Main Content

simplify

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 occurrences are eliminated, and the class of B may be lower than the class of A.

Examples

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.

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

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

Algorithms

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

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.

Version History

Introduced before R2006a

See Also

| | | |