Compute bounds on structured singular value (µ)

bounds = mussv(M,BlockStructure) [bounds,muinfo] = mussv(M,BlockStructure) [bounds,muinfo] = mussv(M,BlockStructure,Options) [ubound,q] = mussv(M,F,BlockStructure) [ubound,q] = mussv(M,F,BlockStructure,'s')

`bounds = mussv(M,BlockStructure)`

calculates upper and lower bounds on the structured singular value,
or µ, for a given block structure. `M`

is a `double`

,
or `frd`

object. If `M`

is an N-D
array (with `N`

≥ 3), then the computation
is performed pointwise along the third and higher array dimensions.
If `M`

is a `frd`

object, the computations
are performed pointwise in frequency (as well as any array dimensions).

`BlockStructure`

is a matrix specifying the
perturbation block structure. `BlockStructure`

has
2 columns, and as many rows as uncertainty blocks in the perturbation
structure. The *i*-th row of `BlockStructure`

defines
the dimensions of the i'th perturbation block.

If

`BlockStructure(i,:) = [-r 0]`

, then the*i*-th block is an`r`

-by-`r`

repeated, diagonal real scalar perturbation;if

`BlockStructure(i,:) = [r 0]`

, then the*i*-th block is an`r`

-by-`r`

repeated, diagonal complex scalar perturbation;if

`BlockStructure(i,:) = [r c]`

, then the*i*-th block is an`r`

-by-`c`

complex full-block perturbation.If

`BlockStructure`

is omitted, its default is`ones(size(M,1),2)`

, which implies a perturbation structure of all 1-by-1 complex blocks. In this case, if`size(M,1)`

does not equal`size(M,2)`

, an error results.

If `M`

is a two-dimensional matrix, then `bounds`

is
a `1-by-2`

array containing an upper (first column)
and lower (second column) bound of the structured singular value of `M`

.
For all matrices `Delta`

with block-diagonal structure
defined by `BlockStructure`

and with norm less than `1/bounds(1)`

(upper
bound), the matrix `I - M*Delta`

is not singular.
Moreover, there is a matrix `DeltaS`

with block-diagonal
structure defined by `BlockStructure`

and with norm
equal to `1/bounds(2)`

(lower bound), for which the
matrix `I - M*DeltaS`

is singular.

The format used in the 3rd output argument from `lftdata`

is
also acceptable for describing the block structure.

If `M`

is an `frd`

, the computations
are always performed pointwise in frequency. The output argument `bounds`

is
a `1-by-2 frd`

of upper and lower bounds at each
frequency. Note that `bounds.Frequency`

equals `M.Frequency`

.

If `M`

is an N-D array (either `double`

or `frd`

),
the upper and lower bounds are computed pointwise along the 3rd and
higher array dimensions (as well as pointwise in frequency, for `frd`

).
For example, suppose that `size(M)`

is *r*×*c*×*d*_{1}×...×*d _{F}*.
Then

`size(bounds)`

is 1×2×`bounds(1,1,i)`

is the
upper bound for the structured singular value of `M(:,:,i)`

,
and `bounds(1,2,i)`

is the lower bound for the structured
singular value of `M(:,:,i)`

. Here, any `i`

between
1 and `bounds = mussv(M,BlockStructure,Options)`

specifies computation options. `Options`

is a character
string, containing any combination of the following characters:

Option | Meaning |
---|---|

`'a'` | Upper bound to greatest accuracy, using LMI solver |

`'an'` | Same as |

`'d'` | Display warnings |

`'f'` | Fast upper bound (typically not as tight as the default) |

`'g` | Use gain-based lower bound method multiple times. The
value of `'g6'` uses gain-based lower bound 70
times. Larger numbers typically give better lower bounds. If
all uncertainty blocks described by |

`'p'` | Use power iteration method to compute lower bound. When
at least one of the uncertainty blocks described by |

`'i'` | Reinitialize lower bound computation at each new matrix
(only relevant if |

`'m` | Randomly reinitialize lower bound iteration multiple
times. `'m7'` randomly reinitializes the lower
bound iteration 7 times. Larger numbers typically give better lower
bounds. |

`'o'` | Run "old" algorithms, from version 3.1.1 and before. Included to allow exact replication of earlier calculations. |

`'s'` | Suppress progress information (silent). |

`'U'` | Upper-bound "only" (lower bound uses a fast/cheap algorithm). |

`'x'` | Decrease iterations in lower bound computation (faster
but not as tight as default). Use |

`[bounds,muinfo] = mussv(M,BlockStructure)`

returns `muinfo`

,
a structure containing more detailed information. The information
within `muinfo`

must be extracted using `mussvextract`

.
See `mussvextract`

for
more details.

`ubound = mussv(M,F,BlockStructure)`

calculates an upper bound on the generalized structured singular value
(generalized µ) for a given block structure. `M`

is
a `double`

or `frd`

object. `M`

and `BlockStructure`

are
as before. `F`

is an additional (`double`

or `frd`

).

`ubound = mussv(M,F,BlockStructure,'s')`

adds an option to run silently. Other options are ignored for generalized
µ problems.

Note that in generalized structured singular value computations,
only an upper bound is calculated. `ubound`

is an
upper bound of the generalized structured singular value of the pair `(M,F)`

,
with respect to the block-diagonal uncertainty described by `BlockStructure`

.
Consequently `ubound`

is 1-by-1 (with additional
array dependence, depending on `M`

and `F`

).
For all matrices `Delta`

with block-diagonal structure
defined by `BlockStructure`

and `norm<1/ubound`

,
the matrix `[I-Delta*M;F]`

is guaranteed not to lose
column rank. This is verified by the matrix `Q`

,
which satisfies `mussv(M+Q*F,BlockStructure,'a')<=ubound`

.

See `mussvextract`

for
a detailed example of the structured singular value.

A simple example for generalized structured singular value can be done with random complex matrices, illustrating the relationship between the upper bound for µ and generalized µ, as well as the fact that the upper bound for generalized µ comes from an optimized µ upper bound.

`M`

is a complex 5-by-5 matrix and `F`

is
a complex 2-by-5 matrix. The block structure `BlockStructure`

is
an uncertain real parameter δ_{1}, an uncertain
real parameter δ_{2}, an uncertain complex
parameter δ_{3} and a twice-repeated uncertain
complex parameter δ_{4}.

rng(929,'twister') M = randn(5,5) + sqrt(-1)*randn(5,5); F = randn(2,5) + sqrt(-1)*randn(2,5); BlockStructure = [-1 0;-1 0;1 1;2 0]; [ubound,Q] = mussv(M,F,BlockStructure); bounds = mussv(M,BlockStructure); optbounds = mussv(M+Q*F,BlockStructure);

The quantities `optbounds(1)`

and `ubound`

should
be extremely close, and significantly lower than `bounds(1)`

and `bounds(2)`

.

[optbounds(1) ubound]

ans = 2.2070 2.1749

[bounds(1) bounds(2)]

ans = 4.4049 4.1960

[1] Boyd, S. and L. El Ghaoui, "Methods of centers
for minimizing generalized eigenvalues," *Linear
Algebra and Its Applications*, Vol. 188–189, 1993,
pp. 63–111.

[2] Fan, M., A. Tits, and J. Doyle, "Robustness in
the presence of mixed parametric uncertainty and unmodeled dynamics," *IEEE
Transactions on Automatic Control*, Vol. AC–36,
1991, pp. 25–38.

[3] Osborne, E., "On preconditioning of matrices," *Journal
of Associated Computer Machines*, Vol. 7, 1960, pp. 338–345.

[4] Packard, A.K., M. Fan and J. Doyle, "A power method
for the structured singular value," *Proc. of 1988
IEEE Conference on Control and Decision*, December 1988,
pp. 2132–2137.

[5] Safonov, M., "Stability margins for diagonally
perturbed multivariable feedback systems," *IEEE
Proc.*, Vol. 129, Part D, 1992, pp. 251–256.

[6] Young, P. and J. Doyle, "Computation of with real
and complex uncertainties," *Proceedings of the 29th
IEEE Conference on Decision and Control*, 1990, pp. 1230–1235.

[7] Young, P., M. Newlin, and J. Doyle, "Practical
computation of the mixed problem," *Proceedings of
the American Control Conference*, 1992, pp. 2190–2194.

`mussvextract`

| `robustperf`

| `robuststab`

| `wcgain`

| `wcmargin`

| `wcsens`

Was this topic helpful?