Decomposing Uncertain Objects

Each uncertain model or matrix (such as uss, genss, ufrd, or umat, ) is a generalized feedback connection (lft) of a not-uncertain object (e.g., double, ss, frd) with a diagonal augmentation of uncertain elements (ureal, ultidyn, umargin, ucomplex, ucomplexm, udyn). In robust control jargon, if the uncertain elements are normalized, this decomposition is often called “the M/D form.”

The purpose of the uncertain objects (ureal, ultidyn, umat, uss, etc.) is to hide this underlying decomposition, and allow the user to focus on modeling and analyzing uncertain systems, rather than the details of correctly propagating the M/D representation in manipulations. Nevertheless, advanced users may want access to the familiar M/D form. The command lftdata accomplishes this decomposition.

Since ureal, umargin, ucomplex and ucomplexm do not have their NominalValue necessarily at zero, and in the case of ureal and umargin objects, are not necessarily symmetric about the NominalValue, some details are required in describing the decomposition.

Normalizing Functions for Uncertain Elements

Associated with each uncertain element is a normalizing function. The normalizing function maps the uncertain element into a normalized uncertain element. Regardless of element type, as the uncertain element varies over its range, the absolute value of the normalizing function (or norm, in the matrix case) varies from 0 and 1.

Uncertain Real Parameter (ureal)

If ρ is an uncertain real parameter, with range [L R] and nominal value N, then the normalizing function F is

$$F\left(\rho \right)=\frac{A+B\rho }{C+D\rho }$$

with the property that for all ρ satisfying L ≤ ρ ≤ R, it follows that –1 ≤ F(ρ) ≤ 1, moreover, F(L) = –1, F(N) = 0, and F(R) = 1. If the nominal value is centered in the range, then it is easy to conclude that

$$\begin{array}{l}A=\frac{R+L}{R-L}\\ B=\frac{2}{R-L}\\ C=1\\ D=0.\end{array}$$

It is left as an algebra exercise for the user to work out the various values for A, B, C and D when the nominal value is not centered.

Uncertain Linear Time-Invariant Dynamic Uncertainty (ultidyn)

If E is an uncertain gain-bounded, linear, time-invariant dynamic uncertainty, with gain-bound β, then the normalizing function F is

$$F\left(E\right)=\frac{1}{\beta }E.$$

If E is an uncertain positive-real, linear, time-invariant dynamic uncertainty, with positivity bound β, then the normalizing function F is

$$F\left(E\right)=\left[I-\alpha \left(E-\frac{\beta }{2}I\right)\right]{\left[I+\alpha \left(E-\frac{\beta }{2}I\right)\right]}^{-1}$$

where α = 2|β| + 1.

Uncertain Gain and Phase (umargin)

For a umargin block Q(s), the normalized value F(Q(s)) = δ(s), where δ(s) is a gain-bounded dynamic uncertainty, normalized so that it always varies within the unit disk (||δ||_∞ < 1). In other words, F(Q) is a unit-gain ultidyn uncertain element.

The actual values of Q map to the unit-gain δ via the parameterization

$$Q\left(s\right)=\frac{1+\alpha \left[\left(1-E\right)/2\right]\delta \left(s\right)}{1-\alpha \left[\left(1+E\right)/2\right]\delta \left(s\right)}.$$

For details about this parameterization, see umargin.

Uncertain Complex Parameters (ucomplex)

The normalizing function for an uncertain complex parameter ξ, with nominal value C and radius γ, is

$$F\left(\xi \right)=\frac{1}{\gamma }\left(\xi -C\right).$$

Uncertain Complex Matrices (umat)

The normalizing function for uncertain complex matrices H, with nominal value N and weights W_L and W_R is

$$F\left(H\right)=W_L^{-1}\left(H-N\right)W_R^{-1}$$

Properties of the Decomposition

Take an uncertain object A, dependent on:

• Uncertain real parameters ρ₁,...,ρ_Nρ

• Uncertain complex parameters ξ₁,...,ξ_Nξ

• Uncertain complex matrices H₁,...,H_NH

• Uncertain gain-bounded linear, time-invariant dynamics E₁,...,E_NE

• Uncertain positive-real linear, time-invariant dynamics P₁,...,P_NP

• Uncertain gain and phase Q₁,…,Q_NQ

Write A(ρ,ξ,H,E,P,Q) to indicate this dependence. Using lftdata, A can be decomposed into two separate pieces: M and Δ(ρ,ξ,H,E,P,Q) with the following properties:

• M is certain (i.e., if A is uss, then M is ss; if A is umat, then M is double; if A is ufrd, then M is frd).

• Δ is always a umat, depending on the same uncertain elements as A, with ranges, bounds, weights, etc., unaltered.

• The form of Δ is block diagonal, with elements made up of the normalizing functions acting on the individual uncertain elements:

  $$\Delta \left(\rho ,\xi ,H,E,P,Q\right)=\left[\begin{array}{cccccc}F\left(\rho \right)& 0& 0& 0& 0& 0\\ 0& F\left(\xi \right)& 0& 0& 0& 0\\ 0& 0& F\left(H\right)& 0& 0& 0\\ 0& 0& 0& F\left(E\right)& 0& 0\\ 0& 0& 0& 0& F\left(P\right)& \\ 0& 0& 0& 0& 0& F\left(Q\right)\end{array}\right].$$

• A(ρ,ξ,H,E,P,Q) is given by a linear fractional transformation of M and Δ(ρ,ξ,H,E,P,Q),

  $$A\left(\rho ,\xi ,H,E,P,Q\right)=M_{22}+M_{21}\Delta \left(\rho ,\xi ,H,E,P,Q\right){\left[I-M_{11}\Delta \left(\rho ,\xi ,H,E,P,Q\right)\right]}^{-1}{M}_{12}.$$

The order of the normalized elements making up A is not the simple order shown above. It is actually the same order as given by the command fieldnames(M.Uncertainty), as shown in the following example.

Decompose Uncertain Model Using lftdata

You decompose an uncertain model into a fixed certain part and normalized uncertain part using the lftdata command. To see how this command works, create a 2-by-2 uncertain matrix (umat) using three uncertain real parameters.

delta = ureal('delta',2); 
eta = ureal('eta',6); 
rho = ureal('rho',-1); 
A = [3+delta+eta delta/eta;7+rho rho+delta*eta]

Uncertain matrix with 2 rows and 2 columns.
The uncertainty consists of the following blocks:
  delta: Uncertain real, nominal = 2, variability = [-1,1], 2 occurrences
  eta: Uncertain real, nominal = 6, variability = [-1,1], 3 occurrences
  rho: Uncertain real, nominal = -1, variability = [-1,1], 1 occurrences

Type "A.NominalValue" to see the nominal value and "A.Uncertainty" to interact with the uncertain elements.

The umat A depends on two occurrences of delta, three occurrences of eta, and one occurrence of rho.

Decompose A into M and Delta.

[M,Delta] = lftdata(A);

M is a numeric matrix.

M

M = 8×8

         0         0         0   -0.1667         0         0    1.0000    0.1667
         0         0         0         0    1.0000         0         0    6.0000
         0         0         0         0         0         0    1.0000         0
         0         0         0   -0.1667         0         0         0    0.1667
         0         0         0         0         0         0         0    1.0000
         0         0         0         0         0         0    1.0000    1.0000
    1.0000         0    1.0000   -0.3333         0         0   11.0000    0.3333
         0    1.0000         0         0    2.0000    1.0000    6.0000   11.0000

Delta is a umat with the same uncertainty dependence as A.

Delta

Uncertain matrix with 6 rows and 6 columns.
The uncertainty consists of the following blocks:
  delta: Uncertain real, nominal = 2, variability = [-1,1], 2 occurrences
  eta: Uncertain real, nominal = 6, variability = [-1,1], 3 occurrences
  rho: Uncertain real, nominal = -1, variability = [-1,1], 1 occurrences

Type "Delta.NominalValue" to see the nominal value and "Delta.Uncertainty" to interact with the uncertain elements.

To examine some of the characteristics of Delta, sample it at three points. Note that:

• The sampled value of Delta is always diagonal.

• The sampled values always range between -1 and 1, because Delta is normalized.

• The sampled matrices each contain three independent values. Duplication of the entries is consistent with the dependence of Delta and A on the three uncertain real parameters.

usample(Delta,3)

ans = 
ans(:,:,1) =

    0.6294         0         0         0         0         0
         0    0.6294         0         0         0         0
         0         0    0.8268         0         0         0
         0         0         0    0.8268         0         0
         0         0         0         0    0.8268         0
         0         0         0         0         0   -0.4430


ans(:,:,2) =

    0.8116         0         0         0         0         0
         0    0.8116         0         0         0         0
         0         0    0.2647         0         0         0
         0         0         0    0.2647         0         0
         0         0         0         0    0.2647         0
         0         0         0         0         0    0.0938


ans(:,:,3) =

   -0.7460         0         0         0         0         0
         0   -0.7460         0         0         0         0
         0         0   -0.8049         0         0         0
         0         0         0   -0.8049         0         0
         0         0         0         0   -0.8049         0
         0         0         0         0         0    0.9150

Verify that the maximum gain of Delta is 1.

maxnorm = wcnorm(Delta)

maxnorm = struct with fields:
    LowerBound: 0
    UpperBound: 1.0008

Finally, verify that lft(Delta,M) is the same as A. To do so, take the difference, and use the 'full' option in simplify to remove redundant dependencies on uncertain elements.

simplify(lft(Delta,M)-A,'full')

ans = 2×2

     0     0
     0     0

Advanced Syntax of lftdata

Even for the advanced user, the variable Delta will actually not be that useful, as it is still a complex object. On the other hand, its internal structure is described completely using a 3rd (and 4th) output argument.

[M,Delta,BlkStruct,NormUnc] = lftdata(A); 

The rows of BlkStruct correspond to the uncertain elements named in fieldnames(A.Uncertainty). The elements of BlkStruct describe the size, type and number-of-copies of the uncertain elements in A, and implicitly delineate the exact block-diagonal structure of Delta. Note that the range/bound information about each uncertain element is not included in BlkStruct.

BlkStruct(1)

ans = struct with fields:
           Name: 'delta'
           Size: [1 1]
           Type: 'ureal'
    Occurrences: 2
       Simplify: 2

BlkStruct(2) 

ans = struct with fields:
           Name: 'eta'
           Size: [1 1]
           Type: 'ureal'
    Occurrences: 3
       Simplify: 2

BlkStruct(3) 

ans = struct with fields:
           Name: 'rho'
           Size: [1 1]
           Type: 'ureal'
    Occurrences: 1
       Simplify: 2

Together, these entries mean that Delta is a block diagonal augmentation of the normalized version of the three uncertain elements.

The first element is named 'delta'. It is 1-by-1; it is of class ureal; and there are two copies diagonally augmented.

The second element is named 'eta'. It is 1-by-1; it is of class ureal; and there are three copies diagonally augmented.

The third element is named 'rho'. It is 1-by-1; it is of class ureal; and there is one copy,

The fourth output argument of lftdata contains a cell array of normalized uncertain elements. The cell array contains as many occurrences of each element as there are occurrences in the original uncertain object A.

size(NormUnc) 

ans = 1×2

     6     1

NormUnc{1} 

Uncertain real parameter "deltaNormalized" with nominal value 0 and variability [-1,1].

isequal(NormUnc{2},NormUnc{1}) 

ans = logical
   1

NormUnc{3} 

Uncertain real parameter "etaNormalized" with nominal value 0 and variability [-1,1].

isequal(NormUnc{4},NormUnc{3}) 

ans = logical
   1

isequal(NormUnc{5},NormUnc{3}) 

ans = logical
   1

NormUnc{6} 

Uncertain real parameter "rhoNormalized" with nominal value 0 and variability [-1,1].

Each normalized element has 'Normalized' appended to its original name to avoid confusion. When normalized,

• ureal objects have nominal value of 0, and range from –1 to 1.

• ultidyn objects are norm bounded, with norm bound of 1.

• umargin objects are converted to norm-bounded ultidyn objects with norm bound of 1.

• ucomplex objects have nominal value of 0, and radius 1.

• ucomplexm objects have nominal value of 0, and identity matrices for each of the WL and WR weights.

The possible behaviors of Delta and blkdiag(NormUnc{:}) are the same. Consequently, the possible behaviors of A and lft(blkdiag(NormUnc{:}),M) are the same.

Hence, by manipulating M, BlkStruct and NormUnc, a you can have direct access to all of the linear fractional transformation details, and can work at the level of the theorems and algorithms that underlie the methods.