## Documentation Center |

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

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

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

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

where *α* = 2|*β*| + 1.

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

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

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:

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

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.

The decomposition is carried out by the command `lftdata`.

You can create a 2-by-2 `umat` named `A` 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] UMAT: 2 Rows, 2 Columns delta: real, nominal = 2, variability = [-1 1], 2 occurrences eta: real, nominal = 6, variability = [-1 1], 3 occurrences rho: real, nominal = -1, variability = [-1 1], 1 occurrence

Note that `A` depends on two occurrences of `delta`,
three occurrences of `eta` and one occurrence of `rho`.

Decompose `A` into `M` and `Delta`.
Note that `A` is a `double`, and `Delta` has
the same uncertainty dependence as `M`.

[M,Delta] = lftdata(A); class(M) ans = double Delta UMAT: 6 Rows, 6 Columns delta: real, nominal = 2, variability = [-1 1], 2 occurrences eta: real, nominal = 6, variability = [-1 1], 3 occurrences rho: real, nominal = -1, variability = [-1 1], 1 occurrence

Sample `Delta` at 5 points. Things to note
are:

It is diagonal.

The values range between -1 and 1.

There are three independent values, and duplication of the entries is consistent with the dependence of

`Delta`and`A`on the three uncertain real parameters.usample(Delta,5) ans(:,:,1) = -0.7106 0 0 0 0 0 0 -0.7106 0 0 0 0 0 0 0.6374 0 0 0 0 0 0 0.6374 0 0 0 0 0 0 0.6374 0 0 0 0 0 0 -0.1258 ans(:,:,2) = -0.5850 0 0 0 0 0 0 -0.5850 0 0 0 0 0 0 -0.3021 0 0 0 0 0 0 -0.3021 0 0 0 0 0 0 -0.3021 0 0 0 0 0 0 0.0803 ans(:,:,3) = 0.7013 0 0 0 0 0 0 0.7013 0 0 0 0 0 0 -0.6749 0 0 0 0 0 0 -0.6749 0 0 0 0 0 0 -0.6749 0 0 0 0 0 0 0.3967 ans(:,:,4) = 0.4262 0 0 0 0 0 0 0.4262 0 0 0 0 0 0 0.0795 0 0 0 0 0 0 0.0795 0 0 0 0 0 0 0.0795 0 0 0 0 0 0 -0.9959 ans(:,:,5) = -0.8392 0 0 0 0 0 0 -0.8392 0 0 0 0 0 0 0.8467 0 0 0 0 0 0 0.8467 0 0 0 0 0 0 0.8467 0 0 0 0 0 0 0.6732

In fact, verify that the maximum gain of `Delta` is
indeed 1

maxnorm = wcnorm(Delta) maxnorm = LowerBound: 1.0000 UpperBound: 1.0004

Finally, verify that `lft(Delta,M)` is the
same as `A` Subtract (and use the `'full'` option
in `simplify`)

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 the string `'Normalized'` appended
to its original name to avoid confusion. By normalized,

`ureal`objects have nominal value of 0, and range from -1 to 1.`ultidyn`objects are norm bounded, 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 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?