Robust Control Toolbox Release Notes

How to Contact MathWorks

Web Newsgroup www.mathworks.com/contact_TS.html Technical Support
www.mathworks.com comp.soft-sys.matlab suggest@mathworks.com bugs@mathworks.com doc@mathworks.com service@mathworks.com info@mathworks.com
Product enhancement suggestions Bug reports Documentation error reports Order status, license renewals, passcodes Sales, pricing, and general information
508-647-7000 (Phone) 508-647-7001 (Fax) The MathWorks, Inc. 3 Apple Hill Drive Natick, MA 01760-2098
For contact information about worldwide offices, see the MathWorks Web site. Robust Control Toolbox Release Notes COPYRIGHT 20052011 by The MathWorks, Inc.
The software described in this document is furnished under a license agreement. The software may be used or copied only under the terms of the license agreement. No part of this manual may be photocopied or reproduced in any form without prior written consent from The MathWorks, Inc. FEDERAL ACQUISITION: This provision applies to all acquisitions of the Program and Documentation by, for, or through the federal government of the United States. By accepting delivery of the Program or Documentation, the government hereby agrees that this software or documentation qualifies as commercial computer software or commercial computer software documentation as such terms are used or defined in FAR 12.212, DFARS Part 227.72, and DFARS 252.227-7014. Accordingly, the terms and conditions of this Agreement and only those rights specified in this Agreement, shall pertain to and govern the use, modification, reproduction, release, performance, display, and disclosure of the Program and Documentation by the federal government (or other entity acquiring for or through the federal government) and shall supersede any conflicting contractual terms or conditions. If this License fails to meet the governments needs or is inconsistent in any respect with federal procurement law, the government agrees to return the Program and Documentation, unused, to The MathWorks, Inc.

Trademarks

MATLAB and Simulink are registered trademarks of The MathWorks, Inc. See www.mathworks.com/trademarks for a list of additional trademarks. Other product or brand names may be trademarks or registered trademarks of their respective holders.

Patents

MathWorks products are protected by one or more U.S. patents. Please see www.mathworks.com/patents for more information.

Contents

Summary by Version. Version 3.6 (R2011a) Robust Control Toolbox Software. Version 3.5 (R2010b) Robust Control Toolbox Software. Version 3.4.1 (R2010a) Robust Control Toolbox Software. Version 3.4 (R2009b) Robust Control Toolbox Software. Version 3.3.3 (R2009a) Robust Control Toolbox Software. Version 3.3.2 (R2008b) Robust Control Toolbox Software. Version 3.3.1 (R2008a) Robust Control Toolbox Software. Version 3.3 (R2007b) Robust Control Toolbox Software. Version 3.2 (R2007a) Robust Control Toolbox Software. Version 3.1.1 (R2006b) Robust Control Toolbox Software. Version 3.1 (R2006a) Robust Control Toolbox Software. 1
Version 3.0.2 (R14SP3) Robust Control Toolbox Software. Version 3.0.1 (R14SP2) Robust Control Toolbox Software. Compatibility Summary for Robust Control Toolbox Software.

Summary by Version

This table provides quick access to whats new in each version. For clarification, see Using Release Notes on page 2. Version (Release) New Features and Changes Yes Details Yes Details No Yes Details No No Yes Details No Yes Details Yes Details No No Yes Details Version Compatibility Considerations No No No Yes Summary No No No No No No No No No Fixed Bugs and Known Problems Bug Reports Includes fixes NoBug Reports Includes fixes Bug Reports Includes fixes Bug Reports Includes fixes Bug Reports Includes fixes Bug Reports Includes fixes No bug fixes No bug fixes No bug fixes No bug fixes No bug fixes No bug fixes No bug fixes

Latest Version V3.6 (R2011a) V3.5 (R2010b) V3.4.1 (R2010a) V3.4 (R2009b) V3.3.3 (R2009a) V3.3.2(R2008b) V3.3.1 (R2008a) V3.3 (R2007b) V3.2 (R2007a) V3.1.1 (R2006b) V3.1 (R2006a) V3.0.2 (R14SP3) V3.0.1 (R14SP2)

Using Release Notes

Use release notes when upgrading to a newer version to learn about: New features Changes Potential impact on your existing files and practices Review the release notes for other MathWorks products required for this product (for example, MATLAB or Simulink). Determine if enhancements, bugs, or compatibility considerations in other products impact you. If you are upgrading from a software version other than the most recent one, review the current release notes and all interim versions. For example, when you upgrade from V1.0 to V1.2, review the release notes for V1.1 and V1.2.
What Is in the Release Notes
New Features and Changes New functionality Changes to existing functionality Version Compatibility Considerations When a new feature or change introduces a reported incompatibility between versions, the Compatibility Considerations subsection explains the impact. Compatibility issues reported after the product release appear under Bug Reports at the MathWorks Web site. Bug fixes can sometimes result in incompatibilities, so review the fixed bugs in Bug Reports for any compatibility impact. Fixed Bugs and Known Problems MathWorks offers a user-searchable Bug Reports database so you can view Bug Reports. The development team updates this database at release time
and as more information becomes available. Bug Reports include provisions for any known workarounds or file replacements. Information is available for bugs existing in or fixed in Release 14SP2 or later. Information is not available for all bugs in earlier releases. Access Bug Reports using your MathWorks Account.
Documentation on the MathWorks Web Site
Related documentation is available on mathworks.com for the latest release and for previous releases: Latest product documentation Archived documentation
Version 3.6 (R2011a) Robust Control Toolbox Software
This table summarizes whats new in Version 3.6 (R2011a): New Features and Changes Yes Details below Version Compatibility Considerations No Fixed Bugs and Known Problems Bug Reports Includes fixes

New features introduced in this version:
Enhanced Workflow for H-Infinity Synthesis of Fixed-Structure Control Systems
New Generalized LTI models in Control System Toolbox allow you to model control systems with tunable parameters. Using these models simplifies controller tuning with hinfstruct. You can model a closed-loop transfer function, including tunable parameters, as a generalized state-space (genss) model and directly tune the parameters to minimize the closed-loop gain. The hinfstruct command can tune any fixed-structure SISO or MIMO control system using H synthesis techniques. Additionally, new realp and genmat objects let you create parametric expressions. You can use such expressions to create custom tunable components. For example, you can define a low-pass filter parametrized by its cutoff frequency, or an observer-based controller parametrized by the state-feedback and observer gains. For more information about creating tunable Generalized LTI models, see Models with Tunable Coefficients in the Control System Toolbox Users Guide. For more information about H tuning with hinfstruct, see H-Infinity Tuning of Fixed Control Structures in the Robust Control Toolbox Getting Started Guide.
For examples of designing controllers for several different architectures using hinfstruct, see the following updated and new demos: Loop Shaping Design with HINFSTRUCT (updated) Tuning of a Two-Loop Autopilot (updated) Decoupling Controller for a Distillation Column (updated) Multi-Loop PID Control of a Robot Arm (updated) Fixed-Structure Autopilot for a Passenger Jet (new)
Version 3.5 (R2010b) Robust Control Toolbox Software
This table summarizes whats new in Version 3.5 (R2010b): New Features and Changes Yes Details below Version Compatibility Considerations No Fixed Bugs and Known Problems Bug Reports Includes fixes
New Commands for H-Infinity Synthesis of Fixed-Structure Control Systems
New commands in this release allow you to tune fixed-structure SISO and MIMO control systems using the techniques of H synthesis. The new hinfstruct command lets you use the frequency-domain methods of H synthesis to tune control systems with a broad range of architectures and controller structures. For example, you can tune: Fixed-order, fixed-structure controllers, such as pure gains, PID controllers, or fixed-order transfer function or state-space models Single feedback-loop architectures with multiple tunable elements, such as a PID controller plus a filter Multiple feedback-loop architectures with multiple tunable elements Specify the tunable elements of your system using the new parametrized Control Design blocks ltiblock.gain, ltiblock.pid, ltiblock.tf, and ltiblock.ss. For examples of designing controllers for several different architectures using

hinfstruct, see the following new demos:
Loop Shaping Design with HINFSTRUCT Tuning of a Fixed-Structure Autopilot
Decoupling Controller for a Distillation Column Multi-Loop PID Control of a Robot Arm For more information, see H-Infinity Tuning of Fixed Control Structures in the Robust Control Toolbox Getting Started Guide.
Version 3.4.1 (R2010a) Robust Control Toolbox Software
This table summarizes whats new in Version 3.4.1 (R2010a): New Features and Changes No Version Compatibility Considerations No Fixed Bugs and Known Problems Bug Reports Includes fixes
Version 3.4 (R2009b) Robust Control Toolbox Software
This table summarizes whats new in Version 3.4 (R2009b): New Features and Changes Yes Details below Version Compatibility Considerations Yes Summary Fixed Bugs and Known Problems Bug Reports Includes fixes
New features and changes introduced in this version are described here: New Option to Improve Robust Performance by Accounting for Real Uncertain Parameters on page 9 New Command to Linearize Simulink Models with Uncertainty on page 9 New Interface for Simulating Effects of Uncertainty in Simulink Models on page 10 New Command to Model Multiple LTI Responses as One Uncertain System on page 10 New and Updated Demos on page 10 Functions, Properties and Blocks Being Removed on page 11
New Option to Improve Robust Performance by Accounting for Real Uncertain Parameters
You can now improve robust performance by accounting for real uncertain parameters when designing controllers using -synthesis. The user-defined options you use in the dksyn command now includes a new option MixedMU. Set this option to 'on' to account for real uncertain parameters in your system. For more information, see the dkitopt, and dksyn reference pages.
New Command to Linearize Simulink Models with Uncertainty
If you have Simulink Control Design software installed, you can take model uncertainty into account when linearizing a Simulink model. You can
then use the resulting uncertain linearized model (uss object) to perform linear analysis and robust control design. If your model already contains Uncertain State Space blocks, use the new ulinearize command to obtain an uss model. If you want to account for uncertainty in your linear analysis without using Uncertain State Space blocks, you can specify individual Simulink blocks to linearize to an uncertain variable. For more information, see "Computing Uncertain State-Space Models from Simulink Models" in the Robust Control Toolbox Users Guide.

New Interface for Simulating Effects of Uncertainty in Simulink Models
This version of the product provides a new interface to simulate the effects of uncertainty in Simulink models. The interface includes the following: Uncertain State Space block to specify uncertain system in Simulink. You should replace USS System blocks in your existing models with the Uncertain State Space block. To do so, run the slupdate command on your models. ufind command to extract all uncertain variables from a Simulink model. usample command to generate random values of these uncertain variables. For more information on simulating the effects of uncertainty using the new interface, see "Simulating Effects of Uncertainty" in the Robust Control Toolbox Users Guide.
New Command to Model Multiple LTI Responses as One Uncertain System
This version of the product includes a new ucover command that lets you model a family of LTI responses as one uncertain system. For more information, see the ucover reference page.

New and Updated Demos

The following new and updated demos illustrate use of the new features:
"Control of Spring-Mass-Damper Using Mixed mu-Synthesis" shows use of the new MixedMU option and dksyn command for mixed-mu synthesis. "Linearization of Simulink Models with Uncertainty" shows how to compute uncertain state-space models using ulinearize and Simulink Control Design software. "Robustness Analysis in Simulink" uses the new interface for simulating effects of uncertainty in Simulink models. "Simultaneous Stabilization Using Robust Control" and "Modeling a Family of Responses as an Uncertain System" show use of the ucover command. "First-Cut Robust Design" shows use of the usample, ucover and dksyn commands. To access the demos, type
demo('toolbox','robust control')
Functions, Properties and Blocks Being Removed
Function, Property or Block Name

usiminfo

What Happens When You Use Function or Property? Still runs

Use This Instead

Compatibility Considerations See New Interface for Simulating Effects of Uncertainty in Simulink Models on page 10. See New Interface for Simulating Effects of Uncertainty in Simulink Models on page 10. See New Interface for Simulating Effects of Uncertainty in Simulink Models on page 10.

usimfill

Still runs

usimsamp

usample
Function, Property or Block Name USS System block
Use This Instead Uncertain State Space block
Compatibility Considerations See New Interface for Simulating Effects of Uncertainty in Simulink Models on page 10. See New Command to Model Multiple LTI Responses as One Uncertain System on page 10.

ltiarray2uss

ucover

Version 3.3.3 (R2009a) Robust Control Toolbox Software
This table summarizes whats new in Version 3.3.3 (R2009a): New Features and Changes No Version Compatibility Considerations No Fixed Bugs and Known Problems Bug Reports Includes fixes
Version 3.3.2 (R2008b) Robust Control Toolbox Software
This table summarizes whats new in Version 3.3.2 (R2008b): New Features and Changes No Version Compatibility Considerations No Fixed Bugs and Known Problems Bug Reports Includes fixes
Version 3.3.1 (R2008a) Robust Control Toolbox Software
This table summarizes whats new in Version 3.3.1 (R2008a): New Features and Changes Yes Details below Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes
New features and changes introduced in this version are described here.
Ability to Use LOOPMARGIN with Simulink
This version of Robust Control Toolbox software lets you analyze the robustness of nonlinear Simulink models using the LOOPMARGIN command. If you have the Simulink Control Design product installed, you can perform stability margin analysis of a Simulink model by passing the model name and a point within that model to the LOOPMARGIN command.
Version 3.3 (R2007b) Robust Control Toolbox Software
This table summarizes whats new in Version 3.3 (R2007b): New Features and Changes No Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes
Version 3.2 (R2007a) Robust Control Toolbox Software
This table summarizes whats new in Version 3.2 (R2007a): New Features and Changes Yes Details below Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes

New Simulink Blocks

USS System This Robust Control Toolbox version introduces a new Simulink block, USS System. You can use this block to import uncertain systems into Simulink models. Multiplot Graph Plot multiple signals in one figure.
Version 3.1.1 (R2006b) Robust Control Toolbox Software
This table summarizes whats new in Version 3.1.1 (R2006b): New Features and Changes Yes Details below Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes
New Function ltiarray2uss
This Robust Control Toolbox version introduces a new function, ltiarray2uss. This function constructs an uncertain state-space model from an LTI array.
Version 3.1 (R2006a) Robust Control Toolbox Software
This table summarizes whats new in Version 3.1 (R2006a): New Features and Changes No Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes
Version 3.0.2 (R14SP3) Robust Control Toolbox Software
This table summarizes whats new in Version 3.0.2 (R14SP3): New Features and Changes No Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes

Version 3.0.1 (R14SP2) Robust Control Toolbox Software
This table summarizes whats new in Version 3.0.1 (R14SP2): New Features and Changes Yes Details below Version Compatibility Considerations No Fixed Bugs and Known Problems No bug fixes
New features and changes introduced in this version are described here:

mussvunwrap Is Renamed

mussvunwrap has been renamed. It is now called mussvextract.
New Functions actual2normalized and normalized2actual
This Robust Control Toolbox version introduced two new functions: actual2normalized Calculate normalized distance between nominal value and given value for uncertain atom. normalized2actual Convert value for atom in normalized coordinates to corresponding actual value.
Compatibility Summary for Robust Control Toolbox Software
This table summarizes new features and changes that might cause incompatibilities when you upgrade from an earlier version, or when you use files on multiple versions. Details are provided with the description of the new feature or change. Version (Release) Latest Version V3.6 (R2011a) V3.5 (R2010b) V3.4.1 (R2010a) V3.4 (R2009b) V3.3.3 (R2009a) V3.3.2 (R2008b) V3.3.1 (R2008a) V3.3 (R2007b) V3.2 (R2007a) V3.1.1 (R2006b) V3.1 (R2006a) New Features and Changes with Version Compatibility Impact None None None See Functions, Properties and Blocks Being Removed on page 11. None None None None None None None
Version (Release) V3.0.2 (R14SP3) V3.0.1 (R14SP2)
New Features and Changes with Version Compatibility Impact None None

Introduction to Uncertain Atoms
Uncertain atoms are the building blocks used to form uncertain matrix objects and uncertain system objects. There are 5 classes of uncertain atoms: Function
ureal ultidyn ucomplex ucomplexm udyn
Description Uncertain real parameter Uncertain, linear, time-invariant dynamics Uncertain complex parameter Uncertain complex matrix Uncertain dynamic system
All of the atoms have properties, which are accessed through get and set methods. This get and set interface mimics the Control System Toolbox and MATLAB Handle Graphics behavior. For instance, get(a,'PropertyName') is the same as a.PropertyName, and set(b,'PropertyName',Value) is the same as b.PropertyName = value. Functionality also includes tab-completion and case-insensitive, partial name property matching. For ureal, ucomplex and ucomplexm atoms, the syntax is
p1 = ureal(name, NominalValue, Prop1, val1, Prop2, val2,.); p2 = ucomplex(name, NominalValue, Prop1, val1, Prop2, val2,.); p3 = ucomplexm(name, NominalValue, Prop1, val1, Prop2, val2,.);
For ultidyn and udyn, the NominalValue is fixed, so the syntax is
p4 = ultidyn(name, ioSize, Prop1, val1, Prop2, val2,.); p5 = udyn(name, ioSize, Prop1, val1, Prop2, val2,.);
For ureal, ultidyn, ucomplex and ucomplexm atoms, the command usample will generate a random instance (i.e., not uncertain) of the atom, within its modeled range. For example,

usample(p1)

creates a random instance of the uncertain real parameter p1. With an integer argument, whole arrays of instances can be created. For instance

usample(p4,100)

generates an array of 100 instances of the ultidyn object p4. See Sampling Uncertain Objects on page 1-45 to learn more about usample.
Uncertain Real Parameters
An uncertain real parameter is used to represent a real number whose value is uncertain. Uncertain real parameters have a name (the Name property), and a nominal value (the NominalValue property). Several other properties (PlusMinus, Range, Percentage) describe the uncertainty in parameter values. All properties of a ureal can be accessed through get and set. The properties are: Properties

Meaning Internal name

NominalValue Mode
Nominal value of atom Signifies which description (from'PlusMinus', 'Range', 'Percentage') of uncertainty is invariant when NominalValue is changed Additive variation Numerical range Additive variation (% of absolute value of nominal)
'off' | {'basic'} |'full'

double char

b.NominalValue = 2.2; get(b) Name: 'b' NominalValue: 2.2000 Mode: 'Percentage' Range: [2.0900 2.5300] PlusMinus: [-0.1100 0.3300] Percentage: [-5.0000 15.0000]

AutoSimplify: 'basic'

Create an uncertain parameter with an unsymmetric variation about its nominal value.
c = ureal('c',-5,'per',[-20 30]); get(c) Name: 'c' NominalValue: -5 Mode: 'Percentage' Range: [-6 -3.5000] PlusMinus: [-1 1.5000] Percentage: [-20 30] AutoSimplify: 'basic'
Create an uncertain parameter, specifying variability with Percentage, but force the Mode to be Range.
d = ureal('d',-1,'mode','range','perc',[-40 60]); get(d) Name: 'd' NominalValue: -1 Mode: 'Range' Range: [-1.4000 -0.4000] PlusMinus: [-0.4000 0.6000] Percentage: [-40.0000 60] AutoSimplify: 'basic'
Finally, create an uncertain real parameter, and set the AutoSimplify property to 'full'.
e = ureal('e',10,'plusminus',[-23],'mode','perce',. 'autosimplify','full') Uncertain Real Parameter: Name e, NominalValue 10, variability = [-20 get(e) Name: 'e' NominalValue: 10 Mode: 'Percentage' Range: [8 13] PlusMinus: [-2 3] 30]%
Percentage: [-20 30] AutoSimplify: 'full'
Specifying conflicting values for Range/Percentage/PlusMinus in a multiple property/value set is not an error. In this case, the last (in list) specified property is used. This last occurrence also determines the Mode, unless Mode is explicitly specified, in which case that is used, regardless of the property/value pairs ordering.
f = ureal('f',3,'plusminus',[-2 1],'perce',40) Uncertain Real Parameter: Name f, NominalValue 3, variability = [-40 g = ureal('g',2,'plusminus',[-2 1],'mode','range','perce',40) Uncertain Real Parameter: Name g, NominalValue 2, Range [1.2 g.Mode ans = Range 2.8] 40]%
Create an uncertain real parameter, use usample to generate 1000 instances (resulting in a 1-by-1-by-1000 array), reshape the array, and plot a histogram, with 20 bins (within the range of 2 to 4).
h = ureal('h',3); hsample = usample(h,1000); hist(reshape(hsample,[1000 1]),20);

Lifting a double matrix to a umat
A not-uncertain matrix may be interpreted as an uncertain matrix that has no dependence on uncertain atoms. Use the umat command to lift a double to the umat class.
Md = [3;6]; M = umat(Md) UMAT: 2 Rows, 3 Columns
High dimensional double matrices can also be lifted. Note from the display that once the matrix is interpreted as a umat, the third dimension and beyond are interpreted as array dimensions. See Array Management for Uncertain Objects on page 1-52 for more information about how multidimensional arrays of uncertain objects are handled.
Md = randn(4,5,6); M = umat(Md) UMAT: 4 Rows, 5 Columns [array, 6 x 1] Md = randn(4,5,6,7); M = umat(Md) UMAT: 4 Rows, 5 Columns [array, 6 x 7] Md = randn(4,5,6,7,8);
M = umat(Md) UMAT: 4 Rows, 5 Columns [array, 6 x 7 x 8]
Uncertain State-Space Systems (uss)
Uncertain systems (uss) are linear systems with uncertain state-space matrices and/or uncertain linear dynamics. Like their certain (i.e., not uncertain) counterpart, the ss object, they are often built from state-space matrices using the ss command. In the case where some of the state-space matrices are uncertain, the result will be a uncertain state-space (uss) object. Combining uncertain systems with uncertain systems (with the feedback command, for example) usually leads to an uncertain system. Not-uncertain systems can be combined with uncertain systems. Usually the result is an uncertain system. The nominal value of an uncertain system is a ss object, which is familiar to Control System Toolbox software users.
Creating Uncertain Systems
Uncertain systems (class uss) are built from of certain and/or uncertain state-space matrices, usually using the ss command. In the example below, the A, B and C matrices are made up of uncertain real parameters. Packing them together with the ss command results in a continuous-time uncertain system. You can create three uncertain real parameters. Then create 3 uncertain matrices A, B and C, and one double matrix D.
p1 = ureal('p1',10,'pe',50); p2 = ureal('p2',3,'plusm',[-.5 1.2]); p3 = ureal('p3',0); A = [-p1 p2;0 -p1]; B = [-p2;p2+p3]; C = [1 0;1 1-p3]; D = [0;0];
Pack the 4 matrices together using the ss command. This results in a continuous-time 2-output, 1-input, 2-state uncertain system.

sys = ss(A,B,C,D)

USS: 2 States, 2 Outputs, 1 Input, Continuous System p1: real, nominal = 10, variability = [-50 50]%, 2 occurrences p2: real, nominal = 3, variability = [-0.5 1.2], 2 occurrences p3: real, nominal = 0, variability = [-1 1], 2 occurrences
Properties of uss Objects
View the properties with the get command.
get(sys) a: b: c: d: StateName: Ts: InputName: OutputName: InputGroup: OutputGroup: NominalValue: Uncertainty: Notes: UserData: [2x2 [2x1 [2x2 [2x1 {2x{''} {2x1 [1x1 [1x1 [2x1 [1x1 {} [] umat] umat] umat] double] cell}

cell} struct] struct] ss] atomlist]
The properties a, b, c, d, and StateName behave in exactly the same manner as Control System Toolbox ss objects. The properties InputName, OutputName, InputGroup and OutputGroup behave in exactly the same manner as all of the Control System Toolbox system objects (ss, zpk, tf, and frd). The NominalValue is a Control System Toolbox ss object, and hence all methods for ss objects are available. For instance, compute the poles and step response of the nominal system.
pole(sys.NominalValue) ans = -10 -10 step(sys.NominalValue)
Just as with the umat class, the Uncertainty property is a atomlist object, acting as a gateway to the uncertain atoms. Direct access to the atoms is facilitated through Uncertainty. Check the Range of the uncertain element named 'p2' within sys, then change its left endpoint.
sys.Uncertainty.p2.range ans = 2.5000 4.2000 sys.Uncertainty.p2.range(1) = 2;
Sampling Uncertain Systems
The command usample randomly samples the uncertain system at a specified number of points. Randomly sample the uncertain system at 20 points in its modeled uncertainty range. This gives a 20-by-1 ss array. Consequently, all analysis tools from Control System Toolbox software are available.
manysys = usample(sys,20); size(manysys) 20x1 array of state-space models Each model has 2 outputs, 1 input, and 2 states.

step(manysys)

The command step can be called directly on a uss object. The default behavior samples the uss object at 20 instances, and plots the step responses of these 20 models, as well as the nominal value. The same features are available for bode, bodemag, impulse, nyquist and step.
Feedback Around an Uncertain Plant
It is possible to form interconnections of uss objects. A common example is to form the feedback interconnection of a given controller with an uncertain plant. First create the uncertain plant. Start with two uncertain real parameters.
gamma = ureal('gamma',4); tau = ureal('tau',.5,'Percentage',30);
Next, create an unmodeled dynamics atom, delta, and a 1st order weighting function, whose DC value is 0.2, high-frequency gain is 10, and whose crossover frequency is 8 rad/sec.
delta = ultidyn('delta',[1 1],'SampleStateDim',5); W = makeweight(0.2,6,6);
Finally, create the uncertain plant consisting of the uncertain parameters and the unmodeled dynamics.
P = tf(gamma,[tau 1])*(1+W*delta);
You can create an integral controller based on nominal plant parameters. Nominally the closed-loop system will have damping ratio of 0.707 and time constant of 2*tau.

KI = 1/(2*tau.Nominal*gamma.Nominal); C = tf(KI,[1 0]);
Create the uncertain closed-loop system using the feedback command.

CLP = feedback(P*C,1);

Using usample and step, plot samples of the open-loop and closed-loop step responses. As expected the integral controller reduces the variability in the low frequency response.
subplot(2,1,1); step(P,5,20) subplot(2,1,2); step(CLP,5,20)
Interpreting Uncertainty in Discrete Time
The interpretation of a ultidyn atom as a continuous-time or discrete-time system depends on the nature of the uncertain system (uss) within which it is an uncertain element. For example, create a scalar ultidyn object. Then, create two 1-input, 1-output uss objects using the ultidyn object as their D matrix. In one case, create without specifying sample-time, which indicates continuous time. In the second case, force discrete-time, with a sample time of 0.42.
delta = ultidyn('delta',[1 1]); sys1 = uss([],[],[],delta) USS: 0 States, 1 Output, 1 Input, Continuous System delta: 1x1 LTI, max. gain = 1, 1 occurrence sys2 = uss([],[],[],delta,0.42) USS: 0 States, 1 Output, 1 Input, Discrete System, Ts = 0.42 delta: 1x1 LTI, max. gain = 1, 1 occurrence
Next, get a random sample of each system. When obtaining random samples using usample, the values of the atoms used in the sample are returned in the 2nd argument from usample as a structure.
[sys1s,d1v] = usample(sys1); [sys2s,d2v] = usample(sys2);
Look at d1v.delta.Ts and d2v.delta.Ts. In the first case, since sys1 is continuous-time, the system d1v.delta is continuous-time. In the second case, since sys2 is discrete-time, with sample time 0.42, the system d2v.delta is discrete-time, with sample time 0.42.
d1v.delta.Ts ans = 0 d2v.delta.Ts ans = 0.4200
Finally, in the case of a discrete-time uss object, it is not the case that ultidyn objects are interpreted as continuous-time uncertainty in feedback with sampled-data systems. This very interesting hybrid theory is beyond the scope of the toolbox.

Lifting a ss to a uss

A not-uncertain state space object may be interpreted as an uncertain state space object that has no dependence on uncertain atoms. Use the uss command to lift a ss to the uss class.

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
The resulting uncertain matrix m4 depends on only two occurrences of a after the reduction.
Sampling Uncertain Objects
The command usample is used to randomly sample an uncertain object, giving a not-uncertain instance of the uncertain object.

Generating One Sample

If A is an uncertain object, then usample(A) generates a single sample of A. For example, a sample of a ureal is a scalar double.
A = ureal('A',6); B = usample(A) B = 5.7298
Create a 1-by-3 umat with A and an uncertain complex parameter C. A single sample of this umat is a 1-by-3 double.
C = ucomplex('C',2+6j); M = [A C A*A]; usample(M) ans = 5.9785 1.4375 + 6.0290i

35.7428

Generating Many Samples
If A is an uncertain object, then usample(A,N) generates N samples of A. For example, 20 samples of a ureal gives a 1-by-1-20 double array.
B = usample(A,20); size(B) ans = 20
Similarly, 30 samples of the 1-by-3 umat M yields a 1-by-3-by-30 array.
size(usample(M,30)) ans = 30
See Creating Arrays with usample on page 1-57 for more information on sampling uncertain objects.

Sampling ultidyn Atoms

When sampling a ultidyn atom (or an uncertain object that contains a ultidyn atom in its Uncertainty gateway) the result is always a state-space (ss) object. The property SampleStateDim of the ultidyn class determines the state dimension of the samples. Create a 1-by-1, gain bounded ultidyn object, with gain-bound 3. Verify that the default state dimension for samples is 1.
del = ultidyn('del',[1 1],'Bound',3); del.SampleStateDim ans = 1
Sample the uncertain atom at 30 points. Verify that this creates a 30-by-1 ss array of 1-input, 1-output, 1-state systems.
delS = usample(del,30); size(delS) 30x1 array of state-space models Each model has 1 output, 1 input, and 1 state.

Modification of a System of LMIs
An existing system of LMIs can be modified in two ways: An LMI can be removed from the system with dellmi.
A matrix variable X can be deleted using delmvar. It can also be instantiated, that is, set to some given matrix value. This operation is performed by setmvar and allows, for example, to fix some variables and solve the LMI problem with respect to the remaining ones.
Specifying a System of LMIs
The LMI Lab can handle any system of LMIs of the form NT L(X1,. , XK) N < MT R(X1,. , XK) M where X1,. , XK are matrix variables with some prescribed structure The left and right outer factors N and M are given matrices with identical dimensions The left and right inner factors L(.) and R(.) are symmetric block matrices with identical block structures, each block being an affine combination of X1,. , XK and their transposes. Note Throughout this chapter, left side refers to what is on the smaller side of the inequality, and right side to what is on the larger side. Accordingly, X is called the right-hand side and 0 the left side of the LMI 0<X even when this LMI is written as X > 0. The specification of an LMI system involves two steps:
1 Declare the dimensions and structure of each matrix variable X1,. , XK. 2 Describe the term content of each LMI.
This process creates the so-called internal representation of the LMI system. This computer description of the problem is used by the LMI solvers and in all subsequent manipulations of the LMI system. It is stored as a single vector called LMISYS. There are two ways of generating the internal description of a given LMI system: (1) by a sequence of lmivar/lmiterm commands that build it incrementally, or (2) via the LMI Editor lmiedit where LMIs can be specified directly as symbolic matrix expressions. Though somewhat less flexible and powerful than the command-based description, the LMI Editor is more
straightforward to use, hence particularly well-suited for beginners. Thanks to its coding and decoding capabilities, it also constitutes a good tutorial introduction to lmivar and lmiterm. Accordingly, beginners may elect to skip the subsections on lmivar and lmiterm and to concentrate on the GUI-based specification of LMIs with lmiedit.

A Simple Example

The following tutorial example is used to illustrate the specification of LMI systems with the LMI Lab tools. Run the demo lmidem to see a complete treatment of this example.
Example: Specifying LMI Systems
Consider a stable transfer function

G ( s ) = C ( sI A )

with four inputs, four outputs, and six states, and consider the set of input/output scaling matrices D with block-diagonal structure

dD= 0 0

NEWSYS = dellmi(LMISYS,2)
where the second argument specifies deletion of the second LMI. The resulting system of two LMIs is returned in NEWSYS. The LMI identifiers (initial ranking of the LMI in the LMI system) are not altered by deletions. As a result, the last LMI S>I remains known as the third LMI even though it now ranks second in the modified system. To avoid confusion, it is safer to refer to LMIs via the identifiers returned by newlmi. If BRL, Xpos, and Slmi are the identifiers attached to the three LMIs, Equation 4-6Equation 4-8, Slmi keeps pointing to S > I even after deleting the second LMI by
NEWSYS = dellmi(LMISYS,Xpos)
Deleting a Matrix Variable
Another way of modifying an LMI system is to delete a matrix variable, that is, to remove all variable terms involving this matrix variable. This operation is performed by delmvar. For instance, consider the LMI ATX + XA + BW + WTBT + I < 0 with variables X = XT R44 and W
R24. This LMI is defined by
X = lmivar(1,[4 1]) W = lmivar(2,[2 4])

% X % W

lmiterm([1 X],1,A,'s') lmiterm([1 W],B,1,'s') lmiterm([1 0],1) LMISYS = getlmis
To delete the variable W, type the command
NEWSYS = delmvar(LMISYS,W)
The resulting NEWSYS now describes the Lyapunov inequality ATX + XA + I < 0 Note that delmvar automatically removes all LMIs that depended only on the deleted matrix variable. The matrix variable identifiers are not affected by deletions and continue to point to the same matrix variable. For subsequent manipulations, it is therefore advisable to refer to the remaining variables through their identifier. Finally, note that deleting a matrix variable is equivalent to setting it to the zero matrix of the same dimensions with setmvar.
Instantiating a Matrix Variable
The function setmvar is used to set a matrix variable to some given value. As a result, this variable is removed from the problem and all terms involving it become constant terms. This is useful, for instance, to fixsetmvar some variables and optimize with respect to the remaining ones. Consider again Example: Specifying LMI Systems on page 4-9 and suppose we want to know if the peak gain of G itself is less than one, that is, if G
This amounts to setting the scaling matrix D (or equivalently, S = DTD) to a multiple of the identity matrix. Keeping in mind the constraint S > I, a legitimate choice is S = 2--I. To set S to this value, enter

NEWSYS = setmvar(LMISYS,S,2)
The second argument is the variable identifier S, and the third argument is the value to which S should be set. Here the value 2 is shorthand for 2-by-I. The resulting system NEWSYS reads

AT X + XA + 2C TC BT X

XB <I X >I > I.
Note that the last LMI is now free of variable and trivially satisfied. It could, therefore, be deleted by
NEWSYS = dellmi(NEWSYS,3)
NEWSYS = dellmi(NEWSYS,Slmi)
if Slmi is the identifier returned by newlmi.

Advanced Topics

This last section gives a few hints for making the most out of the LMI Lab. It is directed toward users who are comfortable with the basics, as described in Introduction on page 4-2.
Structured Matrix Variables
Fairly complex matrix variable structures and interdependencies can be specified with lmivar. Recall that the symmetric block-diagonal or rectangular structures are covered by Types 1 and 2 of lmivar provided that the matrix variables are independent. To describe more complex structures or correlations between variables, you must use Type 3 and specify each entry of the matrix variables directly in terms of the free scalar variables of the problem (the so-called decision variables). With Type 3, each entry is specified as either 0 or xn where xn is the n-th decision variable. The following examples illustrate how to specify nontrivial matrix variable structures with lmivar. First, consider the case of uncorrelated matrix variables.
Example: Specifying Matrix Variable Structures
Suppose that the problem variables include a 3-by-3 symmetric matrix X and a 3-by-3 symmetric Toeplitz matrix:

y1 Y = y2 y 3

y2 y1 y2

y3 y2 . y1

The variable Y has three independent entries, hence involves three decision variables. Since Y is independent of X, these decision variables should be labeled n + 1, n + 2, n + 3 where n is the number of decision variables involved in X. To retrieve this number, define the variable X (Type 1) by
setlmis([]) [X,n] = lmivar(1,[3 1])
The second output argument n gives the total number of decision variables used so far (here n = 6). Given this number, Y can be defined by

Y = lmivar(3,n+[3;2;1])

or equivalently by
Y = lmivar(3,toeplitz(n+[3]))
where toeplitz is a standard MATLAB function. For verification purposes, we can visualize the decision variable distributions in X and Y with decinfo:
lmis = getlmis decinfo(lmis,X) ans = 6 decinfo(lmis,Y) ans = 7
The next example is a problem with interdependent matrix variables.
Example: Specifying Interdependent Matrix Variables
Consider three matrix variables X, Y, Z with structure

x 0 X = , 0 y

z 0 Y = , 0 t

0 x Z= t 0

where x, y, z, t are independent scalar variables. To specify such a triple, first define the two independent variables X and Y (both of Type 1) as follows:
[X,n,sX] = lmivar(1,[1 0;1 0]) [Y,n,sY] = lmivar(1,[1 0;1 0])
The third output of lmivar gives the entry-wise dependence of X and Y on the decision variables (x1, x2, x3, x4) := (x, y, z, t):

sX = sY = 0 4

Using Type 3 of lmivar, you can now specify the structure of Z in terms of the decision variables x1 = x and x4 = t:
[Z,n,sZ] = lmivar(3,[0 sX(1,1); sY(2,2) 0])
Since sX(1,1) refers to x1 while sY(2,2) refers to x4, this defines the variable

0 Z= x4

x1 0 x = 0 t 0
as confirmed by checking its entry-wise dependence on the decision variables:

sZ = 4 0

Complex-Valued LMIs
The LMI solvers are written for real-valued matrices and cannot directly handle LMI problems involving complex-valued matrices. However, complex-valued LMIs can be turned into real-valued LMIs by observing that a complex Hermitian matrix L(x) satisfies L(x) < 0

if and only if

Re ( L ( x ) ) Im ( L ( x ) ) < 0. Im ( L ( x ) ) Re ( L ( x ) )
This suggests the following systematic procedure for turning complex LMIs into real ones: Decompose every complex matrix variable X as X = X1 + jX2 where X1 and X2 are real Decompose every complex matrix coefficient A as A = A1 + jA2 where A1 and A2 are real Carry out all complex matrix products. This yields affine expressions in X1, X2 for the real and imaginary parts of each LMI, and an equivalent real-valued LMI is readily derived from the above observation. For LMIs without outer factor, a streamlined version of this procedure consists of replacing any occurrence of the matrix variable X = X1 + jX2 by

the following commands:

for i=1:10; sim('rct_sim_ex1',10); end
During simulation, the software samples the uncertain variable a in its uncertainty range [-2 -0.5] and shows the simulated response for each sample value. The plots cycle through seven different colors, and the last response appears in red.
Tip: You can clear the plots in the MultiPlot Graph block before you run the simulation.
Varying Uncertainty Values Across Multiple Uncertain State Space Blocks
This section describes the workflow for varying uncertainty values across multiple Uncertain State Space blocks in a Simulink model. Use this approach for complex models with large number of uncertain variables or Uncertain State Space blocks. This section uses a Simulink model to provide step-by-step instructions for toggling between nominal and user-defined uncertainty values at the MATLAB prompt.
1 Open the Simulink model rct_sim_ex2.

rct_sim_ex2

The model contains two Uncertain State Space blocks, as shown in the following figure.
The Unmodeled dynamics and First order with uncertain pole blocks depend on the uncertain variables input_unc and a.
2 Double-click the Unmodeled dynamics block to open the block parameters
dialog box. The Uncertainty value field contains the variable val_all. Similarly, the Uncertainty value field in the First order with uncertain pole block parameters dialog contains the variable val_all. You use this variable to vary the uncertain variable values across both the Uncertain State Space blocks.
Note When defining val_all, you can enter only a subset of uncertain variables referenced by the model in the structure. When you do not specify some uncertain variables, the software uses their nominal value during simulation.
3 At the MATLAB prompt, specify val_all = []; and click
to simulate the model. The software uses the nominal values of the uncertain variables a and input_unc during simulation. After the simulation completes, the MultiPlot Graph block shows the following figure.
4 Generate random samples of uncertainty values: a Find all Uncertain State Space blocks and associated uncertain variables

3 (Prerequisite) If you have not already done so, specify uncertainty in the
Simulink model as described in Specifying Uncertainty Using Uncertain State Space Blocks on page 5-5. Note The software does not evaluate the uncertain variables during linearization. Thus, the value of the uncertainty does not affect the linearization.
4 Run ulinearize to compute an uncertain linearization. This command
returns an uss model. Note If you use the Simulink Control Designlinearize command, the Uncertain State Space blocks linearize to their nominal value. For more information on linearization and how to evaluate the results, see Linearization in the Simulink Control Design documentation. For an example of how to use the Simulink Control Design linearize command, see the Linearization of Simulink Models with Uncertainty demo.
Working with Models Containing Core Simulink or Custom Blocks
In some cases, you cannot use Uncertain State Space blocks in the Simulink model because you share the model or generate code. You can still account for uncertainty in your linear analysis without specifying uncertainty using Uncertain State Space blocks. Robust Control Toolbox lets you specify a core or custom Simulink block to linearize to an uncertain variable. The linearization produces an uncertain state-space uss model. The specified
uncertainty associates only with the block and does not affect the model simulation. For more information, see Controlling Block Linearization in the Simulink Control Design Users Guide. Note If you have Uncertain State Space blocks in the model and want to obtain an uncertain state-space model, see Working with Models Containing Uncertain State Space Blocks on page 5-19. To specify blocks to linearize to uncertain variables and obtain an uncertain state-space model:
1 (Prerequisite) Create or open the Simulink model. 2 (Prerequisite) Specify linearization input and output points using the
Simulink Control Design getlinio or linio commands.
3 Specify a block to linearize to an uncertain variable: a Right-click the block and select Linear Analysis > Specify

Linearization.

This action opens the Block Linearization Specification dialog box.
b In the Block Linearization Specification dialog box, select the Specify
block linearization using a check box. Selecting this check box lets you to specify an uncertain variable for linearization. This check box defaults to MATLAB Expression in the drop-down menu. This option lets you specify the block to linearize to an uncertain variable using a MATLAB expression containing Robust Control Toolbox functions. To learn more about the options, see Controlling Block Linearization in the Simulink Control Design documentation.

Example Computing Stability Margins of a Simulink Model
This example illustrates how to compute the stability margins of the airframemargin model and compare the results with stability margins computed using the linearized model.
1 Open the Simulink model:
airframemargin The Simulink model, as shown in the following figure opens.
2 Define a margin analysis point at the output of the Airframe Model block

by typing:

block1 = 'airframemargin/Airframe Model';
3 Specify the output az of the Airframe Model block as a margin analysis

point by typing:

port1 = 1;
4 Compute stability margins by typing:
[cm,dm,mm] = loopmargin('airframemargin',block1,port1);
5 View the classical gain and phase margins:
MATLAB return the following results:
cm = GainMargin: GMFrequency: PhaseMargin: PMFrequency: DelayMargin: DMFrequency: Stable: [4.5652 2.5055e+003] [7.1979 314.1593] 65.1907 2.1463 53.0113 2.1463 1
6 Compare the classical gain and phase margins cm with stability margins of
the linearized model computed using allmargin:
% Define linearization I/O points. io = linio('airframemargin/Airframe Model',1,'outin','on'); % Linearize the model. lin_sys = linearize('airframemargin',io); % Compute gain and phase margins. cm_lin = allmargin(-lin_sys);
MATLAB returns the following results:
cm_lin = GainMargin: GMFrequency: PhaseMargin: PMFrequency: DelayMargin: DMFrequency: Stable: [4.5652 2.5055e+003] [7.1979 314.1593] 65.1907 2.1463 53.0113 2.1463 1
The gain and phase margins, cm and cm_lin, computed using the two approaches match.
Use this list to find examples in the documentation.
Generating One Sample on page 1-45 Generating Many Samples on page 1-45 Sampling ultidyn Atoms on page 1-46 Creating Arrays with stack and cat Functions on page 1-53 Creating Arrays by Assignment on page 1-55 Creating Arrays with usample on page 1-57 Creating Arrays with usubs on page 1-58 Creating Arrays with gridureal on page 1-59 Creating Arrays with repmat on page 1-60

The LMI Lab

Example: Example: 4-23 Example: Example: Specifying LMI Systems on page 4-9 Minimizing Linear Objectives under LMI Constraints on page Specifying Matrix Variable Structures on page 4-33 Specifying Interdependent Matrix Variables on page 4-34
Varying Uncertainty Values Using Individual Uncertain State Space Blocks on page 5-9 Varying Uncertainty Values Across Multiple Uncertain State Space Blocks on page 5-14 Example - Specifying a Block to Linearize To an Uncertain Variable at the Command Line on page 5-23 Example Computing Stability Margins of a Simulink Model on page 5-28