Each uncertain object (`umat`

, `uss`

, `ufrd`

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

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

, `ucomplex`

and `ucomplexm`

do not have their
`NominalValue`

necessarily at zero, and in the case of `ureal`

objects, are not 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.

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.

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.

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

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}$$

In each case, 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.

Take an uncertain object *A*, dependent on uncertain real parameters
*ρ*_{1},...,*ρ _{N}*,
uncertain complex parameters

Write
*A*(*ρ*,*ξ*,*H*,*E*,*P*)
to indicate this dependence. Using `lftdata`

, *A* can be decomposed into two separate pieces:
*M* and
Δ(*ρ*,*ξ*,*H*,*E*,*P*)
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\right)=\left[\begin{array}{ccccc}F\left(\rho \right)& 0& 0& 0& 0\\ 0& F\left(\xi \right)& 0& 0& 0\\ 0& 0& F\left(H\right)& 0& 0\\ 0& 0& 0& F\left(E\right)& 0\\ 0& 0& 0& 0& F\left(P\right)\end{array}\right].$$

*A*(*ρ*,*ξ*,*H*,*E*,*P*) is given by a linear fractional transformation of*M*and Δ(*ρ*,*ξ*,*H*,*E*,*P*),$$A\left(\rho ,\xi \right)={M}_{22}+{M}_{21}\Delta \left(\rho ,\xi ,H,E,P\right){\left[I-{M}_{11}\Delta \left(\rho ,\xi ,H,E,P\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)`

. See Advanced Syntax of lftdata for more information.

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^{-18}× 0 0.3955 0 0

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

. Note that the range/bound information about
each uncertain element is not included in `BlkStruct`

.

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 = Name: 'delta' Size: [1 1] Type: 'ureal' Occurrences: 2 BlkStruct(2) ans = Name: 'eta' Size: [1 1] Type: 'ureal' Occurrences: 3 BlkStruct(3) ans = Name: 'rho' Size: [1 1] Type: 'ureal' Occurrences: 1

Together, these mean `Delta`

is a block diagonal augmentation of the
normalized version of 3 uncertain elements.

The first element is named `'delta'`

. It is 1-by-1; it is of class
`ureal`

; and there are 2 copies diagonally
augmented.

The second element is named `'eta'`

. It is 1-by-1; it is of class
`ureal`

; and there are 3 copies diagonally
augmented.

The third element is named `'rho'`

. It is 1-by-1; it is of class
`ureal`

; and there is 1 copy,

The 4th output argument 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 = 6 1 NormUnc{1} Uncertain Real Parameter: Name deltaNormalized, NominalValue 0, variability = [-1 1] isequal(NormUnc{2},NormUnc{1}) ans = 1 NormUnc{3} Uncertain Real Parameter: Name etaNormalized, NominalValue 0, variability = [-1 1] isequal(NormUnc{4},NormUnc{3}) ans = 1 isequal(NormUnc{5},NormUnc{3}) ans = 1 NormUnc{6} Uncertain Real Parameter: Name rhoNormalized, NominalValue 0, variability = [-1 1]

Each normalized element has `'Normalized'`

appended to its original
name to avoid confusion. When normalized,

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
power-user has direct access to all of the linear fractional transformation details, and can
easily work at the level of the theorems and algorithms that underlie the methods.