Main Content

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`

array,
an `frd`

model, or a state-space (`ss`

)
model.

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`

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

`M`

is a`ss`

model, the computations are performed using state-space algorithms. Frequencies are adaptively selected, and upper bounds are guaranteed to hold over each interval between frequencies.`M`

must be a single system, without 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 If `M`

is a `ss`

model, `bounds`

is
returned as an `frd`

model.

`bounds = mussv(M,BlockStructure,Options)`

specifies computation options. `Options`

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

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

`'a'` | Upper bound to greatest accuracy, using LMI solver. This is the default behavior when the number of decision variables within the D/G scalings is less than 45. |

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

`'G'` | Force upper bound to use gradient method. This is the default behavior when the number of decision variables within the D/G scalings is greater than or equal to 45. |

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

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

`'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 are typically more computationally
expensive, but often give better lower bounds. |

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

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

`'d'` | Display warnings. |

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

`'an'` | Same as |

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

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

returns `muinfo`

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

must be extracted using `mussvextract`

.

`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

The lower bound is computed using a power method, Young and
Doyle, 1990, and Packard *et al.* 1988, and the
upper bound is computed using the balanced/AMI technique, Young *et
al.*, 1992, for computing the upper bound from Fan *et
al.*, 1991.

Peter Young and Matt Newlin wrote the original function.

The lower-bound power algorithm is from Young and Doyle, 1990,
and Packard *et al.* 1988.

The upper-bound is an implementation of the bound from Fan *et
al.*, 1991, and is described in detail in Young *et
al.*, 1992. In the upper bound computation, the matrix is
first balanced using either a variation of Osborne's method (Osborne,
1960) generalized to handle *repeated scalar* and *full* blocks,
or a Perron approach. This generates the standard upper bound for
the associated complex µ problem. The Perron eigenvector method
is based on an idea of Safonov, (Safonov, 1982). It gives the exact
computation of µ for positive matrices with scalar blocks, but
is comparable to Osborne on general matrices. Both the Perron and
Osborne methods have been modified to handle *repeated scalar* and *full* blocks.
Perron is faster for small matrices but has a growth rate of *n*^{3},
compared with less than *n*^{2} for
Osborne. This is partly due to the `MATLAB`

implementation,
which greatly favors Perron. The default is to use Perron for simple
block structures and Osborne for more complicated block structures.
A sequence of improvements to the upper bound is then made based on
various equivalent forms of the upper bound. A number of descent techniques
are used that exploit the structure of the problem, concluding with
general purpose LMI optimization (Boyd *et al.*),
1993, to obtain the final answer.

The optimal choice of `Q`

(to minimize the
upper bound) in the generalized µ problem is solved by reformulating
the optimization into a semidefinite program (Packard *et
al.*, 1991).

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

| `robgain`

| `robstab`

| `wcdiskmargin`

| `wcgain`