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.

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-th block is an*i*`r`

-by-`r`

repeated, diagonal real scalar perturbation;if

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

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

-by-`r`

repeated, diagonal complex scalar perturbation;if

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

, then the-th block is an*i*`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*×

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

Was this topic helpful?