A minimal realization of the transfer function matrix

$$H\left(s\right)=\left[\begin{array}{cc}\frac{2}{s+1}& \frac{4}{s+1}\\ \frac{3}{s+1}& \frac{6}{s+1}\end{array}\right]$$

has only 1 state, obvious from the decomposition

$$H\left(s\right)=\left[\begin{array}{c}2\\ 3\end{array}\right]\frac{1}{s+1}\left[\begin{array}{cc}1& 2\end{array}\right].$$

However, a "natural" construction, formed by

sys11 = ss(tf(2,[1 1])); sys12 = ss(tf(4,[1 1])); sys21 = ss(tf(3,[1 1])); sys22 = ss(tf(6,[1 1])); sys = [sys11 sys12;sys21 sys22] a = x1 x2 x3 x4 x1 -1 0 0 0 x2 0 -1 0 0 x3 0 0 -1 0 x4 0 0 0 -1 b = u1 u2 x1 2 0 x2 0 2 x3 2 0 x4 0 2 c = x1 x2 x3 x4 y1 1 2 0 0 y2 0 0 1.5 3 d = u1 u2 y1 0 0 y2 0 0 Continuous-time model

has four states, and is nonminimal.

In the same manner, the internal representation of uncertain
objects built up from uncertain elements can become nonminimal, depending
on the sequence of operations in their construction. The command `simplify`

employs
ad-hoc simplification and reduction schemes to reduce the complexity
of the representation of uncertain objects. There are three levels
of simplification: off, basic and full. Each uncertain element has
an `AutoSimplify`

property whose value is one of
the strings `'off'`

, `'basic'`

or `'full'`

.
The default value is `'basic'`

.

After (nearly) every operation, the command `simplify`

is
automatically run on the uncertain object, cycling through all of
the uncertain elements, and attempting to simplify (without error)
the representation of the effect of that uncertain object. The `AutoSimplify`

property
of each element dictates the types of computations that are performed.
In the `'off'`

case, no simplification is even attempted.
In `'basic'`

, fairly simple schemes to detect and
eliminate nonminimal representations are used. Finally, in `'full'`

,
numerical based methods similar to truncated balanced realizations
are used, with a very tight tolerance to minimize error.

Create an uncertain real parameter, view the `AutoSimplify`

property
of `a`

, and then create a 1-by-2 `umat`

, both of whose entries involve the
uncertain parameter.

a = ureal('a',4); a.AutoSimplify ans = basic m1 = [a+4 6*a] UMAT: 1 Rows, 2 Columns a: real, nominal = 4, variability = [-1 1], 1 occurrence

Note that although the uncertain real parameter a appears in
both (two) entries of the matrix, the resulting uncertain matrix `m1`

only
depends on "1 occurrence" of `a`

.

Set the `AutoSimplify`

property of `a`

to `'off'`

(from `'basic'`

).
Recreate the 1-by-2 `umat`

. Now
note that the resulting uncertain matrix `m2`

depends
on "2 occurrences" of `a`

.

a.AutoSimplify = 'off'; m2 = [a+4 6*a] UMAT: 1 Rows, 2 Columns a: real, nominal = 4, variability = [-1 1], 2 occurrences

The `'basic'`

level of autosimplification often
detects (and simplifies) duplication created by linear terms in the
various entries. Higher order (quadratic, bilinear, etc.) duplication
is often not detected by the `'basic'`

autosimplify
level.

For example, reset the `AutoSimplify`

property
of a to `'basic'`

(from `'off'`

).
Create an uncertain real parameter, and a 1-by-2 `umat`

, both of whose entries involve the
square of the uncertain parameter.

a.AutoSimplify = 'basic'; m3 = [a*(a+4) 6*a*a] UMAT: 1 Rows, 2 Columns a: real, nominal = 4, variability = [-1 1], 4 occurrences

Note that the resulting uncertain matrix `m3`

depends
on "4 occurrences" of `a`

.

Set the `AutoSimplify`

property of `a`

to `'full'`

(from `'basic'`

).
Recreate the 1-by-2 `umat`

. Now
note that the resulting uncertain matrix m4 depends on "2 occurrences"
of `a`

.

a.AutoSimplify = 'full'; m4 = [a*(a+4) 6*a*a] UMAT: 1 Rows, 2 Columns a: real, nominal = 4, variability = [-1 1], 2 occurrences

Although `m4`

has a less complex representation
(2 occurrences of `a`

rather than 4 as in `m3`

),
some numerical variations are seen when both uncertain objects are
evaluated at (say) 0.

usubs(m3,'a',0) ans = 0 0 usubs(m4,'a',0) ans = 1.0e-015 * -0.4441 0

Small numerical differences are also noted at other evaluation
points. The example below shows the differences encountered evaluating
at `a`

equal to 1.

usubs(m3,'a',1) ans = 5 6 usubs(m4,'a',1) ans = 5.0000 6.0000

The `simplify`

command can be used to override
all uncertain element's `AutoSimplify`

property.
The first input to the `simplify`

command is an uncertain
object. The second input is the desired reduction technique, which
can either `'basic'`

or `'full'`

.

Again create an uncertain real parameter, and a 1-by-2 `umat`

, both of whose entries involve the
square of the uncertain parameter. Set the `AutoSimplify`

property
of `a`

to `'basic'`

.

a.AutoSimplify = 'basic'; m3 = [a*(a+4) 6*a*a] UMAT: 1 Rows, 2 Columns a: real, nominal = 4, variability = [-1 1], 4 occurrences

Note that the resulting uncertain matrix `m3`

depends
on four occurrences of `a`

.

The `simplify`

command can be used to perform
a `'full'`

reduction on the resulting `umat`

.

m4 = simplify(m3,'full') UMAT: 1 Rows, 2 Columns a: real, nominal = 4, variability = [-1 1], 2 occurrences

The resulting uncertain matrix `m4`

depends
on only two occurrences of `a`

after the reduction.

Was this topic helpful?