Robust Control Toolbox™

Simplify representation of uncertain object

Syntax

• B = simplify(A) 
  B = simplify(A,'full') 
  B = simplify(A,'basic') 
  B = simplify(A,'class') 
  

Description

B = simplify(A) performs model-reduction-like techniques to detect and eliminate redundant copies of uncertain elements. Depending on the result, the class of B may be lower than A. The AutoSimplify property of each uncertain element in A governs what reduction methods are used. After reduction, any uncertain element which does not actually affect the result is deleted from the representation.

B = simplify(A,'full') overrides all uncertain element's AutoSimplify property, and uses 'full' reduction techniques.

B = simplify(A,'basic') overrides all uncertain element's AutoSimplify property, and uses 'basic' reduction techniques.

B = simplify(A,'class') does not perform reduction. However, any uncertain elements in A with zero occurences are eliminated, and the class of B may be lower than the class of A.

Example

Create a simple umat with a single uncertain real parameter. Select specific elements, note that result remains in class umat. Simplify those same elements, and note that class changes.

• p1 = ureal('p1',3,'Range',[2 5]); 
  L = [2 p1]; 
  L(1) 
  UMAT: 1 Rows, 1 Columns 
  L(2) 
  UMAT: 1 Rows, 1 Columns 
    p1: real, nominal = 3, range = [2  5], 1 occurrence 
  simplify(L(1)) 
  ans = 
       2 
  simplify(L(2)) 
  Uncertain Real Parameter: Name p1, NominalValue 3, Range [2  5] 
  

Create four uncertain real parameters, with a default value of AutoSimplify ('basic'), and define a high order polynomial [1].

• m = ureal('m',125000,'Range',[100000 150000]); 
  xcg = ureal('xcg',.23,'Range',[.15 .31]); 
  zcg = ureal('zcg',.105,'Range',[0 .21]); 
  va = ureal('va',80,'Range',[70 90]); 
  cw = simplify(m/(va*va)*va,'full') 
  UMAT: 1 Rows, 1 Columns 
     m: real, nominal = 1.25e+005, range = [100000  150000], 1 
  occurrence 
    va: real, nominal = 80, range = [70  90], 1 occurrence               
  cw = m/va; 
  fac2 = .16726*xcg*cw*cw*zcg - .17230*xcg*xcg*cw ... 
        -3.9*xcg*cw*zcg - .28*xcg*xcg*cw*cw*zcg ... 
        -.07*xcg*xcg*zcg + .29*xcg*xcg*cw*zcg ... 
        + 4.9*xcg*cw - 2.7*xcg*cw*cw ... 
        +.58*cw*cw - 0.25*xcg*xcg - 1.34*cw ... 
        +100.1*xcg -14.1*zcg - 1.91*cw*cw*zcg ... 
        +1.12*xcg*zcg + 24.6*cw*zcg ... 
        +.45*xcg*xcg*cw*cw - 46.85 
  UMAT: 1 Rows, 1 Columns 
      m: real, nominal = 1.25e+005, range = [100000  150000], 18 
  occurrences 
     va: real, nominal = 80, range = [70  90], 8 occurrences                
    xcg: real, nominal = 0.23, range = [0.15  0.31], 18 occurrences         
    zcg: real, nominal = 0.105, range = [0  0.21], 1 occurrence 
  

The result of the high-order polynomial is an inefficient representation involving 18 copies of m, 8 copies of va, 18 copies of xcg and 1 copy of zcg. Simplify the expression, using the 'full' simplification algorithm

• fac2s = simplify(fac2,'full') 
  UMAT: 1 Rows, 1 Columns 
      m: real, nominal = 1.25e+005, range = [100000  150000], 4 
  occurrences 
     va: real, nominal = 80, range = [70  90], 4 occurrences               
    xcg: real, nominal = 0.23, range = [0.15  0.31], 2 occurrences         
    zcg: real, nominal = 0.105, range = [0  0.21], 1 occurrence 
  

which results in a much more economical representation.

Alternatively, change the AutoSimplify property of each parameter to 'full' before forming the polynomial.

• m.AutoSimplify = 'full'; 
  xcg.AutoSimplify = 'full'; 
  zcg.AutoSimplify = 'full'; 
  va.AutoSimplify = 'full'; 
  

You can form the polynomial, which immediately gives a low order representation.

• cw = m/va; 
  fac2f = .16726*xcg*cw*cw*zcg - .17230*xcg*xcg*cw ... 
        -3.9*xcg*cw*zcg - .28*xcg*xcg*cw*cw*zcg ... 
        -.07*xcg*xcg*zcg + .29*xcg*xcg*cw*zcg ... 
        + 4.9*xcg*cw - 2.7*xcg*cw*cw ... 
        +.58*cw*cw - 0.25*xcg*xcg - 1.34*cw ... 
        +100.1*xcg -14.1*zcg - 1.91*cw*cw*zcg ... 
        +1.12*xcg*zcg + 24.6*cw*zcg ... 
        +.45*xcg*xcg*cw*cw - 46.85 
  UMAT: 1 Rows, 1 Columns 
      m: real, nominal = 1.25e+005, range = [100000  150000], 4 
  occurrences 
     va: real, nominal = 80, range = [70  90], 4 occurrences               
    xcg: real, nominal = 0.23, range = [0.15  0.31], 2 occurrences         
    zcg: real, nominal = 0.105, range = [0  0.21], 1 occurrence 
  

Create two real parameters, da and dx, and a 2-by-3 matrix, ABmat, involving polynomial expressions in the two real parameters [2].

• da = ureal('da',0,'Range',[-1 1]); 
  dx = ureal('dx',0,'Range',[-1 1]); 
  a11 = -.32 + da*(.8089 + da*(-.987 + 3.39*da)) + .15*dx; 
  a12 = .934 + da*(.0474 - .302*da); 
  a21 = -1.15 + da*(4.39 + da*(21.97 - 561*da*da)) ... 
       + dx*(9.65 - da*(55.7 + da*177)); 
  a22 = -.66 + da*(1.2 - da*2.27) + dx*(2.66 - 5.1*da); 
  b1 = -0.00071 + da*(0.00175 - da*.00308) + .0011*dx; 
  b2 = -0.031 + da*(.078 + da*(-.464 + 1.37*da)) + .0072*dx; 
  ABmat = [a11 a12 b1;a21 a22 b2] 
  UMAT: 2 Rows, 3 Columns 
    da: real, nominal = 0, range = [-1  1], 19 occurrences 
    dx: real, nominal = 0, range = [-1  1], 2 occurrences 
  

Use 'full' simplification to reduce the complexity of the description.

• ABmatsimp = simplify(ABmat,'full') 
  UMAT: 2 Rows, 3 Columns 
    da: real, nominal = 0, range = [-1  1], 7 occurrences 
    dx: real, nominal = 0, range = [-1  1], 2 occurrences 
  

Alternatively, you can set the parameter's AutoSimplify property to 'full'.

• da.AutoSimplify = 'full'; 
  dx.AutoSimplify = 'full'; 
  

Now you can rebuild the matrix

• a11 = -.32 + da*(.8089 + da*(-.987 + 3.39*da)) + .15*dx; 
  a12 = .934 + da*(.0474 - .302*da); 
  a21 = -1.15 + da*(4.39 + da*(21.97 - 561*da*da)) ... 
       + dx*(9.65 - da*(55.7 + da*177)); 
  a22 = -.66 + da*(1.2 - da*2.27) + dx*(2.66 - 5.1*da); 
  b1 = -0.00071 + da*(0.00175 - da*.00308) + .0011*dx; 
  b2 = -0.031 + da*(.078 + da*(-.464 + 1.37*da)) + .0072*dx; 
  ABmatFull = [a11 a12 b1;a21 a22 b2] 
  UMAT: 2 Rows, 3 Columns 
    da: real, nominal = 0, range = [-1  1], 7 occurrences 
    dx: real, nominal = 0, range = [-1  1], 2 occurrences 
  

Algorithm

simplify uses heuristics along with one-dimensional model reduction algorithms to partially reduce the dimensionality of the representation of an uncertain matrix or system.

Limitations

Multidimensional model reduction and realization theory are only partially complete theories. The heuristics used by simplify are that - heuristics. The order in which expressions involving uncertain elements are built up, eg., distributing across addition and multiplication, can affect the details of the representation (i.e., the number of occurences of a ureal in an uncertain matrix). It is possible that simplify's naive methods cannot completely resolve these differences, so one may be forced to work with "nonminimal" representations of uncertain systems.

References

[1]   Varga, A. and G. Looye, "Symbolic and numerical software tools for LFT-based low order uncertainty modeling," IEEE International Symposium on Computer Aided Control System Design, 1999, pp. 5-11.

[2]  Belcastro, C.M., K.B. Lim and E.A. Morelli, "Computer aided uncertainty modeling for nonlinear parameter-dependent systems Part II: F-16 example," IEEE International Symposium on Computer Aided Control System Design, 1999, pp. 17-23.

See Also
umat        Creates an uncertain matrix object

uss         Creates an uncertain system object

ucomplex    Creates an uncertain complex parameter

ureal       Creates an uncertain real parameter

uss         Creates an uncertain system

Provide feedback about this page

showlmi

skewdec

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