## Documentation Center |

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

`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'N | Use gain-based lower bound method multiple times. The
value of 10+.
For example, *10N'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'N | 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?