Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

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 = Columns 1 through 7 0 0 0 -0.1667 0 0 1.0000 0 0 0 0 1.0000 0 0 0 0 0 0 0 0 1.0000 0 0 0 -0.1667 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1.0000 1.0000 0 1.0000 -0.3333 0 0 11.0000 0 1.0000 0 0 2.0000 1.0000 6.0000 Column 8 0.1667 6.0000 0 0.1667 1.0000 1.0000 0.3333 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 alway 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(:,:,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 = 0 0 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.

Was this topic helpful?