mussv (Robust Control Toolbox™)

Robust Control Toolbox™

mussv

Provide feedback about this page

Compute upper and lower bounds on structured singular value (µ) and upper bounds on generalized structured singular value

Syntax

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

Description

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 rxcxd1x...xdF. Then size(bounds) is 1x2xd1x...xdF. Using single index notation, 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 d1·d2...dF (the product of the dk) would be valid.

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 'a', but without automatic prescaling

'd'
Display warnings

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

'g6'
Use gain-based lower bound (note that the default lower bound employs a power iteration) multiple times (in this case 10+6*10 times). Larger numbers typically give better lower bounds. This is an alternative to the default lower bound which uses a power iteration.

'i'
Reinitialize lower bound computation at each new matrix (only relevant if M is ND array or frd)

'm7'
Randomly reinitialize lower bound iteration multiple times (in this case 7 times, use 1-9); larger number typically gives better lower bound

'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 'U' for an even faster lower bound

Option	Meaning
`'a'`	Upper bound to greatest accuracy, using LMI solver
`'an'`	Same as `'a'`, but without automatic prescaling
`'d'`	Display warnings
`'f'`	Fast upper bound (typically not as tight as the default)
`'g6'`	Use gain-based lower bound (note that the default lower bound employs a power iteration) multiple times (in this case `10+6*10` times). Larger numbers typically give better lower bounds. This is an alternative to the default lower bound which uses a power iteration.
`'i'`	Reinitialize lower bound computation at each new matrix (only relevant if `M` is `ND` array or `frd`)
`'m7'`	Randomly reinitialize lower bound iteration multiple times (in this case 7 times, use 1-9); larger number typically gives better lower bound
`'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 'U' for an even faster lower bound

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

Generalized Structured Singular Value

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.

Example

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 delta 1, an uncertain real parameter delta 2, an uncertain complex parameter delta 3 and a twice-repeated uncertain complex parameter delta 4.

randn(`state',929)
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 = 
    1.6280 1.6007 
[bounds(1)  bounds(2)] 
ans = 
    3.4827 3.3011

Algorithm

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 M-files.

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 n3, compared with less than n2 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 mu problem is solved by reformulating the optimization into a semidefinite program (Packard et al., 1991).

References

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.
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.
Osborne, E., "On preconditioning of matrices," Journal of Associated Computer Machines, Vol. 7, 1960, pp. 338-345.
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.
Safonov, M., "Stability margins for diagonally perturbed multivariable feedback systems," IEEE Proc., Vol. 129, Part D, 1992, pp. 251-256.
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.
Young, P., M. Newlin, and J. Doyle, "Practical computation of the mixed problem," Proceedings of the American Control Conference, 1992, pp. 2190-2194.

See Also
loopmargin Comprehensive analysis of feedback loop

mussvextract Extract compressed data returned from mussv

robuststab Calculate stability margins of uncertain systems

robustperf Calculate performance margins of uncertain systems

wcgain Calculate worst-case gain of a system

wcsens Calculate worst-case sensitivities for feedback loop

wcmargin Calculate worst-case margins for feedback loop

Provide feedback about this page

msfsyn mussvextract

© 1984-2008- The MathWorks, Inc. - Site Help - Patents - Trademarks - Privacy Policy - Preventing Piracy - RSS