Main Content

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.

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.

`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.

`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.

`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`

.

`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).$$

`umat`

)The normalizing function for uncertain complex matrices *H*, with
nominal value *N* and weights
*W _{L}* and

$$F\left(H\right)={W}_{L}^{-1}\left(H-N\right){W}_{R}^{-1}$$

Take an uncertain object *A*, dependent on:

Uncertain real parameters

*ρ*_{1},...,*ρ*_{Nρ}Uncertain complex parameters

*ξ*_{1},...,*ξ*_{Nξ}Uncertain complex matrices

*H*_{1},...,*H*_{NH}Uncertain gain-bounded linear, time-invariant dynamics

*E*_{1},...,*E*_{NE}Uncertain positive-real linear, time-invariant dynamics

*P*_{1},...,*P*_{NP}Uncertain gain and phase

*Q*_{1},…,*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.

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]

A = 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, "get(A)" to see all properties, 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

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, "get(Delta)" to see all properties, 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×210^{-17}× 0 -0.5156 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}

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

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

`ans = `*logical*
1

NormUnc{3}

ans = 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}

ans = 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.

`lftdata`

| `uscale`

| `actual2normalized`

| `normalized2actual`