Robust Control Toolbox

Robust Control Toolbox
For Use with MATLAB
Gary Balas Richard Chiang Andy Packard Michael Safonov
Users Guide
Version 3
How to Contact The MathWorks:

www.mathworks.com comp.soft-sys.matlab [email protected] [email protected] [email protected] [email protected] [email protected] [email protected]
Web Newsgroup Technical support Product enhancement suggestions Bug reports Documentation error reports Order status, license renewals, passcodes Sales, pricing, and general information Phone Fax Mail
508-647-7000 508-647-7001 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 Users Guide COPYRIGHT 19922005 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 government's 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. MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, and xPC TargetBox are registered trademarks of The MathWorks, Inc. Other product or brand names are trademarks or registered trademarks of their respective holders.
Revision History: August 1992 January 1998 June 2001 June 2004 October 2004 March 2005
First printing
New for Version 1
Online only Online only Online only Online only Online only
Revised for Version 2 Revised for Version 2.0.8 (Release 12.1) Revised for Version 2.0.9 (Release 14) Revised for Version 3 (Release 14SP1) Revised for Version 3.0.1 (Release 14SP2)
Contents
Introduction
1
What Is the Robust Control Toolbox? . . . . . . . . . . . . . . . . . . . 1-2 Required Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-2 Modeling Uncertainty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-3 Example: ACC Benchmark Problem . . . . . . . . . . . . . . . . . . . . . 1-3 Worst Case Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-7 Example: ACC Two Cart Benchmark Problem . . . . . . . . . . . . . 1-7 Synthesis of Robust MIMO Controllers . . . . . . . . . . . . . . . . 1-10 Example: Designing a Controller with LOOPSYN . . . . . . . . . 1-10 Model Reduction and Approximation . . . . . . . . . . . . . . . . . . 1-14 Example: NASA HIMAT Controller Order Reduction . . . . . . 1-14 LMI Solvers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-18 Extends Control System Toolbox . . . . . . . . . . . . . . . . . . . . . . 1-19 About the Authors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-20 Bibliography . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-21
Multivariable Loop Shaping
2
Tradeoff between Performance and Robustness . . . . . . . . . 2-2 Norms and Singular Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-2 Typical loop shapes, S and T Design . . . . . . . . . . . . . . . . . . . . 2-5 Singular Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-6
Guaranteed Gain/Phase Margins in MIMO Systems . . . . . . . . 2-9 Using LOOPSYN to do H-Infinity Loop Shaping . . . . . . . . . Example: NASA HiMAT loop-shaping . . . . . . . . . . . . . . . . . . . Design Specifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MATLAB Commands for a LOOPSYN design . . . . . . . . . . . . .
2-11 2-11 2-13 2-13
Using MIXSYN for H-Infinity Loop Shaping . . . . . . . . . . . . 2-18 Example: NASA HiMAT design using MIXSYN . . . . . . . . . . . 2-19 Loop Shaping Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-21
Model Reduction for Robust Control
3
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-2 Hankel Singular Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-2 Overview of Model Reduction Techniques . . . . . . . . . . . . . . . 3-4 Approximating Plant Models -- Additive Error Methods . . 3-6 Approximating Plant Models -- Multiplicative Error Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-8 Using Modal Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-10 Rigid Body Dynamics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-10 Reducing Large Scale Models . . . . . . . . . . . . . . . . . . . . . . . . . 3-13 Using Normalized Coprime Factor Methods . . . . . . . . . . . . 3-14 References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-15
ii
Contents
Robustness Analysis
4
Uncertainty Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Uncertain Models of Dynamic Systems . . . . . . . . . . . Creating Uncertain Parameters . . . . . . . . . . . . . . . . . . . . . . . . . Quantifying Unmodeled Dynamics . . . . . . . . . . . . . . . . . . . . . . .
4-2 4-2 4-3 4-5
Robustness Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-8 Multi-Input, Multi-Output Robustness Analysis . . . . . . . . . Adding Independent Input Uncertainty to Each Channel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Closed-Loop Robustness Analysis . . . . . . . . . . . . . . . . . . . . . . . Nominal Stability Margins . . . . . . . . . . . . . . . . . . . . . . . . . . . . Robustness of Stability Model Uncertainty . . . . . . . . . . . . . . .
4-12 4-13 4-15 4-17 4-18
Worst-Case Gain Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-20 Summary of Robustness Analysis Tools . . . . . . . . . . . . . . . . 4-23
H-Infinity and Mu Synthesis
5
H-Infinity Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5-2 Performance as Generalized Disturbance Rejection . . . . . . . . . 5-2 Robustness in the H Framework . . . . . . . . . . . . . . . . . . . . . . . 5-8 Application of H and mu to Active Suspension Control . Quarter Car Suspension Model . . . . . . . . . . . . . . . . . . . . . . . . . Linear H Controller Design . . . . . . . . . . . . . . . . . . . . . . . . . . . H Control Design 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . H Control Design 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Control Design via m-Synthesis . . . . . . . . . . . . . . . . . . . . . . . .
5-10 5-10 5-12 5-13 5-14 5-19
Functions for Control Design . . . . . . . . . . . . . . . . . . . . . . . . . 5-24
iii
Appendix: Interpretation of H-Infinity norm . . . . . . . . . . . 5-26 Norms of Signals and Systems . . . . . . . . . . . . . . . . . . . . . . . . . 5-26 Using Weighted Norms to Characterize Performance . . . . . . . 5-28 References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5-33
Building Uncertain Models
6
Introduction to Uncertain Atoms . . . . . . . . . . . . . . . . . . . . . . . 6-2 Uncertain Real Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-3 Uncertain LTI Dynamics Atoms . . . . . . . . . . . . . . . . . . . . . . . . 6-10 Complex Parameter Atoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-13 Complex Matrix Atoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-15 Unstructured Uncertain Dynamic Systems . . . . . . . . . . . . . . . 6-17 Uncertain Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Uncertain Matrices from Uncertain Atoms . . . . . . . Accessing Properties of a umat . . . . . . . . . . . . . . . . . . . . . . . . . Row and Column Referencing . . . . . . . . . . . . . . . . . . . . . . . . . . Matrix Operation on umat Objects . . . . . . . . . . . . . . . . . . . . . . Substituting for Uncertain Atoms . . . . . . . . . . . . . . . . . . . . . . . Uncertain State-Space Systems (uss) . . . . . . . . . . . . . . . . . . . Creating Uncertain Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . Properties of uss Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sampling Uncertain Systems . . . . . . . . . . . . . . . . . . . . . . . . . . Feedback Around Uncertain Plant . . . . . . . . . . . . . . . . . . . . . . Interpreting Uncertainty in Discrete Time . . . . . . . . . . . . . . . Lifting a ss to a uss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Handling Delays in uss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Uncertain frd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Uncertain Frequency Response Objects . . . . . . . . . . Properties of ufrd objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Interpreting Uncertainty in Discrete Time . . . . . . . . . . . . . . . Lifting an frd to a ufrd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6-19 6-19 6-20 6-21 6-22 6-23 6-25 6-25 6-26 6-27 6-28 6-30 6-31 6-31 6-33 6-33 6-33 6-36 6-36
iv
Contents
Handling Delays in ufrd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-36 Basic Control System Toolbox Interconnections . . . . . . . . 6-37 Simplifying Representation of Uncertain Objects . . . . . . . 6-38 Effect of AutoSimplify Property . . . . . . . . . . . . . . . . . . . . . . . . 6-39 Direct Use of simplify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-41 Sampling Uncertain Objects . . . . . . . . . . . . . . . . . . . . . . . . . . Generating One Sample . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Generating Many Samples . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sampling ultidyn Atoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6-42 6-42 6-42 6-43
Substitution by usubs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-46 Specifying the Substitution with Structures . . . . . . . . . . . . . . 6-47 Nominal and Random Values . . . . . . . . . . . . . . . . . . . . . . . . . . 6-47 Array Management for Uncertain Objects . . . . . . . . . . . . . . Referencing Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays with stack, cat . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays by Assignment . . . . . . . . . . . . . . . . . . . . . . . . Binary Operations with Arrays . . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays With usample . . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays With usubs . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays with gridureal . . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays with repmat . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Arrays with repsys . . . . . . . . . . . . . . . . . . . . . . . . . . . Using permute and ipermute . . . . . . . . . . . . . . . . . . . . . . . . . . Decomposing Uncertain Objects (for Advanced Users) . . Normalizing Functions for Uncertain Atoms . . . . . . . . . . . . . . Properties of the Decomposition . . . . . . . . . . . . . . . . . . . . . . . . Syntax of lftdata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced Syntax of lftdata . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6-49 6-49 6-50 6-52 6-53 6-53 6-55 6-56 6-57 6-58 6-58 6-60 6-60 6-61 6-62 6-64
Generalized Robustness Analysis
7
Introduction to Generalized Robustness Analysis . . . . . . . . 7-2 Robust Stability Margin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7-5 Robust Performance Margin . . . . . . . . . . . . . . . . . . . . . . . . . . . 7-6 Worst-Case Gain Measure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7-7
Introduction to Linear Matrix Inequalities
8
Linear Matrix Inequalities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-2 LMI Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-2 LMIs and LMI Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-4 The Three Generic LMI Problems . . . . . . . . . . . . . . . . . . . . . . . . 8-5 Further Mathematical Background . . . . . . . . . . . . . . . . . . . . . 8-9 References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-10
The LMI Lab
9
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-2 Some Terminology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-2 Overview of the LMI Lab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-5 Specifying a System of LMIs . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-7 A Simple Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-8 Initializing the LMI System . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-10
vi
Contents
Specifying the LMI Variables . . . . . . . . . . . . . . . . . . . . . . . . . . Specifying Individual LMIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . Specifying LMIs With the LMI Editor . . . . . . . . . . . . . . . . . . . How It All Works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9-10 9-12 9-15 9-18
Querying the LMI System Description . . . . . . . . . . . . . . . . . 9-19 lmiinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-19 lminbr and matnbr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-19 LMI Solvers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-20 From Decision to Matrix Variables and Vice Versa . . . . . . 9-26 Validating Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-27 Modifying a System of LMIs . . . . . . . . . . . . . . . . . . . . . . . . . . . Deleting an LMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deleting a Matrix Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . Instantiating a Matrix Variable . . . . . . . . . . . . . . . . . . . . . . . . Advanced Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Structured Matrix Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . Complex-Valued LMIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Specifying cTx Objectives for mincx . . . . . . . . . . . . . . . . . . . . . Feasibility Radius . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Well-Posedness Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Semi-Definite B(x) in gevp Problems . . . . . . . . . . . . . . . . . . . . Efficiency and Complexity Issues . . . . . . . . . . . . . . . . . . . . . . . Solving M + PTXQ + QTXTP < 0 . . . . . . . . . . . . . . . . . . . . . . . .
9-28 9-28 9-28 9-29 9-31 9-31 9-33 9-36 9-37 9-38 9-39 9-39 9-40
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-42
Function Reference
10
Functions Categorical List . . . . . . . . . . . . . . . . . . . . . . . . . 10-2 Uncertain Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-2
vii
Uncertain Matrices and Systems . . . . . . . . . . . . . . . . . . . . . . . Manipulation of Uncertain Models . . . . . . . . . . . . . . . . . . . . . . Interconnection of Uncertain Models . . . . . . . . . . . . . . . . . . . . Model Order Reduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Robustness and Worst-Case Analysis . . . . . . . . . . . . . . . . . . . . Robustness Analysis for Parameter-Dependent Systems (P-Systems) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Controller Synthesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . m-Synthesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sampled-Data Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gain Scheduling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Supporting Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Specification of Systems of LMIs . . . . . . . . . . . . . . . . . . . . . . . LMI Characteristics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LMI Solvers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Validation of Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Modification of Systems of LMIs . . . . . . . . . . . . . . . . . . . . . . . .
10-2 10-2 10-3 10-3 10-4 10-5 10-6 10-6 10-7 10-7 10-7 10-7 10-8 10-8 10-8 10-9
Functions Alphabetical List . . . . . . . . . . . . . . . . . . . . . . . 10-10
Index
viii Contents
1
Introduction
What Is the Robust Control Toolbox? (p. 1-2) Modeling Uncertainty (p. 1-3) Worst Case Performance (p. 1-7)
Tools for analysis and design of uncertain control systems How to model uncertain parameters, matrices and systems Computing worst-case values for uncertain systems
Synthesis of Robust MIMO Controllers Designing controllers that optimize worst case (p. 1-10) performance and maximize stability margins (H, H2, loop-shaping, mixed sensitivity, -synthesis, and LMI optimization) Model Reduction and Approximation (p. 1-14) LMI Solvers (p. 1-18) Extends Control System Toolbox (p. 1-19) About the Authors (p. 1-20) Bibliography (p. 1-21) Simplifying high-order LTI plant and controller models Tools for solving Linear Matrix Inequalities How the Robust Control Toolbox uses LTI objects and commands from the Control System Toolbox Brief biographies of the toolbox authors A list of sources on robust control theory
Introduction
What Is the Robust Control Toolbox?

The Robust Control Toolbox (RCT) is a collection of functions and tools that help you to analyze and design MIMO control systems with uncertain elements. You can build uncertain LTI system models containing uncertain parameters and uncertain dynamics. You get tools to analyze MIMO system stability margins and worst case performance. The Robust Control Toolbox includes a selection of control synthesis tools that compute controllers that optimize worst-case performance and identify worst-case parameter values. The toolbox lets you simplify and reduce the order of complex models with model reduction tools that minimize additive and multiplicative error bounds. And, it provides tools for implementing advanced robust control methods like H, H2, Linear Matrix Inequalities (LMI), and -synthesis robust control. You can shape MIMO system frequency responses and design uncertainty tolerant controllers.
Required Software
The Robust Control Toolbox requires that you have installed the Control System Toolbox.
1-2
Modeling Uncertainty
At the heart of robust control is the concept of an uncertain LTI system. Model uncertainty arises when system gains or other parameters are not precisely known, or may vary over a given range. Examples of real parameter uncertainties include uncertain pole and zero locations, and uncertain gains. One may also have unstructured uncertainties, by which one means complex parameter variations satisfying given magnitude bounds. With the Robust Control Toolbox you can create uncertain LTI models as MATLAB objects specifically designed for robust control applications. You can build models of complex systems by combining models of subsystems using addition, multiplication, and division, as well as with Control System Toolbox commands like feedback and lft.
Example: ACC Benchmark Problem

For instance, consider the two-cart ACC Benchmark system [13] consisting of two frictionless carts connected by a spring as shown in shown below.
Control Force u1
Position - x1
-
Position Measurement - x2 = y1 m2
m m
m1
m m
e %e e% e e
Spring k
Figure 1-1: ACC benchmark problem
The system has block diagram model shown in Figure 1-2, where the individual carts have respective transfer functions 1 G1(s) = ------------- ; 2 m1s 1 G2(s) = ------------- . 2 m2 s
The parameters m1, m2 and k are uncertain, equal to one plus or minus 20%:
1-3
Introduction
m1 = 10.2 m2 = 10.2 k = 10.2 P(s) u1 + u2 Spring k f1 x1 f2 x2 F(s) y1
G1(s) Cart 1
G2(s) Cart 2
y2
Figure 1-2: ACC benchmark two-cart system block diagram y1 = P(s) u1
The upper dashed-line block has transfer function matrix F(s) = 0 1 0 G2 ( s ) 1 1 + G1 ( s ) 1
This code builds the uncertain system model P shown in Figure 1-2:
% Create the uncertain reak parameters m1, m2 & k m1 = ureal('m1',1,'percent',20); m2 = ureal('m2',1,'percent',20); k = ureal('k',1,'percent',20); s = zpk('s'); % create the Laplace variable s G1 = ss(1/s^2)/m1; % Cart 1 G2 = ss(1/s^2)/m2; % Cart 2 % Now build F and P F = [0;G1]*[1 -1]+[1;-1]*[0,G2]; P = lft(F,k) % close the loop with the spring k
1-4
The variable P is a SISO uncertain state-space (USS) object, with 4 states, and 3 uncertain parameters m1, m2 and k. You can recover the nominal plant with the command
zpk(P.nominal)
which returns
Zero/pole/gain: 1 -------------s^2 (s^2 + 2)
If the uncertain model P(s) has LTI negative feedback controller 100 ( s + 1 ) C ( s ) = --------------------------------( 0001s + 1 ) 3 , r u1
C
y1
then you can form the controller and the closed-loop system y1 = T(s) u1 and view the closed-loop system's step response on the time interval from t=0 to t=0.1 for a Monte Carlo random sample of 5 combinations of the 3 uncertain parameters k, m1 and m2 using this code:
C=100*ss((s+1)/(.001*s+1))^3; % LTI controller T=feedback(P*C,1); % closed-loop uncertain system step(usample(T,5),.1);
1-5
Introduction
The resulting plot is shown in Figure 1-3 below.

1.4 1.2 1 Amplitude 0.8 0.6 0.4 0.2 0 0 Step Response
0.02
0.04 0.06 Time (sec)
0.08
0.1
Figure 1-3: Monte Carlo sampling of uncertain system's step response.
1-6
Worst Case Performance

To be robust, your control system should meet your stability and performance requirements for all possible values of uncertain parameters. Monte Carlo parameter sampling via usample can be used for this purpose as shown in Figure 1-4, but Monte Carlo methods are inherently hit or miss. With Monte Carlo methods, you might need to take an impossibly large number of samples before you hit upon or near a worst-case parameter combination. The Robust Control Toolbox gives you a powerful assortment of robustness analysis commands that let you directly calculate upper and lower bounds on worst-case performance without random sampling:
Worst-Case Robustness Analysis Commands loopmargin loopsens ncfmargin robustperf robuststab wcgain wcmargin wcsens
Comprehensive analysis of feedback loop. Sensitivity functions of feedback loop. Normalized coprime stability margin of feedback loop. Robust performance of uncertain systems. Stability margins of uncertain systems. Worst-case gain of an uncertain system. Worst-case gain/phase margins for feedback loop. Worst-case sensitivity functions of feedback loop.
Example: ACC Two Cart Benchmark Problem

Returning to the Example: ACC Benchmark Problem, the closed loop system is
T=feedback(P*C,1); % closed-loop uncertain system
This uncertain state-space model T has three uncertain parameters, k, m1 and m2, each equal to 120% uncertain variation. To analyze whether the closed-loop system T is robustly stable for all combinations of values for these three parameters, you can execute the commands
1-7
Introduction
[StabilityMargin,Udestab,REPORT] = robuststab(T); REPORT
This displays the REPORT

Uncertain System is robustly stable to modeled uncertainty. -- It can tolerate up to 311% of modeled uncertainty. -- A destabilizing combination of 500% the modeled uncertainty exists, causing an instability at 44.3 rad/s.
The report tells you that the control system is robust for all parameter variations in the 20% range, and that the smallest destabilizing combination of real variations in the values k, m1 and m2 have sizes somewhere between 311% and 500% greater than 20%, i.e., between 62.2% and 100%. The value Udestab returns an estimate of the 500% destabilizing parameter variation combination:
Udestab k: m1: m2: = 1.2174e-005 1.2174e-005 2.0000.
0.5
Bode Diagram
Magnitude (dB)
0.5
1.5
wc
worstcase
Trand random samples 2 10

0
10 Frequency (rad/sec)
Figure 1-4: Uncertain system closed-loop bode plots.
1-8
You have a comfortable safety margin of between 311% to 500% larger than the anticipated 20% parameter variations before the closed-loop goes unstable. But, how much can closed-loop performance deteriorate for parameter variations constrained to lie strictly within the anticipated 20% range? The following code computes worst-case peak gain of T, and estimates the frequency and parameter values at which the peak gain occurs.
[PeakGain,Uwc] = wcgain(T); Twc=usubs(T,Uwc); % Worst case closed-loop system T Trand=usample(T,4); % 4 random samples of uncertain system T bodemag(Twc,'r',Trand,'b-.',{.5,50}); % Do bode plot legend('T_{wc} - worst-case',... 'T_{rand} - random samples',3);
The resulting plot is shown in Figure 1-4.
1-9
Introduction
Synthesis of Robust MIMO Controllers

You can design controllers for Multi-Input-Multi-Output (MIMO) LTI models with your Robust Control Toolbox using following:
Robust Control Synthesis Commands h2hinfsyn h2syn hinfsyn loopsyn ltrsyn mixsyn ncfsyn sdhinfsyn
Mixed H2/H controller synthesis. H2 controller synthesis. H controller synthesis. H loop shaping controller synthesis Loop-transfer recovery controller synthesis H mixed-sensitivity controller synthesis. H normalized coprime factor controller synthesis. Sampled-data H controller synthesis.
Example: Designing a Controller with LOOPSYN

One of the most powerful, yet simple controller synthesis tools is loopsyn. Given an LTI plant, you specify the shape of the open-loop systems frequency response plot that you want, then loopsyn computes a stabilizing controller that best approximates your specified loop shape. For example, consider the 22 NASA HiMAT aircraft model (Safonov, Laub and Hartmann [8]) depicted in Figure 1-5. The control variables are elevon and canard actuators (e and c). The output variables are angle of attack () and attitude angle (). The model has six states, viz.
1-10
x1 x2 x = x3 x4 x5 x6 =
xe x
where x e and x are elevator and canard actuator states.
Aileron Canard Flap Rudder
Elevator Elevon x-axis 0 Velocity Horizontal
Figure 1-5: Aircraft configuration and vertical plane geometry.
1-11
Introduction
You can enter the state-space matrices for this model with the following code:
% NASA HiMAT model G(s) ag =[ -2.2567e-02 -3.6617e+01 -1.8897e+01 -3.2090e+01 9.2572e-05 -1.8997e+00 1.2338e-02 0 0 0 bg = [ 0 0 0 0 30 0 cg = [ 0 0 dg = [ 0 0 0; 0; 0; 0; 0; 30]; 1 0 0; 0]; 0 0 0 1 0 0 0; 0]; 0 0 0 1.1720e+01 -2.6316e+00 1.0000e+00 0 0 3.2509e+00 -7.6257e-01; 2.2396e+01; 0; 0;
9.8312e-01 -7.2562e-04 -1.7080e-01 -4.9652e-03; 8.7582e-04 -3.1604e+01 0 0 0 0 -3.0000e+01
0 -3.0000e+01];
G=ss(ag,bg,cg,dg);
To design a controller to shape the frequency response (sigma) plot so that the system has approximately a bandwidth of 10 rad/s, you can set as your target desired loop shape Gd(s)=10/s, then use loopsyn(G,Gd) to find a loop-shaping controller for G that optimally matches the desired loop shape Gd by typing:
s=zpk('s'); w0=10; Gd=w0/(s+.001); [K,CL,GAM]=loopsyn(G,Gd); % design a loopshaping controller K % Plot the results sigma(G*K,'r',Gd,'k-.',Gd/GAM,'k:',Gd*GAM,'k:',{.1,30}) figure ;T=feedback(G*K,eye(2)); sigma(T,ss(GAM),'k:',{.1,30});grid
The value of = GAM is returned is an indicator of the accuracy to which the optimal loop shape matches your desired loop shape and is an upper bound on the resonant peak magnitude of the closed-loop transfer function T=feedback(G*K,eye(2)). In this case, = 1.6024 = 4 db see Figure 1-6.
1-12
sigma plot
40 30
magnitude, db
desired loop shape G , db d achieved loop shape GK

Gd , db
20 10 0
Gd /, db
10 20 1 10
10
10
frequency rad/s
Figure 1-6: MIMO robust loopshaping with loopsyn(G,Gd).
The achieved loop shape matches the desired target Gd to within about , db.
1-13
Introduction
Model Reduction and Approximation

Complex models are not always required for good control. Yet it is an unfortunate fact that optimization methods (including methods based on H, H2 and -synthesis optimal control theory) generally tend to produce controllers with at least as many states as the plant model. For this reason, the Robust Control Toolbox offers you an assortment of model-order reduction commands that help you to find less-complex, low-order approximations to plant and controller models.
Model Reduction Commands reduce balancmr bstmr hankelmr modreal ncfmr schurmr slowfast stabproj imp2ss
Main interface to model approximation algorithms Balanced truncation model reduction Balanced stochastic truncation model reduction. Optimal Hankel norm model approximations State-space modal truncation/realization Balanced normalized coprime factor model reduction. Schur balanced truncation model reduction State-space slow-fast decomposition State-space stable/anti-stable decomposition Impulse response to state-space approximation
Among the most import types of model reduction methods are minimize bounds on additive, multiplicative, and Normalized Coprime Factor (NCF) model-error. You can access all three of these methods using the command
reduce.
Example: NASA HIMAT Controller Order Reduction

For instance, the NASA HiMAT model considered in the last section has 8-states, and the optimal loopshaping controller turns out to have 16 states. Using model reduction, you can remove at least some of them without
1-14
appreciably affecting stability or closed-loop performance. For controller order reduction, the NCF model reduction is particularly useful, and it works equally well with controllers that have poles anywhere in the complex plane. For the NASA HiMAT design in the last section, you can type
hankelsv(K,'ncf','log');
which will display a logarithmic plot of the NCF hankel singular valuessee Figure 1-8.
10
Hankel SV of Coprime Factors [Nl Ml]
10
10
10 log 10
10
10
10
12
10
14
8 Order
10
12
14
16
Figure 1-7: Hankel Singular Values of Coprime Factorization of K.
Theory says that, without danger of inducing instability, you can confidently discard at least those controller states that have NCF Hankel singular values that are much smaller than ncfmargin(G,K). Compute ncfmargin(G,K) and add it to your Hankel singular values plot.
1-15
Introduction
hankelsv(K,'ncf','log');v=axis; hold on; plot(v(1:2), ncfmargin(G,K)*[1 1],'--'); hold off
10
Hankel SV of Coprime Factors [Nl Ml]
10
10
10
log
10
10
10
10
12
10
14
8 Order
10
12
14
16
Figure 1-8: Five of the 16 NCF hankel singular values of HiMAT controller K are small compared to ncfmargin(G,K).
In this case, you can safely discard 5 of the 16 states of K and compute an 11-state reduced controller by typing
K1=reduce(K,11,'errortype','ncf');
The result is plotted in Figure 1-9.

sigma(G*K1,'b',G*K,'r--',{.1,30});
1-16
50
singular values: openloop GK1 11state reduced K1 GK 16state original K
40
30 Singular Values (dB)
20
10
10
20 1 10
10
Figure 1-9: HiMAT with 11-state controller K1 vs. original 16-state controller K
The picture above shows that low frequency gain is decreased considerably for inputs in one vector direction. Though this does not affect stability, it affects performance. If you wanted to better preserve low-frequency performance, you would discard fewer than 5 of the 16 states of K.
1-17
Introduction
LMI Solvers
At the core of many emergent robust control analysis and synthesis routines are powerful general purpose functions for solving a class of convex nonlinear programming problems known as Linear Matrix Inequalities. The LMI capabilities are invoked by Robust Control Toolbox functions that evaluate worst case performance, as well and functions like hinfsyn and h2hinfsyn. Some of main functions that help you access the LMI capabilities of the Robust Control Toolbox are shown in the table below:.
Specification of LMIs lmiedit setlmis lmivar lmiterm newlmi getlmis
GUI for LMI specification Initialize the LMI description Define a new matrix variable Specify the term content of an LMI Attach an identifying tag to new LMIs Get the internal description of the LMI system
LMI Solvers feasp gevp mincx dec2mat
Test feasibility of a system of LMIs Minimize generalized eigenvalue with LMI constraints Minimize of a linear objective with LMI constraints Convert output of the solvers to values of matrix variables
Evaluation of LMIs/Validation of Results evallmi showlmi
Evaluate for given values of the decision variables Return the left- and right-hand sides of an evaluated LMI
Complete documentation is available in the on-line LMI LAB tutorial.
1-18
Extends Control System Toolbox
Extends Control System Toolbox

The Robust Control Toolbox (RCT) is designed to work with the Control System Toolbox (CST). The RCT extends he capabilities of the CST and leverages off the LTI and plotting capabilities for the CST. The major analysis and synthesis commands in the RCT accept LTI object inputs, e.g., LTI state-space systems produced by commands such as
G=tf(1,[1 2 3]) G=ss([-1 0; 0 -1], [1;1],[1 1],3).
The uncertain system (USS) objects in the RCT generalize the CST LTI SS objects and help ease the task of analyzing and plotting uncertain systems. You can do many of the same algebraic operations on uncertain systems that are possible for LTI objects (multiply, add, invert) and the RCT provides USS uncertain system extensions of CST interconnection and plotting functions like feedback, lft and bode.
1-19
Introduction
About the Authors

Prof. Andy Packard is with the Faculty of Mechanical Engineering at the University of California, Berkeley. His research interests include robustness issues in control analysis and design, linear algebra and numerical algorithms in control problems, applications of system theory to aerospace problems, flight control, and control of fluid flow. Prof. Gary Balas is with the Faculty of the Aerospace Engineering & Mechanics at the University of Minnesota and is president of MUSYN Inc. His research interests include aerospace control systems, both experimental and theoretical. Dr. Michael Safonov is with the Faculty of Electrical Engineering at the University of Southern California. His research interests include control and decision theory. Dr. Richard Chiang is employed by Boeing Satellite Systems, El Segundo, CA. He is a Boeing Technical Fellow and has been working in aerospace industry over 25 years. In his career, Richard has designed three flight control laws, 12 spacecraft attitude control laws, and three large space structure vibration controllers using modern robust control theory and the tools he built in this toolbox. His research interests include robust control theory, model reduction and in-flight system identification. Working in industry instead of academia, Richard serves a unique role in our team, bridging the gap between theory and reality. The Linear Matrix Inequality (LMI) portion of the Robust Control Toolbox was developed by these two authors: Dr. Pascal Gahinet is employed by The MathWorks. His research interests include robust control theory, linear matrix inequalities, numerical linear algebra, and numerical software for control. Prof. Arkadi Nemirovski is with the Faculty of Industrial Engineering and Management at Technion, Haifa, Israel. His research interests include convex optimization, complexity theory, and non-parametric statistics.
1-20
Bibliography
Bibliography
[1] S.P. Boyd and L. El Ghaoui and E. Feron and V. Balakrishnan, Linear Matrix Inequalities in Systems and Control Theory. Philadelphia, PA:SIAM, 1994. [2] P. Dorato (editor), Robust Control. New York: IEEE Press, 1987. [3] P. Dorato and R. K. Yedavalli (editors), Recent Advances in Robust Control. New York: IEEE Press, 1990. [4] J. C. Doyle and G. Stein, Multivariable Feedback Design: Concepts for a Classical/Modern Synthesis, IEEE Trans. on Automat. Contr., AC-26(1):4-16, 1981. [5] L. El Ghaoui and S. Niculescu, Recent Advances in LMI Theory for Control. Philadelphia, PA: SIAM. 2000. [6] N. A. Lehtomaki, N. R. Sandell, Jr., and M. Athans, Robustness Results in Linear-Quadratic Gaussian Based Multivariable Control Designs, IEEE Trans. on Automat. Contr., vol. AC-26, No. 1, pp. 75-92, Feb. 1981. [7] M. G. Safonov, Stability and Robustness of Multivariable Feedback Systems. Cambridge, MA: MIT Press, 1980. [8] M. G. Safonov, A. J. Laub, and G. Hartmann, Feedback Properties of Multivariable Systems: The Role and Use of Return Difference Matrix, IEEE Trans. of Automat. Contr., AC-26(1):47-65, 1981. [9] M. G. Safonov, R. Y. Chiang and H. Flashner, H Control Synthesis for a Large Space Structure, Proc. of American Contr. Conf., Atlanta, GA. June 15-17, 1988. [10] M. G. Safonov and R. Y. Chiang, CACSD Using the State-Space L Theory A Design Example, IEEE Trans. on Automatic Control, AC-33(5):477-479, 1988. [11] R. S. Sanchez-Pena and M. Sznaier, Robust Systems Theory and Applications. New York: Wiley, 1998. [12] S. Skogestad and I. Postlethwaite, Multivariable Feedback Control. New York: Wiley, 1996.
1-21
Introduction
[13] B. Wie and D. S. Bernstein, A Benchmark Problem for Robust Controller Design, Proc. American Control Conf., San Diego, CA May 23-25, 1990; also Boston, MA, June 26-28, 1991. [14] K. Zhou, J. C. Doyle and K. Glover, Robust and Optimal Control. Englewood-Cliffs, NJ: Prentice Hall, 1996.
1-22
2
Tradeoff between Performance and Robustness (p. 2-2) Typical loop shapes, S and T Design (p. 2-5)
Singular values, disturbance attenuation and robustness Sigma plot design specifications (loop shape, sensitivity, and complementary sensitivity)
Using LOOPSYN to do H-Infinity Loop Synthesis of MIMO H optimal loopshaping controllers: Shaping (p. 2-11) LOOPSYN method and HiMAT aircraft example Using MIXSYN for H-Infinity Loop Shaping (p. 2-18) Loop Shaping Commands (p. 2-21) Synthesis of MIMO H optimal loopshaping controllers: MIXSYN method and HiMAT aircraft example Summary of loop shaping commands and utilities
Tradeoff between Performance and Robustness

When the plant modeling uncertainty is not too big, you can design high-gain, high-performance feedback controllers. High loop gains significantly larger than one in magnitude can attenuate the effects of plant model uncertainty and reduce the overall sensitivity of the system to plant noise. But if your plant model uncertainty is so large that you do not even know the sign of your plant gain, then you cannot use large feedback gains without the risk that the system will become unstable. Thus, plant model uncertainty can be a fundamental limiting factor in determining what can be achieved with feedback.
Multiplicative Uncertainty: Given an approximate model of the plant G0 of a plant G, the multiplicative uncertainty M of the model G0 is defined 1 as M = G 0 ( G G 0 ) or, equivalently G = ( I + M )G 0 . Plant model uncertainty arises from may sources. There may be small unmodelled time-delays or stray electrical capacitance. Imprecisely understood actuator time constants, or, in mechanical systems, high frequency torsional bending modes, and similar effects can be responsible for plant model uncertainty. These types of uncertainty are relatively small at lower frequencies and typically increase at higher frequencies. In the case of single-input-single-output (SISO) plants, the frequency at which there are uncertain variations in your plant of size|M|=2 marks a critical threshold beyond which there is insufficient information about the plant to reliably design a feedback controller. With such a 200% model uncertainty, the model provides no indication of the phase angle of the true plant, which means that the only way you can reliably stabilize your plant is to ensure that the loop gain is less than one. Allowing for an additional factor of 2 margin for error, your control system bandwidth is essentially limited to the frequency range over which your multiplicative plant uncertainty M has gain magnitude |M|<1.
Norms and Singular Values

For MIMO systems the transfer functions are matrices and relevant measures of gain are determined by singular values, H and H2 norms which are defined as follows:
2-2
Tradeoff between Performance and Robustness
H2 and H norms. The H2-norm is the energy of the impulse response of plant G. The H-norm is the peak gain of G across all frequencies and all input directions.
Another important concept is the notion of singular values. Singular Values: The singular values of a rank r matrix A C , denoted i , are the non-negative square-roots of the eigenvalues of A * A ordered such that 1 2 p > 0, p min { m , n } . If r < p then there are p r zero singular values, i.e., r + 1 = r + 2 = = p = 0 then the greatest singular value 1 is sometimes denoted ( A ) = 1 . When A is a square n-by-n matrix, then the n-th singular value (i.e., the least singular value) is denoted ( A ) = n
mn
Properties of Singular Values

Some useful properties of singular values are 1 ( A ) = max x C n ----------x Ax Ax
2 ( A ) = min x C n ----------x Properties 1 and 2 are especially important because they establish that the greatest and least singular values of a matrix A as the maximal and minimal gains of the matrix as the input vector x varies over all possible directions. For stable continuous-time LTI systems G ( s ) , the H2-norm and the H-norms are defined terms of the frequency-dependent singular values of G ( j ) :
2-3
H2-norm: G 2 = H-norm
1 -----2
( i ( G ( j ) ) )
i=1
p 2
G = sup ( G ( j ) )
( sup: the least upper bound ) :
2-4
Typical loop shapes, S and T Design

Consider the multivariable feedback control system shown in Figure 2-1, Block diagram of the multivariable feedback control system. In order to quantify the multivariable stability margins and performance of such systems, you can use the singular values of the closed-loop transfer function matrices from r to each of the three outputs e, u and y, viz.
S( s ) = ( I + L ( s ) )
def
def
1 1 1
R( s ) = K ( s ) ( I + L ( s ) ) T( s ) = L ( s ) ( I + L ( s ) )
def
= I S( s)
where the L(s) is the loop transfer function matrix L ( s ) = G ( s )K ( s ) .

d plant disturbance effects + +
(2-1)
command r
error e -
K(s)
control u
G(s)
output y
"controller" "plant"
Figure 2-1: Block diagram of the multivariable feedback control system.
The two matrices S(s) and T(s) are known as the sensitivity function and complementary sensitivity function, respectively. The matrix R(s) has no common name. The singular value Bode plots of each of the three transfer function matrices S(s), R(s), and T(s) play an important role in robust multivariable control system design. The singular values of the loop transfer function matrix L(s) are important because L(s) determines the matrices S(s) and T(s).
2-5
Singular Values
The singular values of S(j) determine the disturbance attenuation since S(s) is in fact the closed-loop transfer function from disturbance d to plant output y see Figure 2-1. Thus a disturbance attenuation performance specification may be written as ( S ( j ) ) W 1 ( j ) where W 1 ( j ) is the desired disturbance attenuation factor. Allowing W 1 ( j ) to depend on frequency enables you to specify a different attenuation factor for each frequency . The singular value Bode plots of R(s) and of T(s) are used to measure the stability margins of multivariable feedback designs in the face of additive plant perturbations A and multiplicative plant perturbations M , respectively. See Figure 2-2. Let us consider how the singular value Bode plot of complementary sensitivity T(s) determines the stability margin for multiplicative perturbations M . The multiplicative stability margin is, by definition, the size of the smallest stable M (s) which destabilizes the system in Figure 2-2 when A = 0 .
1 1
(2-2)
PERTURBED PLANT
A(s)
K(s)
G(s)
+ A(s)
Figure 2-2: Additive/Multiplicative uncertainty.
2-6
Taking ( M ( j ) ) to be the definition of the size of M ( j ) , you have the following useful characterization of multiplicative stability robustness:
Multiplicative Robustness The size of the smallest destabilizing multiplicative uncertainty M (s) is 1 ( M ( j ) ) = ---------------------- ( T ( j ) )
The smaller is ( T ( j ) ) , the greater will be the size of the smallest destabilizing multiplicative perturbation, and hence the greater will be the stability margin. A similar result is available for relating the stability margin in the face of additive plant perturbations A (s) to R(s) if we take ( A ( j ) ) to be our definition of the size of ( A ( j ) ) at frequency . Additive Robustness The size of the smallest destabilizing additive uncertainty A is 1 ( A ( j ) ) = ----------------------- ( R ( j ) )
As a consequence of Robustness Theorems 1 and 2, it is common to specify the stability margins of control systems via singular value inequalities such as ( R { j } ) W 2 ( j ) ( T { j } ) W 3 ( j ) where W 2 ( j ) and W 3 ( j ) are the respective sizes of the largest anticipated additive and multiplicative plant perturbations.
1 1
(2-3) (2-4)
2-7
It is common practice to lump the effects of all plant uncertainty into a single fictitious multiplicative perturbation M , so that the control design requirements may be written 1 ------------------------- W 1 ( j ) ; i ( S ( j ) ) as shown in Figure 2-3. It is interesting to note that in the upper half of Figure 2-3 (above the zero db line) 1 ( L ( j ) ) ---------------------- ( S ( j ) ) while in the lower half of Figure 2-3 below the zero db line ( L ( j ) ) ( T ( j ) ) This results from the fact that S( s ) = ( I + L ( s ) )
def def 1
i ( T [ j ] ) W 3 ( j )
L(s) ,
1
if ( L ( s ) ) 1 if ( L ( s ) ) 1
T s) = L(s)( I + L(s)) (
L ( s ),
2-8
o(L)
|Gd| DESIRED LOOPSHAPE
|W | 1 0 db PERFORMANCE BOUND
o(T)
1 o(S) o(L)
DESIRED CROSSOVER c
ROBUSTNESS BOUND -1 |W | 3
Figure 2-3: Singular value specifications on L, S and T.
Thus, it is not uncommon to see specifications on disturbance attenuation and multiplicative stability margin expressed directly in terms of forbidden regions for the Bode plots of i ( L ( j ) ) as singular value loop shaping requirements, either as specified upper/lower bounds or as a target desired loop shape see Figure 2-3
Guaranteed Gain/Phase Margins in MIMO Systems

For those who are more comfortable with classical single-loop concepts, there are the important connections between the multiplicative stability margins predicted by ( T ) and those predicted by classical M-circles, as found on the Nichols chart. Indeed in the single-input-single-output case L ( j ) ( T ( j ) ) = -----------------------1 + L ( j ) which is precisely the quantity you obtain from Nichols chart M-circles. Thus, T is a multiloop generalization of the closed-loop resonant peak magnitude
2-9
which, as classical control experts will recognize, is closely related to the damping ratio of the dominant closed-loop poles. Also, it turns out that you may relate T , S to the classical gain margin GM and phase margin M in each feedback loop of the multivariable feedback system of Figure 2-1, Block diagram of the multivariable feedback control system. via the formulae [6] 1 G M 1 + ----------T 1 G M 1 + ---------------------------11 S 1 1 M 2 sin --------------- 2 T 1 1 M 2 sin --------------- . 2 S These formula are valid provided S and T are larger than one, as is normally the case. The margins apply even when the gain perturbations or phase perturbations occur simultaneously in several feedback channels. The infinity norms of S and T also yield gain reduction tolerances. The gain reduction tolerance gm is defined to be the minimal amount by which the gains in each loop would have to be decreased in order to destabilize the system. Upper bounds on gm are 1 g m 1 ----------T 1 g m ---------------------------1+1 S
2-10
Using LOOPSYN to do H-Infinity Loop Shaping
Using LOOPSYN to do
H-Infinity Loop Shaping
The command loopsyn lets you design a stabilizing feedback controller to optimally shape the open loop frequency response of MIMO feedback control system to match as closely as possible a desired loop shape Gdsee Figure 2-3. The basic syntax of the loopsyn loopshaping controller synthesis command is
K = LOOPSYN(G,Gd)
Here G is the LTI transfer function matrix of a MIMO plant model, Gd is the target desired loop shape for the loop transfer function L=G*K, and K is the optimal loop shaping controller. The LTI controller K has the property that it shapes the loop L=G*K so that it matches the frequency response of Gd as closely as possible, subject to the constant that the must stabilize the plant model G.
Example: NASA HiMAT loop-shaping

To see how the loopsyn command works in practice to address robustness and performance tradeoffs, lets consider again the NASA HiMAT aircraft model taken from the paper of Safonov, Laub and Hartmann [8]. The longitudinal dynamics of the HiMAT aircraft trimmed at 25000 ft and 0.9 Mach are unstable and have two right half plane phugoid modes. The linear model has 1 state-space realization G ( s ) = C ( Is A ) B with 6 states, with the first four states representing angle of attack () and attitude angle () and their rates of change, and the last two representing elevon and canard control actuator dynamicssee Figure 2-4.
ag =[ -2.2567e-02 -3.6617e+01 -1.8897e+01 -3.2090e+01 3.2509e+00 -7.6257e-01; 9.2572e-05 -1.8997e+00 9.8312e-01 -7.2562e-04 -1.7080e-01 -4.9652e-03; 1.2338e-02 1.1720e+01 -2.6316e+00 8.7582e-04 -3.1604e+01 2.2396e+01; 0 0 1.0000e+00 0 0 0; 0 0 0 0 -3.0000e+01 0; 0 0 0 0 0 -3.0000e+01]; bg = [0 0; 0 0; 0 0; 0 0; 30 0; 0 30]; cg = [0 1 0 0 0 0; 0 0 0 1 0 0]; dg = [0 0; 0 0]; G=ss(ag,bg,cg,dg);
2-11
The control variables are elevon and canard actuators (e and c). The output variables are angle of attack () and attitude angle ().
.
Aileron Canard Flap Rudder
Elevator Elevon x-axis 0 Velocity Horizontal
Figure 2-4: Aircraft configuration and vertical plane geometry.
This model is good at frequencies below 100 rad/s with less than 30% variation between the true aircraft and the model in this frequency range. However as noted in [8], it does not reliably capture very high frequency behaviors, since it was derived by treating the aircraft as a rigid body and neglecting lightly damped fuselage bending modes that occur at somewhere between 100 and 300 rad/sec. These unmodelled bending modes might cause as much as 20 db deviation (i.e., 1000%) between the frequency response of the model and the actual aircraft for frequency > 100 rad/sec. Other effects like control actuator time-delays and fuel sloshing also contribute to model inaccuracy at even higher frequencies, but the dominant unmodelled effects are the fuselage bending modes. You can think of these unmodelled bending modes as multiplicative uncertainty of size 20db, and design your controller using loopsyn, by making sure that the loop has gain less than -20 db at, and beyond, the frequency > 100 rad/sec.
2-12
Design Specifications
The singular value design specifications are:
1 Robustness Spec.: 20 db/decade roll-off slope and 20 db loop-gain at 100
rad/sec
2 Performance Spec.: Maximize the sensitivity function as much as possible.
Both specs can be accommodated by taking as the desired loop shape Gd(s)=8/s.
MATLAB Commands for a LOOPSYN design

%% Enter the desired loop shape Gd s=zpk('s'); % Laplace variable s Gd=8/s; % desired loop shape %% Compute the optimal loop shaping controller K [K,CL,GAM]=loopsyn(G,Gd); %% Compute the loop L, sensitivity S and %% complementary sensitivity T: L=G*K; I=eye(size(L)); S=feedback(I,L); % S=inv(I+L); T=I-S; %% Plot the results: % step response plots step(T);title('\alpha and \theta command step responses'); % frequency response plots figure; sigma(I+L,'--',T,':',L,'r--',Gd,'k-.',Gd/GAM,'k:',... Gd*GAM,'k:',{.1,100});grid legend('1/\sigma(S) performance',... '\sigma(T) robustness',... '\sigma(L) loopshape',... '\sigma(Gd) desired loop',... '\sigma(Gd) \pm GAM, db');
2-13
The plots of the resulting step and frequency response for the NASA HiMAT loopsyn loop shaping controller design are shown in below in Figure 2-6. The number GAM,db (i.e., 20log10(GAM) tells you the accuracy that your loopsyn control design matches the target desired loop:, ( GK ), db G d , db - GAM, db ( GK ), db G d , db + GAM, db for < c for > c .
From: In(1) 1.5 To: Out(1) 1 0.5 0 1.5 To: Out(2) 1 0.5 0 0
From: In(2)
10
10
Figure 2-5: HiMAT closed loop step responses
2-14
50 40 30 Singular Values (dB) 20 10 0 10 20 30 40 1 10

0
Singular Values (L) loopshape (Gd) desired loop (Gd) GAM, db
10 10 Frequency (rad/sec) Singular Values
10
40 30 Singular Values (dB) 20 10 0 10 20 30 40 1 10

0
(T) robustness 1/(S) performance
10 10 Frequency (rad/sec)
10
Figure 2-6: LOOPSYN design results for NASA HiMAT
2-15
Fine tuning the LOOPSYN target loop shape Gd to meet design goals.
If your first attempt at loopsyn design does not achieve everything you wanted, you will need to re-adjust you target desired loop shape Gd. Here are some basic design trade-offs to consider:
1 Stability Robustness. Your target loop Gd should have low gain (as small
as possible) at high frequencies where typically your plant model is so poor that you its phase angle is completely inaccurate with errors approaching 180 or more.
2 Performance. Your loop Gd loop should have high gain (as great as
possible) at frequencies where you model is good in order to assure good control accuracy and good disturbance attenuation.
3 Crossover and Roll-Off. Your desired loop shape Gd should have its 0db
crossover frequency (denoted c) between the above two frequency ranges and, below the crossover frequency c, it should roll-off with a negative slope of between -20 and -40 db/decade, which helps to keep phase lag to less than -180 inside the control loop bandwidth (0 < < c). Other considerations that might affect your choice of Gd are the right-half-plane poles and zeros of the plant G, which impose fundamental limits on your 0db crossover frequency c [12]. For instance, your 0db crossover c must be greater than the magnitude of any plant right-half-plane poles and less than the magnitude of any right-half-plane zeros If do not take care to
max
Re(p i) > 0
pi < c <
min
Re(z i) > 0
zi .
choose target loop shape Gd that conforms to these fundamental constraints, then loopsyn will still compute the optimal loopshaping controller K for your Gd but you should expect that the optimal loop L=G*K will have a poor fit to the
2-16
target loop shape Gd and consequently it may be impossible to meet your performance goals.
2-17
Using MIXSYN for H-Infinity Loop Shaping

A popular alternative approach to loopsyn loop-shaping is the H mixed-sensitivity loop-shaping, which is implemented by the Robust Control Toolbox command
K=mixsyn(G,W1,[],W3)
With mixsyn controller synthesis, your performance and stability robustness specifications equations (2-2) and (2-4) are combined into a single infinity norm specification of the form T y1u1 1 where (see Figure 2-7) T y1 u1 =
def
W1 S . W3 T
The term T y1u1 is called a mixed-sensitivity cost function because it penalizes both sensitivity S(s) and complementary sensitivity T(s). Loop shaping is achieved when you choose W1 to have the target loop shape for frequencies < c, and you choose 1/W3 to be the target for > c. In choosing design specifications W1 and W3 for a mixsyn controller design, you need to take care to be sure that your 0 db crossover frequency for the Bode plot of W1 is below the 0 db crossover frequency of 1/W3 as shown in Figure 2-3, so that there is a gap for the desired loop shape Gd to pass between the performance bound
2-18
Using MIXSYN for H-Infinity Loop Shaping
W1 and your robustness bound W 3 . Otherwise, or your performance and robustness requirements will not be achievable.
AUGMENTED PLANT P(s) AUGMENTED PLANT P(s) W W1W 11 W 1 ++ u 11 uu 22 yy 22 -uu yy G G yy 1a1a
yy 11
ee GG W3 W3
W3 W3
yy
1b 1b
CONTROLLER CONTROLLER F(s) F(s)
K K
Figure 2-7: MIXSYN H mixed-sensitivity loopshaping Ty1 u1.
Example: NASA HiMAT design using MIXSYN

To do a mixsyn H mixed-sensitivity synthesis design on the HiMAT model, start with the plant model G created in Example: NASA HiMAT loop-shaping on page 2-11 and type the following commands:
% Set up the performance and robustness bounds W1 & W3 s=zpk('s'); % Laplace variable s MS=2;AS=.03;WS=5; W1=(s/MS+WS)/(s+AS*WS); MT=2;AT=.05;WT=20; W3=(s+WT/MT)/(AT*s+WT); % Compute the H-infinity mixed-sensitivity optimal sontroller K1 [K1,CL1,GAM1]=mixsyn(G,W1,[],W3); % Next compute an plot the closed-loop system. % Compute the loop L1, sensitivity S1 and comp sensitivity T1: L1=G*K1; I=eye(size(L1)); S1=feedback(I,L1); % S=inv(I+L1); T1=I-S1; % Plot the results:
2-19
% step response plots step(T1,1.5); title('\alpha and \theta command step responses'); % frequency response plots figure; sigma(I+L1,'--',T1,':',L1,'r--',... W1/GAM1,'k--',GAM1/W3,'k-.',{.1,100});grid legend('1/\sigma(S) performance',... '\sigma(T) robustness',... '\sigma(L) loopshape',... '\sigma(W1) performance bound',... '\sigma(1/W3) robustnes bound');
The resulting mixsyn singular value plots for the are shown below.
40 30 Singular Values (dB) 20 10 0 10 20 30 1 10
Singular Values 1/(S) performance (T) robustness (L) loopshape (W1) performance bound (1/W3) robustnes bound
10
Figure 2-8: MIXSYN design results for NASA HiMAT
2-20
Loop Shaping Commands
Loop Shaping Commands

The Robust Control Toolbox gives you several choices for shaping the frequency response properties of multi-input-multi-output (MIMO) feedback control loops. Some of the main commands that you are likely to use for loop shaping design, and associated utility functions, are listed below::
MIMO loop shaping commands loopsyn ltrsyn mixsyn ncfsyn
H loop shaping controller synthesis LQG loop-transfer recovery H mixed-sensitivity controller synthesis Glover-McFarlane H normalized coprime factor loop shaping controller synthesis
MIMO loop shaping utility functions augw
Augmented plant for weighted H2 and H mixed sensitivity control synthesis Weights for H-infinity mixed sensitivity (mixsyn, augw) Singular value plots of LTI feedback loops
makeweight sigma
2-21
2-22
3
Introduction (p. 3-2) Overview of Model Reduction Techniques (p. 3-4) Approximating Plant Models -- Additive Error Methods (p. 3-6) Approximating Plant Models -- Multiplicative Error Method (p. 3-8) Using Modal Algorithms (p. 3-10) Reducing Large Scale Models (p. 3-13)
Motivations, Hankel singular values Hankel singular value based model reduction routines and their Error Bounds Robust Frequency. Rigid body dynamics. Large size plant. Examples. The multiplicative error method is presented, followed by a comparison between additive and multiplicative methods How to keep the j-axis poles of a plant during model reduction Strategies for reducing very large plant models
Using Normalized Coprime Model order reduction examples Factor Methods (p. 3-14) References (p. 3-15) Sources for model reduction theory
Introduction
In the design of robust controllers for complicated systems, model reduction arises in several places:
1 It is desirable to simplify the best available model in light of the purpose to
which the model is to be used namely, to design a control system to meet certain specifications.
2 To speed up the simulation process in design validation stage, using a
smaller size model with most of the system important dynamics preserved is highly desirable.
3 Finally, if a modern control method such as LQG or H is employed for
which the complexity of the control law is not explicitly constrained, the order of the resultant controller is likely to be considerably greater than is truly needed. A good model reduction algorithm applied to the control law can sometimes significantly reduce control law complexity with little change in control system performance. Model reduction routines in this toolbox can be put into two categories:
1 Additive error method: reduced order model has an additive error
bounded by an error criterion.

2 Multiplicative error method: reduced order model has a multiplicative or
relative error bounded by an error criterion. The error is measured in terms of peak gain across frequency (H norm) and the error bounds are a function of the neglected Hankel singular values.
Hankel Singular Values

In control theory, eigenvalues define a system stability, whereas Hankel singular values define the energy of each state in the system. Keeping larger energetic states of a system preserves most of its characteristics in terms of stability, frequency and time responses. Model reduction techniques presented here are all based on the Hankel singular values of a system. They can achieve a reduced order model that preserves the majority of the system characteristics.
3-2
Introduction
Mathematically, given a stable state-space system (A,B,C,D), its Hankel singular values are defined as [1] H = i ( PQ )
T
where P and Q are Controllability and Observability Grammians satisfying AP + PA

T
= BB
T
A Q + QA = C C For example,
rand('state',1234); randn('state',5678); G = rss(30,4,3); hankelsv(G)
returns a Hankel singular value plot as follows
Hankel Singular Value 10
6 abs
10
15 Order
20
25
30
35
which shows that system G has most of its energy stored in states 1 through 15 or so. We will show later on using model reduction routines to keep a15-state reduced model will preserve most of its dynamic response.
3-3
Overview of Model Reduction Techniques

The Robust Control Toolbox offers several algorithms for model approximation and order reduction. These algorithms let you control the absolute or relative approximation error, and are all based on the Hankel singular values of the system. As discussed in previous sections, robust control theory quantifies a system uncertainty as either Additive or Multiplicative types. These model reduction routines are also categorized into two groups: Additive Error and Multiplicative Error types. In other words, some model reduction routines produce a reduced order model Gred of the original model G with a bound on the error G Gred , the peak gain across frequency. Others produce a reduced order model with a bound on the relative error G ( G Gred ) . These theoretical bounds are based on the tails of the Hankel Singular Values of the model, i.e.,
1
Additive Error Bound: [1]

n
G Gred 2 where i are denoted the i

th
i
k+1
Hankel singular value of the original system G.
Multiplicative (Relative) Error Bound: [2]

n
G ( G Gred )
( 1 + 2i (
k+1
2 1 + i + i ) ) 1
where i are denoted the ith Hankel singular value of the phase matrix of the model G (see reference page on bstmr).
Table 3-1: Top Level Model Reduction Command Method reduce Description
Main interface to model approximation algorithms
3-4
Overview of Model Reduction Techniques
Table 3-2: Normalized Coprime Balanced Model Reduction command Method ncfmr Description
Normalized coprime balanced truncation
Table 3-3: Additive Error Model Reduction commands Method balancmr schurmr hankelmr Description
Square-root balanced model truncation Schur balanced model truncation Hankel minimum degree approximation
Table 3-4: Multiplicative Error Model Reduction command Method bstmr Description
Balanced stochastic truncation
Table 3-5: Additional Model Reduction Tools

Method modreal slowfast stabproj Description
Modal realization and truncation Slow and fast state decomposition Stable and anti-stable state projection
3-5
Approximating Plant Models -- Additive Error Methods

Given a system in LTI form, the following commands reduce the system to any desired order as one specifies. The judgement call has based on its Hankel Singular Values as shown in previous paragraph.
rand('state',1234); randn('state',5678); G = rss(30,4,3); % balanced truncation to models with sizes 12:16 [g1,info1] = balancmr(G,12:16); % or use reduce % Schur balanced truncation by specifying `MaxError' [g2,info2] = schurmr(G,'MaxError',[1,0.8,0.5,0.2]); sigma(G,'b-',g1,'r--',g2,'g-.')
shows a comparison plot of the original model G, reduced models g1 and g2.
30
Singular Values G gr g2
25
20
15
Singular Values (dB)
10
10 4 10
10
10
10
10
10
To check whether the theoretical error bound is satisfied:

norm(G-g1(:,:,1),'inf') % 2.0123 info1.ErrorBound(1) % 2.8529
or plot the model error vs. error bound via the following commands
3-6
Approximating Plant Models -- Additive Error Methods
[sv,w] = sigma(G-g1(:,:,1)); loglog(w,sv,w,info1.ErrorBound(1)*ones(size(w))) xlabel('rad/sec');ylabel('SV'); title('Error Bound and Model Error')
10
Error Bound and Model Error
10
10
SV
10
2
10
10
10
10
10
10 rad/sec
10
10
10
3-7
Approximating Plant Models -- Multiplicative Error Method

In most cases, Multiplicative Error model reduction method bstmr tends to bound the relative error between the original and reduced order models across the frequency range of interests, hence producing more accurate reduced order model than the Additive Error methods. This characteristics is obviously shown in system models with low damped poles. The following commands illustrate the significance of a multiplicative error model reduction method as compared to any additive error type. Clearly the phase matching algorithm using bstmr provides a better fit in the Bode plot.
rand('state',1234); randn('state',5678); G = rss(30,1,1); [gr,infor] = reduce(G,'algo','balance','order',7); [gs,infos] = reduce(G,'algo','bst','order',7); figure(1);bode(G,'b-',gr,'r--'); title('Additive Error Method') figure(2);bode(G,'b-',gs,'r--'); title('Relative Error Method')
10 5 0 5
Additive Error Method
Magnitude (dB) Phase (deg)
10 15 20 25 30 35 40 135 90 45 0 45 90 135 10
2
10
10
10
3-8
Approximating Plant Models -- Multiplicative Error Method
20
Relative Error Method
10
10
20
30
40 180 135 90 45 0 45 90 135 10

2
10
10
10
Therefore, for some systems with low damped poles/zeros, Balanced Stochastic Method (bstmr) produces a better reduced order model fit in those frequency range to make multiplicative error small. Whereas additive error methods such as balancmr, schurmr, or hankelmr only care about minimizing the overall absolute peak error, may produce a reduced order model missing those low damped poles/zeros frequency regions.
3-9
Using Modal Algorithms

Rigid Body Dynamics
In many cases, a models j-axis poles are important to keep after model reduction, e.g., rigid body dynamics of a flexible structure plant or integrators of a controller, then a unique routine modreal serves the purpose nicely.
modreal puts a system into its Modal Form with eigenvalues appearing on the
diagonal of its A-matrix. Real eigenvalues will appear in 1x1 blocks, and complex eigenvalues will appear in 2x2 real blocks. All the blocks will be ordered in ascending order based on their eigenvalues magnitudes by default or descending order based on their real parts. Therefore, specifying the number of j-axis poles splits the model into two systems with one containing only j-axis dynamics, the other containing the non-j axis dynamics.
rand('state',5678); randn('state',1234); G = rss(30,1,1); [Gjw,G2] = modreal(G,1); % only one rigid body dynamics G2.d = Gjw.d; Gjw.d = 0; % put DC gain of G into G2 subplot(211);sigma(Gjw);ylabel('Rigid Body') subplot(212);sigma(G2);ylabel('Non-Rigid Body')
Further model reduction can be done on G2 without any numerical difficulty. After G2 is further reduced to Gred, the final approximation of the model is simply Gjw+Gred.
3-10
Using Modal Algorithms
This process of splitting j-axis poles has been built-in and automated in all the model reduction routines (balancmr, schurmr, hankelmr, bstmr, hankelsv) so that users need not to worry about splitting the model to begin with. The following single command creates a size 8 reduced order model from its original 30-state model:
rand('state',5678); randn('state',1234); G = rss(30,1,1); [gr,info] = reduce(G); % choose a size of 8 at prompt bode(G,'b-',gr,'r--')
Without specifying the size of the reduced order model, a Hankel singular value plot will be shown as follows
Hankel Singular Values (1 of jwaxis pole(s) = inf, not shown) 4 3.5 3 2.5
abs
2 1.5 1 0.5 0
10
15 Order
20
25
30
35
3-11
30 25 20 15
Bode Diagram
Original G (30state) Gred (8state)
10 5 0 5 10 15 20 720 630 540 450 360 270 180 10

2
10
10
10
10
The default algorithm balancmr of reduce has done a great job of approximating a 30-state model with just 8-state. Again, the rigid body dynamics has been preserved for further controller design.
3-12
Reducing Large Scale Models
Reducing Large Scale Models

For some really large size problems (states > 200), modreal turns out to be the only way to start the model reduction process. Because of the size and numerical properties associated with those large size, and low damped dynamics, most Hankel based routines can fail to produce a good reduced order model.
modreal puts the large size dynamics into the modal form, then truncates the
dynamic model to a intermediate stage model with a comfortable size of 50-state or so. From this point on, those more sophisticate Hankel singular value based routines can further reduce this intermediate stage model in a much more accurate fashion to a smaller size for final controller design. For a typical 240-state flexible spacecraft model in spacecraft industry, applying modreal and bstmr (or any other additive routines) in sequence can reduce the original 240-state plant dynamics to a 7-state 3-axis model including rigid body dynamics. Any modern robust control design technique mentioned in this toolbox can then be easily applied to this smaller size plant for a controller design.
3-13
Using Normalized Coprime Factor Methods

A special model reduction routine ncfmr produces a reduced order model by truncating a balanced coprime set of a given model. It can directly simplify a modern controller with integrators to a smaller size by balanced truncation of the normalized coprime factors. It does not need modreal for pre/post processing like the other routines do. However, the integrators will not be preserved afterwards.
rand('state',5678); randn('state',1234); K= rss(30,4,3); % The same model G used in the 1st example [Kred,info2] = ncfmr(K); sigma(K,Kred)
Again, without specifying the size of the reduced order model, any model reduction routine presented here will plot a Hankel singular value bar chart and prompt for user decision for a reduced model size. In this case, enter 15.
120
Singular Values Original K (30state) Kred (15state)
100
80
60
40
20
20
10
10
10
10
10
10
10
If integral control is important, previously mentioned methods (except ncfmr) can nicely preserve the original integrator(s) in the model.
3-14
References
References
[15] K. Glover, All Optimal Hankel Norm Approximation of Linear Multivariable Systems, and Their L - error Bounds, Int. J. Control, vol. 39, no. 6, pp. 1145-1193, 1984. [16] K. Zhou, J. C. Doyle and K. Glover, Robust and Optimal Control. Englewood-Cliffs, NJ: Prentice Hall, 1996. [17] M. G. Safonov and R. Y. Chiang, A Schur Method for Balanced Model Reduction, IEEE Trans. on Automat. Contr., vol. 34, no. 7, July 1989, pp. 729-733. [18] M. G. Safonov and R. Y. Chiang, and D. J. N. Limebeer, Optimal Hankel Model Reduction for Nonminimal Systems, IEEE Trans. on Automat. Contr., vol. 35, no. 4, April 1990, pp. 496-502. [19] M. G. Safonov and R. Y. Chiang, Model Reduction for Robust Control: A Schur Relative Error Method, International J. of Adaptive Control and Signal Processing, vol. 2, 259-272 (1988). [20] G. Obinata and B. D. O. Anderson, Model Reduction for Control System Design. London: Springer-Verlag, 2001.
3-15
3-16
4
Robustness Analysis
Uncertainty Modeling (p. 4-2) Robustness Analysis (p. 4-8) Multi-Input, Multi-Output Robustness Analysis (p. 4-12) Worst-Case Gain Analysis (p. 4-20) What is uncertainty modeling? Why is it important? Designing and comparing various controllers Creating and analyzing uncertain MIMO models How to perform worst-case gain analysis
Summary of Robustness Analysis Tools Tables of functions available for robust control (p. 4-23)
Robustness Analysis
Uncertainty Modeling
Dealing with, and understanding the effects of uncertainty are important tasks of the control engineer. Reducing the effect of some forms of uncertainty (initial conditions, low frequency disturbances) without catastrophically increasing the effect of other dominant forms (sensor noise, model uncertainty) is the primary job of the feedback control system. Closed-loop stability is the manner in which we deal with the (always present) uncertainty in initial conditions, or arbitrarily small disturbances. High-gain feedback in low frequency ranges is a typical manner in which we deal with the effect of unknown biases and disturbances acting on the process output. Roll-off filters in high-frequency ranges is how we are then forced to deal with high-frequency sensor noise in a feedback system. Finally, notions such as gain and phase margins (and their generalizations) help us quantify the sensitivity of the above ideas (stability and performance) in the face of model uncertainty, which is the imprecise knowledge of how the control input directly affects the feedback variables. The Robust Control Toolbox has built-in features allowing you to specify model uncertainty in a simple and natural manner. The primary building blocks, called uncertain elements or atoms, are uncertain real parameters and uncertain linear, time-invariant objects. These can be used to create coarse and simple or detailed and complex descriptions of the model uncertainty present within your process models. Once formulated, high-level system robustness tools can help you analyze the potential degradation of stability and performance of the closed-loop system brought on by the system model uncertainty.
Creating Uncertain Models of Dynamic Systems

The two dominant forms of model uncertainty are:
1 Uncertainty in parameters of the underlying differential equation models,
and
2 Frequency-domain uncertainty, which often quantifies model uncertainty
by describing absolute or relative uncertainty in the processs frequency response.
4-2
Using these two basic building blocks, along with conventional system creation commands (such as ss and tf), you can easily create uncertain system models.
Creating Uncertain Parameters

An uncertain parameter has a name (used to identify it within an uncertain system with many uncertain parameters) and a nominal value. Being uncertain, it also has variability, described in either one of the following manners an additive deviation from the nominal, a range about the nominal, or a percentage deviation from the nominal. Create a real parameter, with name 'bw', nominal value 5, and a percentage uncertainty of 10%.
bw = ureal('bw',5,'Percentage',10)
This creates a ureal object. View its properties using the get command
Uncertain Real Parameter: Name bw, NominalValue 5, variability = [-10 10]% get(bw) Name: 'bw' NominalValue: 5 Mode: 'Percentage' Range: [4.5000 5.5000] PlusMinus: [-0.5000 0.5000] Percentage: [-10 10] AutoSimplify: 'basic'
Note that the range of variation (Range property) and the additive deviation from nominal (the PlusMinus property) are consistent with the Percentage property value. You can create state-space and transfer function models with uncertain real coefficients using ureal objects. The result is a uncertain state-space object, or uss. As an example, use the uncertain real parameter bw to model a first order system whose bandwidth is between 4.5 and 5.5 rad/s.
H = tf(1,[1/bw 1]) USS: 1 State, 1 Output, 1 Input, Continuous System
4-3
Robustness Analysis
bw: real, nominal = 5, variability = [-10
10]%, 1 occurrence
Note that the result H is an uncertain system, called a uss object. The nominal value of H is a state-space object. Verify that the pole is at -5.
pole(H.NominalValue) ans = -5
Next, use bode and step to examine the behavior of H.

bode(H,{1e-1 1e2});
0 Bode Diagram
10
15
20
25
30 0
45
90 10
1
10
10
4-4
step(H)
1 Step Response
0.9
0.8
0.7
0.6
Amplitude
0.5
0.4
0.3
0.2
0.1
0.5 Time (sec)
1.5
While there are variations in the bandwidth and time constant of H, the high-frequency rolls off at 20 dB/decade regardless of the value of bw. You can capture the more complicated uncertain behavior that typically occurs at high frequencies using the ultidyn uncertain element which is described next.
Quantifying Unmodeled Dynamics

An informal manner to describe the difference between the model of a process and the actual process behavior is in terms of bandwidth. It is common to hear The model is good out to 8 radians/second. The precise meaning is not clear, but it is reasonable to believe that for frequencies lower than (say) 5 rad/s, the model is accurate, and for frequencies beyond, say 30 rad/s, the model is not necessarily representative of the process behavior. In the frequency range between 5 and 30, the guaranteed accuracy of the model degrades. The uncertain linear, time-invariant dynamics object, ultidyn can be used to model this type of knowledge. A ultidyn object represents an unknown linear system whose only known attribute is a uniform magnitude bound on its frequency response. When coupled with a nominal model and a frequency
4-5
Robustness Analysis
shaping filter, ultidyn objects can be used to capture uncertainty associated with the model dynamics. Suppose that the behavior of the system modeled by H significantly deviates from its 1st-order behavior beyond 9 rad/s, for example you believe about 5% potential relative error at low frequency and increasing to 1000% at high frequency where H rolls off. In order to model frequency domain uncertainty as described above using ultidyn objects, follow the steps below.
1 Create the nominal system, Gnom, using tf, ss or zpk. Gnom itself may
already have parameter uncertainty. In this case Gnom is H, the first-order system with an uncertain time-constant.
2 Create a filter, W, called the weight, whose magnitude represents the
relative uncertainty at each frequency. The utility makeweight is useful for creating 1st order weights with specific low and high frequency gains, and specified gain crossover frequency.
3 Create a ultidyn object, Delta, with magnitude bound equal to 1.
The uncertain model G is formed by G = Gnom*(1+W*Delta). If the magnitude of W represents an absolute (rather than relative) uncertainty, use the formula G = Gnom + W*Delta instead. The command below carry out the steps described above.
Gnom = H; W = makeweight(.05,9,10); Delta = ultidyn('Delta',[1 1]); G = Gnom*(1+W*Delta) USS: 2 States, 1 Output, 1 Input, Continuous System Delta: 1x1 LTI, max. gain = 1, 1 occurrence bw: real, nominal = 5, variability = [-10 10]%, 1 occurrence
Note that the result G is also an uncertain system, with dependence on both Delta and bw. You can use bode to make a Bode plot of 20 random samples of G's behavior, over the frequency range [0.1 100] rad/s.
4-6
bode(G,{1e-1 1e2},25)
10 5 0
Magnitude (dB)
Bode Diagram
5 10 15 20 25 30 360
180
Phase (deg)
180 10
1
10
10
In the next section, we design and compare two feedback controllers for G.
4-7
Robustness Analysis
Robustness Analysis
Next, we design a feedback controller for G. The goals of this design are the usual ones -- good steady-state tracking and disturbance rejection properties. Since the plant model is nominally a first-order lag, we chose a PI control architecture. Given desired closed-loop damping ratio, and natural frequency n, the design equations for KI and KP are (based on the nominl open-loop time constant of 0.2.) n 2 2 K I = ------ , K P = ------------- 1 5 5 In order to study how the uncertain behavior of G impacts the achievable closed-loop bandwidth, design two controllers, both achieving =0.707, with different n, 3 and 7.5 respectively.
xi wn K1 wn K2 = = = = = 0.707; 3; tf([(2*xi*wn/5-1) wn*wn/5],[1 0]); 7.5; tf([(2*xi*wn/5-1) wn*wn/5],[1 0]);
2
Note that the nominal closed-loop bandwidth achieved by K2 is in a region where G has significant model uncertainty. It will not be surprising if the model variations lead to significant degradations in the closed-loop performance. Form the closed-loop systems using feedback.
T1 = feedback(G*K1,1); T2 = feedback(G*K2,1);
Plot the step responses of 20 samples of each closed-loop system.

tfinal = 3;
4-8
Robustness Analysis
step(T1,'b',T2,'r',tfinal,20)
Step Response 1.5
0.5
Amplitude
0.5
1 0 0.5 1 1.5 Time (sec) 2 2.5 3
The step responses for T2 exhibit a faster rise time since K2 sets a higher closed loop bandwidth. However, the model variations have a greater effect. You can use robuststab to check the robustness of stability to the model variations.
[stabmarg1,destabu1,report1] = robuststab(T1); stabmarg1 stabmarg1 = ubound: 4.0241 lbound: 4.0241 destabfreq: 3.4959 [stabmarg2,destabu2,report2] = robuststab(T2); stabmarg2 stabmarg2 = ubound: 1.2545 lbound: 1.2544 destabfreq: 10.5249
4-9
Robustness Analysis
The stabmarg variable gives lower and upper bounds on the stability margin. A stability margin greater than 1 means the system is stable for all values of the modeled uncertainty. A stability margin less than 1 means there are allowable values of the uncertain elements that make the system unstable. The report variable briefly summarizes the analysis.
report1 report1 = Uncertain System is robustly stable to modeled uncertainty. -- It can tolerate up to 402% of modeled uncertainty. -- A destabilizing combination of 402% the modeled uncertainty exists, causing an instability at 3.5 rad/s. report2 report2 = Uncertain System is robustly stable to modeled uncertainty. -- It can tolerate up to 125% of modeled uncertainty. -- A destabilizing combination of 125% the modeled uncertainty exists, causing an instability at 10.5 rad/s.
While both systems are stable for all variations, their performance is clearly affected to different degrees. To determine how the uncertainty affects closed-loop performance, you can use wcgain, you can compute the worst-case effect of the uncertainty on the peak magnitude of the closed-loop sensitivity (S=1/(1+GK)) function. This peak gain is typically correlated with the amount of overshoot in a step response. To do this, form the closed-loop sensitivity functions, and call wcgain.
S1 = feedback(1,G*K1); S2 = feedback(1,G*K2); [maxgain1,wcu1] = wcgain(S1); maxgain1 maxgain1 = lbound: 1.8684 ubound: 1.9025 critfreq: 3.5152 [maxgain2,wcu2] = wcgain(S2); maxgain2 maxgain2 = lbound: 4.6031 ubound: 4.6671 critfreq: 11.0231
4-10
Robustness Analysis
The maxgain variable gives lower and upper bounds on the worst-case peak-gain of the Sensitivity transfer function, as well as the specific frequency where the maximum gain occurs. The wcu variable contains specific values of the uncertain elements that achieve this worst-case behavior. You can use usubs to substitute these worst-case values for uncertain elements, and compare the nominal and worst-case behavior. Use bodemag and step to make the comparison.
bodemag(S1.NominalValue,'b',usubs(S1,wcu1),'b'); hold on bodemag(S2.NominalValue,'r',usubs(S2,wcu2),'r'); hold off
Bode Diagram 20
10
Magnitude (dB)
10
20
30
40
50 1 10
10
10
10
Clearly, while K2 achieves better nominal sensitivity than K1, the nominal closed-loop bandwidth extends too far into the frequency range where the process uncertainty is very large. Hence the worst-case performance of K2 is inferior to K1 for this particular uncertain model. In the next section, we explore these robustness analysis tools further on a multi-input, multi-output system.
4-11
Robustness Analysis
Multi-Input, Multi-Output Robustness Analysis

So far, we've focused on simple uncertainty models of single-input and single-output systems, predominantly from a transfer function perspective. You can also create uncertain state-space models made up of uncertain state-space matrices. Moreover, all of the analysis tools covered thus far can be applied to these systems as well. Consider, for example, a 2-input, 2-output, 2-state system whose model has parametric uncertainty in the state-space matrices. First create an uncertain parameter p. Using the parameter, make uncertain A and C matrices. The B matrix happens to be not-uncertain, although you will add frequency domain input uncertainty to the model in the next section.
p A B C H = = = = = ureal('p',10,'Percentage',10); [0 p;-p 0]; eye(2); [1 p;-p 1]; ss(A,B,C,[0 0;0 0]);
You can view the properties of the uncertain system H using the get command.
get(H) a: b: c: d: StateName: Ts: InputName: OutputName: InputGroup: OutputGroup: NominalValue: Uncertainty: Notes: UserData: [2x2 [2x2 [2x2 [2x2 {2x1 0 {2x1 {2x1 [1x1 [1x1 [2x2 [1x1 {} [] umat] double] umat] double] cell} cell} cell} struct] struct] ss] atomlist]
The properties a, b, c, d, and StateName behave in exactly the same manner as ss objects. The properties InputName, OutputName, InputGroup and OutputGroup behave in exactly the same manner as all of the system objects (ss, zpk, tf, and frd). The NominalValue is a ss object.
4-12
Adding Independent Input Uncertainty to Each Channel

The model for H did not include actuator dynamics. Said differently, the actuator models are unity-gain for all frequencies. Nevertheless it is known that the behavior of the actuator for channel 1 is both modestly uncertain (say 10%) at low frequencies and the high frequency behavior beyond 20 rad/s is not accurately modeled. Similar statements hold for actuator in channel 2, with larger modest uncertainty at low frequency (say 20%) but accuracy out to 45 rad/s. Use ultidyn objects Delta1 and Delta2, along with shaping filters W1 and W2 to add this form of frequency domain uncertainty into the model.
W1 = makeweight(.1,20,50); W2 = makeweight(.2,45,50); Delta1 = ultidyn('Delta1',[1 1]); Delta2 = ultidyn('Delta2',[1 1]); G = H*blkdiag(1+W1*Delta1,1+W2*Delta2) USS: 4 States, 2 Outputs, 2 Inputs, Continuous System Delta1: 1x1 LTI, max. gain = 1, 1 occurrence Delta2: 1x1 LTI, max. gain = 1, 1 occurrence p: real, nominal = 10, variability = [-10 10]%, 2 occurrences
Note that G is a 2-input, 2-output uncertain system, with dependence on 3 uncertain elements, Delta1, Delta2 and p. It has 4 states, 2 from H, and one each from the shaping filters W1 and W2 which are embedded in G. You can plot a 2-second step response of several samples of G. The 10% uncertainty in the natural frequency is obvious.
4-13
Robustness Analysis
step(G,2)
From: In(1) 1.5 1 0.5 0 0.5 1 1.5 2 Step Response From: In(2)
Amplitude
To: Out(1) To: Out(2)
2.5 1.5 1 0.5 0 0.5 1 1.5 2 2.5
0.5
1.5
2 0 Time (sec)
0.5
1.5
You can plot Bode plot of 50 samples of G. The high-frequency uncertainty in the model is also obvious. For clarity, start the Bode plot beyond the resonance.
4-14
bode(G,{13 100},50)
From: In(1) 20 Bode Diagram From: In(2)
To: Out(1) Magnitude (dB) ; Phase (deg) To: Out(1) To: Out(2) To: Out(2)
20
40 360
360 20
20
40 360

2
10
Closed-Loop Robustness Analysis

You need to load the controller and verify that it is 2-input and 2-output.
load mimoKexample size(K) State-space model with 2 outputs, 2 inputs, and 9 states.
You can use the command loopsens to form all of the standard plant/controller feedback configurations, including sensitivity and complementary sensitivity at both the input and output. Since G is uncertain, all of the closed-loop systems will be uncertain as well.
F = loopsens(G,K) F = Poles: [13x1 double]
4-15
Robustness Analysis
Stable: Si: Ti: Li: So: To: Lo: PSi: CSo:
1 [2x2 [2x2 [2x2 [2x2 [2x2 [2x2 [2x2 [2x2
uss] uss] uss] uss] uss] uss] uss] uss]
F is a structure with many fields. The poles of the nominal closed-loop system are in F.poles, and F.Stable is 1 if the nominal closed-loop system is stable. In the remaining 10 fields, S stands for sensitivity, T for complementary sensitivity, and L for open-loop gain. The suffix i and o refer to the input and output of the plant (G). Finally P and C refer to the plant and controller.
Hence Ti is mathematically the same as K ( I + GK ) G while Lo is G*K, and CSo is mathematically the same as K ( I + GK )
1 1
You can examine the transmission of disturbances at the plant input to the plant output using bodemag on F.PSi. Graph 50 samples along with the nominal.
4-16
bodemag(F.PSi,':/-',{1e-1 100},50)
From: In(1) 20 10 0 10 20 30 40
Magnitude (dB)
Bode Diagram
From: In(2)
50 60 20 10 0 10 20 30 40 50 60 1 10
10
10
1 2
10
10
10
Nominal Stability Margins

You can use loopmargin to investigate loop-at-a-time gain and phase margins, loop-at-a-time disk margins and simultaneous multivariable margins. They are computed for the nominal system and do not reflect the uncertainty models within G. Explore the simultaneous margins individually at the plant input, individually at the plant output, and simultaneously at both input and output.
[I,DI,SimI,O,DO,SimO,Sim] = loopmargin(G,K);
The third output argument are the simultaneous gain and phase variations allowed in all input channels to the plant.
SimI
4-17
Robustness Analysis
SimI = GainMargin: [0.1180 8.4769] PhaseMargin: [-76.5441 76.5441] Frequency: 6.2287
This information implies that the gain at the plant input can vary in both channels independently by factors between (approximately) 1/8 and 8, as well as phase variations up to 76 degrees. The 6th output argument are the simultaneous gain and phase variations allowed in all output channels to the plant.
SimO SimO = GainMargin: [0.1193 8.3836] PhaseMargin: [-76.3957 76.3957] Frequency: 18.3522
Note that the simultaneous margins at the plant output are similar to those at the input. This is not always the case in multiloop feedback systems. The last output argument are the simultaneous gain and phase variations allowed in all input and output channels to the plant. As expected, when you consider all such variations simultaneously, the margins are somewhat smaller than those at the input or output alone.
Sim Sim = GainMargin: [0.5671 1.7635] PhaseMargin: [-30.8882 30.8882] Frequency: 18.3522
Nevertheless, these numbers indicate a generally robust closed-loop system, able to tolerate significant gain (more than +/-50% in each channel) and phase 30 degrees variations simultaneously in all input and output channels of the plant.
Robustness of Stability Model Uncertainty

With loopmargin, you determined various margins of the nominal, multiloop system. These margins are computed only for the nominal system, and do not reflect the uncertainty explicitly modeled by the ureal and ultidyn objects. When working with detailed, complex uncertain system models, the
4-18
conventional margins computed by loopmargin may not always be indicative of the actual stability margins associated with the uncertain elements. You can use robuststab to check the stability margin of the system to these specific modeled variations. In this example, use robuststab to compute the stability margin of the closed-loop system represented by Delta1, Delta2 and p. Use any of the closed-loop systems within F = loopsens(G,K). All of them, F.Si, F.To, etc., have the same internal dynamics, and hence the stability properties are the same.
[stabmarg,desgtabu,report] = robuststab(F.So); stabmarg stabmarg = ubound: 2.2175 lbound: 2.2175 destabfreq: 13.7576 report report = Uncertain System is robustly stable to modeled uncertainty. -- It can tolerate up to 222% of modeled uncertainty. -- A destabilizing combination of 222% the modeled uncertainty exists, causing an instability at 13.8 rad/s.
This analysis confirms what the loopmargin analysis suggested. The closed-loop system is quite robust, in terms of stability, to the variations modeled by the uncertain parameters Delta1, Delta2 and p. In fact, the system can tolerate more than twice the modeled uncertainty without losing closed-loop stability. In the next section, we study the effect of these variations on the closed-loop output sensitivity function.
4-19
Robustness Analysis
Worst-Case Gain Analysis

You can plot the Bode magnitude of the nominal output sensitivity function. It clearly shows decent disturbance rejection in all channels at low frequency.
bodemag(F.So.NominalValue,{1e-1 100})
From: In(1) 10 0 10
To: Out(1)
Bode Diagram
From: In(2)
20 30 40
Magnitude (dB)
50 60 10 0 10 20 30
To: Out(2)
40 50 60 70 80 90 100 1 10 10
0
10
1 2
10
10
10
You can compute the peak value of the maximum singular value of the frequency response matrix using norm.
[PeakNom,freq] = norm(F.So.NominalValue,'inf') PeakNom = 1.1317 freq = 7.0483
The peak is about 1.13, occurring at a frequency of 36 rad/s.
4-20
Worst-Case Gain Analysis
What is the maximum output sensitivity gain that is achieved, when the uncertain elements Delta1, Delta2 and p vary over their ranges? You can use wcgain to answer this.
[maxgain,wcu] maxgain maxgain = lbound: ubound: critfreq: = wcgain(F.So);
2.1017 2.1835 8.5546
The analysis indicates that the worst-case gain is somewhere between 2.1 and 2.2. The frequency where the peak is achieved is about 8.5. You can substitute the values for Delta1, Delta2 and p that achieve the gain of 2.1 using usubs. Make the substitution in the output complementary sensitivity, and do a step response.
step(F.To.NominalValue,usubs(F.To,wcu),5)
From: In(1) 1.5 Step Response From: In(2)
To: Out(1) Amplitude To: Out(2)
0.5
1.4 1.2 1 0.8 0.6 0.4 0.2 0 0.2
5 0 Time (sec)
The perturbed response, which is the worst combination of uncertain values in terms of output sensitivity amplification does not show significant degradation of the command response significantly. The settling time is increased by about
4-21
Robustness Analysis
50%, from 2 to 4, and the off-diagonal coupling is increased by about a factor of about 2, but is still quite small.
4-22
Summary of Robustness Analysis Tools
Summary of Robustness Analysis Tools
Function ureal ultidyn uss
Description
Creates uncertain real parameter Creates uncertain, linear, time-invariant dynamics Creates uncertain state-space object from uncertain state-space matrices Creates uncertain frequency response object Compute all relevant open and closed-loop quantities for a MIMO feedback connection Compute loop-at-a-time, as well as MIMO gain and phase margins for a multiloop system, including the simultaneous gain/phase margins Robustness performance of uncertain systems Computes the robust stability margin of a nominally stable uncertain system Computes the worst-case gain of a nominally stable uncertain system Computes worst-case (over uncertainty) loop-at-a-time disk-based gain and phase margins Computes worst-case (over uncertainty) sensitivity of plant-controller feedback loop
ufrd loopsens
loopmargin
robustperf robuststab
wcgain
wcmargin
wcsens
4-23
Robustness Analysis
4-24
5
This chapter covers an introduction to H and structured singular value, , control design. H-Infinity Performance (p. 5-2) Application of H and mu to Active Suspension Control (p. 5-10) Functions for Control Design (p. 5-24) Appendix: Interpretation of H-Infinity norm (p. 5-26) References (p. 5-33) Discusses a modern approach to characterizing closed-loop performance A fully worked example of designing a compensator for active suspension control A discussion of the functions you can use for robust control design Details about norms and their properties A list of relevant papers and books about H-infinity and structured singular value design
H-Infinity Performance
Performance as Generalized Disturbance Rejection
The modern approach to characterizing closed-loop performance objectives is to measure the size of certain closed-loop transfer function matrices using various matrix norms. Matrix norms provide a measure of how large output signals can get for certain classes of input signals. Optimizing these types of performance objectives, over the set of stabilizing controllers is the main thrust of recent optimal control theory, such as L1, H2, and H, and optimal control. Hence, it is important to develop a clear understanding of how many types of control objectives can be posed as a minimization of closed-loop transfer functions. Consider a tracking problem, with disturbance rejection, measurement noise, and control input signal limitations, as shown in Figure 5-1. K is some controller to be designed and G is the system we want to control.
reference
control input
external force disturbance
? error ; - e - tracking
e
noise
Typical Closed-Loop Performance Objective A reasonable, though not precise, design objective would be to Design K to keep tracking errors and control input signal small for all reasonable reference commands, sensor noises, and external force disturbances. Hence, a natural performance objective is the closed-loop gain from exogenous influences (reference commands, sensor noise, and external force disturbances) to regulated variables (tracking errors and control input signal). Specifically,
5-2
let T denote the closed-loop mapping from the outside influences to the regulated variables, reference tracking error = T external force control input noise regulated variables outside influences
We can assess performance by measuring the gain from outside influences to regulated variables. In other words, good performance is associated with T being small. Since the closed-loop system is a multi-input, multi-output (MIMO) dynamic system, there are two different aspects to the gain of T: Spatial (vector disturbances and vector errors) Temporal (dynamical relationship between input/output signals) Hence the performance criterion must account for: Relative magnitude of outside influences Frequency dependence of signals Relative importance of the magnitudes of regulated variables So, if the performance objective is in the form of a matrix norm, it should actually be a weighted norm ||WLTWR|| where the weighting function matrices WL and WR are frequency dependent, to account for bandwidth constraints and spectral content of exogenous signals. A natural (mathematical) manner to characterize acceptable performance is in terms of the MIMO |||| (H) norm. See the Appendix at the end of this chapter for an interpretation of the H norm and signals.
Interconnection with Typical MIMO Performance Objectives

The closed-loop performance objectives is formulated as weighted closed-loop transfer functions which are to be made small through feedback. A generic example, which includes many relevant terms, is shown in block diagram form in Figure 5-1. In the diagram, G denotes the plant model and K is the feedback controller.
5-3
Figure 5-1: Generalized and Weighted Performance Block Diagram
The blocks in Figure 5-1 might be scalar (SISO) and/or multivariable (MIMO), depending on the specific example. The mathematical objective of H control is to make the closed-loop MIMO transfer function Ted satisfy ||Ted|| < 1. The weighting functions are used to scale the input/output transfer functions such that when ||Ted|| < 1, the relationship between d and e is suitable. Performance requirements on the closed-loop system are transformed into the H framework with the help of weighting or scaling functions. Weights are selected to account the relative magnitude of signals, their frequency dependence and their relative importance. This is captured in Figure 5-1 where the weights or scalings, [Wcmd , Wdist,Wsnois ], are used to transform and scale the normalized input signals [d1,d2,d3] into physical units defined as [d1, d2, d3]. Similarly weights or scalings [Wact , Wperf1,Wperf2 ] transform and scale
5-4
physical units into normalized output signals, [e1, e2, e3]. An interpretation of the signals, weighting functions and models follows.
Signal Meaning
d1 d1 d2 d2 d3 d3 e1 e1 e2 e2 e3 e3
Normalized reference command Typical reference command in physical units Normalized exogenous disturbances Typical exogenous disturbances in physical units Normalized sensor noise Typical sensor noise in physical units Weighted control signals Actual control signals in physical units Weighted tracking errors Actual tracking errors in physical units Weighted plant errors Actual plant errors in physical units
Wcmd
Wcmd is included in H control problems that require tracking of a reference command. Wcmd shapes (magnitude and frequency) the normalized reference command signals into the actual (or typical) reference signals that you expect to occur. It describes the magnitude and the frequency dependence of the reference commands generated by the normalized reference signal. Normally Wcmd is flat at low frequency and rolls off at high frequency. For example, in a flight control problem, fighter pilots can (and will) generate stick input reference commands up to a bandwidth of about 2Hz. Suppose that the stick has a maximum travel of three inches. Pilot commands could be modeled as normalized signals passed through a first order filter
5-5
3 W act = --------------------------1 -------------- s + 1 2 2
Wmodel
Wmodel represents a desired ideal model for the closed-looped system and is often included in problem formulations with tracking requirements. Inclusion of and ideal model for tracking is often called a model matching problem, i.e. the objective of the closed-loop system is the match the defined model. For good command tracking response, you might desire the closed-loop system to respond like a well-damped second-order system. The ideal model would then be
W model = 10 ------------------------------------2 2 s + 2 + 2
for specific desired natural frequency and desired damping ratio . Unit conversions might be necessary to insure exact correlation between the ideal model and the closed-loop system. In the fighter pilot example, suppose that roll-rate is being commanded and 10/second response is desired for each inch of stick motion. Then, in these units, the appropriate model is
W model = 10 ------------------------------------2 2 s + 2 +
Wdist
Wdist shapes the frequency content and magnitude of the exogenous disturbances affecting the plant. For example, consider an electron microscope as the plant. The dominant performance objective is to mechanically isolate the microscope from outside mechanical disturbances, such as the ground excitations, sound (pressure) waves, and air currents. You would capture the spectrum and relative magnitudes of these disturbances with the transfer function weighting matrix Wdist.
5-6
Wperf1
Wperf1 weights the difference between the response of the closed-loop system and the ideal model, Wmodel. Often you may desire accurate matching of the ideal model at low frequency and require less accurate matching at higher frequency, in which case Wperf1 is flat at low frequency, rolls off at first or second order, and flattens out at a small, nonzero value at high frequency. The inverse of the weight is related to the allowable size of tracking errors, in the face of the reference commands and disturbances described by Wref and Wdist.
Wperf2
Wperf2 penalizes variables internal to the process G, such as actuator states that are internal to G, or other variables that are not part of the tracking objective.
Wact
Wact is used to shape the penalty on control signal use. Wact is a frequency varying weighting function used to penalize limits on the deflection/position, deflection rate/velocity, etc., response of the control signals, in the face of the tracking and disturbance rejection objectives defined above. Each control signal is usually penalized independently.
Wsnois
Wsnois represents frequency domain models of sensor noise. Each sensor measurement feedback to the controller has some noise, which is often higher in one frequency range than another. The Wsnois weight tries to capture this information, derived from laboratory experiments or based on manufacturer measurements, in the control problem. For example, medium grade accelerometers have substantial noise at low frequency and high frequency. Therefore the corresponding Wsnois weight would be larger at low and high frequency and have a smaller magnitude in the mid-frequency range. Displacement or rotation measurement is often quite accurate at low frequency and in steady-state, but responds poorly as frequency increases. The weighting function for this sensor would be small at low frequency, gradually increase in magnitude as a first or second system, and level out at high frequency.
Hsens
Hsens represents a model of the sensor dynamics or an external anti-aliasing filter. The transfer functions used to describe Hsens are based on physical
5-7
characteristics of the individual components. These models might also be lumped into the plant model G. This generic block diagram has tremendous flexibility and many control performance objectives can be formulated in the H framework using this block diagram description.
Robustness in the H Framework

Performance and robustness tradeoffs in control design were discuss in the context of multivariable loop shaping in Chapter ***. In the H control design framework, you can include robustness objectives as addition disturbance to error transfer functions to be kept small. Consider the following figure of a closed-loop feedback system with additive and multiplicative uncertainty models.

The transfer function matrices are defined as:

-1
TF(s) z w 1 1 TF(s) z 2 w2
= =
TI ( s ) KS O ( s )
= =
KG ( I ) , K ( I + GK )
1
where TI(s) denotes the input complementary sensitivity function and SO(s) denotes the output sensitivity function. Theorems 1 and 2 in Chapter *** give bounds on the size of the transfer function matrices from z1 to w1 and z2 to w2 to insure the closed-loop system is robust to multiplicative uncertainty, M(s), at the plant input and additive uncertainty, A(s), around the plant G(s). In the H control problem formulation, the robustness objectives enter the synthesis procedure as additional input/output signals to be kept small. The interconnection with the uncertainty blocks removed follows.
5-8
The H control robustness objective is now in the same format as the performance objectives. That is minimize the H norm of the transfer matrix from z, [z1,z2], to w, [w1,w2]. Weighting or scaling matrices are often introduced to shape the frequency and magnitude content of the sensitivity and complementary sensitivity transfer function matrices. Let WM correspond to the multiplicative uncertainty and WA correspond to the additive uncertainty model. M(s) and A(s) are assumed to be norm bounded by 1, i.e. |M(s)|<1 and |A(s)|<1. Hence as a function of frequency, |WM(j)| and |WA(j)| are the respective sizes of the largest anticipated additive and multiplicative plant perturbations. The multiplicative weighting or scaling, WM, represents a percentage error in the model and is often small in magnitude at low frequency, between 0.05 and 0.20 (5% to 20% modeling error) growing larger in magnitude at high frequency, 2 to 5 ((200% to 500% modeling error). The weight will transition by crossing a magnitude value of 1, which corresponds to 100% uncertainty in the model, at least twice the bandwidth of the closed-loop system. A typical multiplicative weight is
1 -- s + 1 5 W M = 0.10 ---------------------1 --------- s + 1 200
The additive weight or scaling, WA, represents an absolute error which is often small at low frequency and large in magnitude at high frequency. The magnitude of this weight depends directly on the magnitude of the plant model, G(s). You can initially select WA to be a constant whose magnitude is 10% of the ||G(s)||.
5-9
Application of H and mu to Active Suspension Control

Conventional passive suspensions employ a spring and damper between the car body and wheel assembly, represent a trade-off between conflicting performance metrics such as passenger comfort, road holding, and suspension deflection. Active suspensions allow the designer to balance these objectives using a hydraulic actuator, controlled by feedback, between the chassis and wheel assembly. In this section, you will design of an active suspension system for a quarter car body and wheel assembly model using the H control design technique. You will see the trade-off between passenger comfort, i.e. minimizing car body travel, versus suspension travel as the performance objective.
Quarter Car Suspension Model

The quarter car model shown will be used to design active suspension control laws.
The sprung mass, ms, represents the car chassis, while the unsprung mass, mus, represents the wheel assembly. The spring, ks, and damper, bs, represent a passive spring and shock absorber that are placed between the car body and the wheel assembly, while the spring, kt, serves to model the compressibility of the pneumatic tyre. The variables xs, xus, and r are the car body travel, the wheel travel, and the road disturbance respectively. The force fs, kN, applied between the sprung and unsprung masses, is controlled by feedback and
5-10
represents the active component of the suspension system. The dynamics of the actuator, and assume that the control signal is the force fs are ignored in this example. Defining x1:=xs, x 2 : = x s , x3:=xus and x 4 : = x us , the following state-space description of the quarter car dynamics. x 1 = x 2, 1 x 2 = ------ [ k s ( x 1 x 3 ) + b s ( x 2 x 4 ) f s ], ms x 3 = x 4, 1 x 4 = --------- [ k s ( x 1 x 3 ) + b s ( x 2 x 4 ) k t ( x 3 r ) f s ]. m us The following component values are taken from reference [Lin97].
ms = 290; mus = 59; bs = 1000; ks = 16182 ; kt = 190000; % % % % % kg kg N/m/s N/m N/m
A linear, time-invariant model of the quarter car model, qcar, is constructed from the equations of motion and parameter values. The inputs to the model, qcar, are the road disturbance and actuator force respectively and the outputs are the car body deflection, acceleration and suspension deflection.
A12 = [ 0 1 0 0; [-ks -bs ks bs]/ms ]; A34 = [ 0 0 0 1; [ks bs -ks-kt -bs]/mus]; B12 = [0 0; 0 10000/ms]; B34 = [0 0; [kt -10000]/mus]; C = [1 0 0 0; A12(2,:); 1 0 -1 0; 0 0 0 0]; D = [0 0; B12(2,:); 0 0; 0 1]; qcar = ss([A12; A34],[B12; B34],C,D);
It is well known [Hedrick90] that the acceleration transfer function has an invariant point at the tyrehop frequency, 56.7 rad/sec. Similarly, the suspension deflection transfer function has an invariant point at the rattlespace frequency, 23.3 rad/sec. The trade-off between passenger comfort and suspension deflection is due to the fact that it is not possible to
5-11
simultaneously keep both the above transfer functions small around the tyrehop frequency and in the low frequency range.
Linear H Controller Design

The design of linear suspension controllers that emphasize either passenger comfort or suspension deflection. The controllers in this section are designed using linear H synthesis [FialBal]. As is standard in the H framework, the performance objectives are achieved via minimizing weighted transfer function norms. Weighting functions serve two purposes in the H framework: they allow the direct comparison of different performance objectives with the same norm and they allow for frequency information to be incorporated into the analysis. For more details on H control design the reader is referred to [DGKF, Fran1, GloD, SkoP, Zame] and the references therein. A block diagram of the H control design interconnection for the active suspension problem is shown in the following figure.
The measured output or feedback signal, y, is the suspension deflection x1x3. The controller acts on this signal to produce the control input, the hydraulic actuator force fs. The block Wn serves to model sensor noise in the measurement channel. Wn is set to a sensor noise value of 0.01 m.
Wn = 0.01;
In a more realistic design, Wn would be frequency dependent and would serve to model the noise associated with the displacement sensor. The weight Wref is used to scale the magnitude of the road disturbances. We assume that the maximum road disturbance is 7 cm and hence choose Wref = 0.07.
5-12
Wref = 0.07;
The magnitude and frequency content of the control force fs is limited by the 100 s + 50 weighting function Wact. We choose W act = --------- ------------------ . The magnitude of 13 s + 500 the weight increases above 50 rad/s in order to limit the closed-loop bandwidth.
Wact = (100/13)*tf([1 50],[1 500]);
H Control Design 1
The purpose of the weighting functions W x and W x 1 x 3 are to keep the 1 car deflection and the suspension deflection small over the desired frequency ranges. In the first design, you are designing the controller for passenger comfort and hence the car body deflection x1 is penalized.
Wx1 = 8*tf(2*pi*5,[1 2*pi*5]);
The weight magnitude rolls off above 52 rad/s to respect a well-known H design rule-of-thumb that requires the performance weights to roll off before an open-loop zero (56.7 rad/s in this case). The suspension deflection weight, W x x , is not included in this control problem formulation
1 3
You can construct the weighted H plant model for control design, denoted qcaric1, is using the sysic command. The control signal corresponds to the last input to qcaric1, fs. The car body acceleration, which is noisy, is the measured signal and corresponds to the last output of qcaric1.
systemnames = 'qcar Wn Wref Wact Wx1'; inputvar = '[ d1; d2; fs ]'; outputvar = '[ Wact; Wx1; qcar(2)+Wn ]'; input_to_qcar = '[ Wref; fs]'; input_to_Wn = '[ d2 ]'; input_to_Wref = '[ d1 ]'; input_to_Wact = '[ fs ]'; input_to_Wx1 = '[ qcar(1) ]'; qcaric1 = sysic;
A H controller is synthesized with the hinfsyn command. There is one control input, ncont, the hydraulic actuator force and one measurement signal, nmeas, the car body acceleration.
ncont = 1; nmeas = 1;
5-13
[K1,Scl1,gam1] = hinfsyn(qcaric1,nmeas,ncont); CL1 = lft(qcar([1:4 2],1:2),K1); sprintf('H-infinity controller K1 achieved a norm of %2.5g',gam1) ans = H-infinity controller K1 achieved a norm of 0.56698
You can analyze the H controller by constructing the closed-loop feedback system, CL1. Bode magnitude plots of the passive suspension and active suspension are shown in the following figure.
10
1
Bode Diagram From: Road Disturbance To: Suspension Deflection
10
Magnitude (abs)
10
1
Passive K1 10
2
10
10
H Control Design 2
In the second design, you are designing the controller to keep the suspension deflection transfer function small. Hence the road disturbance to suspension deflection x1x3 is penalized via the weighting function Wx1x3. The Wx1x3 weight magnitude rolls off above 10 rad/s to roll off before an open-loop zero (23.3 rad/s) in the design.
Wx1x3 = 25*tf(1,[1/10 1]);
The car deflection weight, W x , is not included in this control problem 1 formulation. You can construct the weighted H plant model for control design,
5-14
denoted qcaric2, is using the sysic command. The same control and measurements are used as in the first design.
M = iconnect; d = icsignal(2); fs = icsignal(1); ycar = icsignal(size(qcar,1)); M.Equation{1} = equate(ycar,qcar*[Wref*d(1); fs]); M.Input = [d;fs]; M.Output = [Wact*fs;Wx1*ycar(1);ycar(2)+Wn*d(2)]; qcaric2 = M.System;
The second H controller is synthesized with the hinfsyn command.

[K2,Scl2,gam2] = hinfsyn(qcaric2,nmeas,ncont); CL2 = lft(qcar([1:4 2],1:2),K2); sprintf('H-infinity controller K2 achieved a norm of %2.5g',gam2) ans = H-infinity controller K2 achieved a norm of 0.89949
Recall that this H control design emphasizes minimization of suspension deflection over passenger comfort where as the first H design focussed on passenger comfort. You can analyze the H controller by constructing the closed-loop feedback system, CL2. Bode magnitude plots of the transfer function from road
5-15
disturbance to suspension deflection for both controllers and the passive suspension system shown in the following figure.
10
1
10
Magnitude (abs)
10
1
Passive K1 K2 10
2
10
10
The dotted and solid lines in the figure are the closed-loop frequency responses that result from the different performance weighting functions selected. Observe the reduction in suspension deflection in the vicinity of the tyrehop frequency 1= 56.7 rad/s, and the corresponding increase in the acceleration frequency response in this vicinity. Also, compared to Design 1, a reduction in suspension deflection has been achieved for frequencies below the rattlespace frequency 2= 23.3 rad/sec.
5-16
The second H control design attenuates both resonance modes where as the first controller focussed its efforts on the first mode, the rattlespace frequency at 23.3 rad/sec.
10
3
Bode Diagram From: Road Disturbance To: Car Body Acceleration
10
Magnitude (abs)
10
10
Passive K1 K2 10
1
10
10
All the analysis till now has been in the frequency domain. Time domain performance characteristics are critical to the success of the active suspension system on the car. Time response plots of the two H controllers are shown in following figures. The dashed, solid and dotted lines correspond to the passive suspension, H controller 1 and 2 respectively. All responses correspond to the road disturbance r(t) r(t) = a ( 1 cos 8t ),
= 0 otherwise, where a=0.025 corresponds to a road bump of peak magnitude 5 cm. Observe that the acceleration response of Design 1 to the 5 cm bump is very good however the suspension deflection is larger than for Design 2. This is due to the fact that suspension deflection was not penalized in this design. The suspension deflection response of Design 2 to a 5 cm bump is good however the acceleration response to the 5 cm bump is much inferior to Design 1 (see the
5-17
figure). Once again this is due to the fact that car body displacement and acceleration were not penalized in design 2.
Body Travel 0.05 0.04 0.03
x1 (m)
Body Acceleration 6 K1 K2 Passive bump 4

Accel (m/s/s)
2 0 2 4 6
0.02 0.01 0 0.01 0.02 0 0.2 0.4 0.6 0.8 1
0.2
0.4
0.6
0.8
Suspension Deflection 0.04 0.02

x1 x3 (m)
Control Force 0.15 0.1 0.05
0 0.02 0.04 0.06
fs (10kN)
0 0.05 0.1 0.15
0.2
0.4 0.6 Time (sec)
0.8
0.2
0.2
0.4 0.6 Time (sec)
0.8
Designs 1 and 2 represent extreme ends of the performance trade-off spectrum. This section described synthesis of H to achieve the performance objectives on the active suspension system. Equally, if not more important, is the design of controlles robust to model error or uncertainty. The goal of every control design is to achieve the desired performance specifications on the nominal model as well as other plants that are close to the nominal model. In other words, it you want to achieve the performance objectives in the presence of model error or uncertainty. This is called robust performance. In the next section, you will design a controller which achieves robust performance using the -synthesis control design methodology. The
5-18
active suspension system again serves as the example. Instead of an assume perfect actuator, a nominal actuator model with modeling error is introduced into the control problem.
Control Design via -Synthesis

The active suspension H controllers designed in the previous section ignored the hydraulic actuator dynamics. In section, you will include a first order model of the hydraulic actuator dynamics as well as an uncertainty model to account for differences between the actuator model and the actual actuator dynamics. 1 The hydraulic actuator is modeled as act = ------------------ . 1 ----- s + 1 60
act = tf(1,[1/60 1]);
The actuator model itself is uncertain. You can describe the actuator model error as a set of possible models using a weighting function. At low frequency, below 4 rad/s, it can vary up to 10% from its nominal value. Around 4 rad/s the percentage variation starts to increase and reaches 400% at approximately 800 rad/s. The model uncertainty is represented by the weight, Wunc, which corresponds to the frequency variation of the model uncertainty and the uncertain LTI dynamic object unc defined as unc.
Wunc = 0.10*tf([1/4 1],[1/800 1]); unc = ultidyn('unc',[1 1]); actmod = act*(1+ Wunc*unc) USS: 2 States, 1 Output, 1 Input, Continuous System unc: 1x1 LTI, max. gain = 1, 1 occurrence
The actuator model, actmod, is an uncertain state-space system. The following Bode plot shows the nominal actuator model, denoted with a '+' symbol, and 50 random actuator models described by actmod.
bode(actmod,'b/r+',50,logspace(-1,3,120))
5-19
10
Nominal and 50 random actuator models
Magnitude (abs) Phase (deg)
10
10
10 90
90
180
270 10
1
10
10
10
The uncertain actuator model, actmod, is represents the model of the hydraulic actuator used for control. The revised control design interconnection diagram is
5-20
You are designing the controller for passenger comfort, as in the first H control design, hence the car body deflection x1 is penalized with Wx1. The uncertain weighted H plant model for control design, denoted qcaricunc, is using the sysic command. As previously described, the control signal corresponds to the last input to qcaric1, fs. The car body acceleration, which is noisy, is the measured signal and corresponds to the last output of qcaricunc.
systemnames = 'qcar Wn Wref Wact Wx1 actmod'; inputvar = '[ d1; d2; fs ]'; outputvar = '[ Wact; Wx1; qcar(2)+Wn ]'; input_to_actmod = '[ fs ]'; input_to_qcar = '[ Wref; fs]'; input_to_Wn = '[ d2 ]'; input_to_Wref = '[ d1 ]'; input_to_Wact = '[ fs ]'; input_to_Wx1 = '[ qcar(1) ]'; qcaricunc = sysic;
A -synthesis controller is synthesized using DK iteration with the dksyn command. The DK iteration procedure is an approximation to -synthesis that attempts to synthesize a controller that achieves robust performance [SteD, BalPac, PacDB, SkoP]. There is one control input, ncont, the hydraulic actuator force and one measurement signal, nmeas, the car body acceleration.
[Kdk,CLdk,gdk] = dksyn(qcaricunc,nmeas,ncont); CLdkunc = lft(qcar([1:4 2],1:2)*blkdiag(1,actmod),Kdk); sprintf('mu-synthesis controller Kdk achieved a norm of %2.5g',gdk) ans = mu-synthesis controller Kdk achieved a norm of 0.53946
You can analyze the -synthesis controller by constructing the closed-loop feedback system, CLdkunc. Bode magnitude plots of the passive suspension and active suspension systems on the nominal actuator model with H design 1 and the -synthesis controller are shown in the following figure. Note that the
5-21
-synthesis controller better attenuates the first resonant mode at the expense of decrease performance below 3 rad/sec.
10
10
Magnitude (abs)
10
1
Passive K1 Kdk 10
2
10
10
It is important to understand how robust both controllers are in the presence of model error. You can simulate the active suspension system with the H design 1 and the -synthesis controller. The uncertain closed-loop systems, CL1unc and CLdkunc, are formed with K1 and Kdk respectively. For each uncertain system, 40 random plant models in the model set are simulated. As you can see, both controllers are robust and performance well in the presence of actuator model error. The -synthesis controller, Kdk, achieves slightly better performance than H design 1.
CL1unc = lft(qcar([1:4 2],1:2)*blkdiag(1,actmod),K1); [CLdkunc40,dksamples] = usample(CLdkunc,40); CL1unc40 = usubs(CL1unc,dksamples);
5-22
Random sample of 40 plant models: DK Controller 0.08
0.07
0.06
0.05
Body Travel (m)
0.04
0.03
0.02
0.01
0.01
0.02
0.1
0.2
0.3
0.4
0.5 0.6 Time (seconds)
0.7
0.8
0.9
Random sample of 40 plant models: H Design 1 0.08
0.07
0.06
0.05
Body Travel (m)
0.04
0.03
0.02
0.01
0.01
0.02
0.1
0.2
0.3
0.4
0.5 0.6 Time (seconds)
0.7
0.8
0.9
5-23
Functions for Control Design

The term control system design refers to the process of synthesizing a feedback control law that meets design specifications in a closed-loop control system. The design methods are iterative, combining parameter selection with analysis, simulation and insight into the dynamics of the plant. The Robust Control Toolbox provides a set of commands that you can use for a broad range of multivariable control applications, including: H2 control design H standard and loop shaping control design H normalized coprime factor control design Mixed H2/H control design -synthesis via DK iteration Sample-data H control design These functions cover both continuous and discrete-time problems. The following table summarizes the H2 and H control design commands.
Function augw Description
Augments plant weights for mixed-sensitivity control design Mixed H2/Hcontroller synthesis H2 controller synthesis H controller synthesis. H loop shaping controller synthesis Loop-transfer recovery controller synthesis H mixed-sensitivity controller synthesis H normalized coprime factor controller synthesis Sample-data H controller synthesis
h2hinfsyn h2syn hinfsyn loopsyn ltrsyn mixsyn ncfsyn sdhinfsyn
5-24
Functions for Control Design
The following table summarizes the -synthesis via DK iteration control design commands.
Function dksyn dkitopt drawmag fitfrd fitmagfrd Description
Synthesis of a robust controller via -synthesis Create a dksyn options object Interactive mouse-based sketching and fitting tool Fit scaling frequency response data with LTI model Fit scaling magnitude data with stable, minimum-phase model
5-25
Appendix: Interpretation of H-Infinity norm

Norms of Signals and Systems
There are several ways of defining norms of a scalar signal e(t) in the time domain. We will often use the 2-norm, (L2-norm), for mathematical convenience, which is defined as
e 2 := e ( t ) dt
1 -2
If this integral is finite, then the signal e is square integrable, denoted as e
L2. For vector-valued signals,

e1 ( t ) e(t) = e2 ( t ) en ( t ) the 2-norm is defined as
1 -2 2 2 dt )
e 2 := (
= (
1 -2 T e ( t )e ( t )dt )
e(t)
In -Tools the dynamic systems we deal with are exclusively linear, with state-space model
5-26
x = A B x C D d e
or, in the transfer function form e(s) = T(s)d(s), T(s) := C(sI A)1B + D
Two mathematically convenient measures of the transfer matrix T(s) in the frequency domain are the matrix H2 and H norms,
1 -2 1 T 2 := -----T ( j ) F d 2 2
T := max [ T ( j ) ] wR
where the Frobenius norm (see the MATLAB norm command) of a complex matrix M is M F := trace ( M*M )
Both of these transfer function norms have input/output time-domain interpretations. If, starting from initial condition x(0) = 0, two signals d and e are related by x = A B x CD d e
5-27
then: for d, a unit intensity, white noise process, the steady-state variance of e is ||T||2. The L2 (or RMS) gain from d e ,
e 2 max ---------d0 d 2
is equal to ||T||. This is discussed in greater detail in the next section.
Using Weighted Norms to Characterize Performance

In any performance criterion, we must also account for: Relative magnitude of outside influences Frequency dependence of signals Relative importance of the magnitudes of regulated variables So, if the performance objective is in the form of a matrix norm, it should actually be a weighted norm ||WLTWR|| where the weighting function matrices WL and WR are frequency dependent, to account for bandwidth constraints and spectral content of exogenous signals. Within the structured singular value setting considered in chapter ****, the most natural (mathematical) manner to characterize acceptable performance is in terms of the MIMO |||| (H) norm. For this reason, we discuss some interpretations of the H norm.
5-28
e ~
~ d
Figure 5-2: Unweighted MIMO System
Suppose T is a MIMO stable linear system, with transfer function matrix T(s). For a given driving signal d ( t ) , define e as the output, as shown in Figure 5-3. Note that it is more traditional to write the diagram in Figure 5-3 with the arrows going from left to right as in Figure 5-4.
~ d
~ -e
Figure 5-3: Unweighted MIMO System: Vectors from Left to Right
The diagrams in Figure 5-3 and Figure 5-4 represent the exact same system. We prefer to write these block diagrams with the arrows going right to left to be consistent with matrix and operator composition. Assume that the dimensions of T are ne nd. Let > 0 be defined as := T := max [ T ( j ) ] wR
(5-1)
Now consider a response, starting from initial condition equal to 0. In that case, Parsevals theorem gives that
T [ e ( t )e ( t ) dt ] e 2 0 ---------- = ---------------------------------------------------- 12 T d 2 d ( t )d ( t ) dt
12
5-29
e 2 Moreover, there are specific disturbances d that result in the ratio --------- d 2 arbitrarily close to . Because of this, ||T|| is referred to as the L2 (or RMS) gain of the system. As you would expect, a sinusoidal, steady-state interpretation of ||T|| is also possible: For any frequency R , any vector of amplitudes a R n , and any d vector of phases R n d , with ||a||2 1, define a time signal a 1 sin ( t + 1 ) a nd sin ( t + n d ) Applying this input to the system T results in a steady-state response e ss of the form b 1 sin ( t + 1 ) e ss ( t ) = b ne sin ( t + ne ) The vector b R n e will satisfy ||b||2 . Moreover, , as defined in equation Figure 5-4, is the smallest number such that this fact is true for every ||a||2 1, , and . Note that in this interpretation, the vectors of the sinusoidal magnitude responses are unweighted, and measured in Euclidean norm. If realistic multivariable performance objectives are to be represented by a single, MIMO |||| objective on a closed-loop transfer function, additional scalings are necessary. Since many different objectives are being lumped into one matrix and the associated cost is the norm of the matrix, it is important to use frequency-dependent weighting functions, so that different requirements can be meaningfully combined into a single cost function. Diagonal weights are most easily interpreted. Consider the diagram of Figure 5-4, along with Figure 5-3.
d(t) =
5-30
Assume that WL and WR are diagonal, stable transfer function matrices, with diagonal entries denoted Li and Ri. L1 0 0 WL = 0 L2 0 .. . 0 0 Ln ,
e
R1 0 0 WR = 0 R2 0 .. . 0 0 Rn
WL e
e ~
~ d
WR
WL e ~
~ WL T d
WL T WR d
Figure 5-4: Weighted MIMO System
Bounds on the quantity ||WLTWR|| will imply bounds about the sinusoidal steady-state behavior of the signals d and e (= Td ) in Figure 5-3. Specifically, for sinusoidal signal d , the steady-state relationship between e (= Td ) , d and ||WLTWR|| is as follows: The steady-state solution e ss , denoted as e 1 sin ( t + 1 ) e ss ( t ) = e n e sin ( t + n d ) satisfies
(5-2)
ne i=1
W L i ( jw )e i 1 for all sinusoidal input signals d of the form
d(t) =
d 1 sin ( t + i ) d nd sin ( t + n )
d
(5-3)
satisfying
5-31
2 di --------------------------- 1 2 W R ( j ) i=1
nd
if and only if ||WLTWR|| 1. This approximately (very approximately the next statement is not actually correct) implies that ||WLTWR|| 1 if and only if for every fixed frequency , and all sinusoidal disturbances d of the form (5-3) satisfying d i W R ( j ) i the steady-state error components will satisfy 1 e i ----------------------W L ( j )
i
This shows how one could pick performance weights to reflect the desired frequency-dependent performance objective. Use WR to represent the relative 1 magnitude of sinusoids disturbances that might be present, and use --------- to W L represent the desired upper bound on the subsequent errors that are produced. Remember, though, the weighted H norm does not actually give element by-element bounds on the components of e based on element-by-element bounds on the components of d . The precise bound it gives is in terms of Euclidean norms of the components of e and d (weighted appropriately by WL(j ) and WR(j )).
5-32
References
References
[BalPac:] Balas, G.J. and A.K. Packard, The structured singular value -framework, CRC Controls Handbook, Section 2.3.6, pp. 671-688, January, 1996. [BallC:] Ball, J.A. and N. Cohen, Sensitivity minimization in an H norm: Parametrization of all suboptimal solutions, International Journal of Control, vol. 46, pp. 785-816, 1987. [BamP:] Bamieh, B.A. and J.B. Pearson, A general framework for linear periodic systems with applications to H sampled-data control, IEEE Transactions on Automatic Control, vol. AC-37, pp. 418435, 1992. [DGKF:] Doyle, J.C., K. Glover, P. Khargonekar, and B. Francis, State-space solutions to standard H2 and H control problems, IEEE Transactions on Automatic Control, vol. AC-34, no. 8, pp. 831-847, August 1989. [FialBal:] Fialho, I. and G.J. Balas, Design of nonlinear controllers for active vehicle suspensions using parameter-varying control synthesis, Vehicle Systems Dynamics, vol. 33, no. 5, May 2000, pp. 351-370. [Fran1:] Francis, B.A., A course in H control theory, Lecture Notes in Control and Information Sciences, vol. 88, Springer-Verlag, Berlin, 1987. [GloD:] Glover, K. and J.C. Doyle, State-space formulae for all stabilizing controllers that satisfy an H norm bound and relations to risk sensitivity, Systems and Control Letters, vol. 11, pp. 167-172, August 1989. International Journal of Control, vol. 39, pp. 11151193, 1984. [Hedrick90:] Hedrick, J.K. and Batsuen, T., Invariant Properties of Automotive Suspensions, Proceedings of The Institution of Mechanical Engineers, 204 (1990), pp. 21-27. [Lin971:] Lin, J. and Kanellakopoulos, I., ``Road Adaptive Nonlinear Design of Active Suspensions, Proceedings of the American Control Conference, (1997), pp. 714-718. [PacDB:] Packard, A.K., J.C. Doyle, and G.J. Balas, Linear, multivariable robust control with a perspective, ASME Journal of Dynamics, Measurements and Control: Special Edition on Control, vol. 115, no. 2b, June, 1993, pp. 426-438.
5-33
[SkoP:] Skogestad, S. and I. Postlethwaite, Multivariable Feedback Control: Analysis & Design, John Wiley & Sons, 1996. [SteD:] Stein, G., and J. Doyle, Beyond singular values and loopshapes, AIAA Journal of Guidance and Control, vol. 14, num. 1, pp. 5-16, January, 1991. [Zame:] Zames, G., Feedback and optimal sensitivity: model reference transformations, multiplicative seminorms, and approximate inverses, IEEE Transactions on Automatic Control, vol. AC-26, pp. 301-320, 1981.
5-34
6
Introduction to Uncertain Atoms (p. 6-2) Uncertain Matrices (p. 6-19) Uncertain State-Space Systems (uss) (p. 6-25) Uncertain frd (p. 6-33) Basic Control System Toolbox Interconnections (p. 6-37) Simplifying Representation of Uncertain Objects (p. 6-38) Sampling Uncertain Objects (p. 6-42) Substitution by usubs (p. 6-46) Array Management for Uncertain Objects (p. 6-49) Decomposing Uncertain Objects (for Advanced Users) (p. 6-60)
How to build uncertain real, complex, and LTI uncertain matrices, dynamics, and systems How to manipulate matrices used in systems with structured uncertainty Building systems with uncertain state-space matrices and/or uncertain linear dynamics Discusses uncertain frequency response data (frd) objects A list of Control System Toolbox interconnection commands that work with uncertain objects How to simplify representations of uncertain objects in your models How to randomly sample uncertain objects How to fix a subset of uncertain objects in your model while leaving the rest uncertain Working with multidimensional arrays containing uncertain objects Discusses advanced decomposition techniques
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,
6-2
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 the section Sampling Uncertain Objects on page 6-42 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 the parameter's value. All properties of a ureal can be accessed through get and set. The properties are:
Properties Name NominalValue Mode Meaning Class char double char
Internal Name Nominal value of atom Signifies which description (from

'PlusMinus','Range','Percentage') of
uncertainty is invariant when

NominalValue is changed PlusMinus
Additive variation
scalar or 1x2 double

1x2 double
Range Percentage
Numerical range Additive variation (% of absolute value of nominal)

'off' | {'basic'} |'full'
scalar or 1x2 double

char
AutoSimplify
6-3
The properties Range, Percentage and PlusMinus are all automatically synchronized. If the nominal value is 0, then the Mode cannot be Percentage. The Mode property controls what aspect of the uncertainty remains unchanged when NominalValue is changed. Assigning to any of Range/Percentage/PlusMinus changes the value, but does not change the mode. The AutoSimplify property controls how expressions involving the real parameter are simplified. Its default value is 'basic', which means elementary methods of simplification are applied as operations are completed. Other values for AutoSimplify are 'off' (no simplification performed) and 'full' (model-reduction-like techniques are applied). See the section Simplifying Representation of Uncertain Objects on page 6-38 to learn more about the AutoSimplify property and the command simplify. If no property/value pairs are specified, default values are used. The default
Mode is PlusMinus, and the default value of PlusMinus is [-1 1]. Some
examples are shown below. In many cases, the full property name is not specified, taking advantage of the case-insensitive, partial name property matching. Create an uncertain real parameter, nominal value 3, with default values for all unspecified properties (including plus/minus variability of 1). View the properties and their values, and note that the Range and Percentage descriptions of variability are automatically maintained.
a = ureal('a',3) Uncertain Real Parameter: Name a, NominalValue 3, variability = [-1 1] get(a) Name: 'a' NominalValue: 3 Mode: 'PlusMinus' Range: [2 4] PlusMinus: [-1 1] Percentage: [-33.3333 33.3333] AutoSimplify: 'basic'
Create an uncertain real parameter, nominal value 2, with 20% variability. Again, view the properties, and note that the Range and PlusMinus descriptions of variability are automatically maintained.
6-4
b = ureal('b',2,'percentage',20) Uncertain Real Parameter: Name b, NominalValue 2, variability = [-20 20]% get(b) Name: 'b' NominalValue: 2 Mode: 'Percentage' Range: [1.6000 2.4000] PlusMinus: [-0.4000 0.4000] Percentage: [-20.0000 20.0000] AutoSimplify: 'basic'
Change the range of the parameter. All descriptions of variability are automatically updated, while the nominal value remains fixed. Although the change in variability was accomplished by specifying the Range, the Mode is unaffected, and remains Percentage.
b.Range = [1.9 2.3]; get(b) Name: 'b' NominalValue: 2 Mode: 'Percentage' Range: [1.9000 2.3000] PlusMinus: [-0.1000 0.3000] Percentage: [-5.0000 15.0000] AutoSimplify: 'basic'
As mentioned, the Mode property signifies what aspect of the uncertainty remains unchanged when NominalValue is modified. Hence, if a real parameter is in Percentage mode, then the Range and PlusMinus properties are determined from the Percentage property and NominalValue. Changing NominalValue preserves the Percentage property, and automatically updates the Range and PlusMinus properties.
b.NominalValue = 2.2; get(b) Name: 'b' NominalValue: 2.2000 Mode: 'Percentage' Range: [2.0900 2.5300] PlusMinus: [-0.1100 0.3300]
6-5
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 30]% get(e) Name: 'e' NominalValue: 10 Mode: 'Percentage' Range: [8 13] PlusMinus: [-2 3]
6-6
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 40]% g = ureal('g',2,'plusminus',[-2 1],'mode','range','perce',40) Uncertain Real Parameter: Name g, NominalValue 2, Range [1.2 2.8] g.Mode ans = Range
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);
6-7
Make the range unsymmetric about the nominal value, and repeat the sampling, and histogram plot (with 40 bins over the range of 2-to-6)
h.Range = [2 6]; hsample = usample(h,1000); hist(reshape(hsample,[1000 1]),40);
6-8
80
70
60
50
40
30
20
10
2.5
3.5
4.5
5.5
Note that the distribution is skewed. However, the number of samples less than the nominal value and the number of samples greater than the nominal value is equal (on average). Verify this.
length(find(hsample(:)<h.NominalValue)) ans = 509 length(find(hsample(:)>h.NominalValue)) ans = 491
The distribution used in usample is uniform in the normalized description of the uncertain real parameter. See the section Decomposing Uncertain Objects (for Advanced Users) on page 6-60 to learn more about the normalized description. There is no notion of an empty ureal (or any other atom, for that matter). ureal, by itself, creates an unnamed atom, with default property values. The given name is 'UNNAMED'. This can be observed with get and set.
get(ureal) Name: 'UNNAMED' NominalValue: 0 Mode: 'PlusMinus'
6-9
Range: PlusMinus: Percentage: AutoSimplify: set(ureal) Name: NominalValue: Mode: Range: PlusMinus: Percentage: AutoSimplify:
[-1 1] [-1 1] [-Inf Inf] 'basic' 'String' '1x1 real DOUBLE' 'Range | PlusMinus' '1x2 DOUBLE' '1x2 or scalar DOUBLE' 'Not settable since Nominal==0' '['off' | 'basic' | 'full']'
Uncertain LTI Dynamics Atoms

Uncertain linear, time-invariant objects, ultidyn, are used to represent unknown linear, time-invariant dynamic objects, whose only known attributes are bounds on their frequency response. Uncertain linear, time-invariant objects have an internal name (the Name property), and are created by specifying their size (number of outputs and number of inputs). The property Type specifies whether the known attributes about the frequency response are related to gain or phase. The property Type may be 'GainBounded' or 'PositiveReal'. The default value is 'GainBounded'. The property Bound is a single number, which along with Type, completely specifies what is known about the uncertain frequency response. Specifically, if is an ultidyn atom, and if denotes the value of the Bound property, then the atom represents the set of all stable, linear, time-invariant systems whose frequency response satisfies certain conditions: If Type is 'GainBounded', [ ( ) ] for all frequencies. When Type is 'GainBounded', the default value for Bound (i.e., ) is 1. The NominalValue of is always the 0-matrix. If Type is 'PositiveReal', ()+*()2 for all frequencies. When Type is 'PositiveReal', the default value for Bound (i.e., ) is 0. The NominalValue is always (+1+2||)I.
6-10
All properties of a ultidyn are can be accessed with get and set (although the NominalValue is determined from Type and Bound, and not accessible with set). The properties are
Properties Name NominalValue Type Bound SampleStateDim Meaning Class char See above char
Internal Name Nominal value of atom

'GainBounded' |'PositiveReal'
Norm bound or minimum real State-space dimension of random samples of this uncertain element
'off' | {'basic'} |'full'
scalar double scalar double

char
AutoSimplify
The SampleStateDim property specifies the state dimension of random samples of the atom when using usample. The default value is 1. The AutoSimplify property serves the same function as in the uncertain real parameter. You can create a 2-by-3 gain-bounded uncertain linear dynamics atom. Verify its size, and check the properties.
f = ultidyn('f',[2 3]); size(f) ans = 2 3 get(f) Name: 'f' NominalValue: [2x3 double] Type: 'GainBounded' Bound: 1 SampleStateDim: 1 AutoSimplify: 'basic'
You can create a 1-by-1 (scalar) positive-real uncertain linear dynamics atom, whose frequency response always has real part greater than -0.5. Set the
6-11
SampleStateDim property to 5. View the properties, and plot a Nyquist plot of
30 instances of the atom.

g = ultidyn('g',[1 1],'type','positivereal','bound',-0.5); g.SampleStateDim = 5; get(g) Name: 'g' NominalValue: 1.5000 Type: 'PositiveReal' Bound: -0.5000 SampleStateDim: 5 AutoSimplify: 'basic' nyquist(usample(g,30)) xlim([-2 10]) ylim([-6 6]);
Nyquist Diagram
2
Imaginary Axis
6 2
4
Real Axis
10
Time-domain of ultidyn atoms

On its own, every ultidyn atom is interpreted as a continuous-time, system with uncertain behavior, quantified by bounds (gain or real-part) on its
6-12
frequency response. To see this, create a ultidyn, and view the sample time of several random samples of the atom.
h = ultidyn('h',[1 1]); get(usample(h),'Ts') ans = 0 get(usample(h),'Ts') ans = 0 get(usample(h),'Ts') ans = 0
However, when a ultidyn atom is an uncertain element of an uncertain state space model (uss), then the time-domain characteristic of the atom is determined from the time-domain characteristic of the system. The bounds (gain-bounded or positivity) apply to the frequency-response of the atom. SEe the section Interpreting Uncertainty in Discrete Time on page 6-30 for more information.
Complex Parameter Atoms

The ucomplex atom represents an uncertain complex number, whose value lies in a disc, centered at NominalValue, with radius specified by the Radius property. The size of the disc can also be specified by Percentage, which means the radius is derived from the absolute value of the NominalValue. The properties of ucomplex objects are
Properties Name NominalValue Mode Radius Meaning Class char double char
Internal Name Nominal value of atom

'Range' | 'Percentage'
Radius of disk
double
6-13
Properties Percentage AutoSimplify
Meaning
Class
Additive variation (percent of Radius)

'off' | {'basic'} | 'full'
double
char
The simplest construction requires only a name and nominal value. The default Mode is Radius, and the default radius is 1.
a = ucomplex('a',2-j) Uncertain Complex Parameter: Name a, NominalValue 2-1i, Radius 1 get(a) Name: 'a' NominalValue: 2.0000- 1.0000i Mode: 'Radius' Radius: 1 Percentage: 44.7214 AutoSimplify: 'basic' set(a) Name: 'String' NominalValue: '1x1 DOUBLE' Mode: 'Radius | Percentage' Radius: 'scalar DOUBLE' Percentage: 'scalar DOUBLE' AutoSimplify: '['off' | 'basic' | 'full']'
Sample the uncertain complex parameter at 400 values, and plot in the complex plane. Clearly, the samples appear to be from a disc of radius 1, centered in the complex plane at the value 2j.
asample = usample(a,400); plot(asample(:),'o'); xlim([0 4]); ylim([-3 1]);
6-14
0.5
0.5
1.5
2.5
3 0
0.5
1.5
2.5
3.5
Complex Matrix Atoms

The uncertain complex matrix class, ucomplexm, represents the set of matrices given by the formula N + W L W R where N,WL,WR are known matrices, and is any complex matrix with ( ) 1 . All properties of a ucomplexm are can be accessed with get and set. The properties are
Properties Name NominalValue WL Meaning Class char double double
Internal Name Nominal value of atom Left weight
6-15
Properties WR AutoSimplify
Meaning
Class
Right weight
'off' | {'basic'} | 'full'
double
char
The simplest construction requires only a name and nominal value. The default left and right weight matrices are identity. You can create a 4-by-3 ucomplexm element, and view its properties.
m = ucomplexm('m',[1 2 3;4 5 6;7 8 9;10 11 12]) Uncertain Complex Matrix: Name m, 4x3 get(m) Name: 'm' NominalValue: [4x3 double] WL: [4x4 double] WR: [3x3 double] AutoSimplify: 'basic' m.NominalValue ans = 1 2 3 4 5 6 7 8 9 10 11 12 m.WL ans = 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
Sample the uncertain matrix, and compare to the nominal value. Note the element-by-element sizes of the difference are generally equal, indicative of the default (identity) weighting matrices that are in place.
abs(usample(m)-m.NominalValue) ans = 0.2948 0.1001 0.2867 0.3028 0.2384 0.2508 0.3376 0.1260 0.2506
6-16
0.2200
0.3472
0.1657
Change the left and right weighting matrices, making the uncertainty larger as you move down the rows, and across the columns.
m.WL = diag([0.2 0.4 0.8 1.6]); m.WR = diag([0.1 1 4]);
Sample the uncertain matrix, and compare to the nominal value. Note the element-by-element sizes of the difference, and the general trend that the smallest differences are near the (1,1) element, and the largest differences are near the (4,3) element, which is completely expected by choice of the diagonal weighting matrices.
abs(usample(m)-m.NominalValue) ans = 0.0091 0.0860 0.2753 0.0057 0.1717 0.6413 0.0304 0.2756 1.4012 0.0527 0.4099 1.8335
Unstructured Uncertain Dynamic Systems

The unstructured uncertain dynamic system class, udyn, represents completely unknown multivariable, time-varying nonlinear systems. For practical purposes, these uncertain elements represent noncommuting symbolic variables (placeholders). All algebraic operations, such as addition, subtraction, multiplication (i.e., cascade) operate properly, and substitution (with usubs) is allowed. However, all of the analysis tools (e.g., robuststab) do not handle these types of uncertain elements. As such, these elements do not provide a significant amount of usability, and their role in the user's guide is small. You can create a 2-by-3 udyn element. Check its size, and properties.
m = udyn('m',[2 3]) Uncertain Dynamic System: Name m, size 2x3 size(m) ans = 2 3 get(m) Name: 'm'
6-17
NominalValue: [2x3 double] AutoSimplify: 'basic'
6-18
Uncertain Matrices
Uncertain Matrices
Uncertain matrices (class umat) are built from doubles, and uncertain atoms, using traditional MATLAB matrix building syntax. Uncertain matrices can be added, subtracted, multiplied, inverted, transposed, etc., resulting in uncertain matrices. The rows and columns of an uncertain matrix are referenced in the same manner that MATLAB references rows and columns of an array, using parenthesis, and integer indices. The NominalValue of a uncertain matrix is the result obtained when all uncertain atoms are replaced with their own NominalValue. The uncertain atoms making up a umat are accessible through the Uncertainty gateway, and the properties of each atom within a umat can be changed directly. Using usubs, specific values may be substituted for any of the uncertain atoms within a umat. The command usample generates a random sample of the uncertain matrix, substituting random samples (within their ranges) for each of the uncertain atoms. The command wcnorm computes tight bounds on the worst-case (maximum over the uncertain elements' ranges) norm of the uncertain matrix. Standard MATLAB numerical matrices (i.e., double) naturally can be viewed as uncertain matrices without any uncertainty.
Creating Uncertain Matrices from Uncertain Atoms

You can create 2 uncertain real parameters, and then a 3-by-2 uncertain matrix using these uncertain atoms.
a = ureal('a',3); b = ureal('b',10,'pe',20); M = [-a 1/b;b a+1/b;1 3] UMAT: 3 Rows, 2 Columns a: real, nominal = 3, variability = [-1 1], 2 occurrences b: real, nominal = 10, variability = [-20 20]%, 3 occurrences
The size and class of M are as expected

size(M) ans = 3 class(M) ans =
6-19
umat
Accessing Properties of a umat

Use get to view the accessible properties of a umat.
get(M) NominalValue: [3x2 double] Uncertainty: [1x1 atomlist]
The NominalValue is a double, obtained by replacing all uncertain elements with their nominal values.
M.NominalValue ans = -3.0000 0.1000 10.0000 3.1000 1.0000 3.0000
The Uncertainty property is a atomlist object, which is simply a gateway from the umat to the uncertain atoms.
class(M.Uncertainty) ans = atomlist M.Uncertainty a: [1x1 ureal] b: [1x1 ureal]
Direct access to the atoms is facilitated through Uncertainty. Check the Range of the uncertain element named 'a' within M, then change it.
M.Uncertainty.a.Range ans = 2 4 M.Uncertainty.a.Range = [2.5 5]; M UMAT: 3 Rows, 2 Columns a: real, nominal = 3, variability = [-0.5 2], 2 occurrences b: real, nominal = 10, variability = [-20 20]%, 3 occurrences
6-20
Uncertain Matrices
The change to the uncertain real parameter a only took place within M. Verify that the variable a in the workspace is no longer the same as the variable a within M.
isequal(M.Uncertainty.a,a) ans = 0
Note that combining atoms which have a common internal name, but different properties leads to an error. For instance, subtracting the two atoms gives an error, not 0.
M.Uncertainty.a - a ??? Error using ==> ndlft.lftmask
Atoms named 'a' have different properties.
Row and Column Referencing

Standard Row/Column referencing is allowed. Note, however, that single-indexing is only allowed if the umat is a column or a row. Reconstruct M (if need be), and make a 2-by-2 selection from M
a = ureal('a',3); b = ureal('b',10,'pe',20); M = [-a 1/b;b a+1/b;1 3]; M.Uncertainty.a.Range = [2.5 5]; M(2:3,:) UMAT: 2 Rows, 2 Columns a: real, nominal = 3, variability = [-0.5 2], 1 occurrence b: real, nominal = 10, variability = [-20 20]%, 2 occurrences
Make a single column selection from M, and use single-index references to access elements of it.
h = M([2 1 2 3],2) UMAT: 4 Rows, 1 Columns a: real, nominal = 3, variability = [-0.5 2], 1 occurrence b: real, nominal = 10, variability = [-20 20]%, 1 occurrence h(2) UMAT: 1 Rows, 1 Columns b: real, nominal = 10, variability = [-20 20]%, 1 occurrence
6-21
h(3) UMAT: 1 Rows, 1 Columns a: real, nominal = 3, variability = [-0.5 2], 1 occurrence b: real, nominal = 10, variability = [-20 20]%, 1 occurrence
Finally, make the (3,2) entry of M uncertain.

M(3,2) = ureal('c',3,'perc',40) UMAT: 3 Rows, 2 Columns a: real, nominal = 3, variability = [-0.5 2], 2 occurrences b: real, nominal = 10, variability = [-20 20]%, 2 occurrences c: real, nominal = 3, variability = [-40 40]%, 1 occurrence
Matrix Operation on umat Objects

Many matrix operations are allowed, such as matrix-multiply, transpose, and inverse. Combinations of certain (i.e., not uncertain) matrices and uncertain matrices are allowed. Premultiply M by a 1-by-3 constant matrix, resulting in a 1-by-2 umat.
M1 = [2 3 1]*M UMAT: 1 Rows, 2 Columns a: real, nominal = 3, variability = [-0.5 2], 1 occurrence b: real, nominal = 10, variability = [-20 20]%, 2 occurrences c: real, nominal = 3, variability = [-40 40]%, 1 occurrence
Verify that the 1st entry of M1 is -2*a + 3*b + 1. Direct subtraction yields a umat without any dependence on uncertain elements. Simplifying the class shows that the result is zero as expected.
d = M1(1) - (-2*M.Uncertainty.a + 3*M.Uncertainty.b + 1) UMAT: 1 Rows, 1 Columns simplify(d,'class') ans = 0
Transpose M, form a product, an inverse, and sample the uncertain result. As expected, the result is the 2-by-2 identity matrix.
H = M.'*M; K = inv(H); usample(K*H,3)
6-22
Uncertain Matrices
ans(:,:,1) = 1.0000 -0.0000 -0.0000 1.0000 ans(:,:,2) = 1.0000 -0.0000 -0.0000 1.0000 ans(:,:,3) = 1.0000 -0.0000 -0.0000 1.0000
Substituting for Uncertain Atoms

You can substitute for uncertain atoms by using usubs, as described in the section Substitution by usubs on page 6-46. This section describes some special cases. Substitute all instances of the uncertain real parameter named a with the number 4. This results in a umat, with dependence on the uncertain real parameters b and c.
M2 = usubs(M,'a',4) UMAT: 3 Rows, 2 Columns b: real, nominal = 10, variability = [-20 20]%, 2 occurrences c: real, nominal = 3, variability = [-40 40]%, 1 occurrence
Similarly, we can substitute all instances of the uncertain real parameter named b with M.Uncertainty.a, resulting in a umat with dependence on the uncertain real parameters a and c.
M3 = usubs(M,'b', M.Uncertainty.a) UMAT: 3 Rows, 2 Columns a: real, nominal = 3, variability = [-0.5 2], 4 occurrences c: real, nominal = 3, variability = [-40 40]%, 1 occurrence Nominal and/or random instances can easily be specified. M4 = usubs(M,'a','nominal','b','random') UMAT: 3 Rows, 2 Columns c: real, nominal = 3, variability = [-40 40]%, 1 occurrence
If one value is being substituted for many different atoms, the atom names can be listed in a cell array, and then the value given. For example, substitute a and b with the number 4, and c with the number 5.
M5 = usubs(M,{'a' 'b'},4,'c',5)
6-23
M5 = -4.0000 4.0000 1.0000
0.2500 4.2500 5.0000
The command usample also generates multiple random instances of a umat (and uss and ufrd). See the section Sampling Uncertain Objects on page 6-42 for more information.
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 = [1 2 3;4 5 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 3rd dimension and beyond are interpreted as array dimensions. See the section Array Management for Uncertain Objects 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]
6-24
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 the ss object, which is familiar to the users of the Control System Toolbox.
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
6-25
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 {2x1 0 {''} {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 the ss object of the Control System Toolbox, and therefore 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)
6-26
Step Response
0.05
To: Out(1) Amplitude To: Out(2)
0.1
0.15
0.2
0.25 0.1 0.09 0.08 0.07 0.06 0.05 0.04 0.03 0.02 0.01 0 0 0.1 0.2 0.3 Time (sec) 0.4 0.5 0.6 0.7
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 the Control System Toolbox 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)
6-27
0 0.05 0.1 0.15 0.2 0.25 0.3 0.35
Step Response
Amplitude
0.4 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0 0.1 0.2 0 0.5 1 Time (sec) 1.5 2 2.5
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 and the nominal value for these 20 models. The same features are available for bode, bodemag and nyquist.
Feedback Around 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);
6-28
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)
6 5 4
Step Response
Amplitude
3 2 1 0 1 2 0 0.5 1 1.5 2 2.5 Time (sec) 3 3.5 4 4.5 5
1.5
Step Response
Amplitude
0.5
0.5
0.5
1.5
2.5 Time (sec)
3.5
4.5
6-29
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 the first 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 has been studied by many authors, see [DullerudGlover], but it is beyond the scope of the toolbox.
6-30
Lifting a ss to a uss
A non-certain 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 the ss to the uss class.
sys = rss(3,2,1); usys = uss(sys) USS: 3 States, 2 Outputs, 1 Input, Continuous System
Arrays of ss objects can also be lifted. See the sectionArray Management for Uncertain Objects on page 6-49 for more information about handling arrays of uncertain objects.
Handling Delays in uss

In the current implementation, delays are not allowed. Delays are omitted and a warning is displayed when ss objects are lifted to uss objects.
sys = rss(3,2,1); sys.inputdelay = 1.3; usys = uss(sys) Warning: Omitting DELAYs in conversion to USS > In uss.uss at 103 USS: 3 States, 2 Outputs, 1 Input, Continuous System
This lifting process happens in the background whenever ss objects are combined with any uncertain object. Consequently all delays will be lost in such operations. Use the command pade to approximately preserve the effect of the time delay in the ss object. Before operations involving ss objects containing delays and uncertain objects, use the pade command to convert the ss object to a delay free object. For example, consider an uncertain system with a time constant approximately equal to 1, an extra input delay of 0.3 seconds, second-order rolloff beyond 20 rad/s, and an uncertain steady-state gain ranging from 4 to 6. This can be approximated using the pade command as follows.
sys = tf(1,[1 1])*tf(1,[0.05 1]); sys.inputdelay = 0.3; gain = ureal('gain',5); usys = gain*pade(sys,4)
6-31
USS: 6 States, 1 Output, 1 Input, Continuous System gain: real, nominal = 5, variability = [-1 1], 1 occurrence
If gain is multiplied by sys directly, the time delay is unfortunately omitted, since this operation involves lifting sys to a uss as described above. The difference is obvious from the step responses.
step(usys,gain*sys,4,5) Warning: Omitting DELAYs in conversion to USS > In uss.uss at 103 In umat.umat at 98 In atom.mtimes at 7
Step Response
Amplitude
2 1 0 1 0
0.5
1.5
2 Time (sec)
2.5
3.5
6-32
Uncertain frd
Uncertain frd
Uncertain frequency responses (ufrd) arise naturally when computing the frequency response of an uncertain state-space (uss). They also arise when frequency response data (in an frd object) is combined (added, multiplied, concatenated, etc.) to an uncertain matrix (umat).
Creating Uncertain Frequency Response Objects

The most common manner in which a ufrd arises is taking the frequency response of a uss. The natural command that would do this is frd (an overloaded version in the @uss directory). Reconstruct sys, if necessary.
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]; 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
Compute the uncertain frequency response of the uncertain system. Use the frd command, along with a frequency grid containing 100 points. The result is an uncertain frequency response data object, referred to as a ufrd.
sysg = frd(sys,logspace(-2,2,100)) UFRD: 2 Outputs, 1 Input, Continuous System, 100 Frequency points 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 ufrd objects

View the properties with the get command.
6-33
get(sysg) Frequency: ResponseData: Units: Ts: InputName: OutputName: InputGroup: OutputGroup: NominalValue: Uncertainty: Notes: UserData: Version:
[100x1 double] [2x1x100 umat] 'rad/s' 0 {''} {2x1 cell} [1x1 struct] [1x1 struct] [2x1 frd] [1x1 atomlist] {} [] 4
The properties ResponseData and Frequency behave in exactly the same manner as Control System Toolbox frd objects, except that ResponseData is a umat. 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 frd object, and hence all methods for frd objects are available. For instance, plot the Bode response of the nominal system.
bode(sysg.nom)
6-34
Uncertain frd
0 10
Bode Diagram
To: Out(1) Magnitude (dB) ; Phase (deg) To: Out(2) To: Out(1) To: Out(2)
20 30 40 180
90 0 20 40 60 80 100 0
90
180 3 10
10
10
10 Frequency (Hz)
10
10
Just as with the umat and uss classes, the Uncertainty property is an atomlist object, acting as a gateway to the uncertain atoms. Direct access to the atoms is facilitated through Uncertainty. Change the nominal value of the uncertain element named 'p1' within sysg to 14, and replot the Bode plot of the (new) nominal system.
sysg.unc.p1.nom = 14 UFRD: 2 Outputs, 1 Input, Continuous System, 100 Frequency points p1: real, nominal = 14, 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
6-35
Interpreting Uncertainty in Discrete Time

This issue is described in the section Interpreting Uncertainty in Discrete Time on page 6-30.
Lifting an frd to a ufrd

A not-uncertain frequency response object may be interpreted as an uncertain frequency response object that has no dependence on uncertain atoms. Use the ufrd command to lift an frd object to the ufrd class.
sys = rss(3,2,1); sysg = frd(sys,logspace(-2,2,100)); usysg = ufrd(sysg) UFRD: 2 Outputs, 1 Input, Continuous System, 100 Frequency points
Arrays of frd objects can also be lifted. See the section Array Management for Uncertain Objects on page 6-49 for more information.
Handling Delays in ufrd

This is identical to handling delays in USS, as described in the section Handling Delays in uss on page 6-31.
6-36
Basic Control System Toolbox Interconnections
Basic Control System Toolbox Interconnections

All of the basic system interconnections defined in the Control System Toolbox append blkdiag series parallel feedback lft star starp work with uncertain objects as well. Uncertain objects may be combined with certain objects, resulting in an uncertain object.
6-37
Simplifying Representation of Uncertain Objects

A minimal realization of the transfer function matrix 2 --------s+1 H(s) = 3 ----------s+1 4 --------s+1 6 ----------s+1
has only 1 state, obvious from the decomposition 1 H ( s ) = 2 ----------- 1 2 . 3 s+1 However, a natural construction, formed by
sys11 sys12 sys21 sys22 sys = a = x1 x2 x3 x4 b = x1 x2 x3 = ss(tf(2,[1 1])); = ss(tf(4,[1 1])); = ss(tf(3,[1 1])); = ss(tf(6,[1 1])); [sys11 sys12;sys21 sys22] x1 -1 0 0 0 u1 2 0 2 x2 0 -1 0 0 u2 0 2 0 x3 0 0 -1 0 x4 0 0 0 -1
x4 0 2
c = y1 y2 d = x1 1 0 x2 2 0 x3 0 1.5 x4 0 3
6-38
u1 u2 y1 0 0 y2 0 0 Continuous-time model.
has 4 states, and is nonminimal. In the same manner, the internal representation of uncertain objects built up from uncertain atoms 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 atom 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 atoms, and attempting to simplify (without error) the representation of the effect of that uncertain object. The AutoSimplify property of each atom 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.
Effect of AutoSimplify Property

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
6-39
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 =
6-40
0 0 usubs(m4,'a',0) ans = 1.0e-015 * -0.4441
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
Direct Use of simplify

The simplify command can be used to override the AutoSimplify property of all uncertain element. 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 4 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 2 occurrences of a after the reduction.
6-41
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 = 1 1 20
Similarly, 30 samples of the 1-by-3 umat M yields a 1-by-3-by-30 array.

size(usample(M,30)) ans = 1 3 30
See the section Creating Arrays With usample on page 6-53 for more information about sampling uncertain objects.
6-42
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.
Plot the Nyquist plot of these samples and add a disk of radius 3. Note that the gain bound is satisfied and that the Nyquist plots are all circles, indicative of 1st order systems.
nyquist(delS) hold on; theta = linspace(-pi,pi); plot(del.Bound*exp(sqrt(-1)*theta),'r'); hold off;
6-43
Nyquist Diagram
1.5
0.5
Imaginary Axis
0.5
1.5
2 3
0 Real Axis
Change the SampleStateDim to 4, and repeat entire procedure. The Nyquist plots satisfy the gain bound and as expected are more complex than the circles found in the 1st-order sampling.
del.SampleStateDim = 4; delS = usample(del,30); nyquist(delS) hold on; theta = linspace(-pi,pi); plot(del.Bound*exp(sqrt(-1)*theta),'r'); hold off;
6-44
Nyquist Diagram
Imaginary Axis
3 3
0 Real Axis
6-45
Substitution by usubs
If an uncertain object (umat, uss, ufrd) has many uncertain parameters, it is often necessary to freeze some, but not all, of the uncertain parameters to specific values. The usubs command accomplishes this, and also allows more complicated substitutions for an atom.
usubs accepts a list of atom names, and respective values to substitute for them. You can create 3 uncertain real parameters and use them to create a 2-by-2 uncertain matrix A. delta = ureal('delta',2); eta = ureal('eta',6); rho = ureal('rho',-1); A = [3+delta+eta delta/eta;7+rho rho+delta*eta] UMAT: 2 Rows, 2 Columns delta: real, nominal = 2, variability = [-1 1], 2 occurrences eta: real, nominal = 6, variability = [-1 1], 3 occurrences rho: real, nominal = -1, variability = [-1 1], 1 occurrence
Use usubs to substitute the uncertain element named delta in A with the value 2.3, leaving all other uncertain atoms intact. Note that the result, B, is an uncertain matrix with dependence only on eta and rho.
B = usubs(A,'delta',2.3) UMAT: 2 Rows, 2 Columns eta: real, nominal = 6, variability = [-1 1], 3 occurrences rho: real, nominal = -1, variability = [-1 1], 1 occurrence
To set multiple atoms, list individually, or in cells. The following are the same
B1 = usubs(A,'delta',2.3,'eta',A.Uncertainty.rho); B2 = usubs(A,{'delta';'eta'},{2.3;A.Uncertainty.rho});
In each case, delta is replaced by 2.3, and eta is replaced by

A.Uncertainty.rho.
If it makes sense, a single replacement value can be used to replace multiple atoms. So
B3 = usubs(A,{'delta';'eta'},2.3);
replaces both the atoms delta and eta with the real number 2.3. Any superfluous substitution requests are ignored. Hence
6-46
Substitution by usubs
B4 = usubs(A,'fred',5);
is the same as A, and

B5 = usubs(A,{'delta';'eta'},2.3,{'fred' 'gamma'},0);
is the same as B3.
Specifying the Substitution with Structures

An alternative syntax for usubs is to specify the substituted values in a structure, whose fieldnames are the names of the atoms being substituted with values. Create a structure NV with 2 fields, delta and eta. Set the values of these fields to be the desired values. Then perform the substitution with usubs.
NV.delta = 2.3; NV.eta = A.Uncertainty.rho; B6 = usubs(A,NV);
Here, B6 is the same as B1 and B2 above. Again, any superfluous fields are ignored. Therefore, adding an additional field gamma to NV, and substituting does not alter the result.
NV.gamma = 0; B7 = usubs(A,NV);
Here, B7 is the same as B6. The commands wcgain, robuststab, and usample all return substitutable values in this structure format. See the section Creating Arrays With usubs on page 6-55 for more information.
Nominal and Random Values

If the replacement value is the (partial and case-independent) string 'Nominal', then the listed atom are replaced with their nominal values. Therefore
B8 = usubs(A,fieldnames(A.Uncertainty),'nom') B8 = 11.0000 0.3333 6.0000 11.0000
6-47
B9 = A.NominalValue B9 = 11.0000 0.3333 6.0000 11.0000
are the same. It is possible to only set some of the atoms to NominalValues, and would be the typical use of usubs with the 'nominal' argument. Within A, set eta to its nominal value, delta to a random value (within its range) and rho to a specific value, say 6.5
B10 = usubs(A,'eta','nom','delta','rand','rho',6.5) B10 = 10.5183 0.2531 13.5000 15.6100
Unfortunately, the 'Nominal' and 'Random' specifiers may not be used in the structure format. However, explicitly setting a field of the structure to an atom's nominal value, and then following (or preceeding) the call to usubs with a call to usample (to generate the random samples) is acceptable, and achieves the same effect.
6-48
Array Management for Uncertain Objects

All of the uncertain system classes (uss, ufrd) may be multidimensional arrays. This is intended to provide the same functionality as the LTI-arrays of the Control System Toolbox. The command size returns a row vector with the sizes of all dimensions. The first two dimensions correspond to the outputs and inputs of the system. Any dimensions beyond are referred to as the array dimensions. Hence, if szM = size(M), then szM(3:end) are sizes of the array dimensions of M. For these types of objects, it is clear that the first two dimensions (system output and input) are interpreted differently from the 3rd, 4th, 5th and higher dimensions (which often model parametrized variability in the system input/output behavior).
umat objects are treated in the same manner. The first two dimensions are the rows and columns of the uncertain matrix. Any dimensions beyond are the array dimensions.
Referencing Arrays
Suppose M is a umat, uss or ufrd, and that Yidx and Uidx are vectors of integers. Then
M(Yidx,Uidx)
selects the outputs (rows) referred to by Yidx and the inputs (columns) referred to by Uidx, preserving all of the array dimensions. For example, if size(M) equals [4 5 3 6 7], then (for example) the size of M([4 2],[1 2 4]) is [2 3 3 6 7]. If size(M,1)==1 or size(M,2)==1, then single indexing on the inputs or outputs (rows or columns) is allowed. If Sidx is a vector of integers, then M(Sidx) selects the corresponding elements. All array dimensions are preserved. If there are K array dimensions, and idx1, idx2, ..., idxK are vectors of integers, then
G = M(Yidx,Uidx,idx1,idx2,...,idxK)
selects the outputs and inputs referred to by Yidx and Uidx, respectively, and selects from each array dimension the slices referred to by the idx1,
6-49
idx2,..., idxK index vectors. Consequently, size(G,1) equals length(Yidx), size(G,2) equals length(Uidx), size(G,3) equals length(idx1), size(G,4) equals length(idx2), and size(G,K+2) equals length(idxK).
If M has K array dimensions, and less than K index vectors are used in doing the array referencing, then the MATLAB convention for single indexing is followed. For instance, suppose size(M) equals [3 4 6 5 7 4]. The expression
G = M([1 3],[1 4],[2 3 4],[5 3 1],[8 10 12 2 4 20 18])
is valid. The result has size(G) equals [2 2 3 3 7]. The last index vector [8 10 12 2 4 20 18] is used to reference into the 7-by-4 array, preserving the order dictated by MATLAB single indexing (e.g., the 10th element of a 7-by-4 array is the element in the (3,2) position in the array). Note that if M has either one output (row) or one input (column), and M has array dimensions, then it is not allowable to combine single indexing in the output/input dimensions along with indexing in the array dimensions. This will result in an ambiguity in how to interpret the second index vector in the expression (i.e., does it correspond to the input/output reference, or does it correspond to the first array dimension?).
Creating Arrays with stack, cat

An easy manner to create an array is with stack. Create a [4-by-1] umat array by stacking four 1-by-3 umat objects with the stack command. The first argument of stack specifies in which array dimension the stacking occurs. In the example below, the stacking is done is the 1st array dimension, hence the result is a 1-by-3-by-4-by-1 umat, referred to as a 4-by-1 umat array.
a = ureal('a',4); b = ureal('b',2); M = stack(1,[a b 1],[-a UMAT: 1 Rows, 3 Columns a: real, nominal = 4, b: real, nominal = 2, size(M) ans = 1 3 4 arraysize(M)
-b 4+a],[4 5 6],[a 0 0]) [array, 4 x 1] variability = [-1 1], 1 occurrence variability = [-1 1], 1 occurrence
6-50
ans = 4
Check that result is valid. Use referencing to access parts of the [4-by-1] umat array and compare to the expected values. The first 4 examples should all be arrays full of 0 (zeros). The last two should be the value 5, and the uncertain real parameter a, respectively.
simplify(M(:,:,1) - [a b 1]) ans = 0 0 0 simplify(M(:,:,2) - [-a -b 4+a]) ans = 0 0 0 simplify(M(:,:,3) - [4 5 6]) ans = 0 0 0 simplify(M(:,:,4) - [a 0 0]) ans = 0 0 0 simplify(M(1,2,3)) % should be 5 ans = 5 simplify(M(1,3,2)-4) Uncertain Real Parameter: Name a, NominalValue 4, variability = [-1 1]
You can create a random 1-by-3-by-4 double matrix and stack this with M along the second array dimension, creating a 1-by-3-by-4-by-2 umat.
N = randn(1,3,4); M2 = stack(2,M,N); size(M2) ans = 1 3 4 arraysize(M2) ans = 4 2
As expected, both M and N can be recovered from M2.

d1 = simplify(M2(:,:,:,1)-M);
6-51
d2 = simplify(M2(:,:,:,2)-N); [max(abs(d1(:))) max(abs(d2(:)))] ans = 0 0
It is also possible to stack M and N along the 1st array dimension, creating a 1-by-3-by-8-by-1 umat.
M3 = stack(1,M,N); size(M3) ans = 1 3 8 arraysize(M3) ans = 8 1
As expected, both M and N can be recovered from M3.

d3 = simplify(M3(:,:,1:4)-M); d4 = simplify(M3(:,:,5:8)-N); [max(abs(d3(:))) max(abs(d4(:)))] ans = 0 0
Creating Arrays by Assignment

Arrays can be created by direct assignment. As with other MATLAB classes, there is no need to preallocate the variable first. Simply assign elements all resizing is performed automatically. For instance, an equivalent construction to
a = ureal('a',4); b = ureal('b',2); M = stack(1,[a b 1],[-a -b 4+a],[4 5 6],[a 0 0]); is Mequiv(1,1,1) = a; Mequiv(1,2,1) = b; Mequiv(1,3,1) = 1; Mequiv(1,:,4) = [a 0 0]; Mequiv(1,:,2:3) = stack(1,[-a -b 4+a],[4 5 6]);
6-52
The easiest manner for you to verify that the results are the same is to subtract and simplify,
d5 = simplify(M-Mequiv); max(abs(d5(:))) ans = 0
Binary Operations with Arrays

Most operations simply cycle through the array dimensions, doing pointwise operations. Assume A and B are umat (or uss, or ufrd) arrays with identical array dimensions (slot 3 and beyond). The operation C = fcn(A,B) is equivalent to looping on k1, k2, ..., setting
C(:,:,k1,k2,...) = fcn(A(:,:,k1,k2,...),B(:,:,k1,k2,...))
The result C has the same array dimensions as A and B. The user is required to manage the extra dimensions (i.e., keep track of what they mean). Methods such as permute, squeeze and reshape are included to facilitate this management. In general, any binary operation requires that the extra-dimensions are compatible. The umat, uss and ufrd objects allow for slightly more flexible interpretation of this. For illustrative purposes, consider a binary operation involving variables A and B. Suppose the array dimensions of A are and that the array dimensions of B are m 1 m l . By B MATLAB convention, the infinite number of singleton (i.e., 1) trailing dimensions are not listed. The compatibility of the extra dimensions is determined by the following rule: If lA=lB, then pad the shorter dimension list with trailing 1's. Now compare the extra dimensions: In the k-th dimension, it must be that one of 3 conditions hold: nk=mk, or nk=1 or mk=1. In other words, non-singleton dimensions must exactly match (so that the pointwise operation can be executed), and singleton dimensions match with anything, implicitly through a repmat.
A
n1 nl
Creating Arrays With usample

You can generate an array by sampling an uncertain object in some of the uncertain elements. Using the ureal objects a and b from above, create a 2-by-3 umat.
6-53
M = [a b;b*b a/b;1-b 1+a*b] UMAT: 3 Rows, 2 Columns a: real, nominal = 4, variability = [-1 b: real, nominal = 2, variability = [-1 size(M) ans = 3 2
1], 3 occurrences 1], 6 occurrences
Sample (at 20 random points within its range) the uncertain real parameter b in the matrix M. This results in a 3-by-2-by-20 umat, with only one uncertain element, a. The uncertain element b of M has been sampled out, leaving a new array dimension in its place.
[Ms,bvalues] = usample(M,'b',20); Ms UMAT: 3 Rows, 2 Columns [array, 20 x 1] a: real, nominal = 4, variability = [-1 size(Ms) ans = 3 2 20
1], 2 occurrences
Continue sampling (at 15 random points within its range) the uncertain real parameter a in the matrix Ms. This results in a 3-by-2-by-20-by-15 double.
[Mss,avalues] = usample(Ms,'a',15); size(Mss) ans = 3 2 20 15 class(Mss) ans = double
The above 2-step sequence can be performed in 1 step,

[Mss,values] = usample(M,'b',20,'a',15); class(Mss) ans = double
In this case, values is a 20-by-15 struct array, with 2 fields b and a, whose values are the values used in the random sampling. It follows that usubs(M,values) is the same as Mss.
6-54
Rather than sampling the each variable (a and b) independently, generating a 20-by-15 grid in a 2-dimensional space, the two-dimensional space can be sampled. Sample the 2-dimensional space with 800 points,
[Ms,values] = usample(M,{'a' 'b'},800); size(Ms) ans = 3 2 800 size(values) ans = 800 1
Creating Arrays With usubs

Suppose that Values is a struct array with the following properties: the dimensions of Values match the array dimensions of M, as described in the section Creating Arrays With usample on page 6-53; the field names of Values are some (or all) of the names of the uncertain elements of M; and the dimensions of the contents of the fields within Values match the sizes of the uncertain elements within M. Then usubs(M,Values) will substitute the uncertain elements in M with the contents found in the respective fields of Values. You can create a 3-by-2 uncertain matrix using 2 uncertain real parameters.
a = ureal('a',4); b = ureal('b',2); M = [a b;b*b a/b;1-b 1+a*b];
Create a 5-by-1 struct array with fieldname a. Make its values random scalars. Create a 1-by-4 struct array with fieldname b.
Avalue = struct('a',num2cell(rand(5,1))); Bvalue = struct('b',num2cell(rand(1,4)));
Substitute the uncertain real parameter a in M with the values in Avalue, yielding ma. Similarly substitute the uncertain real parameter b in M with the values in Avalue, yielding mb.
ma = usubs(M,Avalue) UMAT: 3 Rows, 2 Columns [array, 5 x 1] b: real, nominal = 2, variability = [-1 mb = usubs(M,Bvalue)
1], 6 occurrences
6-55
UMAT: 3 Rows, 2 Columns [array, 1 x 4] a: real, nominal = 4, variability = [-1
1], 2 occurrences
Continue, substituting the uncertain real parameter b in ma with the values in Bvalue, yielding mab. Do the analogous operation for mb, yielding mba. Subtract, and note that the difference is 0, as expected.
mab = usubs(ma,Bvalue); mba = usubs(mb,Avalue); thediff = mab-mba; max(abs(thediff(:))) ans = 4.4409e-016
Creating Arrays with gridureal

The command gridureal enables uniform sampling of specified uncertain real parameters within an uncertain object. It is a specialized case of usubs.
gridureal removes a specified uncertain real parameter and adds an array dimension (to the end of the existing array dimensions). The new array dimension represents the uniform samples of the uncertain object along the specified uncertain real parameter's range.
Create a 2-by-2 uncertain matrix with 3 uncertain real parameters.

a = ureal('a',3,'Range',[2.5 4]); b = ureal('b',4,'Percentage',15); c = ureal('c',-2,'Plusminus',[-1 .3]); M = [a b;b c] UMAT: 2 Rows, 2 Columns a: real, nominal = 3, range = [2.5 4], 1 occurrence b: real, nominal = 4, variability = [-15 15]%, 2 occurrences c: real, nominal = -2, variability = [-1 0.3], 1 occurrence
Grid the uncertain real parameter b in M with 100 points. The result is a umat array, with dependence on uncertain real parameters a and c.
Mgrid1 = gridureal(M,'b',100) UMAT: 2 Rows, 2 Columns [array, 100 x 1] a: real, nominal = 3, range = [2.5 4], 1 occurrence c: real, nominal = -2, variability = [-1 0.3], 1 occurrence
6-56
Operating on the uncertain matrix M, grid the uncertain real parameter a with 20 points, the uncertain real parameter b with 12 points, and the uncertain real parameter c with 7 points, The result is a 2-by-2-by20-by-12-by7 double array.
Mgrid3 = gridureal(M,'a',20,'b',12,'c',7); size(Mgrid3) ans = 2 2 20 12 7
Creating Arrays with repmat

The MATLAB command repmat is used to replicate and tile arrays. It works on the built-in objects of MATLAB, namely double, char, as well as the generalized container objects cell and struct. The identical functionality is provided for replicating and tiling uncertain elements (ureal, ultidyn, etc.) and umat objects. You can create an uncertain real parameter, and replicate it in a 2-by-3 uncertain matrix. Compare to generating the same uncertain matrix through multiplication.
a = ureal('a',5); Amat = repmat(a,[2 3]) UMAT: 2 Rows, 3 Columns a: real, nominal = 5, variability = [-1 Amat2 = a*ones(2,3); simplify(Amat-Amat2) ans = 0 0 0 0 0 0
1], 1 occurrence
Create (as in section a [4-by-1] umat array by stacking four 1-by-3 umat objects with the stack command. Use repmat to tile this 1-by-3-by-4-by-1 umat, into a 2-by-3-by-8-by-5 umat.
a = ureal('a',4); b = ureal('b',2); M = stack(1,[a b 1],[-a -b 4+a],[4 5 6],[a 0 0]); size(M) ans = 1 3 4
6-57
Mtiled = repmat(M,[2 1 2 5]) UMAT: 2 Rows, 3 Columns [array, 8 x 5] a: real, nominal = 4, variability = [-1 1], 1 occurrence b: real, nominal = 2, variability = [-1 1], 1 occurrence Verify the equality of M and a few certain tiles of Mtiled. d1 = simplify(M-Mtiled(2,:,5:8,3)); d2 = simplify(M-Mtiled(1,:,1:4,2)); d3 = simplify(M-Mtiled(2,:,1:4,5)); [max(abs(d1(:))) max(abs(d2(:))) max(abs(d3(:)))] ans = 0 0 0
Note that repmat never increases the complexity of the representation of an uncertain object. The number of occurrences of each uncertain element remains the same, regardless of the extent of the replication and tiling.
Creating Arrays with repsys

Replicating and tiling uncertain state-space systems (uss, and uncertain frequency response data (ufrd) is done with repsys. The syntax and behavior are the same as the manner in which repmat is used to replicate and tile matrices. The syntax and behavior of repsys for uss and ufrd objects are the same as the traditional repsys which operates on ss and frd object. Just as in those cases, the uncertain version of repsys also allows for diagonal tiling.
Using permute and ipermute

The commands permute and ipermute are generalizations of transpose, which exchanges the rows and columns of a two-dimensional matrix.
permute(A,ORDER) rearranges the dimensions of A so that they are in the order specified by the vector ORDER. The array produced has the same values of A but the order of the subscripts needed to access any particular element are rearranged as specified by ORDER. The elements of ORDER must be a rearrangement of the numbers from 1 to N.
All of the uncertain objects are essentially 2-dimensional (output and input) operators with array dependence. This means that the first 2 dimensions are treated differently from dimensions 3 and beyond. It is not permissible to permute across these groups.
6-58
For uss and ufrd, the restriction is built into the syntax. The elements of the ORDER vector only refer to array dimensions. Therefore, there is no possibility of permute across these dimensions. In you need to permute the first two dimensions, use the command transpose instead. For umat, the restriction is enforced in the software. The elements of the ORDER vector refer to all dimensions. However, the first two elements of ORDER must be a rearrangement of the numbers 1 and 2. The remaining elements of
ORDER must be a rearrangement of the numbers 3 through N. If either of those conditions fail, an error is generated. Hence, for umat arrays, either permute or transpose can be used to effect the transpose operation.
6-59
Decomposing Uncertain Objects (for Advanced Users)

Each uncertain object (umat, uss, ufrd) is a generalized feedback connection (lft) of a not-uncertain object (e.g., double, ss, frd) with a diagonal augmentation of uncertain atoms (ureal, ultidyn, ucomplex, ucomplexm udyn). In robust control jargon, if the uncertain elements are normalized, this decomposition is often called the M/ form. The purpose of the uncertain objects (ureal, ultidyn, umat, uss, etc.) is to hide this underlying decomposition, and allow the user to focus on modeling and analyzing uncertain systems, rather than the details of correctly propagating the M/ representation in manipulations. Nevertheless, advanced users may want access to the familiar M/ form. The command lftdata accomplishes this decomposition. Since ureal, ucomplex and ucomplexm do not have their NominalValue necessarily at zero, and in the case of ureal objects, are not symmetric about the NominalValue, some details are required in describing the decomposition.
Normalizing Functions for Uncertain Atoms

Associated with each uncertain element is a normalizing function. The normalizing function maps the uncertain element into a normalized uncertain element. If is an uncertain real parameter, with range [L R] and nominal value N, then the normalizing function F is A + B F ( ) = -----------------C + D with the property that for all satisfying LR, it follows that 1F()1, moreover, F(L)=1, F(N)=0, and F(R)=1. It is left as an exercise for the user to work out the various values for A, B, C and D as functions of the nominal value and range. If E is an uncertain gain-bounded, linear, time-invariant dynamic uncertainty, with gain-bound , then the normalizing function F is 1 F ( E ) = -- E. If E is an uncertain positive-real, linear, time-invariant dynamic uncertainty, with positivity bound , then the normalizing function F is 1 F ( E ) = I E -- I I + E -- I 2 2
6-60
where =2||+1. The normalizing function for an uncertain complex parameter , with nominal value C and radius is 1 F ( ) = -- ( C ) The normalizing function for uncertain complex matrices H, with nominal value N and weights WL and WR is F ( H ) = W L ( H N )W R
1 1
In each case, as the uncertain atom varies over its range, the absolute value of the normalizing function (or norm, in the matrix case) varies from 0 and 1.
Properties of the Decomposition

Take an uncertain object A, dependent on uncertain real parameters 1,,N, uncertain complex parameters 1,,K, uncertain complex matrices H1,,HB, uncertain gain-bounded linear, time-invariant dynamics E1,,ED, and uncertain positive-real linear, time-invariant dynamics P1,,PQ. Write A(,,H,E,P) to indicate this dependence. Using lftdata, A can be decomposed into two separate pieces: M and (,,H,E,P) with the following properties M is certain (i.e., if A is uss, then M is ss; if A is umat, then M is double; if A is ufrd, then M is frd). is always a umat, depending on the same uncertain elements as A, with ranges, bounds, weights, etc., unaltered. The form of is block diagonal, with elements made up of the normalizing functions acting on the individual uncertain elements. F() 0 0 0 0 0 F() 0 0 0 ( , , H, E , P ) = 0 0 F(H) 0 0 0 0 0 F(E) 0 0 0 0 0 F(P) A(,,H,E,P) is given by a linear fractional transformation of M and (,,H,E,P), A ( , ) = M 22 + M 21 ( , , H, E, P ) [ I M 11 ( , , H, E, P ) ] M 12
1
6-61
The order of the normalized atoms making up A is not the simple order shown above. It is actually the same order as given by the command fieldnames(M.Uncertainty). See the section Advanced Syntax of lftdata on page 6-64 for more information.
Syntax of lftdata
The decomposition is carried out by the command lftdata. You can create a 2-by-2 umat named A using 3 uncertain real parameters.
delta = ureal('delta',2); eta = ureal('eta',6); rho = ureal('rho',-1); A = [3+delta+eta delta/eta;7+rho rho+delta*eta] UMAT: 2 Rows, 2 Columns delta: real, nominal = 2, variability = [-1 1], 2 occurrences eta: real, nominal = 6, variability = [-1 1], 3 occurrences rho: real, nominal = -1, variability = [-1 1], 1 occurrence
Note that A depends on 2 occurrences of delta, 3 occurrences of eta and 1 occurrence of rho. Decompose A into M and Delta. Note that M is a double, and Delta has the same uncertainty dependence as A.
[M,Delta] = lftdata(A) M = 0 0 1.0000 0.1667 0 0 0 6.0000 0 0 1.0000 0 0 0 0 0.1667 0 0 0 1.0000 0 0 1.0000 1.0000 1.0000 0 11.0000 0.3333
0 0 0 0 0 0 1.0000
-0.1667 0 0 -0.1667 0 0 -0.3333 0 0 1.0000
0 0 0 0 0 0 0
0 0
6-62
0 1.0000 0 0 2.0000 1.0000 6.0000 11.0000 UMAT: 6 Rows, 6 Columns delta: real, nominal = 2, variability = [-1 1], 2 occurrences eta: real, nominal = 6, variability = [-1 1], 3 occurrences rho: real, nominal = -1, variability = [-1 1], 1 occurrence
Sample Delta at 5 points. Things to note are: it is diagonal; the values range between -1 and 1; there are 3 independent values, and duplication of the entries is consistent with the dependence of Delta and A on the 3 uncertain real parameters.
usample(Delta,5) ans(:,:,1) = 0.0224 0 0 0.0224 0 0 0 0 0 0 0 0 ans(:,:,2) = 0.8016 0 0 0.8016 0 0 0 0 0 0 0 0 ans(:,:,3) = 0.1222 0 0 0.1222 0 0 0 0 0 0 0 0 ans(:,:,4) = -0.3433 0 0 -0.3433 0 0 0 0 0 0 0 0
0 0 -0.1498 0 0 0 0 0 -0.2106 0 0 0 0 0 -0.9328 0 0 0 0 0 -0.4898 0 0 0
0 0 0 -0.1498 0 0 0 0 0 -0.2106 0 0 0 0 0 -0.9328 0 0 0 0 0 -0.4898 0 0
0 0 0 0 -0.1498 0 0 0 0 0 -0.2106 0 0 0 0 0 -0.9328 0 0 0 0 0 -0.4898 0
0 0 0 0 0 0.9620 0 0 0 0 0 -0.4700 0 0 0 0 0 -0.2453 0 0 0 0 0 -0.3629
6-63
ans(:,:,5) = 0.1409 0 0 0 0 0
0 0.1409 0 0 0 0
0 0 -0.3917 0 0 0
0 0 0 -0.3917 0 0
0 0 0 0 -0.3917 0
0 0 0 0 0 0.5187
In fact, verify that the maximum gain of Delta is indeed 1.

maxnorm = wcnorm(Delta) maxnorm = lbound: 1.0000 ubound: 1.0004
Finally, verify that lft(Delta,M) is the same as A. Subtract (and use the 'full' option in simplify)
simplify(lft(Delta,M)-A,'full') ans = 0 0 0 0
Advanced Syntax of lftdata

Even for the advanced user, the variable Delta will actually not be that useful, as it is still a complex object. On the other hand, its internal structure is described completely using a 3rd argument.
[M,Delta,BlkStruct] = lftdata(A);
The rows of BlkStruct correspond to the uncertain atoms named in fieldnames(A.Uncertainty). Note that the range/bound information about each uncertain atom is not included in BlkStruct.
BlkStruct BlkStruct = 1 1 2 1 1 1 3 1 1 1 1 1 fieldnames(A.Uncertainty) ans = 'delta'
6-64
'eta' 'rho'
Together, these mean Delta is a block diagonal augmentation of the normalized version of 3 uncertain atoms. The first atom is named 'delta'. It is 1-by-1 (first two columns of BlkStruct; there are 2 copies diagonally augmented (3rd column of BlkStruct); and it is of type 1 (4th column of BlkStruct), which means ureal. The second atom is named 'eta'. It is 1-by-1; there are 3 copies diagonally augmented; and it is of type 1. The third atom is named 'rho'. It is 1-by-1; there 1 copy; and it is of type 1. Other types include: ultidyn is type 2; ucomplex is type 3; ucomplexm is type 4; and udyn is type 5. Hence, by manipulating M and BlkStruct, a power-user has direct access to all of the linear fractional transformation details, and can easily work at the level of the theorems and algorithms that underlie the methods.
6-65
6-66
6-67
6-68
7
Introduction to Generalized Robustness Analysis (p. 7-2) Robust Stability Margin (p. 7-5) Robust Performance Margin (p. 7-6) Worst-Case Gain Measure (p. 7-7)
What is generalized robustness analysis? A brief discussion of robust stability margins The definition of robust performance margins The maximum achievable gain over all uncertain system objects
Introduction to Generalized Robustness Analysis

The performance of a nominally-stable uncertain system model will generally degrade for specific values of its uncertain elements. Moreover, the maximum possible degradation increases as the uncertain elements are allowed to further and further deviate from their nominal values. The graph below shows the typical trade-off curve between allowable deviation of uncertain elements from their nominal values and the worst-case degradation in system performance. Here, system performance is characterized by system gain (e.g., peak magnitude on Bode plot). Interpreting the system as the relationship mapping disturbances/commands to errors, small system gains are desirable, and large gains are undesirable.
Maximum System Gain over Uncertainty
3 2.5 2
1.72
Maximum System Gain due to varying amounts of uncertainty
System performance degradation curve
1.5
Nominal System Gain = 0.8
1 0.5 0 0
System Gain as large as 1.72 if uncertain elements can deviate from their nominal values by 1.5 units.
0.5 1 1.5 2 2.5 Bound on Normalized Uncertainty
When all uncertain elements are set to their nominal values (i.e., zero deviation from their nominal values) the input/output gain of the system is its
7-2
Introduction to Generalized Robustness Analysis
nominal value. In the figure, the nominal system gain is about 0.8. As the uncertainties are allowed to deviate from nominal, the maximum (over the uncertain elements) system gain increases. The heavy blue line represents the maximum system gain due to uncertainty of various sizes (the horizontal axis). and is called the system performance degradation curve. It is monotonically increasing. Determining specific attributes of the system performance degradation curve are referred to as robustness computations. Generally, robustness computations refer to determining specific attributes of the system performance degradation curve. The commands robuststab, robustperf and wcgain all compute single scalar attributes of the system performance degradation curve. Redraw the system performance degradation curve with 3 additional curves: a hyperbola defined by xy=1; a vertical line drawn at the uncertainty bound = 1; and a vertical line tangent to the asymptotic behavior of the performance
7-3
degradation curve at large uncertainty bounds. These are used to define three robustness measures, explained next.
3
WCGain uses bound of 1 on normalized uncertainty
2.5
Uncertainty level at which system can become unstable
1.5
WCGain=1.22 y=1/x curve in uncertainty size .vs. performance tradeoff space
1
PerfMarg=0.88
0.5
StabMarg=1.9
0 0
0.5
1 1.5 2 2.5 Bound on Normalized Uncertainty
7-4
Robust Stability Margin

The robust stability margin, StabMarg, is the size of the smallest deviation from nominal of the uncertain elements that leads to system instability.
3

2.5
Uncertainty level at which system can become unstable
1.5
0.5
StabMarg=1.9
0 0
0.5
System instability is equivalent to the system gain becoming arbitrarily large, and hence characterized by the vertical line tangent to the asymptotic behavior of the performance degradation curve.
7-5
Robust Performance Margin

The hyperbola is used to define the performance margin. Systems whose performance degradation curve intersects high on the hyperbola curve represent non-robustly-performing systems in that very small deviations of the uncertain elements from their nominal values can result in very large system gains. Conversely, an intersection low on the hyperbola represent robustly-performing systems.
3
Robust Performance Margin

2.5
2
1.5
y=1/x curve in uncertainty size .vs. performance tradeoff space
1
PerfMarg=0.88
0.5
0 0
0.5
The point where the system performance degradation curve crosses the green line is used as a scalar measure of the robustness of a system to uncertainty. The horizontal coordinate of the crossing point is the robust performance margin, PerfMarg.
7-6
Worst-Case Gain Measure
Worst-Case Gain Measure

The worst-case gain measure is the maximum achievable system gain over all uncertain elements whose normalized size is bounded by 1.
3
WCGain uses bound of 1 on normalized uncertainty
2.5
2
WCGain=1.22
1.5
0.5
WorstCase Gain Measure

0.5 1 1.5 2 2.5 Bound on Normalized Uncertainty 3
0 0
On the graph, this is the vertical coordinate of the performance degradation curve as it crosses the vertical line drawn at the uncertainty bound = 1. Each measure captures a single scalar attribute of the system performance degradation curve. Mathematically, they are independent quantities, answering subtly different questions. Consequently, for two uncertain systems, sysA and sysB, it is possible that the StabMarg of sysA is larger than the StabMarg of sysB, though the PerfMarg of sysA is smaller than the PerfMarg of sysB. Nevertheless, they are useful metrics for concise description of the robustness of a system (uss or ufrd) due to various uncertain elements.
7-7
7-8
8
Linear Matrix Inequalities (p. 8-2) LMIs and LMI Problems (p. 8-4) Further Mathematical Background (p. 8-9) References (p. 8-10)
An introduction to the concept of linear matrix inequalities and what LMI functionality can do for you The basic properties of LMIs Detailed mathematical development of LMI theory Relevant papers on linear matrix inequalities
Linear Matrix Inequalities

Linear Matrix Inequalities (LMIs) and LMI techniques have emerged as powerful design tools in areas ranging from control engineering to system identification and structural design. Three factors make LMI techniques appealing: A variety of design specifications and constraints can be expressed as LMIs. Once formulated in terms of LMIs, a problem can be solved exactly by efficient convex optimization algorithms (the LMI solvers). While most problems with multiple constraints or objectives lack analytical solutions in terms of matrix equations, they often remain tractable in the LMI framework. This makes LMI-based design a valuable alternative to classical analytical methods. See [9] for a good introduction to LMI concepts. The LMI Control Toolbox is designed as an easy and progressive gateway to the new and fast-growing field of LMIs: For users who occasionally need to solve LMI problems, the LMI Editor and the tutorial introduction to LMI concepts and LMI solvers provide for quick and easy problem solving. For more experienced LMI users, the LMI Lab (Chapter 8) offers a rich, flexible, and fully programmable environment to develop customized LMI-based tools.
LMI Features
The Robust Control Toolbox LMI functionality serves two purposes: Provide state-of-the-art tools for the LMI-based analysis and design of robust control systems Offer a flexible and user-friendly environment to specify and solve general LMI problems (the LMI Lab) :Examples of LMI-based analysis and design tools include Functions to analyze the robust stability and performance of uncertain systems with varying parameters (popov, quadstab, quadperf ...)
8-2
Linear Matrix Inequalities
Functions to design robust control with a mix of H2, H, and pole placement objectives (h2hinfsyn) Functions for synthesizing robust gain-scheduled H controllers (hinfgs) For users interested in developing their own applications, the LMI Lab provides a general-purpose and fully programmable environment to specify and solve virtually any LMI problem. Note that the scope of this facility is by no means restricted to control-oriented applications.
Note The LMI Control Toolbox implements state-of-the-art interior-point LMI solvers. While these solvers are significantly faster than classical convex optimization algorithms, you should keep in mind that the complexity of LMI computations can grow quickly with the problem order (number of states). For example, the number of operations required to solvea a Riccati equation is o(n3) where n is the state dimension, while the cost of solving and equivalent Riccati inequality LMI is o(n6).
8-3
LMIs and LMI Problems

A linear matrix inequality (LMI) is any constraint of the form A ( x ) := A 0 + x 1 A 1 + + x N A N < 0 where x = (x1, . . . , xN) is a vector of unknown scalars (the decision or optimization variables) A0, . . . , AN are given symmetric matrices < 0 stands for negative definite, i.e., the largest eigenvalue of A(x) is negative Note that the constraints A(x) > 0 and A(x) < B(x) are special cases of (1-1) since they can be rewritten as A(x) < 0 and A(x) B(x) < 0, respectively. The LMI (1-1) is a convex constraint on x since A(y) < 0 and A(z) < 0 imply that
+ ----------A y 2 z < 0 . As a result,
Its solution set, called the feasible set, is a convex subset of RN Finding a solution x to (1-1), if any, is a convex optimization problem. Convexity has an important consequence: even though (1-1) has no analytical solution in general, it can be solved numerically with guarantees of finding a solution when one exists. Note that a system of LMI constraints can be regarded as a single LMI since A1 ( x ) < 0 . . is equivalent to A ( x ) := diag ( A 1 ( x ),, A K ( x ) ) < 0 . AK ( x ) < 0 where diag (A1(x), . . . , AK(x)) denotes the block-diagonal matrix with A1(x), . . . , AK(x) on its diagonal. Hence multiple LMI constraints can be imposed on the vector of decision variables x without destroying convexity.
8-4
In most control applications, LMIs do not naturally arise in the canonical form (1-1), but rather in the form L(X1, . . . , Xn) < R(X1, . . . , Xn) where L(.) and R(.) are affine functions of some structured matrix variables X1, . . . , Xn. A simple example is the Lyapunov inequality A X + XA < 0
T
(8-1)
where the unknown X is a symmetric matrix. Defining x1, . . . , xN as the independent scalar entries of X, this LMI could be rewritten in the form (1-1). Yet it is more convenient and efficient to describe it in its natural form (1-2), which is the approach taken in the LMI Lab.
The Three Generic LMI Problems

Finding a solution x to the LMI system A(x) < 0
(8-2)
is called the feasibility problem. Minimizing a convex objective under LMI constraints is also a convex problem. In particular, the linear objective minimization problem Minimize c x subject to A ( x ) < 0 plays an important role in LMI-based design. Finally, the generalized eigenvalue minimization problem A ( x ) 0 C(x) < 0
T
(8-3)
(8-4)
is quasi-convex and can be solved by similar techniques. It owes its name to the fact that is related to the largest generalized eigenvalue of the pencil (A(x),B(x)). Many control problems and design specifications have LMI formulations [9]. This is especially true for Lyapunov-based analysis and design, but also for
8-5
optimal LQG control, H control, covariance control, etc. Further applications of LMIs arise in estimation, identification, optimal design, structural design [6, 7], matrix scaling problems, and so on. The main strength of LMI formulations is the ability to combine various design constraints or objectives in a numerically tractable manner. A nonexhaustive list of problems addressed by LMI techniques includes the following: Robust stability of systems with LTI uncertainty (-analysis) ([24], [21], [27]) Robust stability in the face of sector-bounded nonlinearities (Popov criterion) ([22], [28], [13], [16]) Quadratic stability of differential inclusions ([15], [8]) Lyapunov stability of parameter-dependent systems [12] Input/state/output properties of LTI systems (invariant ellipsoids, decay rate, etc.) [9] Multi-model/multi-objective state feedback design ([4], [17], [3], [9], [10]) Robust pole placement Optimal LQG control [9] Robust H control ([11], [14]) Multi-objective H synthesis ([18], [23], [10], [18]) Design of robust gain-scheduled controllers ([5], [2]) Control of stochastic systems [9] Weighted interpolation problems [[9] To hint at the principles underlying LMI design, lets review the LMI formulations of a few typical design objectives.
Stability
The stability of the dynamic system x = Ax is equivalent to the feasibility of Find P = PT such that AT P + P A < 0, P > I.
8-6
This can be generalized to linear differential inclusions (LDI) x = A ( t )x where A(t) varies in the convex envelope of a set of LTI models:
N n A ( t ) Co { A 1 ,,A n } = a i A i : a i 0, ai = 1 i=1 i = 1
A sufficient condition for the asymptotic stability of this LDI is the feasibility of Find P = PT such that A i P + PA i < 0, P > I.
T
RMS gain
The random-mean-squares (RMS) gain of a stable LTI system x = Ax + Bu y = Cx + Du is the largest input/output gain over all bounded inputs u(t). This gain is the global minimum of the following linear objective minimization problem [1, 26, 25]. Minimize over X = XT and such that T T A X + XA XB C T T B X I D < 0 C D I X > 0
LQG performance
For a stable LTI system x = Ax + Bw G y = Cx
8-7
where w is a white noise disturbance with unit covariance, the LQG or H2 performance ||G||2 is defined by 1 T T 2 G 2 : = lim E --- y ( t )y ( t )dt T T 0 1 H = -----G ( j )G ( j )d 2
It can be shown that G 2 = inf { Trace ( CPC ) : AP + PA + BB < 0 } Hence G 2 is the global minimum of the LMI problem Minimize Trace (Q) over the symmetric matrices P,Q such that AP + PA + BB < 0 Q CP >0 PC T P Again this is a linear objective minimization problem since the objective Trace (Q) is linear in the decision variables (free entries of P,Q).
T T 2 2 T T T
8-8
Further Mathematical Background
Further Mathematical Background

Efficient interior-point algorithms are now available to solve the three generic LMI problems (1-3)(1-5) defined in The Three Generic LMI Problems on page 8-5. These algorithms have a polynomial-time complexity. That is, the number N() of flops needed to compute an -accurate solution is bounded by M N3 log(V/) where M is the total row size of the LMI system, N is the total number of scalar decision variables, and V is a data-dependent scaling factor. The Robust Control Toolbox implements the Projective Algorithm of Nesterov and Nemirovski [20, 19]. In addition to its polynomial-time complexity, this algorithm does not require an initial feasible point for the linear objective minimization problem (1-4) or the generalized eigenvalue minimization problem (1-5). Some LMI problems are formulated in terms of inequalities rather than strict inequalities. For instance, a variant of (1-4) is Minimize cTx subject to A(x) < 0. While this distinction is immaterial in general, it matters when A(x) can be made negative semi-definite but not negative definite. A simple example is T Minimize c x subject to x x 0. xx
(8-5)
Such problems cannot be handled directly by interior-point methods which require strict feasibility of the LMI constraints. A well-posed reformulation of (1-6) would be Minimize cTx subject to x 0. Keeping this subtlety in mind, we always use strict inequalities in this manual.
8-9
References
[1] Anderson, B.D.O, and S. Vongpanitlerd, Network Analysis, Prentice-Hall, Englewood Cliffs, 1973. [2] Apkarian, P., P. Gahinet, and G. Becker, Self-Scheduled H Control of Linear Parameter-Varying Systems, Proc. Amer. Contr. Conf., 1994, pp. 856-860. [3] Bambang, R., E. Shimemura, and K. Uchida, Mixed H2 /H Control with Pole Placement, State-Feedback Case, Proc. Amer. Contr. Conf., 1993, pp. 2777-2779. [4] Barmish, B.R., Stabilization of Uncertain Systems via Linear Control, IEEE Trans. Aut. Contr., AC28 (1983), pp. 848-850. [5] Becker, G., Packard, P., Robust Performance of Linear-Parametrically Varying Systems Using Parametrically-Dependent Linear Feedback, Systems and Control Letters, 23 (1994), pp. 205-215. [6] Bendsoe, M.P., A. Ben-Tal, and J. Zowe, Optimization Methods for Truss Geometry and Topology Design, to appear in Structural Optimization. [7] Ben-Tal, A., and A. Nemirovski, Potential Reduction Polynomial-Time Method for Truss Topology Design, to appear in SIAM J. Contr. Opt. [8] Boyd, S., and Q. Yang, Structured and Simultaneous Lyapunov Functions for System Stability Problems, Int. J. Contr., 49 (1989), pp. 2215-2240. [9] Boyd, S., L. El Ghaoui, E. Feron, V. Balakrishnan, Linear Matrix Inequalities in Systems and Control Theory, SIAM books, Philadelphia, 1994. [10] Chilali, M., and P. Gahinet, H Design with Pole Placement Constraints: an LMI Approach, to appear in IEEE Trans. Aut. Contr. Also in Proc. Conf. Dec. Contr., 1994, pp. 553-558. [11] Gahinet, P., and P. Apkarian, A Linear Matrix Inequality Approach to H Control, Int. J. Robust and Nonlinear Contr., 4 (1994), pp. 421-448. [12] Gahinet, P., P. Apkarian, and M. Chilali, Affine Parameter-Dependent Lyapunov Functions for Real Parametric Uncertainty, Proc. Conf. Dec. Contr., 1994, pp. 2026-2031. [13] Haddad, W.M. and D.S. Berstein,Parameter-Dependent Lyapunov Functions, Constant Real Parameter Uncertainty, and the Popov Criterion in
8-10
References
Robust Analysis and Synthesis: Part 1 and 2, Proc. Conf. Dec. Contr., 1991, pp. 2274-2279 and 2632-2633. [14] Iwasaki, T., and R.E. Skelton, All Controllers for the General H Control Problem: LMI Existence Conditions and State-Space Formulas, Automatica, 30 (1994), pp. 1307-1317. [15] Horisberger, H.P., and P.R. Belanger, Regulators for Linear Time-Varying Plants with Uncertain Parameters, IEEE Trans. Aut. Contr., AC21 (1976), pp. 705-708. [16] How, J.P., and S.R. Hall, Connection between the Popov Stability Criterion and Bounds for Real Parameter Uncertainty, Proc. Amer. Contr. Conf., 1993, pp. 1084-1089. [17] Khargonekar, P.P., and M.A. Rotea,Mixed H2 /H Control: a Convex Optimization Approach, IEEE Trans. Aut. Contr., 39 (1991), pp. 824-837. [18] Masubuchi, I., A. Ohara, and N. Suda, LMI-Based Controller Synthesis: A Unified Formulation and Solution, submitted to Int. J. Robust and Nonlinear Contr., 1994. [19] Nemirovski, A., and P. Gahinet, The Projective Method for Solving Linear Matrix Inequalities, Proc. Amer. Contr. Conf., 1994, pp. 840-844. [20] Nesterov, Yu, and A. Nemirovski, Interior Point Polynomial Methods in Convex Programming: Theory and Applications, SIAM Books, Philadelphia, 1994. [21] Packard, A., and J.C. Doyle, The Complex Structured Singular Value, Automatica, 29 (1994), pp. 71-109. [22] Popov, V.M., Absolute Stability of Nonlinear Systems of Automatic Control, Automation and Remote Control, 22 (1962), pp. 857-875. [23] Scherer, C., Mixed H2 H Control, to appear in Trends in Control: A European Perspective, volume of the special contributions to the ECC 1995. [24] Stein, G. and J.C. Doyle, Beyond Singular Values and Loop Shapes, J. Guidance, 14 (1991), pp. 5-16. [25] Vidyasagar, M., Nonlinear System Analysis, Prentice-Hall, Englewood Cliffs, 1992.
8-11
[26] Willems, J.C., Least-Squares Stationary Optimal Control and the Algebraic Riccati Equation, IEEE Trans. Aut. Contr., AC16 (1971), pp. 621-634. [27] Young, P. M., M. P. Newlin, and J. C. Doyle, Let's Get Real, in Robust Control Theory, Springer Verlag, 1994, pp. 143-174. [28] Zames, G., On the Input-Output Stability of Time-Varying Nonlinear Feedback Systems, Part I and II, IEEE Trans. Aut. Contr., AC11 (1966), pp. 228-238 and 465-476.
8-12
9
The LMI Lab
Introduction on page 9-2 Specifying a System of LMIs (p. 9-7) Querying the LMI System Description (p. 9-19) LMI Solvers (p. 9-20)
An quick look at the LMI Lab, canonical forms of the LMI problem, and the tools available in the LMI Lab How to set up a system of LMIs How to find out characteristics of your LMI system How the LMI solvers work
From Decision to Matrix Variables and The relationships between decision variables and matrix Vice Versa (p. 9-26) variables Validating Results (p. 9-27) Modifying a System of LMIs (p. 9-28) Advanced Topics (p. 9-31) References (p. 9-42) Verifying your solutions Adapting an existing system to a new problem Topics for the experienced user A list of relevant papers
The LMI Lab
Introduction
The LMI Lab is a high-performance package for solving general LMI problems. It blends simple tools for the specification and manipulation of LMIs with powerful LMI solvers for three generic LMI problems. Thanks to a structure-oriented representation of LMIs, the various LMI constraints can be described in their natural block-matrix form. Similarly, the optimization variables are specified directly as matrix variables with some given structure. Once an LMI problem is specified, it can be solved numerically by calling the appropriate LMI solver. The three solvers feasp, mincx, and gevp constitute the computational engine of the LMI Control Toolbox. Their high performance is achieved through C-MEX implementation and by taking advantage of the particular structure of each LMI. The LMI Lab offers tools to Specify LMI systems either symbolically with the LMI Editor or incrementally with the lmivar and lmiterm commands Retrieve information about existing systems of LMIs Modify existing systems of LMIs Solve the three generic LMI problems (feasibility problem, linear objective minimization, and generalized eigenvalue minimization) Validate results This chapter gives a tutorial introduction to the LMI Lab as well as more advanced tips for making the most out of its potential. The tutorial material is also covered by the demo lmidem.
Some Terminology
Any linear matrix inequality can be expressed in the canonical form L(x) = L0 + x1L1 + . . . + xNLN < 0 where L0, L1, . . . , LN are given symmetric matrices x = (x1, . . . , xN)T RN is the vector of scalar variables to be determined. We refer to x1, . . . , xN as the decision variables. The names design variables and optimization variables are also found in the literature.
9-2
Introduction
Even though this canonical expression is generic, LMIs rarely arise in this form in control applications. Consider for instance the Lyapunov inequality A X + XA < 0
T
(9-1)
x x where A = 1 2 and the variable X = 1 2 is a symmetric matrix. x x 0 2 2 3
Here the decision variables are the free entries x1, x2, x3 of X and the canonical form of this LMI reads x1 2 2 + x2 0 3 + x3 0 0 < 0 2 0 3 4 0 4
(9-2)
Clearly this expression is less intuitive and transparent than (8-1). Moreover, the number of matrices involved in (8-2) grows roughly as n2 /2 if n is the size of the A matrix. Hence, the canonical form is very inefficient from a storage viewpoint since it requires storing o(n2 /2) matrices of size n when the single n-by-n matrix A would be sufficient. Finally, working with the canonical form is also detrimental to the efficiency of the LMI solvers. For these various reasons, the LMI Lab uses a structured representation of LMIs. For instance, the expression ATX + XA in the Lyapunov inequality (8-1) is explicitly described as a function of the matrix variable X, and only the A matrix is stored. In general, LMIs assume a block matrix form where each block is an affine combination of the matrix variables. As a fairly typical illustration, consider the following LMI drawn from H theory T T A X + XA XC B T N CX I D T T B D I N < 0
(9-3)
where A, B, C, D, N are given matrices and the problem variables are X = XT Rnn and R. We use the following terminology to describe such LMIs:
9-3
The LMI Lab
N is called the outer factor, and the block matrix T T A X + XA XC B L ( X, ) = CX I D T T D I B
is called the inner factor. The outer factor needs not be square and is often absent. X and are the matrix variables of the problem. Note that scalars are considered as 1-by-1 matrices. The inner factor L(X, ) is a symmetric block matrix, its block structure being characterized by the sizes of its diagonal blocks. By symmetry, L(X, ) is entirely specified by the blocks on or above the diagonal. Each block of L(X, ) is an affine expression in the matrix variables X and . This expression can be broken down into a sum of elementary terms. For instance, the block (1,1) contains two elementary terms: ATX and XA. Terms are either constant or variable. Constant terms are fixed matrices like B and D above. Variable terms involve one of the matrix variables, like XA, XCT, and I above. The LMI (8-3) is specified by the list of terms in each block, as is any LMI regardless of its complexity. As for the matrix variables X and , they are characterized by their dimensions and structure. Common structures include rectangular unstructured, symmetric, skew-symmetric, and scalar. More sophisticated structures are sometimes encountered in control problems. For instance, the matrix variable X could be constrained to the block-diagonal structure x 0 0 1 X = 0 x2 x3 0 x x 3 4
9-4
Introduction
Another possibility is the symmetric Toeplitz structure x x x 1 2 3 X = x2 x1 x2 x x x 3 2 1
Summing up, structured LMI problems are specified by declaring the matrix variables and describing the term content of each LMI. This term-oriented description is systematic and accurately reflects the specific structure of the LMI constraints. There is no built-in limitation on the number of LMIs that you can specify or on the number of blocks and terms in any given LMI. LMI systems of arbitrary complexity can therefore, be defined in the LMI Lab.
Overview of the LMI Lab

The LMI Lab offers tools to specify, manipulate, and numerically solve LMIs. Its main purpose is to Allow for straightforward description of LMIs in their natural block-matrix form Provide easy access to the LMI solvers (optimization codes) Facilitate result validation and problem modification The structure-oriented description of a given LMI system is stored as a single vector called the internal representation and generically denoted by LMISYS in the sequel. This vector encodes the structure and dimensions of the LMIs and matrix variables, a description of all LMI terms, and the related numerical data. It must be stressed that you need not attempt to read or understand the content of LMISYS since all manipulations involving this internal representation can be performed in a transparent manner with LMI-Lab tools. The LMI Lab supports the following functionalities:
Specification of a System of LMIs

LMI systems can be either specified as symbolic matrix expressions with the interactive graphical user interface lmiedit, or assembled incrementally with the two commands lmivar and lmiterm. The first option is more intuitive and transparent while the second option is more powerful and flexible.
9-5
The LMI Lab
Information Retrieval
The interactive function lmiinfo answers qualitative queries about LMI systems created with lmiedit or lmivar and lmiterm. You can also use lmiedit to visualize the LMI system produced by a particular sequence of lmivar/lmiterm commands.
Solvers for LMI Optimization Problems

General-purpose LMI solvers are provided for the three generic LMI problems defined on page 8-5. These solvers can handle very general LMI systems and matrix variable structures. They return a feasible or optimal vector of decision variables x*. The corresponding values X * , , X * of the matrix variables are 1 K given by the function dec2mat.
Result Validation
The solution x* produced by the LMI solvers is easily validated with the functions evallmi and showlmi. This allows a fast check and/or analysis of the results. With evallmi, all variable terms in the LMI system are evaluated for the value x* of the decision variables. The left- and right-hand sides of each LMI then become constant matrices that can be displayed with showlmi.
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.
9-6
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.
Important: Throughout this chapter, left-hand side refers to what is on the smaller side of the inequality, and right-hand side to what is on the larger side. Accordingly, X is called the right-hand side and 0 the left-hand 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
9-7
The LMI Lab
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 8.1
Consider a stable transfer function G ( s ) = C ( sI A ) B with four inputs, four outputs, and six states, and consider the set of input/output scaling matrices D with block-diagonal structure D = d1 0 0 0 0 d1 0 0 0 0 d2 d3 0 0 d4 d5
(9-5)
1
(9-4)
The following problem arises in the robust stability analysis of systems with time-varying uncertainty [4]: Find, if any, a scaling D of structure (8-5) such that the largest gain across frequency of D G(s) D1 is less than one. This problem has a simple LMI formulation: there exists an adequate scaling D if the following feasibility problem has solutions: Find two symmetric matrices X R66 and S = DT D R44 such that
9-8
A T X + XA + C T SC XB <0 T B X S
(9-6)
X>0 S>1
(9-7) (9-8)
The LMI system (Equation 9-6, Equation 9-7, and Equation 9-8) can be described with the LMI Editor as outlined below. Alternatively, its internal description can be generated with lmivar and lmiterm commands as follows:
setlmis([]) X=lmivar(1,[6 1]) S=lmivar(1,[2 0;2 1]) % 1st LMI lmiterm([1 lmiterm([1 lmiterm([1 lmiterm([1
1 1 1 2
1 1 2 2
X],1,A,'s') S],C',C) X],1,B) S], 1,1)
% 2nd LMI lmiterm([ 2 1 1 X],1,1) % 3rd LMI lmiterm([ 3 1 1 S],1,1) lmiterm([3 1 1 0],1) LMISYS = getlmis
Here the lmivar commands define the two matrix variables X and S while the lmiterm commands describe the various terms in each LMI. Upon completion, getlmis returns the internal representation LMISYS of this LMI system. The next three subsections give more details on the syntax and usage of these various commands. More information on how the internal representation is updated by lmivar/lmiterm can also be found in How It All Works on page 9-18.
9-9
The LMI Lab
Initializing the LMI System

The description of an LMI system should begin with setlmis and end with getlmis. The function setlmis initializes the LMI system description. When specifying a new system, type
setlmis([])
To add on to an existing LMI system with internal representation LMIS0, type

setlmis(LMIS0)
Specifying the LMI Variables

The matrix variables are declared one at a time with lmivar and are characterized by their structure. To facilitate the specification of this structure, the LMI Lab offers two predefined structure types along with the means to describe more general structures: Type 1: Symmetric block diagonal structure. This corresponds to matrix variables of the form D 0 0 1 0 D 2 X = 0 0 0 Dr where each diagonal block Dj is square and is either zero, a full symmetric matrix, or a scalar matrix Dj = d I, dR
... ... ...
This type encompasses ordinary symmetric matrices (single block) and scalar variables (one block of size one). Type 2: Type 3: Rectangular structure. This corresponds to arbitrary rectangular matrices without any particular structure. General structures. This third type is used to describe more sophisticated structures and/or correlations between the matrix variables. The principle is as follows: each entry of X is specified independently as either 0, xn, or xn where xn denotes the n-th decision variable in the problem. For details on how to use Type 3,
9-10
see Structured Matrix Variables on page 9-31 below as well as the lmivar entry in the reference pages. In Example 8.1 on page 9-8, the matrix variables X and S are of Type 1. Indeed, both are symmetric and S inherits the block-diagonal structure (8-5) of D. Specifically, S is of the form S = s1 0 0 0 0 s1 0 0 0 0 s2 s3 0 0 s3 s4
After initializing the description with the command setlmis([]), these two matrix variables are declared by
lmivar(1,[6 1]) % X lmivar(1,[2 0;2 1]) % S
In both commands, the first input specifies the structure type and the second input contains additional information about the structure of the variable: For a matrix variable X of Type 1, this second input is a matrix with two columns and as many rows as diagonal blocks in X. The first column lists the sizes of the diagonal blocks and the second column specifies their nature with the following convention: 1 full symmetric block 0 scalar block 1 zero block In the second command, for instance, [2 0;2 1] means that S has two diagonal blocks, the first one being a 2-by-2 scalar block and the second one a 22 full block. For matrix variables of Type 2, the second input of lmivar is a two-entry vector listing the row and column dimensions of the variable. For instance, a 3-by-5 rectangular matrix variable would be defined by
lmivar(2,[3 5])
9-11
The LMI Lab
For convenience, lmivar also returns a tag that identifies the matrix variable for subsequent reference. For instance, X and S in Example 8.1 could be defined by
X = lmivar(1,[6 1]) S = lmivar(1,[2 0;2 1])
The identifiers X and S are integers corresponding to the ranking of X and S in the list of matrix variables (in the order of declaration). Here their values would be X=1 and S=2. Note that these identifiers still point to X and S after deletion or instantiation of some of the matrix variables. Finally, lmivar can also return the total number of decision variables allocated so far as well as the entry-wise dependence of the matrix variable on these decision variables (see the lmivar entry in the reference pages for more details).
Specifying Individual LMIs

After declaring the matrix variables with lmivar, we are left with specifying the term content of each LMI. Recall that LMI terms fall into three categories: The constant terms, i.e., fixed matrices like I in the left-hand side of the LMI S>I The variable terms, i.e., terms involving a matrix variable. For instance, ATX and CTSC in (8-6). Variable terms are of the form PXQ where X is a variable and P, Q are given matrices called the left and right coefficients, respectively. The outer factors The following rule should be kept in mind when describing the term content of an LMI:
Important: Specify only the terms in the blocks on or above the diagonal. The inner factors being symmetric, this is sufficient to specify the entire LMI. Specifying all blocks results in the duplication of off-diagonal terms, hence in the creation of a different LMI. Alternatively, you can describe the blocks on or below the diagonal.
9-12
LMI terms are specified one at a time with lmiterm. For instance, the LMI A T X + XA + C T SC XB <0 T B X S is described by
lmiterm([1 lmiterm([1 lmiterm([1 lmiterm([1 1 1 1 2 1 1 2 2 1],1,A,'s') 2],C',C) 1],1,B) 2], 1,1)
These commands successively declare the terms ATX + XA, CTSC, XB, and S. In each command, the first argument is a four-entry vector listing the term characteristics as follows: The first entry indicates to which LMI the term belongs. The value m means left-hand side of the m-th LMI, and m means right-hand side of the m-th LMI The second and third entries identify the block to which the term belongs. For instance, the vector [1 1 2 1] indicates that the term is attached to the (1, 2) block The last entry indicates which matrix variable is involved in the term. This entry is 0 for constant terms, k for terms involving the k-th matrix variable T Xk, and k for terms involving X k (here X and S are first and second variables in the order of declaration). Finally, the second and third arguments of lmiterm contain the numerical data (values of the constant term, outer factor, or matrix coefficients P and Q for variable terms PXQ or PXTQ). These arguments must refer to existing MATLAB variables and be real-valued. SeeComplex-Valued LMIs on page 9-33 for the specification of LMIs with complex-valued coefficients. Some shorthand is provided to simplify term specification. First, blocks are zero by default. Second, in diagonal blocks the extra argument 's' allows you to specify the conjugated expression AXB + BTXTAT with a single lmiterm command. For instance, the first command specifies ATX + XA as the symmetrization of XA. Finally, scalar values are allowed as shorthand for scalar matrices, i.e., matrices of the form I with scalar. Thus, a constant
9-13
The LMI Lab
term of the form I can be specified as the scalar . This also applies to the coefficients P and Q of variable terms. The dimensions of scalar matrices are inferred from the context and set to 1 by default. For instance, the third LMI S > I in Example 8.3 on page 9-31 is described by
lmiterm([ 3 1 1 2],1,1) lmiterm([3 1 1 0],1) % 1*S*1 = S % 1*I = I
Recall that by convention S is considered as the right-hand side of the inequality, which justifies the 3 in the first command. Finally, to improve readability it is often convenient to attach an identifier (tag) to each LMI and matrix variable. The variable identifiers are returned by lmivar and the LMI identifiers are set by the function newlmi. These identifiers can be used in lmiterm commands to refer to a given LMI or matrix variable. For the LMI system of Example 8.1, this would look like:
setlmis([]) X = lmivar(1,[6 1]) S = lmivar(1,[2 0;2 1]) BRL = newlmi lmiterm([BRL lmiterm([BRL lmiterm([BRL lmiterm([BRL
1 1 1 2
1 1 2 2
X],1,A,'s') S],C',C) X],1,B) S], 1,1)
Xpos = newlmi lmiterm([-Xpos 1 1 X],1,1) Slmi = newlmi lmiterm([-Slmi 1 1 S],1,1) lmiterm([Slmi 1 1 0],1)
When the LMI system is completely specified, type

LMISYS = getlmis
This returns the internal representation LMISYS of this LMI system. This MATLAB description of the problem can be forwarded to other LMI-Lab functions for subsequent processing. The command getlmis must be used only once and after declaring all matrix variables and LMI terms.
9-14
Here the identifiers X and S point to the variables X and S while the tags BRL, Xpos, and Slmi point to the first, second, and third LMI, respectively. Note that Xpos refers to the right-hand side of the second LMI. Similarly, X would indicate transposition of the variable X.
Specifying LMIs With the LMI Editor

The LMI Editor lmiedit is a graphical user interface (GUI) to specify LMI systems in a straightforward symbolic manner. Typing
lmiedit
calls up a window with several editable text areas and various buttons.
Declare each matrix variable (name and structure) here.
Use the view commands buttons to visualize the sequence of lmivar/lmiterm commands needed to describe this LMI system.
Specify the LMIs as MATLAB expressions here.
Read a sequence of
lmivar/lmiterm
commands from a file by clicking Read.
Generate the internal representation of the LMI system by clicking Create.
Save/Load the symbolic description of the LMI system as a MATLAB string.
9-15
The LMI Lab
In more detail, to specify your LMI system,

1 Declare each matrix variable (name and structure) in the upper half of the
worksheet. The structure is characterized by its type (S for symmetric block diagonal, R for unstructured, and G for other structures) and by an additional structure matrix. This matrix contains specific information about the structure and corresponds to the second argument of lmivar (see Specifying the LMI Variables on page 9-10 for details). Please use one line per matrix variable in the text editing areas.
2 Specify the LMIs as MATLAB expressions in the lower half of the
worksheet. For instance, the LMI T A X + XA XB < 0 T B X I is entered by typing

[a'*x+x*a x*b; b'*x 1] < 0
if x is the name given to the matrix variable X in the upper half of the worksheet. The left- and right-hand sides of the LMIs should be valid MATLAB expressions. Once the LMI system is fully specified, the following tasks can be performed by clicking the corresponding button: Visualize the sequence of lmivar/lmiterm commands needed to describe this LMI system (view commands button). Conversely, the LMI system defined by a particular sequence of lmivar/lmiterm commands can be displayed as a MATLAB expression by clicking on the describe... buttons. Beginners can use this facility as a tutorial introduction to the lmivar and
lmiterm commands.
Save the symbolic description of the LMI system as a MATLAB string (save button). This description can be reloaded later on by clicking the load button. Read a sequence of lmivar/lmiterm commands from a file (read button). You can then click on describe the matrix variables or describe the LMIs to visualize the symbolic expression of the LMI system specified by these
9-16
commands. The file should describe a single LMI system but may otherwise contain any sequence of MATLAB commands. This feature is useful for code validation and debugging. Write in a file the sequence of lmivar/lmiterm commands needed to describe a particular LMI system (write button). This is helpful to develop code and prototype MATLAB functions based on the LMI Lab. Generate the internal representation of the LMI system by clicking create. The result is written in a MATLAB variable named after the LMI system (if the name of the LMI system is set to mylmi, the internal representation is written in the MATLAB variable mylmi). Note that all LMI-related data should be defined in the MATLAB workspace at this stage. The internal representation can be passed directly to the LMI solvers or any other LMI Lab function.
Keyboard Shortcuts
As with lmiterm, you can use various shortcuts when entering LMI expressions at the keyboard. For instance, zero blocks can be entered simply as 0 and need not be dimensioned. Similarly, the identity matrix can be entered as 1 without dimensioning. Finally, upper diagonal LMI blocks need not be fully specified. Rather, you can just type (*) in place of each such block.
Limitations
Though fairly general, lmiedit is not as flexible as lmiterm and the following limitations should be kept in mind: Parentheses cannot be used around matrix variables. For instance, the expression
(a*x+b)'*c + c'*(a*x+b)
is invalid when x is a variable name. By contrast, (a+b)'*x + x'*(a+b) is perfectly valid. Loops and if statements are ignored. When turning lmiterm commands into a symbolic description of the LMI system, an error is issued if the first argument of lmiterm cannot be
9-17
The LMI Lab
evaluated. Use the LMI and variable identifiers supplied by newlmi and lmivar to avoid such difficulties. Figure 8-1 shows how to specify the feasibility problem of Example 8.1 on page 9-8 with lmiedit.
How It All Works

Users familiar with MATLAB may wonder how lmivar and lmiterm physically update the internal representation LMISYS since LMISYS is not an argument to these functions. In fact, all updating is performed through global variables for maximum speed. These global variables are initialized by setlmis, cleared by getlmis, and are not visible in the workspace. Even though this artifact is transparent from the user's viewpoint, be sure to Invoke getlmis only once and after completely specifying the LMI system Refrain from using the command clear global before the LMI system description is ended with getlmis
9-18
Querying the LMI System Description
Querying the LMI System Description

Recall that the full description of an LMI system is stored as a single vector called the internal representation. The user should not attempt to read or retrieve information directly from this vector. The Robust Control Toolbox provides three functions called lmiinfo, lminbr, and matnbr to extract and display all relevant information in a user-readable format.
lmiinfo
lmiinfo is an interactive facility to retrieve qualitative information about LMI
systems. This includes the number of LMIs, the number of matrix variables and their structure, the term content of each LMI block, etc. To invoke lmiinfo, enter
lmiinfo(LMISYS)
where LMISYS is the internal representation of the LMI system produced by getlmis.
lminbr and matnbr

These two functions return the number of LMIs and the number of matrix variables in the system. To get the number of matrix variables, for instance, enter
matnbr(LMISYS)
9-19
The LMI Lab
LMI Solvers
LMI solvers are provided for the following three generic optimization problems (here x denotes the vector of decision variables, i.e., of the free entries of the matrix variables X1, . . . , XK): Feasibility problem Find x RN (or equivalently matrices X1, . . . , XK with prescribed structure) that satisfies the LMI system A(x) < B(x) The corresponding solver is called feasp. Minimization of a linear objective under LMI constraints Minimize cTx over x RN subject to A(x) < B(x) The corresponding solver is called mincx. Generalized eigenvalue minimization problem Minimize over x RN subject to C(x) < D(x) 0 < B(x) A(x) < B(x). The corresponding solver is called gevp. Note that A(x) < B(x) above is a shorthand notation for general structured LMI systems with decision variables x = (x1, . . . , xN). The three LMI solvers feasp, mincx, and gevp take as input the internal representation LMISYS of an LMI system and return a feasible or optimizing value x* of the decision variables. The corresponding values of the matrix variables X1, . . . , XK are derived from x* with the function dec2mat. These solvers are C-MEX implementations of the polynomial-time Projective Algorithm Projective Algorithm of Nesterov and Nemirovski [3, 2]. For generalized eigenvalue minimization problems, it is necessary to distinguish between the standard LMI constraints C(x) < D(x) and the linear-fractional LMIs A(x) < B(x)
9-20
LMI Solvers
attached to the minimization of the generalized eigenvalue . When using gevp, you should follow these three rules to ensure proper specification of the problem: Specify the LMIs involving as A(x) < B(x) (without the ) Specify them last in the LMI system. gevp systematically assumes that the last L LMIs are linear-fractional if L is the number of LMIs involving Add the constraint 0 < B(x) or any other constraint that enforces it. This positivity constraint is required for well-posedness of the problem and is not automatically added by gevp (see the reference pages for details). An initial guess xinit for x can be supplied to mincx or gevp. Use mat2dec to derive xinit from given values of the matrix variables X1, . . . , XK. Finally, various options are available to control the optimization process and the solver behavior. These options are described in detail in the reference pages. The following example illustrates the use of the mincx solver.
Example 8.2
Consider the optimization problem Minimize Trace(X) subject to A X + XA + XBB X + Q < 0 with data 1 2 1 1 A = 3 2 1 ; B = 0 1 2 1 1 1 1 0 ; Q = 1 3 12 0 12 36
T T
(9-9)
It can be shown that the minimizer X* is simply the stabilizing solution of the algebraic Riccati equation ATX + XA + XBBTX + Q = 0 This solution can be computed directly with the Riccati solver care and compared to the minimizer returned by mincx. From an LMI optimization standpoint, problem (8-9) is equivalent to the following linear objective minimization problem:
9-21
The LMI Lab
T Minimize Trace(X) subject to A X + XA + Q XB < 0 T B X I
(9-10)
Since Trace(X) is a linear function of the entries of X, this problem falls within the scope of the mincx solver and can be numerically solved as follows:
1 Define the LMI constraint (8-9) by the sequence of commands
setlmis([]) X = lmivar(1,[3 1]) % variable X, full symmetric lmiterm([1 lmiterm([1 lmiterm([1 lmiterm([1 1 1 2 2 1 1 2 1 X],1,a,'s') 0],q) 0], 1) X],b',1)
LMIs = getlmis
2 Write the objective Trace(X) as cTx where x is the vector of free entries of X.
Since c should select the diagonal entries of X, it is obtained as the decision vector corresponding to X = I, that is,
c = mat2dec(LMIs,eye(3))
Note that the function defcx provides a more systematic way of specifying such objectives (see Specifying cTx Objectives for mincx on page 9-36 for details).
3 Call mincx to compute the minimizer xopt and the global minimum
copt = c'*xopt of the objective: options = [1e 5,0,0,0,0] [copt,xopt] = mincx(LMIs,c,options)
Here 1e 5 specifies the desired relative accuracy on copt. The following trace of the iterative optimization performed by mincx appears on the screen:
Solver for linear objective minimization under LMI constraints
9-22
LMI Solvers
Iterations : Best objective value so far 1 2 3 *** 4 *** 5 *** 6 *** 7 *** 8 *** 9 *** 10 *** 11 *** 12 *** 13 *** 14 *** 15 8.511476 13.063640 new lower bound: 15.768450 new lower bound: 17.123012 new lower bound: 17.882558 new lower bound: 18-339853 new lower bound: 18.552558 new lower bound: 18.646811 new lower bound: 18.687324 new lower bound: 18.705715 new lower bound: 18.712175 new lower bound: 18.714880 new lower bound: 18.716094 new lower bound: 18.716509 18.717986 18.719624 18.723491 18.732574 18.753903 18.803708 18.919668 19.189417 19.819471 21.306781 25.005604 34.023978
9-23
The LMI Lab
*** 16 ***
new lower bound: 18.716695 new lower bound:
18.717297
18.716873
Result: feasible solution of required accuracy best objective value: 18.716695 guaranteed relative accuracy: 9.50e 06 f-radius saturation: 0.000% of R = 1.00e+09
The iteration number and the best value of cTx at the current iteration appear in the left and right columns, respectively. Note that no value is displayed at the first iteration, which means that a feasible x satisfying the constraint (8-10) was found only at the second iteration. Lower bounds on the global minimum of cTx are sometimes detected as the optimization progresses. These lower bounds are reported by the message
*** new lower bound: xxx
Upon termination, mincx reports that the global minimum for the objective Trace(X) is 18.716695 with relative accuracy of at least 9.5-by-106. This is the value copt returned by mincx.
4 mincx also returns the optimizing vector of decision variables xopt. The
corresponding optimal value of the matrix variable X is given by

Xopt = dec2mat(LMIs,xopt,X)
which returns 6.3542 5.8895 2.2046 X opt = 5.8895 6.2855 2.2201 2.2046 2.2201 6.0771 This result can be compared with the stabilizing Riccati solution computed by care:
Xst = care(a,b,q, 1) norm(Xopt-Xst)
9-24
LMI Solvers
ans = 6.5390e 05
9-25
The LMI Lab
From Decision to Matrix Variables and Vice Versa

While LMIs are specified in terms of their matrix variables X1, . . . , XK , the LMI solvers optimize the vector x of free scalar entries of these matrices, called the decision variables. The two functions mat2dec and dec2mat perform the conversion between these two descriptions of the problem variables. Consider an LMI system with three matrix variables X1, X2, X3. Given particular values X1, X2, X3 of these variables, the corresponding value xdec of the vector of decision variables is returned by mat2dec:
xdec = mat2dec(LMISYS,X1,X2,X3)
An error is issued if the number of arguments following LMISYS differs from the number of matrix variables in the problem (see matnbr). Conversely, given a value xdec of the vector of decision variables, the corresponding value of the k-th matrix is given by dec2mat. For instance, the value X2 of the second matrix variable is extracted from xdec by
X2 = dec2mat(LMISYS,xdec,2)
The last argument indicates that the second matrix variable is requested. It could be set to the matrix variable identifier returned by lmivar. The total numbers of matrix variables and decision variables are returned by matnbr and decnbr, respectively. In addition, the function decinfo provides precise information about the mapping between decision variables and matrix variable entries (see the reference pages).
9-26
Validating Results
Validating Results
The LMI Lab offers two functions to analyze and validate the results of an LMI optimization. The function evallmi evaluates all variable terms in an LMI system for a given value of the vector of decision variables, for instance, the feasible or optimal vector returned by the LMI solvers. Once this evaluation is performed, the left- and right-hand sides of a particular LMI are returned by showlmi. In the LMI problem considered in Example 8.2 on page 9-21, you can verify that the minimizer xopt returned by mincx satisfies the LMI constraint (8-10) as follows:
evlmi = evallmi(LMIs,xopt) [lhs,rhs] = showlmi(evlmi,1)
The first command evaluates the system for the value xopt of the decision variables, and the second command returns the left- and right-hand sides of the first (and only) LMI. The negative definiteness of this LMI is checked by
eig(lhs-rhs) ans = 2.0387e 04 3.9333e 05 1.8917e 07 4.6680e+01
9-27
The LMI Lab
Modifying a System of LMIs

Once specified, a system of LMIs can be modified in several ways with the functions dellmi, delmvar, and setmvar.
Deleting an LMI
The first possibility is to remove an entire LMI from the system with dellmi. For instance, suppose that the LMI system of Example 8.1 on page 9-8 is described in LMISYS and that we want to remove the positivity constraint on X. This is done by
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 (8-6)(8-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
setlmis([]) X = lmivar(1,[4 1]) % X W = lmivar(2,[2 4]) % W
9-28
Modifying a System of LMIs
lmiterm([1 1 1 X],1,A,'s') lmiterm([1 1 1 W],B,1,'s') lmiterm([1 1 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 8.1 on page 9-8 and suppose we want to know if the peak gain of G itself is less than one, that is, if ||G|| < 1 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 = 2I. To set S to this value, enter
NEWSYS = setmvar(LMISYS,S,2)
9-29
The LMI Lab
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 2byI. The resulting system NEWSYS reads A T X + XA + 2C T C XB <0 T B X 2I X>0 2I > I Note that the last LMI is now free of variable and trivially satisfied. It could, therefore, be deleted by
NEWSYS = dellmi(NEWSYS,3)
or
NEWSYS = dellmi(NEWSYS,Slmi)
if Slmi is the identifier returned by newlmi.
9-30
Advanced Topics
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 described above.
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. We first consider the case of uncorrelated matrix variables.
Example 8.3
Suppose that the problem variables include a 3-by-3 symmetric matrix X and a 3-by-3 symmetric Toeplitz matrix y y y 1 2 3 Y = y2 y1 y2 y y y 3 2 1 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+[1 2 3;2 1 2;3 2 1])
9-31
The LMI Lab
or equivalently by
Y = lmivar(3,toeplitz(n+[1 2 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 = 1 2 4
2 3 5
4 5 6
decinfo(lmis,Y) ans = 7 8 9
8 7 8
9 8 7
The next example is a problem with interdependent matrix variables.
Example 8.4
Consider three matrix variables X, Y, Z with structure X = x 0 , 0 y Y = z 0 , 0 t Z = 0 x 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:
setlmis([]) [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 = 1 0 0 2
9-32
Advanced Topics
sY = 3 0
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 x 1 = 0 x Z = x 0 t 0 4 as confirmed by checking its entry-wise dependence on the decision variables:
sZ = 0 4 0 1
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
9-33
The LMI Lab
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
X 1 X 2
X2 X1
and any fixed matrix A = A1 + jA2, including real ones,by

A A 1 2 A A 2 1
For instance, the real counterpart of the LMI system M XM < X,

H
X = X >I
(9-11)
reads (given the decompositions M = M1 + jM2 and X = X1 + jX2 with Mj, Xj real): M M 1 2 M M 2 1
T
X X 1 2 X X 2 1
M M 1 2 M M 2 1
X X 1 2 < X X 2 1
X X 1 2 <I X X 2 1 Note that X = XH in turn requires that X 1 = X 1 and X 2 + X 2 = 0 . Consequently, X1 and X2 should be declared as symmetric and skewsymmetric matrix variables, respectively. Assuming, for instance, that M C55, the LMI system (8-11) would be specified as follows:
H T
9-34
Advanced Topics
M1=real(M), M2=imag(M) bigM=[M1 M2;-M2 M1] setlmis([]) % declare bigX=[X1 X2;-X2 X1] with X1=X1' and X2+X2'=0: [X1,n1,sX1] = lmivar(1,[5 1]) [X2,n2,sX2] = lmivar(3,skewdec(5,n1)) bigX = lmivar(3,[sX1 sX2;-sX2 sX1]) % describe the real counterpart of (1.12): lmiterm([1 1 1 0],1) lmiterm([ 1 1 1 bigX],1,1) lmiterm([2 1 1 bigX],bigM',bigM) lmiterm([ 2 1 1 bigX],1,1) lmis = getlmis
Note the three-step declaration of the structured matrix variable bigX = X X 1 2 X X 2 1 :
1 Specify X1 as a (real) symmetric matrix variable and save its structure
description sX1 as well as the number n1 of decision variables used in X1.

2 Specify X2 as a skew-symmetric matrix variable using Type 3 of lmivar and
the utility skewdec. The command skewdec(5,n1) creates a 5-by5 skew-symmetric structure depending on the decision variables n1 + 1, n1 + 2,...
3 Define the structure of bigX in terms of the structures sX1 and sX2 of X1 and
X2 . See the previous subsection for more details on such structure manipulations.
9-35
The LMI Lab
Specifying cTx Objectives for mincx

The LMI solver mincx minimizes linear objectives of the form cTx where x is the vector of decision variables. In most control problems, however, such objectives are expressed in terms of the matrix variables rather than of x. Examples include Trace(X) where X is a symmetric matrix variable, or uTXu where u is a given vector. The function defcx facilitates the derivation of the c vector when the objective is an affine function of the matrix variables. For the sake of illustration, consider the linear objective Trace(X) + x 0 Px0 where X and P are two symmetric variables and x0 is a given vector. If lmisys is the internal representation of the LMI system and if x0, X, P have been declared by
x0 = [1;1] setlmis([]) X = lmivar(1,[3 0]) P = lmivar(1,[2 1]) : : lmisys = getlmis
T
the c vector such that cTx = Trace(X) + x 0 Px0 can be computed as follows:
n = decnbr(lmisys) c = zeros(n,1) for j=1:n, [Xj,Pj] = defcx(lmisys,j,X,P) c(j) = trace(Xj) + x0'*Pj*x0 end
The first command returns the number of decision variables in the problem and the second command dimensions c accordingly. Then the for loop performs the following operations:
1 Evaluate the matrix variables X and P when all entries of the decision vector
x are set to zero except xj:= 1. This operation is performed by the function
defcx. Apart from lmisys and j, the inputs of defcx are the identifiers X and
9-36
Advanced Topics
P of the variables involved in the objective, and the outputs Xj and Pj are the corresponding values.
2 Evaluate the objective expression for X:= Xj and P:= Pj. This yields the j-th
entry of c by definition. In our example the result is

c = 3 1 2 1
Other objectives are handled similarly by editing the following generic skeleton:
n = decnbr( LMI system ) c = zeros(n,1) for j=1:n, [ matrix values ] = defcx( LMI system,j, matrix identifiers) c(j) = objective(matrix values) end
Feasibility Radius
When solving LMI problems with feasp, mincx, or gevp, it is possible to constrain the solution x to lie in the ball xTx < R2 where R > 0 is called the feasibility radius. This specifies a maximum (Euclidean norm) magnitude for x and avoids getting solutions of very large norm. This may also speed up computations and improve numerical stability. Finally, the feasibility radius bound regularizes problems with redundant variable sets. In rough terms, the set of scalar variables is redundant when an equivalent problem could be formulated with a smaller number of variables. The feasibility radius R is set by the third entry of the options vector of the LMI solvers. Its default value is R = 109. Setting R to a negative value means no rigid bound, in which case the feasibility radius is increased during the
9-37
The LMI Lab
optimization if necessary. This flexible bound mode may yield solutions of large norms.
Well-Posedness Issues
The LMI solvers used in the LMI Lab are based on interior-point optimization techniques. To compute feasible solutions, such techniques require that the system of LMI constraints be strictly feasible, that is, the feasible set has a nonempty interior. As a result, these solvers may encounter difficulty when the LMI constraints are feasible but not strictly feasible, that is, when the LMI L(x) 0 has solutions while L(x) < 0 has no solution. For feasibility problems, this difficulty is automatically circumvented by
feasp, which reformulates the problem
Find x such that L ( x ) 0 as Minimize t subject to Lx < t I.
(9-12)
(9-13)
In this modified problem, the LMI constraint is always strictly feasible in x, t and the original LMI (8-12) is feasible if and only if the global minimum tmin of (8-13) satisfies tmin 0 For feasible but not strictly feasible problems, however, the computational effort is typically higher as feasp strives to approach the global optimum tmin = 0 to a high accuracy. For the LMI problems addressed by mincx and gevp, nonstrict feasibility generally causes the solvers to fail and to return an infeasibility diagnosis. Although there is no universal remedy for this difficulty, it is sometimes possible to eliminate underlying algebraic constraints to obtain a strictly feasible problem with fewer variables.
9-38
Advanced Topics
Another issue has to do with homogeneous feasibility problems such as ATP + P A < 0, P>0
While this problem is technically well-posed, the LMI optimization is likely to produce solutions close to zero (the trivial solution of the nonstrict problem). To compute a nontrivial Lyapunov matrix and easily differentiate between feasibility and infeasibility, replace the constraint P > 0-by-P > I with > 0. Note that this does not alter the problem due to its homogeneous nature.
Semi-Definite B(x) in gevp Problems

Consider the generalized eigenvalue minimization problem Minimize subject to A ( x ) 0, C ( x ) < 0. Technically, the positivity of B(x) for some x Rn is required for the well-posedness of the problem and the applicability of polynomial-time interior-point methods. Hence problems where B (x) 0 B(x) = 1 , with B 1 ( x ) > 0 strictly feasible 0 0 cannot be directly solved with gevp. A simple remedy consists of replacing the constraints A(x) < B(x), by A(x) < Y 0 , 0 0 Y 0 B(x) > 0
(9-14)
where Y is an additional symmetric variable of proper dimensions. The resulting problem is equivalent to (8-14) and can be solved directly with gevp.
Efficiency and Complexity Issues

As explained in the beginning of the chapter, the term-oriented description of LMIs used in the LMI Lab typically leads to higher efficiency than the canonical representation
9-39
The LMI Lab
A 0 + x 1 A 1 + + x N A N < 0.
(9-15)
This is no longer true, however, when the number of variable terms is nearly equal to or greater than the number N of decision variables in the problem. If your LMI problem has few free scalar variables but many terms in each LMI, it is therefore preferable to rewrite it as (8-15) and to specify it in this form. Each scalar variable xj is then declared independently and the LMI terms are of the form xjAj. If M denotes the total row size of the LMI system and N the total number of scalar decision variables, the flop count per iteration for the feasp and mincx solvers is proportional to N3 when the least-squares problem is solved via. Cholesly factorization of the Hessian matrix (default) [2] M-by-N2 when numerical instabilities warrant the use of QR factorization instead While the theory guarantees a worst-case iteration count proportional to M, the number of iterations actually performed grows slowly with M in most problems. Finally, while feasp and mincx are comparable in complexity, gevp typically demands more computational effort. Make sure that your LMI problem cannot be solved with mincx before using gevp.
Solving M + PTXQ + QTXTP < 0

In many output-feedback synthesis problems, the design can be performed in two steps:
1 Compute a closed-loop Lyapunov function via LMI optimization. 2 Given this Lyapunov function, derive the controller state-space matrices by
solving an LMI of the form M + P XQ + Q X P < 0

T T T
(9-16)
where M, P, Q are given matrices and X is an unstructured m-by-n matrix variable.
9-40
Advanced Topics
It turns out that a particular solution Xc of (8-16) can be computed via simple linear algebra manipulations [1]. Typically, Xc corresponds to the center of the ellipsoid of matrices defined by (8-16). The function basiclmi returns the explicit solution Xc:
Xc = basiclmi(M,P,Q)
Since this central solution sometimes has large norm, basiclmi also offers the option of computing an approximate least-norm solution of (8-16). This is done by
X = basiclmi(M,P,Q,'Xmin')
and involves LMI optimization to minimize ||X||.
9-41
The LMI Lab
References
[1] Gahinet, P., and P. Apkarian, A Linear Matrix Inequality Approach to H Control, Int. J. Robust and Nonlinear Contr., 4 (1994), pp. 421448. [2] Nemirovski, A., and P. Gahinet, The Projective Method for Solving Linear Matrix Inequalities, Proc. Amer. Contr. Conf., 1994, pp. 840844. [3] Nesterov, Yu, and A. Nemirovski, Interior Point Polynomial Methods in Convex Programming: Theory and Applications, SIAM Books, Philadelphia, 1994. [4] Shamma, J.S., Robustness Analysis for Time-Varying Systems, Proc. Conf. Dec. Contr., 1992, pp. 31633168.
9-42
10
Function Reference
This chapter gives a detailed description of all Robust Control Toolbox functions. Functions are grouped by application in tables at the beginning of this chapter, then they are listed alphabetically. In addition, information on each function is available through the online Help facility.
Functions Categorical List (p. 10-2) Functions Alphabetical List (p. 10-10)
Lists the Robust Control Toolbox functions according to their purpose. Lists the Robust Control Toolbox functions alphabetically.
10
Function Reference
Functions Categorical List

Uncertain Elements
ucomplex ucomplexm udyn ultidyn ureal
Uncertain complex parameter Uncertain complex matrix Uncertain dynamics Uncertain linear time-invariant object Uncertain real parameter
Uncertain Matrices and Systems

umat uss ufrd randatom randumat randuss
Plant augmentation for state-space models Plant augmentation for transfer functions General multivariable interconnected system Create a random uncertain element Create a random uncertain matrix Create a random uncertain state-space model
Manipulation of Uncertain Models

isuncertain simplify usample usubs gridureal lftdata uss/ssbal
True for uncertain systems Simplify representation of an uncertain object Generate random samples of an uncertain object Substitutes values for uncertain elements Grid real parameters over their range Extract LFT data from uncertain objects Diagonal state/uncertainty scaling for an uncertain system
10-2
Interconnection of Uncertain Models

imp2exp sysic iconnect icsignal imp2exp
Converts implicit LFT relationship to explicit I/O Form interconnections of LTI and uncertain objects Creates an interconnection object (alternative to sysic) Creates an ICsignal object for equations used with iconnect Creates an identically-zero ICsignal used with iconnect
Model Order Reduction

reduce balancmr bstmr hankelmr modreal ncfmr schurmr slowfast stabproj imp2ss
Main interface to model approximation algorithms Balanced truncation model reduction Balanced stochastic truncation model reduction Optimal Hankel norm model approximation Schur balanced truncation model reduction Balanced normalized coprime factor model reduction Schur balanced truncation model reduction State-space slow-fast decomposition State-space stable/anti-stable decomposition Impulse response to state-space approximation
10-3
10
Function Reference
Robustness and Worst-Case Analysis

cpmargin gapmetric loopmargin loopsens mussv mussvextract ncfmargin popov robustperf robuststab robopt wcnorm wcgain wcgopt wcmargin wcsens
Coprime stability margin of plant-controller feedback loop Compute the cap and the Vinnicombe gap metric Comprehensive analysis of feedback loops Sensitivity functions of feedback loops Bounds on the structured singular value () Extracts data from mussv output structure Normalized coprime stability margin of feedback loop Test for robust stability with Popov criterion Robust performance of uncertain systems Stability margins of uncertain systems Creates a robuststab/robustperf options object Worst-case norm of an uncertain matrix Worst-case gain of an uncertain system Creates a wcnorm/wcgain options objects Worst-case gain/phase margins for feedback loops Worst-case sensitivity functions of feedback loops
10-4
Robustness Analysis for Parameter-Dependent Systems (P-Systems)

psys psinfo ispsys pvec pvinfo polydec uss aff2pol quadstab quadperf pdlstab decay pdsimul
Specify a parameter-dependent system (P-system) Query characteristics of a P-system True for parameter-dependent systems Specify a vector of uncertain or time-varying parameters Query characteristics of a parameter vector Compute polytopic coordinates with respect to box corners Convert affine P-systems to uncertain state-space models Convert affine P-systems to polytopic representation Assess quadratic stability of parameter-dependent systems Assess quadratic Hinf performance of P-systems Test robust stability using parametric Lyapunov functions Compute quadratic decay rate Simulate P-systems along parameter trajectories
10-5
10
Function Reference
Controller Synthesis
augw h2hinfsyn h2syn hinfsyn sdhinfsyn loopsyn ltrsyn mixsyn ncfsyn mkfilter
Augments plant weights for mixed-sensitivity control design Mixed H2/H controller synthesis H2 controller synthesis. H controller synthesis. H controller synthesis. for continuous sampled-data system H loop shaping controller synthesis Loop-transfer recovery controller synthesis H mixed-sensitivity controller synthesis H normalized coprime factor controller synthesis Construct a shaping filter
-Synthesis
cmslsyn dksyn dkitopt drawmag fitfrd fitmagfrd
Constant matrix -synthesis Synthesis of a robust controller by -synthesis Create a dksyn options object Interactive mouse-based sketching and fitting tool Fit frequency-dependent scaling with LTI models Fit scaling magnitude data with stable, minimum-phase model
10-6
Sampled-Data Systems
adhinfnorm sdlsim sdhinfsyn
Induced L2 norm of a sampled-data system Time response of sampled-data feedback systems Sample-data H controller synthesis
Gain Scheduling
hinfgs
Design gain-scheduled H controllers
Supporting Utilities
bilin mktito sectf skewdec
State-space bilinear transform Partition LTI systems by input and output groups Sector transformation for LTI systems Create a skew-symmetric matrix (LMI)
Specification of Systems of LMIs

lmiedit setlmis lmivar lmiterm newlmi getlmis
Open the LMI editor GUI Initialize the creation of LMIs Create a new matrix-valued variable in LMI systems Add a new term to a given LMI Add a new LMI to an LMI system Get the internal description of LMI systems
10-7
10
Function Reference
LMI Characteristics
lmiinfo lminbr matnbr decnbr dec2mat mat2dec decinfo
Get information about an existing system of LMIs Get the number of LMIs in an LMI system Get the number of matrix variables in an LMI system Get the number of decision variables in an LMI system Extract matrix variable value from vector of decision variables Construct decision variables vector from matrix Show how matrix variables depend on decision variables
LMI Solvers
feasp mincx gevp defcx
compute a solution to a given LMI system Minimize a linear objective under LMI constraints Solve generalized eigenvalue minimization problems Specify cx objectives of mincx
Validation of Results
evallmi showlmi
Evaluate the LMIs for given values of decision variables Return the left- and right-hand-side of evaluated LMIs
10-8
Modification of Systems of LMIs

dellmi delmvar setmvar
Synthesis of a robust controller via -synthesis Create a dksyn options object Interactive mouse-based sketching and fitting tool
10-9
10
Functions Alphabetical List
10
actual2normalized . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-15 aff2pol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-18 augw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-19 balancmr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-22 bilin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-27 bstmr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-32 cmsclsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-37 decay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-39 decinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-40 decnbr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-43 dec2mat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-44 defcx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-45 dellmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-46 delmvar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-48 diag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-49 dkitopt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-50 dksyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-54 dmplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-63 drawmag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-67 evallmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-69 feasp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-71 fitfrd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-75 fitmagfrd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-78 gapmetric . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-83 genphase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-87 getlmis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-88 gevp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-89 gridureal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-93 h2hinfsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-97 h2syn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-99 hankelmr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-105 hankelsv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-112 hinfgs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-115 hinfsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-118 iconnect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-125
10-10
icsignal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . imp2exp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . imp2ss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ispsys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . isuncertain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lftdata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lmiedit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lmiinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lminbr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lmireg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lmiterm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lmivar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . frd/loglog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . loopmargin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . loopsens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . loopsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ltrsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . matnbr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mat2dec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mincx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mixsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mkfilter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mktito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . modreal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . msfsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mussv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . mussvextract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ncfmargin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ncfmr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ncfsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . newlmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . normalized2actual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . pdlstab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . pdsimul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . polydec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . popov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . psinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10-129 10-130 10-133 10-136 10-137 10-139 10-145 10-147 10-151 10-152 10-153 10-156 10-160 10-162 10-173 10-177 10-183 10-187 10-188 10-190 10-193 10-196 10-198 10-200 10-202 10-204 10-209 10-214 10-218 10-222 10-226 10-227 10-228 10-230 10-231 10-232 10-233
10-11
10
psys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . pvec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . pvinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . quadperf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . quadstab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . randatom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . randumat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . randuss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . frd/rcond . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . repmat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . robopt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . robustperf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . robuststab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . frd/schur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . schurmr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sdhinfnorm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sdhinfsyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sdlsim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sectf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . frd/semilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . setlmis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . setmvar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . showlmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . simplify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . skewdec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . slowfast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . squeeze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . uss/ssbal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . stabproj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . frd/svd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . symdec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sysic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ucomplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ucomplexm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . udyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10-234 10-236 10-238 10-239 10-241 10-243 10-245 10-247 10-249 10-250 10-254 10-255 10-258 10-266 10-276 10-277 10-282 10-284 10-287 10-292 10-297 10-298 10-299 10-301 10-302 10-307 10-308 10-310 10-311 10-314 10-316 10-318 10-319 10-320 10-323 10-325 10-327
10-12
ufrd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ultidyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . umat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . uplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ureal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . usample . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . uss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . usubs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . wcgain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . wcgopt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . wcmargin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . wcnorm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . wcsens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10-328 10-330 10-332 10-334 10-337 10-340 10-343 10-345 10-348 10-361 10-366 10-372 10-378
10-13
10
10-14
actual2normalized
Purpose Syntax Description
10actual2normalized
Calculate the normalized distance between a nominal value and a given value for an uncertain atom
ndist = actual2normalized(A,V) ndist = actual2normalized(A,V) is the normalized distance between the nominal value of the uncertain atom A and the given value V.
If V is an array of values, then ndist is an array of normalized distances. The robustness margins computed in robuststab and robustperf serve as bounds for the normalized distances in ndist. For example, if an uncertain system has a stability margin of 1.4, this system is stable when the normalized distance of the uncertain element values from the nominal is less than 1.4.
Example
For uncertain real parameters whose range is symmetric about their nominal value, the normalized distance is intuitive. Create uncertain real parameters with a range that is symmetric about the nominal value, where each end point is 1 unit from the nominal. Points that lie inside the range are less than 1 unit from the nominal, while points that lie outside the range are greater than 1 unit from the nominal.
a = ureal('a',3,'range',[1 5]); actual2normalized(a,[1 3 5]) ans = -1.0000 -0.0000 1.0000 actual2normalized(a,[2 4]) ans = -0.5000 0.5000 actual2normalized(a,[0 6]) ans = -1.5000 1.5000
Plot the normalized distance for several values. Note that the relationship between a normalized distance and a numerical difference is linear.
values = linspace(-3,9,250); ndist = actual2normalized(a,values);
10-15
actual2normalized
plot(values,ndist)
Next, create an asymmetric parameter, where each end point is 1 unit from the nominal. Points that lie inside the range are less than 1 unit from the nominal, while points that lie outside the range are greater than 1 unit from the nominal.
au = ureal('a',4,'range',[1 5]); actual2normalized(a,[1 4 5]) ans = -1.0000 0.5000 1.0000 actual2normalized(a,[2 4.5]) ans = -0.5000 0.7500 actual2normalized(a,[0 6]) ans = -1.5000 1.5000
Plot the normalized distance for several values. Note that the relationship between normalized distance and numerical difference is nonlinear.
10-16
actual2normalized
ndistu = actual2normalized(au,values); plot(values,ndistu) xlim([-4 10]) ylim([0 4])
See Also
robuststab robustperf
Calculate robust stability margin Calculate robust performance margin
10-17
aff2pol
10aff2pol
Convert affine parameter-dependent models to polytopic models

polsys = aff2pol(affsys) aff2pol derives a polytopic representation polsys of the affine parameter-
dependent system E ( p )x = A ( p )x + B ( p )u y = C ( p )x + D ( p )u
(10-1) (10-2)
where p = (p1, . . ., pn) is a vector of uncertain or time-varying real parameters taking values in a box or a polytope. The description affsys of this system should be specified with psys. The vertex systems of polsys are the instances of (9-1)(9-2) at the vertices pex of the parameter range, i.e., the SYSTEM matrices A ( p ) + jE ( p ) B ( p ) ex ex ex D ( p ex ) C ( p ex )
for all corners pex of the parameter box or all vertices pex of the polytope of parameter values.
See Also
psys pvec uss
Specification of uncertain state-space model Quantification of uncertainty on physical parameters Create an uncertain state-space model
10-18
augw
10augw
State-space or transfer function plant augmentation for use in weighted mixed-sensitivity H and H2 loopshaping design.
P = AUGW(G,W1,W2,W3) P = AUGW(G,W1,W2,W3) computes a state-space model of an augmented LTI plant P(s) with weighting functions W1(s), W2(s), and W3(s) penalizing the error signal, control signal and output signal respectively (see block diagram) so that the closed-loop transfer function matrix is the weighted mixed sensitivity
W 1S
Ty u = W2 R 1 1 W3 T where S, R and T are given by S = ( I + GK )

1 1 1
R = K ( I + GK )
T = GK ( I + GK )
The LTI systems S and T are called the sensitivity and complementary sensitivity, respectively.
AUGMENTED PLANT P(s) y
W1 W2 + u 1 u 2
W3
y 2
CONTROLLER F(s) K(s)
Figure 10-1: Plant Augmentation.
10-19
augw
For dimensional compatibility, each of the three weights W1, W2 and W3 must be either empty, a scalar (SISO) or have respective input dimensions NY, NU, and NY where G is NY-by-NU. If one of the weights is not needed, you may simply assign an empty matrix [ ]; e.g., P = AUGW(G,W1,[],W3) is P(s) as in the Algorithm section below, but without the second row (without the row containing W2).
Algorithm
The augmented plant P(s) produced by is W1 P( s) = 0 0 I W1 G W2 W3 G G
with state-space realization A B1 B2 P ( s ) := C 1 D 11 D 12 C 2 D 21 D 22 AG B W1 C G 0 = BW CG 3 DW DG

1
0 AW1 0 0 CW 0 0 0
1
0 0 AW 0 0 CW 0 0
2 2
0 0 0 AW 0 0 C W3 0
3
0 BW1 0 0 DW 0 0 I
1
BG B W1 D G B W2 BW DG 3 DW DG
1
0 C G + D W3 C G CG
DW
D G + D W3 D G D G
Partitioning is embedded via P=mktito(P,NY,NU), which sets the InputGroup and OutputGroup properties of P as follows
[r,c]=size(P); P.InputGroup = struct('U1',1:c-NU,'U2',c-NU+1:c); P.OutputGroup = struct('Y1',1:r-NY,'Y2',r-NY+1:r);
10-20
augw
Example
s=zpk('s'); G=(s-1)/(s+1); W1=0.1*(s+100)/(100*s+1); W2=0.1; W3=[]; P=augw(G,W1,W2,W3); [K,CL,GAM]=hinfsyn(P); [K2,CL2,GAM2]=h2syn(P); L=G*K; S=inv(1+L); T=1-S; sigma(S,'k',GAM/W1,'k-.',T,'r',GAM*G/W2,'r-.') legend('S = 1/(1+L)','GAM/W1', 'T=L/(1+L)','GAM*G/W2',2)
Singular Values S = 1/(1+L) GAM/W1 T=L/(1+L) GAM*G/W2
60
40
20
20
40
60
80 4 10
10
10
10
10
Limitations
The transfer functions G, W1, W2 and W3 must be proper, i.e., bounded as s or, in the discrete-time case, as z . Additionally, W1, W2 and W3 should be stable. The plant G should be stabilizable and detectable; else, P will not be stabilizable by any K.
h2syn hinfsyn mixsyn mktito
See Also
H2 controller synthesis H controller synthesis H mixed-sensitivity controller synthesis Partition LTI system via Input and Output Groups
10-21
balancmr
Purpose Syntax
10balancmr
Balanced model truncation via square root method GRED = balancmr(G) GRED = balancmr(G,order) [GRED,redinfo] = balancmr(G,key1,value1,...) [GRED,redinfo] = balancmr(G,order,key1,value1,...) balancmr returns a reduced order model GRED of G and a struct array redinfo
Description
containing the error bound of the reduced model and Hankel singular values of the original system. The error bound is computed based on Hankel singular values of G. For a stable system these values indicate the respective state energy of the system. Hence, reduced order can be directly determined by examining the system Hankel SVs, . With only one input argument G, the function will show a Hankel singular value plot of the original model and prompt for model order number to reduce. This method guarantees an error bound on the infinity norm of the additive error || G-GRED || for well-conditioned model reduced problems [1]:
n
G Gred 2
i
k+1
This table describes input arguments for balancmr.

Argument G Description
LTI model to be reduced (without any other inputs will plot its Hankel singular values and prompt for reduced order) (Optional) an integer for the desired order of the reduced model, or optionally a vector packed with desired orders for batch runs
ORDER
A batch run of a serial of different reduced order models can be generated by specifying order = x:y, or a vector of positive integers. By default, all the
10-22
balancmr
anti-stable part of a system is kept, because from control stability point of view, getting rid of unstable state(s) is dangerous to model a system. 'MaxError' can be specified in the same fashion as an alternative for 'Order'. In this case, reduced order will be determined when the sum of the tails of the Hankel sv's reaches the 'MaxError'. This table lists the input arguments 'key' and its 'value'.
Argument Value Description
'MaxError'
Real number or vector of different errors

{Wout,Win} cell
Reduce to achieve H error. When present, 'MaxError'overides ORDER input. Optimal 1-by-2 cell array of LTI weights Wout (output) and Win (input). Defaults are both identity. Weights must be invertible. Display Hankel singular plots (default 'off'). Order of reduced model. Use only if not specified as 2nd argument.
'Weights'
array
'Display' 'Order'
'on' or 'off'
Integer, vector or cell array
Weights on the original model input and/or output can make the model reduction algorithm focus on some frequency range of interests. But weights have to be stable, minimum phase and invertible.
10-23
balancmr
This table describes output arguments.

Argument GRED Description
LTI reduced order model. Becomes multidimensional array when input is a serial of different model order array A STRUCT array with three fields: REDINFO.ErrorBound (bound on || G-GRED ||) REDINFO.StabSV (Hankel SV of stable part of G) REDINFO.UnstabSV (Hankel SV of unstable part of G)
REDINFO
G can be stable or unstable, continuous or discrete.
Algorithm
Given a state space (A,B,C,D) of a system and k, the desired reduced order, the following steps will produce a similarity transformation to truncate the original state space system to the kth order reduced model.
1 Find the SVD of the controllability and observability grammians
P = Up p VpT Q = Uq q VqT
2 Find the square root of the grammians (left/right eigenvectors)
Lp = Up p1/2 Lo = Uq q1/2
3 Find the SVD of (LoTLp)
LoT Lp = U VT
4 Then the left and right transformation for the final kth order reduced model
is SL,BIG = Lo U(:,1:k) (1;k,1:k))-1/2 SR,BIG = Lp V(:,1:k) (1;k,1:k))-1/2
10-24
balancmr
5 Finally,
A C
B D
S T L, BIG AS R, BIG S L, BIG B CS R, BIG D
The proof of the square root balance truncation algorithm can be found in [2].
Example
Given a continuous or discrete, stable or unstable system, G, the following commands can get a set of reduced order models based on your selections:
rand('state',1234); randn('state',5678);G = rss(30,5,4); [g1, redinfo1] = balancmr(G); % display Hankel SV plot % and prompt for order (try 15:20) [g2, redinfo2] = balancmr(G,20); [g3, redinfo3] = balancmr(G,[10:2:18]); [g4, redinfo4] = balancmr(G,'MaxError',[0.01, 0.05]); rand('state',12345); randn('state',6789); wt1 = rss(6,5,5); wt1.d = eye(5)*2; wt2 = rss(6,4,4); wt2.d = 2*eye(4); [g5, redinfo5] = balancmr(G, [10:2:18], 'weight',{wt1,wt2}); for i = 1:5 figure(i); eval(['sigma(G,g' num2str(i) ');']); end
Reference
[1] Glover, K. All Optimal Hankel Norm Approximation of Linear Multivariable Systems, and Their L - error Bounds," Int. J. Control, vol. 39, no. 6, pp. 1145-1193, 1984. [2] Safonov M.G. and R. Y. Chiang, A Schur Method for Balanced Model Reduction, IEEE Trans. on Automat. Contr., vol. 34, no. 7, July 1989, pp. 729-733.
See Also
reduce schurmr hankelmr bstmr ncfmr
Top level model reduction function Balanced model truncation via Schur method Hankel minimum degree approximation Balanced stochastic model truncation via Schur method Balanced model truncation for normalized coprime factors
10-25
balancmr
hankelsv
Hankel singular values
10-26
bilin
10bilin
Multivariable bilinear transform of frequency (s or z).

GT = bilin(G,VERS,METHOD,AUG) bilin computes the effect on a system of the frequency-variable substitution,
z + s = --------------z + The variable VERS denotes the transformation direction: VERS= 1, forward transform ( s z ) or ( s s ) . VERS=-1, reverse transform ( z s ) or ( s s ) . This transformation maps lines and circles to circles and lines in the complex plane. People often use this transformation to do sampled-data control system design [1] or, in general, to do shifting of j modes [2], [3], [4].
Bilin computes several state-space bilinear transformations such as backward rectangular, etc., based on the METHOD you select Table 10-1: Bilinear transform types. Method 'BwdRec' Type of bilinear transform
backward rectangular: z1 s = ----------Tz

AUG = T, the sampling period.
'FwdRec'
forward rectangular: z1 s = ----------T

AUG = T, the sampling period.
10-27
bilin
Table 10-1: Bilinear transform types. Method 'S_Tust' Type of bilinear transform
shifted Tustin: 2 z1 s = --- ------------ z T -- + 1 h

AUG = [T h], is the shift coefficient.
'S_ftjw'
shifted j-axis, bilinear pole-shifting, continuous-time to continuous-time: s + p1 s = -------------------- 1 + s p2

AUG = [p2 p1].
'G_Bilin'
METHOD = 'G_Bilin', general bilinear, continuous-time
to continuos-time: s + s = -------------- s +
AUG = [ ] .
Example
Example 1. Tustin continuous s-plane to discrete z-plane transforms.

Consider the following continuous-time plant (sampled at 20 Hz) A = 1 1 , B = 1 0 , C = 1 0 , D = 0 0 ; T s = 0.05 0 2 1 1 0 1 0 0 Following is an example of four common continuous to discrete bilin transformations for the sampled plant:
A= [-1 1; 0 -2]; B=[1 0; 1 1]; C= [1 0; 0 1]; D=[0 0; 0 0]; sys = ss(A,B,C,D); Ts=0.05; % sampling time [syst] = c2d(sys,Ts,'tustin');
% ANALOG % Tustin
10-28
bilin
[sysp] = c2d(sys,Ts,'prewarp',40); % Pre-warped Tustin [sysb] = bilin(sys,1,'BwdRec',Ts); % Backward Rectangular [sysf] = bilin(sys,1,'FwdRec',Ts); % Forward Rectangular w = logspace(-2,3,50); % frequencies to plot sigma(sys,syst,sysp,sysb,sysf,w);
.
Figure 10-2: . Comparison of 4 Bilinear Transforms from Example 1.
Example 2. Bilinear continuous to continuous pole-shifting 'S_ftjw'

Design an H mixed-sensitivity controller for the ACC Benchmark plant 1 G ( s ) = ------------------------2 2 s (s + 2) such that all closed-loop poles lie inside a circle in the left half of the s-plane whose diameter lies on between points [p1,p2]=[-12,-2]:
p1=-12; p2=-2; s=zpk('s'); G=ss(1/(s^2*(s^2+2))); % original unshifted plant Gt=bilin(G,1,'Sft_jw',[p1 p2]); % bilinear pole shifted plant Gt Kt=mixsyn(Gt,1,[],1); % bilinear pole shifted controller K =bilin(Kt,-1,'Sft_jw',[p1 p2]); % final controller K
10-29
bilin
As shown in Figure 10-3, closed-loop poles are placed in the left circle [p1 p2]. The shifted plant, which has its non-stable poles shifted to the inside the right circle, is 4 5 ( s 12 ) G t ( s ) = 4.765 10 --------------------------------------------------------------------------2 2 ( s 2 ) ( s 4.274s + 5.918 )
Example of Bilinear Mapping: s~ = (s + p1) / (s/p2 1) 10 8 6 4 2 0 2 4 6 8 10 15 10 5 0 5 (p1 = 2, p2 = 12) 10 15 p2 p1 p1 p2 original plant poles (splane) shifted plant poles (s~plane) shifted HInf closedloop poles final HInf closedloop poles
Figure 10-3: 'S_ftjw' final closed-loop poles are inside the left [p1,p2] circle.
Algorithm
bilin employs the state-space formulae in [3]:

1 Ab Bb ----------------- = ( A I ) ( I + A ) -----------------------------------------------------Cb Db 1 C ( I A )
( ) ( I A ) B ---------------------------------------------------------1 D + C ( I A ) B
10-30
bilin
References
[1] Franklin, G. F., and J. D. Powell, Digital Control of Dynamics System, Addison-Wesley, 1980. [2] Safonov, M. G., R. Y. Chiang and H. Flashner, H Control Synthesis for a Large Space Structure, AIAA J. Guidance, Control and Dynamics, 14, 3, pp. 513-520, May/June 1991. [3] Safonov, M. G., Imaginary-Axis Zeros in Multivariable H Optimal Control, in R. F. Curtain (editor), Modelling, Robustness and Sensitivity Reduction in Control Systems, pp. 71-81, Springer-Varlet, Berlin, 1987. [4] Chiang, R. Y. and M. G. Safonov, H Synthesis using a Bilinear Pole Shifting Transform, AIAA, J. Guidance, Control and Dynamics, vol. 15, no. 5, pp. 1111-1117, SeptemberOctober 1992.
See Also
c2d d2c sectf
Convert from continous- to discrete-time Convert from continous- to discrete-time Sector transformation
10-31
bstmr
Purpose Syntax
10bstmr
Balanced stochastic model truncation (BST) via Schur method GRED = bstmr(G) GRED = bstmr(G,order) [GRED,redinfo] = bstmr(G,key1,value1,...) [GRED,redinfo] = bstmr(G,order,key1,value1,...) bstmr returns a reduced order model GRED of G and a struct array redinfo
Description
containing the error bound of the reduced model and Hankel singular values of the phase matrix of the original system [2]. The error bound is computed based on Hankel singular values of the phase matrix of G. For a stable system these values indicate the respective state energy of the system. Hence, reduced order can be directly determined by examining these values. With only one input argument G, the function will show a Hankel singular value plot of the phase matrix of G and prompt for model order number to reduce. This method guarantees an error bound on the infinity norm of the multiplicative || GRED-1(G-GRED) || or relative error || G-1(G-GRED) || for well-conditioned model reduction problems [1]:
n
G ( G Gred )
( 1 + 2i (
k+1
2 1 + i + i ) ) 1
This table describes input arguments for bstmr.

LTI model to be reduced (without any other inputs will plot its Hankel singular values and prompt for reduced order) (Optional) an integer for the desired order of the reduced model, or a vector of desired orders for batch runs
ORDER
A batch run of a serial of different reduced order models can be generated by specifying order = x:y, or a vector of integers. By default, all the anti-stable
10-32
bstmr
part of a system is kept, because from control stability point of view, getting rid of unstable state(s) is dangerous to model a system. 'MaxError' can be specified in the same fashion as an alternative for 'ORDER'. In this case, reduced order will be determined when the accumulated product of Hankel SVs shown in the above equation reaches the 'MaxError'.
Argument 'MaxError' Value Description

'on' or 'off'
Reduce to achieve H error. When present, 'MaxError'overides ORDER input. Display Hankel singular plots (default 'off'). Order of reduced model. Use only if not specified as 2nd argument.
'Display'
'Order'

LTI reduced order model. Become multi-dimension array when input is a serial of different model order array. A STRUCT array with three fields: REDINFO.ErrorBound (bound on || G-1(G-GRED) ||) REDINFO.StabSV (Hankel SV of stable part of G) REDINFO.UnstabSV (Hankel SV of unstable part of G)
REDINFO
Algorithm
10-33
bstmr
1 Find the controllability grammian P and observability grammian Q of the
left spectral factor = ()() = ()() by solving the following Lyapunov and Riccati equations AP + PAT + BBT = 0 BW = PCT + BDT QA + AT Q + (QBW - CT) (-DDT) (QBW - CT)T = 0
2 Find the Schur decomposition for PQ in both ascending and descending
order, respectively,
T
1 0 0 0 n n 0 0 0 1
V A PQV A =
V D PQV D =
3 Find the left/right orthonormal eigen-bases of PQ associated with the kth big
Hankel singular values of the all-pass phase matrix (W*(s))-1G(s). k V A = [V R, SMALL, V L, BIG ] k V D = [ V R, BIG ,V L, SMALL]
4 Find the SVD of (VTL,BIG VR,BIG) = U 5 Form the left/right transformation for the final kth order reduced model
SL,BIG = V L,BIG U(1:k,1:k)1/2 SR,BIG = VR,BIGV(1:k,1:k)1/2
10-34
bstmr
6 Finally,
A C
B D
The proof of the Schur BST algorithm can be found in [2].
Note The BST model reduction theory requires that the original model D matrix be full rank, for otherwise the Riccati solver fails. For any problem with strictly proper model, you can shift the j-axis via bilin such that BST/REM approximation can be achieved up to a particular frequency range of interests. Alternatively, you can attach a small but full rank D matrix to the original problem but remove the D matrix of the reduced order model afterwards. As long as the size of D matrix is insignificant inside the control bandwidth, the reduced order model should be fairly close to the true model. By default, the bstmr program will assign a full rank D matrix scaled by 0.001 of the minimum eigenvalue of the original model, if its D matrix is not full rank to begin with. This serves the purpose for most problems if user does not want to go through the trouble of model pretransformation.
Example
rand('state',1234); randn('state',5678); G = rss(30,5,4); G.d = zeros(5,4); [g1, redinfo1] = bstmr(G); % display Hankel SV plot % and prompt for order (try 15:20) [g2, redinfo2] = bstmr(G,20); [g3, redinfo3] = bstmr(G,[10:2:18]); [g4, redinfo4] = bstmr(G,'MaxError',[0.01, 0.05]); for i = 1:4 figure(i); eval(['sigma(G,g' num2str(i) ');']); end
Reference
[1] Zhou K. Frequency weighted L error bounds, Syst. Contr. Lett., Vol. 21, 115-125, 1993.
10-35
bstmr
[2] Safonov M. G. and R. Y. Chiang, Model Reduction for Robust Control: A Schur Relative Error Method, International J. of Adaptive Control and Signal Processing, Vol. 2, pp. 259-272, 1988.
See Also
reduce balancmr hankelmr schurmr ncfmr hankelsv
Top level model reduction function Balanced truncation via square-root method Hankel minimum degree approximation Balanced truncation via Schur method Balanced truncation for normalized coprime factors Hankel singular value
10-36
cmsclsyn
Purpose Syntax
Approximately solves the constant-matrix, upper bound -synthesis problem

10cmsclsyn
[qopt,bnd] [qopt,bnd] [qopt,bnd] [qopt,bnd]
= = = =
cmsclsyn(R,U,V,BlockStructure); cmsclsyn(R,U,V,BlockStructure,opt); cmsclsyn(R,U,V,BlockStructure,opt,qinit); cmsclsyn(R,U,V,BlockStructure,opt,'random',N)
Description
cmsclsyn approximately solves the constant-matrix, upper bound -synthesis
problem by minimization ( R + UQV )
min
QC
rt
for given matrices R Cnm, U Cnr,V Ctm, and a set Cmn. This applies to constant matrix data in R, U, and V.
[QOPT,BND] = cmsclsyn(R,U,V,BlockStructure) minimizes, by choice of Q, QOPT is the optimum value of Q, the upper bound of mussv(R+U*Q*V,BLK), BND. The matrices R,U and V are constant matrices of the appropriate dimension. BlockStructure is a matrix specifying the perturbation blockstructure as defined for mussv. [QOPT,BND] = cmsclsyn(R,U,V,BlockStructure,OPT) uses the options specified by OPT in the calls to mussv. See mussv for more information. The default value for OPT is 'cUsw'. [QOPT,BND] = cmsclsyn(R,U,V,BlockStructure,OPT,QINIT) initializes the iterative computation from Q = QINIT. Due to the nonconvexity of the overall problem, different starting points often yield different final answers. If QINIT
is an N-D array, then the iterative computation is performed multiple times the i'th optimization is initialized at Q = QINIT(:,:,i). The output arguments are associated with the best solution obtained in this brute force approach.
[QOPT,BND] = cmsclsyn(R,U,V,BlockStructure,OPT,'random',N) initializes the iterative computation from N random instances of QINIT. If NCU is the number of columns of U, and NRV is the number of rows of V, then the approximation to solving the constant matrix synthesis problem is two-fold: only the upper bound for is minimized, and the minimization is not convex, hence the optimum is generally not found. If U is full column rank, or V is full
10-37
cmsclsyn
row rank, then the problem can (and is) cast as a convex problem, [PacZPB], and the global optimizer (for the upper bound for ) is calculated.
Algorithm
The cmsclsyn algorithm is iterative, alternatively holding Q fixed, and computing the mussv upper bound, followed by holding the upper bound multipliers fixed, and minimizing the bound implied by choice of Q. If U or V is square and invertible, then the optimizations reformulated (exactly) as an linear matrix inequality, and solved directly, without resorting to the iteration.
dksyn hinfsyn mussv robuststab robustperf
See Also
Synthesize a robust controller via D-K iteration Synthesize a H controller Calculate bounds on the Structured Singular Value (m) Calculate stability margins of uncertain systems Calculate performance margins of uncertain systems
Reference
Packard, A.K., K. Zhou, P. Pandey, and G. Becker, A collection of robust control problems leading to LMIs, 30th IEEE Conference on Decision and Control, pp. 12451250, Brighton, UK, 1991.
10-38
decay
10decay
Quadratic decay rate of polytopic or affine P-systems

[drate,P] = decay(ps,options)
For affine parameter-dependent systems E(p) x = A(p)x, or polytopic systems E(t) x = A(t)x, (A, E) Co{(A1, E1), . . ., (An, En)}, p(t) = (p1(t), . . ., pn(t))
decay returns the quadratic decay rate drate, i.e., the smallest R such that
ATQE + EQAT < Q holds for some Lyapunov matrix Q > 0 and all possible values of (A, E). Two control parameters can be reset via options(1) and options(2): If options(1)=0 (default), decay runs in fast mode, using the least expensive sufficient conditions. Set options(1)=1 to use the least conservative conditions. options(2) is a bound on the condition number of the Lyapunov matrix P. The default is 109.
See Also
quadstab pdlstab psys
Quadratic stability of polytopic or parameter-dependent systems Robust stability of polytopic or affine parameter-dependent systems (P-system) Specification of uncertain state-space models
10-39
decinfo
10decinfo
Describe how the entries of a matrix variable X relate to the decision variables
decinfo(lmisys) decX = decinfo(lmisys,X)
The function decinfo expresses the entries of a matrix variable X in terms of the decision variables x1, . . ., xN. Recall that the decision variables are the free scalar variables of the problem, or equivalently, the free entries of all matrix variables described in lmisys. Each entry of X is either a hard zero, some decision variable xn, or its opposite xn. If X is the identifier of X supplied by lmivar, the command
decX = decinfo(lmisys,X)
returns an integer matrix decX of the same dimensions as X whose (i, j) entry is 0 if X(i, j) is a hard zero n if X(i, j) = xn (the n-th decision variable) n if X(i, j) = xn
decX clarifies the structure of X as well as its entry-wise dependence on x1, . . ., xN. This is useful to specify matrix variables with atypical structures (see lmivar). decinfo can also be used in interactive mode by invoking it with a single
argument. It then prompts the user for a matrix variable and displays in return the decision variable content of this variable.
Example 1
Consider an LMI with two matrix variables X and Y with structure: X = x I3 with x scalar Y rectangular of size 2-by-1 If these variables are defined by
setlmis([]) X = lmivar(1,[3 0]) Y = lmivar(2,[2 1]) : : lmis = getlmis
10-40
decinfo
the decision variables in X and Y are given by

dX = decinfo(lmis,X) dX = 1 0 0
0 1 0
0 0 1
dY = decinfo(lmis,Y) dY = 2 3
This indicates a total of three decision variables x1, x2, x3 that are related to the entries of X and Y by x 0 0 1 X = 0 x1 0 0 0 x 1 , x Y= 2 x 3
Note that the number of decision variables corresponds to the number of free entries in X and Y when taking structure into account.
Example 2
Suppose that the matrix variable X is symmetric block diagonal with one 2-by-2 full block and one 2-by-2 scalar block, and is declared by
setlmis([]) X = lmivar(1,[2 1;2 0]) : lmis = getlmis
The decision variable distribution in X can be visualized interactively as follows:

decinfo(lmis) There are 4 decision variables labeled x1 to x4 in this problem.
10-41
decinfo
Matrix variable Xk of interest (enter k between 1 and 1, or 0 to quit): ?> 1 The decision variables involved in X1 are among {-x1,...,x4}. Their entry-wise distribution in X1 is as follows (0,j>0,-j<0 stand for 0,xj,-xj, respectively): X1 : 1 2 0 0 2 3 0 0 0 0 4 0 0 0 0 4
********* Matrix variable Xk of interest (enter k between 1 and 1, or 0 to quit): ?> 0
See Also
lmivar mat2dec dec2mat
Specify the matrix variables in an LMI problem Return the vector of decision variables corresponding to particular values of the matrix variables Given values of the decision variables, derive the corresponding values of the matrix variables decnbr
10-42
decnbr
10decnbr
Give the total number of decision variables in a system of LMIs

ndec = decnbr(lmisys)
The function decnbr returns the number ndec of decision variables (free scalar variables) in the LMI problem described in lmisys. In other words, ndec is the length of the vector of decision variables. For an LMI system lmis with two matrix variables X and Y such that X is symmetric block diagonal with one 2-by-2 full block, and one 2-by-2 scalar block Y is 2-by-3 rectangular, the number of decision variables is
ndec = decnbr(LMIs) ndec = 10
Example
This is exactly the number of free entries in X and Y when taking structure into account (see decinfo for more details).
See Also
dec2mat decinfo mat2dec
Given values of the decision variables, derive the corresponding values of the matrix variables decnbr Describe how the entries of a matrix variable X relate to the decision variables Return the vector of decision variables corresponding to particular values of the matrix variables
10-43
dec2mat
10dec2mat
Given values of the decision variables, derive the corresponding values of the matrix variables
valX = dec2mat(lmisys,decvars,X)
Given a value decvars of the vector of decision variables, dec2mat computes the corresponding value valX of the matrix variable with identifier X. This identifier is returned by lmivar when declaring the matrix variable. Recall that the decision variables are all free scalar variables in the LMI problem and correspond to the free entries of the matrix variables X1, . . ., XK. Since LMI solvers return a feasible or optimal value of the vector of decision variables, dec2mat is useful to derive the corresponding feasible or optimal values of the matrix variables.
Example See Also
See the description of feasp.

mat2dec decnbr decinfo
Return the vector of decision variables corresponding to particular values of the matrix variables Give the total number of decision variables in a system of LMIs Describe how the entries of a matrix variable X relate to the decision variables
10-44
defcx
Help specify cTx objectives for the mincx solver

10defcx
[V1,...,Vk] = defcx(lmisys,n,X1,...,Xk) defcx is useful to derive the c vector needed by mincx when the objective is
expressed in terms of the matrix variables. Given the identifiers X1,...,Xk of the matrix variables involved in this objective, defcx returns the values V1,...,Vk of these variables when the n-th decision variable is set to one and all others to zero.
See Also
mincx decinfo
Minimize a linear objective under LMI constraints Describe how the entries of a matrix variable X relate to the decision variables
10-45
dellmi
10dellmi
Remove an LMI from a given system of LMIs

newsys = dellmi(lmisys,n) dellmi deletes the n-th LMI from the system of LMIs described in lmisys. The updated system is returned in newsys.
The ranking n is relative to the order in which the LMIs were declared and corresponds to the identifier returned by newlmi. Since this ranking is not modified by deletions, it is safer to refer to the remaining LMIs by their identifiers. Finally, matrix variables that only appeared in the deleted LMI are removed from the problem.
Example
Suppose that the three LMIs A 1 X1 + X1 A1 + Q 1 < 0 A 2 X2 + X2 A2 + Q 2 < 0 A 3 X3 + X3 A3 + Q 3 < 0 have been declared in this order, labeled LMI1, LMI2, LMI3 with newlmi, and stored in lmisys. To delete the second LMI, type
lmis = dellmi(lmisys,LMI2) lmis now describes the system of LMIs
T T T
A1 X1 + X1 A1 + Q1 < 0 A3 X3 + X3 A3 + Q3 < 0
T
(10-3)
(10-4)
and the second variable X2 has been removed from the problem since it no longer appears in the system (9-4)(9-5). To further delete (9-5), type
lmis = dellmi(lmis,LMI3)
or equivalently
lmis = dellmi(lmis,3)
10-46
dellmi
Note that (9-5) has retained its original ranking after the first deletion.
See Also
newlmi lmiedit lmiinfo
Attach an identifying tag to LMIs Specify or display systems of LMIs as MATLAB expressions Interactively retrieve information about the variables and term content of LMIs
10-47
delmvar
10delmvar
Delete one of the matrix variables of an LMI problem

newsys = delmvar(lmisys,X) delmvar removes the matrix variable X with identifier X from the list of variables defined in lmisys. The identifier X should be the second argument returned by lmivar when declaring X. All terms involving X are automatically
removed from the list of LMI terms. The description of the resulting system of LMIs is returned in newsys.
Example
Consider the LMI T T 0 < A Y + B YA + Q CX + D T T T T X C +D ( X + X )
involving two variables X and Y with identifiers X and Y. To delete the variable X, type
lmisys = delmvar(lmisys,X)
Now lmisys describes the LMI T T 0 < A YB + B YA + Q D T D 0 with only one variable Y. Note that Y is still identified by the label Y.
See Also
lmivar setmvar lmiinfo
Specify the matrix variables in an LMI problem Instantiate a matrix variable and evaluate all LMI terms involving this matrix variable Interactively retrieve information about the variables and term content of LMIs
10-48
diag
10diag
Diagonalize and diagonals of uncertain matrices and systems

v = diag(x)
If x is a vector of uncertain system models or matrices, diag(x) puts x on the main diagonal. If x is a matrix of uncertain system models or matrices, diag(x) is the main diagonal of v. diag(diag(x)) is a diagonal matrix of uncertain system models or matrices. The statement produces a diagonal system mxg of size 4-by-4. Given multivariable system xx, a vector of the diagonal elements of xxg are found using diag.
x = rss(3,4,1); xg = frd(x,logspace(-2,2,80)); size(xg) FRD model with 4 output(s) and 1 input(s), at 80 frequency point(s). mxg = diag(xg); size(mxg) FRD model with 4 output(s) and 4 input(s), at 80 frequency point(s). xxg = [xg(1:2,1) xg(3:4,1)]; m = diag(xxg); size(m) FRD model with 2 output(s) and 1 input(s), at 80 frequency point(s).
Example
See Also
append
Group models by appending their inputs and outputs
10-49
dkitopt
Purpose Syntax
10dkitopt
Create an options object for use with dksyn

dkitopt options = dkitopt options = dkitopt('name1',value1,'name2',value2,...) dkitopt with no input or output arguments displays a complete list of option
Description
properties and their default values.

options = dkitopt creates an options object with all the properties set to their
default values.
options = dkitopt('name1',value1,'name2',value2,...) creates a dkitopt object called options with specific values assigned to certain
properties. Any unspecified property is set to its default value. When entering property names, it is sufficient to only type the leading characters that identify the name uniquely. Property names are not case-sensitive. If the AutoIter property is set to 'off', the D-K iteration procedure is interactive. You are prompted to fit the D-Scale data and provide input on the control design process. This table lists the dkitopt object properties.
Object Property FrequencyVector Description
Frequency vector used for analysis. Default is an empty matrix ([]) which results in the frequency range and number of points chosen automatically Controller used to initiate first iteration. Default is an empty SS object. Automated mu-synthesis mode. Default is 'on', Displays iteration progress in AutoIter mode. Default is 'off'. Starting iteration number. Default is 1.
InitialController
AutoIter
DisplayWhileAutoIter
StartingIterationNumber
10-50
dkitopt
Object Property NumberOfAutoIterations
Description
Number of D-K iterations to perform. Default is 10. Maximum state order for fitting D-scaling data. Default is 5. Automatic termination of iteration procedure based on progress of design iteration. Default is 'on'. Tolerance used by AutoIterSmartTerminate. Default is 0.005. A 1-by-1 structure of dkitopt property default values. A 1-by-1 structure text description of each property.
AutoScalingOrder
AutoIterSmartTerminate
AutoIterSmartTerminateTol
Default Meaning
Example
This statement creates a dkitopt options object called opt with all default values.
opt = dkitopt Property Object Values: FrequencyVector: InitialController: AutoIter: DisplayWhileAutoIter: StartingIterationNumber: NumberOfAutoIterations: AutoScalingOrder: AutoIterSmartTerminate: AutoIterSmartTerminateTol: Default: Meaning:
[] [0x0 ss] 'on' 'off' 1 10 5 'on' 0.0050 [1x1 struct] [1x1 struct]
The dksyn options object opt is updated with the following statements. The frequency vector is set to logspace(-2,3,80), the number of D-K iterations to 16, and the maximum state order of the fitted D-scale data to 9.
10-51
dkitopt
opt.FrequencyVector = logspace(-2,3,80); opt.NumberOfAutoIterations = 16; opt.AutoScalingOrder = 16; opt Property Object Values: FrequencyVector: [1x80 double] InitialController: [0x0 ss] AutoIter: 'on' DisplayWhileAutoIter: 'off' StartingIterationNumber: 1 NumberOfAutoIterations: 16 AutoScalingOrder: 16 AutoIterSmartTerminate: 'on' AutoIterSmartTerminateTol: 0.0050 Default: [1x1 struct] Meaning: [1x1 struct]
In this statement, the same properties are set with a single call to robopt.
opt = dkitopt('FrequencyVector',logspace(-2,3,80),... 'NumberOfAutoIterations',16,'AutoScalingOrder',9) Property Object Values: FrequencyVector: [1x80 double] InitialController: [0x0 ss] AutoIter: 'on' DisplayWhileAutoIter: 'off' StartingIterationNumber: 1 NumberOfAutoIterations: 16 AutoScalingOrder: 9 AutoIterSmartTerminate: 'on' AutoIterSmartTerminateTol: 0.0050 Default: [1x1 struct] Meaning: [1x1 struct]
Algorithm
The dksyn command stops iterating before the total number of automated iterations ('NumberOfAutoIterations') if 'AutoIterSmartTerminate' is set to 'on' and a stopping criteria is satisfied. The stopping criteria involves the m(i) value of the current ith iteration, m(i-1) and m(i-2), the previous two iterations and the options property 'AutoIterSmartTerminateTol'. The DK iteration procedure automatically terminates if the difference between each of
10-52
dkitopt
the three values is less than the relative tolerance of AutoIterSmartTerminateTol (i) or the current value, (i), has increased relative to the value of the previous iteration (i1) by 20AutoIterSmartTerminateTol.
See Also
dksyn h2syn hinfsyn mussv robopt robuststab robustperf wcgopt
Synthesize a robust controller via D-K iteration Synthesize a H2 optimal controller Synthesize a H optimal controller Calculate bounds on the Structured Singular Value () Create a robustperf/robuststab option object Calculate stability margins of uncertain systems Calculate performance margins of uncertain systems Create a wcgain option object
10-53
dksyn
Synthesis of a robust controller via -synthesis D-K iteration
10dksyn
Purpose Syntax
k = dksyn(p,nmeas,ncont) [k,clp,bnd] = dksyn(p,nmeas,ncont) [k,clp,bnd] = dksyn(p,nmeas,ncont,opt) [k,clp,bnd,dkinfo] = dksyn(p,nmeas,ncont,prevdkinfo,opt) [k,clp,bnd,dkinfo] = dksyn(p) dksyn synthesizes a robust controller via D-K iteration. The D-K iteration procedure is an approximation to -synthesis control design. The objective of -synthesis is to minimize the structure singular value of the corresponding robust performance problem associated with the uncertain system p. The uncertain system p is an open-loop interconnection containing known components including the nominal plant model, uncertain parameters (ucomplex) and unmodeled LTI dynamics (ultidyn) and performance and uncertainty weighting functions. You use weighting functions to include magnitude and frequency shaping information into the optimization. The control objective is to synthesize a stabilizing controller k that minimizes the robust performance value, which corresponds to bnd.
Description
The D-K iteration procedure involves a sequence of minimizations, first over the controller variable K (holding the D variable associated with the scaled upper bound fixed), and then over the D variable (holding the controller K variable fixed). The D-K iteration procedure is not guaranteed to converge to the minimum value, but often works well in practice. dksyn automates the D-K iteration procedure and the option object dkitopt allows you to customize its behavior.
[k,clp,bnd] = dksyn(p,nmeas,ncont) synthesizes a robust controller, k, for the uncertain open-loop plant model, p, via the D-K iteration. p is a uss and has nmeas measurement outputs and ncont control inputs. It is assumed that the measurement outputs and control inputs correspond to the last nmeas outputs and ncont inputs. k is the controller, clp is the closed-loop
interconnection and bnd is the robust performance bound for the uncertain closed-loop system clp. p, k, clp, and bnd are related as follows:
clp = lft(p,k); bnd = robustperf(clp);
10-54
dksyn
[k,clp,bnd] = dksyn(p,nmeas,ncont,opt) specifies options described in dkitopt. opt is created via the command opt=dkitopt. See dkitopt for more
details.
[k,clp,bnd,dkinfo] = dksyn(p,nmeas,ncont,prevdkinfo,opt) uses information from a previous dksyn iteration. prevdkinfo is a structure
from a previous attempt at designing a robust controller using dksyn.

prevdkinfo is used when the dksyn starting iteration is not 1 (opt.StartingIterationNumber = 1) to determine the correct D-scalings to
initiate the iteration procedure.

dkinfo is a N-by-1 cell array where N is the total number of iterations
performed. The ith cell contains a structure with the following fields:.
Field K Bnds Description
Controller at i'th iteration, a ss object. Robust performance bound on the closed-loop system (double). Left D-scale, a ss object. Right D-scale, a ss object. Upper and lower m bounds, a frd object. Structure returned from mussv at each iteration.
DL DR MussvBnds MussvInfo
k = dksyn(p) is a valid calling argument provided p is a uss object and has two-input-two-output partitioning as defined by mktito.
Example
The following statements create a robust performance control design for an unstable, uncertain single-input/single-output plant model. The nominal plant s model, G, is an unstable first order system ----------- . s1
G = tf(1,[1 -1]);
The model itself is uncertain. At low frequency, below 2 rad/s, it can vary up to 25% from its nominal value. Around 2 rad/s the percentage variation starts to
10-55
dksyn
increase and reaches 400% at approximately 32 rad/s. The percentage model uncertainty is represented by the weight, Wu, which corresponds to the frequency variation of the model uncertainty and the uncertain LTI dynamic object InputUnc.
Wu = 0.25*tf([1/2 1],[1/32 1]); InputUnc = ultidyn('InputUnc',[1 1]);T
The uncertain plant model, Gpert, represents the model of the physical system to be controlled. Plant model set: Gpert Input Line Wu
u K + + d e
Wp
Gpert = G*(1+InputUnc*Wu);
The robust stability objective is to synthesize a stabilizing LTI controller for all the plant models parameterized by the uncertain plant model, Gpert. The control interconnection structure is shown in the following figure.
The goal is to synthesize a controller that stabilizes and achieves the closed-loop performance objectives for all possible plant models in the Gpert. The performance objective is defined as a weighted sensitivity minimization problem, see the above figure. 1 The sensitivity function, S, is defined as S = ----------------- where P is the plant 1 + PK model and K is the controller. A weighted sensitivity minimization problem selects a weight Wp which corresponds to the inverse of the desired sensitivity function of the closed-loop system as a function of frequency. Hence the product of the sensitivity weight Wp and actual closed-loop sensitivity function is less
10-56
dksyn
than 1 across all frequencies. The sensitivity weight Wp has a gain of 100 at low frequency begins to decrease at 0.006 rad/s and reaches a minimum magnitude of 0.25 after 2.4 rad/s.
Wp = tf([1/4 0.6],[1 0.006]);
The defined sensitivity weight Wp implies that the desired disturbance rejection should be at least 100:1 disturbance rejection at DC, rise slowly between 0.006 and 2.4 rad/s, and allow the disturbance rejection to increase above the open-loop level, 0.25, at high frequency. For the case when the plant model is uncertain, the closed-loop performance objective is to achieve the desired sensitivity function for all plant models defined by the uncertain plant model, Gpert. The performance objective for an uncertain system is a robust performance objective. A block diagram of this uncertain closed-loop system illustrating the performance objective (closed-loop transfer function from de) is shown in the following figure. d P y K From the definition of the robust performance control objective, the weighted, uncertain control design interconnection model, which includes the robustness and performance objectives, can be constructed and is denoted by P. The robustness and performance weights are selected such that if the robust performance structure singular value, bnd, of the closed-loop uncertain system, clp, is less than 1 then the performance objectives have been achieved for all the plant models in the model set. You can form the uncertain transfer matrix, P, from [d; u] to [e; y] using the following commands.
P = [Wp; 1 ]*[1 Gpert]; [K,clp,bnd] = dksyn(P,1,1); bnd bnd =
10-57
dksyn
0.6860 P = [Wp; 1 ]*[1 Gpert]; [K,clp,bnd] = dksyn(P,1,1); bnd bnd = 0.6860
The controller K achieves a robust performance value, bnd, of 0.685. Therefore you have achieved the robust performance objectives for the given problem. You can use the robustperf command to analyze the closed-loop robust performance of clp.
[rpnorm,wcf,wcu,report] = robustperf(clp); disp(report{1}) Uncertain system, clp, achieves robust performance. The our analysis showed clp can tolerate 146% of the model uncertainty and achieve the performance and stability objectives. A model uncertainty exists of size 146% that results in a peak gain performance of 0.686 at 0.569 rad/s.
Algorithm
The DK iteration procedure is an approximation to synthesis control design. It involves a sequence of minimizations, first over the controller variable K (holding the D variable associated with the scaled upper bound fixed), and then over the D variable (holding the controller K variable fixed). The DK iteration procedure is not guaranteed to converge to the minimum value, but often works well in practice.
dksyn automates the DK iteration procedure. Internally, the algorithm works with the generalized, scaled plant model P which is extracted from a uss object using the command lftdata.
The following is a list of what occurs during a single, complete step of the DK iteration.
7 (In the 1st iteration, this step is skipped.) The calculation (from the
previous step) provides a frequency-dependent scaling matrices, Df. The
10-58
dksyn
fitting procedure fits these scalings with rational, stable transfer function matrices,. After fitting, plots of ( D f ( j )F L ( P, K ) ( j )D f ( j ) ) and 1 ( D f ( j )F L ( P, K ) ( j )D f ( j ) ) are shown for comparison. (In the 1st iteration, this step is skipped.) The rational D is absorbed into the open-loop interconnection for the next controller synthesis. Using either the previous frequency-dependent Ds or the just-fit rational D , an estimate of an
1
H norm is made. This is simply a conservative value of the scaled closed- loop H norm, using the most recent controller and either
appropriate value for the a frequency sweep (using the frequency-dependent Ds) or a state-space calculation (with the rational Ds).
8 (The 1st iteration begins at this point.) A controller is designed using
synthesis on the scaled open-loop interconnection. If you set the

DisplayWhileAutoIter field in dkitopt to 'on', the following information
is displayed:
a The progress of the -iteration is displayed. b The singular values of the closed-loop frequency response are plotted. c
You are given the option to change the frequency range. If you change it, all relevant frequency responses are automatically recomputed. parameters if you set the AutoIter field in dkitopt to 'off'. This is convenient if, for instance, the bisection tolerance was too large, or if maximum gamma value was too small.
d You are given the option to rerun the H synthesis with a set of modified
9 The structured singular value of the closed-loop system are calculated and
plotted.
10 An iteration summary is displayed, showing all of the controller order, as
well as the peak value of of the closed-loop frequency responses.

11 The choice of stopping, or performing another iteration is given.
10-59
dksyn
Subsequent iterations proceed along the same lines without the need to re-enter the iteration number. A summary at the end of each iteration is updated to reflect data from all previous iterations. This often provides valuable information about the progress of the robust controller synthesis procedure.
Interactive fitting of D-Scalings

Setting the AutoIter field in dkitopt to 'off' requires you interactively fit the D-scales each iteration. During step 2 of the DK iteration procedure, you are prompted to enter your choice of options for fitting the D-scaling data. After pressing return, the following is a list of your options.
Enter Choice (return for list): Choices: nd Move to Next D-Scaling nb Move to Next D-Block i d apf mx 3 at 1.01 0 2 n e s Increment Fit Order Decrement Fit Order Auto-PreFit Change Max-Order to 3 Change Auto-PreFit tol to 1.01 Fit with zeroth order Fit with second order Fit with n'th order Exit with Current Fittings See Status
nd and nb allow you to move from one D-scale data to another. nd moves to the next scaling, whereas nb moves to the next scaling block. For scalar D-scalings, these are identical operations, but for problems with full D-scalings, (perturbations of the form I) they are different. In the (1,2) subplot window, the title displays the D-scaling Block number, the row/column of the scaling that is currently being fit, and the order of the current fit (with d for data, when no fit exists). The order of the current fit can be incremented or decremented (by 1) using i and d.
10-60
dksyn
apf automatically fits each D-scaling data. The default maximum state order of individual D-scaling is 5. The mx variable allows you to change the maximum D-scaling state order used in the automatic prefitting routine. mx must be a positive, nonzero integer. at allows you to define how close the rational, scaled upper bound is to approximate the actual upper bound in a norm sense. Setting at 1 would require an exact fit of the D-scale data, and is not allowed. Allowable values for at are greater than 1. This setting plays a role (mildly unpredictable, unfortunately) in determining where in the (D,K) space the DK iteration converges. Entering a positive integer at the prompt will fit the current D-scale data with that state order rational transfer function. e exits the D-scale fitting to continue the DK iteration. The variable s will display a status of the current and fits.
Limitations
There are two shortcomings of the D K iteration control design procedure: Calculation of the structured singular value, (), has been approximated by its upper bound. This is not a serious problem since the value of and its upper bound are often close. The D K iteration is not guaranteed to converge to a global, or even local minimum [SteD]. This is a serious problem, and represents the biggest limitation of the design procedure. In spite of these drawbacks, the D K iteration control design technique appears to work well on many engineering problems. It has been applied to a number of real world applications with success. These applications include: vibration suppression for flexible structures, flight control, chemical process control problems, and acoustic reverberation suppression in enclosures.
Reference
Balas, G.J.and J.C. Doyle, Robust control of flexible modes in the controller crossover region, AIAA Journal of Guidance, Dynamics and Control, Vol. 17, no. 2, pp. 370377, March-April, 1994. Balas, G.J., A.K. Packard and J.T. Harduvel, Application of -synthesis techniques to momentum management and attitude control of the space station, AIAA Guidance, Navigation and Control Conference, New Orleans, August 1991. Doyle, J.C., Doyle, K. Lenz, and A. Packard, Design examples using -synthesis: Space shuttle lateral axis FCS during reentry, NATO ASI
10-61
dksyn
Series, Modelling, Robustness, and Sensitivity Reduction in Control Systems, vol. 34, Springer-Verlag, 1987. Packard, A., J. Doyle, and G. Balas, Linear, multivariable robust control with a perspective, ASME Journal of Dynamic Systems, Measurement and Control, 50th Anniversary Issue, vol. 115, no. 2b, pp. 310319, June 1993. [SteD:] Stein, G., and J. Doyle, Beyond singular values and loopshapes, AIAA Journal of Guidance and Control, vol. 14, num. 1, pp. 5-16, January, 1991.
See Also
dkitopt h2syn hinfsyn loopmargin mktito mussv robuststab robustperf wcgain wcsens wcmargin
Create a dksyn options object Synthesize a H2 optimal controller Synthesize a H optimal controller Comprehensive analysis of feedback loop Create a two-input/two-output LTI partition Calculate bounds on the Structured Singular Value () Calculate stability margins of uncertain systems Calculate performance margins of uncertain systems Calculate worst-case gain of a system Calculate worst-case sensitivities for feedback loop Calculate worst-case margins for feedback loop
10-62
dmplot
Purpose Syntax
10dmplot
Interpret disk gain and phase margins

dmplot dmplot(diskgm) [dgm,dpm] = dmplot dmplot plots disk gain margin (dgm) and disk phase margin (dpm). Both margins are derived from the largest disk that
Description
contains the critical point (-1,0) does not intersect the Nyquist plot of the open-loop response L
diskgm is the radius of this disk and a lower bound on the classical gain margin. dmplot(diskgm) plots the maximum allowable phase variation as a function of the actual gain variation for a given disk gain margin diskgm (the maximum gain variation being diskgm). The closed-loop system is guaranteed to remain
stable for all combined gain/phase variations inside the plotted ellipse.
[dgm,dpm] = dmplot returns the data used to plot the gain/phase variation
ellipse.
Example
When you call dmplot (without an argument), the resulting plot shows a comparison of a disk margin analysis with the classical notations of gain and phase margins. The Nyquist plot is of the loop transfer function L(s) s----- + 1 30 L ( s ) = ---------------------------------------------------------( s + 1 ) ( s 2 + 1.6s + 16 ) The Nyquist plot of L corresponds to the blue line. The unit disk corresponds to the dotted red line. GM and PM indicate the location of the classical gain and phase margins for the system L. DGM and DPM correspond to the disk gain and phase margins, respectively. The disk margins provide a lower bound on classical gain and phase margins.
10-63
dmplot
The disk margin circle, represented by the dashed black line, corresponds to the largest disk centered at (GMD + 1/GMD)/2 that just touches the loop transfer function L. This location is indicated by the red dot.
Disk gain margin (DGM) and disk phase margin (DPM) in the Nyquist plot 1 0.8 0.6 Disk Margin 0.4 Imaginary Axis 0.2 0 0.2 0.4 0.6 0.8 Unit Disk Disk Margin Critical point
DGM
GM
DPM
PM
1 1.5 1 0.5 Real Axis 0 0.5 1
The x-axis corresponds to the gain variation, in dB, and the y-axis corresponds to the phase variation allowable, in degrees. For a disk gain margin corresponding to 3 dB (1.414), the closed-loop system is stable for all phase and gain variations inside the blue ellipse. For example, the closed-loop system can simultaneously tolerate +/- 2dB gain variation and +/- 14 deg phase variations.
10-64
dmplot
dmplot(1.414)
Max. Allowable Phase Variation for a 1.41dB Disk Gain Margin. (stability is guaranteed for all gain/phase variations inside the ellipse) 20
18
16
14
Phase Variation (deg)
12
10
0 4
0 1 Gain Variation (dB)
Reference
Barrett, M.F. (1980), Conservatism with robustness tests for linear feedback control systems, Ph.D. Thesis, Control Science and Dynamical Systems, University of Minnesota. Blight, J.D., Dailey, R.L. and Gangsass, D. (1994), Practical control law design for aircraft using multivariable techniques, International Journal of Control, Vol. 59, No. 1, 93-137. Bates, D. and I. Postlethwaite (2002), Robust Multivariable Control of Aerospace Systems, Delft University Press, Delft, The Netherlands, ISBN: 90-407-2317-6.
See Also
loopmargin
Comprehensive stability analysis of feedback loops
10-65
dmplot
wcmargin
Calculate worst-case margins for feedback loop
10-66
drawmag
10drawmag
A mouse-based tool for sketching and fitting

[sysout,pts] = drawmag(data) [sysout,pts] = drawmag(data,init_pts) drawmag interactively uses the mouse in the plot window to create pts (the frd object) and sysout (a stable minimum-phase ss object), which approximately fits the frequency response (magnitude) in pts.
Input arguments: data either a frequency response object that is plotted as a reference, or a constant matrix of the form [xmin xmax ymin ymax] specifying the plot window on the data. optional frd objects of initial set of points
init_pts
Output arguments:
sysout pts
Stable, minimum phase ss object which approximately fits, in magnitude, the pts data. Frequency response of points.
While drawmag is running, all interaction with the program is through the mouse and/or the keyboard. The mouse, if there is one, must be in the plot window. The program recognizes several commands: Clicking the mouse button adds a point at the crosshairs. If the crosshairs are outside the plotting window, the points will be plotted when the fitting, windowing, or replotting modes are invoked. Typing a is the same as clicking the mouse button. Typing r removes the point with frequency nearest that of the crosshairs. Typing any integer between 0-9 fits the existing points with a transfer function of that order. The fitting routine approximately minimizes the maximum error in a log sense. The new fit is displayed along with the points, and the most recent previous fit, if it exists. Typing w uses the crosshair location as the initial point in creating a window. Moving the crosshairs and clicking the mouse or pressing any key then gives
10-67
drawmag
a second point at the new crosshair location. These two points define a new window on the data, which is immediately replotted. This is useful in fine tuning parts of the data. Windowing may be called repeatedly. Typing p simply replots the data using a window that covers all the current data points as well as whatever was specified in in. Typically used after windowing to view all the data. Typing k invokes the keyboard using the keyboard command. Caution should be exercised when using this option, as it can wreak havoc on the program if variables are changed.
See Also
ginput loglog
Graphically input information from mouse Plotting frequency responses on log-log scale
10-68
evallmi
10evallmi
Given a particular instance of the decision variables, evaluate all variable terms in the system of LMIs
evalsys = evallmi(lmisys,decvars) evallmi evaluates all LMI constraints for a particular instance decvars of the vector of decision variables. Recall that decvars fully determines the values of the matrix variables X1, . . ., XK. The evaluation consists of replacing all terms involving X1, . . ., XK by their matrix value. The output evalsys is an LMI system containing only constant terms.
The function evallmi is useful for validation of the LMI solvers output. The vector returned by these solvers can be fed directly to evallmi to evaluate all variable terms. The matrix values of the left- and right-hand sides of each LMI are then returned by showlmi.
Observation
evallmi is meant to operate on the output of the LMI solvers. To evaluate all LMIs for particular instances of the matrix variables X1, . . ., XK, first form the corresponding decision vector x with mat2dec and then call evallmi with x as input.
Example
Consider the feasibility problem of finding X > 0 such that ATXA X + I < 0
where A = 0.5 0.2 . This LMI system is defined by: 0.1 0.7 setlmis([]) X = lmivar(1,[2 1]) % full symmetric X lmiterm([1 1 1 X],A',A) % LMI #1: A'*X*A lmiterm([1 1 1 X],-1,1) % LMI #1: -X lmiterm([1 1 1 0],1) % LMI #1: I lmiterm([-2 1 1 X],1,1) % LMI #2: X lmis = getlmis
To compute a solution xfeas, call feasp by

[tmin,xfeas] = feasp(lmis)
10-69
evallmi
The result is
tmin = -4.7117e+00 xfeas' = 1.1029e+02
-1.1519e+01
1.1942e+02
The LMI constraints are therefore feasible since tmin < 0. The solution X corresponding to the feasible decision vector xfeas would be given by
X = dec2mat(lmis,xfeas,X).
To check that xfeas is indeed feasible, evaluate all LMI constraints by typing
evals = evallmi(lmis,xfeas)
The left- and right-hand sides of the first and second LMIs are then given by
[lhs1,rhs1] = showlmi(evals,1) [lhs2,rhs2] = showlmi(evals,2)
and the test

eig(lhs1-rhs1) ans = -8.2229e+01 -5.8163e+01
confirms that the first LMI constraint is satisfied by xfeas.
See Also
showlmi setmvar dec2mat mat2dec
Return the left- and right-hand sides of an LMI after evaluation of all variable terms Instantiate a matrix variable and evaluate all LMI terms involving this matrix variable Given values of the decision variables, derive the corresponding values of the matrix variables Return the vector of decision variables corresponding to particular values of the matrix variables
10-70
feasp
10feasp
Find a solution to a given system of LMIs

[tmin,xfeas] = feasp(lmisys,options,target)
The function feasp computes a solution xfeas (if any) of the system of LMIs described by lmisys. The vector xfeas is a particular value of the decision variables for which all LMIs are satisfied. Given the LMI system T T N LxN M R ( x )M,
xfeas is computed by solving the auxiliary convex program:
T T
(10-5)
Minimize t subject to N L ( x ) N M R ( x ) M tI . The global minimum of this program is the scalar value tmin returned as first output argument by feasp. The LMI constraints are feasible if tmin 0 and strictly feasible if tmin < 0. If the problem is feasible but not strictly feasible, tmin is positive and very small. Some post-analysis may then be required to decide whether xfeas is close enough to feasible. The optional argument target sets a target value for tmin. The optimization code terminates as soon as a value of t below this target is reached. The default value is target = 0. Note that xfeas is a solution in terms of the decision variables and not in terms of the matrix variables of the problem. Use dec2mat to derive feasible values of the matrix variables from xfeas.
Control Parameters
The optional argument options gives access to certain control parameters for the optimization algorithm. This five-entry vector is organized as follows: options(1) is not used options(2) sets the maximum number of iterations allowed to be performed by the optimization procedure (100 by default) options(3) resets the feasibility radius. Setting options(3) to a value R > 0 further constrains the decision vector x = (x1, . . ., xN) to lie within the ball
10-71
feasp
xi < R
2 i=1
In other words, the Euclidean norm of xfeas should not exceed R. The feasibility radius is a simple means of controlling the magnitude of solutions. Upon termination, feasp displays the f-radius saturation, that is, the norm of the solution as a percentage of the feasibility radius R. The default value is R = 109. Setting options(3) to a negative value activates the flexible bound mode. In this mode, the feasibility radius is initially set to 108, and increased if necessary during the course of optimization options(4) helps speed up termination. When set to an integer value J > 0, the code terminates if t did not decrease by more than one percent in relative terms during the last J iterations. The default value is 10. This parameter trades off speed vs. accuracy. If set to a small value (< 10), the code terminates quickly but without guarantee of accuracy. On the contrary, a large value results in natural convergence at the expense of a possibly large number of iterations. options(5) = 1 turns off the trace of execution of the optimization procedure. Resetting options(5) to zero (default value) turns it back on. Setting option(i) to zero is equivalent to setting the corresponding control parameter to its default value. Consequently, there is no need to redefine the entire vector when changing just one control parameter. To set the maximum number of iterations to 10, for instance, it suffices to type
options=zeros(1,5) options(2)=10 % default value for all parameters
Memory Problems
When the least-squares problem solved at each iteration becomes ill conditioned, the feasp solver switches from Cholesky-based to QR-based linear algebra (seeMemory Problems on page 10-191 for details). Since the QR mode typically requires much more memory, MATLAB may run out of memory and display the message
??? Error using ==> feaslv Out of memory. Type HELP MEMORY for your options.
10-72
feasp
You should then ask your system manager to increase your swap space or, if no additional swap space is available, set options(4) = 1. This will prevent switching to QR and feasp will terminate when Cholesky fails due to numerical instabilities.
Example
Consider the problem of finding P > I such that A 1 P + PA 1 < 0 A 2 P + PA 2 < 0 A 3 P + PA 3 < 0 with data A 1 = 1 2 , A 2 = 0.8 1.5 , A 3 = 1.4 0.9 1 3 1.3 2.7 0.7 2.0 This problem arises when studying the quadratic stability of the polytope of matrices Co{A1, A2, A3}. To assess feasibility with feasp, first enter the LMIs (9-8)(9-10) by:
setlmis([]) p = lmivar(1,[2 1]) lmiterm([1 1 1 p],1,a1,'s') % LMI lmiterm([2 1 1 p],1,a2,'s') % LMI lmiterm([3 1 1 p],1,a3,'s') % LMI lmiterm([-4 1 1 p],1,1) % LMI #4: lmiterm([4 1 1 0],1) % LMI #4: I lmis = getlmis #1 #2 #3 P
T T T
(10-6)
(10-7)
(10-8)
Then call feasp to find a feasible decision vector:

[tmin,xfeas] = feasp(lmis)
10-73
feasp
This returns tmin = -3.1363. Hence (9-8)(9-10) is feasible and the dynamical system x = A(t)x is quadratically stable for A(t) Co{A1, A2, A3}. To obtain a Lyapunov matrix P proving the quadratic stability, type
P = dec2mat(lmis,xfeas,p)
This returns P = 270.8 126.4 126.4 155.1 It is possible to add further constraints on this feasibility problem. For instance, you can bound the Frobenius norm of P by 10 while asking tmin to be less than or equal to 1. This is done by
[tmin,xfeas] = feasp(lmis,[0,0,10,0,0],-1)
The third entry 10 of options sets the feasibility radius to 10 while the third argument -1 sets the target value for tmin. This yields tmin = -1.1745 and a matrix P with largest eigenvalue max(P) = 9.6912.
Reference
The feasibility solver feasp is based on Nesterov and Nemirovskis Projective Method described in Nesterov, Y., and A. Nemirovski, Interior Point Polynomial Methods in Convex Programming: Theory and Applications, SIAM, Philadelphia, 1994. Nemirovski, A., and P. Gahinet, The Projective Method for Solving Linear Matrix Inequalities, Proc. Amer. Contr. Conf., 1994, Baltimore, Maryland, pp. 840844. The optimization is performed by the C-MEX file feaslv.mex.
See Also
mincx gevp dec2mat
Minimize a linear objective under LMI constraints Generalized eigenvalue minimization under LMI constraints Given values of the decision variables, derive the corresponding values of the matrix variables
10-74
fitfrd
Purpose Syntax
10fitfrd
Fit D-scaling frequency response data with state-space model

B = fitfrd(A,N) B = fitfrd(A,N,RD) B = fitfrd(A,N,RD,WT) B = fitfrd(A,N) is a state-space object with state-dimension N, where A is a frd object and N is a nonnegative integer. The frequency response of B closely matches the D-scale frequency response data in A. A must have either 1 row or 1 column, though it need not be 1-by-1. B will be the same size as A. In all cases, N should be a nonnegative scalar. B = fitfrd(A,N,RD) forces the relative degree of B to be RD. RD must be a nonnegative integer. The default value for RD is 0. If A is a row (or column) then RD can be a vector of the same size as well, specifying the relative degree of each entry of B. If RD is a scalar, then it specifies the relative degree for all entries of B. The default for RD can also be specified by setting RD to an empty matrix. B = fitfrd(A,N,RD,WT) uses the magnitude of WT to weight the optimization fit criteria. WT may be a double, ss or frd. If WT is a scalar, then it is used to weight all entries of the error criteria (A-B). If WT is a vector, it must be the same size as A, and each individual entry of WT acts as a weighting function on the corresponding entry of (A-B).
Description
Example
You can use the fitfrd command to fit D-scale data. For example, create D-scale frequency response data from a fifth order system.
sys = tf([1 2 2],[1 2.5 1.5])*tf(1,[1 0.1]); sys = sys*tf([1 3.75 3.5],[1 2.5 13]); omeg = logspace(-1,1); sysg = frd(sys,omeg);
10-75
fitfrd
bode(sysg,'r-');
10
Original data from 5th order system
10
15
20 0
30
60
90
120 10
1
10
You can try to fit the frequency response D-scale data, sysg, with a first order system, b1. Similarly, you can fit the D-scale data with a third order system, b3.
b1 = fitfrd(sysg,1); b3 = fitfrd(sysg,3);
Compare the original D-scale data, sysg, with the frequency responses of the first and third order models calculated by fitfrd.
b1g = frd(b1,omeg); b3g = frd(b3,omeg);
10-76
fitfrd
bode(sysg,'r-',b1g,'k:',b3g,'b-.')
10
First and third order fit to 5th order system
10
15
20 0
45
90
135 10
1
5th order system 1st order fit 3rd order fit

0
10
Limitations See Also
Numerical conditioning problems arise if the state order of the fit, N, is selected to be higher than required by the dynamics of A.
fitmagfrd
Fit magnitude data with stable LTI model
10-77
fitmagfrd
Purpose Syntax
10fitmagfrd
Fit frequency response magnitude data with a stable, minimum-phase state-space model
B B B B = = = = fitmagfrd(A,N) fitmagfrd(A,N,RD) fitmagfrd(A,N,RD,WT) fitmagfrd(A,N,RD,WT,C)
Description
B = fitmagfrd(A,N) is a stable, minimum-phase ss object, with state-dimension N, whose frequency response magnitude closely matches the magnitude data in A. A is a 1-by-1 frd object, and N is a nonnegative integer. B = fitmagfrd(A,N,RD) forces the relative degree of B to be RD. RD must be a nonnegative integer whose default value is 0. The default for RD can also be specified by setting RD to an empty matrix. B = fitmagfrd(A,N,RD,WT) uses the magnitude of WT to weight the optimization fit criteria. WT may be a double, ss or frd. If WT is a scalar, then it is used to weight all entries of the error criteria (A-B). If WT is a vector, it must be the same size as A, and each individual entry of WT acts as a weighting function on the corresponding entry of (A-B). The default value for WT is 1, and can also be specified by setting WT to an empty matrix. B = fitmagfrd(A,N,RD,WT,C) enforces additional magnitude constraints on B, relative to A as:
if C(w) == -1, then enforce abs(B(w)) <= abs(A(w) if C(w) == 1, then enforce abs(B(w)) >= abs(A(w)) if C(w) == 0, then no additional constraint where w denotes the frequency. C should be a scalar, double, or frd, with C.Frequency equal to A.Frequency.
Example
You can use the fitmagfrd command to fit frequency response magnitude data. Create frequency response data from a fifth order system.
sys = tf([1 2 2],[1 2.5 1.5])*tf(1,[1 0.1]); sys = sys*tf([1 3.75 3.5],[1 2.5 13]); omeg = logspace(-1,1); sysg = abs(frd(sys,omeg));
10-78
fitmagfrd
bodemag(sysg,'r');
Original data from 5th order system
10
Magnitude (dB)
10
15
20 1 10
10
Fit the magnitude data with a minimum phase, stable third order system
ord = 3; b1 = fitmagfrd(sysg,ord); b1g = frd(b1,omeg);
10-79
fitmagfrd
bodemag(sysg,'r',b1g,'k:');
10
Third order fit to 5th order system
Magnitude (dB)
10
15
5th order system 3rd order fit

20 1 10 10 Frequency (rad/sec)
0
10
Fit the magnitude data with a third order system constrained to lie below and above the given data.
b2 = fitmagfrd(sysg,ord,[],[],-1); b2g = frd(b2,omeg); b3 = fitmagfrd(sysg,ord,[],[],1); b3g = frd(b3,omeg);
10-80
fitmagfrd
bodemag(sysg,'r',b1g,'k:',b2g,'b-.',b3g,'m--')
10
Third order fits to 5th order system
Magnitude (dB)
10
15
5th order system 3rd order fit Bounded below fit Bounded above fit
20 1 10 10 Frequency (rad/sec)
0
10
Algorithm
fitmagfrd uses a version of log-Chebychev magnitude design, solving min f subject to (at every frequency point in A): |d|^2 /(1+ f/WT) < |n|^2/A^2 < |d|^2*(1 + f/WT)
plus additional constraints imposed with C. n, d denote the numerator and denominator respectively and B = n/d. n and d have orders (N-RD) and N, respectively. The problem is solved using bisection on f and linear programming for fixed f. An alternate approximate method, which cannot enforce the constraints defined by C, is B = fitfrd(genphase(A),N,RD,WT).
Limitations Reference
This input FRD object must be either a scalar 1-by-1 object, a row or column vector. Oppenheim, A.V., and R.W. Schaffer, Digital Signal Processing, Prentice Hall, New Jersey, 1975, pp. 513.
10-81
fitmagfrd
See Also
fitfrd
Fits frequency response data with state-space model
10-82
gapmetric
10gapmetric
Computes upper bounds on the gap and nugap distances (metric) between two systems
[gap,nugap] = gapmetric(p0,p1) [gap,nugap] = gapmetric(p0,p1,tol) [gap,nugap] = gapmetric(p0,p1) calculates upper bounds on the gap and nugap metric between systems p0 and p1. The gap and nugap values lie between
0 and 1. A small value (relative to 1) implies that any controller which stabilizes p0 will likely stabilize p1, and moreover, that the closed-loop gains of the two closed-loop systems will be similar. A gap or nugap of 0 implies that p0 equals p1 and a value of 1 implies that the plants are far apart. The input and output dimensions of p0 and p1 must be the same.
[gap,nugap] = gapmetric(p0,p1,tol) specifies a relative accuracy for calculating the gap metric and nugap metric. The default value for tol is 0.001. The computed answers are guaranteed to satisfy gap-tol < gapexact(p0,p1) <= gap
Example
Consider two plant models. One plant is a unstable, first order, with transfer function 1/(s-0.001) and the other plant is stable first order with transfer function 1/(s+0.001).
p1 = tf(1,[1 -0.001]); p2 = tf(1,[1 0.001]);
Despite the fact that one plant is unstable and the other is stable, these plants are close in the gap and nugap metrics. Intuitively, this is obvious, since, for instance, the feedback controller K=1 will stabilize both plants, and render the closed-loop systems nearly identical.
[g,ng] = gapmetric(p1,p2) g = 0.0029 ng = 0.0020 K = 1; H1 = loopsens(p1,K); H2 = loopsens(p2,K); subplot(2,2,1); bode(H1.Si,'-',H2.Si,'--');
10-83
gapmetric
subplot(2,2,2); bode(H1.Ti,'-',H2.Ti,'--'); subplot(2,2,3); bode(H1.PSi,'-',H2.PSi,'--'); subplot(2,2,4); bode(H1.CSo,'-',H2.CSo,'--');
0 Magnitude (dB)
Bode Diagram Magnitude (dB)
50
Bode Diagram
50
100 180 Phase (deg) Phase (deg)

4 2 0 2
50 0
90
45
0 10 10 10 Frequency (rad/sec) 10
90 2 10
10
10
50 Magnitude (dB)
Bode Diagram Magnitude (dB)
Bode Diagram
50
50 0 Phase (deg) Phase (deg)

1 0 1 2
100 180
45
90
90 2 10
0 10 10 10 Frequency (rad/sec) 10 10
4
10
Next, consider two stable plant models that differ by a first order system. One plant is the transfer function 50/(s+50) and the other plant is the transfer function 50/(s+50) * 8/(s+8).
p3 = tf([50],[1 50]); p4 = tf([8],[1 8])*p3;
Although the two systems have similar high frequency dynamics, the same unity gain at low frequency, the plants are modestly far apart in the gap and nugap metrics.
[g,ng] = gapmetric(p3,p4) g = 0.6156 ng = 0.6147
10-84
gapmetric
Algorithm
gap and nugap compute the gap and gap metrics between two LTI objects. Both quantities give a numerical value (p0,p1) between 0 and 1 for the distance between a nominal system p0 (G0) and a perturbed system p1 (G1).
The gap metric was introduced into the control literature by Zames and El-Sakkary, 1980, and exploited by Georgiou and Smith, 1990. The gap metric was derived by Vinnicombe, 1993. For both of these metrics the following robust performance result holds from Qui and Davidson, 1992, and Vinnicombe, 1993 arcsin b(G1,K1) arcsin b(G0,K0) arcsin (G0,G1) arcsin (K0,K1) where b ( G, K ) = I ( I GK ) 1 G I K
1
The interpretation of this result is that if a nominal plant G0 is stabilized by controller K0, with stability margin b(G0,K0), then the stability margin when G0 is perturbed to G1 and K0 is perturbed to K1 is degraded by no more than the above formula. Note that 1/b(G,K) is also the signal gain from disturbances on the plant input and output to the input and output of the controller. The gap is always less than or equal to the gap, so its predictions using the above robustness result are tighter. To make use of the gap metrics in robust design, weighting functions need to be introduced. In the above robustness result, G needs to be replaced by W2GW1 and K by W 1 KW 2 (similarly for G0, G1, K0 and K1). This makes the weighting functions compatible with the weighting structure in the H -loop shaping control design procedure (see loopsyn and ncfsyn for more details). The computation of the gap amounts to solving 2-block H problems, Georgiou, Smith 1988. The particular method used here for solving the H problems is based on Green et al., 1990. The computation of the nugap uses the method of Vinnicombe, 1993.
1 1
Reference
Georgiou, T.T., On the computation of the gap metric, Systems Control Letters, vol. 11, pp. 253257, 1988.
10-85
gapmetric
Georgiou, T.T., and M. Smith, Optimal robustness in the gap metric, IEEE Transactions on Automatic Control, vol. 35, pp. 673686, 1990. Green, M., K. Glover, D. Limebeer, and J.C. Doyle, A J-spectral factorization approach to H control, SIAM J. of Control and Opt., 28(6), pp. 13501371, 1990. Qiu, L., and E.J. Davison, Feedback stability under simultaneous gap metric uncertainties in plant and controller, Systems Control Letters, vol. 181, pp. 922, 1992. Vinnicombe, G., Measuring Robustness of Feedback Systems, PhD dissertation, Department of Engineering, University of Cambridge, 1993. Zames, G., and El-Sakkary, Unstable systems and feedback: The gap metric, Proceedings of the Allerton Conference, pp. 380385, Oct., 1980.
See Also
loopmargin loopsyn ncfsyn robuststab wcsens wcmargin
Comprehensive analysis of feedback loop H - loop shaping controller synthesis H - normalized coprime controller synthesis Calculate stability margins of uncertain systems Calculate worst-case sensitivities for feedback loop Calculate worst-case margins for feedback loop
10-86
genphase
10genphase
Fit single-input/single-output magnitude data with a real, rational, minimum phase transfer function
resp = genphase(d) genphase uses the complex-cepstrum algorithm to generate a complex frequency response, resp, whose magnitude is equal to the real, positive response d, but whose phase corresponds to a stable, minimum phase function. The input, d, and output, resp, are frd objects.
Reference See Also
Oppenheim, A.V., and R.W. Schaffer, Digital Signal Processing, Prentice Hall, New Jersey, 1975, pp. 513.
fitmagfrd
Fitting magnitude data with stable LTI model
10-87
getlmis
10getlmis
Get the internal description of an LMI system

lmisys = getlmis
After completing the description of a given LMI system with lmivar and lmiterm, its internal representation lmisys is obtained with the command
lmisys = getlmis
This MATLAB representation of the LMI system can be forwarded to the LMI solvers or any other LMI-Lab function for subsequent processing.
See Also
setlmis lmivar lmiterm newlmi
Initialize the description of an LMI system Specify the matrix variables in an LMI problem Specify the term content of LMIs Attach an identifying tag to LMIs
10-88
gevp
10gevp
Generalized eigenvalue minimization under LMI constraints

[lopt,xopt] = gevp(lmisys,nlfc,options,linit,xinit,target) gevp solves the generalized eigenvalue minimization problem
Minimize subject to:
C(x)
<
D(x) B(x)
(10-9) (10-10) (10-11)
0 <
A(x)
< B(x)
where C(x) < D(x) and A(x) < B(x) denote systems of LMIs. Provided that (9-11)(9-12) are jointly feasible, gevp returns the global minimum lopt and the minimizing value xopt of the vector of decision variables x. The corresponding optimal values of the matrix variables are obtained with dec2mat. The argument lmisys describes the system of LMIs (9-11)(9-13) for = 1. The LMIs involving are called the linear-fractional constraints while (9-11)(9-12) are regular LMI constraints. The number of linear-fractional constraints (9-13) is specified by nlfc. All other input arguments are optional. If an initial feasible pair (0, x0) is available, it can be passed to gevp by setting linit to 0 and xinit to x0. Note that xinit should be of length decnbr(lmisys) (the number of decision variables). The initial point is ignored when infeasible. Finally, the last argument target sets some target value for . The code terminates as soon as it has found a feasible pair (, x) with target.
Caution
When setting up your gevp problem, be cautious to Always specify the linear-fractional constraints (9-13) last in the LMI system. gevp systematically assumes that the last nlfc LMI constraints are linear fractional Add the constraint B(x) > 0 or any other LMI constraint that enforces it (see Remark below). This positivity constraint is required for regularity and good formulation of the optimization problem.
10-89
gevp
Control Parameters
The optional argument options gives access to certain control parameters of the optimization code. In gevp, this is a five-entry vector organized as follows: options(1) sets the desired relative accuracy on the optimal value lopt (default = 102). options(2) sets the maximum number of iterations allowed to be performed by the optimization procedure (100 by default). options(3) sets the feasibility radius. Its purpose and usage are as for feasp. options(4) helps speed up termination. If set to an integer value J > 0, the code terminates when the progress in over the last J iterations falls below the desired relative accuracy. By progress, we mean the amount by which decreases. The default value is 5 iterations. options(5) = 1 turns off the trace of execution of the optimization procedure. Resetting options(5) to zero (default value) turns it back on. Setting option(i) to zero is equivalent to setting the corresponding control parameter to its default value.
Example
Given A 1 = 1 2 , A 2 = 0.8 1.5 , A 3 = 1.4 0.9 , 1 3 1.3 2.7 0.7 2.0 consider the problem of finding a single Lyapunov function V(x) = xTPx that proves stability of dV ( x ) and maximizes the decay rate --------------- . This is equivalent to minimizing dt subject to I<P A 1 P + PA 1 < P
T
x = Aix (i = 1, 2, 3)
(10-12) (10-13)
10-90
gevp
A 2 P + PA 2 I : I lemiterm([ 1 1 1 p],1,1) % P > I : lemiterm([2 1 1 p],1,a1,'s') % LFC lemiterm([ 2 1 1 p],1,1) % LFC # 1 lemiterm([3 1 1 p],1,a2,'s') % LFC lemiterm([ 3 1 1 p],1,1) % LFC # 2 lemiterm([4 1 1 p],1,a3,'s') % LFC lemiterm([ 4 1 1 p],1,1) % LFC # 3 lmis = getlmis
P # 1 (lhs) (rhs) # 2 (lhs) (rhs) # 3 (lhs) (rhs)
Note that the linear fractional constraints are defined last as required. To minimize subject to (9-15)(9-17), call gevp by
[alpha,popt]=gevp(lmis,3)
This returns alpha = -0.122 as optimal value (the largest decay rate is therefore 0.122). This value is achieved for P = 5.58 8.35 8.35 18.64
Remark
Generalized eigenvalue minimization problems involve standard LMI constraints (9-11) and linear fractional constraints (9-13). For well-posedness, the positive definiteness of B(x) must be enforced by adding the constraint B(x) > 0 to the problem. Although this could be done automatically from inside the code, this is not desirable for efficiency reasons. For instance, the set of constraints (9-12) may reduce to a single constraint as in the example above. In this case, the single extra LMI P > I is enough to enforce positivity of all
10-91
gevp
linear-fractional right-hand sides. It is therefore left to the user to devise the least costly way of enforcing this positivity requirement.
Reference
The solver gevp is based on Nesterov and Nemirovskis Projective Method described in Nesterov, Y., and A. Nemirovski, Interior Point Polynomial Methods in Convex Programming: Theory and Applications, SIAM, Philadelphia, 1994. The optimization is performed by the CMEX file fpds.mex.
See Also
dec2mat decnbr feasp mincx
Given values of the decision variables, derive the corresponding values of the matrix variables Give the total number of decision variables in a system of LMIs Find a solution to a given system of LMIs Minimize a linear objective under LMI constraints
10-92
gridureal
Purpose Syntax
10gridureal
Grid ureal parameters uniformly over their range

B = gridreal(A,N) [B,SampleValues] = gridreal(A,N) [B,SampleValues] = gridreal(A,Names,N) [B,SampleValues] = gridreal(A,Names1,N1,Names2,N2,...) B = gridureal(A,N) substitutes N uniformly-spaced samples of the uncertain real parameters in A. The size of array B is equal to [size(A) N]. The N samples are generated by uniformly gridding each ureal in A across its range. If A includes uncertain objects other than ureal, then B will be an uncertain object. [B,SampleValues] = gridureal(A,N) additionally returns the specific sampled values (as a STRUCT whose fieldnames are the names of As uncertain elements) of the uncertain reals. Hence, B is the same as usubs(A,SampleValues). [B,SampleValues] = gridureal(A,NAMES,N) samples only the uncertain reals listed in the NAMES variable (CELL, or CHAR array). Any entries of NAMES that are not elements of A are ignored. Note that gridureal(A,fieldnames(A.Uncertainty),N) is the same as gridureal(A,N). [B,SampleValues] = gridureal(A,NAMES1,N1,NAMES2,N2,...) takes N1 samples of the uncertain real parameters listed in NAMES1, and N2 samples of the uncertain real parameters listed in NAMES2 and so on. size(B) will equal [size(A) N1 N2 ...].
Description
Example
Create two uncertain real parameters gamma and tau. The nominal value of gamma is 4 and its range is 3 to 5. The nominal value of tau is 0.5 and its value can change by +/- 30 percent.
gamma = ureal('gamma',4); tau = ureal('tau',.5,'Percentage',30);
These uncertain parameters are used to construct an uncertain transfer function p. An integral controller, c, is synthesized for the plant p based on the nominal values of gamma and tau. The uncertain closed-loop system, clp, is formed.
p = tf(gamma,[tau 1]);
10-93
gridureal
KI = 1/(2*tau.Nominal*gamma.Nominal); c = tf(KI,[1 0]); clp = feedback(p*c,1);
The figure below shows the open-loop unit step response (top plot) and closed-loop response (bottom plot) for a grid of 20 values of gamma and tau.
subplot(2,1,1); step(gridureal(p,20),6) title('Open-loop plant step responses') subplot(2,1,2); step(gridureal(clp,20),6)
Openloop plant step responses
6 5 4 Amplitude 3 2 1 0
3 Time (sec)
1.5
Closedloop plant step responses
1 Amplitude 0.5 0 0
3 Time (sec)
Clearly this illustrates the low-frequency closed-loop insensitivity achieved by the PI control system.
More detailed example

The next example illustrates the different options in gridding high-dimensional (e.g., n greater than 2) parameter spaces. An uncertain matrix, m, is constructed from four uncertain real parameters, a, b, c and d, each making up the individual entries.
a=ureal('a',1); b=ureal('b',2); c=ureal('c',3); d=ureal('d',4);
10-94
gridureal
m = [a b;c d];
In the first case, the (a,b) space is gridded at five places, and the (c,d) space at 3 places, The uncertain matrix m is evaluated at these 15 grid-points resulting in the matrix m1.
m1 = gridureal(m,{'a';'b'},5,{'c';'d'},3);
In the second case, the (a,b,c,d) space is gridded at 15 places, and the uncertain matrix m is sampled at these 15 points. The resulting matrix is m2.
m2 = gridureal(m,{'a';'b';'c';'d'},15);
The (2,1) entry of m is just the uncertain real parameter c. Below, you see the histogram plots of the (2,1) entry of both m1 and m2. The (2,1) entry of m1 only takes on 3 distinct values, while the (2,1) entry of m2 (which is also c) takes on 15 distinct values uniformly through its range.
subplot(2,1,1) hist(m1(2,1,:)) title('2,1 entry of m1') subplot(2,1,2) hist(m2(2,1,:))
10-95
gridureal
title('2,1 entry of m2')

2,1 entry of m1 5 4 3 2 1 0
2.2
2.4
2.6
2.8
3.2
3.4
3.6
3.8
2,1 entry of m2 2
1.5
0.5
2.2
2.4
2.6
2.8
3.2
3.4
3.6
3.8
See Also
usample usubs
Generates random samples of an atom Substitutes values for atoms
10-96
h2hinfsyn
10h2hinfsyn
Mixed H2/H synthesis with pole placement constraints

[gopt,h2opt,K,R,S] = hinfmix(P,r,obj,region,dkbnd,tol) h2hinfyn performs multi-objective output-feedback synthesis. The control problem is sketched in this figure.
w P(s) y K(s)
z z2
Figure 10-4: Mixed H2/H synthesis
If T(s) and T2(s) denote the closed-loop transfer functions from w to z and z2, respectively, hinfmix computes a suboptimal solution of the following synthesis problem: Design an LTI controller K(s) that minimizes the mixed H2/H criterion T + T2 2 subject to ||T|| < 0 ||T2||2 < 0 The closed-loop poles lie in some prescribed LMI region D. Recall that ||.|| and ||.||2 denote the H norm (RMS gain) and H2 norm of transfer functions. More details on the motivations and statement of this problem can be found in Multi-Objective H Synthesis on page 5-15.
P is any SS, TF, or ZPK LTI representation of the plant P(s), and r is a
2 2
three-entry vector listing the lengths of z2, y, and u. Note that z and/or z2 can be empty. The four-entry vector obj = [0, 0, , ] specifies the H2/H
10-97
h2hinfsyn
constraints and trade-off criterion, and the remaining input arguments are optional: region specifies the LMI region for pole placement (the default region = [] is the open left-half plane). Use lmireg to interactively build the LMI region description region dkbnd is a user-specified bound on the norm of the controller feedthrough matrix DK. The default value is 100. To make the controller K(s) strictly proper, set dkbnd = 0. tol is the required relative accuracy on the optimal value of the trade-off criterion (the default is 102). The function h2hinfsyn returns guaranteed H and H2 performances gopt and h2opt as well as the SYSTEM matrix K of the LMI-optimal controller. You can also access the optimal values of the LMI variables R, S via the extra output arguments R and S. A variety of mixed and unmixed problems can be solved with hinfmix. In particular, you can use hinfmix to perform pure pole placement by setting obj = [0 0 0 0]. Note that both z and z2 can be empty in such case.
Reference
Chilali, M., and P. Gahinet, H Design with Pole Placement Constraints: An LMI Approach, to appear in IEEE Trans. Aut. Contr., 1995. Scherer, C., Mixed H2 H Control, to appear in Trends in Control: A European Perspective, volume of the special contributions to the ECC 1995.
See Also
lmireg msfsyn
Specify LMI regions for pole placement purposes Multi-model/multi-objective state-feedback synthesis
10-98
h2syn
10h2syn
H2 control synthesis for an LTI plant
[K,CL,GAM,INFO]=H2SYN(P,NMEAS,NCON) h2syn computes a stabilizing H2 optimal LTI/SS controller K for a partitioned LTI plant P. The controller, K, stabilizes the plant P and has the same number
A B1 B2 P = C 1 D 11 D 12 C 2 D 21 D 22 of states as P. The LTI system P is partitioned where inputs to B1 are the disturbances, inputs to B2 are the control inputs, output of C1 are the errors to be kept small, and outputs of C2 are the output measurements provided to the controller. B2 has column size (NCON) and C2 has row size (NMEAS). If P is constructed with mktito, you can omit NMEAS and NCON from the arguments. The closed-loop system is returned in CL and the achieved H2 cost in GAM. see Figure 2. INFO is a STRUCT array that returns additional information about the design.
u2
A B1 B2 D 11 D P = C 1P(s) 12 C 2 D 21 D 22
y1 y2
K F(s)
Figure 10-5:
H2 control system CL=
lft(P,K)= T y u . 1 1
10-99
h2syn
. Output arguments: K
CL= lft(P,K) GAM = norm(CL) INFO
LTI controller LTI closed-loop system T y u 1 1 Ty u the H optimal cost =

2
1 1
additional output information
Additional output structure array INFO containing possible additional information depending on METHOD):
INFO.NORMS
norms of 4 different quantities, full information control cost (FI), output estimation cost (OEF), direct feedback cost (DFL) and full control cost (FC). NORMS = [FI OEF DFL FC]; full-information gain matrix (constant feedback) u (t) = K x(t) 2 FI
INFO.KFI
INFO.GFI
full-information closed-loop system

GFI=ss(A-B2*KFI,B1,C1-D12*KFI,D11)
INFO.HAMX INFO.HAMY
X Hamiltonian matrix (state-feedback) Y Hamiltonian matrix (Kalman filter)
Examples
Example 1: Stabilize 4-by-5 unstable plant with 3-states, NMEAS=2, NCON=2

rand('seed',0);randn('seed',0); P=rss(3,4,5)'; [K,CL,GAM]=h2syn(P,2,1); open_loop_poles=pole(P) closed_loop_poles=pole(CL)
10-100
h2syn
Example 2: Mixed-Sensitivity H2 loop-shaping. Here the goal is to shape the

sigma plots of sensitivity S:=(I+GK)-1 and complementary sensitivity
T:=GK(I+GK)-1, by choosing a stabilizing K the minimizes the H2 norm of
W 1S ( W 2 G )T W3 T
Ty u = 1 1
0.1 ( s + 1000 ) s1 where G ( s ) = ----------- , W 1 = ----------------------------------- , W 2 = 0.1 , no W3. 100s + 1 s2

s=zpk('s'); G=10*(s-1)/(s+1)^2; W1=0.1*(s+100)/(100*s+1); W2=0.1; W3=[]; P=(G,W1,W2,W3); [K,CL,GAM]=h2syn(P); L=G*K; S=inv(1+L); T=1-S; sigma(L,'k-.',S,'r',T,'g')
Algorithm
The H2 optimal control theory has its roots in the frequency domain interpretation the cost function associated with time-domain state-space LQG control theory [1]. The equations and corresponding nomenclature used here are taken from the Doyle et al., 1989 [2]-[3].
h2syn solves the H2 optimal control problem by observing that it is equivalent
to a conventional Linear-Quadratic Gaussian (LQG) optimal control problem. For simplicity, we shall describe the details of algorithm only for the continuous-time case, in which case the cost function JLQG satisfies
10-101
h2syn
1 T T J LQG = lim E --- y 1 y 1 dt T T 0 1 T T T Q Nc x = lim E --- [ x u 2 ] dt T u2 T T 0 Nc R
T 1 T T T C1 x --- [ x u 2 ] = lim E [ C 1 D 12 ] dt T u2 T T 0 D 12
with plant noise u1 channel of intensity I, passing through the matrix [B1;0;D12] to produce equivalent white correlated with plant and white measurement noise having joint correlation function Nf T E ( t ) [ ( ) ( ) ] = (t ) T ( t) Nf = B1 D 21
T T B 1 D 21 ( t )
The H2 optimal controller K(s) is thus realizable in the usual LQG manner as a full-state feedback KFI and a Kalman filter with residual gain matrix KFC.
1 Kalman Filter
x = A x + B 2 u 2 + K FC ( y 2 C 2 x D 22 u 2 ) K FC = ( YC 2 + N f )
T 1
= ( YC 2 + B 1 D 21 ) ( D 21 D 21 )
T 1
where Y= YT0 solves the Kalman filter Riccati equation YA + A Y ( YC 2 + N f ) ( C 2 Y + N f ) + = 0

T T 1 T
10-102
h2syn
2 Full-State Feedback
u 2 = K FI x K FI = R ( B 2 X + N c ) = ( D 12 D 12 ) ( B 2 X + D 12 C 1 ) where X = XT0 solves the state-feedback Riccati equation A X + X A ( XB 2 + N c ) R ( B 2 X + N c ) + Q = 0 The final positive-feedback H2 optimal controller u 2 = K ( s )y 2 has a familiar closed-form A K FC C 2 B 2 K FI + K FC D 22 K FI K f K ( s ) := K FI 0
h2syn implements the continuos optimal H2 control design computations using
T 1 T T 1 T T T 1 T T
the formulae described in the Doyle, et al.[2]; for discrete-time plants, h2syn uses the same controller formula, except that the corresponding discrete time Riccati solutions (dare) are substituted for X and Y. A Hamiltonian is formed and solved via a Riccati equation. In the continuous-time case, the optimal H2-norm is infinite when the plant D11 matrix associated with the input disturbances and output errors is non-zero; in this case, the optimal H2 controller returned by h2syn is computed by first setting D11 to zero.
3 Optimal Cost GAM.
The full information (FI) cost is given by the equation
( trace ( B 1 X 2 B 1 ) ) 2
1 --
1 --
. The
output estimation cost (OEF) is given by ( trace ( F 2 Y 2 F 2 ) ) 2 , where F 2 =: ( B 2 X 2 + D 12 C 1 ) . The disturbance feedforward cost (DFL) is ( trace ( L 2 X 2 L 2 ) ) 2 , where L2 is defined by ( Y 2 C 2 + B 1 D 21 ) and the full control cost (FC) is given by ( trace ( C 1 Y 2 C 1 ) ) 2 . X2 and Y2 are the solutions to the X and Y Riccati equations, respectively. For for continuous-time plants with zero feedthrough term (D11 = 0), and for all discrete-time plants, the optimal H2 cost = T y 1 u 1 2 is
1 --
1 --
10-103
h2syn
GAM =sqrt(FI^2 + OEF^2+ trace(D11*D11'));
otherwise, GAM = Inf.
Limitations
1 (A, B2, C2) must be stabilizable and detectable. 2 D12 must have full column rank and D21 must have full row rank
References
[1] Safonov, M. G., A. J. Laub, and G. Hartmann, Feedback Properties of Multivariable Systems: The Role and Use of Return Difference Matrix, IEEE Trans. of Automat. Contr., AC-26, pp. 47-65, 1981. [2] Doyle, J. C., K. Glover, P. Khargonekar, and B. Francis, State-space solutions to standard H2 and H control problems, IEEE Transactions on Automatic Control, vol. 34, no. 8, pp. 831847, August 1989. [3] Glover, K., and J.C. Doyle, State-space formulae for all stabilizing controllers that satisfy an H norm bound and relations to risk sensitivity, Systems and Control Letters, 1988. vol. 11, pp. 167172, August 1989.
See Also
augw hinfsyn
Augment plant weights for control design H synthesis controller
10-104
hankelmr
Purpose Syntax
10hankelmr
Hankel Minimum Degree Approximation (MDA) without balancing GRED = hankelmr(G) GRED = hankelmr(G,order) [GRED,redinfo] = hankelmr(G,key1,value1,...) [GRED,redinfo] = hankelmr(G,order,key1,value1,...) hankelmr returns a reduced order model GRED of G and a struct array redinfo
Description
containing the error bound of the reduced model and Hankel singular values of the original system. The error bound is computed based on Hankel singular values of G. For a stable system Hankel singular values indicate the respective state energy of the system. Hence, reduced order can be directly determined by examining the system Hankel SVs, . With only one input argument G, the function will show a Hankel singular value plot of the original model and prompt for model order number to reduce. This method guarantees an error bound on the infinity norm of the additive error || G-GRED || for well-conditioned model reduced problems [1]:
n
G Gred 2
i
k+1
Note It seems this method is similar to the additive model reduction routines balancmr and schurmr, but actually it can produce more reliable reduced order model when the desired reduced model has nearly controllable and/or observable states (has Hankel singular values close to machine accuracy). hankelmr will then select an optimal reduced system to satisfy the error bound criterion regardless the order one might naively select at the beginning.
10-105
hankelmr
This table describes input arguments for hankelmr.

ORDER
A batch run of a serial of different reduced order models can be generated by specifying order = x:y, or a vector of integers. By default, all the anti-stable part of a system is kept, because from control stability point of view, getting rid of unstable state(s) is dangerous to model a system. 'MaxError' can be specified in the same fashion as an alternative for 'ORDER'. In this case, reduced order will be determined when the sum of the tails of the Hankel sv's reaches the 'MaxError'.

{Wout,Win} cell
Reduce to achieve H error. When present, 'MaxError'overides ORDER input. Optimal 1x2 cell array of LTI weights Wout (output) and Win (input). Default for both is identity. Weights must be invertible. Display Hankel singular plots (default 'off'). Order of reduced model. Use only if not specified as 2nd argument.
'Weights'
array
'Display'
'on' or 'off'
'Order'
10-106
hankelmr
Weights on the original model input and/or output can make the model reduction algorithm focus on some frequency range of interests. But weights have to be stable, minimum phase and invertible. This table describes output arguments.
LTI reduced order model. Become multi-dimensional array when input is a serial of different model order array. A STRUCT array with 4 fields: REDINFO.ErrorBound (bound on || G-GRED ||) REDINFO.StabSV (Hankel SV of stable part of G) REDINFO.UnstabSV (Hankel SV of unstable part of G) REDINFO.Ganticausal (Anti-causal part of Hankel MDA)
REDINFO
Note If size(GRED) is not equal to the order you specified. The optimal Hankel MDA algorithm has selected the best Minimum Degree Approximate it can find within the allowable machine accuracy.
Algorithm
Given a state-space (A,B,C,D) of a system and k, the desired reduced order, the following steps will produce a similarity transformation to truncate the original state space system to the kth order reduced model.
1 Find the controllability and observability grammians P and Q. 2 Form the descriptor
E = QP I where k > k + 1 , and descriptor state-space
10-107
hankelmr
Es A C
B D
= A + QAP QB CP D
Take SVD of descriptor E and partition the result into kth order truncation form E = [U E1,U E2]
T E 0 V E1 T 0 0 V E2
3 Apply the transformation to the descriptor state-space system above we
have
T A 11 A 12 U E1 2 T = ( A + QAP ) V E1 V E2 T A 21 A 22 U E2
B1 B2
T U E1 T U E2
QB C
C1 C2 =
CP B
T
V E1 V E2
D1 = D
4 Form the equivalent state-space model. 5 The final kth order Hankel MDA is the stable part of the above state-space
realization. Its anticausal part is stored in redinfo.Ganticausal.
10-108
hankelmr
A C
1 1 B = E ( A 11 A 12 A 22 A 21 ) E ( B 1 A 12 A 22 B 2 ) C 1 C 2 A 22 A 21 D 1 C 2 A 22 B 2 D
The proof of the Hankel MDA algorithm can be found in [2]. The error system between the original system G and the Zeroth Order Hankel MDA G0 is an all-pass function [1].
Example
rand('state',1234); randn('state',5678);G = rss(30,5,4); [g1, redinfo1] = hankelmr(G); % display Hankel SV plot % and prompt for order (try 15:20) [g2, redinfo2] = hankelmr(G,20); [g3, redinfo3] = hankelmr(G,[10:2:18]); [g4, redinfo4] = hankelmr(G,'MaxError',[0.01, 0.05]); rand('state',12345); randn('state',6789); wt1 = rss(6,5,5); wt1.d = eye(5)*2; wt2 = rss(6,4,4); wt2.d = 2*eye(4); [g5, redinfo5] = hankelmr(G, [10:2:18], 'weight',{wt1,wt2}); for i = 1:5 figure(i); eval(['sigma(G,g' num2str(i) ');']); end
Figure 10-6, Singular Value Bode Plot of G (30-state, 5 outputs, 4 inputs), on page 10-110 shows a singular value Bode plot of a random system G with 20 states, 5 output and 4 inputs. The error system between G and its Zeroth order Hankel MDA has it infinity norm equals to an all pass function, as shown in Figure 10-7, All-Pass Error System Between G and Zeroth Order G Anticausal, on page 10-111 (ref.: [5]). The Zeroth order Hankel MDA and its error system sigma plot are obtained via commands
[g0,redinfo0] = hankelmr(G,0); sigma(G-redinfo0.Ganticausal)
This interesting all-pass property is unique in Hankel MDA model reduction.
10-109
hankelmr
Figure 10-6: Singular Value Bode Plot of G (30-state, 5 outputs, 4 inputs)
10-110
hankelmr
Figure 10-7: All-Pass Error System Between G and Zeroth Order G Anticausal
Reference
[1] Glover K. All Optimal Hankel Norm Approximation of Linear Multivariable Systems, and Their L error Bounds, Int. J. Control, vol. 39, no. 6, pp. 1145-1193, 1984. [2] Safonov M. G. and R. Y. Chiang, and D. J. N. Limebeer, Optimal Hankel Model Reduction for Nonminimal Systems, IEEE Trans. on Automat. Contr., vol. 35, no. 4, April 1990, pp. 496-502.
See Also
reduce balancmr schurmr bstmr ncfmr hankelsv
Top level model reduction routines Balanced truncation via square-root method Balanced truncation via Schur method Balanced stochastic truncation via Schur method Balanced truncation for normalized coprime factors Hankel singular value
10-111
hankelsv
Purpose Syntax
10hankelsv
Compute Hankel singular values for stable/unstable or continuous/discrete system

hankelsv(G) hankelsv(G,ErrorType,style) [sv_stab,sv_unstab]=hankelsv(G,ErrorType,style) [sv_stab,sv_unstab]=hankelsv(G,ErrorType,style) returns a column vector SV_STAB containing the Hankel singular values of the stable part of G and SV_UNSTAB of anti-stable part (if it exists). The Hankel SV's of anti-stable part ss(a,b,c,d) is computed internally via ss(-a,-b,c,d). Discrete model is
Description
converted to continuous one via the bilinear transform.

hankelsv(G) with no output arguments draws a bar graph of the Hankel
singular values such as the following:
10-112
hankelsv
This table describes optional input arguments for hankelsvd.

Argument ERRORTYPE Value 'add' Description
'mult' 'ncf'
STYLE
Regular Hankel SVs of G Hankel SVs of phase matrix Hankel SVs of coprime factors Absolute value logarithm scale
'abs' 'log'
Algorithm
For ErrorType = `add', hankelsv implements the numerically robust square root method to compute the Hankel singular values [1]. Its algorithm goes as follows: Given a stable model G, with controllability and observability grammians P and Q, compute the SVD of P and Q:
[Up,Sp,Vp] = svd(P); [Uq,Sq,Vq] = svd(Q);
Then form the square roots of the grammians:

Lr = Up*diag(sqrt(diag(Sp))); Lo = Uq*diag(sqrt(diag(Sq)));
The Hankel singular values are simply:

H = svd(Lo'*Lr);
This method not only takes the advantages of robust SVD algorithm, but also ensure the computations stay well within the square root of the machine accuracy. For ErrorType = `mult', hankelsv computes the Hankel singular value of the phase matrix of G [2]. For ErrorType = `ncf', hankelsv computes the Hankel singular value of the normalized coprime factor pair of the model [3].
10-113
hankelsv
Reference
[1] Safonov M. G. and R. Y. Chiang, A Schur Method for Balanced Model Reduction, IEEE Trans. on Automat. Contr., vol. AC-2, no. 7, July 1989, pp. 729-733. [2] Safonov M. G. and R. Y. Chiang, Model Reduction for Robust Control: A Schur Relative Error Method, International J. of Adaptive Control and Signal Processing, Vol. 2, pp. 259-272, 1988. [3] Vidyasagar M. Control System Synthesis - A Factorization Approach. London: The MIT Press, 1985.
See Also
reduce balancmr schurmr bstmr ncfmr hankelmr
Top level model reduction routines Balanced truncation via square-root method Balanced truncation via Schur method Balanced stochastic truncation via Schur method Balanced truncation for normalized coprime factors Hankel minimum degree approximation
10-114
hinfgs
10hinfgs
Synthesis of gain-scheduled H controllers

[gopt,pdK,R,S] = hinfgs(pdP,r,gmin,tol,tolred)
Given an affine parameter-dependent plant x = A ( p )x + B ( p )w + B u 1 2 P z = C 1 ( p )x + D 11 ( p )w + D 12 u y = C x + D w + D u 2 21 22 where the time-varying parameter vector p(t) ranges in a box and is measured in real time, hinfgs seeks an affine parameter-dependent controller = A K ( p ) + B K ( p )y K u = C K ( p ) + D K ( p )y scheduled by the measurements of p(t) and such that K stabilizes the closed-loop system w P y K for all admissible parameter trajectories p(t) K minimizes the closed-loop quadratic H performance from w to z. The description pdP of the parameter-dependent plant P is specified with psys and the vector r gives the number of controller inputs and outputs (set r=[p2,m2] if y Rp2 and u Rm2). Note that hinfgs also accepts the polytopic model of P returned, e.g., by aff2pol.
hinfgs returns the optimal closed-loop quadratic performance gopt and a polytopic description of the gain-scheduled controller pdK. To test if a
10-115
hinfgs
closed-loop quadratic performance is achievable, set the third input gmin to . The arguments tol and tolred control the required relative accuracy on gopt and the threshold for order reduction. Finally, hinfgs also returns solutions R, S of the characteristic LMI system.
Controller Implementation
The gain-scheduled controller pdK is parametrized by p(t) and characterized by

A (p) B (p) K at the corners of the parameter box. The the values Kj of K j CK ( p ) DK ( p )
command
Kj = psinfo(pdK,'sys',j)
returns the j-th vertex controller Kj while

pv = psinfo(pdP,'par') vertx = polydec(pv) Pj = vertx(:,j)
gives the corresponding corner j of the parameter box (pv is the parameter vector description). The controller scheduling should be performed as follows. Given the measurements p(t) of the parameters at time t,
6 Express p(t) as a convex combination of the j:
N
p(t) = 11 + . . .+ NN,
j 0,
j
i=1
= 1
This convex decomposition is computed by polydec.

7 Compute the controller state-space matrices at time t as the convex
combination of the vertex controllers Kj:

A (t) B (t) K K CK ( t ) DK ( t ) =
N
j K .
j
i=1
8 Use AK(t), BK(t), CK(t), DK(t) to update the controller state-space equations.
10-116
hinfgs
Reference
Apkarian, P., P. Gahinet, and G. Becker, Self-Scheduled H Control of Linear Parameter-Varying Systems, submitted to Automatica, October 1995. Becker, G., Packard, P., Robust Performance of Linear-Parametrically Varying Systems Using Parametrically-Dependent Linear Feedback, Systems and Control Letters, 23 (1994), pp. 205215. Packard, A., Gain Scheduling via Linear Fractional Transformations, Syst. Contr. Letters, 22 (1994), pp. 7992.
See Also
psys pvec pdsimul polydec
Specification of uncertain state-space models Quantification of uncertainty on physical parameters Time response of a parameter-dependent system along a given parameter trajectory Compute polytopic coordinates wrt. box corners
10-117
hinfsyn
Purpose Syntax
Compute an H optimal controller for an LTI plant

10hinfsyn
[K,CL,GAM,INFO] = hinfsyn(P) [K,CL,GAM,INFO] = hinfsyn(P,NMEAS,NCON) [K,CL,GAM,INFO] = hinfsyn(P,NMEAS,NCON,KEY1,VALUE1,KEY2,VALUE2,...) hinfsyn computes a stabilizing H optimal LTI/SS controller K for a partitioned LTI plant P.
Description
A B1 B2 P = C 1 D 11 D 12 C 2 D 21 D 22 The controller, K, stabilizes the P and has the same number of states as P. The SYSTEM P is partitioned where inputs to B1 are the disturbances, inputs to B2 are the control inputs, output of C1 are the errors to be kept small, and outputs of C2 are the output measurements provided to the controller. B2 has column size (NCON) and C2 has row size (NMEAS). The optional KEY and VALUE inputs determine tolerance, solution method and so forthsee Figure 1 for details. The closed-loop system is returned in CL and the achieved H cost in GAM. INFO is a STRUCT array that returns additional information about the designsee Figure 2.
u2
A B1 B2 D 11 D P= C 1 P(s) 12 C 2 D 21 D 22
y1 y2
K F(s)
Figure 10-8:
H control system CL=
lft(P,K)= T y u . 1 1
10-118
hinfsyn
Key
'GMAX' 'GMIN' 'TOLGAM' 'S0'
Value
Meaning
real real real real

`ric' 'lmi' 'maxe'
initial upper bound on GAM (default=Inf) initial lower bound on GAM (default=0) relative error tolerance for GAM (default=.01) (default=Inf) frequency S0 at which entropy is evaluated, only applies to METHOD 'maxe' (default) standard 2-Riccati solution, LMI solution maximum entropy solution (default) no command window display, or command window displays synthesis progress information
'METHOD'
'DISPLAY'
'off' 'on'
Figure 10-9: Optional input arguments (KEY, VALUE) pairs
When DISPLAY='on', the hinfsyn program displays several variables indicating the progress of the algorithm. For each value being tested, the minimum magnitude, real part of the eigenvalues of the X and Y Hamiltonian matrices are displayed along with the minimum eigenvalue of X and Y, which are the solutions to the X and Y Riccati equations, respectively. The maximum eigenvalue of XY, scaled by 2,is also displayed. A # sign is placed to the right of the condition that failed in the printout . Output arguments:
K CL= lft(P,K)
LTI controller LTI closed-loop system T y 1 u1
10-119
hinfsyn
GAM = norm(CL,Inf) INFO
the H cost = T y 1 u1 additional output information
Additional output structure array INFO containing possible additional information depending on METHOD):
INFO.AS INFO.KFI
all solutions controller, LTI two-port LFT full information gain matrix (constant feedback x(t) u (t) = K 2 FI u ( t ) 1
INFO.KFC
full control gain matrix (constant output-injection; KFC is the dual of KFI)
INFO.GAMFI INFO.GAMFC
H cost for full information KFI H cost for full control KFC
Algorithm
The default 'ric' method uses the two-riccati formulae ([4],[5]) with loopshifting [6]. In the case of the lmi method, hinfsyn employs the LMI technique ([7],[8],[9]). With 'METHOD' 'maxe', K returns the max entropy H controller that minimize an entropy integral relating to the point s0; i.e.,
2 s 02 2 Entropy = -----ln detI T y1 u1 ( j ) T y 1 u 1 ( j ) -------------------- d 2 s 2 + 2 0
where T y 1 u 1 is the closed-loop transfer function CL. With all methods, hinfsyn uses a standard -iteration technique to determine the optimal value of . Starting with high and low estimates of . The -iteration is a bisection algorithm that iterates on the value of in an effort to approach the optimal H control design. The stopping criterion for the bisection algorithm requires the relative difference between the last value that failed and the last value that passed be less than TOLGAM (default=.01)
10-120
hinfsyn
At each value of , the algorithm employed requires tests to determine whether a solution exists for a given value. In the case of the 'ric' method, the conditions checked for the existence of a solution are: H and J Hamiltonian matrices (which are formed from the state-space data of P and the level) must have no imaginary-axis eigenvalues. the stabilizing Riccati solutions X and Y associated with the Hamiltonian matrices must exist and be positive, semi-definite. spectral radius of (X,Y) must be less than or equal to 2. When, DISPLAY is 'on', the hinfsyn program displays several variables, which indicate which of the above conditions are satisfied for each value being tested. In the case of the default 'ric' method, the display includes the current value of being tested, real part of the eigenvalues of the X and Y Hamiltonian matrices along with the minimum eigenvalue of X and Y, which are the solutions to the X and Y Riccati equations, respectively. The maximum eigenvalue of XY, scaled by 2, is also displayed. A # sign is placed to the right of the condition that failed in the printout. A similar DISPLAY is produced with method 'lmi' The algorithm works best when the following conditions are satisfied by the plant: D12 and D21 have full rank. ( A jI B 2 C1 D 12 has full column rank for all R.
A jI B 1 has full row rank for all R. C 2 D 21
When the above rank conditions do not hold, the controller may have undesirable properties: If D12 and D21 are not full rank, the H controller K may have large high-frequency gain. If either of the latter two rank conditions does not hold at some frequency , the controller may have very lightly damped poles near that frequency .
10-121
hinfsyn
In general, the solution to the infinity-norm optimal control problem is non-unique. Whereas the K returned by hinfsyn is only a particular F(s), when the ric method is selected, the INFO.AS field of INFO give you in addition the all- solution controller parameterization KAS(s) such that all solutions to the infinity-norm control problem are parameterized by a free stable contraction map U(s) constrained by ( U ( s ) < 1 ) (see Figure 5-9); that is, every stabilizing controller K(s) that makes T y1 u1 = sup max ( T y1 u1 ( j ) ) <
K=lft(INFO.AS,U)
where U is a stable LTI system satisfying norm(U,Inf) <1.

u 1 y1 y2
u2
P(s)
KAS(s) K(s)
U(s) F(s) K(s)
Figure 10-10: All-solution KAS(s) returned by INFO.AS
An important use of the infinity-norm control theory is for direct shaping of closed-loop singular value Bode plots of control systems. In such cases, the system P(s) will typically be the plant augmented with suitable loop-shaping filters see and mixsyn.
10-122
hinfsyn
Examples
Following are three simple problems solved via hinfsyn. Example 1: A random 4-by-5 plant with 3-states, NMEAS=2, NCON=2
rand('seed',0);randn('seed',0); P=rss(3,4,5); [K,CL,GAM]=hinfsyn(P,2,2);
The optimal H cost in this case is GAM=0.2641. You verify that T y 1 u 1 = sup max ( T y 1 u 1 ( j ) ) <
sigma(CL,ss(GAM));
with a sigma plot
0.1 ( s + 1000 ) s1 Example 2: Mixed-Sensitivity G ( s ) = ----------- , W 1 = ----------------------------------- , W 2 = 0.1 , 100s + 1 s2 no W3.

s=zpk('s'); G=(s-1)/(s+1); W1=0.1*(s+100)/(100*s+1); W2=0.1; W3=[]; P=(G,W1,W2,W3); [K,CL,GAM]=hinfsyn(P); sigma(CL,ss(GAM));
In this case, GAM = 0.1854 = -14.6386 db Example 3: Mixed sensitivity with W1 removed.
s=zpk('s'); G=(s-1)/(s+1); W1=[]; W2=0.1; W3=[]; P=(G,W1,W2,W3) [K,CL,GAM]=hinfsyn(P)
In this case, GAM=0, K=0, and CL=K*(1+G*K)=0.
Limitation
The plant must be stabilizable from the control inputs u2 and detectable from the measurement output y2: (A,B2) must be stabilizable and (C2,A) must be detectable. Otherwise, an the hinfsyn returns an error.
10-123
hinfsyn
References
[4] Glover, K., and J.C. Doyle, State-space formulae for all stabilizing controllers that satisfy an Hnorm bound and relations to risk sensitivity, Systems and Control Letters, vol. 11, pp. 167172, 1988. [5] Doyle, J.C., K. Glover, P. Khargonekar, and B. Francis, State-space solutions to standard H2 and H control problems, IEEE Transactions on Automatic Control, vol. 34, no. 8, pp. 831847, August 1989 [6] .M. G. Safonov, D. J. N. Limebeer and R. Y. Chiang, Simplifying the H Theory via Loop Shifting, Matrix Pencil and Descriptor Concepts, Int. J. Contr., vol. 50, no. 6, pp. 2467-2488, 1989. [7] A. Packard, K. Zhou, P. Pandey, J. Leonhardson, and G. Balas, Optimal, constant I/O similarity scaling for full-information and state-feedback problems, Systems and Control Letters, 19:271280, 1992. [8] P. Gahinet and P. Apkarian, A linear matrix inequality approach to H1-control, Int J. Robust and Nonlinear Control, 4(4):421448, JulyAugust 1994. [9] T. Iwasaki and R. E. Skelton, All controllers for the general H -control problem: LMI existence conditions and state space formulas, Automatica, 30(8):13071317, August 1994.
See Also
augw h2syn loopsyn mktito ncfsyn
Augments plant weights for control design H2 synthesis controller H - loop shaping controller synthesis 2-input 2-output partition of a USS object H - normailized coprime controller synthesis
10-124
iconnect
10iconnect
Creates empty iconnect (interconnection) objects

H = iconnect
Interconnection objects (class iconnect) are an alternate to sysic, and are used to build complex interconnections of uncertain matrices and systems. An iconnect object has 3 fields to be set by the user, 'Input', 'Output' and 'Equation'. 'Input' and 'Output' are icsignal objects, while 'Equation'.is a cell-array of equality constraints (using equate) on icsignal objects. Once these are specified, then the 'System' property is the input/output model, implied by the constraints in 'Equation'. relating the variables defined in 'Input' and 'Output'.
Example
iconnect can be used to create the transfer matrix M as described in the
following figure.
Create three scalar icsignals, r, e and y. Create an empty iconnect object. Define the output of the interconnection to be [e; y], and the input to be r. Define two constraints among the variables: e = r-y, and y = (2/s) e. Get the transfer function representation of the relationship between the input (r) and the output [e; y].
r = icsignal(1); e = icsignal(1); y = icsignal(1); M = iconnect; M.Input = r; M.Output = [e;y]; M.Equation{1} = equate(e,r-y); M.Equation{2} = equate(y,tf(2,[1 0])*e); tf(M.System)
The transfer functions from input to outputs are
10-125
iconnect
#1:
s ----s + 2 2 ----s + 2
#2:
By not explicitly introducing e, this can be done more concisely with only one equality constraint.
r = icsignal(1); y = icsignal(1); N = iconnect; N.Input = r; N.Output = [r-y;y]; N.Equation{1} = equate(y,tf(2,[1 0])*(r-y)); tf(N.System)
You have created the same transfer functions from input to outputs.
#1: s ----s + 2 2 ----s + 2
#2:
You can also specify uncertain, multivariable interconnections using iconnect. Consider two uncertain motor/generator constraints among 4 variables [V;I;T;W], V-R*I-K*W=0, and T=K*I. Find the uncertain 2x2 matrix B so that [V;T] = B*[W;I].
R = ureal('R',1,'Percentage',[-10 40]); K = ureal('K',2e-3,'Percentage',[-30 30]); V = icsignal(1); I = icsignal(1); T = icsignal(1); W = icsignal(1); M = iconnect; M.Input = [W;I];
10-126
iconnect
M.Output = [V;T]; M.Equation{1} = equate(V-R*I-K*W,iczero(1)); M.Equation{2} = equate(T,K*I); B = M.System UMAT: 2 Rows, 2 Columns K: real, nominal = 0.002, variability = [-30 30]%, 2 occurrences R: real, nominal = 1, variability = [-10 40]%, 1 occurrence B.NominalValue ans = 0.0020 1.0000 0 0.0020
A simple system interconnection, identical to the system illustrated in the sysic reference pages. Consider a three-input, two-output SYSTEM matrix T,
y1 y2
noise deltemp setpoint
which has internal structure

y1 y2
57.3
g;
+ 6
g+
wt act
deltemp
6 + noise k
setpoint
P = rss(3,2,2); K = rss(1,1,2); A = rss(1,1,1); W = rss(1,1,1); M = iconnect; noise = icsignal(1);
10-127
iconnect
deltemp = icsignal(1); setpoint = icsignal(1); yp = icsignal(2); rad2deg = 57.3 rad2deg = 57.3000 M.Equation{1} = equate(yp,P*[W*deltemp;A*K*[noise+yp(2);setpoint]]); M.Input = [noise;deltemp;setpoint]; M.Output = [rad2deg*yp(1);setpoint-yp(2)]; T = M.System; size(T) State-space model with 2 outputs, 3 inputs, and 6 states.
Algorithm
Each equation represents an equality constraint among the variables. You choose the input and output variables, the imp2exp function makes the implicit relationship between them explicit. The syntax for iconnect objects and icsignal's is very flexible. Without care, you can build inefficient (i.e., non-minimal) representations where the state dimension of the interconnection is greater than the sum of the state dimensions of the components. This is in contrast to sysic. In sysic, the syntax used to specify inputs to systems (the input_to_ListedSubSystemName variable) forces you to include each subsystem of the interconnection only once in the equations. Hence, interconnections formed with sysic are componentwise minimal. That is, the state dimension of the interconnection equals the sum of the state dimensions of the components.
equate icsignal sysic
Limitations
See Also
Equates expressions for icsignal objects Constructs an icsignal object Constructs system interconnection
10-128
icsignal
10icsignal
Create an icsignal object.

v = icsignal(n); v = icsignal(n,'name'); icsignal creates an icsignal object, which is a symbolic column vector. The icsignal object is used with iconnect objects to specify signal constraints
described by the interconnection of components.

v = icsignal(n) creates an icsignal object of vector length n. The value of n must be a nonnegative integer. icsignal objects are symbolic column vectors, used in conjunction with iconnect (interconnection) objects to specify the
signal constraints described by an interconnection of components.

v = icsignal(n,name) creates an icsignal object of dimension n, with internal name identifier given by the character string argument 'name'.
See Also
iconnect sysic
Equates expressions for icsignal objects Constructs system interconnections
10-129
imp2exp
10imp2exp
Convert an implicit linear relationship to an explicit input-output relation

B = imp2exp(A,yidx,uidx) B = imp2exp(A,yidx,uidx) transforms a linear constraint between variables Y and U of the form A(:,[yidx;uidx])*[Y;U] = 0 into an explicit input/output relationship Y = B*U. The vectors yidx and uidx refer to the columns (inputs) of A as referenced by the explicit relationship for B.
The constraint matrix A may be a DOUBLE, SS, TF, ZPK and FRD objects as well as an uncertain object, including UMAT, USS and UFRD. The result B will be of the same class.
Example
Scalar Algebraic constraint Consider the constraint 4y + 7u = 0. Solving for y gives y = 1.75u. You form the equation using imp2exp A = [4 7]; Yidx = 1; Uidx = 2;
and then
B = imp2exp(A,Yidx,Uidx) B = -1.7500
yields B equal to -1.75.

Matrix algebraic constraint
Consider two motor/generator constraints among 4 variables [V;I;T;W], namely [1 -1 0 -2e-3;0 -2e-3 1 0]*[V;I;T;W] = 0. You can find the 2x2 matrix B so that [V;T] = B*[W;I] using imp2exp.
A = [1 -1 0 -2e-3;0 -2e-3 1 0]; Yidx = [1 3]; Uidx = [4 2]; B = imp2exp(A,Yidx,Uidx) B = 0.0020 1.0000 0 0.0020
10-130
imp2exp
You can find the 2x2 matrix C so that [I;W] = C*[T;V]

Yidx = [2 4]; Uidx = [3 1]; C = imp2exp(A,Yidx,Uidx) C = 500 0 -250000 500 Uncertain matrix algebraic constraint
Consider two uncertain motor/generator constraints among 4 variables [V;I;T;W], namely [1 -R 0 -K;0 -K 1 0]*[V;I;T;W] = 0. You can find the uncertain 2x2 matrix B so that [V;T] = B*[W;I].
R = ureal('R',1,'Percentage',[-10 40]); K = ureal('K',2e-3,'Percentage',[-30 30]); A = [1 -R 0 -K;0 -K 1 0]; Yidx = [1 3]; Uidx = [4 2]; B = imp2exp(A,Yidx,Uidx) UMAT: 2 Rows, 2 Columns K: real, nominal = 0.002, variability = [-30 30]%, 2 occurrences R: real, nominal = 1, variability = [-10 40]%, 1 occurrence Scalar dynamic system constraint
Consider a standard single-loop feedback connection of controller C and an uncertain plant P, described by the equations e=r-y, u=Ce; f=d+u; y=Pf.
P = tf([1],[1 0]); C = tf([2*.707*1 1^2],[1 0]); A = [1 -1 0 0 0 -1;0 -C 1 0 0 0;0 0 -1 -1 1 0;0 0 0 0 -P 1]; OutputIndex = [6;3;2;5]; % [y;u;e;f] InputIndex = [1;4]; % [r;d] Sys = imp2exp(A,OutputIndex,InputIndex);
10-131
imp2exp
Sys.InputName = {'r';'d'}; Sys.OutputName = {'y';'u';'e';'f'}; pole(Sys) ans = -0.7070 + 0.7072i -0.7070 - 0.7072i step(Sys)
From: r 2 1.5 To: y 1 0.5 0 0.5 2 1 To: u 0 1 Amplitude 2 1 0.5 To: e 0 0.5 1 2 1 To: f 0 1 2
Step Response
From: d
8 0 1 Time (sec)
Algorithm See Also
The number of rows of A must equal the length of yidx.

iconnect inv
Equates expressions for icsignal objects Forms the system inverse
10-132
imp2ss
Purpose Syntax
10imp2ss
System realization via Hankel singular value decomposition.

[a,b,c,d,totbnd,hsv] = imp2ss(y) [a,b,c,d,totbnd,hsv] = imp2ss(y,ts,nu,ny,tol) [ss,totbnd,hsv] = imp2ss(imp) [ss,totbnd,hsv] = imp2ss(imp,tol)
Description
The function imp2ss produces an approximate state-space realization of a given impulse response
imp=mksys(y,t,nu,ny,'imp');
using the Hankel SVD method proposed by S. Kung [2]. A continuous-time realization is computed via the inverse Tustin transform (using bilin) if t is positive; otherwise a discrete-time realization is returned. In the SISO case the variable y is the impulse response vector; in the MIMO case y is an N+1-column matrix containing N + 1 time samples of the matrix-valued impulse response H0, , HN of an nu-input, ny-output system stored row wise: y = [ H 0 ( : ) ;H 2 ( : ) ;H 3 ( : ) ; ;H N ( : ) ] The variable tol bounds the H norm of the error between the approximate realization (a, b, c, d) and an exact realization of y; the order, say n, of the realization (a, b, c, d) is determined by the infinity norm error bound specified by the input variable tol. The inputs ts, nu, ny, tol are optional; if not present they default to the values ts = 0, nu = 1, ny = (no. of rows of y)/nu, tol = 0.01 1. The output hsv = [ 1 , 2 , ] returns the singular values (arranged in descending order of magnitude) of the Hankel matrix: H1 H2 H3 HN = H2 H3 H4 0 H3 H4 H5 0 ... H N 0 0s ... ...
... ...
10-133
imp2ss
Denoting by GN a high-order exact realization of y, the low-order approximate model G enjoys the H norm bound G G N totbnd where
N
totbnd = 2
i = n+1
Algorithm
The realization (a, b, c, d) is computed using the Hankel SVD procedure proposed by Kung [2] as a method for approximately implementing the classical Hankel factorization realization algorithm. Kungs SVD realization procedure was subsequently shown to be equivalent to doing balanced truncation (balmr) on an exact state space realization of the finite impulse response {y(1),.y(N)} [3]. The infinity norm error bound for discrete balanced truncation was later derived by Al-Saggaf and Franklin [1]. The algorithm is as follows:
1 Form the Hankel matrix from the data y. 2 Perform SVD on the Hankel matrix
= UV = [ U 1 U 2 ]
1 0
V 1
0 2 V 2
= U 1 1 V 1
where 1 has dimension n n and the entries of 2 are nearly zero. U1 and V1 have ny and nu columns, respectively.
3 Partition the matrices U1 and V1 into three matrix blocks:
U 11 U 13
V 11 V 13
ny n
U 1 = U 12 ; V 12
where U 11 , U 13 C
and V 11 , V 13 C
nu n
10-134
imp2ss
4 A discrete state-space realization is computed as
A = 1 B = 1
1 2 1 2
U 1
12
V 11
1 2
C = U 11 1 D = H0 where U 11 U 12
U=
U 12 U 13
5 If the sampling time t is greater than zero, then the realization is converted
to continuous time via the inverse of the Tustin transform z1 s = 2 ----------- ; -tz+1 Otherwise, this step is omitted and the discrete-time realization calculated in Step 4 is returned.
References
[1] U. M. Al-Saggaf and G. F. Franklin, An Error Bound for a Discrete Reduced Order Model of a Linear Multivariable System, IEEE Trans. on Autom. Contr., AC-32, pp. 815-819, 1987. [2] S. Y. Kung, A New Identification and Model Reduction Algorithm via Singular Value Decompositions, Proc.Twelth Asilomar Conf. on Circuits, Systems and Computers., pp. 705-714, November 6-8, 1978. [3] L. M. Silverman and M. Bettayeb, Optimal Approximation of Linear Systems, Proc. American Control Conf., San Francisco, CA, 1980.
10-135
ispsys
Purpose Syntax Description See Also
10ispsys
True for parameter-dependent systems

bool = ispsys(sys) bool = ispsys(sys) returns 1 if sys is a polytopic or parameter-dependent
system.
psys psinfo
Specification of uncertain state-space models Inquire about polytopic or parameter-dependent systems created with psys
10-136
isuncertain
10isuncertain
Checks if argument is an uncertain class type

B = isuncertain(A)
Returns true if input argument is uncertain, false otherwise. Uncertain classes are umat, ufrd, uss, ureal, ultidyn, ucomplex, ucomplexm and udyn. In this example, you verify the correct operation of isuncertain on double, ureal, ss and uss objects.
isuncertain(rand(3,4)) ans = 0 isuncertain(ureal('p',4)) ans = 1 isuncertain(rss(4,3,2)) ans = 0 isuncertain(rss(4,3,2)*[ureal('p1',4) 6;0 1]) ans = 1
Example
Limitations
isuncertain only checks the class of the input argument, and does not actually verify that the input argument is truly uncertain. Create a umat by lifting a constant (i.e., not uncertain) matrix to the umat class. A = umat([2 3;4 5;6 7]);
Note that although A is in class umat, it is not actually uncertain. Nevertheless, based on class, the result of isuncertain(A) is true.
isuncertain(A) ans = 1
The result of simplify(A) is a double, and hence not uncertain.

isuncertain(simplify(A)) ans =
10-137
isuncertain
The number of rows of A must equal the length of yidx.
See Also
isvalid
Checks if uncertain object is an uncertain atom
10-138
lftdata
Purpose Syntax
10lftdata
Decompose uncertain objects into fixed normalized and fixed uncertain parts
[M,Delta] = lftdata(A); [M,Delta] = lftdata(A,List); [M,Delta,Blkstruct] = lftdata(A); [M,Delta,Blkstruct,Normunc] = lftdata(A); lftdata decomposes an uncertain object into a fixed certain part and a normalized uncertain part. lftdata can also partially decompose an uncertain
Description
object into an uncertain part, and a normalized uncertain part. Uncertain objects (umat, ufrd, uss) are represented as certain (i.e., not uncertain) objects in feedback with block-diagonal concatenations of uncertain elements.
[M,Delta] = lftdata(A) separates the uncertain object A into a certain object M, and a normalized uncertain matrix Delta, such that A is equal to lft(Delta,M) as shown below.
If A is a umat, then M will be double; if A is a uss, then M will be ss; if A is a ufrd, then M will be frd. In all cases, Delta is a umat.
[M,Delta] = lftdata(A,List) separates the uncertain object A into an uncertain object M, in feedback with a normalized uncertain matrix Delta. List is a cell array (or char) of names of uncertain elements of A that make up Delta. All other uncertainty in A remains in M. lftdata(A,fieldnames(A.Uncertainty)) is the same as lftdata(A). [M,DELTA,BLKSTRUCT] = LFTDATA(A) returns an N-by-1 structure array BLKSTRUCT, where BLKSTRUCT(i) describes the i-th normalized uncertain
element. This uncertainty description can be passed directly to the low-level structured singular value analysis function MUSSV.
[M,DELTA,BLKSTRUCT,NORMUNC] = LFTDATA(A) returns the cell array NORMUNC
of normalized uncertain elements. Each normalized element has the string
10-139
lftdata
'Normalized' appended to its original name to avoid confusion. Note that LFT(BLKDIAG(NORMUNC{:}),M) is equivalent to A.
Example
Create an uncertain matrix, A, with 3 uncertain parameters, p1, p2 and p3. You can decompose A into it certain, M, and normalized uncertain parts, Delta.
p1 = ureal('p1',-3,'perc',40); p2 = ucomplex('p2',2); A = [p1 p1+p2;1 p2]; [M,Delta] = lftdata(A);
You can inspect the difference between the original uncertain matrix, A, and the result formed by combining the two results from the decomposition.
simplify(A-lft(Delta,M)) ans = 0 0 0 0 M M = 0 0 1.0954 0 0 0 1.0954 1.0000 -3.0000 0 1.0000 1.0000
1.0954 1.0000 -1.0000 2.0000
You can check the worst-case norm of the uncertain part using wcnorm. Compare samples of the uncertain part A with the uncertain matrix A.
wcn = wcnorm(Delta) wcn = lbound: 1.0000 ubound: 1.0001 usample(Delta,5) ans(:,:,1) = 0.8012 0 ans(:,:,2) = 0.4919 0 ans(:,:,3) = -0.1040
0 0.2499 + 0.6946i 0 0.2863 + 0.6033i 0
10-140
lftdata
0 ans(:,:,4) = 0.8296 0 ans(:,:,5) = 0.6886 0 Uncertain Systems
0.7322 - 0.3752i 0 0.6831 + 0.1124i 0 0.0838 + 0.3562i
Create an uncertain matrix, A, with 2 uncertain real parameters, v1 and v2 and create an uncertain system G using A as the dynamic matrix, and simple matrices for the input and output.
A = [ureal('p1',-3,'perc',40) 1;1 ureal('p2',-2)]; sys = ss(A,[1;0],[0 1],0); sys.InputGroup.ActualIn = 1; sys.OutputGroup.ActualOut = 1;
You can decompose G into it a certain system, Msys, and a normalized uncertain matrix, Delta. You can see from Msys that it is certain, and the input and output groups have been adjusted.
[Msys,Delta] = lftdata(sys); Msys a = x1 x2 x1 -3 1 x2 1 -2
b = x1 x2 u1 1.095 0 u2 0 1 u3 1 0
c = y1 y2 x1 1.095 0 x2 0 1
10-141
lftdata
y3
d = y1 y2 y3 u1 0 0 0 u2 0 0 0 u3 0 0 0
Input groups: Name ActualIn p1_NC p2_NC Output groups: Name ActualOut p1_NC p2_NC
Channels 3 1 2
Channels 3 1 2
Continuous-time model.
You can compute the norm on samples of the difference between the original uncertain matrix and the result formed by combining Msys and Delta.
norm(usample(sys-lft(Delta,Msys),'p1',4,'p2',3),'inf') ans = 0 0 0 0 0 0 0 0 0 0 0 0 Partial decomposition
Create an uncertain matrix, A, and derive an uncertain matrix B using an implicit-to-explicit conversion, imp2exp. Note that B has 2 uncertain parameters, R and K. You can decompose B into it certain, M, and normalized uncertain parts, Delta.
R = ureal('R',1,'Percentage',[-10 40]); K = ureal('K',2e-3,'Percentage',[-30 30]);
10-142
lftdata
A = [1 -R 0 -K;0 -K 1 0]; Yidx = [1 3]; Uidx = [4 2]; B = imp2exp(A,Yidx,Uidx); [M,Delta] = lftdata(B);
The same operation can be performed by defining the uncertain parameters, K and R, to be extracted.
[MK,DeltaR] = lftdata(B,'R'); MK UMAT: 3 Rows, 3 Columns K: real, nominal = 0.002, variability = [-30 30]%, 2 occurrences [MR,DeltaK] = lftdata(B,'K'); MR UMAT: 4 Rows, 4 Columns R: real, nominal = 1, variability = [-10 40]%, 1 occurrence simplify(B-lft(Delta,M)) ans = 0 0 0 0 simplify(B-lft(DeltaR,MK)) ans = 0 0 0 0 simplify(B-lft(DeltaK,MR)) ans = 0 0 0 0
Sample and inspect the uncertain part as well as the difference between the original uncertain matrix. You can see the result formed by combining the two results from the decomposition.
[Mall,Deltaall] = lftdata(B,{'K';'R'}); simplify(Mall)-M ans = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10-143
lftdata
0 0
0 0
0 0
0 0
0 0
See Also
lft ssdata
Forms Redheffer star product of systems Returns uncertain state-space data
10-144
lmiedit
10lmiedit
Specify or display systems of LMIs as MATLAB expressions

lmiedit lmiedit is a graphical user interface for the symbolic specification of LMI problems. Typing lmiedit calls up a window with two editable text areas and
various buttons. To specify an LMI system,

1 Give it a name (top of the window). 2 Declare each matrix variable (name and structure) in the upper half of the
window. The structure is characterized by its type (S for symmetric block diagonal, R for unstructured, and G for other structures) and by an additional structure matrix similar to the second input argument of lmivar. Please use one line per matrix variable in the text editing areas.
3 Specify the LMIs as MATLAB expressions in the lower half of the window.
An LMI can stretch over several lines. However, do not specify more than one LMI per line. Once the LMI system is fully specified, you can perform the following operations by pressing the corresponding button: Visualize the sequence of lmivar/lmiterm commands needed to describe this LMI system (view commands buttons) Conversely, display the symbolic expression of the LMI system produced by a particular sequence of lmivar/lmiterm commands (click the describe... buttons) Save the symbolic description of the LMI system as a MATLAB string (save button). This description can be reloaded later on by pressing the load button Read a sequence of lmivar/lmiterm commands from a file (read button). The matrix expression of the LMI system specified by these commands is then displayed by clicking on describe the LMIs... Write in a file the sequence of lmivar/lmiterm commands needed to specify a particular LMI system (write button) Generate the internal representation of the LMI system by pressing create. The result is written in a MATLAB variable with the same name as the LMI system
10-145
lmiedit
Remark
Editable text areas have built-in scrolling capabilities. To activate the scroll mode, click in the text area, maintain the mouse button down, and move the mouse up or down. The scroll mode is only active when all visible lines have been used.
lmivar lmiterm newlmi lmiinfo
See Also
Specify the matrix variables in an LMI problem Specify the term content of LMIs Attach an identifying tag to LMIs Interactively retrieve information about the variables and term content of LMIs
10-146
lmiinfo
10lmiinfo
Interactively retrieve information about the variables and term content of LMIs
lmiinfo(lmisys) lmiinfo provides qualitative information about the system of LMIs lmisys.
This includes the type and structure of the matrix variables, the number of diagonal blocks in the inner factors, and the term content of each block.
lmiinfo is an interactive facility where the user seeks specific pieces of
information. General LMIs are displayed as

N' * L(x) * N < M' * R(x) * M
where N,M denote the outer factors and L,R the left and right inner factors. If the outer factors are missing, the LMI is simply written as
L(x) < R(x)
If its right-hand side is zero, it is displayed as

N' * L(x) * N < 0
Information on the block structure and term content of L(x) and R(x) is also available. The term content of a block is symbolically displayed as
C1 + A1*X2*B1 + B1'*X2*A1' + a2*X1 + x3*Q1
with the following conventions: X1, X2, x3 denote the problem variables. Upper-case X indicates matrix variables while lower-case x indicates scalar variables. The labels 1,2,3 refer to the first, second, and third matrix variable in the order of declaration. Cj refers to constant terms. Special cases are I and I (I = identity matrix). Aj, Bj denote the left and right coefficients of variable terms. Lower-case letters such as a2 indicate a scalar coefficient. Qj is used exclusively with scalar variables as in x3*Q1. The index j in Aj, Bj, Cj, Qj is a dummy label. Hence C1 may appear in several blocks or several LMIs without implying any connection between the corresponding constant terms. Exceptions to this rule are the notations
10-147
lmiinfo
A1*X2*A1' and A1*X2*B1 + B1'*X2'*A1' which indicate symmetric terms and
symmetric pairs in diagonal blocks.
Example
Consider the LMI T T T 0 2X + A YB + B Y A + I XC T C X zI where the matrix variables are X of Type 1, Y of Type 2, and z scalar. If this LMI is described in lmis, information about X and the LMI block structure can be obtained as follows:
lmiinfo(lmis) LMI ORACLE -----This is a system of 1 LMI with 3 variable matrices Do you want information on (v) matrix variables (l) LMIs (q) quit ?> v Which variable matrix (enter its index k between 1 and 3) ? 1 X1 is a 2x2 symmetric block diagonal matrix its (1,1)-block is a full block of size 2 ------This is a system of 1 LMI with 3 variable matrices Do you want information on (v) matrix variables (l) LMIs (q) quit ?> l Which LMI (enter its number k between 1 and 1) ? 1 This LMI is of the form
10-148
lmiinfo
0 < R(x) where the inner factor(s) has 2 diagonal block(s)
Do you want info on the right inner factor ? (w) whole factor (b) only one block (o) other LMI (t) back to top level ?> w Info about the right inner factor block (1,1) : I + a1*X1 + A2*X2*B2 + B2'*X2'*A2' block (2,1) : A3*X1 block (2,2) : x3*A4 (w) whole factor (b) only one block (o) other LMI (t) back to top level -----This is a system of 1 LMI with 3 variable matrices Do you want information on (v) matrix variables (l) LMIs (q) quit ?> q It has been a pleasure serving you!
Note that the prompt symbol is ?> and that answers are either indices or letters. All blocks can be displayed at once with option (w), or you can prompt for specific blocks with option (b).
Remark
lmiinfo does not provide access to the numerical value of LMI coefficients.
10-149
lmiinfo
See Also
decinfo lminbr matnbr decnbr
Describe how the entries of a matrix variable X relate to the decision variables Return the number of LMIs in an LMI system Return the number of matrix variables in a system of LMIs Give the total number of decision variables in a system of LMIs
10-150
lminbr
10lminbr
Return the number of LMIs in an LMI system

k = lminbr(lmisys) lminbr returns the number k of linear matrix inequalities in the LMI problem described in lmisys. lmiinfo matnbr
Interactively retrieve information about the variables and term content of LMIs Return the number of matrix variables in a system of LMIs
10-151
lmireg
10lmireg
Specify LMI regions for pole placement purposes

region = lmireg region = lmireg(reg1,reg2,...) lmireg is an interactive facility to specify the LMI regions involved in multi-objective H synthesis with pole placement constraints (see msfsyn).
Recall that an LMI region is any convex subset D of the complex plane that can be characterized by an LMI in z and z , i.e., D = {z C : L + Mz + MT z < 0} for some fixed real matrices M and L = LT. This class of regions encompasses half planes, strips, conic sectors, disks, ellipses, and any intersection of the above. Calling lmireg without argument starts an interactive query/answer session where you can specify the region of your choice. The matrix region = [L, M] is returned upon termination. This matrix description of the LMI region can be passed directly to msfsyn for synthesis purposes. The function lmireg can also be used to intersect previously defined LMI regions reg1, reg2,.... The output region is then the [L, M] description of the intersection of these regions.
See Also
msfsyn
Multi-model/multi-objective state-feedback synthesis
10-152
lmiterm
10lmiterm
Specify the term content of LMIs

lmiterm(termID,A,B,flag) lmiterm specifies the term content of an LMI one term at a time. Recall that
LMI term refers to the elementary additive terms involved in the block-matrix expression of the LMI. Before using lmiterm, the LMI description must be initialized with setlmis and the matrix variables must be declared with lmivar. Each lmiterm command adds one extra term to the LMI system currently described. LMI terms are one of the following entities: outer factors constant terms (fixed matrices) variable terms AXB or AXTB where X is a matrix variable and A and B are given matrices called the term coefficients. When describing an LMI with several blocks, remember to specify only the terms in the blocks on or below the diagonal (or equivalently, only the terms in blocks on or above the diagonal). For instance, specify the blocks (1,1), (2,1), and (2,2) in a two-block LMI. In the calling of limterm, termID is a four-entry vector of integers specifying the term location and the matrix variable involved.
termID (1) =
+p -p
where positive p is for terms on the left-hand side of the p-th LMI and negative p i s for terms on the right-hand side of the p-th LMI. Recall that, by convention, the left-hand side always refers to the smaller side of the LMI. The index p is relative to the order of declaration and corresponds to the identifier returned by newlmi. [ 0, 0 ] for outer factors termID (2:3) = [ i, j ] for terms in the ( i, j )-th block of the left or right inner factor
10-153
lmiterm
0 for outer factors termID (4) = x for variable terms AXB T x for variable terms AX B where x is the identifier of the matrix variable X as returned by lmivar. The arguments A and B contain the numerical data and are set according to:
Type of Term A B
outer factor N constant term C variable term AXB or AXTB
matrix value of N matrix value of C matrix value of A (1 if A is absent)
omit omit matrix value of B (1 if B is absent)
Note that identity outer factors and zero constant terms need not be specified. The extra argument flag is optional and concerns only conjugated expressions of the form (AXB) + (AXB)T = AXB + BTX(T)AT in diagonal blocks. Setting flag = 's' allows you to specify such expressions with a single lmiterm command. For instance,
lmiterm([1 1 1 X],A,1,'s')
adds the symmetrized expression AX + XTAT to the (1,1) block of the first LMI and summarizes the two commands
lmiterm([1 1 1 X],A,1) lmiterm([1 1 1 X],1,A')
Aside from being convenient, this shortcut also results in a more efficient representation of the LMI.
10-154
lmiterm
Example
Consider the LMI T T T 2AX 2 A x 3 E + DD B X 1 T X1 B I T T T T CX 1 C + CX 1 C 0 <M 0 f X2 M
where X1, X2 are matrix variables of Types 2 and 1, respectively, and x3 is a scalar variable (Type 1). After initializing the LMI description with setlmis and declaring the matrix variables with lmivar, the terms on the left-hand side of this LMI are specified by:
lmiterm([1 1 lmiterm([1 1 lmiterm([1 1 lmiterm([1 2 lmiterm([1 2 Here X1, X2, X3 1 1 1 1 2 X2],2*A,A') % 2*A*X2*A' x3],-1,E) % -x3*E 0],D*D') % D*D' -X1],1,B) % X1'*B 0],-1) % -I
should be the variable identifiers returned by lmivar.
Similarly, the term content of the right-hand side is specified by:

lmiterm([-1 0 0 0],M) % outer factor M lmiterm([-1 1 1 X1],C,C','s') % C*X1*C'+C*X1'*C' lmiterm([-1 2 2 X2],-f,1) % -f*X2
Note that CX1CT + C X 1 CT is specified by a single lmiterm command with the flag 's' to ensure proper symmetrization.
See Also
setlmis lmivar getlmis lmiedit newlmi
Initialize the description of an LMI system Specify the matrix variables in an LMI problem Get the internal description of an LMI system Specify or display systems of LMIs as MATLAB expressions Attach an identifying tag to LMIs
10-155
lmivar
10lmivar
Specify the matrix variables in an LMI problem

X = lmivar(type,struct) [X,n,sX] = lmivar(type,struct) lmivar defines a new matrix variable X in the LMI system currently described. The optional output X is an identifier that can be used for subsequent reference to this new variable.
The first argument type selects among available types of variables and the second argument struct gives further information on the structure of X depending on its type. Available variable types include: type=1: Symmetric matrices with a block-diagonal structure. Each diagonal block is either full (arbitrary symmetric matrix), scalar (a multiple of the identity matrix), or identically zero. If X has R diagonal blocks, struct is an R-by-2 matrix where struct(r,1) is the size of the r-th block struct(r,2) is the type of the r-th block (1 for full, 0 for scalar, 1 for zero block). type=2: Full m-by-n rectangular matrix. Set struct = [m,n] in this case. type=3: Other structures. With Type 3, each entry of X is specified as zero or xn where xn is the n-th decision variable. Accordingly, struct is a matrix of the same dimensions as X such that struct(i,j)=0 if X(i, j) is a hard zero struct(i,j)=n if X(i, j) = xn struct(i,j)= n if X(i, j) = xn Sophisticated matrix variable structures can be defined with Type 3. To specify a variable X of Type 3, first identify how many free independent entries are involved in X. These constitute the set of decision variables associated with X. If the problem already involves n decision variables, label the new free variables as xn+1, . . ., xn+p. The structure of X is then defined in terms of xn+1, . . ., xn+p as indicated above. To help specify matrix variables of Type 3, lmivar optionally returns two extra outputs: (1) the total number n of scalar
10-156
lmivar
decision variables used so far and (2) a matrix sX showing the entry-wise dependence of X on the decision variables x1, . . ., xn.
Example 1
Consider an LMI system with three matrix variables X1, X2, X3 such that X1 is a 3 3 symmetric matrix (unstructured), X2 is a 2 4 rectangular matrix (unstructured), X3 = 0 0 0 1 0 0 0 2 I2
where is an arbitrary 5 5 symmetric matrix, 1 and 2 are scalars, and I2 denotes the identity matrix of size 2. These three variables are defined by
setlmis([]) X1 = lmivar(1,[3 1]) % Type 1 X2 = lmivar(2,[2 4]) % Type 2 of dim. 2x4 X3 = lmivar(1,[5 1;1 0;2 0]) % Type 1
The last command defines X3 as a variable of Type 1 with one full block of size 5 and two scalar blocks of sizes 1 and 2, respectively.
Example 2
Combined with the extra outputs n and sX of lmivar, Type 3 allows you to specify fairly complex matrix variable structures. For instance, consider a matrix variable X with structure X 0 X = 1 0 X 2
where X1 and X2 are 2-by-3 and 3-by-2 rectangular matrices, respectively. You can specify this structure as follows:
1 Define the rectangular variables X1 and X2 by
setlmis([]) [X1,n,sX1] = lmivar(2,[2 3])
10-157
lmivar
[X2,n,sX2] = lmivar(2,[3 2])
The outputs sX1 and sX2 give the decision variable content of X1 and X2:
sX1 sX1 = 1 4 sX2 sX2 = 7 9 11
2 5
3 6
8 10 12
For instance, sX2(1,1)=7 means that the (1,1) entry of X2 is the seventh decision variable.
2 Use Type 3 to specify the matrix variable X and define its structure in terms
of those of X1 and X2:

[X,n,sX] = lmivar(3,[sX1,zeros(2);zeros(3),sX2])
The resulting variable X has the prescribed structure as confirmed by

sX sX = 1 4 0 0 0
2 5 0 0 0
3 6 0 0 0
0 0 0 0 7 8 9 10 11 12
See Also
setlmis lmiterm getlmis lmiedit skewdec delmvar
Initialize the description of an LMI system Specify the term content of LMIs Get the internal description of an LMI system Specify or display systems of LMIs as MATLAB expressions Form a skew-symmetric matrix Delete one of the matrix variables of an LMI problem
10-158
lmivar
setmvar
Instantiate a matrix variable and evaluate all LMI terms involving this matrix variable
10-159
frd/loglog
10frd/loglog
Log-log scale plot of frd objects.

loglog(sys) loglog(sys,linetype) loglog is the same as plot except a logarithmic (base 10) scale is used for both the X- and Y-axis.
The argument list consists of (many) X-data, Y-data and line type. triples. The X-data and Y-data can be specified individually, as doubles, or jointly as an frd.
Example
Generate three frequency response objects, sys1g, sys2g and sys3g. Plot the magnitude of these transfer functions versus frequency on an log-log plot.
omega = logspace(-2,2,40); sys1 = tf(0.9,[.1 1]); sys1g = frd(sys1,omega); sys2 = tf(0.9,[1 1]); sys2g = frd(sys2,omega); sys3 = tf(0.9,[10 1]); sys3g = frd(sys3,omega); loglog(abs(sys1g),abs(sys2g),'r+',sys3g.Freq,...
10-160
frd/loglog
abs(sys3g.Resp(:)),'--');
10
10
10
10
10
10
10
10
10
10
See Also
plot semilogx semilogy
Plots on linear axis Plots semi-log scale plot Plots semi-log scale plot
10-161
loopmargin
10loopmargin
Comprehensive analysis of feedback loops

[sm,dm,mm] = loopmargin(L) [smi,dmi,mmi,smo,dmo,mmo,mmio] = loopmargin(P,C) [sm,dm,mm] = loopmargin(L) analyzes the multivariable feedback loop consisting of the loop transfer matrix L (size N-by-N) in negative feedback with an N-by-N identity matrix. sm, or single-loop margin, is an N-by-1 structure corresponding to
loop-at-a-time gain and phase margins for each channel.

dm is an N-by-1 structure corresponding to loop-at-a-time disk gain and phase margins for each channel. The disk margin for the i-th feedback channel defines a circular region centered on the negative real axis at the average GainMargin (GM), e.g. (GMlow+GMhigh)/2, such that L(i,i) does not enter that region. Gain and phase disk margin bounds are derived from the radius of the circle, calculated based on the balanced sensitivity function (see Algorithm). mm, or multi-loop disk margin, is a structure corresponding to simultaneous, independent, variations in the individual channels of loop transfer matrix L. mm
calculates the largest region such that for all gain and phase variations, occurring independently in each channel, which lie inside the region the closed-loop system is stable. Note that mm is a single structure, independent of the number of channels, since variations in all channels are handled simultaneously. As in the case for disk margin, the guaranteed bounds are calculated based on a balanced sensitivity function. If L is an ufrd or uss object, then the nominal value, L.NominalValue, of L is used in the loop analysis. The wcmargin command can be used to analyze single-loop margins in the presence of the worst-case uncertainty. The disk margin and multi-loop disk margin calculations are performed in the frequency domain. If L is a ss/tf/zpk/uss object, the frequency range and number of points used to calculate dm and mm margins are chosen automatically (see bode command).
[smi,dmi,mmi,smo,dmo,mmo,mmio] = loopmargin(p,c) analyzes the multivariable feedback loop consisting of the controller, C, in negative feedback with the plant, P. C should only be the compensator in the feedback path, without reference channels, if it is a 2-dof architecture. That is, if the
10-162
loopmargin
closed-loop system has a 2-dof architecture the reference channel of the controller should be eliminated resulting in a 1-dof architecture as shown in the figure below.

smi,dmi and mmi structures correspond to the loop-at-a-time gain and phase
margins, disk margins and multi-loop channel margins at the plant input respectively. The structures smo, dmo and mmo have the same fields as described for smi, dmi and mmi though they correspond to the plant outputs. mmio, or multi-input/multi-output margins, is a structure corresponding to simultaneous, independent, variations in all the individual input and output channels of the feedback loops. mmio has the same fields as mmi and mmo. The nominal values of P and C are used in the analysis if P and/or C are uncertain system or frequency response objects. If the closed-loop system is a ss/tf/zpk/uss, the frequency range and number of points used to calculate sm, dm and mm margins are chosen automatically.
Basic syntax
[sm,dm,mm] = loopmargin(L) sm is calculated using the allmargin command and has the same fields as allmargin. The sm is a structure with the following
fields:
Field GMFrequency GainMargin Description
All -180 deg crossover frequencies (in rad/s) Corresponding gain margins (g.m. = 1/G where G is the gain at crossover) Corresponding phase margins (in degrees) All 0 dB crossover frequencies (in rad/s)
PhaseMargin PMFrequency
10-163
loopmargin
Field DelayMargin
Description
Delay margins (in seconds for continuous-time systems, and multiples of the sample time for discrete-time systems) 1 if nominal closed loop is stable, 0 otherwise. If L is a frd or ufrd object, the Stable flag is set to NaN.
Stable
dm, or Disk Margin, is a structure with the following fields Field GainMargin Description
Smallest gain variation (GM) such that a disk centered at the point -(GM(1) + GM(2))/2 would just touch the loop transfer function. Smallest phase variation, in degrees, corresponding to the disk described in the GainMargin field (degrees). Associated with GainMargin/PhaseMargin fields (rad/s).
PhaseMargin
Frequency
mm is a structure with the following fields: Field GainMargin Description
Guaranteed bound on simultaneous, independent, gain variations allowed in all plant channel(s). Guaranteed bound on simultaneous, independent, phase variations allowed in all plant channel(s) (degrees). Associated with GainMargin/PhaseMargin fields (rad/s).
PhaseMargin
Frequency
Example
MIMO Loop-at-a-Time Margins
10-164
loopmargin
This example is designed to illustrate that loop-at-a-time margins (gain, phase, and/or distance to 1) can be inaccurate measures of multivariable robustness margins. We will see that margins of the individual loops may be very sensitive to small perturbations within other loops. The nominal closed-loop system considered here is shown as follows
;6 d K ;6
G and K are 2 2 multi-input/multi-output (MIMO) systems, defined as

2 1 ( s + 1 ) ,K=I G: = ----------------- s 2 2 2 s + ( s + 1 ) s 2
Set := 10, construct G in state-space form and compute its frequency response.
a = [0 10;-10 0]; b = eye(2); c = [1 8;-10 1]; d = zeros(2,2); G = ss(a,b,c,d); K = [1 -2;0 1]; [smi,dmi,mmi,smo,dmo,mmo,mmio]=loopmargin(G,K);
First consider the margins at the input to the plant. The first input channel has infinite gain margin and 90 degrees of phase margin based on the results from the allmargin command, smi(1). The disk margin analysis, dmi, of the first channel provide similar results.
smi(1) ans = GMFrequency: [1x0 double] GainMargin: [1x0 double] PMFrequency: 21
10-165
loopmargin
PhaseMargin: DMFrequency: DelayMargin: Stable: dmi(1) ans = GainMargin: PhaseMargin: Frequency:
90 21 0.0748 1
[0 Inf] [-90 90] 1.1168
The second input channel has a gain margin of 2.105 and infinite phase margin based on the single-loop analysis, smi(2). The disk margin analysis, dmi(2), which allows for simultaneous gain and phase variations a loop-at-a-time results in maximum gain margin variations of 0.475 and 2.105 and phase margin variations of +/- 39.18 degs.
smi(2) ans = GMFrequency: GainMargin: PMFrequency: PhaseMargin: DMFrequency: DelayMargin: Stable: dmi(2) ans = GainMargin: PhaseMargin: Frequency:
0 2.1053 [1x0 double] [1x0 double] [1x0 double] [1x0 double] 1
[0.4749 2.1056] [-39.1912 39.1912] 0.0200
The multiple margin analysis of the plant inputs corresponds to allowing simultaneous, independent gain and phase margin variations in each channel. Allowing independent variation of the input channels further reduces the tolerance of the closed-loop system to variations at the input to the plant. The multivariable margin analysis, mmi, leads to a maximum allowable gain margin variation of 0.728 and 1.373 and phase margin variations of +/- 17.87 degs. Hence even though the first channel had infinite gain margin and 90 degrees of phase margin, allowing variation in both input channels leads to a factor of two reduction in the gain and phase margin.
10-166
loopmargin
mmi mmi = GainMargin: [0.7283 1.3730] PhaseMargin: [-17.8659 17.8659] Frequency: 9.5238e-004
The guaranteed region of phase and gain variations for the closed-loop system can be illustrated graphically. The disk margin analysis, dmi(2), indicates the closed-loop system will remain stable for simultaneous gain variations of 0.475 and 2.105 ( 6.465 dB) and phase margin variations of 39.18 degs in the second input channel. This is denoted by the region associated with the large ellipse in the following figure. The multivariable margin analysis at the input to the plant, mmi, indicates that the closed-loop system will be stable for independent, simultaneous, gain margin variation up to 0.728 and 1.373 (2.753 dB) and phase margin variations up to 17.87 degs (the dark ellipse region) in both input channels.
Gain and Phase Margin Guaranteed Disk Margin: Input 2 Guaranteed Multivariable Input Margin
10
5 Gain Variation (dB)
10
40
30
20
10 0 10 Phase Variation (degrees)
20
30
40
The output channels have single loop margins of infinite gain and 90 degs phase variation. The output multivariable margin analysis, mmo, leads to a maximum allowable gain margin variation of 0.607 and 1.649 and phase
10-167
loopmargin
margin variations of +/- 27.53 degs. Hence even though both output channels had infinite gain margin and 90 degrees of phase margin, simultaneous variations in both channels significantly reduces the margins at the plant outputs.
mmo mmo = GainMargin: [0.6065 1.6489] PhaseMargin: [-27.5293 27.5293] Frequency: 0.2287
If all the input and output channels are allow to vary independently, mmio, the gain margin variation of 0.827 and 1.210 and phase margin variations of +/10.84 degs.
mmio mmio = GainMargin: [0.8267 1.2097] PhaseMargin: [-10.8402 10.8402] Frequency: 0.2287
Algorithm
Two well known loop robustness measures are based on the sensitivity function, S=(IL)1 and the complementary sensitivity function, T=L(IL)1 where L is the loop gain matrix associated with the input or output loops broken simultaneously. In the following figure, S is the transfer matrix from summing junction input u to summing junction output e. T is the transfer matrix from u to y. If signals e and y are summed, the transfer matrix from u to e+y is given by (I+L)(IL)1, the balanced sensitivity function. It can be shown (Dailey 1991, Blight, Daily and Gangass 1994) that each broken-loop gain may be perturbed by the complex gain (1+)(1) where ||<1/(S+T) or ||<1/max(S+T) at each frequency without causing instability at that frequency. The peak value of (S+T) or max(S+T) gives a robustness guarantee
10-168
loopmargin
for all frequencies and for (S+T), the guarantee is non-conservative (Blight, Daily and Gangass 1994).
10-169
loopmargin
This figure shows a comparison of a disk margin analysis with the classical notations of gain and phase margins.
Disk gain margin (DGM) and disk phase margin (DPM) in the Nyquist plot 1 0.8 0.6 Disk Margin 0.4 Imaginary Axis 0.2 0 0.2 0.4 0.6 0.8 Unit Disk Disk Margin Critical point
DGM
GM
DPM
PM
1 1.5 1 0.5 Real Axis 0 0.5 1
10-170
loopmargin
The Nyquist plot is of the loop transfer function L(s) s ----- + 1 30 L ( s ) = ---------------------------------------------------------( s + 1 ) ( s 2 + 1.6s + 16 ) The Nyquist plot of L corresponds to the blue line The unit disk corresponds to the dotted red line GM and PM indicate the location of the classical gain and phase margins for the system L. DGM and DPM correspond to the disk gain and phase margins. The disk margins provide a lower bound on classical gain and phase margins. The disk margin circle corresponds to the dashed black line. The disk margin corresponds to the largest disk centered at (GMD + 1/GMD)/2 that just touches the loop transfer function L. This location is indicated by the red dot. The disk margin and multiple channel margins calculation involve the balanced sensitivity function S+T. For a given peak value of (S+T), any simultaneous phase and gain variations applied to each loop independently will not destabilize the system if the perturbations remain inside the corresponding circle or disk. This corresponds to the disk margin calculation to find dmi and dmo. Similarly, the multiple channel margins calculation involves the balanced sensitivity function S+T. Instead of calculating (S+T) a single loop at a time, all the channels are included in the analysis. A - analysis problem is formulated with each channel perturbed by an independent, complex perturbation. The peak (S+T) value guarantees that any simultaneous, independent phase and gain variations applied to each loop simultaneously will not destabilize the system if they remain inside the corresponding circle or disk of size (S+T).
See Also
allmargin bode loopsens mussv robuststab wcgain wcsens
Finds all stability margins and crossover frequencies Plots Bode frequency response of LTI models Calculates sensitivity functions of feedback loop Calculate bounds on the Structured Singular Value () Calculate stability margins of uncertain systems Calculates worst-case gain of a system Calculate worst-case sensitivities for feedback loop
10-171
loopmargin
wcmargin
Reference
Barrett, M.F. (1980), Conservatism with robustness tests for linear feedback control systems, Ph.D. Thesis, Control Science and Dynamical Systems, University of Minnesota. Blight, J.D., Dailey, R.L. and Gangsass, D. (1994), Practical control law design for aircraft using multivariable techniques, International Journal of Control, Vol. 59, No. 1, 93-137. Bates, D. and I. Postlethwaite (2002), Robust Multivariable Control of Aerospace Systems, Delft University Press, Delft, The Netherlands, ISBN: 90-407-2317-6.
10-172
loopsens
10loopsens
Sensitivity functions of plant-controller feedback loop

loops = loopsens(P,C)
loops = loopsens(P,C) creates a Struct, loops, whose fields contain the multivariable sensitivity, complementary and open-loop transfer functions. The closed-loop system consists of the controller, C, in negative feedback with the plant, P. C should only be the compensator in the feedback path, not any reference channels, if it is a 2-dof controller as seen in the figure below. The plant and compensator, P and C, can be constant matrices, double, lti objects, frd/ss/tf/zpk, or uncertain objects, umat/ufrd/uss.

The loops structure contains the following fields:

Field Poles Stable Description
Closed-loop poles. NaN for frd/ufrd objects. 1 if nominal closed loop is stable, 0 otherwise. NaN for
frd/ufrd objects.
Si Ti Li So To Lo PSi CSo
Input-to-plant sensitivity function Input-to-plant complementary sensitivity function Input-to-plant loop transfer function Output-to-plant sensitivity function Output-to-plant complementary sensitivity function Output-to-plant loop transfer function Plant times input-to-plant sensitivity function Compensator times output-to-plant sensitivity function
10-173
loopsens
The multivariable closed-loop interconnection structure, shown below, defines the input/output sensitivity, complementary sensitivity and loop transfer functions.
Description
Equation
Input Sensitivity ( TF e1 d1 ) Input Complementary Sensitivity ( TF e2 d1 ) Output Sensitivity ( TF e3 d2 ) Output Complementary Sensitivity ( TF e4 d2 ) Input Loop Transfer Function Output Loop Transfer Function
(I+CP)1 CP(I+CP)1 (I+PC)1 PC(I+PC)1 CP PC
Example
Consider a three-input and four-output plant with three integrators. One of the integrators, uncint, is uncertain. A four input, three output constant gain controller, c, is used to stabilize the closed-loop system. The gain of the controller (1,4) entry is uncertain, ranging between 0.02 and 1.5. You can use the loopsens command to construct the closed-loop system sensitivity, complementary sensitivity and loop transfer functions.
int = tf(1,[1 0]); addunc = ultidyn('addunc',[1 1],'Bound',0.2); uncint = int + addunc; int3 = blkdiag(int,uncint,int); p = [1 .2 .5;-.5 0 1;1 0 0;0 1 0]*int3;
10-174
loopsens
gain = ureal('gain',0.9, 'Range',[-3 1.5]); c = [.02 .3 0 0;1 -.3 .32 gain; 0 1 -.2 .1]; loops = loopsens(p,c) loops = Poles: [3x1 double] Stable: 1 Si: [3x3 uss] Ti: [3x3 uss] Li: [3x3 uss] So: [4x4 uss] To: [4x4 uss] Lo: [4x4 uss] PSi: [4x3 uss] CSo: [3x4 uss]
Note that the input sensitivity, complementary sensitivity and loop transfer functions have three inputs and three outputs, whereas the output sensitivity, complementary sensitivity and loop transfer functions have four inputs and four outputs. For the nominal plant model, i.e. the additive uncertainty addunc set to zero, the closed-loop system is stable only for positive values of the gain parameter.
gainval = reshape([-0.22 -0.215 -0.20 1.5],[1 1 4]); nomSi = usubs(loops.Si,'gain',gainval); pole(nomSi.NominalValue) ans(:,:,1) = -0.8537 0.0018 + 0.2164i 0.0018 - 0.2164i ans(:,:,2) = -0.8541 -0.0004 + 0.2176i -0.0004 - 0.2176i ans(:,:,3) = -0.8556 -0.0072 + 0.2207i -0.0072 - 0.2207i ans(:,:,4) = -0.1663 -0.6505
10-175
loopsens
-1.7533
See Also
loopmargin robuststab wcsens wcmargin
Performs a comprehensive analysis of feedback loop Calculate stability margins of uncertain systems Calculate worst-case sensitivities for feedback loop Calculate worst-case margins for feedback loop
10-176
loopsyn
10loopsyn
Compute a controller for plant G to optimally match target loop shape Gd

[K,CL,GAM,INFO]=loopsyn(G,Gd) [K,CL,GAM,INFO]=loopsyn(G,Gd,RANGE) loopsyn is an H optimal method for loopshaping control synthesis. It computes a stabilizing Hcontroller K for plant G to shape the sigma plot of the loop transfer function GK to have desired loop shape Gd with accuracy =GAM in the sense that if 0 is the 0db crossover frequency of the sigma plot of Gd(j), then, roughly,
1 ( G ( j )K ( j ) ) -- ( G d ( j ) ) 1 ( G ( j )K ( j ) ) -- ( G d ( j ) )
for all < 0 for all > 0
(10-16)
(10-17)
The STRUCT array INFO returns additional design information, including a MIMO stable min-phase shaping pre-filter W, the shaped plant Gs = GW, the controller for the shaped plant Ks=WK, as well as the frequency range {min,max} over which the loop shaping is achieved..) Input arguments:
G Gd RANGE
LTI Plant Desired loop-shape (LTI Model) (optional, default {0,Inf}) Desired frequency range for loop-shaping, a 1-by-2 cell array {min,max}; max should be at least ten times min
Output arguments:
K CL= G*K/(I+GK)
LTI controller LTI closed-loop system
10-177
loopsyn
GAM
loop-shaping accuracy (GAM 1, with GAM=1 being perfect fit additional output information LTI pre-filter W satisfying (Gd)=(GW) for all ; W is always minimum-phase LTI shaped plant: Gs = GW LTI controller for the shaped plant: Ks=WK {min,max} cell-array containing the approximate frequency range over which loop-shaping could be accurately achieved to with accuracy G. The output INFO.range is either the same as or a subset of the input range
INFO
INFO.W
INFO.Gs INFO.Ks INFO.range
Algorithm
Using the GCD formula of Le and Safonov [1], loopsyn first computes a stable-minimum-phase loop-shaping, squaring-down prefilter W such that the shaped plant Gs = GW is square, and the desired shape Gd is achieved with good accuracy in the frequency range {min,max} by the shaped plant; i.e., (Gd) (Gs) for all {min,max}. Then, loopsyn uses the Glover-McFarlane [2] normalized-coprime-factor control synthesis theory to compute an optimal loop-shaping controller for the shaped plant via Ks=ncfsyn(Gs), and returns K=W*Ks. If the plant G is a continuous time LTI and
1 G has a full-rank D-matrix, and 2 no finite zeros on the j-axis, and 3
{min,max}=[0,],
then GW theoretically achieves a perfect accuracy fit (Gd) = (GW) for all frequency . Otherwise, loopsyn uses a bilinear pole-shifting bilinear transform [3] of the form
Gshifted=bilin(G,-1,'S_Tust',[min,max]),
10-178
loopsyn
which results in a perfect fit for transformed Gshifted and an approximate fit over the smaller frequency range [min,max] for the original unshifted G provided that max >> min. For best results, you should choose max to be at least 100 times greater than min. In some cases, the computation of the optimal W for Gshifted may be singular or ill-conditioned for the range [min,max], as when Gshifted has undamped zeros or, in the continuous-time case only, Gshifted has a D-matrix that is rank-deficient); in such cases, loopsyn automatically reduces the frequency range further, and returns the reduced range [min,max] as a cell array in the output INFO.range={min,max}
Example
The following code generates the optimal loopsyn loopshaping control for the case of a 5-state, 4-output, 5-input plant with a full-rank non-minimum phase zero at s=+10. The result in shown in Figure 10-11.
rand('seed',0);randn('seed',0); s=tf('s'); w0=5; Gd=5/s; % desired bandwith w0=5 G=((s-10)/(s+100))*rss(3,4,5); % 4-by-5 non-min-phase plant [K,CL,GAM,INFO]=loopsyn(G,Gd); sigma(G*K,'r',Gd*GAM,'k-.',Gd/GAM,'k-.',{.1,100}) % plot result
This figure shows that the LOOPSYN controller K optimally fits

sigma(G*K) = sigma(Gd)GAM % dB
In the above example, GAM = 2.0423 = 6.2026 dB.
10-179
loopsyn
Figure 10-11: LOOPSYN controller
The loopsyn controller K optimally fits sigma(G*K). As shown in Figure 10-11, it is sandwiched between sigma(Gd/GAM) and sigma(Gd*GAM) in accordance with the inequalities in Equation 10-16 and Equation 10-17. In the this example, GAM = 2.0423 = 6.2026 db.
Limitations
The plant G must be stabilizable and detectable, must have at least as many outputs and inputs, and must be full rank; i.e, size(G,2) size(G,1) rank(freqresp(G,w)) = size(G,1) for some frequency w. The order of the controller K can be large. Generically, when Gd is given as a SISO LTI, then the order NK of the controller K satisfies NK = NGs + NW = NyNGd + NRHP + NW = NyNGd + NRHP + NG
10-180
loopsyn
where Ny denotes the number of outputs of the plant G, NRHP denotes the total number of non-stable poles and non-minimum-phase zeros of the plant G, including those on the stability boundary and at infinity, and NG, NGs, NGd and NW denote the respective orders of G, Gs, Gd and W. Model reduction can help reduce the order of K see reduce and ncfmr.
References
[1] Le, V. X., and M. G. Safonov. Rational matrix GCDs and the design of squaring-down compensatorsa state space theory. IEEE Trans. Autom.Control, AC-36(3):384392, March 1992. [2] Glover, K., and D. McFarlane. Robust stabilization of normalized coprime factor plant descriptions with H-bounded uncertainty. IEEE Trans. Autom. Control, AC-34(8):821830, August 1992. [3] Chiang, R. Y., and M. G. Safonov. H synthesis using a bilinear pole-shifting transform. AIAA J. Guidance, Control and Dynamics, 15(5):1111 1115, SeptemberOctober 1992.
See Also
loopsyn_demo mixsyn ncfsyn
A demo of this function H mixed-sensitivity controller synthesis H - normailized coprime controller synthesis
Algorithm
Using a real eigen structure decomposition reig and ordering the eigenvectors in ascending order according to their eigenvalue magnitudes, we can form a similarity transformation out of these ordered real eigenvectors such that he resulting systems G1 and/or G2 are in block diagonal modal form.
Note This routine is extremely useful when model has j-axis singularities, e.g., rigid body dynamics. If we apply the Hankel based model reduction routines directly such as hankelmr, balancmr, bstmr, or schurmr to the original model, the reduction routines can failed due to unsolvable grammians. However, if we apply modreal to the model first, isolate the rigid body dynamics part from the rest, apply the Hankel based model routines to
10-181
loopsyn
the non-rigid part, then add back the rigid dynamics, we can do a very successful model reduction task this way.
Example
Given a continuous stable or unstable system, G, the following commands can get a set of modal form realizations depending on the split index -- cut:
randn('state',1234); rand('state',5678); G = rss(50,2,2); [G1,G2] = modreal(G,2); % cut = 2 for two rigid body modes G2.d = G1.d; G1.d = zeros(2,2); % assign the DC gain to G2 sigma(G1,G2)
See Also
reduce balancmr schurmr bstmr ncfmr hankelmr hankelsv
Top level model reduction routines Balanced truncation via square-root method Balanced truncation via Schur method Balanced stochastic truncation via Schur method Balanced truncation for normalized coprime factors Hankel minimum degree approximation Hankel singular value
10-182
ltrsyn
Purpose Syntax
10ltrsyn
LQG loop transfer-function recovery (LTR) control synthesis

[K,SVL,W1] [K,SVL,W1] [K,SVL,W1] [K,SVL,W1] = = = = ltrsyn(G,F,XI,THETA,RHO) ltrsyn(G,F,XI,THETA,RHO,W) ltrsyn(G,F,XI,THETA,RHO,OPT) ltrsyn(G,F,XI,THETA,RHO,W,OPT)
Description
[K,SVL,W1] = ltrsyn(G,F,XI,TH,RHO) computes a reconstructed-state output-feedback controller K for LTI plant G so that K*G asymptotically recovers plant-input full-state feedback loop transfer function L(s) = F(Is-A)-1B+D; that is, at any frequency w>0, max(sigma(K*G-L, w)) 0 as , where L= ss(A,B,F,D) is the LTI full-state feedback loop transfer
function.
[K,SVL,W1] = ltrsyn(G,F1,Q,R,RHO,'OUTPUT') computes the solution to the dual problem of filter loop recovery for LTI plant G where F is a Kalman
filter gain matrix. In this case, the recovery is at the plant output, and
max(sigma(G*K-L, w)) 0 as , where L1 denotes the LTI filter loop feedback loop transfer function L1= ss(A,F,C,D).
Only the LTI controller K for the final value RHO(end)is returned. Inputs
G F XI
LTI plant LQ full-state-feedback gain matrix plant noise intensity, or, if OPT='OUTPUT' state-cost matrix XI=Q,
THETA
sensor noise intensity or, if OPT='OUTPUT' control-cost matrix THETA=R,
RHO W
vector containing a set of recovery gains (optional) vector of frequencies (to be used for plots); if input W is not supplied, then a reasonable default is used
10-183
ltrsyn
Outputs
K
K(s) LTI LTR (loop-transfer-recovery) output-feedback, for the last element of RHO (i.e., RHO(end)) sigma plot data for the recovered loop transfer function if G is MIMO or, for SISO G only, Nyquist loci SVL = [re(1:nr)
im(1:nr)]
SVL
W1
frequencies for SVL plots, same as W when present
Algorithm
For each value in the vector RHO, [K,SVL,W1] = ltrsyn(G,F,XI,THETA,RHO) computes the full-state-feedback (default OPT='INPUT') LTR controller K ( s ) = [ K c ( Is A + B K c + K f C K f DK c ) K f ] where Kc=F and Kf=lqr(A',C',XI+RHO(i)*B*B',THETA). The fictitious noise term RHO(i)*B*B' results in loop-transfer recovery as RHO(i) . The Kalman filter gain is K f = C
T T T 1 1
where satisfies the Kalman filter Riccati

T
equation 0 = A + A C C + + BB . See [1] for further details. Similarly for the dual problem of filter loop recovery case, [K,SVL,W1] = ltrsyn(G,F,Q,R,RHO,'OUTPUT') computes a filter loop recovery controller of
10-184
ltrsyn
the same form, but with Kf=F is being the input filter gain matrix and the control gain matrix Kc computed as Kc=lqr(A,B,Q+RHO(i)*C'*C,R).
LQG/LTR @ PLANT OUTPUT 50
-50
SV (DB)
-100 - & -- : Kalman Filter Gain .. & .-: q = 1 - & -- : q = 1e5 .. & .-: q = 1e10 - & -- : q = 1e15
-150
-200
-250
-300 10 -4
10 -3
10 -2
10 -1
10 0 Rad/Sec
10 1
10 2
10 3
10 4
Figure 10-12: Example of LQG/LTR at Plant Output.
Example
s=tf('s');G=ss(1e4/((s+1)*(s+10)*(s+100)));[A,B,C,D]=ssdata(G); F=lqr(A,B,C'*C,eye(size(B,2))); L=ss(A,B,F,0*F*B); XI=100*C'*C; THETA=eye(size(C,1)); RHO=[1e3,1e6,1e9,1e12];W=logspace(-2,2); nyquist(L,'k-.');hold; [K,SVL,W1]=ltrsyn(G,F,XI,THETA,RHO,W);
See also ltrdemo
Limitations
The ltrsyn procedure may fail for non-minimum phase plants. For full-state LTR (default OPT='INPUT'), the plant should not have fewer outputs than inputs. Conversely for filter LTR (when OPT='OUTPUT'), the plant should not have fewer inputs than outputs. The plant must be strictly proper, i.e., the D-matrix of the plant should be all zeros. ltrsyn is only for continuous time plants (Ts==0) [1] J. Doyle and G. Stein Multivariable Feedback Design: Concepts for a Classical/Modern Synthesis, IEEE Trans. on Automat. Contr., AC-26, pp. 4-16, 1981.
References
10-185
ltrsyn
See Also
h2syn hinfsyn lqg loopsyn ltrdemo ncfsyn
H2 controller synthesis H controller synthesis

Continuous linear-quadratic-Gaussian control synthesis H - loop shaping controller synthesis Demo of LQG/LTR optimal control synthesis H - normalized coprime controller synthesis
10-186
matnbr
10matnbr
Return the number of matrix variables in a system of LMIs

K = matnbr(lmisys) matnbr returns the number K of matrix variables in the LMI problem described by lmisys. decnbr lmiinfo decinfo
Give the total number of decision variables in a system of LMIs Interactively retrieve information about the variables and term content of LMIs Describe how the entries of a matrix variable X relate to the decision variables
10-187
mat2dec
10mat2dec
Return the vector of decision variables corresponding to particular values of the matrix variables
decvec = mat2dec(lmisys,X1,X2,X3,...)
Given an LMI system lmisys with matrix variables X1, . . ., XK and given values X1,...,Xk of X1, . . ., XK, mat2dec returns the corresponding value decvec of the vector of decision variables. Recall that the decision variables are the independent entries of the matrices X1, . . ., XK and constitute the free scalar variables in the LMI problem. This function is useful, for example, to initialize the LMI solvers mincx or gevp. Given an initial guess for X1, . . ., XK, mat2dec forms the corresponding vector of decision variables xinit. An error occurs if the dimensions and structure of X1,...,Xk are inconsistent with the description of X1, . . ., XK in lmisys.
Example
Consider an LMI system with two matrix variables X and Y such that X is A symmetric block diagonal with one 2-by-2 full block and one 2-by-2 scalar block Y is a 2-by-3 rectangular matrix Particular instances of X and Y are X0 = 1 3 0 0 3 1 0 0 0 0 5 0 0 0 0 5 , Y0 = 1 2 3 4 5 6
and the corresponding vector of decision variables is given by

decv = mat2dec(lmisys,X0,Y0) decv' ans = 1 3 -1 5 1 2 3 4 5 6
10-188
mat2dec
Note that decv is of length 10 since Y has 6 free entries while X has 4 independent entries due to its structure. Use decinfo to obtain more information about the decision variable distribution in X and Y.
See Also
dec2mat decinfo decnbr
Given values of the decision variables, derive the corresponding values of the matrix variables Describe how the entries of a matrix variable X relate to the decision variables Give the total number of decision variables in a system of LMIs
10-189
mincx
10mincx
Minimize a linear objective under LMI constraints

[copt,xopt] = mincx(lmisys,c,options,xinit,target)
The function mincx solves the convex program minimize c x subject to

T
N L ( x ) N MT R ( x )M
(10-18)
where x denotes the vector of scalar decision variables. The system of LMIs (9-18) is described by lmisys. The vector c must be of the same length as x. This length corresponds to the number of decision variables returned by the function decnbr. For linear objectives expressed in terms of the matrix variables, the adequate c vector is easily derived with defcx. The function mincx returns the global minimum copt for the objective cTx, as well as the minimizing value xopt of the vector of decision variables. The corresponding values of the matrix variables is derived from xopt with dec2mat. The remaining arguments are optional. The vector xinit is an initial guess of the minimizer xopt. It is ignored when infeasible, but may speed up computations otherwise. Note that xinit should be of the same length as c. As for target, it sets some target for the objective value. The code terminates as soon as this target is achieved, that is, as soon as some feasible x such that cTx target is found. Set options to [] to use xinit and target with the default options.
Control Parameters
The optional argument options gives access to certain control parameters of the optimization code. In mincx, this is a five-entry vector organized as follows: options(1) sets the desired relative accuracy on the optimal value lopt (default = 102). options(2) sets the maximum number of iterations allowed to be performed by the optimization procedure (100 by default). options(3) sets the feasibility radius. Its purpose and usage are as for feasp.
10-190
mincx
options(4) helps speed up termination. If set to an integer value J > 0, the code terminates when the objective cTx has not decreased by more than the desired relative accuracy during the last J iterations. options(5) = 1 turns off the trace of execution of the optimization procedure. Resetting options(5) to zero (default value) turns it back on. Setting option(i) to zero is equivalent to setting the corresponding control parameter to its default value. See feasp for more detail.
Tip for Speed-Up
In LMI optimization, the computational overhead per iteration mostly comes from solving a least-squares problem of the form min Ax b
x
where x is the vector of decision variables. Two methods are used to solve this problem: Cholesky factorization of ATA (default), and QR factorization of A when the normal equation becomes ill conditioned (when close to the solution typically). The message
* switching to QR
is displayed when the solver has to switch to the QR mode. Since QR factorization is incrementally more expensive in most problems, it is sometimes desirable to prevent switching to QR. This is done by setting options(4) = 1. While not guaranteed to produce the optimal value, this generally achieves a good trade-off between speed and accuracy.
Memory Problems
QR-based linear algebra (see above) is not only expensive in terms of computational overhead, but also in terms of memory requirement. As a result, the amount of memory required by QR may exceed your swap space for large problems with numerous LMI constraints. In such case, MATLAB issues the error
??? Error using ==> pds Out of memory. Type HELP MEMORY for your options.
You should then ask your system manager to increase your swap space or, if no additional swap space is available, set options(4) = 1. This will prevent
10-191
mincx
switching to QR and mincx will terminate when Cholesky fails due to numerical instabilities.
Reference
The solver mincx implements Nesterov and Nemirovskis Projective Method as described in Nesterov, Yu, and A. Nemirovski, Interior Point Polynomial Methods in Convex Programming: Theory and Applications, SIAM, Philadelphia, 1994. Nemirovski, A., and P. Gahinet, The Projective Method for Solving Linear Matrix Inequalities, Proc. Amer. Contr. Conf., 1994, Baltimore, Maryland, pp. 840844. The optimization is performed by the C-MEX file pds.mex.
See Also
defcx dec2mat decnbr feasp gevp
Help specify cTx objectives for the mincx solver Given values of the decision variables, derive the corresponding values of the matrix variables Give the total number of decision variables in a system of LMIs Find a solution to a given system of LMIs Generalized eigenvalue minimization under LMI constraints
10-192
mixsyn
Purpose Syntax
10mixsyn
H mixed-sensitivity synthesis method for robust control loopshaping design

[K,CL,GAM,INFO]=mixsyn(G,W1,W2,W3) [K,CL,GAM,INFO]=mixsyn(G,W1,W2,W3,KEY1,VALUE1,KEY2,VALUE2,...)
Description
[K,CL,GAM,INFO]=mixsyn(G,W1,W2,W3) computes a controller K that minimizes the H norm of the closed-loop transfer function the weighted mixed sensitivity
W 1S
Ty u = W2 R 1 1 W3 T where S and T are called the sensitivity and complementary sensitivity, respectively and S, R and T are given by S = ( I + GK )
1 1 1
R = K ( I + GK )
T = GK ( I + GK )
AUGMENTED PLANT P(s) y
W1 W2 + u 1 u 2 e u G y W3
y 2
CONTROLLER F(s) K(s)
Figure 10-13: Closed-loop transfer function T y u for mixed sensitivity 1 1 mixsyn.
10-193
mixsyn
The returned values of S, R, and T satisfy the following loop shaping inequalities: ( S ( j ) ) ( W 1 ( j ) ) ( R ( j ) ) ( W 2 ( j ) ) ( T ( j ) ) ( W 3 ( j ) ) where =GAM. Thus, W1, W3 determine the shapes of sensitivity S and complementary sensitivity T. Typically, you would choose W1 to be small inside the desired control bandwidth to achieve good disturbance attenuation (i.e., performance), and choose W3 to be small outside the control bandwidth, which helps to ensure good stability margin (i.e., robustness). For dimensional compatibility, each of the three weights W1, W2 and W3 must be either empty, scalar (SISO) or have respective input dimensions NY, NU, and NY where G is NY-by-NU. If one of the weights is not needed, you may simply assign an empty matrix []; e.g., P = AUGW(G,W1,[],W3) is SYS but without the second row (without the row containing W2).
1 1 1
Algorithm
[K,CL,GAM,INFO]=mixsyn(G,W1,W2,W3,KEY1,VALUE1,KEY2,VALUE2,...)
is equivalent to
[K,CL,GAM,INFO]=... hinfsyn((G,W1,W2,W3),KEY1,VALUE1,KEY2,VALUE2,...). mixsyn accepts all the same key value pairs as hinfsyn.
Example
The following code illustrates the use of mixsyn for sensitivity and complementary sensitivity loop-shaping.
s=zpk('s'); G=(s-1)/(s+1)^2; W1=0.1*(s+100)/(100*s+1); W2=0.1; [K,CL,GAM]=mixsyn(G,W1,W2,[]); L=G*K; S=inv(1+L); T=1-S; sigma(S,'g',T,'r',GAM/W1,'g-.',GAM*G/ss(W2),'r-.')
10-194
mixsyn
Figure 10-14: mixsyn(G,W1,W2,[ ]) shapes sigma plots of S and T to conform to /W1 and G/W2, respectively.
Limitations
The transfer functions G, W1, W2 and W3 must be proper, i.e., bounded as s or, in the discrete-time case, as z . Additionally, W1, W2 and W3 should be stable. The plant G should be stabilizable and detectable; else, P will not be stabilizable by any K.
augw hinfsyn
See Also
Augments plant weights for control design H controller synthesis
10-195
mkfilter
10mkfilter
Generate a Bessel, Butterworth, Chebyshev or RC filter

sys = mkfilter(fc,ord,type) sys = mkfilter(fc,ord,type,psbndr) sys = mkfilter(fc,ord,type) returns a single-input, single-output analog low-pass filter, sys as an ss object. The cutoff frequency (Hertz) is fc and the filter order is ord, a positive integer. The string variable, type, specifies the type of filter and can be one of the following type, String variable 'butterw' 'cheby' 'bessel' 'rc' Description
Butterworth filter Chebyshev filter Bessel filter Series of resistor/capacitor filters
The dc gain of each filter (except even order Chebyshev) is set to unity.
sys = mkfilter(fc,ord,type,psbndr) contains the input argument psbndr
that specifies the Chebyshev passband ripple (in dB). At the cutoff frequency, the magnitude is -psbndr dB. For even order Chebyshev filters the DC gain is also -psbndr dB.
Example
butw = mkfilter(2,4,'butterw'); cheb = mkfilter(4,4,'cheby',0.5); rc = mkfilter(1,4,'rc'); bode(butw_g,'-',cheb_g,'--',rc_g,'-.')
10-196
mkfilter
megend('Butterworth','Chebyshev','RC filter')
Butterworth, RC & Chebyshev Filters
Log Magnitude
10
10
10
10
10 Frequency (radians/sec)
10
0 Phase (degrees) 100 200 300 10

1
10
10 Frequency (radians/sec)
10
Limitations See Also
The Bessel filters are calculated using the recursive polynomial formula. This is poorly conditioned for high order filters (order > 8).
augw
Augments plant weights for control design
10-197
mktito
10mktito
Make a TITO (two-input-two-output) system out of a MIMO LTI system

SYS=mktito(SYS,NMEAS,NCONT) SYS=mktito(SYS,NMEAS,NCONT) tadds TITO (two-input-two-output) partitioning to LTI system SYS, assigning OutputGroup and InputGroup properties such that NMEAS = dim ( y 2 ) NCONT = dim ( u 2 )
y1 P y2
SYS
u1 u2
Any pre-existing OutputGroup or InputGroup properties of SYS are overwritten. TITO partitioning simplifies syntax for control synthesis functions like hinfsyn and h2syn.
Algorithm
[r,c]=size(SYS); set(SYS,'InputGroup', struct('U1',1:c-NCONT,'U2',c-NCONT+1:c)); set(SYS,'OutputGroup',struct('Y1',1:r-NMEAS,'Y2',r-NMEAS+1:r));
Example
You can type

P=rss(2,4,5); P=mktito(P,2,2); disp(P.OutputGroup); disp(P.InputGroup);
to create a 4-by-5 LTI system P with OutputGroup and InputGroup properties

U1: [1 2 3] U2: [4 5] Y1: [1 2] Y2: [3 4]
See also
augw hinfsyn
Augments plant weights for control design H synthesis controller
10-198
mktito
h2syn ltiprops sdhinfsyn
H2 synthesis controller Help on LTI model properties H discrete-time controller
10-199
modreal
10modreal
Modal form realization and projection

[G1,G2] = modreal(G,cut) [G1,G2] = modreal(G,cut) returns a set of state-space LTI objects G1 and G2 in modal form given a state-space G and the model size of G1, cut.
The modal form realization has its A matrix in block diagonal form with either 1x1 or 2x2 blocks. The real eigenvalues will be put in 1x1 blocks and complex eigenvalues will be put in 2x2 blocks. These diagonal blocks are ordered in ascending order based on eigenvalue magnitudes. The complex eigenvalue a+bj is appearing as 2x2 block a b b a This table describes input arguments for modreal.
Argument G cut Description
LTI model to be reduced. (Optional) an integer to split the realization. Without it, a complete modal form realization is returned
This table lists output arguments.

Argument G1,G2 Description
LTI models in modal form
G can be stable or unstable. G 1 = ( A 1, B 1, C 1, D 1 ) , G 2 = ( A 2, B 2, C 2, D 2 ) and D 1 = D + C 2 ( A 2 ) 1 B 2 is calculated such that the system DC gain is preserved.
Algorithm
Using a real eigen structure decomposition reig and ordering the eigenvectors in ascending order according to their eigenvalue magnitudes, we can form a
10-200
modreal
similarity transformation out of these ordered real eigenvectors such that he resulting systems G1 and/or G2 are in block diagonal modal form.
Note This routine is extremely useful when model has j-axis singularities, e.g., rigid body dynamics. It has been incorporated inside Hankel based model reduction routines - hankelmr, balancmr, bstmr, and schurmr to isolate those j-axis poles from the actual model reduction process.
Example
Given a continuous stable or unstable system, G, the following commands can get a set of modal form realizations depending on the split index -- cut:
randn('state',1234); rand('state',5678); G = rss(50,2,2); [G1,G2] = modreal(G,2); % cut = 2 for two rigid body modes G1.d = zeros(2,2); % remove the DC gain of the system from G1 sigma(G,G1,G2)
See Also
reduce balancmr schurmr bstmr ncfmr hankelmr hankelsv
Top level model reduction routines Balanced truncation via square-root method Balanced truncation via Schur method Balanced stochastic truncation via Schur method Balanced truncation for normalized coprime factors Hankel minimum degree approximation Hankel singular value
10-201
msfsyn
10msfsyn
Multi-model/multi-objective state-feedback synthesis

[gopt,h2opt,K,Pcl,X] = msfsyn(P,r,obj,region,tol)
Given an LTI plant P with state-space equations x = Ax + B 1 w + B 2 u C 1 x + D 11 w + D 12 u C 2 x + D 22 u
z = z2 =
msfsyn computes a state-feedback control u = Kx that
Maintains the RMS gain (H norm) of the closed-loop transfer function T from w to z below some prescribed value 0 > 0 Maintains the H2 norm of the closed-loop transfer function T2 from w to z2 below some prescribed value 0 > 0 Minimizes an H2/H trade-off criterion of the form T + T2 2 Places the closed-loop poles inside the LMI region specified by region (see lmireg for the specification of such regions). The default is the open left-half plane. Set r = size(d22) and obj = [0, 0, , ] to specify the problem dimensions and the design parameters 0, 0, , and . You can perform pure pole placement by setting obj = [0 0 0 0]. Note also that z or z2 can be empty. On output, gopt and h2opt are the guaranteed H and H2 performances, K is the optimal state-feedback gain, Pcl the closed-loop transfer function from w to , and X the corresponding Lyapunov matrix.
z2 z
2 2
The function msfsyn is also applicable to multi-model problems where P is a polytopic model of the plant:
10-202
msfsyn
A ( t )x + B 1 ( t )w + B 2 ( t )u C 1 ( t )x + D 11 ( t )w + D 12 ( t )u C 2 ( t )x + D 22 ( t )u
z = z2 =
with time-varying state-space matrices ranging in the polytope A(t) B (t) B (t) A k B k B 2k 1 2 C ( t ) D ( t ) D ( t ) Co C D 1k 11k D 12k 11 12 1 C (t) 0 D 22 ( t ) C 2k 0 D 22k 2 : k = 1, , K
In this context, msfsyn seeks a state-feedback gain that robustly enforces the specifications over the entire polytope of plants. Note that polytopic plants should be defined with psys and that the closed-loop system Pcl is itself polytopic in such problems. Affine parameter-dependent plants are also accepted and automatically converted to polytopic models.
See Also
lmireg psys
Specify LMI regions for pole placement purposes Specification of uncertain state-space models
10-203
mussv
Purpose Syntax
10mussv
Compute upper and lower bounds on the Structured Singular Value () and upper bounds on Generalized structured singular value
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') 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
Description
of the ith perturbation block. If BlockStructure(i,:) = [-r 0], then the i-th block is a r-by-r repeated, diagonal real scalar perturbation; if BlockStructure(i,:) = [r 0], then the i-th block is a r-by-r repeated, diagonal complex scalar perturbation; if BlockStructure(i,:) = [r c], then the i-th block is a 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 2-dimensional matrix, then bounds is a 1x2 array containing an upper (1st column) and lower (2nd column) bound of 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.
10-204
mussv
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 rcd1dF. Then size(bounds) is 12d1dF. 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 d1d2dF (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 'a' 'an' 'd' 'f' 'i' Meaning
Upper bound to greatest accuracy, using LMI solver Same as 'a', but without automatic-prescaling Display warnings Fast upper bound (typically not as tight as the default) Initialize lower bound computation using previous matrix (only relevant if M is ND array or FRD) Randomly initialize lower bound iteration multiple times (in this case 7 times, use 1-9), larger number typically gives better lower bound. Suppress progress information (silent) Decrease iterations in lower bound computation (faster but not as tight as default)
'm7'
's' 'x'
[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.
10-205
mussv
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 will be 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,'C')<=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 1, an uncertain
real parameter 2, an uncertain complex parameter 3 and a twice repeated uncertain complex parameter 4.
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); points completed (of 1) ... 1 bounds = mussv(M,BlockStructure); optbounds = mussv(M+Q*F,BlockStructure,'C5');
The quantities optbounds(1) and ubound should be extremely close, and significantly lower than bounds(1) and bounds(2).
10-206
mussv
[optbounds(1) ubound] ans = 1.5917 1.5925 [bounds(1) bounds(2)] ans = 3.8184 3.7135
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 Osbornes 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 which 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, etal, 1991).
10-207
mussv
Reference
Boyd, S. and L. El Ghaoui, Methods of centers for minimizing generalized eigenvalues, Linear Algebra and Its Applications, vol. 188189, pp. 63111, 1993. Fan, M. A. Tits, and J. Doyle, Robustness in the presence of mixed parametric uncertainty and unmodeled dynamics, IEEE Transactions on Automatic Control, vol. AC36, pp. 2538, 1991. Osborne, E. On preconditioning of matrices, Journal of Associated Computer Machines, vol. 7, pp. 338345, 1960. 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, pp. 21322137, December 1988. Safonov, M. Stability margins for diagonally perturbed multivariable feedback systems, IEEE Proc., vol. 129, Part D, pp. 251256, 1982. Young, P. and J. Doyle, Computation of with real and complex uncertainties, Proceedings of the 29th IEEE Conference on Decision and Control, pp. 12301235, 1990. Young, P., M. Newlin, and J. Doyle, Practical computation of the mixed problem, Proceedings of the American Control Conference, pp. 21902194, June, 1992.
See Also
loopmargin mussvextract robuststab robustperf wcgain wcsens wcmargin
Comprehensive analysis of feedback loop Extract compressed data returned from mussv Calculate stability margins of uncertain systems Calculate performance margins of uncertain systems Calculate worst-case gain of a system Calculate worst-case sensitivities for feedback loop Calculate worst-case margins for feedback loop
10-208
mussvextract
10mussvextract
Extracts the muinfo structure returned by mussv

[VDelta,VSigma,VLmi] = mussvextract(muinfo)
A structured singular value computation of the form

[bounds,muinfo] = mussv(M,BlockStructure)
returns detailed information in the structure muinfo. mussvextract is used to extract the compressed information within muinfo into a readable form. The most general call to mussvextract extracts three usable quantities: VDelta, VSigma, and VLmi. VDelta is used to verify the lower bound. VSigma is used to verify the Newlin/Young upper bound and has fields DLeft, DRight, GLeft, GMiddle, and GRight. VLmi is used to verify the LMI upper bound and has fields Dr, Dc, Grc, and Gcr. The relation/interpretation of these quantities with the numerical results in bounds is described below.
Upper Bound Information

The upper bound is based on a proof that det(I - M*Delta) is nonzero for all block-structured matrices Delta with norm smaller than 1/bounds(1). The Newlin/Young method consists of finding a scalar and matrices D and G, consistent with BlockStructure, such that
- - 2 4 Dr 2 4 (I + G l ) --------- jG m (I + G r ) 1 1 1 1
Since some uncertainty blocks and M need not be square, the matrices D and G have a few different manifestations. In fact, in the formula above, there is a left and right D and G, as well as a middle G. Any such is an upper bound of mussv(M,BlockStructure). It is true that if BlockStructure consists only of complex blocks, then all G matrices will be zero, and the expression above simplifies to ( D r ) . The LMI method consists of finding a scalar and matrices D and G, consistent with BlockStructure, such that
1
10-209
mussvextract
M'D rM D c + j* ( G cr M M'G rc ) is negative semidefinite. Again, D and G have a few different manifestations to match the row and column dimensions of M. Any such is an upper bound of mussv(M,BlockStructure). If BlockStructure consists only of complex blocks, then all G matrices will be zero, and negative semidefinitness of MDrM2Dc is sufficient to derive an upper bound.
Lower Bound Information

The lower bound of mussv(M,BlockStructure) is based on finding a small (hopefully the smallest) block-structured matrix VDelta that causes det(I M*VDelta) to equal 0. Equivalently, the matrix M*VDelta has an eigenvalue equal to 1. It will always be true that the lower bound (bounds(2)) will be the reciprocal of norm(VDelta).
Example
Suppose M is a 4-by-4 complex matrix. Take the block structure to be two 1-by-1 complex blocks and one 2-by-2 complex block.
M = randn(4,4) + sqrt(-1)*randn(4,4); BlockStructure = [1 1;1 1;2 2];
You can calculate bounds on the structured singular value using the mussv command and extract the scaling matrices using mussvextract.
[bounds,muinfo] = mussv(M,BlockStructure); [VDelta,VSigma,VLmi] = mussvextract(muinfo);
You can first verify the Newlin/Young upper bound with the information extracted from muinfo. The corresponding scalings are Dl and Dr.
Dl = VSigma.DLeft Dl = 1.0000 0 0 0.8393 0 0 0 0 Dr = VSigma.DRight Dr = 1.0000 0 0 0.8393 0 0
0 0 0.8917 0
0 0 0 0.8917
0 0 0.8917
0 0 0
10-210
mussvextract
0 0 [norm(Dl*M/Dr) bounds(1)] ans = 4.2013 4.2013
0.8917
You can first verify the LMI upper bound with the information extracted from muinfo. The corresponding scalings are Dr and Dc.
Dr = VLmi.Dr; Dc = VLmi.Dc; eig(M'*Dr*M - bounds(1)^2*Dc) ans = -15.2960 - 0.0000i -0.0000 - 0.0000i -10.1037 + 0.0000i -5.9719 + 0.0000i
Note that VDelta matches the structure defined by BlockStructure, and the norm of VDelta agrees with the lower bound,
VDelta VDelta = 0.2009 - 0.1277i 0 0 0.1648 - 0.1718i 0 0 - 0.1012i 0 0 + 0.1460i [norm(VDelta) 1/bounds(2)] ans = 0.2380 0.2380
0 0 0 0 -0.0408 + 0.0773i -0.0291 0.0635 - 0.1070i 0.0341
and that M*VDelta has an eigenvalue exactly at 1.

eig(M*VDelta) ans = 1.0000 + 0.0000i 0.0000 + 0.0000i -0.1161 + 0.0225i -0.0837 + 0.6532i
10-211
mussvextract
Keep the matrix the same, but change BlockStructure to be a 2-by-2 repeated, real scalar block and two complex 1-by-1 blocks. Run mussv with the 'C' option to tighten the upper bound.
BlockStructure2 = [-2 0; 1 0; 1 0]; [bounds2,muinfo2] = mussv(M,BlockStructure2,'C');
You can compare the computed bounds. Note that bounds2 should be smaller than bounds, since the uncertainty set defined by BlockStructure2 is a proper subset of that defined by BlockStructure.
[bounds; bounds2] ans = 4.2013 4.2009 4.0005 4.0005
You can extract the D, G and Delta from muinfo2 using mussvextract.
[VDelta2,VSigma2,VLmi2] = mussvextract(muinfo2);
As before, you can first verify the Newlin/Young upper bound with the information extracted from muinfo. The corresponding scalings are Dl, Dr, Gl, Gm and Gr.
Dl = VSigma2.DLeft; Dr = VSigma2.DRight; Gl = VSigma2.GLeft; Gm = VSigma2.GMiddle; Gr = VSigma2.GRight; dmd = Dl*M/Dr/bounds2(1) - sqrt(-1)*Gm; SL = (eye(4)+Gl*Gl)^-0.25; SR = (eye(4)+Gr*Gr)^-0.25; norm(SL*dmd*SR) ans = 1.0000
You can first verify the LMI upper bound with the information extracted from muinfo. The corresponding scalings are Dr, Dc, Grc and Gcr.
Dr = VLmi2.Dr; Dc = VLmi2.Dc; Grc = VLmi2.Grc; Gcr = VLmi2.Gcr;
10-212
mussvextract
eig(M'*Dr*M ans = -0.0075 -0.0009 -0.0001 -0.0004 -
- bounds(1)^2 *Dc + j*(Gcr*M-M'*Grc)) 0.0000i 0.0000i 0.0000i 0.0000i
Note that VDelta2 matches the structure defined by BlockStructure, and the norm of VDelta2 agrees with the lower bound,
VDelta2 VDelta2 = 0.2500 0 0 0.2500 0 0 0 0 [norm(VDelta2) 1/bounds2(2)] ans = 0.2500 0.2500
0 0 -0.0130 + 0.2496i 0 0.1402
0 0 0 + 0.2069i
and that M*VDelta2 has an eigenvalue exactly at 1.

eig(M*VDelta2) ans = 1.0000 + 0.0000i -0.3097 + 0.6127i -0.2287 + 0.0747i -0.2692 - 0.4897i
See Also
mussv
Calculate bounds on the Structured Singular Value ()
10-213
ncfmargin
10ncfmargin
Calculate the normalized coprime stability margin of the plant-controller feedback loop
[marg,freq] = ncfmargin(P,C) [marg,freq] = ncfmargin(P,C,tol) [marg,freq] = ncfmargin(P,C) calculates the normalized coprime factor/gap metric robust stability margin b(P, C), marg, of the multivariable feedback loop consisting of C in negative feedback with P. The normalized coprime factor b(P,
C) is defined as b ( P, C ) = I ( I PC ) 1 . P I C
1
C should only be the compensator in the feedback path, such as the 1-dof
architecture shown below (on the right). If the compensator has 2-dof architecture shown below (on the left), you must eliminate the reference channels before calling ncfmargin. freq is the frequency associated with the upper bound on marg.

The normalized coprime factor robust stability margin lies between 0 and 1 and is used as an indication of robustness to unstructured perturbations. Values of marg greater than 0.3 generally indicate good robustness margins.
[marg,freq] = ncfmargin(P,C,tol) calculates the normalized coprime
factor/gap metric robust stability of the multivariable feedback loop consisting of C in negative feedback with P. tol specifies a relative accuracy for calculating the normalized coprime factor metric and must be between 10-5 and 10-2. tol=0.001 is the default value.
10-214
ncfmargin
Example
Consider the plant model 4/(s-0.001), an unstable first order and two constant gain controllers, k1 = 1 and k2 = 10. Both controllers stabilize the closed-loop system
x = tf(4,[1 0.001]); clp1 = feedback(x,1)
The transfer function clp1 is shown as is clp2.

4 --------s + 4.001 clp2 = feedback(x,10) Transfer function: 4 -----s + 40
The closed-loop system with controller k1, clp1, has a normalized coprime factor robust stability margin of 0.71 which is achieved at infinite frequency. This indicates that the closed-loop system is very robust to unstructured perturbations. The closed-loop system with controller k2, clp2, has a normalized coprime factor robust stability margin of 0.10. This indicates that the closed-loop system is not robust to unstructured perturbations.
[marg1,freq1] = ncfmargin(x,1) marg1 = 0.7071 freq1 = Inf [marg2,freq2] = ncfmargin(x,10) marg2 = 0.0995 freq2 = Inf
Construct an uncertain system, xu, by adding a 11% unmodeled dynamics to the nominal system x. Calculate the robust stability of the closed-loop system with the feedback gain 1 and 10.
10-215
ncfmargin
xu = x + ultidyn('uncstruc',[1 1],'Bound',0.11); [stabmarg1, du1, report1] = robuststab(feedback(xu,1)); disp(report1{1}) Uncertain System is robustly stable to modeled uncertainty. -- It can tolerate up to 909% of modeled uncertainty. -- A destabilizing combination of 909% the modeled uncertainty exists, causing an instability at 165 rad/s. [stabmarg10, du10, report10] = robuststab(feedback(xu,10)); disp(report10{1}) Uncertain System is NOT robustly stable to modeled uncertainty. -- It can tolerate up to 90.9% of modeled uncertainty. -- A destabilizing combination of 90.9% the modeled uncertainty exists, causing an instability at 1.64e+003 rad/s.
The closed-loop system with K=1 is robustly stable in the presence of the unmodeled dynamics based on the robust stability analysis. In fact, the closed-loop system with K=1 can tolerate 909% (or 9.09*11%) of the unmodeled LTI dynamics. Whereas the closed-loop system is not robustly stable with a constant gain of 10 controller. The closed-loop system with K=10 implemented can only tolerate 90.9% (or.909*11%) of the unmodeled LTI dynamics.
Algorithm
The computation of the gap amounts to solving 2-block H problems, Georgiou, Smith 1988. The particular method used here for solving the H problems is based on Green et al., 1990. The computation of the nugap uses the method of Vinnicombe, 1993. McFarlane, D.C.and K. Glover, Robust Controller Design using Normalised Coprime Factor Plant Descriptions, Springer Verlag, Lecture Notes in Control and Information Sciences, vol. 138, 1989. McFarlane, D.C., and K. Glover, A Loop Shaping Design Procedure using Synthesis, IEEE Transactions on Automatic Control, vol. 37, no. 6, pp. 759-769, June 1992. Vinnicombe, G., Measuring Robustness of Feedback Systems, PhD dissertation, Department of Engineering, University of Cambridge, 1993.
Reference
See Also
loopmargin gapmetric norm
Performs a comprehensive analysis of feedback loop Computes the gap and the Vinnicombe gap metric Computes the norm of a system
10-216
ncfmargin
wcmargin
10-217
ncfmr
Purpose Syntax
10ncfmr
Balanced model truncation for normalized coprime factors. GRED = ncfmr(G) GRED = ncfmr(G,order) [GRED,redinfo] = ncfmr(G,key1,value1,...) [GRED,redinfo] = ncfmr(G,order,key1,value1,...) ncfmr returns a reduced order model GRED formed by a set of balanced normalized coprime factors and a struct array redinfo containing the left and right coprime factors of G and their coprime Hankel singular values.
Description
Hankel singular values of coprime factors of such a stable system indicate the respective state energy of the system. Hence, reduced order can be directly determined by examining the system Hankel SVs. With only one input argument G, the function will show a Hankel singular value plot of the original model and prompt for model order number to reduce. The left and right normalized coprime factors are defined as [1]
Left Coprime Factorization: G = M l 1 ( s )N l ( s ) Right Coprime Factorization: G = N r ( s )M r 1 ( s )
where there exist stable U r ( s ) , V r ( s ) , U l ( s ) , and V l ( s ) such that Ur Nr + Vr Mr = I Nl Ul + Ml Vl = I The left/right coprime factors are stable, hence implies Mr(s) should contain as RHP-zeros all the RHP-poles of G(s). The comprimeness also implies that there should be no common RHP-zeros in Nr(s) and Mr(s), i.e., when forming G = N r ( s )M r 1 ( s ) , there should be no pole-zero cancellations.
10-218
ncfmr
This table describes input arguments for ncmfr.

ORDER
A batch run of a serial of different reduced order models can be generated by specifying order = x:y, or a vector of integers. By default, all the anti-stable part of a system is kept, because from control stability point of view, getting rid of unstable state(s) is dangerous to model a system. ncfmr method allows the original model to have j-axis singularities. 'MaxError' can be specified in the same fashion as an alternative for 'ORDER'. In this case, reduced order will be determined when the sum of the tails of the Hankel sv's reaches the 'MaxError'
Argument Value Description
'MaxError ' 'Display' 'Order'
A real number or a vector of different errors

'on' or 'off'
Reduce to achieve H error. When present, 'MaxError'overides ORDER input. Display Hankel singular plots (default 'off'). Order of reduced model. Use only if not specified as 2nd argument.
integer, vector or cell array
10-219
ncfmr

LTI reduced order model, that becomes multi-dimensional array when input is a serial of different model order array. A STRUCT array with 3 fields: REDINFO.GL (left coprime factor) REDINFO.GR (right coprime factor) REDINFO.hsv (Hankel singular values)
REDINFO
Algorithm
1 Find the normalized coprime factors of G by solving Hamiltonian described
in [1]. Gl = Nl Ml
Gr =
Nr Mr
2 Perform kth order square root balanced model truncation on Gl (or Gr) [2]. 3 The reduced model GRED is [2]:
A C
B D
Ac Bm Cl Bn Bm Dl Dl Cl
where
10-220
ncfmr
Nl:= (Ac, Bn, Cc, Dn) Ml:= (Ac, Bm, Cc, Dm) Cl = (Dm)-1Cc Dl = (Dm)-1Dn
Example
rand('state',1234); randn('state',5678); G = rss(30,5,4); G.d = zeros(5,4); [g1, redinfo1] = ncfmr(G); % display Hankel SV plot % and prompt for order (try 15:20) [g2, redinfo2] = ncfmr(G,20); [g3, redinfo3] = ncfmr(G,[10:2:18]); [g4, redinfo4] = ncfmr(G,'MaxError',[0.01, 0.05]); for i = 1:4 figure(i); eval(['sigma(G,g' num2str(i) ');']); end
Reference
[1] M. Vidyasagar. Control System Synthesis - A Factorization Approach. London: The MIT Press, 1985. [2] M. G. Safonov and R. Y. Chiang, A Schur Method for Balanced Model Reduction, IEEE Trans. on Automat. Contr., vol. AC-2, no. 7, July 1989, pp. 729-733.
See Also
reduce balancmr schurmr bstmr hankelmr hankelsv
Top level model reduction routines Balanced truncation via square-root method Balanced truncation via Schur method Balanced stochastic truncation via Schur method Hankel minimum degree approximation Hankel singular value
10-221
ncfsyn
Purpose Syntax
10ncfsyn
Loop shaping design using the Glover-McFarlane method

[K,CL,GAM,INFO]=ncfsyn(G) [K,CL,GAM,INFO]=ncfsyn(G,W1) [K,CL,GAM,INFO]=ncfsyn(G,W1,W2) ncfsyn is a method for designing controllers that uses a combination of loop
Description
shaping and robust stabilization as proposed in McFarlane and Glover [1]-[2]. The first step is for you to select a pre- and post-compensator W1 and W2, so that the gain of the shaped plant Gs:= W2GW1 is sufficiently high at frequencies where good disturbance attenuation is required and is sufficiently low at frequencies where good robust stability is required. The second step is to use ncfsyn to compute an optimal positive feedback controllers K. The optimal Ks has the property that the sigma plot of the shaped loop
Ls=W2*G*W1*Ks
matches the target loopshape Gs optimally, roughly to within plus or minus 20*log10(GAM) decibels. The number margin GAM=1/ncfmargin(Gs,K) and is always greater than 1. GAM gives a good indication of robustness of stability to a wide class of unstructured plant variations, with values in the range 1<GAM<3 corresponding to satisfactory stability margins for most typical control system designs.
Algorithm
K=W2*Ks*W1, where Ks =K is an optimal
minimizes the two H cost functions := min K := min K
H controller that simultaneously
I ( I G K )1 [ G , I ] s s K I 1 ( I KG s ) [ K, I ] Gs
Roughly speaking, this means for most plants that (W2GW1 K), db = (W2GW1), db , db (KW2GW1), db = (W2GW1), db , db,
10-222
ncfsyn
so you can use the weights W1 and W2 for loopshaping. For a more precise bounds on loopshaping accuracy, see Theorem 16.12 of Zhou and Glover [1]. Theory ensures that if Gs=NM1is a normalized coprime factorization (NCF) of the weighted plant model Gs satisfying Gs=N(jw)*N(jw) + M(jw)*M(jw) = I, then the control system will remain robustly stable for any perturbation G s to the weighted plant model Gs that can be written
1 Gs = ( N + 1 ) ( M + 2 )
for some stable pair 1, 2 satisfying 1 2
< MARG:=1/GAM .
The closed-loop H-norm objective has the standard signal gain interpretation. Finally it can be shown that the controller, K, does not substantially affect the loop shape in frequencies where the gain of W2GW1 is either high or low, and will guarantee satisfactory stability margins in the frequency region of gain cross-over. In the regulator set-up, the final controller to be implemented is K=W1KW2. Input arguments
G
LTI plant to be controlled stable min-phase LTI weights, either SISO or MIMO. Default is W1=I, W2=I
W1,W2
Output arguments
K CL
LTI controller K= W1*Ks*W2 I 1 ( I W 2 GW 1 K ) [ W 2 GW 1, I ] , LTI H optimal closed loop K
10-223
ncfsyn
1 H optimal cost = ----------------------------------------- = hinfnorm(CL) 1 b ( W 2 GW 1, K ) structure array containing additional information
GAM INFO
Additional output INFO fields:

INFO.emax nugap robustness emax=1/GAM=ncfmargin(Gs,-Ks)= b ( W 2 GW 1, K ) 'shaped plant' Gs=W2*G*W1 Ks = K = NCFSYN(Gs) = NCFSYN(W2*G*W1)
INFO.Gs INFO.Ks
[MARG,FREQ] = ncfmargin(G,K,TOL) calculates the normalized coprime
factor/gap metric robust stability margin assuming negative feedback.

MARG=b ( G, K ) = 1
I ( I + GK ) 1 [ G , I ] . K
where G and K are LTI plant and controller, and TOL (default=.001) is the tolerance used to compute the H norm. FREQ is the peak frequency i.e., the frequency at which the infinity norm is reached to within TOL.
Algorithm Example
See the McFarlane and Glover [1]-[2] for details. The following code shows how ncfsyn can be used for loop-shaping. The achieved loop G*K has a sigma plot is equal to that of the target loop G*W1 to within plus or minus 20*log10(GAM) decibels.
s=zpk('s'); G=(s-1)/(s+1)^2; W1=0.5/s; [K,CL,GAM]=ncfsyn(G,W1); sigma(G*K,'r',G*W1,'r-.',G*W1*GAM,'k-.',G*W1/GAM,'k-.')
10-224
ncfsyn
Figure 10-15: Achieved loop G*K and shaped loop Gs, 20log(GAM) db
Reference
[1] McFarlane, D. C., and K. Glover, Robust Controller Design using Normalised Coprime Factor Plant Descriptions, Springer Verlag, Lecture Notes in Control and Information Sciences, vol. 138, 1989. [2] McFarlane, D.C., and K. Glover, A Loop Shaping Design Procedure using Synthesis, IEEE Transactions on Automatic Control, vol. 37, no. 6, pp. 759 769, June 1992. [3] Vinnicombe, G., Measuring Robustness of Feedback Systems, PhD dissertation, Department of Engineering, University of Cambridge, 1993. [4] Zhou, K., and J. C. Doyle, Essentials of Robust Control. NY: Prentice-Hall, 1998.
See Also
gapmetric hinfsyn loopsyn ncfmargin
Computes the gap and the Vinnicombe gap metric H controller synthesis H - loop shaping controller synthesis Normalized coprime stability margin of the plant-controller feedback loop
10-225
newlmi
10newlmi
Attach an identifying tag to LMIs

tag = newlmi newlmi adds a new LMI to the LMI system currently described and returns an identifier tag for this LMI. This identifier can be used in lmiterm, showlmi, or dellmi commands to refer to the newly declared LMI. Tagging LMIs is optional and only meant to facilitate code development and readability.
Identifiers can be given mnemonic names to help keep track of the various LMIs. Their value is simply the ranking of each LMI in the system (in the order of declaration). They prove useful when some LMIs are deleted from the LMI system. In such cases, the identifiers are the safest means of referring to the remaining LMIs.
See Also
setlmis lmivar lmiterm getlmis lmiedit dellmi
Initialize the description of an LMI system Specify the matrix variables in an LMI problem Specify the term content of LMIs Get the internal description of an LMI system Specify or display systems of LMIs as MATLAB expressions Remove an LMI from a given system of LMIs
10-226
normalized2actual
10normalized2actual
Convert the value for an atom in normalized coordinates to the corresponding actual value
avalue = normalizedactual2(A,NV) avalue = normalizedactual2(A,NV) converts the value for atom in normalized coordinates, NV, to the corresponding actual value.
If NV is an array of values, then avalue will be an array of the same dimension.
Example
Create uncertain real parameters with a range that is symmetric about the nominal value, where each end point is 1 unit from the nominal. Points that lie inside the range are less than 1 unit from the nominal, while points that lie outside the range are greater than 1 unit from the nominal.
a = ureal('a',3,'range',[1 5]); actual2normalized(a,[1 3 5]) ans = -1.0000 -0.0000 1.0000 normalized2actual(a,[-1 1]) ans = 1.0000 5.0000 normalized2actual(a,[-1.5 1.5]) ans = 0.0000 6.0000
See Also
actual2normalized robuststab robustperf
Calculates of an uncertain atom Calculates robust stability margin Calculates robust performance margin
10-227
pdlstab
10pdlstab
Assess the robust stability of a polytopic or parameter-dependent system

[tau,Q0,Q1,...] = pdlstab(pds,options) pdlstab uses parameter-dependent Lyapunov functions to establish the
stability of uncertain state-space models over some parameter range or polytope of systems. Only sufficient conditions for the existence of such Lyapunov functions are available in general. Nevertheless, the resulting robust stability tests are always less conservative than quadratic stability tests when the parameters are either time-invariant or slowly varying. For an affine parameter-dependent system E(p) x = A(p)x + B(p)u y = C(p)x + D(p)u with p = (p1, . . ., pn) Rn, pdlstab seeks a Lyapunov function of the form V(x, p) = xTQ(p)1x, Q(p) = Q0 + p1Q1 + . . .pnQn
such that dV(x, p)/dt < 0 along all admissible parameter trajectories. The system description pds is specified with psys and contains information about the range of values and rate of variation of each parameter pi. For a time-invariant polytopic system E x = Ax + Bu y = Cx + Du with A + jE B = C D A + jE B i i i , Ci Di i=1
n n
i 0 ,
i = 1 ,
i=1
(10-19)
pdlstab seeks a Lyapunov function of the form
V(x, ) = xTQ()1x,
Q() = 1Q1 + . . .+ nQn
such that dV(x, )/dt < 0 for all polytopic decompositions (9-19).
10-228
pdlstab
Several options and control parameters are accessible through the optional argument options: Setting options(1)=0 tests robust stability (default) When options(2)=0, pdlstab uses simplified sufficient conditions for faster running times. Set options(2)=1 to use the least conservative conditions
Remark
For affine parameter-dependent systems with time-invariant parameters, there is equivalence between the robust stability of E ( p )x = A ( p )x and that of the dual system
T T E(p) z = A(p) z
(10-20)
(10-21)
However, the second system may admit an affine parameter-dependent Lyapunov function while the first does not. In such case, pdlstab automatically restarts and tests stability on the dual system (9-21) when it fails on (9-20).
See Also
quadstab
Quadratic stability of polytopic or affine parameter-dependent systems
10-229
pdsimul
10pdsimul
Time response of a parameter-dependent system along a given parameter trajectory

pdsimul(pds,'traj',tf,'ut',xi,options) [t,x,y] = pdsimul(pds,pv,'traj',tf,'ut',xi,options) pdsimul simulates the time response of an affine parameter-dependent system
E(p) x = A(p)x + B(p)u y = C(p)x + D(p)u along a parameter trajectory p(t) and for an input signal u(t). The parameter trajectory and input signals are specified by two time functions p=traj(t) and u=ut(t). If 'ut' is omitted, the response to a step input is computed by default. The affine system pds is specified with psys. The function pdsimul also accepts the polytopic representation of such systems as returned by aff2pol(pds) or hinfgs. The final time and initial state vector can be reset through tf and xi (their respective default values are 5 seconds and 0). Finally, options gives access to the parameters controlling the ODE integration (type help gear for details). When invoked without output arguments, pdsimul plots the output trajectories y(t). Otherwise, it returns the vector of integration time points t as well as the state and output trajectories x,y.
See Also
psys pvec
Specification of uncertain state-space models Quantification of uncertainty on physical parameters
10-230
polydec
10polydec
Compute polytopic coordinates wrt. box corners

vertx = polydec(PV) [C,vertx] = polydec(PV,P) vertx = polydec(PV) takes an uncertain parameter vector PV taking values ranging in a box, and returns the corners or vertices of the box as columns of the matrix vertx. [C,vertx] = polydec(PV,P) takes an uncertain parameter vector PV and a value P of the parameter vector PV, and returns the convex decomposition C of P over the set VERTX of box corners: P = c1*VERTX(:,1) + ... + cn*VERTX(:,n) cj >=0 , c1 + ... + cn = 1
The list vertx of corners can be obtained directly by typing

vertx = polydec(PV)
See Also
pvec pvinfo aff2pol hinfgs
Quantification of uncertainty on physical parameters Describe a parameter vector specified with pvec Convert affine parameter-dependent models to polytopic ones Synthesis of gain-scheduled H controllers
10-231
popov
10popov
Perform the Popov robust stability test

[t,P,S,N] = popov(sys,delta,flag) popov uses the Popov criterion to test the robust stability of dynamical systems with possibly nonlinear and/or time-varying uncertainty. The uncertain system must be described as the interconnection of a nominal LTI system sys and some uncertainty delta.
The command
[t,P,S,N] = popov(sys,delta)
tests the robust stability of this interconnection. Robust stability is guaranteed if t < 0. Then P determines the quadratic part xTPx of the Lyapunov function and D and S are the Popov multipliers. If the uncertainty delta contains real parameter blocks, the conservatism of the Popov criterion can be reduced by first performing a simple loop transformation. To use this refined test, call popov with the syntax
[t,P,S,N] = popov(sys,delta,1)
See Also
quadstab pdlstab
Quadratic stability of polytopic or affine parameter-dependent systems Robust stability of polytopic or affine parameter-dependent systems (P-system)
10-232
psinfo
Purpose Syntax
10psinfo
Inquire about polytopic or parameter-dependent systems created with psys

psinfo(ps) [type,k,ns,ni,no] = psinfo(ps) pv = psinfo(ps,'par') sk = psinfo(ps,'sys',k) sys = psinfo(ps,'eval',p) psinfo is a multi-usage function for queries about a polytopic or parameter-dependent system ps created with psys. It performs the following
Description
operations depending on the calling sequence: psinfo(ps) displays the type of system (affine or polytopic); the number k of SYSTEM matrices involved in its definition; and the numbers of ns, ni, no of states, inputs, and outputs of the system. This information can be optionally stored in MATLAB variables by providing output arguments. pv = psinfo(ps,'par') returns the parameter vector description (for parameter-dependent systems only). sk = psinfo(ps,'sys',k) returns the k-th SYSTEM matrix involved in the definition of ps. The ranking k is relative to the list of systems syslist used in psys. sys = psinfo(ps,'eval',p) instantiates the system for a given vector p of parameter values or polytopic coordinates. For affine parameter-dependent systems defined by the SYSTEM matrices S0, S1, . . ., Sn, the entries of p should be real parameter values p1, . . ., pn and the result is the LTI system of SYSTEM matrix S(p) = S0 + p1S1 + . . .+ pnSn For polytopic systems with SYSTEM matrix ranging in Co{S1, . . ., Sn}, the entries of p should be polytopic coordinates p1, . . ., pn satisfying pj 0 and the result is the interpolated LTI system of SYSTEM matrix p1 S1 + + pn Sn S = --------------------------------------------p1 + + pn
See Also
psys
Specification of uncertain state-space models
10-233
psys
10psys
Specify polytopic or parameter-dependent linear systems

pols = psys(syslist) affs = psys(pv,syslist) psys specifies state-space models where the state-space matrices can be uncertain, time-varying, or parameter-dependent.
Two types of uncertain state-space models can be manipulated in the LMI Control Toolbox: Polytopic systems E(t) x = A(t)x + B(t)u y = C(t)x + D(t)u whose SYSTEM matrix takes values in a fixed polytope: A ( t ) + jE ( t ) B ( t ) Co A 1 + jE 1 B 1 , . . ., A k + jE k B k C(t) D(t) C1 D1 Ck Dk S(t) S1 Sk

where S1, . . ., Sk are given vertex systems and

k k i Si : i 0 , i = 1 Co{S1, . . ., Sk} = i=1 i = 1
denotes the convex hull of S1, . . ., Sk (polytope of matrices with vertices S1, . . ., Sk) Affine parameter-dependent systems E(p) x = A(p)x + B(p)u
10-234
psys
y = C(p)x + D(p)u where A(.); B(.), . . ., E(.) are fixed affine functions of some vector p = (p1, . . ., pn) of real parameters, i.e., A ( p ) + jE ( p ) B ( p ) = C(p) D(p) S(p)

A 0 + jE 0 B 0 A + jE 1 B 1 A + jE n B n + p1 1 + . . . + pn n C0 D0 C1 D1 Cn Dn

S0
S1
where S0, S1, . . ., Sn are given SYSTEM matrices. The parameters pi can be time-varying or constant but uncertain. Both types of models are specified with the function psys. The argument syslist lists the SYSTEM matrices Si characterizing the polytopic value set or parameter dependence. In addition, the description pv of the parameter vector (range of values and rate of variation) is required for affine parameterdependent models (see pvec for details). Thus, a polytopic model with vertex systems S1, . . ., S4 is created by
pols = psys([s1,s2,s3,s4])
while an affine parameter-dependent model with 4 real parameters is defined by

affs = psys(pv,[s0,s1,s2,s3,s4])
The output is a structured matrix storing all the relevant information.
See Also
psinfo pvec aff2pol
Inquire about polytopic or parameter-dependent systems created with psys Quantification of uncertainty on physical parameters Convert affine parameter-dependent models to polytopic ones
Sn
10-235
pvec
10pvec
Specify the range and rate of variation of uncertain or time-varying parameters

pv = pvec('box',range,rates) pv = pvec('pol',vertices) pvec is used in conjunction with psys to specify parameter-dependent systems.
Such systems are parametrized by a vector p = (p1, . . ., pn) of uncertain or time-varying real parameters pi. The function pvec defines the range of values and the rates of variation of these parameters. The type 'box' corresponds to independent parameters ranging in intervals pj pj pj The parameter vector p then takes values in a hyperrectangle of Rn called the parameter box. The second argument range is an n-by-2 matrix that stacks up the extremal values p j and p j of each pj. If the third argument rates is omitted, all parameters are assumed time-invariant. Otherwise, rates is also an n-by-2 matrix and its j-th row specifies lower and upper bounds j and j dp on ---------j : dt dp j j -------- j dt Set j = Inf and j = Inf if pj(t) can vary arbitrarily fast or discontinuously. The type 'pol' corresponds to parameter vectors p ranging in a polytope of the parameter space Rn. This polytope is defined by a set of vertices V1, . . ., Vn corresponding to extremal values of the vector p. Such parameter vectors are declared by the command
pv = pvec('pol',[v1,v2, . . ., vn])
where the second argument is the concatenation of the vectors v1,...,vn. The output argument pv is a structured matrix storing the parameter vector description. Use pvinfo to read the contents of pv.
Example
Consider a problem with two time-invariant parameters p1 [1, 2], p2 [20, 50]
10-236
pvec
The corresponding parameter vector p = (p1, p2) is specified by

pv = pvec('box',[-1 2;20 50])
Alternatively, this vector can be regarded as taking values in the rectangle drawn in Figure 9.2. The four corners of this rectangle are the four vectors v1 = 1 , v2 = 1 20 50 , v3 = 2 , 20 v4 = 2 50
Hence, you could also specify p by

pv = pvec('pol',[v1,v2,v3,v4])
p2 50
20
-1
p1
Figure 10-16: Parameter box
See Also
pvinfo psys
Describe a parameter vector specified with pvec Specification of uncertain state-space models
10-237
pvinfo
Purpose Syntax
10pvinfo
Describe a parameter vector specified with pvec

[typ,k,nv] = pvinfo(pv) [pmin,pmax,dpmin,dpmax] = pvinfo(pv,'par',j) vj = pvinfo(pv,'par',j) p = pvinfo(pv,'eval',c) pvec retrieves information about a vector p = (p1, . . ., pn) of real parameters declared with pvec and stored in pv. The command pvinfo(pv) displays the type of parameter vector ('box' or 'pol'), the number n of scalar parameters, and for the type 'pol', the number of vertices used to specify the parameter range.
Description
For the type 'box':

[pmin,pmax,dpmin,dpmax] = pvinfo(pv,'par',j)
returns the bounds on the value and rate of variations of the j-th real parameter pj. Specifically, dp j pmin p ( t ) pmax , dpmin -------- dpmax j dt For the type 'pol':
pvinfo(pv,'par',j)
returns the j-th vertex of the polytope of Rn in which p ranges, while

pvinfo(pv,'eval',c)
returns the value of the parameter vector p given its barycentric coordinates c with respect to the polytope vertices (V1, . . .,Vk). The vector c must be of length k and have nonnegative entries. The corresponding value of p is then given by p =
i = 1 c i V i ---------------------------k i = 1 c i
k
See Also
pvec psys
Quantification of uncertainty on physical parameters Specification of uncertain state-space models
10-238
quadperf
Compute the quadratic H performance of a polytopic or parameter-dependent system

[perf,P] = quadperf(ps,g,options)
10quadperf
The RMS gain of the time-varying system E ( t )x = A ( t )x + B ( t )u, is the smallest > 0 such that y L u L 2 2 y = C ( t )x + D ( t )u
(10-22)
(10-23)
for all input u(t) with bounded energy. A sufficient condition for (9-23) is the existence of a quadratic Lyapunov function V(x) = xTPx, such that
T 2 T dV u L 2 , ------- + y y u u < 0 dt
P>0
Minimizing over such quadratic Lyapunov functions yields the quadratic H performance, an upper bound on the true RMS gain. The command
[perf,P] = quadperf(ps)
computes the quadratic H performance perf when (9-22) is a polytopic or affine parameter-dependent system ps (see psys). The Lyapunov matrix P yielding the performance perf is returned in P. The optional input options gives access to the following task and control parameters: If options(1)=1, perf is the largest portion of the parameter box where the quadratic RMS gain remains smaller than the positive value g (for affine parameter-dependent systems only). The default value is 0
10-239
quadperf
If options(2)=1, quadperf uses the least conservative quadratic performance test. The default is options(2)=0 (fast mode) options(3) is a user-specified upper bound on the condition number of P (the default is 109).
See Also
quadstab psys
Quadratic stability of polytopic or affine parameter-dependent systems Specification of uncertain state-space models
10-240
quadstab
10quadstab
Quadratic stability of polytopic or affine parameter-dependent systems

[tau,P] = quadstab(ps,options)
For affine parameter-dependent systems E(p) x = A(p)x, or polytopic systems E(t) x = A(t)x, (A, E) Co{(A1, E1), . . ., (An, En)}, p(t) = (p1(t), . . ., pn(t))
quadstab seeks a fixed Lyapunov function V(x) = xTPx with P > 0 that
establishes quadratic stability. The affine or polytopic model is described by ps (see psys). The task performed by quadstab is selected by options(1): if options(1)=0 (default), quadstab assesses quadratic stability by solving the LMI problem Minimize over Q = QT such that ATQE + EQAT I The global minimum of this problem is returned in tau and the system is quadratically stable if tau < 0 if options(1)=1, quadstab computes the largest portion of the specified parameter range where quadratic stability holds (only available for affine models). Specifically, if each parameter pi varies in the interval pi [pi0 i, pi0 + i],
quadstab computes the largest > 0 such that quadratic stability holds over
the parameter box pi [pi0 i, pi0 + i] This quadratic stability margin is returned in tau and ps is quadratically stable if tau 1. Given the solution Qopt of the LMI optimization, the Lyapunov matrix P is 1 given by P = Q opt . This matrix is returned in P.
10-241
quadstab
Other control parameters can be accessed through options(2) and options(3): if options(2)=0 (default), quadstab runs in fast mode, using the least expensive sufficient conditions. Set options(2)=1 to use the least conservative conditions options(3) is a bound on the condition number of the Lyapunov matrix P. The default is 109.
See Also
pdlstab decay quadperf psys
Robust stability of polytopic or affine parameter-dependent systems (P-system) Quadratic decay rate of polytopic or affine P-systems Compute the quadratic H performance of a polytopic or parameter-dependent system Specification of uncertain state-space models
10-242
randatom
Purpose Syntax
10randatom
Generate random uncertain atom objects

A = randatom(Type) A = randatom(Type,sz) A = randatom A = randatom(Type) generates a 1-by-1 type uncertain object. Valid values for Type include 'ureal', 'ultidyn', 'ucomplex', and 'ucomplexm'. A = randatom(Type,sz) generates an sz(1)-by-sz(2) uncertain object. Valid values for Type include 'ultidyn' or 'ucomplexm'. If Type is set to 'ureal' or 'ucomplex', the size variable is ignored and A is a 1-by-1 uncertain object. A = randatom, where randatom has no input arguments, results in a 1-by-1 uncertain object. The class is of this object is randomly selected between 'ureal','ultidyn' and 'ucomplex'.
Description
In general, both rand and randn are used internally. You can control the result of randatom by setting seeds for both random number generators before calling the function.
Example
The following statement creates the ureal uncertain object xr. Note that your display may differ because a random seed is used.
xr = randatom('ureal') Uncertain Real Parameter: Name BMSJA, NominalValue -6.75, Range [-7.70893 -1.89278]
The following statement creates the variable ultidyn uncertain object xlti with three inputs and four outputs. You will get the results shown below if both the random variable seeds are set to 29.
rand(`seed',29); randn(`seed',29); xlti = randatom('ultidyn',[4 3]) Uncertain GainBounded LTI Dynamics: Name OOJGS, 4x3, Gain Bound = 0.646
See Also
rand randn randumat
Generates uniformly distributed random numbers Generates normally distributed random numbers Creates a random uncertain matrix
10-243
randatom
randuss ucomplex ucomplexm ultidyn
Creates a random uncertain system Creates an uncertain complex parameter Creates an uncertain complex matrix Creates an uncertain linear time-invariant object
10-244
randumat
10randumat
Generate random uncertain umat objects

um = randumat(ny,nu) um = randumat um = randumat(ny,nu) generates an uncertain matrix of size ny-by-nu. randumat randomly selects from uncertain atoms of type 'ureal', 'ultidyn', and 'ucomplex'. um = randumat results in a 1-by-1 umat uncertain object, including up to four uncertain objects.
Example
The following statement creates the umat uncertain object x1 of size 2-by-3. Note that your result may differ because a random seed is used.
x1 = randumat(2,3) UMAT: 2 Rows, 3 Columns ROQAW: complex, nominal = 9.92+4.84i, radius = 0.568, 1 occurrence UEPDY: real, nominal = -5.81, variability = [-1.98681 0.133993], 3 occurrences VVNHL: complex, nominal = 5.64-6.13i, radius = 1.99, 2 occurrences
The following statement creates the umat uncertain object x2 of size 4-by-2 with the seed 91.
rand(`seed',91); randn(`seed',91); x2 = randumat(4,2) UMAT: 4 Rows, 2 Columns SSAFF: complex, nominal = -0.366+2.81i, radius = 1.76, 3 occurrences VDTIH: complex, nominal = -3.03-3i, +/- 27.5%, 2 occurrences XOLLJ: real, nominal = 0.0628, range = [-3.73202 4.28174], 1 occurrence
See Also
rand randn randatom randuss ucomplex
Generate uniformly distributed random numbers
Generate normally distributed random numbers Create a random uncertain atom Create a random uncertain system Creates an uncertain complex parameter
10-245
randumat
ultidyn
Creates an uncertain linear time-invariant object
10-246
randuss
Purpose Syntax
10randuss
Generates stable, random uss objects.

usys usys usys usys usys = = = = = randuss(n) randuss(n,p) randuss(n,p,m) randuss(n,p,m,Ts) randuss
Description
usys = randuss(n) generates an n-th order single-input/single-output
uncertain continuous-time system. randuss randomly selects from uncertain atoms of type 'ureal', 'ultidyn', and 'ucomplex'.
usys = randuss(n,p) generates an n-th order single-input uncertain continuous-time system with p outputs. usys = randuss(n,p,m) generates an n-th order uncertain continuous-time system with p outputs and m inputs. usys = randuss(n,p,m,Ts) generates an n-th order uncertain discrete-time system with p outputs and m inputs. The sample time is Ts. usys = randuss (without arguments) results in a 1-by-1 uncertain continuous-time uss object with up to four uncertain objects.
In general, both rand and randn are used internally. You can control the result of randuss by setting seeds for both random number generators before calling the function.
Example
The statement creates a 5th order, continuous-time uncertain system, s1, of size 2-by-3. Note your display may differ since a random seed is used.
s1 = randuss(5,2,3) USS: 5 States, 2 Outputs, 3 Inputs, Continuous System CTPQV: 1x1 LTI, max. gain = 2.2, 1 occurrence IGDHN: real, nominal = -4.03, variability = [-3.74667 22.7816]%, 1 occurrence MLGCD: complex, nominal = 8.36+3.09i, +/- 7.07%, 1 occurrence OEDJK: complex, nominal = -0.346-0.296i, radius = 0.895, 1 occurrence
See Also
rand
Generates uniformly distributed random numbers
10-247
randuss
randn randatom randumat ucomplex ultidyn
Generates normally distributed random numbers Creates a random uncertain atom Creates a random uncertain matrix Creates an uncertain complex parameter Creates an uncertain linear time-invariant object
10-248
frd/rcond
10frd/rcond
LAPACK reciprocal condition estimator of a frd object.

r = rcond(x) rcond(x) is an estimate for the reciprocal of the condition of the frd object x in the 1-norm obtained by the LAPACK condition estimator. rcond operates on x.ReponseData of the x frd at each frequency to construct r. If x is well conditioned, rcond(x) is near 1.0. If x is badly conditioned, rcond(x) is near EPS. r=rcond(x) returns r as an frd object.
See Also
cond norm condest normest
Calculates condition number with respect to inversion Calculates matrix or vector norm Calculates a 1-norm condition number estimate Calculates a matrix 2-norm estimate
10-249
reduce
Purpose Syntax
10reduce
Simplified access to Hankel singular value based model reduction functions GRED = reduce(G) GRED = reduce(G,order) [GRED,redinfo] = reduce(G,'key1','value1',...) [GRED,redinfo] = reduce(G,order,'key1','value1',...) reduce returns a reduced order model GRED of G and a struct array redinfo
Description
containing the error bound of the reduced model, Hankel singular values of the original system and some other relevant model reduction information. An error bound is a measure of how close GRED is to G and is computed based on either additive error, || G-GRED ||, multiplicative error, || G-1(G-GRED) ||, or nugap error (ref.: ncfmr) [1],[4],[5]. Hankel singular values of a stable system indicate the respective state energy of the system. Hence, reduced order can be directly determined by examining the system Hankel SV's. Model reduction routines, which based on Hankel SV's are grouped by their error bound types. In many cases, the additive error method GRED=reduce(G,ORDER) is adequate to provide a good reduced order model. But for systems with lightly damped poles and/or zeros, a multiplicative error method (namely, GRED=reduce(G,ORDER,'ErrorType','mult')) that minimizes the relative error between G and GRED tends to produce a better fit. This table describes input arguments for reduce.
LTI model to be reduced (without any other inputs will plot its Hankel singular values and prompt for reduced order). (Optional) an integer for the desired order of the reduced model, or optionally a vector packed with desired orders for batch runs.
ORDER
A batch run of a serial of different reduced order models can be generated by specifying order = x:y, or a vector of integers. By default, all the anti-stable part of a physical system is kept, because from control stability point of view, getting rid of unstable state(s) is dangerous to model a system.
10-250
reduce
'MaxError' can be specified in the same fashion as an alternative for 'ORDER' after an 'ErrorType' is selected. In this case, reduced order will be determined when the sum of the tails of the Hankel SV's reaches the 'MaxError'.
Argument 'Algorithm' Value 'balance' 'schur' 'hankel' 'bst' 'ncf' 'add' 'mult' 'ncf' Description
Default for 'add' (balancmr) Option for 'add' (schurmr) Option for 'add' (hankelmr) Default for 'mult' (bstmr) Default for 'ncf' (ncfmr) Additive error (default) Multiplicative error at model output NCF nugap error Reduce to achieve H error. When present, 'MaxError' overrides ORDER input. Optimal 1x2 cell array of LTI weights
Wout (output) and Win (input); default is
'ErrorType'
'MaxError'

{Wout,Win}
'Weights'
cell array
both identity; used only with

'ErrorType', 'add'. Weights must be
invertible.
'Display' 'on' or 'off'
Display Hankel singular plots (default 'off'). Order of reduced model. Use only if not specified as 2nd argument.
'Order'
10-251
reduce

LTI reduced order model. Becomes multi-dimensional array when input is a serial of different model order array. A STRUCT array with 3 fields: REDINFO.ErrorBound REDINFO.StabSV REDINFO.UnstabSV For 'hankel' algorithm, STRUCT array becomes: REDINFO.ErrorBound REDINFO.StabSV REDINFO.UnstabSV REDINFO.Ganticausal For 'ncf' option, STRUCT array becomes: REDINFO.GL REDINFO.GR REDINFO.hsv
REDINFO
G can be stable or unstable. G and GRED can be either continuous or discrete.
A successful model reduction with a well-conditioned original model G will ensure that the reduced model GRED satisfies the infinity norm error bound.
Example
rand('state',1234); randn('state',5678);G = rss(30,5,4); [g1, redinfo1] = reduce(G); % display Hankel SV plot % and prompt for order [g2, redinfo2] = reduce(G,20); % default to balancmr [g3, redinfo3] = reduce(G,[10:2:18],'algorithm','schur'); % select schurmr [g4, redinfo] = reduce(G,'ErrorType','mult','MaxError',[0.01, 0.05]);
10-252
reduce
rand('state',12345); randn('state',6789); wt1 = rss(6,5,5); wt1.d = eye(5)*2; wt2 = rss(6,4,4); wt2.d = 2*eye(4); [g5, redinfo5] = reduce(G, [10:2:18], 'weight',{wt1,wt2}); [g6, redinfo6] = reduce(G,'ErrorType','add','algorithm','hankel', ... 'maxerror',[0.01]); for i = 1:6 figure(i); eval(['sigma(G,g' num2str(i) ');']); end
Reference
[1] K. Glover, All Optimal Hankel Norm Approximation of Linear Multivariable Systems, and Their L error Bounds, Int. J. Control, vol. 39, no. 6, pp. 1145-1193, 1984. [2] M. G. Safonov and R. Y. Chiang, A Schur Method for Balanced Model Reduction, IEEE Trans. on Automat. Contr., vol. AC-2, no. 7, July 1989, pp. 729-733. [3] M. G. Safonov, R. Y. Chiang and D. J. N. Limebeer, Optimal Hankel Model Reduction for Nonminimal Systems, IEEE Trans. on Automat. Contr., vol. 35, No. 4, April, 1990, pp. 496-502. [4] M. G. Safonov and R. Y. Chiang, Model Reduction for Robust Control: A Schur Relative-Error Method, International Journal of Adaptive Control and Signal Processing, vol. 2, pp. 259-272, 1988. [5] K. Zhou, Frequency weighted L error bounds, Syst. Contr. Lett., Vol. 21, 115125, 1993.
See Also
balancmr schurmr bstmr ncfmr hankelmr hankelsv
Balanced truncation via square-root method Balanced truncation via Schur method Balanced stochastic truncation via Schur method Balanced truncation for normalized coprime factors Hankel minimum degree approximation Hankel singular value
10-253
repmat
10repmat
Replicate and tile an array

B = repmat(A,M,N) B = repmat(A,M,N) creates a large matrix B consisting of an M-by-N tiling of
copies of A.
B = repmat(A,[M N]) accomplishes the same result as repmat(A,M,N). B = repmat(A,[M N P ...]) tiles the array A to produce an M-by-N-by-P-by-...
block array. A can be N-D.

repmat(A,M,N) for scalar A is commonly used to produce an M-by-N matrix filled with values of A.
Example
Simple examples of using repmat are:

repmat(randumat(2,2),2,3) repmat(ureal(`A',6),[4 2])
10-254
robopt
10robopt
Create an options object for use with robuststab and robustperf

opts = robopt opts = robopt('name1',value1,'name2',value2,...) options = robopt (with no input arguments) creates an options object with all the properties set to their default values. options = robopt('name1',value1,'name2',value2,...) creates an robopt object in which specified properties have the given values. Any unspecified property is set to its default value. It is sufficient to type only enough leading characters to define the property name uniquely. Case is ignored for property names. robopt with no input or output arguments displays a complete list of option
properties and their default values.
Fields
The following are the robopt object properties:
Object Property Display Description
Displays progress of computations. Default is

'off'
Sensitivity
Computes margin sensitivity to individual uncertainties. Default is 'on' Percentage variation of uncertainty used as a stepsize in finite-difference calculations to estimate sensitivity. Default is 25. Option used in internal structured singular value calculations (when calling mussv). Default is 'sm9'.
VaryUncertainty
Mussv
10-255
robopt
Object Property Default
Description
Structure, fieldnames are robopt properties, and values are the default values. Structure, fieldnames are robopt properties, and values text description of property
Meaning
Example
You can create a robopt options object called opt with all default values.
opt = robopt Property Object Values: Display: 'off' Sensitivity: 'on' VaryUncertainty: 25 Mussv: 'sm9' Default: [1x1 struct] Meaning: [1x1 struct]
In estimating local sensitivities, an elementary finite-difference scheme is used. The property VaryUncertainty denotes the stepsize used in estimating the derivatives necessary in computing sensitivities. In the following statements, you are requesting that the sensitivity of the robust stability margin calculation to a 50% variation individual uncertainties be calculated. The robopt options properties 'Sensitivity' and 'VaryUncertainty' are individually set.
opt = robopt; opt.VaryUncertainty = 50; opt Property Object Values: Display: 'off' Sensitivity: 'on' VaryUncertainty: 50 Mussv: 'sm9' Default: [1x1 struct] Meaning: [1x1 struct]
See Also
dkitopt robuststab
Creates an options object for dksyn Calculates stability margins of uncertain systems
10-256
robopt
robustperf wcgopt wcsens wcmargin
Calculates performance margins of uncertain systems Creates a wcgain option object Calculates worst-case sensitivities for a feedback loop Calculates worst-case margins for a feedback loop
10-257
robustperf
Purpose Syntax
10robustperf
Calculates the robust performance margin of an uncertain multivariable system. Largely included for historical purposes.
perfmarg = robustperf(sys) [perfmarg,wcu,report,info] = robustperf(sys) [perfmarg,wcu,report,info] = robustperf(sys,opt)
Description
The performance of a nominally-stable uncertain system model will generally degrade for specific values of its uncertain elements. robustperf computes the robust performance margin, which is one measure of the level of degradation brought on by the modeled uncertainty. The relationship between robustperf and other measures, such as robuststab and wcgain, is described in Chapter 7, Generalized Robustness Analysis. As with other uncertain-system analysis tools, only bounds on the performance margin are computed. The exact robust performance margin is guaranteed to lie in between these upper and lower bounds. The computation used in robustperf is a frequency-domain calculation. If the input system sys is a ufrd, then the analysis is performed on the frequency grid within the ufrd. If the input system sys is a uss, then an appropriate frequency grid is generated (automatically), and the analysis performed on that frequency grid. In all discussion that follows below, N denotes the number of points in the frequency grid.
Basic syntax
Suppose sys is a ufrd or uss with M uncertain elements. The results of
[perfmarg,perfmargunc,Report] = robustperf(sys)
are such that perfmarg is a structure with the following fields

Field LowerBound Description
Lower bound on robust performance margin, positive scalar.
10-258
robustperf
Field UpperBound
Description
Upper bound on robust performance margin, positive scalar. The value of frequency at which the performance degradation curve crosses the y=1/x curve. See section Generalized Robustness Analysis of the on-line documentation.
CriticalFrequency
perfmargunc is a struct of values of uncertain elements associated with the
intersection of the performance degradation curve and the y=1/x curve. See Chapter 7, Generalized Robustness Analysis. There are M fieldnames, which are the names of uncertain elements of sys.
Report is a text description of the robust performance analysis results.
Example
Create a plant with nominal model of an integrator, and include additive unmodeled dynamics uncertainty of a level of 0.4 (this corresponds to 100% model uncertainty at 2.5 rads/s).
P = tf(1,[1 0]) + ultidyn('delta',[1 1],'bound',0.4);
Design a proportional controller K which puts the nominal closed-loop bandwidth at 0.8 rad/sec. Roll-off K at a frequency 25 times the nominal closed-loop bandwidth. Form the closed-loop sensitivity function.
BW = 0.8; K = tf(BW,[1/(25*BW) 1]); S = feedback(1,P*K);
Assess the performance margin of the closed-loop sensitivity function. Since the nominal gain of the sensitivity function is 1, and the performance degradation curve is monotonically increasing (see Chapter 7, Generalized Robustness Analysis), the performance margin should be less than 1.
[perfmargin,punc] = robustperf(S); perfmargin perfmargin = UpperBound: 7.4305e-001 LowerBound: 7.4305e-001 CriticalFrequency: 5.3096e+000
10-259
robustperf
You can verify that the upper bound of the performance margin corresponds to a point on or above the y=1/x curve. First compute the normalized size of the value of the uncertain element, and check that this agrees with the upper bound.
nsize = actual2normalized(S.Uncertainty.delta, punc.delta) nsize = perfmargin.UpperBound ans = 7.4305e-001
Compute the system gain with that value substituted, and verify that the product of the normalized size and the system gain is greater than or equal to 1.
gain = norm(usubs(S,punc),inf,.00001); nsize*gain ans = 1.0000e+000
Finally, as a sanity check, verify that the robust performance margin is less than the robust stability margin (it should always be, as described in Chapter 4, Robustness Analysis).
[stabmargin] = robuststab(S); stabmargin stabmargin = UpperBound: 3.1251e+000 LowerBound: 3.1251e+000 DestabilizingFrequency: 4.0862e+000
While the robust stability margin is easy to describe (poles migrating from stable region into unstable region), describing the robust performance margin is less elementary. See the diagrams and figures in Chapter 7, Generalized Robustness Analysis. Rather than finding values for uncertain elements which lead to instability, the analysis finds values of uncertain elements corresponding to the intersection point of the performance degradation curve with a y=1/x hyperbola. This characterization, mentioned above in the description of perfmarg.CriticalFrequency and perfmargunc will be used often in the descriptions below.
10-260
robustperf
Basic syntax with 4th output argument

A 4th output argument yields more specialized information, including sensitivities and frequency-by-frequency information.
[perfmarg,perfmargunc,Report,Info] = robustperf(sys)
In addition to the first 3 output arguments, described previous, Info is a structure with the following fields
Field Sensitivity Description
A struct with M fields, fieldnames are names of uncertain elements of sys. Values of fields are positive, each the local sensitivity of the overall Stability Margin to that elements uncertainty range. For instance, a value of 25 indicates that if the uncertainty range is enlarged by 8%, then the stability margin should drop by about 2% (25% of 8). If the Sensitivity property of the robopt object is 'off', the values are set to NaN. N1 frequency vector associated with analysis. N-by-1 cell array, with one entry for each frequency point. The kth entry Info.BadUncertainValues{k} is a struct of values of uncertain elements resulting from a robust performance analysis at frequency Info.Frequency(k). A 1-by-2 frd, with upper and lower bounds from mussv. The (1,1) entry is the -upper bound (corresponds to perfmarg.LowerBound) and the (1,2) entry is the -lower bound (for perfmarg.UpperBound). Structure of compressed data from mussv.
Frequency BadUncertainValues
MussvBnds
MussvInfo
Options (e.g., controlling what is displayed during the computation, turning on/off the sensitivity computation, setting the step-size in the sensitivity computation, and controlling the option argument used in the underlying call to mussv) can be specified using the robustness analysis options robopt object.
10-261
robustperf
For instance, you can turn the on display and turn off the sensitivity by executing
opt = robopt('Sensitivity','off','Display','on'); [PerfMarg,Destabunc,Report,Info] = robustperf(sys,opt)
Handling array dimensions

If sys has array dimensions (for example, suppose that the size of sys is rcd1d2dF, refer to the d1d2dF as the array dimensions) then the margin calculation is performed pointwise (individually, at each and every array value) and the computed answers all have array dimensions as well. Details are described below. Again, assume that there are N frequency points and M uncertain elements. The results of
[perfmarg,perfmargunc,Report,Info] = robustperf(sys,opt)
are perfmarg is a structure with the following fields

d1dF, lower bound on stability margin across the array dimensions. d1dF, upper bound on performance margin across the array dimensions. Using single-indexing, for each i, the upper bound on the performance margin of sys(:,:,i) is perfmarg.UpperBound(i). d1dF, the value of frequency at which the performance degradation curve crosses the y=1/x curve. Using single-indexing, for each i, the frequency at which the performance degradation curve crosses the y=1/x curve in robust performance analysis of sys(:,:,i) is perfmarg.CriticalFrequency(i). See Chapter 7, Generalized Robustness Analysis.
UpperBound
CriticalFrequency
10-262
robustperf
perfmargunc is a d1dF structure array of values of uncertain elements, associated with the intersection of the performance degradation curve and the y=1/x curve. See section Generalized Robustness Analysis of the on-line documentation. Using single-indexing, for each i, the struct of values of uncertain elements for uncertain system sys(:,:,i) is perfmargunc(i). Report is a character array, dimensions 3, 4, ..., F+2 are d1dF, containing
text description of the robustness analysis results at each grid in the array dimensions. In addition to the first 3 output arguments, described previous, Info is a structure with the following fields
A d1dF struct, fieldnames are names of uncertain elements of sys. Using single indexing notation, Sensitivity(i) contains the sensitivities of perfmarg.UpperBound(i) for the uncertain system
sys(:,:,i).
N1 frequency vector associated with analysis. N-by-1 cell array, with one entry for each frequency point. The k'th entry Info.BadUncertainValues{k} is a d1dF struct of values of uncertain elements resulting from a d1dF family of robust performance computations at frequency Info.Frequency(k). 12d1dF frd, with upper and lower bounds from mussv. Using single-indexing for the dimensions associated with the array dimensions, it follows that the (1,1,i) entry is the -upper bound (reciprical of perfmarg.UpperBound(i)) while the (1,2,i) entry is the -lower bound (reciprocal of perfmarg.UpperBound(i)). Structure of compressed data from mussv.
MussvBnds
MussvInfo
10-263
robustperf
The smallest performance margin over all array dimensions can be computed min(perfmarg.UpperBound(:)). Computing
i = find(UpperBound==min(UpperBound(:)))
and then selecting perfmargunc(i) yields values for an uncertainty corresponding to the smallest performance margin across all array dimensions.
Algorithm
A rigorous robust performance analysis consists of two steps:

1 verify that the nominal system is stable; and then 2 robust performance analysis on an augmented system.
The algorithm in robustperf follows this in spirit, but may require user attention. If sys is a uss object, then the first requirement of stability of nominal value is explicitly checked within robustperf. However, if sys is an ufrd, then the verification of nominal stability from the nominal frequency response data is not performed, and is instead assumed. The exact performance margin is guaranteed to be no larger than UpperBound (some uncertain elements associated with this magnitude cause instability one instance is returned in the structure perfmargunc). The instability created by perfmargunc occurs at frequency value in CriticalFrequency. Similarly, the exact performance margin is guaranteed to be no smaller than
LowerBound.
Limitations
Because the calculation is carried out with a frequency gridding, it is possible (likely) that the true critical frequency is missing from the frequency vector used in the analysis. This is similar to the problem in robuststab. However, in comparing to robuststab, the problem in robustperf is less acute. The robust performance margin, considered a function of problem data and frequency, is typically a continuous function (unlike the robust stability margin, described in the Robust Control Toolbox demo entitled Getting Reliable Estimates of Robustness Margins in the online documentation). Hence, in robust performance margin calculations, increasing the density of the frequency grid will always increase the accuracy of the answers, and in the limit, answers arbitrarily close to the actual answers are obtainable with finite frequency grids.
10-264
robustperf
See Also
loopmargin mussv norm robopt robuststab actual2normalized wcgain wcsens wcmargin
Comprehensive analysis of feedback loop. Calculate bounds on the Structured Singular Value () Calculate LTI system norms Create a robuststab/robustperf options object Calculates stability margins of uncertain systems Normalizes range of uncertain atoms Calculate worst-case gain of uncertain systems Calculate worst-case sensitivities for feedback loop Calculate worst-case margins for feedback loop
10-265
robuststab
10robuststab
Calculates robust stability margins of an uncertain multivariable system.

[stabmarg,destabunc,report,info] = robuststab(sys) [stabmarg,destabunc,report,info] = robuststab(sys,opt)
A nominally stable uncertain system will generally be unstable for specific values of its uncertain elements. Determining the values of the uncertain elements closest to their nominal values for which instability occurs is a robust stability calculation. If the uncertain system is stable for all values of uncertain elements within their allowable ranges (ranges for ureal, norm bound or positive-real constraint for ultidyn, radius for ucomplex, weighted ball for ucomplexm), the uncertain system is robustly stable. Conversely, if there is a combination of element values that cause instability, and all lie within their allowable ranges, then the uncertain system is not robustly stable.
robuststab computes the margin of stability robustness for an uncertain
system. A stability robustness margin greater than 1 means that the uncertain system is stable for all values of its modeled uncertainty. A stability robustness margin less than 1 implies that certain allowable values of the uncertain elements, within their specified ranges, lead to instability. Numerically, a margin of 0.5 (for example) implies two things: the uncertain system remains stable for all values of uncertain elements which are less than 0.5 normalized units away from their nominal values; and, there is a collection of uncertain elements which are less than or equal to 0.5 normalized units away from their nominal values that results in instability. Similarly, a margin of 1.3 implies that the uncertain system remains stable for all values of uncertain elements up to 30% outside of their modeled uncertain ranges. See actual2normalized for converting between actual and normalized deviations from the nominal value of an uncertain element. As with other uncertain-system analysis tools, only bounds on the exact stability margin are computed. The exact robust stability margin is guaranteed to lie in between these upper and lower bounds. The computation used in robuststab is a frequency-domain calculation. If the input system sys is a ufrd, then the analysis is performed on the frequency grid within the ufrd. If the input system sys is a uss, then an appropriate
10-266
robuststab
frequency grid is generated (automatically), and the analysis performed on that frequency grid. In all discussion that follows below, N denotes the number of points in the frequency grid.
Basic syntax
Suppose sys is a ufrd or uss with M uncertain elements. The results of
[stabmarg,destabunc,Report] = robuststab(sys)
are stabmarg is a structure with the following fields

Lower bound on stability margin, positive scalar. If greater than 1, then the uncertain system is guaranteed stable for all values of the modeled uncertainty. If the nominal value of the uncertain system is unstable, then stabmarg.UpperBound and stabmarg.LowerBound will equal . Upper bound on stability margin, positive scalar. If less than 1, the uncertain system is not stable for all values of the modeled uncertainty. The critical value of frequency at which instability occurs, with uncertain elements closest to their nominal values. At a particular value of uncertain elements (see destabunc below), the poles migrate across the stability boundary (imaginary-axis in continuous-time systems, unit-disk in discrete-time systems) at the frequency given by DestabilizingFrequency.
UpperBound
DestabilizingFrequency
destabunc is a structure of values of uncertain elements, closest to nominal, which cause instability. There are M fieldnames, which are the names of uncertain elements of sys. The value of each field is the corresponding value of
10-267
robuststab
the uncertain element, such that when jointly combined, lead to instability. The command pole(usubs(sys,destabunc)) shows the instability. If A is an uncertain atom of sys, then
actual2normalized(destabunc.A,sys.Uncertainty.A)
will be less than or equal to UpperBound, and for at least one uncertain element of sys, this normalized distance will be equal to UpperBound, proving that UpperBound is indeed an upper bound on the robust stability margin.
Report is a text description of the robustness analysis results.
Example
Construct a feedback loop with a second order plant and a PID controller with approximate differentiation. The second-order plant has frequency-dependent uncertainty, in the form of additive unmodeled dynamics, introduced with a ultidyn object and a shaping filter.
robuststab is used to compute the stability margins of the closed-loop system
with respect to the plant model uncertainty.

P = tf(4,[1 .8 4]); delta = ultidyn('delta',[1 1],'SampleStateDim',5); Pu = P + 0.25*tf([1],[.15 1])*delta; C = tf([1 1],[.1 1]) + tf(2,[1 0]); S = feedback(1,Pu*C); [stabmarg,destabunc,report,info] = robuststab(S);
You can view the stabmarg variable.

stabmarg stabmarg = UpperBound: 0.8181 LowerBound: 0.8181 DestabilizingFrequency: 9.1321
As the margin is less than 1, the closed-loop system is not stable for plant models covered by the uncertain model Pu. There is a specific plant within the uncertain behavior modeled by Pu (actually about 82% of the modeled uncertainty) that leads to closed-loop instability, with the poles migrating across the stability boundary at 9.1 rads/s. The report variable is specific, giving a plain-language version of the conclusion.
10-268
robuststab
report report = Uncertain System is NOT robustly stable to modeled uncertainty. -- It can tolerate up to 81.8% of modeled uncertainty. -- A destabilizing combination of 81.8% the modeled uncertainty exists, causing an instability at 9.13 rad/s. -- Sensitivity with respect to uncertain element ... 'delta' is 100%. Increasing 'delta' by 25% leads to a 25% decrease in the margin.
Since the problem has only one uncertain element, the stability margin is completely determined by this element, and hence the margin exhibits 100% sensitivity to this uncertain element. You can verify that the destabilizing value of delta is indeed about 0.82 normalized units from its nominal value.
actual2normalized(S.Uncertainty.delta,destabunc.delta) ans = 0.8181
Use usubs to substitute the specific value into the closed-loop system. Verify that there is a closed-loop pole near j9.1, and plot the unit-step response of the nominal closed-loop system, as well as the unstable closed-loop system.
Sbad = usubs(S,destabunc); pole(Sbad) ans = 1.0e+002 * -3.2318 -0.2539 -0.0000 + 0.0913i -0.0000 - 0.0913i -0.0203 + 0.0211i -0.0203 - 0.0211i -0.0106 + 0.0116i -0.0106 - 0.0116i step(S.NominalValue,'r--',Sbad,'g',4);
Finally, as an ad-hoc test, set the gain-bound on the uncertain delta to 0.81 (slightly less than the stability margin). Sample the closed-loop system at 100 values, and compute the poles of all of these systems.
10-269
robuststab
S.Uncertainty.delta.Bound = 0.81; S100 = usample(S,100); p100 = pole(S100); max(real(p100(:))) ans = -6.4647e-007
As expected, all poles have negative real-parts.
Basic syntax with 4th output argument

A 4th output argument yields more specialized information, including sensitivities and frequency-by-frequency information.
[StabMarg,Destabunc,Report,Info] = robuststab(sys)
A struct with M fields, fieldnames are names of uncertain elements of sys. Values of fields are positive, each the local sensitivity of the overall Stability Margin to that elements uncertainty range. For instance, a value of 25 indicates that if the uncertainty range is enlarged by 8%, then the stability margin should drop by about 2% (25% of 8). If the Sensitivity property of the robopt object is 'off', the values are set to NaN. N1 frequency vector associated with analysis.
Frequency
10-270
robuststab
Field BadUncertainValues
Description
N-by-1 cell array, with one entry for each frequency point. The kth entryInfo.BadUncertainValues{k} is a struct of values of uncertain elements, closest to their nominal values, which cause the system poles to migrate across the stability boundary at frequency Info.Frequency(k). The command
pole(usubs(sys,Info.BadUncertainValues{k}))
shows the migration. The command

usubs(sys,cat(1,Info.BadUncertainValues{:})) generates an N-by-1 ss array. Each
instance is unstable, with poles on the stability boundary at frequencies given by the vector Info.Frequency. This migration to instability has been achieved with the smallest normalized deviations in the uncertain elements from their nominal values.
MussvBnds
A 1-by-2 frd, with upper and lower bounds from mussv. The (1,1) entry is the -upper bound (corresponds to stabmarg.LowerBound) and the (1,2) entry is the -lower bound (for stabmarg.UpperBound). Structure of compressed data from mussv.
MussvInfo
Options (e.g., controlling what is displayed during the computation, turning on/off the sensitivity computation, setting the step-size in the sensitivity computation, and controlling the option argument used in the underlying call to mussv) can be specified using the robustness analysis options robopt object. For instance, you can turn the display on, and the sensitivity calculation off be executing
opt = robopt('Sensitivity','off','Display','on'); [StabMarg,Destabunc,Report,Info] = robuststab(sys,opt)
10-271
robuststab
Handling array dimensions
If sys has array dimensions (for example, suppose that the size of sys is rcd1d2dF, refer to the d1d2dF as the array dimensions) then the margin calculation is performed pointwise (individually, at each and every array value) and the computed answers all have array dimensions as well. Details are described below. Again, assume that there are N frequency points and M uncertain elements. The results of
[stabmarg,destabunc,Report,Info] = robuststab(sys,opt)
are stabmarg is a structure with the following fields

d1dF, lower bound on stability margin across the array dimensions. d1dF, upper bound on stability margin across the array dimensions. Using single-indexing, for each i, the upper bound on the stability margin of sys(:,:,i) is stabmarg.UpperBound(i). d1dF, frequency at which instability occurs, associated with stabmarg.UpperBound. Using single-indexing, for each i, the frequency at which instability occurs in robust stability analysis of sys(:,:,i) is
stabmarg.DestabilizingFrequency(i).
UpperBound
DestabilizingFrequency
destabunc is a d1dF structure array of values of uncertain elements,
which cause instability. Using single-indexing, for each i, the destabilizing values of uncertain elements for uncertain system sys(:,:,i) is destabunc(i).
Report is a character array, dimensions 3, 4, ... , F+2 are d1dF, containing
text description of the robustness analysis results at each grid in the array dimensions.
10-272
robuststab
A d1dF struct, fieldnames are names of uncertain elements of sys. Using single indexing notation, Sensitivity(i) contains the sensitivities of stabmarg.UpperBound(i) for the uncertain system sys(:,:,i). N1 frequency vector associated with analysis. N-by-1 cell array, with one entry for each frequency point. The kth entry Info.BadUncertainValues{k} is a d1dF struct of values of uncertain elements, closest to their nominal values, which cause the system poles to migrate across the stability boundary at frequency Info.Frequency(k). The command
usubs(sys,Info.BadUncertainValues{k})
produces an ss array of size d1dF with the substitutions made. Alternatively,

usubs(sys,cat(F+1,Info.BadUncertainValues{:})) produces an ss array of size
d1dFN with the substitutions made.

MussvBnds
A 12d1df frd, with upper and lower bounds from mussv. Using single-indexing for the dimensions associated with the array dimensions, it follows that the (1,1,i) entry is the -upper bound (corresponding to stabmarg.LowerBound(i)) while the (1,2,i) entry is the -lower bound (which corresponds to stabmarg.UpperBound(i)). Structure of compressed data from mussv.
MussvInfo
You can compute the smallest stability margin over all array dimensions via
10-273
robuststab
min(stabmarg.UpperBound(:)).
Computing i = find(UpperBound==min(UpperBound(:))) and then destabunc(i) yields values for an uncertainty corresponding to the smallest stability margin across all array dimensions.
Algorithm
A rigorous robust stability analysis consists of two steps:

1 verify that the nominal system is stable; and then 2 verify that no poles cross the stability boundary as the uncertain elements
vary within their ranges. Since the stability boundary is also associated with the frequency response, the second step can be interpreted (and carried out) as a frequency domain calculation. This amounts to a classical -analysis problem. The algorithm in robuststab follows this in spirit, but may require user attention. If sys is a uss object, then the first requirement of stability of nominal value is explicitly checked within robuststab. However, if sys is an ufrd, then the verification of nominal stability from the nominal frequency response data is not performed, and is instead assumed. In the second step (monitoring the stability boundary for the migration of poles), rather than check all points on stability boundary, the algorithm only detects migration of poles across the stability boundary at the frequencies in info.Frequency. See the Limitations section below about issues related to migration detection. The exact stability margin is guaranteed to be no larger than UpperBound (some uncertain elements associated with this magnitude cause instability one instance is returned in the structure destabunc). The instability created by destabunc occurs at frequency value in DestabilizingFrequency. Similarly, the exact stability margin is guaranteed to be no smaller than LowerBound. In other words, for all modeled uncertainty with magnitude up to LowerBound, the system is guaranteed stable. These bounds are derived using upper bound for the structured singular value, which is essentially optimally-scaled, small-gain theorem analysis.
10-274
robuststab
Limitations
Under most conditions, the robust stability margin that occurs at each frequency is a continuous function of the problem data at that frequency. Since the problem data, in turn, is a continuous function of frequency, it follows that finite frequency grids are usually adequate in correctly assessing robust stability bounds, assuming the frequency grid is dense enough. Nevertheless, there are simple examples which violate this. In some problems, the migration of poles from stable to unstable only occurs at a finite collection of specific frequencies (generally unknown to you). Any frequency grid which excludes these critical frequencies (and almost every grid will exclude them) will result in undetected migration and misleading results, namely stability margins of . See the Robust Control Toolbox demo titled Getting Reliable Estimates of Robustness Margins in the online documentation about circumventing the problem in an engineering-relevant fashion.
See Also
loopmargin mussv robopt robustperf wcgain wcsens wcmargin
Comprehensive analysis of a feedback loop Calculates bounds on the Structured Singular Value () Creates a robuststab/robustperf options object Calculates performance margins of uncertain systems Calculates worst-case gain of uncertain systems Calculates worst-case sensitivities for a feedback loop Calculates worst-case margins for a feedback loop
10-275
frd/schur
Purpose Syntax
10frd/schur
Schur decomposition of an frd object.

[u,t] t [u,t] t [u,t] t = = = = = = schur(x) schur(x) schur(x,0) schur(x,0) schur(x,'econ') schur(x,'econ')
Description
frd/schur applies the schur command to frd objects. [u,t] = schur(x) operates on x.ReponseData of the frd object at each frequency point to construct u and t. u and t are frd objects. x must be square. See the built in schur command for details. qz schur
See Also
Creates a QZ factorization for generalized eigenvalues Calculates a Schur decomposition
10-276
schurmr
Purpose Syntax
10schurmr
Balanced model truncation via Schur method GRED = schurmr(G) GRED = schurmr(G,order) [GRED,redinfo] = schurmr(G,key1,value1,...) [GRED,redinfo] = schurmr(G,order,key1,value1,...) schurmr returns a reduced order model GRED of G and a struct array redinfo containing the error bound of the reduced model and Hankel singular values of the original system.
Description
The error bound is computed based on Hankel singular values of G. For a stable system Hankel singular values indicate the respective state energy of the system. Hence, reduced order can be directly determined by examining the system Hankel SVs, . With only one input argument G, the function will show a Hankel singular value plot of the original model and prompt for model order number to reduce. This method guarantees an error bound on the infinity norm of the additive error || G-GRED || for well-conditioned model reduced problems [1]:
n
G Gred 2
i
k+1
This table describes input arguments for schurmr.

LTI model to be reduced (without any other inputs will plot its Hankel singular values and prompt for reduced order). (Optional) an integer for the desired order of the reduced model, or optionally a vector packed with desired orders for batch runs
ORDER
A batch run of a serial of different reduced order models can be generated by specifying order = x:y, or a vector of integers. By default, all the anti-stable
10-277
schurmr
part of a system is kept, because from control stability point of view, getting rid of unstable state(s) is dangerous to model a system. 'MaxError' can be specified in the same fashion as an alternative for 'ORDER'. In this case, reduced order will be determined when the sum of the tails of the Hankel sv's reaches the 'MaxError'.

{Wout,Win}
Reduce to achieve H error. When present, 'MaxError'overides ORDER input.
'Weights'
cell array
'Display' 'on' or 'off'
Optimal 1x2 cell array of LTI weights Wout (output) and Win (input); default is both identity; Weights must be invertible. Display Hankel singular plots (default 'off'). Order of reduced model. Use only if not specified as 2nd argument.
'Order'
10-278
schurmr

LTI reduced order model. Becomes multi-dimensional array when input is a serial of different model order array. A STRUCT array with 3 fields: REDINFO.ErrorBound REDINFO.StabSV REDINFO.UnstabSV
REDINFO
G can be stable or unstable. G and GRED can be either continuous or discrete.
Algorithm
Given a state space (A,B,C,D) of a system and k, the desired reduced order, the following steps will produce a similarity transformation to truncate the original state space system to the kth order reduced model [16].
1 Find the controllability and observability grammians P and Q. 2 Find the Schur decomposition for PQ in both ascending and descending
order, respectively, 1 0 0 0 n
V A PQV A =
T V D PQV D
n = 0 0 0 1
3 Find the left/right orthonormal eigen-bases of PQ associated with the kth big
Hankel singular values.

4 Find the SVD of (VTL,BIG VR,BIG) = U VT
10-279
schurmr
V A = [V R, SMALL, V L, BIG ] V D = [ V R, BIG ,V L, SMALL]

5 Form the left/right transformation for the final kth order reduced model
SL,BIG = V L,BIG U(1:k,1:k)-1/2 SR,BIG = VR,BIGV(1:k,1:k)-1/2

6 Finally,
A C
B D
The proof of the Schur balance truncation algorithm can be found in [2].
Example
rand('state',1234); randn('state',5678);G = rss(30,5,4); [g1, redinfo1] = schurmr(G); % display Hankel SV plot % and prompt for order (try 15:20) [g2, redinfo2] = schurmr(G,20); [g3, redinfo3] = schurmr(G,[10:2:18]); [g4, redinfo4] = schurmr(G,'MaxError',[0.01, 0.05]); rand('state',12345); randn('state',6789); wt1 = rss(6,5,5); wt1.d = eye(5)*2; wt2 = rss(6,4,4); wt2.d = 2*eye(4); [g5, redinfo5] = schurmr(G, [10:2:18], 'weight',{wt1,wt2}); for i = 1:5 figure(i); eval(['sigma(G,g' num2str(i) ');']); end
Reference
[1] K. Glover, All Optimal Hankel Norm Approximation of Linear Multivariable Systems, and Their L error Bounds, Int. J. Control, vol. 39, no. 6, pp. 1145-1193, 1984.
10-280
schurmr
[2] M. G. Safonov and R. Y. Chiang, A Schur Method for Balanced Model Reduction, IEEE Trans. on Automat. Contr., vol. 34, no. 7, July 1989, pp. 729-733.
See Also
reduce balancmr bstmr ncfmr hankelmr hankelsv
Top level model reduction routines Balanced truncation via square-root method Balanced stochastic truncation via Schur method Balanced truncation for normalized coprime factors Hankel minimum degree approximation Hankel singular value
10-281
sdhinfnorm
Purpose Syntax
Computes the L2 norm of a continuous-time system in feedback with a discrete-time system

[gaml,gamu] = sdhinfnorm(sdsys,k) [gaml,gamu] = sdhinfnorm(sdsys,k,delay) [gaml,gamu] = sdhinfnorm(sdsys,k,delay,tol) [gaml,gamu] = sdhinfnorm(sdsys,k) computes the L2 induced norm of a continuous-time LTI plant, sdsys, in feedback with a discrete-time controller, k, connected through an ideal sampler and a zero-order hold (see figure below). sdsys must be strictly proper, such that the constant feedback gain must be zero. The outputs, gamu and gaml, are upper and lower bounds on the induced L2 norm of the sampled-data closed-loop system.
10sdhinfnorm
Description
[gaml,gamu] = sdhinfnorm(sdsys,k,h,delay) includes the input argument, delay. delay is a non-negative integer associated with the number of
computational delays of the controller. The default value of the delay is 0.

[gaml,gamu] = sdhinfnorm(sdsys,k,h,delay,tol) includes the input argument, tol, which defines the difference between upper and lower bounds when search terminates. The default value of tol is 0.001.
Example
Consider an open-loop, continuous-time transfer function p = 30/s(s+30) and a continuous-time controller k = 4/(s+4). The closed-loop continuous-time system has a peak magnitude across frequency of 1.
p = ss(tf(30,[1 30])*tf([1],[1 0])); k = ss(tf(4,[1 4])); cl = feedback(p,k); norm(cl,'inf') ans = 1
10-282
sdhinfnorm
Initially the controller is to be implemented at a sample rate of 1.5 Hz. The sample-data norm of the closed-loop system with the discrete-time controller is 1.0.
kd = c2d(k,0.75,'zoh'); [gu,gl] = sdhinfnorm([1; 1]*p*[1 1],-kd); [gu gl] ans = 3.7908 3.7929
Due to the large difference in norm between the continuous-time and sampled-data closed-loop system, the sample rate of the controller is increased from 1.5 Hz to 5 Hz. The sample-data norm of new closed-loop system is 3.79.
kd = c2d(k,0.2,'zoh'); [gu,gl] = sdhinfnorm([1; 1]*p*[1 1],-kd); [gu gl] ans = 1.0044 1.0049
Algorithm
sdhinfnorm uses variations of the formulae described in the Bamieh and
Pearson paper to obtain an equivalent discrete-time system. (These variations are done to improve the numerical conditioning of the algorithms.) A preliminary step is to determine whether the norm of the continuous-time system over one sampling period without control is less than the given-value. This requires a search and is, computationally, a relatively expensive step.
Reference
Bamieh, B.A., and J.B. Pearson, A General Framework for Linear Periodic Systems with Applications to Sampled-Data Control, IEEE Transactions on Automatic Control, vol. AC37, pp. 418-435, 1992.
gapmetric hinfsyn norm sdhinfsyn sdlsim
See Also
Computes the gap and the Vinnicombe gap metric Synthesizes a H optimal controller Calculates the system norm of an LTI object Synthesizes a sample-data H optimal controller Simulates response of a sampled-data feedback system
10-283
sdhinfsyn
10sdhinfsyn
sdhinfsyn computes an
H controller for a sampled-data system.
[K,GAM]=sdhinfsyn(P,NMEAS,NCON) [K,GAM]=sdhinfsyn(P,NMEAS,NCON, KEY1,VALUE1,KEY2,VALUE2,...) sdhinfsyn is concerned with the control of a continuous-time LTI system P by a discrete-time controller K. The continuous-time LTI plant P, has state-space realization partitioned as follows
A B1 B2 P = C1 0 0 C2 0 0
where the continuous-time disturbance inputs enter through B1, the outputs from the controller are held constant between sampling instants and enter through B2, the continuous-time errors to be kept small correspond to the C1 partition, and the output measurements that are sampled by the controller correspond to the C2 partition. B2 has column size (ncon) and C2 has row size (nmeas). Note that the D matrix is must be zero.
sdhinfsyn synthesizes a discrete-time LTI controller K to achieve a given norm (if possible) or find the minimum possible norm to within tolerance TOLGAM y1 u
1
y2
P u2
sampler
delay
Ts
hold
Similar to hinfsyn, the function sdhinfsyn employs a iteration. Given a high and low value of , GMAX and GMIN, the bisection method is used to iterate on the value of in an effort to approach the optimal H control design. If GMAX = GMIN, only one value is tested. The stopping criteria for the bisection algorithm
10-284
sdhinfsyn
requires the relative difference between the last value that failed and the last value that passed be less than TOLGAM. Input arguments:
P NMEAS NCON
LTI plant number of measurements output to controller number of control inputs
Optional input arguments (KEY, VALUE) pairs are similar to hinfsyn, but with additional KEY values 'Ts' and 'DELAY'.
KEY 'GMAX' 'GMIN' 'TOLGAM' 'Ts' VALUE
MEANING initial upper bound on GAM (default=Inf) initial lower bound on GAM (default=0) relative error tolerance for GAM (default=.01) (default=1) sampling period of the controller to be designed (default=0) a non-negative integer giving the number of sample periods delays for the control computation (default) no command window display, or command window displays synthesis progress information
real real real real integer
'DELAY'
'DISPLAY'
'off' 'on'
Output arguments:
K GAM
H controller
final value of H cost achieved
Algorithm
sdhinfsyn uses a variation of the formulae described in the Bamieh and
Pearson paper [1] to obtain an equivalent discrete-time system. (This is done to improve the numerical conditioning of the algorithms.) A preliminary step is
10-285
sdhinfsyn
to determine whether the norm of the continuous-time system over one sampling period without control is less than the given -value, this requires a search and is computationally a relatively expensive step.
Reference
[1] Bamieh, B.A., and J.B. Pearson, A General Framework for Linear Periodic Systems with Applications to Sampled-Data Control, IEEE Transactions on Automatic Control, vol. AC37, pp. 418435, 1992.
norm hinfsyn sdhinfnorm
See Also
System norm of an LTI object Synthesize an H optimal controller Calculate norm of sampled-data feedback system
10-286
sdlsim
Purpose Syntax
10sdlsim
Time response of sampled-data feedback system.

sdlsim(p,k,w,t,tf) sdlsim(p,k,w,t,tf,x0,z0) sdlsim(p,k,w,t,tf,x0,z0,int) [vt,yt,ut,t] = sdlsim(p,k,w,t,tf) [vt,yt,ut,t] = sdlsim(p,k,w,t,tf,x0,z0,int) sdlsim(p,k,w,t,tf) plots the time response of the hybrid feedback system, lft(p,k), is forced by the continuous input signal described by w and t (values and times, as in lsim). p must be a continuous-time LTI system, and k must be
Description
discrete-time LTI system, with a specified sampling time (the unspecified sampling time, -1, is not allowed). The final time is specified with tf.
sdlsim(p,k,w,t,tf,x0,z0) specifies the initial state vector x0 of p, and z0 of k, at time t(1). sdlsim(p,k,w,t,tf,x0,z0,int) specifies the continuous-time integration step size int. sdlsim forces int = (k.Ts)/N int where N>4 is an integer. If
any of these optional arguments are omitted, or passed as empty matrices, then default values are used. The default value for x0 and z0 is zero. Nonzero initial conditions are allowed for p (and/or k) only if p (and/or k) is an ss object. If p and/or k are LTI arrays with consistent array dimensions, then the time simulation is performed pointwise across the array dimensions.
[vt,yt,ut,t] = sdlsim(p,k,w,t,tf) computes the continuous-time response of the hybrid feedback system lft(p,k) forced by the continuous input signal defined by w and t (values and times, as in lsim). p must be a continuous-time system, and k must be discrete-time, with a specified sampling time (the unspecified sampling time, -1, is not allowed). The final time is specified with tf. The outputs vt, yt and ut are 2-by-1 cell arrays: in each the first entry is a time vector, and the 2nd entry is the signal values. Stored in this manner, the signal vt can be plotted by using one of the following commands: plot(vt{1},vt{2}) plot(vt{:})
Signals yt and ut are respectively the input to k and output of k.
10-287
sdlsim
If p and/or k are LTI arrays with consistent array dimensions, then the time simulation is performed pointwise across the array dimensions. The outputs are 2-by-1-by-Array Dimension cell arrays. All responses can be plotted simultaneously, for example, plot(vt).
[vt,yt,ut,t] = sdlsim(p,k,w,t,tf,x0,z0,int) The optional arguments are int (integration step size), x0 (initial condition for p), and z0 (initial condition for k). sdlsim forces int = (k.Ts)/N, where N>4 is an integer. If any
of these arguments are omitted, or passed as empty matrices, then default values are used. The default value for x0 and z0 is zero. Nonzero initial conditions are allowed for p (and/or k) only if p (and/or k) is an ss object.
Example
To illustrate the use of sdlsim, consider the application of a discrete controller to a an integrator with near integrator. A continuous plant and a discrete controller are created. A sample and hold equivalent of the plant is formed and the discrete closed-loop system is calculated. Simulating this with lsim gives the system response at the sample points. sdlsim is then used to calculate the intersample behavior.
P = tf(1,[1, 1e-5,0]); T = 1.0/20; C = ss([-1.5 T/4; -2/T -.5],[ .5 2;1/T 1/T],... [-1/T^2 -1.5/T], [1/T^2 0],T); Pd = c2d(P,T,'zoh');
The closed-loop digital system is now set up. You can use sysic to construct the interconnected feedback system.
systemnames = 'Pd C'; inputvar = '[ref]'; outputvar = '[Pd]'; input_to_Pd = '[C]'; input_to_C = '[ref ; Pd]'; sysoutname = 'dclp'; cleanupsysic = 'yes'; sysic; lsim is used to simulate the digital step response. [yd,td] = step(dclp,20*T);
10-288
sdlsim
The continuous interconnection is set up and the sampled data response is calculated with sdlsim.
M = [0,1;1,0;0,1]*blkdiag(1,P); t = [0:.01:1]'; u = ones(size(t)); y1 = sdlsim(M,C,u,t); plot(td,yd,'r*',y1{:},'b-') axis([0,1,0,1.5]) xlabel('Time: seconds') title('Step response: discrete (*), &continuous')
Step response: discrete (*), &continuous 1.5
0.5
0.1
0.2
0.3
0.4
0.5 0.6 Time: seconds
0.7
0.8
0.9
You can see he effect of a nonzero initial condition in the continuous- time system. Note how examining the system at only the sample points will underestimate the amplitude of the overshoot.
y2 = sdlsim(M,C,u,t,1,0,[0.25;0]); plot(td,yd,'r*',y1{:},'b-',y2{:},'g--') axis([0,1,0,1.5])
10-289
sdlsim
xlabel('Time: seconds') title('Step response: non zero initial condition')

Step response: non zero initial condition 1.5
0.5
0.1
0.2
0.3
0.4
0.7
0.8
0.9
Finally, you can examine the effect of a sinusoidal disturbance at the continuous-time plant output. This controller has not been designed to reject such a disturbance and the system does not contain anti-aliasing filters. Simulating the effect of anti-aliasing filters is easily accomplished by including them in the continuous interconnection structure.
M2 = [0,1,1;1,0,0;0,1,1]*blkdiag(1,1,P); t = [0:.001:1]'; dist = 0.1*sin(41*t); u = ones(size(t)); [y3,meas,act] = sdlsim(M2,C,[u dist],t,1); plot(y3{:},'-',t,dist,'b--',t,u,'g-.') xlabel('Time: seconds')
10-290
sdlsim
title('Step response: disturbance (dashed) &

Step response: disturbance (dashed) & output (solid) 1.4
output (solid)')
1.2
0.8
0.6
0.4
0.2
0.2
0.1
0.2
0.3
0.4
0.7
0.8
0.9
Algorithm See Also
sdlsim over samples the continuous-time, N times the sample rate of the controller k. gapmetric hinfsyn norm sdhinfnorm sdhinfsyn sdlsim
Computes the gap and the Vinnicombe gap metric Synthesizes a H optimal controller Computes the system norm of an LTI object Calculates the norm of a sampled-data feedback system Synthesizes a sample-data H optimal controller Simulates response of a sampled-data feedback system
10-291
sectf
10sectf
State-space sector bilinear transformation

[G,T] = sectf(F,SECF,SECG) [G,T] = sectf(F,SECF,SECG) computes a linear fractional transform T such that the system lft(F,K) is in sector SECF if and only if the system lft(G,K) is in sector SECG where G=lft(T,F,NU,NY)
where NU and NY are the dimensions of uT2 and yT2, respectivelysee Figure 10-17.
G yG1 yT1 yT2

T
uT1 uT2
uG1
yF1 yG2
yF2
uF1 uF2 uG2
K
Figure 10-17: Sector transform G=lft(T,F,NU,NY). sectf are used to transform general conic-sector control system performance
specifications into equivalent H-norm performance specifications.
10-292
sectf
. Input arguments:
F SECG, SECF: [-1,1] or [-1;1] [0,Inf] or [0;Inf] [A,B] or [A;B] [a,b] or [a;b] S S
LTI state-space plant Conic Sector: y

2
0 Re [ y u ] 0 Re [ ( y Au ) ( y Bu ) ] 0 Re [ ( y diag ( a )u ) ( y diag ( b )u ) ] 0 Re [ ( S 11 u + S 12 y ) ( S 21 u + S 22 y ) ] 0 Re [ ( S 11 u + S 12 y ) ( S 21 u + S 22 y ) ]
where A,B are scalars in [, ] or square matrices; a,b are vectors; S=[S11 S12;S21,S22] is a square matrix whose blocks S11,S12,S21,S22 are either scalars or square matrices; S is a two-port system S=mksys(a,b1,b2, ,'tss') with transfer function S(s) = .) Output arguments:
G T
S 11 ( s ) S 12 ( s ) S 21 ( s ) S 22 ( s )
transformed plant G(s)=lftf(T,F) LFT sector transform, maps conic sector

SECF into conic sector SECG
10-293
sectf
Output variables are:

G
The transformed plant G(s)=lftf(T,F): The linear fractional transformation T(s)=T
Examples
The statement G(j) inside sector[1, 1] is equivalent to the H inequality sup ( G ( j ) ) = G 1 Given a two-port open-loop plant P(s) := P, the command P1 = sectf(P,[0,Inf],[-1,1]) computes a transformed P1(s):= P1 such that if lft(G,K) is inside sector[1, 1] if and only if lft(F,K) is inside sector[0, ]. In other words, norm(lft(G,K),inf)<1 if and only if lft(F,K) is strictly positive real. See Figure 10-19
u1 u2
P(s)
y1 y2
K(s)
Figure 10-18: Sector Transform Block Diagram.
Here is a simple example of the sector transform. 1 s+2 P ( s ) = ----------- sec tor [ 1, 1 ] P 1 ( s ) = ----------- sec tor [ 0 , ]. s+1 s You can compute this by simply executing the following commands:
P = ss(tf(1,[1 1])); P1 = sectf(P,[-1,1],[0,Inf]);
The Nyquist plots for this transformation are depicted in Figure 10-19, Example of Sector Transform.. The condition P1(s) inside [0, ] implies that P1(s) is stable and P1(j) is positive real, i.e.,
10-294
sectf
P1 ( j ) + P 1 ( j ) 0
P(s) = 1/(s+1) in SEC[-1,1] 0 -0.05 -0.1 -0.15
P1 = (s+2)/s in SEC[0,inf] 0 -0.1 -0.2 -0.3
IMAG(P1)
-0.2
-0.4 -0.5 -0.6 -0.7 -0.8 -0.9
IMAG(P)
-0.25 -0.3 -0.35 -0.4 -0.45 -0.5 0 0.1 0.2 0.3 0.4 0.5 REAL(P) 0.6 0.7 0.8 0.9 1
-1 0
0.2
0.4
0.6
0.8
1 REAL(P1)
1.2
1.4
1.6
1.8
Figure 10-19: Example of Sector Transform.
Algorithm
sectf uses the generalization of the sector concept of [3] described by [1]. First the sector input data Sf= SECF and Sg=SECG is converted to two-port state-space form; non-dynamical sectors are handled with empty a, b1, b2, c1, c2 matrices. Next the equation
Sg ( s )
ug1 yg1
= Sf ( s )
u f1 yf1
is solved for the two-port transfer function T(s) from u g y f to u f y g . Finally, 1 1 1 1 the function lftf is used to compute G(s) as G=lftf(T,F).
10-295
sectf
A well-posed conic sector must have det ( B A ) 0 or det
s 11 s 12 ; 0. s 21 s 22
Limitations
Also, you must have dim ( u F1 ) = dim ( y F1 ) since sectors are only defined for square systems.
References
[1] Safonov, M. G., Stability and Robustness of Multivariable Feedback Systems. Cambridge, MA: MIT Press, 1980. [2] Safonov, M. G., E. A. Jonckheere, M. Verma and D. J. N. Limebeer, Synthesis of Positive Real Multivariable Feedback Systems, Int. J. Control, vol. 45, no. 3, pp. 817-842, 1987. [3] Zames, G., On the Input-Output Stability of Time-Varying Nonlinear Feedback Systems Part I: Conditions Using Concepts of Loop Gain, Conicity, and Positivity, IEEE Trans. on Automat. Contr., AC-11, pp. 228-238, 1966.
See Also
lft hinfsyn
Forms Redheffer star product of systems H controller synthesis
10-296
frd/semilog
10frd/semilog
Semi-log scale plot of a frd object.

semilogx(...) same as plot semilogx(...) is the same as plot(...), except a logarithmic (base 10) scale
is used for the X-axis.

loglog plot semilogy
Plot frd object on a log-log scale Plot frd object on a linear scale Plot frd object on a semi-log scale
10-297
setlmis
10setlmis
Initialize the description of an LMI system

setlmis(lmi0)
Before starting the description of a new LMI system with lmivar and lmiterm, type
setlmis([])
to initialize its internal representation. To add on to an existing LMI system, use the syntax
setlmis(lmi0)
where lmi0 is the internal representation of this LMI system. Subsequent lmivar and lmiterm commands will then add new variables and terms to the initial LMI system lmi0.
See Also
getlmis lmivar lmiterm newlmi
Get the internal description of an LMI system Specify the matrix variables in an LMI problem Specify the term content of LMIs Attach an identifying tag to LMIs
10-298
setmvar
10setmvar
Instantiate a matrix variable and evaluate all LMI terms involving this matrix variable
newsys = setmvar(lmisys,X,Xval) setmvar sets the matrix variable X with identifier X to the value Xval. All terms involving X are evaluated, the constant terms are updated accordingly, and X is removed from the list of matrix variables. A description of the resulting LMI system is returned in newsys.
The integer X is the identifier returned by lmivar when X is declared. Instantiating X with setmvar does not alter the identifiers of the remaining matrix variables. The function setmvar is useful to freeze certain matrix variables and optimize with respect to the remaining ones. It saves time by avoiding partial or complete redefinition of the set of LMI constraints.
Example
Consider the system x = Ax + Bu and the problem of finding a stabilizing state-feedback law u = Kx where K is an unknown matrix. By the Lyapunov Theorem, this is equivalent to finding P > 0 and K such that (A + BK)P + P(A + BK)T + I < 0. With the change of variable Y := KP, this condition reduces to the LMI AP + PAT + BY + YTBT + I < 0. This LMI is entered by the commands
n = size(A,1) % number of states ncon = size(B,2) % number of inputs setlmis([]) P = lmivar(1,[n 1]) % P full symmetric Y = lmivar(2,[ncon n]) % Y rectangular lmiterm([1 1 1 P],A,1,'s') % AP+PA'
10-299
setmvar
lmiterm([1 1 1 Y],B,1,'s') % BY+Y'B' lmiterm([1 1 1 0],1) % I lmis = getlmis
To find out whether this problem has a solution K for the particular Lyapunov matrix P = I, set P to I by typing
news = setmvar(lmis,P,1)
The resulting LMI system news has only one variable Y = K. Its feasibility is assessed by calling feasp:
[tmin,xfeas] = feasp(news) Y = dec2mat(news,xfeas,Y)
The computed Y is feasible whenever tmin < 0.
See Also
evallmi delmvar
Given a particular instance of the decision variables, evaluate all variable terms in the system of LMIs Delete one of the matrix variables of an LMI problem
10-300
showlmi
10showlmi
Return the left- and right-hand sides of an LMI after evaluation of all variable terms
[lhs,rhs] = showlmi(evalsys,n)
For given values of the decision variables, the function evallmi evaluates all variable terms in a system of LMIs. The left- and right-hand sides of the n-th LMI are then constant matrices that can be displayed with showlmi. If evalsys is the output of evallmi, the values lhs and rhs of these left- and right-hand sides are given by
[lhs,rhs] = showlmi(evalsys,n)
An error is issued if evalsys still contains variable terms.
Example See Also
See the description of evallmi.

evallmi setmvar
Given a particular instance of the decision variables, evaluate all variable terms in the system of LMIs Instantiate a matrix variable and evaluate all LMI terms involving this matrix variable
10-301
simplify
Purpose Syntax
10simplify
Simplify representations of uncertain objects

B B B B = = = = simplify(A) simplify(A,'full') simplify(A,'basic') simplify(A,'off')
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 elements AutoSimplify property, and uses 'full' reduction techniques. B = simplify(A,'basic') overrides all uncertain elements AutoSimplify property, and uses 'basic' reduction techniques. B = simplify(A,'off') 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]
10-302
simplify
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.
10-303
simplify
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
10-304
simplify
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 dx: real, nominal = 0, range = [-1
1], 7 occurrences 1], 2 occurrences
Alternatively, you can set the parameters 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 Limitations
simplify uses heuristics along with one-dimensional model reduction algorithms to partially reduce the dimensionality of the representation of an uncertain matrix or system.
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 simplifys naive methods cannot completely resolve these differences, so one may be forced to work with nonminimal representations of uncertain systems.
10-305
simplify
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, pp. 5, 1999. [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, pp. 17, 1999.
See Also
umat uss ucomplex ureal uss
Creates an uncertain matrix object Creates an uncertain system object Creates an uncertain complex parameter Creates an uncertain real parameter Creates an uncertain system
10-306
skewdec
10skewdec
Form a skew-symmetric matrix

x = skewdec(m,n) skewdec(m,n) forms the m-by-m skew-symmetric matrix
0 ( n 1 ) ( n 2 ) (n + 1) 0 ( n 3 ) (n + 2) (n + 3) 0
This function is useful to define skew-symmetric matrix variables. In this case, set n to the number of decision variables already used.
See Also
decinfo lmivar
Describe how the entries of a matrix variable X relate to the decision variables Specify the matrix variables in an LMI problem
10-307
slowfast
10slowfast
Slow and fast modes decomposition
[G1,G2] = slowfast(G,cut)
slowfast computes the slow and fast modes decompositions of a system G(s)
such that G ( s ) = [ G ( s ) ]s + [ G ( s ) ]f where [ G ( s ) ] s : = ( A 11, B 1, C 1, D 1 ) denotes the slow part of G(s), and [ G ( s ) ] : = ( A , B , C , D ) denotes the fast part. The variable cut denotes the
f 22 2 2 2
index where the modes will be split.

stabproj employs the algorithm in [1] as follows:
Find a unitary matrix V via the ordered Schur decomposition routines blksch or rschur such that A 11 A 12 T A = V AV = 0 A
22
Based on the style of ordered Schur form, you get i ( A 11 ) < i ( A 22 ) . Finally solving the matrix equation for X A 11 X X A 22 + A 12 = 0 you get the state-space projections [ G ( s ) ] s : = ( A 11, B 1, C 1, D 1 ) and [ G ( s ) ] f : = ( A 22, B 2, C 2, D 2 ) where
10-308
slowfast
B1 : = I X VB 0 I B2
and
T I X C 1 C 2 : = CV 0 I
References
[1] M. G. Safonov, E. A. Jonckheere, M. Verma and D. J. N. Limebeer, Synthesis of Positive Real Multivariable Feedback Systems, Int. J. Control, vol. 45, no. 3, pp. 817-842, 1987.
blkrsch cschur rschur schur modreal
See Also
Block ordered Schur realization Complex Schur realization Real Schur decomposition Schur decomposition Modal form realization
10-309
squeeze
10squeeze
Remove singleton dimensions for umat objects

B = squeeze(A) B = squeeze(A) returns an array B with the same elements as A but with all
the singleton dimensions removed. A singleton is a dimension such that

size(A,dim)==1. 2-D arrays are unaffected by squeeze so that row vectors
remain rows.
See Also
permute reshape
Permutes array dimensions. Changes size of matrix
10-310
uss/ssbal
Purpose Syntax
10uss/ssbal
Scale state/uncertainty while preserving the uncertain input/output map of an uncertain system.
usysout usysout usysout usysout = = = = ssbal(usys) ssbal(usys,Wc) ssbal(usys,Wc,FSflag) ssbal(usys,Wc,FSflag,BLTflag)
Description
usysout = ssbal(usys) yields a system whose input/output and uncertain properties are the same as usys, an uss object. The numerical conditioning of usysout is usually better than that of usys, improving the accuracy of additional computations performed with usysout. usysout is an uss object. The balancing algorithm uses mussv to balance the constant uncertain state-space matrices in discrete-time. If usys is a continuous-time uncertain system, the uncertain state-space is mapped by using a bilinear transformation into discrete-time for balancing. usysout = ssbal(usys,wc) defines the critical frequency, wc, for the bilinear prewarp transformation from continuous-time to discrete-time. The default value of wc is 1 when the nominal uncertain system is stable and 1.25*mxeig when it is unstable. mxeig corresponds to the value of real of the most positive pole of usys. usysout = ssbal(usys,wc,FSflag) sets the scaling flag, FSflag, to handle repeated uncertain parameters. Setting FSflag=1 uses full matrix scalings to balance the repeated uncertain parameter blocks. FSflag=0, the default, uses a single, positive scalar to balance the repeated uncertain parameter blocks. usysout = ssbal(usys,wc,FSflag,BLTflag) sets the bilinear transformation flag, BLTflag. By default, BLTflag=1 and transforms the continuous-time system usys to a discrete-time system for balancing. BLTflag=0 results in balancing the continuous-time state-space data from usys. Note that if usys is a discrete-time system, no bilinear transformation is performed. ssbal does not work on an array of uncertain systems. An error message is
generated to alert you of this.
Example
Consider a two-input, two-output, two-state uncertain system with two real parameter uncertainties, p1 and p2.
10-311
uss/ssbal
p2=ureal('p2',-17,'Range',[-19 -11]); p1=ureal('p1',3.2,'Percentage',0.43); A = [-12 p1;.001 p2]; B = [120 -809;503 24]; C = [.034 .0076; .00019 2]; usys = ss(A,B,C,zeros(2,2)) USS: 2 States, 2 Outputs, 2 Inputs, Continuous System p1: real, nominal = 3.2, variability = [-0.43 0.43]%, 1 occurrence p2: real, nominal = -17, range = [-19 -11], 1 occurrence usys.NominalValue a = x1 x2 x1 -12 3.2 x2 0.001 -17 b = x1 x2 c = y1 y2 d = y1 y2 u1 0 0 u2 0 0 x1 0.034 0.00019 x2 0.0076 2 u1 120 503 u2 -809 24
Continuous-time model. ssbal is used to balance the uncertain system, usys. usysout = ssbal(usys) USS: 2 States, 2 Outputs, 2 Inputs, Continuous System p1: real, nominal = 3.2, variability = [-0.43 0.43]%, 1 occurrence p2: real, nominal = -17, range = [-19 -11], 1 occurrence
10-312
uss/ssbal
usysout.NominalValue a = x1 x2 x1 -12 0.3302 x2 0.009692 -17 b = x1 x2 c = y1 y2 d = y1 y2 u1 0 0 u2 0 0 x1 5.229 0.02922 x2 0.1206 31.74 u1 0.7802 31.7 u2 -5.26 1.512
Continuous-time model.
See Also
canon c2d d2c mussv mussvextract ss2ss
Forms canonical state-space realizations Converts continuous-time models to discrete-time Converts discrete-time models to continuous-time Sets bounds on the Structure Singular Value () Extracts compressed data returned from mussv Changes state coordinates for state-space models
10-313
stabproj
10stabproj
Stable and antistable projection [G1,G2,m] = stabproj(G) stabproj computes the stable and antistable projections of a minimal realization G(s) such that G ( s ) = [ G ( s ) ] - + [ G ( s ) ] + where
[ G ( s ) ] - : = ( A 11, B 1, C 1, D 1 ) denotes the stable part of G(s), and [ G ( s ) ] : = ( A , B , C , D ) denotes the antistable part. The variable m
+ 22 2 2 2
returns the number of stable eigenvalues of A.
Algorithm
stabproj employs the algorithm in [1] as follows:
Find a unitary matrix V via the ordered Schur decomposition routines blksch or rschur such that
T
A = V AV =
A 11 A 12 0 A
22
Based on the style of ordered Schur form, you can get a stable A 11 and an antistable A .; ( A ) < ( A ) for the case of slowfast.
22 i 11 i 22
Finally solving the matrix equation for X A 11 X X A 22 + A 12 = 0 you get the state-space projections [ G ( s ) ] - or [ G ( s ) ] s : = ( A 11, B 1, C 1, D 1 ) and [ G ( s ) ] + or [ G ( s ) ] us : = ( A 22, B 2, C 2, D 2 )
10-314
stabproj
where B1 : = I X VB 0 I B2 and
T I X C 1 C 2 : = CV 0 I
References
[1] M. G. Safonov, E. A. Jonckheere, M. Verma and D. J. N. Limebeer, Synthesis of Positive Real Multivariable Feedback Systems, Int. J. Control, vol. 45, no. 3, pp. 817-842, 1987.
blkrsch cschur rschur schur modreal
See Also
Block ordered Schur realization Complex Schur realization Real Schur decomposition Schur decomposition Modal form realization
10-315
stack
10stack
Construct an array by stacking uncertain matrices, models, or arrays

umatout = stack(arraydim,umat1,umat2,...) usysout = stack(arraydim,usys1,usys2,...) stack constructs an uncertain array by stacking uncertain matrices, models, or arrays along array dimensions of an uncertain array. umatout = stack(arraydim,umat1,umat2,...) produces an array of uncertain matrices, umatout, by stacking (concatenating) the umat matrices (or umat arrays) umat1, umat2,... along the array dimension arraydim. All models must have the same number of columns and rows. The column/row dimensions are not counted in the array dimensions. umatout = stack(arraydim,usys1,usys2,...) produces an array of uncertain models, ufrd or uss, or usysout, by stacking (concatenating) the ufrd or uss matrices (or ufrd or uss arrays) usys1, usys2,... along the array dimension arraydim. All models must have the same number of columns and rows (the same input/output dimensions). Note that the input/output dimensions are not considered for arrays.
Example
Consider usys1 and usys2, two single-input/single-output uss models:

zeta wn = P1 = P2 = = ureal('zeta',1,'Range',[0.4 4]); ureal('wn',0.5,'Range',[0.3 0.7]); tf(1,[1 2*zeta*wn wn^2]); tf(zeta,[1 10]);
You can stack along the first dimension to produce a 2-by-1 uss array.
stack(1,P1,P1) USS: 2 States, 1 Output, 1 Input, Continuous System [array, 2 x 1] wn: real, nominal = 0.5, range = [0.3 0.7], 3 occurrences zeta: real, nominal = 1, range = [0.4 4], 1 occurrence
You can stack along the second dimension to produce a 1-by-2 uss array.
stack(2,P1,P2) % produces a 1-by-2 USS array. USS: 2 States, 1 Output, 1 Input, Continuous System [array, 1 x 2] wn: real, nominal = 0.5, range = [0.3 0.7], 3 occurrences zeta: real, nominal = 1, range = [0.4 4], 1 occurrence
10-316
stack
You can stack along the third dimension to produce a 1-by-1-by-2 uss array.
stack(3,P1,P2) % produces a 1-by-1-by-2 USS array. USS: 2 States, 1 Output, 1 Input, Continuous System [array, 1 x 1 x 2] wn: real, nominal = 0.5, range = [0.3 0.7], 3 occurrences zeta: real, nominal = 1, range = [0.4 4], 1 occurrence
See Also
append blkdiag horzcat vertcat
Groups models by appending their inputs and outputs Groups models by appending their inputs and outputs Performs horizontal concatenation Performs vertical concatenation
10-317
frd/svd
10frd/svd
Singular value decomposition of a frd object

S = svd(X) [U,S,V] = svd(X) S = svd(X) operates on X.ReponseData at each frequency to construct S. [U,S,V] = svd(X) produces a diagonal frd S that has the same dimensions as X and includes positive diagonal elements in decreasing order. U and V are unitary matrices and frd objects, such that X = U*S*V'. For more information, see the built in svd command for more details.
See Also
schur svd
Constructs a Schur decomposition Constructs a singular value decomposition
10-318
symdec
10symdec
Form a symmetric matrix

x = symdec(m,n)
symdec(m,n) forms an m-by-m symmetric matrix of the form (n + 1) (n + 2) (n + 4) (n + 2) (n + 3) (n + 5) (n + 4) (n + 5) (n + 6)
This function is useful to define symmetric matrix variables. n is the number of decision variables.
See Also
decinfo
Show how matrix variables depend on decision variables
10-319
sysic
10sysic
Build interconnections of certain and uncertain matrices and systems.

sysout = sysic sysic requires that 3 variables with fixed names are present in the calling workspace: systemnames, inputvar and outputvar. systemnames is a char, containing the names of the subsystems (double, tf, zpk, ss, uss, frd, ufrd, etc) that comprise the interconnection. The names
must be separated by spaces with no additional punctuation. Each named variable must exist in the calling workspace.
inputvar is a char, defining the names of the external inputs to the interconnection. The names are separated by semicolons, and the entire list is enclosed in square brackets [ ]. Inputs can be scalar or multivariate. For instance, a 3-component (x,y,z) force input can be specified with 3 separate names, Fx, Fy, Fz. Alternatively, a single name with a defined integer dimension can be specified, as in F{3}. The order of names in inputvar determines the order of inputs in the interconnection. outputvar is a char, describing the outputs of the interconnection. Outputs do
not have names they are simply linear combinations of individual subsystems outputs and external inputs. Semicolons delineate separate components of the interconnections outputs. Between semicolons, signals can be added and subtracted, and multiplied by scalars. For multivariable subsystems, arguments within parentheses specify which subsystem outputs are to be used and in what order. For instance plant(2:4,1,9:11) specifies outputs 2,3,4,1,9,10,11 from the subsystem plant. If a subsystem is listed in outputvar without arguments, then all outputs from that subsystem are used.
sysic also requires that for every subsystem name listed in systemnames, a corresponding variable, input_to_ListedSubSystemName must exist in the calling workspace. This variable is similar to outputvar it defines the input signals to this particular subsystem as linear combinations of individual subsystems outputs and external inputs. sysout = sysic will perform the interconnection described by the variables above, using the subsystem data in the names found in systemnames. The
10-320
sysic
resulting interconnection will be returned in the output argument, listed above as sysout.
Example
A simple system interconnection, identical to the system illustrated in the iconnect description. Consider a three-input, two-output LTI matrix T,
y1 y2
noise deltemp setpoint
which has internal structure

y1 y2
57.3
g; g + 6 +
wt act
deltemp
6 + noise k
setpoint
P = rss(3,2,2); K = rss(1,1,2); A = rss(1,1,1); W = rss(1,1,1); systemnames = 'W A K P'; inputvar = '[noise;deltemp;setpoint]'; outputvar = '[57.3*P(1);setpoint-P(2)]'; input_to_W = '[deltemp]'; input_to_A = '[K]'; input_to_K = '[P(2)+noise;setpoint]'; input_to_P = '[W;A]'; T = sysic;
10-321
sysic
Limitations
The syntax of sysic is limited, and for the most part is restricted to what is shown here. The iconnect interconnection object can also be used to define complex interconnections, and has a more flexible syntax. Within sysic, error-checking routines monitor the consistency and availability of the subsystems and their inputs. These routines provide a basic level of error detection to aid the user in debugging.
See Also
iconnect
Equates expressions for icsignal objects
10-322
ucomplex
Purpose Syntax
10ucomplex
Create an uncertain complex parameter

A = ucomplex('NAME',nominalvalue) A = ucomplex('NAME',nominalvalue,'Property1',Value1,... 'Property2',Value2,...)
Description
An uncertain complex parameter is used to represent a complex number whose value is uncertain. Uncertain complex parameters have a name (the Name property), and a nominal value (the NominalValue property). The uncertainty (potential deviation from the nominal value) is described in two different manners: Radius (radius of disc centered at NominalValue) Percentage (disc size is percentage of magnitude of NominalValue) The Mode property determines which description remains invariant if the NominalValue is changed (the other is derived). The default Mode is 'Radius' and the default radius is 1. Property/Value pairs may also specified upon creation. For instance, B = ucomplex('B',6-j,'Percentage',25) sets the nominal value to 6-j, the percentage uncertainty to be 25 and, implicitly, the Mode to 'Percentage'.
Example
Create an uncertain complex parameter with internal name A. The uncertain parameters possible values are a complex disc of radius 1, centered at 4+3j. The value of A.percentage is 20 (radius is 1/5 of the magnitude of the nominal value).
A = ucomplex('A',4+3*j) Uncertain Complex Parameter: Name A, NominalValue 4+3i, Radius 1
You can visualized the uncertain complex parameter by sampling and plotting the data.
sa = usample(A,400); w = linspace(0,2*pi,200); circ = sin(w) + j*cos(w); rc = real(A.NominalValue+circ);
10-323
ucomplex
ic = imag(A.NominalValue+circ); plot(real(sa(:)),imag(sa(:)),'o',rc,ic,'k-') xlim([2.5 5.5]) ylim([1.5 4.5]) axis equal

Sampled complex parameter A 4.5
3.5
2.5
1.5
2.5
3.5
4.5
5.5
See Also
get umat ucomplexm ultidyn ureal
Gets object properties Creates an uncertain matrix object Creates an uncertain complex matrix Creates an uncertain LTI dynamic object Creates an uncertain real parameter
10-324
ucomplexm
Purpose Syntax
10ucomplexm
Create uncertain complex matrix

M = ucomplexm('Name',NominalValue) M = ucomplexm('Name',NominalValue,'WL',WLvalue,'WR',WRvalue) M = ucomplexm('Name',NominalValue,'Property',Value) M = ucomplexm('Name',NominalValue) creates an uncertain complex matrix represents a ball of complex-valued matrices, centered at a NominalValue and named Name. M = ucomplexm('Name',NominalValue,'WL',WLvalue,'WR',WRvalue) creates an uncertain complex matrix with weights WL and WR. Specifically, the values represented by M are all matrices H which satisfy norm(inv(M.WL)*(H M.NominalValue)*inv(M.WR)) <= 1. WL and WR are square, invertible, and
Description
weighting matrices that quantify the size and shape of the ball of matrices represented by this object. The default values for WL and WR are identity matrices of appropriate dimensions. Trailing Property/Value pairs are allowed, as in
M = ucomplexm('NAME',nominalvalue,'P1',V1,'P2',V2,...)
The property AutoSimplify controls how expressions involving the uncertain matrix are simplified. Its default value is 'basic', which means elementary methods of simplification are applied as operations are completed. Other values for AutoSimplify are 'off'', no simplification performed, and 'full' which applies model-reduction-like techniques to the uncertain object.
Example
Create a ucomplexm with the name 'F', nominal value [1 2 3; 4 5 6], and weighting matrices WL = diag([.1.3]), WR = diag([.4 .8 1.2]).
F = ucomplexm('F',[1 2 3;4 5 6],'WL',diag([.1 .3]),... 'WR',diag([.4 .8 1.2]));
Sample the difference between the uncertain matrix and its nominal value at 80 points, yielding a 2-by-3-by-80 matrix typicaldev.
typicaldev = usample(F-F.NominalValue,40);
Plot histograms of the deviations in the (1,1) entry as well as the deviations in the (2,3) entry.
10-325
ucomplexm
The absolute value of the (1,1) entry and the (2,3) entry are shown by histogram plots. Typical deviations in the (1,1) entry should be about 10 times smaller than the typical deviations in the (2,3) entry.
subplot(2,1,1); hist(abs(typicaldev(1,1,:)));xlim([0 .25]) title('Sampled F(1,1) - F(1,1).NominalValue') subplot(2,1,2); hist(abs(typicaldev(2,3,:)));xlim([0 .25]) title('Sampled F(2,3) - F(2,3).NominalValue')
Sampled F(1,1) F(1,1).NominalValue 12 10 8 6 4 2 0 0 0.05 0.1 0.15 0.2 0.25
Sampled F(2,3) F(2,3).NominalValue 20
15
10
0.05
0.1
0.15
0.2
0.25
See Also
get umat ucomplem ultidyn ureal
Gets object properties Creates an uncertain matrix object Creates an uncertain complex parameter Creates an uncertain LTI dynamic object Creates an uncertain real parameter
10-326
udyn
10udyn
Create an unstructured uncertain dynamic system object.

n = udyn('name',iosize); n = udyn('name',iosize) creates an unstructured uncertain dynamic system class, with input/output dimension specified by iosize. This object represents
the class of completely unknown multivariable, time-varying nonlinear systems. For practical purposes, these uncertain elements represent noncommuting symbolic variables (placeholders). All algebraic operations, such as addition, subtraction, multiplication (i.e., cascade) operate properly, and substitution (with usubs) is allowed. The analysis tools (e.g., robuststab) do not currently handle these types of uncertain elements. As such, these elements do not provide a significant amount of usability, and their role in the toolbox is small.
Example
You can create a 2-by-3 udyn element and check its size and properties.
N = udyn('N',[2 3]) Uncertain Dynamic System: Name N, size 2x3 size(N) ans = 2 3 get(N) Name: 'N' NominalValue: [2x3 double] AutoSimplify: 'basic'
See Also
ureal ultidyn ucomplex ucomplexm
Creates an uncertain real parameter Creates an uncertain linear time-invariant object Creates an uncertain complex parameter Creates an uncertain complex matrix
10-327
ufrd
Purpose Syntax
Create an uncertain frequency response data (ufrd) object, or convert another model type to a ufrd model.
usysfrd = ufrd(usys,frequency) usysfrd = ufrd(usys,frequency,'Units',units) usysfrd = ufrd(sysfrd) usys = ufrd(response,frequency) usys = ufrd(response,frequency,Ts) usys = ufrd(response,frequency,RefSys) usys = ufrd(response,frequency,'Units',units,Ts) usys = ufrd(response,frequency,'Units',units,Ts,RefSys)
10ufrd
Description
Uncertain frequency response data (ufrd) models results from the conversion of an uncertain state-space (uss) system to its uncertain frequency response. ufrd models also result when frequency response data models (frd) are combined with uncertain matrices (umat).
usysfrd = ufrd(usys,frequency,'Units',units) converts a uss model usys to a ufrd model usysfrd by frequency response.'Units' specifies the units of the frequencies in frequency, which may be 'rad/s' or 'Hz'. If the last two arguments are omitted, the default for frequency units is 'rad/s'.
Any of the previous syntaxes can be followed by property name/property value pairs.
usysfrd = ufrd(usys,frequency,'Units',units,'P1',V1,'P2',V2,...) set the properties P1, P2, ... to the values V1, V2, ... usys = ufrd(response,frequency) creates a ufrd from the response and frequency arguments. response should be a umat array, whose 1st array dimension (i.e., size(response,3)) aligns with the frequency. Note that you
are unlikely to use this option.

usysfrd = ufrd(sysfrd) converts an frd model sysfrd to a ufrd model usysfrd with no uncertain elements.
Example
In the first example, you create a continuous-time uncertain system with both parametric uncertainty and unmodeled dynamics uncertainty. Compute the uncertain frequency response, and plot the Bode plot, using 20 random samples, and a color choice of red for random samples, and blue for nominal.
10-328
ufrd
p1 = ureal('p1',5,'Range',[2 6]); p2 = ureal('p2',3,'Plusminus',0.4); p3 = ultidyn('p3',[1 1]); Wt = makeweight(.15,30,10); A = [-p1 0;p2 -p1]; B = [0;p2]; C = [1 1]; usys = uss(A,B,C,0)*(1+Wt*p3); usysfrd = ufrd(usys,logspace(-2,2,60)); bode(usysfrd,'r',usysfrd.NominalValue,'b+')
Example 2
Convert a not-uncertain frd model to ufrd without uncertainties. Verify that the equality of the nominal value and simplified representation to the original system.
G = frd(tf([1 2 3],[1 2 3 4]),logspace(-2,2,40)); usys = ufrd(G) UFRD: 1 Output, 1 Input, Continuous System, 40 Frequency points isequal(usys.NominalValue,G) ans = 1 isequal(simplify(usys,'class'),G) ans = 1
See Also
frd ss
Creates or converts to frequency response data model Creates or converts to state-space model
10-329
ultidyn
Purpose Syntax
10ultidyn
Create an uncertain linear time-invariant object.

H = ultidyn('Name',iosize) H = ultidyn('Name',iosize,'Property1',Value1,'Property2',Value2,...) H = ultidyn('Name',iosize) creates an uncertain linear, time-invariant objects are used to represent unknown dynamic objects, whose only known attributes are bounds on their frequency response. Uncertain linear, time-invariant objects have a name (the Name property), and an input/output size (ioSize property).
Description
The property Type is 'GainBounded' (default) or 'PositiveReal', and describes in what form the knowledge about the objects frequency response is specified. If Type is 'GainBounded', then the knowledge is a upper bound on the magnitude (ie., absolute value), namely abs(H)<= Bound at all frequencies. The matrix generalization of this is ||H||<= Bound. If Type is 'PositiveReal' then the knowledge is a lower bound on the real part, namely Real(H) >= Bound at all frequencies. The matrix generalization of this is H+H' >= 2*Bound; The property Bound is a real, scalar, which quantifies the bound on the frequency response of the uncertain object as described above. Trailing Property/Value pairs are allowed in the construction.
H=ultidyn('name',iosize,'Property1',Value1,'Property2',Value2,...)
The property SampleStateDim is a positive integer, defining the state dimension of random samples of the uncertain object when sampled with usample. The default value is 1. The property AutoSimplify controls how expressions involving the uncertain matrix are simplified. Its default value is 'basic', which means elementary methods of simplification are applied as operations are completed. Other values for AutoSimplify are 'off'', no simplification performed, and 'full' which applies model-reduction-like techniques to the uncertain object.
10-330
ultidyn
Example
Example 1
Create a ultidyn object with internal name 'H', dimension 2-by-3, norm bounded by 7.
H = ultidyn('H',[2 3],'Bound',7) Uncertain GainBounded LTI Dynamics: Name H, 2x3, Gain Bound = 7
Example 2
Create a scalar ultidyn object with an internal name 'B', whose frequency response has a real part greater than 2.5. Change the SampleStateDim to 5, and plot the Nyquist plot of 30 random samples.
B = ultidyn('B',[1 1],'Type','PositiveReal','Bound',2.5) Uncertain PositiveReal LTI Dynamics: Name B, 1x1, M+M' >= 2*(2.5) B.SampleStateDim = 5; nyquist(usample(B,30))
30 Nyquist Diagram
20
10
Imaginary Axis
10
20
30 10
10
20 Real Axis
30
40
50
60
See Also
get ureal uss
Gets object properties Creates an uncertain real parameter Creates an uncertain LTI system object
10-331
umat
10umat
Uncertain matrices
h = umat(m)
Uncertain matrices are usually created by manipulation of uncertain atoms (ureal, ucomplex, ultidyn, etc), double matrices and other uncertain matrices. Most standard matrix manipulations are valid, including addition, multiplication, inverse, horizontal and vertical concatenation. Specific rows/columns of a uncertain matrix can be referenced and assigned. The command umat is rarely used. There are two situations where it may be useful. If M is a double, then H = umat(M) recasts M as an uncertain matrix (UMAT object) without any uncertainties. Similarly, if M is an uncertain atom, then H = umat(M) recasts M as an uncertain matrix (UMAT object) whose value is merely the uncertain atom. In both cases, simplify(H,'class') is the same as M. If M is a umat, then M.NominalValue is the result obtained by replacing each uncertain atom in M with its own nominal value. If M is a umat, then M.Uncertainty is an object describing all of the uncertain atoms in M. All atoms can be referenced, and their properties modified with this Uncertainty gateway. For instance, if B is an uncertain real parameter in M, then M.Uncertainty.B accesses the uncertain atom B in M.
Example
Create 3 uncertain atoms, and then a 3-by-2 umat.

a = ureal('a',5,'Range',[2 6]); b = ucomplex('b',1+j,'Radius',0.5); c = ureal('c',3,'Plusminus',0.4); M = [a b;b*a 7;c-a b^2] UMAT: 3 Rows, 2 Columns a: real, nominal = 5, range = [2 6], 1 occurrence b: complex, nominal = 1+1i, radius = 0.5, 4 occurrences c: real, nominal = 3, variability = [-0.4 0.4], 1 occurrence
View the properties of M with get

get(M) NominalValue: [3x2 double] Uncertainty: [1x1 atomlist]
10-332
umat
The nominal value of M is the result when all atoms are replaced by their nominal values. View the properties of M with get
M.NominalValue ans = 5.0000 5.0000 + 5.0000i -2.0000
1.0000 + 1.0000i 7.0000 0 + 2.0000i
Change the nominal value of a within M to 4. The nominal value of M reflects this change.
M.Uncertainty.a.NominalValue = 4; M.NominalValue ans = 4.0000 1.0000 + 1.0000i 4.0000 + 4.0000i 7.0000 -1.0000 0 + 2.0000i
Get a random sample of M, obtained by taking random samples of the uncertain atoms within M.
usample(M) ans = 2.0072 1.7358 + 2.7808i 1.3829
0.8647 + 1.3854i 7.0000 -1.1715 + 2.3960i
Select the 1st and 3rd rows, and 2nd column of M. The result is a 2-by-1 umat, whose dependence is only on b.
M([1 3],2) UMAT: 2 Rows, 1 Columns b: complex, nominal = 1+1i, radius = 0.5, 3 occurrences
See Also
ureal ultidyn ucomplex ucomplexm usample
Creates an uncertain real parameter Creates an uncertain linear time-invariant object Creates an uncertain complex parameter Creates an uncertain complex matrix Generates random samples of an uncertain object
10-333
uplot
Purpose Syntax
10uplot
Plot multiple frequency response objects and doubles on the same graph
uplot(G1) uplot(G1,G2) uplot(G1,Xdata,Ydata) uplot(G1,Xdata,Ydata,...) uplot(G1,linetype) uplot(G1,linetype,G2,...) uplot(G1,linetype,Xdata,Ydata,linetype) uplot(type,G1,linetype,Xdata,Ydata,linetype) H = uplot(G1) H = uplot(G1,G2) H = uplot(G1,Xdata,Ydata) H = uplot(G1,Xdata,Ydata,...) H = uplot(G1,linetype) H = uplot(G1,linetype,G2,...) H = uplot(G1,linetype,Xdata,Ydata,linetype)
Description
uplot plots double and frd objects. The syntax is the same as the MATLAB plot command except that all data is contained in frd objects, and the axes are specified by type. The (optional) type argument must be one of:
Type 'iv,d' 'iv,m' 'iv,lm' 'iv,p' 'liv,m' 'liv,d' 'liv,m' Description
data versus independent variable (default) magnitude versus independent variable

log(magnitude) versus independent variable
phase versus independent variable magnitude versus log(independent variable) data versus log(independent variable) magnitude versus log(independent variable)
10-334
uplot
Type 'liv,lm' 'liv,p' 'r,i'
Description log(magnitude) versus log(independent variable)
phase versus log(independent variable) real versus imaginary (parametrize by independent variable) real versus imaginary (parametrize by independent variable) Nicholas plot Bode magnitude and phase plot
'nyq'
'nic' 'bode'
The remaining arguments of uplot take the same form as the MATLAB plot command. Line types (for example,'+', 'g-.', or '*r') can be optionally specified after any frequency response argument. There is a subtle distinction between constant and frd objects with only one independent variable. A constant is treated as such across all frequency, and consequently shows up as a line on any graph with the independent variable as an axis. A frd object with only one frequency point will always show up as a point. You may need to specify one of the more obvious point types in order to see it (e.g., '+', 'x', etc.).
Example
Two SISO second-order systems are created, and their frequency responses are calculated for each over different frequency ranges.
a1 = [-1,1;-1,-0.5]; b1 = [0;2]; c1 = [1,0]; d1 = 0; sys1 = ss(a1,b1,c1,d1); a2 = [-.1,1;-1,-0.05]; b2 = [1;1]; c2 = [-0.5,0]; d2 = 0.1; sys2 = ss(a2,b2,c2,d2); omega = logspace(-2,2,100); sys1g = frd(sys1,omega); omega2 = [ [0.05:0.1:1.5] [1.6:.5:20] [0.9:0.01:1.1] ]; omega2 = sort(omega2); sys2g = frd(sys2,omega2);
10-335
uplot
A frd object with a single frequency is also created. Note the distinction between the frd object and the constant matrix in the subsequent plots.
sys3 = rss(1,1,1); rspot = frd(sys3,2);
The following plot uses the 'liv,lm' plot_type specification.

uplot('liv,lm',sys1g,'b-.',rspot,'r*',sys2g); xlabel('log independent variable') ylabel('log magnitude') title('axis specification: liv,lm')
10
1
axis specification: liv,lm
10
log magnitude
10
10
10
10
10
10
10
10
10
log independent variable
See Also
bode plot nichols nyquist semilogx semilogy sigma
Plots Bode frequency response Plots on linear axis Plots Nichols frequency response Plots Nyquist frequency response Plots semi-log scale plot Plots semi-log scale plot Plots singular values of a LTI system
10-336
ureal
Purpose Syntax
10ureal
Create an uncertain real parameter.

p = ureal('name',nominalvalue) p = ureal('name',nominalvalue,'Property1',Value1,... 'Property2',Value2,...)
Description
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 (NominalValue property). The uncertainty (potential deviation from NominalValue) is described (equivalently) in 3 different properties: PlusMinus: the additive deviation from NominalValue Range: the interval containing NominalValue Percentage: the percentage deviation from NominalValue The Mode property specifies which one of these 3 descriptions remains unchanged if the NominalValue is changed (the other two descriptions are derived). The possible values for the Mode property are 'Range', 'Percentage' or 'PlusMinus'. The default Mode is 'PlusMinus', and [-1 1] is the default value for the 'PlusMinus' property. The range of uncertainty need not be symmetric about NominalValue. The property AutoSimplify controls how expressions involving the uncertain matrix are simplified. Its default value is 'basic', which means elementary methods of simplification are applied as operations are completed. Other values for AutoSimplify are 'off'', no simplification performed, and 'full' which applies model-reduction-like techniques to the uncertain object.
Example
Example 1
Create an uncertain real parameter and use get to display the properties and their values. Create uncertain real parameter object a with the internal name 'a' and nominal value 5.
a = ureal('a',5) Uncertain Real Parameter: Name a, NominalValue 5, variability = [-1 1]
10-337
ureal
get(a) Name: NominalValue: Mode: Range: PlusMinus: Percentage: AutoSimplify: 'a' 5 'PlusMinus' [4 6] [-1 1] [-20 20] 'basic'
Note that the Mode is 'PlusMinus', and that value of PlusMinus is indeed [-1 1]. As expected, the range description of uncertainty is [4 6], while percentage description of uncertainty is [-20 20]. Set the range to [3 9]. This leaves Mode and NominalValue unchanged, but all three descriptions of uncertainty have been modified.
a.Range = [3 9]; get(a) Name: NominalValue: Mode: Range: PlusMinus: Percentage: AutoSimplify:
'a' 5 'PlusMinus' [3 9] [-2 4] [-40 80] 'basic'
Example 2
Property/Value pairs may also specified upon creation.
b = ureal('b',6,'Percentage',[-30 40],'AutoSimplify','full'); get(b) Name: 'b' NominalValue: 6 Mode: 'Percentage' Range: [4.2000 8.4000] PlusMinus: [-1.8000 2.4000] Percentage: [-30.0000 40.0000] AutoSimplify: 'full'
Note that Mode is automatically set to 'Percentage'.
10-338
ureal
Example 3
Specify the uncertainty in terms of percentage, but force Mode to 'Range'.
c = ureal('c',4,'Mode','Range','Percentage',25); get(c) Name: 'c' NominalValue: 4 Mode: 'Range' Range: [3 5] PlusMinus: [-1 1] Percentage: [-25 25] AutoSimplify: 'basic'
See Also
ucomplex umat uss
Creates an uncertain complex parameter Creates an uncertain matrix Creates an uncertain, linear dynamic object
10-339
usample
Purpose Syntax
10usample
Generate random samples of an uncertain object.

B = usample(A); B = usample(A,N) [B,SampleValues] = usample(A,N) [B,SampleValues] = usample(A,Names,N) [B,SampleValues] = usample(A,Names1,N1,Names2,N2,...) B = usample(A) substitutes a random sample of the uncertain objects in A, returning a certain (ie., not uncertain) array of size [size(A)]. B = usample(A,N) substitutes N random samples of the uncertain objects in A, returning a certain (ie., not uncertain) array of size [size(A) N]. [B,SampleValues] = usample(A,N) additionally returns the specific sampled values (as a Struct whose fieldnames are the names of As uncertain elements) of the uncertain elements. Hence, B is the same as usubs(A,SampleValues). [B,SampleValues] = usample(A,Names,N) samples only the uncertain elements listed in the Names variable (cell, or char array). If Names does not include all of the uncertain objects in A, then B will be an uncertain object. Any entries of Names that are not elements of A are simply ignored. Note that usample(A,fieldnames(A.Uncertainty),N) is the same as usample(A,N). [B,SampleValues] = usample(A,Names1,N1,Names2,N2,...) takes N1 samples of the uncertain elements listed in Names1, and N2 samples of the uncertain elements listed in Names2 and so on. size(B) will equal [size(A) N1 N2 ...].
Description
Example
Sample a real parameter, and plot a histogram

A = ureal('A',5); Asample = usample(A,500); size(A) ans = 1 1 size(Asample) ans = 1 1 500 class(Asample) ans =
10-340
usample
double hist(Asample(:))
The second example illustrates the open and closed-loop response of an uncertain plant model. You can create two uncertain real parameters, and an uncertain plant.
gamma = ureal('gamma',4); tau = ureal('tau',.5,'Percentage',30); P = tf(gamma,[tau 1]);
Create an integral controller based on nominal plant parameters

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

CLP = feedback(P*C,1);
You can sample the plant at 20 values (distributed uniformly about the tau and gamma parameter cube).
[Psample1D,Values1D] = usample(P,20); size(Psample1D)
10-341
usample
20x1 array of state-space models Each model has 1 output, 1 input, and 1 state.
You can sample the plant, P, at 10 values in the tau parameter, and 15 values in the gamma parameter.
[Psample2D,Values2D] = usample(P,'tau',10,'gamma',15); size(Psample2D) 10x15 array of state-space models Each model has 1 output, 1 input, and 1 state.
You can plot the 1-D sampled plant step responses

subplot(2,1,1); step(Psample1D)
You can also evaluate the uncertain closed-loop at the same values, and plot the step response using usubs.
subplot(2,1,2); step(usubs(CLP,Values1D))
Step Response
6 5 4 Amplitude 3 2 1 0
0.5
1.5
2 Time (sec)
2.5
3.5
1.5
Step Response
1 Amplitude 0.5 0 0
4 Time (sec)
See Also
usubs
Substitutes values for uncertain atoms
10-342
uss
Purpose Syntax
10uss
Specify uncertain state space models or convert a LTI model to an uncertain state space model.
usys usys usys usys usys usys = = = = = = uss(a,b,c,d) uss(a,b,c,d,Ts) uss(d) uss(a,b,c,d,Property,Value,...) uss(a,b,c,d,Ts,Property,Value,...) uss(sys)
Description
uss is used to create uncertain state-space models (uss objects) or to convert LTI models to the uss class. usys = uss(a,b,c,d) creates a continuous-time uncertain state-space object. The matrices a, b, c and d may be umat and/or double and/or uncertain
atoms. These are the 4 matrices associated with the linear differential equation model to describe the system.
usys = uss(a,b,c,d,Ts) creates a discrete-time uncertain state-space object with sampling time Ts. usys = uss(d) specifies a static gain matrix and is equivalent to usys = uss([],[],[],d).
Any of these syntaxes can be followed by property name/property value pairs.

usys = uss(a,b,c,d,'P1',V1,'P2',V2,...) set the properties P1, P2, ... to the values V1, V2, ... usys = uss(sys) converts an arbitrary ss or tf or zpk model sys to an uncertain state space object without uncertainties. Both usys.NominalValue and simplify(usys,'class') are the same as ss(sys).
Example
You can first create 2 uncertain atoms and use them to create two uncertain matrices. These 4 matrices can be packed together to form a 1-output, 1-input, 2-state continuous-time uncertain state space system.
p1 = ureal('p1',5,'Range',[2 6]); p2 = ureal('p2',3,'Plusminus',0.4); A = [-p1 0;p2 -p1]; B = [0;p2];
10-343
uss
C = [1 1]; usys = uss(A,B,C,0);
In the second example, you can convert a not-uncertain tf model to an uncertain state-space model without uncertainties. Verify that the equality of the nominal value and simplified representation to the original system.
G = tf([1 2 3],[1 2 3 4]); usys = uss(G) USS: 3 States, 1 Output, 1 Input, Continuous System isequal(usys.NominalValue,ss(G)) ans = 1 isequal(simplify(usys,'class'),ss(G)) ans = 1
See Also
frd ss
Creates or converts to frequency response data model Creates or converts to state-space model
10-344
usubs
Purpose Syntax
10usubs
Substitute given values for uncertain elements of uncertain objects

B = usubs(M,atomname1,value1,atomname2,value2,...) B = usubs(M,{atomname1;atomname2;...},{value1;value2;...}) B = usubs(M,StrucArray) usubs is used to substitute a specific value for an uncertain element of an
Description
uncertain object. The value may itself be uncertain. It needs to be the correct size, but otherwise can be of any class, and can be an array. Hence, the result may be of any class. In this manner, uncertain elements act as symbolic placeholders, for which specific values (which may contain other placeholders too) can be substituted.
B = usubs(M,atomname1,value1,atomname2,value2,...) sets the atoms in M, identified by atomname1, atomname2, etc., to the values in value1, value2, etc.
respectively.
B = usubs(M,ElementName1,value1,ElementName2,value2,...) sets the elements in M, identified by ElementName1, ElementName2, etc., to the values in value1, value2, etc. respectively.
The names and values can also be grouped in Cell Arrays, as B = usubs(M,atomname1,value1,...) In this case, if the value cell is 1-by-1, then that value is substituted for all of the listed atoms. For this situation, it is not required that value be in a cell array.
value can also be the strings 'NominalValue' or 'Random' (or specified only partially) in which case the nominal value, or a random instance of the atom is used.
Combinations of the above syntaxs is also allowed, so that B = usubs(M,{atomname1;atomname2},{value1;value2}) is allowed. The names and values can also be grouped in a structure, with its fieldnames constituting the Names, and the field values constituting the Values. In the following function call, StrucArray is a structure with fieldnames and values.
10-345
usubs
B = usubs(M,StrucArray) Robustness analysis commands, such as wcnorm, wcgain and robuststab return the offending uncertain element values in this manner. usample, which randomly samples uncertain objects also returns the sample points in this manner.
Example
Create an uncertain matrix, and perform identical substitution in two different manners.
p = ureal('p',5); m = [1 p;p^2 4]; size(m) ans = 2 2 m1 = usubs(m,'p',5) m1 = 1 5 25 4 NamesValues.p = 5; m2 = usubs(m,NamesValues) m2 = 1 5 25 4 m1 - m2 ans = 0 0 0 0
You can make an array-valued substitution using the structure-based syntax,

NamesValues.p = rand(1,1,6); m3 = usubs(m,NamesValues); % 2-by-2-by-6 size(m3) ans = 2 2 6
You can use usubs to substitute for individual uncertainties. Create 3 uncertain real parameters, and form a simple 2-by-2 uncertain matrix with the parameters
a = ureal('a',5); b = ureal('b',3); c = ureal('c',1);
10-346
usubs
m = [a b;c a*b*c];
You can perform a single parameter substitution, and check the results
m1 = usubs(m,'a',10); simplify(m1(1,1)) ans = 10 simplify(10*m1(1,2)*m1(2,1) - m1(2,2)) ans = 0
You can substitute one real parameter with a transfer function, and other parameters with DOUBLES. You can do this using two different forms of the syntax, and check that the results are identical.
m2 = usubs(m,'a',tf([5],[1 1]),'b',2.6,'c',1.3); nv.a = tf([5],[1 1]); nv.b = 2.6; nv.c = 1.3; m3 = usubs(m,nv); norm(m2-m3,'inf') ans = 0
In m, substitute 'a' with 'b', obtaining 'b' directly from m

m4 = usubs(m,'a',m.Uncertainty.b);
See Also
gridureal usample simplify
Grids uncertain real parameters over their range Generates random samples of an atom Simplify representation of uncertain objects
10-347
wcgain
10wcgain
Calculates bounds on the worst-case gain of an uncertain system.

[maxgain,wcu,info] = wcgain(sys) [maxgain,wcu,info] = wcgain(sys,opts)
The gain of an uncertain system will generally be depend on the values of its uncertain elements. Here gain refers to the frequency response magnitude. Determining the maximum gain over all allowable values of the uncertain elements is referred to as a worst-case gain analysis. This maximum gain is called the worst-case gain. The following figure shows the frequency response magnitude of many samples of an uncertain system model.
10
1
Various sample responses
10
Magnitude
10
1
Nominal Response
10
10
10
10
10
10
Frequency
wcgain can perform two types of analysis on uncertain systems.
10-348
wcgain
A pointwise-in-frequency worst-gain analysis yields the frequency-dependent curve of maximum gain, shown in the figure below.
10
1
Maximum Gain pointwise across frequency
10
Magnitude
10
WorstCase gain degradation from nominal
10
10
10
10
10
10
Frequency
This plot shows the maximum frequency-response magnitude at each frequency due to the uncertain elements within the model. A peak-over-frequency worst-gain analysis only aims to compute the largest value of frequency-response magnitude across all frequencies. During such
10-349
wcgain
an analysis, large frequency ranges can be quickly eliminated from consideration, thus reducing the computation time.
10
1
WorstCase Gain, peakacrossfrequency
10
Magnitude
10
Nominal
10
10
10
10
10
10
Frequency
The default analysis performed by wcgain is (peak-over-frequency). You can control which analysis is performed using the wcgopt options object. For multi-input, multi-output systems, the gain is the maximum singular value of the frequency response matrix. As with other uncertain-system analysis tools, only bounds on the worst-case gain are computed. The exact value of the worst-case gain is guaranteed to lie between these upper and lower bounds. The computation used in wcgain is a frequency-domain calculation. If the input system sys is an uncertain frequency response object (ufrd), then the analysis is performed on the frequency grid within the ufrd. If the input system sys is an uncertain state space object (uss), then an appropriate frequency grid is generated (automatically), and the analysis performed on that frequency grid. In all descriptions below, N denotes the number of points in the frequency grid.
Basic syntax
Suppose sys is an ufrd or uss with M uncertain elements. The results of
10-350
wcgain
[maxgain,maxgainunc] = wcgain(sys) maxgain is a structure with the following fields Field LowerBound UpperBound Description
Lower bound on worst-case gain, positive scalar. Upper bound on worst-case gain, positive scalar. If the nominal value of the uncertain system is unstable, then maxgain.LowerBound and maxgain.UpperBound equal . The critical value of frequency at which maximum gain occurs (this is associated with maxgain.LowerBound).
CriticalFrequency
maxgainunc is a structure containing values of uncertain elements which
maximize the system gain. There are M fieldnames, which are the names of uncertain elements of sys. The value of each field is the corresponding value of the uncertain element, such that when jointly combined, lead to the gain value in maxgain.LowerBound. The command
norm(usubs(sys,maxgainunc),'inf')
shows the gain.
Example
Create a plant with nominal model of an integrator, and include additive unmodeled dynamics uncertainty of a level of 0.4 (this corresponds to 100% model uncertainty at 2.5 rad/s). Design a proportional controller K1 which puts the nominal closed-loop bandwidth at 0.8 rad/sec. Roll-off K1 at a frequency 25 times the nominal closed-loop bandwidth. Repeat the design for a controller K2 which puts the nominal closed-loop bandwidth at 2.0 rad/sec. In each case, form the closed-loop sensitivity function.
P = tf(1,[1 0]) + ultidyn('delta',[1 1],'bound',0.4); BW1 = 0.8; K1 = tf(BW1,[1/(25*BW1) 1]); S1 = feedback(1,P*K1);
10-351
wcgain
BW2 = 2.0; K2 = tf(BW2,[1/(25*BW2) 1]); S2 = feedback(1,P*K2);
Assess the worst-case gain of the closed-loop sensitivity function.

[maxgain1,wcunc1] = wcgain(S1); [maxgain2,wcunc2] = wcgain(S2); maxgain1 maxgain1 = LowerBound: 1.5070e+000 UpperBound: 1.5080e+000 CriticalFrequency: 5.3096e+000 maxgain2 maxgain2 = LowerBound: 5.1024e+000 UpperBound: 5.1034e+000 CriticalFrequency: 1.0215e+001
The maxgain variables indicate that controller K1 achieves better worst-case performance than K2. Plot Bode magnitude plots of the nominal closed-loop sensitivity functions, as well as the worst instances, using usubs to replace the uncertain element with the worst value returned by wcgain.
bodemag(S1.Nom,'r--',usubs(S1,wcunc1),'r',...
10-352
wcgain
S2.Nom,'b--',usubs(S2,wcunc2),'b')
10
1
Bode Diagram
10
Magnitude (abs)
10
1
Nominal S1 WorstCase S1 Nominal S2 WorstCase S2 10

2
10
10
10
10
Note that although the nominal closed-loop sensitivity resulting from K2 is superior to that with K1, the worst-case behavior is much worse.
Basic syntax with 3rd output argument

A 3rd output argument yields more specialized information, including sensitivities of the worst-case gain to the uncertain elements ranges and frequency-by-frequency information.
[maxgain,maxgainunc,info] = wcgain(sys)
10-353
wcgain
The 3rd output argument info is a structure with the following fields
A struct with M fields, fieldnames are names of uncertain elements of sys. Values of fields are positive numbers, each entry indicating the local sensitivity of the worst-case gain in maxgain.LowerBound to all of the individual uncertain elements uncertainty ranges. For instance, a value of 25 indicates that if the uncertainty range is enlarged by 8%, then the worst-case gain should increase by about 2%. If the Sensitivity property of the wcgopt object is 'off', the values are NaN. N1 frequency vector associated with analysis. 1-by-1 scalar matrix, value is 1. In more complicated situations (described later) the value of this field will be dependent on the input data.
Frequency ArrayIndex
Options (eg., turning on/off the sensitivity computation, setting the step-size in the sensitivity computation, adjusting the stopping criteria, and controlling behavior across frequency and array dimensions) can be specified using the worst-case gain analysis options wcgopt object. For instance, you can turn the sensitivity calculation off by executing
opt = wcgopt('Sensitivity','off'); [maxgain,maxgainunc,info] = wcgain(sys,opt)
Advanced options: Pointwise-in-Frequency Calculations It is also possible to perform the computation pointwise-in-frequency, determining the worst-case gain at each and every frequency point. To do this, the wcgopt options object must be used.
opt = wcgopt('FreqPtWise',1); [maxgain,maxgainunc,info] = wcgain(sys);
10-354
wcgain
As the calculation is pointwise-in-frequency, many results are N1 cell arrays, often containing scalar information relevant to each particular frequency. maxgain is a structure with the following fields
Lower bound on worst-case gain, positive scalar (frd with N frequency points.) Upper bound on worst-case gain, positive scalar. If the nominal value of the uncertain system is unstable, then maxgain.LowerBound and maxgain.UpperBound equal . (frd with N frequency points.) Scalar. The critical value of frequency at which maximum gain occurs (this is associated with
norm(maxgain.LowerBound,inf)).
UpperBound
CriticalFrequency
maxgainunc is a N1 cell array of values of uncertain elements which maximize the system gain. Each entry of the cell array is a struct, whose M fieldnames are the names of uncertain elements of sys. The maximum singular value of usubs(sys,maxgainunc{k}) at the kth frequency (in info.Frequency(k)) is equal to maxgain.LowerBound{k}. info is a structure with the following fields Field Sensitivity Description
N1 cell, each entry is struct, corresponding to the sensitivities in the worst-case gain at each individual frequency. N1 frequency vector associated with analysis. N1 cell array, each value is the 1-by-1 matrix, whose numerical value is 1. In more complicated situations (described later) the value of this field will be dependent on the input data.
10-355
wcgain
Advanced options: Handling array dimensions If sys has array dimensions, the default behavior is to maximize over all of these dimensions as well. This can be controlled though, and it is also possible to perform the computation pointwise-in-the-array-dimensions, determining the worst-case gain at each and every grid point. Moreover, any combination of peak-over and pointwise-over is allowed. To specify the desired computation, the wcgopt must be used. For concreteness, suppose that sys is a rc758 uncertain system (ie., a 7-by-5-by-8 array of uncertain r output, c input systems). In order to perform the worst-case gain calculation pointwise over the 2nd and 3rd array dimensions (the slot with 5 points and the slot with 8 points), set the ArrayDimPtWise property as follows.
opt = wcgopt('ArrayDimPtWise',[2 3]);
In this case, the worst-case gain calculation is performed pointwise on the 5-by-8 grid, but only the peak value over the first array dimension (the slot with 7 points) is kept track of. For that reason, many of the results will be of dimension 1-by-5-by-8. In general, suppose that the array dimensions of sys are d1dF (758 in the above example). Furthermore, assume that the ArrayDimPtWise property of the wcgopt object has been set to some of the integers between 1 and F. Let e1,e2,,eF denote the dimensions of the array on which the results are computed. By definition, if j is an integer listed in ArrayDimPtWise, then ej=dj (all grid points in slot j are computed), otherwise ej=1 (only the maximum in slot j is computed). In the above example, with ArrayDimPtWise set to [2 3], it follows that e1=1,e2=5,e3=8. Assume FreqPtWise is set to 'off' (well return to that case later below). In this case, the results of
[maxgain,maxgainunc,info] = wcgain(sys,opt)
10-356
wcgain
are: maxgain is a structure with the following fields

1-by-1 frd, with array dimensions e1eF, lower bound on worst-case gain, computed pointwise over all array dimensions listed in ArrayDimPtWise property, and peaked over all others. Upper bound, analogous to LowerBound e1eF array with the critical value of frequency at which maximum gain occurs (this is associated with maxgain.LowerBound).
UpperBound CriticalFrequency
maxgainunc is a e1eF struct, containing values of uncertain elements
which maximize the system gain. There are M fieldnames, which are the names of uncertain elements of sys. The value of each field is the corresponding value of the uncertain element, such that when jointly combined, lead to the gain value in maxgain.LowerBound. The command norm(usubs(sys,maxgainunc),'inf') shows the gain, and should be identical to maxgain.LowerBound (to within tolerance used in norm).
info is a structure with the following fields Field Sensitivity Description
e1eF struct array, each entry is the local sensitivity of the worst-case gain in maxgain.LowerBound to all of the individual uncertain elements uncertainty ranges. N1 frequency vector associated with analysis. At each value in the e1eF grid, there is a corresponding value in the d1dF grid where the maximum occurs. The variable info.ArrayIndexis an e1eF matrix whose value is the single-index representation of the maximizing location in the d1dF grid.
10-357
wcgain
Advanced options: Array dimension handling with FreqPtWise set 'on' The final case involves array dimensions and pointwise-in-frequency calculations. Again, suppose that the array dimensions of sys are d1dF. Furthermore, assume that the ArrayDimPtWise property of the wcgopt object has been set to some of the integers between 1 and F. Let e1,e2,,eF denote the dimensions of the array on which the results are computed. As the calculation is pointwise-in-frequency, many results are N1 cell arrays, often containing e1eF arrays in each cell.
maxgain is a structure with the following fields Field LowerBound Description
N-by-1 cell array, maxgain.LowerBound{k} is a 1-by-1 frd with array dimensions e1eF, and is a lower bound on worst-case gain at frequency info.Frequency(k), computed pointwise over all array dimensions listed in ArrayDimPtWise property, and peaked over all others. Upper bound on worst-case gain, analogous to maxgain.LowerBound. e1eF array with the critical value of frequency at which maximum gain (pointwise over all array dimensions listed in ArrayDimPtWise property, and peaked over all others) occurs.
UpperBound
CriticalFrequency
maxgain.CriticalFrequency e1eF array with the critical value of
frequency at which maximum gain (pointwise over all array dimensions listed in ArrayDimPtWise property, and peaked over all others) occurs.
maxgainunc is a N1 cell array, kth entry is a e1eF struct, containing values of uncertain elements which maximize the system gain at frequency info.Frequency(k).
10-358
wcgain
N1 cell, each entry is the e1eF struct array which holds the local sensitivity of the worst-case gain at one frequency to all of the individual uncertain elements uncertainty ranges. N1 frequency vector associated with analysis. N-by-1 cell array, kth e1eF, at each value in the e1eF grid, there is a corresponding value in the d1dF grid where the maximum occurs. The variable info.ArrayIndex is a e1eF matrix whose value is the single-index representation of the maximizing location in the d1dF grid.
Behavior on not-uncertain systems

wcgain can also be used on not-uncertain systems (eg., ss and frd). If sys is a single ss or frd, then the worst-case gain is simply the gain of the system (identical to norm(sys,'inf')). However, if sys has array dimensions, then the possible combinations of peak-over and pointwise-over can be used to customize the computation.
Algorithm
The worst-case gain is guaranteed to be at least as large as LowerBound (some value of allowable uncertain elements yield this gain one instance is returned in the structure maxgainunc. The frequency at which the gain in LowerBound occurs is in CriticalFrequency. Lower bounds for wcgain are computed using a power iteration on ultidyn, ucomplex and ucomplexm uncertain atoms, (holding uncertain real parameters fixed) and a coordinate aligned search on the uncertain real parameters (while holding the complex blocks fixed). Similarly, the worst-case gain is guaranteed to be no larger than UpperBound. In other words, for all allowable modeled uncertainty, the gain is provably less than or equal to UpperBound. These bounds are derived using upper bound for the structured singular value, which is essentially optimally-scaled, small-gain theorem analysis. Upper bounds are obtained by solving a semidefinite
10-359
wcgain
program. wcgain uses Branch and Bound on the uncertain real parameters to tighten the lower and upper bounds.
Limitations
Because the calculation is carried out with a frequency gridding, it is possible (likely) that the true critical frequency is missing from the frequency vector used in the analysis. This is similar to the problem in robuststab. However, in comparing to robuststab, the problem in wcgain is less acute. Thought of as a function of problem data and frequency, the worst-case gain is a continuous function (unlike the robust stability margin, which in special cases is not see section entitled Regularizing Robust Stability calculations with only ureal uncertain elements in the online documentation). Hence, in worst-case gain calculations, increasing the density of the frequency grid will always increase the accuracy of the answers and in the limit, answers arbitrarily close to the actual answers are obtainable with finite frequency grids.
loopmargin mussv norm robuststab wcgopt wcsens wcmargin
See Also
Comprehensive analysis of feedback loops Calculate bounds on the Structured Singular Value () System norm of an LTI object Calculates stability margins of uncertain systems Creates a wcgain options object Calculates worst-case sensitivities for a feedback loop Calculates worst-case margins for a feedback loop
10-360
wcgopt
Purpose Syntax
10wcgopt
Create an options object for use with wcgain, wcsens, and wcmargin
options = wcgopt options = wcgopt('name1',value1,'name2',value2,...) wcgopt options = wcgopt (with no input arguments) creates an options object with all the properties set to their default values. options = wcgopt('name1',value1,'name2',value2,...) creates a wcgain, wcsens and wcmargin options object called options in which specified properties
Description
have specific values. Any unspecified property is set to its default value. It is sufficient to type only enough leading characters to define the property name uniquely. Case is ignored for property names.
wcgopt with no input or output arguments displays a complete list of option
properties and their default values. The following are the wcgopt object properties:
Object Property Sensitivity Description
Computes margin sensitivity to individual uncertainties. Default is 'on' If LowerBoundOnly is 'on', then only the lower bound computation will be performed. The default value is 'off', which implies that both upper and lower bounds for worst-case gain are computed. Apply stopping criteria based on upper/lower bounds (described below) at every frequency point (as opposed to just the peak value). FreqPtWise=1 activates the pointwise criteria. In order to only compute the peak value to within tolerance, use 0. Default = 0.
LowerBoundOnly
FreqPtWise
10-361
wcgopt
Object Property ArrayDimPtWise
Description
Relevant for uss/ufrd/ss/frd arrays. For indices specified in ArrayDimPtWise, the stopping criteria based on upper/lower bounds (described below) is used at every point in array dimensions specified in ArrayDimPtWise, being applied to the peak value over all other array dimensions. Default = []. If FreqPtWise==1, the computation terminates when at least one of the following four conditions is true at every frequency: UpperBound - LowerBound <= AbsTol UpperBound - LowerBound <= Reltol*UpperBound UpperBound <= AGoodThreshold + MGoodThreshold*Norm(NominalValue)
LowerBound >= ABadThreshold + MBadThreshold*Norm(NominalValue)
If FreqPtWise==0, the computation terminates when any one of the following four conditions is true:
1 PeakUpperBound - PeakLowerBound <= AbsTol 2 PeakUpperBound - PeakLowerBound <= Rel-
tol*PeakUpperBound at every frequency:

3 UpperBound <= AGoodThreshold + MGoodThresh-
old*Norm(NominalValue)) at some frequency:

4 LowerBound >= ABadThreshold + MBadThresh-
old*Norm(NominalValue)
In both situations above, the stopping condition is applied at every point in array dimensions specified in ArrayDimPtWise. UpperBound and LowerBound are the peak value over all other array dimensions.
Default
Structure with default values of all wcgopt properties.
10-362
wcgopt
Object Property Meaning
Description
Structure, fieldnames are wcgopt properties, and values text description of property Percentage variation of uncertainty used as a stepsize in finite-difference calculations to estimate sensitivity. Default is 25. Upper and lower absolute stopping tolerance. Default=0.02. Upper and lower absolute sopping tolerance. Default = 0.02. Upper and lower relative stopping tolerance. Default=0.05 Multiplicative (UpperBound) Stopping Threshold, Default = 1.04. Additive (UpperBound) stopping threshold, Default = 0.05. Multiplicative (LowerBound) stopping t hreshold, Default = 5.
VaryUncertainty
AbsTol
RelTol
AbsTol
MGoodThreshold
AGoodThreshold
MBadThreshold
AGoodThreshold
Additive (LowerBound) stopping threshold, default = 20. Number of restarts in lower bound search (positive integer). Number of cycles in lower bound search (positive integer), Default = 3. Maximum computation time allowed (in seconds). The computation is prematurely terminated if this much real time elapses before the computation is complete. All quantities that have been computed are returned. Default = 720.
NTimes
MaxCnt
MaxTime
10-363
wcgopt
Example
You can create a wcgopt options object called opt with all default values.
opt = wcgopt Property Object Values: Sensitivity: 'on' LowerBoundOnly: 'off' FreqPtWise: 0 ArrayDimPtWise: [] VaryUncertainty: 25 Default: [1x1 struct] Meaning: [1x1 struct] AbsTol: 0.0200 RelTol: 0.0500 MGoodThreshold: 1.0400 AGoodThreshold: 0.0500 MBadThreshold: 20 ABadThreshold: 5 NTimes: 2 MaxCnt: 3 MaxTime: 720
The following statements changes the absolute tolerance stopping criteria from 0.02 to 0.04 and the point-wise over frequency test from the peak worst-case value, opt.FreqPtWise=0, to the worst-case value at every frequency.
opt = wcgopt; opt.AbsTol = 0.04; opt.FreqPtWise = 1; opt Property Object Values: Sensitivity: 'on' LowerBoundOnly: 'off' FreqPtWise: 1 ArrayDimPtWise: [] Default: [1x1 struct] Meaning: [1x1 struct] VaryUncertainty: 25 AbsTol: 0.0400 RelTol: 0.0500 MGoodThreshold: 1.0400 AGoodThreshold: 0.0500
10-364
wcgopt
MBadThreshold: ABadThreshold: NTimes: MaxCnt: MaxTime:
20 5 2 3 720
This statement makes a single call to wcgopt to set the maximum computation time to 10000 seconds and disables the Sensitivity calculation.
opt = wcgopt('MaxTime',10000,'Sensitivity','off');
See Also
dkitopt robopt wcgain wcnorm wcsens wcmargin
Creates a dksyn options object Creates a robustperf/robuststab options object Calculates worst-case gain of a system Calculates worst-case gain of a matrix Calculates worst-case sensitivities for a feedback loop Calculates worst-case margins for a feedback loop
10-365
wcmargin
Purpose Syntax
10wcmargin
Worst-case disk gain/phase margins for plant-controller feedback loop.

wcmargi = wcmargin(p,c) [wcmargi,wcmargo] = wcmargin(p,c) wcmargi = wcmargin(p,c,opt) [wcmargi,wcmargo] = wcmargin(p,c,opt)
Description
Classical gain and phase margins define the loop-at-a-time allowable, independent variations in the nominal system gain and phase for which the feedback loop retains stability. An alternative to classical gain and phase margins is the disk margin. The disk margin calculates the largest region for each channel such that for all gain and phase variations inside the region the nominal closed-loop system is stable. The guaranteed bound is calculated based on the balanced sensitivity function. See the dmplot and loopmargin Algorithm sections for more information. Consider a system with uncertain elements. It is of interest to determine the gain and phase margins of each individual channel in the presences of uncertainty. These margins are called worst-case margins. Worst-case margin, wcmargin, calculates the largest disk margin such that for values of the uncertainty and all gain and phase variations inside the disk, the closed-loop system is stable. The worst-case gain and phase margins bounds are defined based on the balanced sensitivity function. Hence, results from the worst-case margin calculation imply that the closed-loop system is stable for given uncertainty set and would remain stable in the presence of an additional gain and phase margin variation in the specified input/output channel.
[wcmargi,wcmargo] = wcmargin(L) calculates the combined worst-case input and output loop-at-a-time gain/phase margins of the feedback loop consisting of the loop transfer matrix L in negative feedback with an identity matrix. L must be an uncertain system, uss or ufrd object. If L is a uss object, the frequency range and number of points used to calculate wcmargi and wcmargo are chosen automatically. Note that in this case, the worst-case margins at the input and output are equal since an identity matrix is used in feedback. [wcmargi,wcmargo] = wcmargin(P,C) calculates the combined worst-case input and output loop-at-a-time gain/phase margins of the feedback loop consisting of C in negative feedback with P. C should only be the compensator in the feedback path, without reference channels, if it is a 2-dof architecture.
10-366
wcmargin
That is, if the closed-loop system has a 2-dof architecture the reference channel of the controller should be eliminated resulting in a 1-dof architecture as shown in the following figure. Either P or C must be an uncertain system, uss or ufrd, or an uncertain matrix, umat. If P and C are ss/tf/zpk or uss objects, the frequency range and number of points used to calculate wcmargi and wcmargo are chosen automatically.

Basic syntax
[wcmargi,wcmargo] = wcmargin(L) [wcmargi,wcmargo] = wcmargin(P,C) wcmargi and wcmargo are structures corresponding to the loop-at-a-time
worst-case, single-loop gain and phase margin of the channel. For the single loop transfer matrix L of size N-by-N, wcmargi will be a N-by-1 structure. For the case with two input arguments, the plant model, P, will have NY outputs and NU inputs and hence the controller, C, must have NU outputs and NY inputs. wcmargi will be a NU-by-1 structure with the following fields:
Field GainMargin Description
Guaranteed bound on worst-case, single-loop gain margin at plant input(s). Loop-at-a-time analysis. Loop-at-a-time worst-case phase margin at plant input(s). Units are degrees.
PhaseMargin
10-367
wcmargin
Field Frequency
Description
Frequency associated with the worst-case margin (rad/s).

Struct with M fields, fieldnames are names of uncertain elements of P and C. Values of fields are positive numbers, each entry indicating the local sensitivity of the worst-case margins to all of the individual uncertain elements uncertainty ranges. For instance, a value of 50 indicates that if the uncertainty range is enlarged by 8%, then the worst-case gain should increase by about 4%. If the Sensitivity property of the wcgopt object is 'off', the values are NaN.
Sensitivity
wcmargo is a N-by-1 structure for the single loop transfer matrix input and wcmargo is a NY-by-1 structure when the plant and controller are input. In both these cases, wcmargo will have the same fields as wcmargi. The worst-case
bound on the gain and phase margins are calculated based on a balanced sensitivity function.
[wcmargi,wcmargo] = wcmargin(L,opt) and [wcmargi,wcmargo] = wcmargin(p,c,opt) specifies options described in opt. (See wcgopt for more details on the options for wcmargin.)
The sensitivity of the worst-case margin calculations to the individual uncertain elements can be selected using the options object opt. To compute sensitivities, create a wcgopt options object, and set the Sensitivity property to 'on'.
opt = wcgopt('Sensitivity','on'); [maxgain,maxgainunc,info] = wcgain(sys,opt)
Example
MIMO Loop-at-a-Time Margins

This example is designed to illustrate that loop-at-a-time margins (gain, phase, and/or distance to 1) can be inaccurate measures of multivariable robustness margins. We will see that margins of the individual loops may be very sensitive to small perturbations within other loops.
10-368
wcmargin
The nominal closed-loop system considered here is shown as follows d G ; d K
6;6
G and K are 2 2 multi-input/multi-output (MIMO) systems, defined as

2 1 (s + 1) , K = I G := ----------------- s 2 2 2 s + ( s + 1 ) s 2
Set := 10, construct the nominal model, G, in state-space form and compute its frequency response.
a b c d G K = = = = = = [0 10;-10 0]; eye(2); [1 8;-10 1]; zeros(2,2); ss(a,b,c,d); [1 -2;0 1];
The nominal plant was analyzed previous using the loopmargin command. Based on experimental data, the gain of the first input channel, b(1,1), is found to vary between 0.97 and 1.06. The following statement generate the updated uncertain model.
ingain1 = ureal('ingain1',1,'Range',[0.97 1.06]); b = [ingain1 0;0 1]; Gunc = ss(a,b,c,d);
Due to differences between measured data and the plant model an 8% unmodeled dynamic uncertainty is added to the plant outputs.
unmod = ultidyn('unmod',[2 2],'Bound',0.08); Gmod = (eye(2)+unmod)*Gunc; Gmodg = ufrd(Gmod,logspace(-1,3,60));
10-369
wcmargin
You can use the command wcmargin to determine the worst-case gain and phase margins in the presences of the uncertainty.
[wcmi,wcmo] = wcmargin(Gmodg,K);
The worst-case analysis corresponds to maximum allowable disk margin for all possible defined uncertainty ranges. The worst-case single- loop margin analysis performed using wcmargin results in a maximum allowable gain margin variation of 1.31 and phase margin variations of 15.6 degs in the second input channel in the presences of the uncertainties, 'unmod' and 'ingain1'. wcmi(1)
ans = GainMargin: [0.3613 2.7681] PhaseMargin: [-50.2745 50.2745] Frequency: 0.1000 Sensitivity: [1x1 struct] wcmi(2) ans = GainMargin: [0.7585 1.3185] PhaseMargin: [-15.6426 15.6426] Frequency: 0.1000 Sensitivity: [1x1 struct]
Hence even though the second channel had infinite gain margin and 90 degrees of phase margin, see the loopmargin command page example for more details, allowing variation in both uncertainties, 'unmod' and 'ingain1' leads to a dramatic reduction in the gain and phase margin. You can display the sensitivity of the worst-case margin in the second input channel to 'unmod' and 'ingain1' as follows:
wcmi(2).Sensitivity ans = ingain1: 12.1865 unmod: 290.4557
The results indicate that the worst-case margins are not very sensitive to the gain variation in the first input channel, 'ingain1', but is very sensitive the LTI dynamic uncertainty at the output of the plant.
10-370
wcmargin
The worst-case single-loop margin at the output results in a maximum allowable gain margin variation of 1.46 and phase margin variation of 21.3 degs in the second output channel in the presences of the uncertainties, 'unmod' and 'ingain1'.
wcmo(1) ans = GainMargin: [0.2521 3.9664] PhaseMargin: [-61.6995 61.6995] Frequency: 0.1000 Sensitivity: [1x1 struct] wcmo(2) ans = GainMargin: [0.6835 1.4632] PhaseMargin: [-21.2984 21.2984] Frequency: 0.1000 Sensitivity: [1x1 struct]
You can display the sensitivity of the worst-case margin in the second output channel to 'unmod 'and 'ingain1' as follows:
wcmo(2).Sensitivity ans = ingain1: 16.3435 unmod: 392.1320
The results are similar to the worst-case margins at the input. Though the worst-case margins at the second output channel is even more sensitive to the LTI dynamic uncertainty than the input channel margins.
See Also
dmplot loopsens loopmargin robuststab usubs wcgain wcgopt wcsens
Interprets disk gain and phase margins Calculates sensitivity functions of feedback loops Performs comprehensive analysis of feedback loops Calculates stability margins of uncertain systems Substitutes values for uncertain atoms Calculates worst-case gain of a system Creates a worst-case options object Calculates worst-case sensitivity functions
10-371
wcnorm
Purpose Syntax
10wcnorm
Calculate the worst-case norm of an uncertain matrix

maxnorm = wcnorm(m) [maxnorm,wcu] = wcnorm(m) [maxnorm,wcu] = wcnorm(m,opts) [maxnorm,wcu,info] = wcnorm(m) [maxnorm,wcu,info] = wcnorm(m,opts)
Description
The norm of an uncertain matrix generally depends on the values of its uncertain elements. Determining the maximum norm over all allowable values of the uncertain elements is referred to as a worst-case norm analysis. The maximum norm is called the worst-case norm. As with other uncertain-system analysis tools, only bounds on the worst-case norm are computed. The exact value of the worst-case norm is guaranteed to lie between these upper and lower bounds.
Basic syntax
Suppose mat is a umat or a uss with M uncertain elements. The results of
[maxnorm,maxnormunc] = wcnorm(mat) maxnorm is a structure with the following fields Field LowerBound UpperBound Description
Lower bound on worst-case norm, positive scalar. Upper bound on worst-case norm, positive scalar.
maxnormunc is a structure that includes values of uncertain elements and
maximizes the matrix norm. There are M fieldnames, which are the names of uncertain elements of mat. The value of each field is the corresponding value of the uncertain element, such that when jointly combined, lead to the norm value in maxnorm.LowerBound. The following command shows the norm:
norm(usubs(mat,maxnormunc))
10-372
wcnorm
Basic syntax with third output argument

A third output argument provides information about sensitivities of the worst-case norm to the uncertain elements ranges.
[maxnorm,maxnormunc,info] = wcgain(mat)
The third output argument info is a structure with the following fields:
A struct with M fields. Fieldnames are names of uncertain elements of sys. Field values are positive numbers, each entry indicating the local sensitivity of the worst-case norm in maxnorm.LowerBound to all of the individual uncertain elements uncertainty ranges. For instance, a value of 25 indicates that if the uncertainty range is increased by 8%, then the worst-case norm should increase by about 2%. If the Sensitivity property of the wcgopt object is 'off', the values are NaN. 1-by-1 scalar matrix with the value of 1. In more complicated situations (described later) the value of this field depends on the input data.
ArrayIndex
Advanced options: Handling array dimensions If mat has array dimensions, the default behavior is to maximize over all dimensions. It is also possible to perform the computation pointwise-in-the-array-dimensions to determine the worst-case norm at each grid point. Any combination of peak-over and pointwise-over is allowed. To specify the desired computation, the wcgopt must be used. For concreteness, suppose that mat is an rc758 uncertain system (i.e., a 7-by-5-by-8 array of uncertain r output, c input systems). To perform the worst-case gain calculation pointwise over the second and third array dimensions (the slots with 5 points and 8 points, respectively), set the ArrayDimPtWise property:
opt = wcgopt('ArrayDimPtWise',[2 3]);
In this case, the worst-case norm calculation is performed pointwise on the 5-by-8 grid. Only the peak value in the first array dimension (the slot with 7
10-373
wcnorm
points) is tracked. For that reason, many of the results will be of dimension 1-by-5-by-8. In general, suppose that the array dimensions of sys are d1dF (758 in the above example). Furthermore, assume that the ArrayDimPtWise property of the wcgopt object has been set to some of the integers between 1 and F. Let e1,e2,,eF denote the dimensions of the array on which the results are computed. By definition, if j is an integer listed in ArrayDimPtWise, then ej=dj (all grid points in slot j are computed), otherwise ej=1 (only the maximum in slot j is computed). In the above example, with ArrayDimPtWise set to [2 3], it follows that e1=1, e2=5, e3=8. In this case, the following command
[maxgain,maxgainunc,info] = wcgain(sys,opt)
produces the maxgain a structure with the following fields

e1eF matrix of lower bounds on worst-case norm, computed pointwise over all array dimensions listed in ArrayDimPtWise property and peaked over all others. Upper bound, analogous to LowerBound
UpperBound
maxgainunc is a e1eF struct, containing values of uncertain elements which maximize the system norm. There are M fieldnames, which are the names of uncertain elements of mat. The value of each field is the corresponding value of the uncertain element, which lead to the gain value in maxnorm.LowerBound when jointly combined.
10-374
wcnorm
e1eF struct array, where each entry is the local sensitivity of the worst-case norm in maxnorm.LowerBound to the uncertainty range of each uncertain element. At each value in the e1eF grid, there is a corresponding value in the d1dF grid where the maximum occurs. The variable info.ArrayIndex is an e1eF matrix, where the value is the single-index representation of the maximizing location in the d1dF grid.
ArrayIndex
Example
You can construct an uncertain matrix and compute the worst-case norm of the matrix, as well as its inverse. Your objective is to accurately estimate the worst-case, or the largest, value of the condition number of the matrix.
a=ureal('a',5,'Range',[4 b=ureal('b',2,'Range',[1 b=ureal('b',3,'Range',[2 c=ureal('c',9,'Range',[8 d=ureal('d',1,'Range',[0 M = [a b;c d]; Mi = inv(M); [maxnormM] = wcnorm(M) maxnormM = LowerBound: 14.7199 UpperBound: 14.7327 [maxnormMi] = wcnorm(Mi) maxnormMi = LowerBound: 2.5963 UpperBound: 2.5979 6]); 3]); 10]); 11]); 2]);
The condition number of M must be less than the product of the two upper bounds for all values of the uncertain elements making up M. Conversely, the largest value of M condition number must be at least equal to the condition number of the nominal value of M. Compute these crude bounds on the worst-case value of the condition number.
10-375
wcnorm
condUpperBound = maxnormM.UpperBound*maxnormMi.UpperBound; condLowerBound = cond(M.NominalValue); [condLowerBound condUpperBound] ans = 5.0757 38.2743
How can you get a more accurate estimate? Recall that the condition number of an nxm matrix M can be expressed as an optimization, where a free norm-bounded matrix tries to align the gains of M and M1 ( M ) = max m m ( max ( MM ) )
1
C max ( ) 1
If M is itself uncertain, then the worst-case condition number involves further maximization over the possible values of M. Therefore, you can compute the worst-case condition number of an uncertain matrix by using a ucomplexm uncertain element, and then by using wcnorm to carry out the maximization. Create a 2-by-2 ucomplexm object, with nominal value equal to zero.
Delta = ucomplexm('Delta',zeros(2,2));
The range of values represented by Delta includes 2-by-2 matrices with the maximum singular value less than or equal to 1. You can create the expression involving M, Delta and inv(M).
H = M*Delta*Mi;
Finally, consider the stopping criteria and call wcnorm. One stopping criteria for wcnorm(H) is based on the norm of the nominal value of H. During the computation, if wcnorm determines that the worst-case norm is at least
ABadThreshold + MBadThreshold*norm ( H.NominalValue )
then the calculation is terminated. In our case, since H.NominalValue equals 0, the stopping criteria is governed by ABadThreshold. The default value of ABadThreshold is 5. To keep wcnorm from prematurely stopping, set ABadThreshold to 38 (based on our crude upper bound above).
opt = wcgopt('ABadThreshold',38);
10-376
wcnorm
[maxKappa,wcu,info] = wcnorm(H,opt); maxKappa maxKappa = LowerBound: 26.9629 UpperBound: 27.9926
You can verify that wcu makes the condition number as large as
maxKappa.LowerBound. cond(usubs(M,wcu)) ans = 26.9629
Algorithm See Also
See wcgain
lti/norm svd wcgain wcgopt
Calculates LTI system norms Calculates singular value decomposition Calculates worst-case gain of a system Creates a wcgain options object
10-377
wcsens
Purpose Syntax
10wcsens
Calculate the worst-case sensitivity and complementary sensitivity functions of a plant-controller feedback loop
wcst wcst wcst wcst wcst wcst wcst wcst wcst wcst = = = = = = = = = = wcsens(L) wcsens(L,type) wcsens(L,opt) wcsens(L,type,scaling) wcsens(L,type,scaling,opt) wcsens(P,C) wcsens(P,C,type) wcsens(P,C,opt) wcsens(P,C,type,scaling) wcsens(P,C,type,scaling,opt)
Description
The sensitivity function, S=(I+L)1, and the complementary sensitivity function, T=L(I+L)1, where L is the loop gain matrix associated with the input, CP, or output, PC, are two transfer functions related to the robustness and performance of the closed-loop system. The multivariable closed-loop interconnection structure, shown below, defines the input/output sensitivity, complementary sensitivity and loop transfer functions.
Description
Equation
Si: Input Sensitivity Ti: Input Complementary Sensitivity So: Output Sensitivity
(I+CP)1 CP(I+CP)1 (I+PC)1
10-378
wcsens
Description
Equation
To: Output Complementary Sensitivity Li: Input Loop Transfer Function Lo: Output Loop Transfer Function
PC(I+PC)1 CP PC
wcst = wcsens(L) calculates the worst-case sensitivity and complementary sensitivity functions for the loop transfer matrix L in feedback in negative feedback with an identity matrix. If L is a uss object, the frequency range
and number of points are chosen automatically.

wcst = wcsens(P,C) calculates the worst-case sensitivity and complementary sensitivity functions for the feedback loop C in negative feedback with P. C
should only be the compensator in the feedback path, not any reference channels, if it is a 2-dof architecture (see loopsens). If P and C are ss/tf/zpk or uss objects, the frequency range and number of points are chosen automatically. wcst is a structure with the following substructures:
Table 10-2: Fields of wcst: Field Si Ti Description
Worst-case input-to-plant sensitivity function Worst-case input-to-plant complementary sensitivity function Worst-case output-to-plant sensitivity function Worst-case output-to-plant complementary sensitivity function Worst-case plant times input-to-plant sensitivity function Worst-case compensator times output-to-plant sensitivity function 1 if nominal closed loop is stable, 0 otherwise. NaN for frd/ufrd objects.
So To
PSi
CSo
Stable
10-379
wcsens
Each sensitivity substructure is a structures with five fields MaximumGain, BadUncertainValues, System, BadSystem, Sensitivity derived from the outputs of wcgain.
Table 10-3: Fields of Si, So, Ti, To, PSi, CSo: Field MaximumGain Description
struct with fields LowerBound, UpperBound and CriticalFrequency. LowerBound and UpperBound are bounds on the unweighted maximum gain of the uncertain sensitivity function. CriticalFrequency is the frequency at which the maximum gain occurs.
Struct, containing values of uncertain elements
BadUncertainValues
which maximize the sensitivity gain. There are M fluidness, which are the names of uncertain elements of sensitivity function. The value of each field is the corresponding value of the uncertain element, such that when jointly combined, lead to the gain value in MaximumGain.LowerBound.
System
Uncertain sensitivity function (ufrd or uss).
10-380
wcsens
Field BadSystem
Description
Worst-case system based on the uncertain object values in BadUncertainValues. BadSystem is

defined as BadSystem=usubs(System, BadUncertainValues).
Sensitivity
Struct with M fields, fieldnames are names of un-
certain elements of system. Values of fields are positive numbers, each entry indicating the local sensitivity of the maximum gain to all of the individual uncertain elements uncertainty ranges. For instance, a value of 50 indicates that if the uncertainty range is enlarged by 8%, then the maximum gain should increase by about 4%. If the 'Sensitivity' property of the wcgopt object is 'off', the values are NaN.
wcst = wcsens(L,type) and wcst = wcsens(P,C,type) allows selection of individual Sensitivity and Complementary Sensitivity functions, type, as 'Si','Ti','So','To','PSi','CSo' corresponding to the sensitivity and complementary sensitivity functions. Setting type to 'S' or 'T' selects all sensitivity functions ('Si','So','PSi','CSo') or all complementary sensitivity functions ('Ti','To'). Similarly, setting type to 'Input' or 'Output' selects all input Sensitivity functions ('Si','Ti','PSi') or all output sensitivity functions ('So,'To','CSo'). 'All' selects all six Sensitivity functions for analysis (default). type may also be a cell containing a collection of strings, i.e. 'Si','To', as well as a comma separated list. wcst = wcsens(L,type,scaling) and wcst = wcsens(P,C,type,scaling) adds a scaling to the worst-case sensitivity analysis. scaling is either the character strings 'Absolute' (default), 'Relative' or a ss/tf/zpk/frd object. The default scaling 'Absolute' calculates bounds on the maximum gain of the uncertain sensitivity function. The 'Relative' scaling finds bounds on
the maximum relative gain of the uncertain sensitivity function. That is, the maximum relative gain is the largest ratio of the worst-case gain and the nominal gain evaluated at each frequency point in the analysis, Similarly if scaling is a ss/tf/zpk/frd object, bounds on the maximum scaled gain of the
10-381
wcsens
uncertain sensitivity function are found. If scaling is 'Relative'or a ss/tf/zpk/frd object, the worst-case analysis peaks over frequency. If scaling is an object, its input/output dimensions should be 1-by-1 or dimensions compatible with P and C. type and scaling can also be combined in a cell array, e.g.
wcst = wcsens(P,C,{'Ti','So'},'Abs','Si','Rel','PSi',wt) wcst = wcsens(P,C,opt) or wcst = wcsens(P,C,type,scaling,opt) specifies options for the worst-case gain calculation as defined by opt. (See wcgopt for more details on the options for wcsens.)
The sensitivity of the worst-case sensitivity calculations to the individual uncertain components can be determined using the options object opt. To compute the sensitivities to the individual uncertain components, create a wcgopt options object, and set the Sensitivity property to 'on'.
opt = wcgopt('Sensitivity','on'); wcst = wcsens(P,C,opt)
Example
The following constructs a feedback loop with a first order plant and a proportional-integral controller. The time constant is uncertain and the model also includes an multiplicative uncertainty. The nominal (input) sensitivity function has a peak of 1.09 at omega = 1.55 rad/sec. Since the plant and controller are single-input / single-output, the input/output sensitivity functions are the same.
delta = ultidyn('delta',[1 1]); tau = ureal('tau',5,'range',[4 6]); P = tf(1,[tau 1])*(1+0.25*delta); C=tf([4 4],[1 0]); looptransfer = loopsens(P,C); Snom = looptransfer.Si.NominalValue; norm(Snom,inf) ans = 1.0864 wcsens is then used to compute the worst-case sensitivity function as the
uncertainty ranges over its possible values. More information about the fields in wcst.Si can be found in the wcgain help. The badsystem field of wcst.Si contains the worst case sensitivity function. This worst case sensitivity has a
10-382
wcsens
peak of 1.52 at omega = 1.02 rad/sec. The maxgainunc field of wcst.Si contains the perturbation that corresponds to this worst case sensitivity function.
wcst = wcsens(P,C) wcst = Si: [1x1 struct] Ti: [1x1 struct] So: [1x1 struct] To: [1x1 struct] PSi: [1x1 struct] CSo: [1x1 struct] Stable: 1 Swc = wcst.Si.BadSystem; omega = logspace(-1,1,50); bodemag(Snom,'-',Swc,'-.',omega); legend('Nominal Sensitivity','Worst-Case Sensitivity',... 'Location','SouthEast') norm(Swc,inf) ans = 1.5075
For multi-input/multi-output systems the various input/output sensitivity functions will, in general, be different.
Reference
J. Shin, G.J. Balas, and A.K. Packard, Worst case analysis of the X-38 crew return vehicle flight control system, AIAA Journal of Guidance, Dynamics and Control, vol. 24, no. 2, March-April 2001, pp. 261-269.
loopsens loopmargin robuststab usubs wcgain wcgopt wcmargin
See Also
Calculate sensitivity functions of feedback loops Comprehensive analysis of feedback loops Calculate stability margins of uncertain systems Substitutes values for uncertain atoms Calculate worst-case gain of a system Create a worst-case options object Calculate worst-case margins for feedback loop
10-383
wcsens
10-384
Index
A
ACC Benchmark plant 10-29 additive error 10-22, 10-105, 10-277 all-pass phase matrix 10-34 augmented plant 10-19
complementary sensitivity 2-5 complementary sensitivity T 10-19 conic-sector 10-292 crossover frequency c 2-16
D B
Balanced model truncation 10-22 balancmr 10-22 Schur method 10-277 schurmr 10-277 square root method 10-22 Balanced stochastic truncation 10-32 BST 10-32 bstmr 10-32 balancmr 10-22 Bamieh, B.A. 10-285 bilinear transform, frequency continuous to continuous pole-shifting transform 10-29 continuous to discrete backward rectangular 10-27 forward rectangular 10-27 shifted Tustin 10-28 general bilinear 10-28 reverse transform 10-27 bisection algorithm 10-120 design goals crossover 2-16 performance 2-16 roll-off 2-16 stability robustness 2-16 disturbance attenuation 2-6 Doyle, J. C. state-space H 10-104 D-scalings automatic prefitting 10-61
F
fitmag 10-87 fitmaglp 10-87
forbidden regions 2-9 Franklin, G. F. 10-31 fundamental limits right-half-plane poles 2-16 right-half-plane zeros 2-16
G C
Chiang, R. Y. bilinear pole shifting 10-31
cmsclsyn 10-37
gain reduction tolerance 2-10 gain/phase margins MIMO system 2-9 gap metric 10-224
Index-1
Index
genphase 10-87
-iteration 10-120 Glover, K. loop shaping 10-181 state-space H2 10-104
hankel singular values NCF 1-15 HiMAT aircraft model 1-10
I
imp2ss 10-133
H
H mixsyn 2-18 norm 2-3 H loop shaping 1-10 mixed-sensitivity 1-10 Sampled-data 1-10 H -norm 10-292 H optimal controller 10-118 H Control performance objectives 5-3 H2 norm 2-3 H2 control synthesis 10-99 mixed-sensitivity 10-19 h2syn 10-99 Hankel Minimum Degree Approximation 10-105 Hankel minimum degree approximation hankelmr 10-105 MDA 10-105 Zeroth Order Hankel MDA 10-109 Hankel singular value 10-22, 10-32, 10-105, 10-277 hankelsv 10-112 Hankel singular value based model reduction 10-250 reduce 10-250 Hankel singular values 10-22, 10-105, 10-277
L
Le,V. X. 10-181 linear matrix inequalities LMI solvers 1-18 LMI solvers 1-18 loop shaping 1-10 loopsyn 2-5 loop transfer function matrix 2-5 loop-shaping synthesis loopsyn H optimal method 10-177 LTR loop transfer recovery method 10-183 see also mixed-sensitivity loopsyn 10-177 LQG loop tranfer-function recovery. See ltrsyn LQG optimal control 10-101 LTR control synthesis. See ltrsyn ltrsyn 10-183
M
magfit 10-87
max entropy 10-120 McFarlane, D. C., 10-225

mfilter 10-196
Mixed H /H2 lcontroller synthesis 1-10, 10-6 mixed-sensitivity 2-18 mixed-sensitivity synthesis
Index-2
Index
H 10-193 H2 10-19 plant augmentation for 10-19 mixsyn 10-193 mktito 10-198 Modal form realization 10-200 modreal 10-200 model reduction 1-14 controller order reduction 1-15 Monte Carlo random sample 1-5 multiplicative error bound 10-32 multiplicative uncertainty 2-2 multivariable margins 10-165, 10-368
plant augmentation 10-19 proper system 10-21
R
relative error 10-32 robustness of stability 2-16 robustness analysis Monte Carlo 1-7 worst case 1-7 roll-off 2-16
S N
ncfmargin 10-222 ncfsyn 10-222
norm
H 2-2 H2 2-2 normalized comprime factor (NCF) 10-222 Normalized coprime factor 10-218 Left Compie Factorization 10-218 Right Coprime Facotrization 10-218 Normalized coprme factor ncfmr 10-218 Normallized coprime factor balanced model truncation 10-218 norms 5-26 performance 5-28
Safonov, M. G. imaginy axis zeros H 10-31 return difference matrix 10-104 stabiltiy and robustness 10-296 sdhfsyn 10-284 sectf 10-292 sector bilinear transformation 10-292 sensitivity 2-5 sensitivity S 10-19 singular values 2-3 properties of 2-3 Slow and fadt modes decomposition slowfast 10-308 Slow and fast modes decomposition 10-308, 10-314 slow and fast modes decomposition 10-308, 10-314
slowfast 10-308
P
perturbation additive 2-6 multiplicative 2-6
spectral factor 10-34 square root method 10-22 squaring-down prefilter 10-178 Stable and antistable projection 10-314
Index-3
Index
stabproj 10-314 stable and antistable projections 10-314

stabproj 10-314
SVD system realization 10-133 System realization 10-133
T
TITO (two-input-two-output) system 10-198
U
uncertain LTI system 1-3 USS object 1-5
W
weighted mixed-sensitivity 10-19 worst-case peak gain 1-9
Z
Zames, G. 10-296 Zhou, K. 10-225
Index-4

Robust Control Toolbox

Uploaded by

Copyright:

Available Formats

Robust Control Toolbox

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Robust Control Toolbox

Uploaded by

Copyright:

Available Formats

What is the Robust Control Toolbox used for?

What is the Robust Control Toolbox used for?

What modeling techniques does it provide for uncertainty?

What modeling techniques does it provide for uncertainty?

Robust Control Toolbox

For Use with MATLAB

Gary Balas Richard Chiang Andy Packard Michael Safonov

How to Contact The MathWorks:

New for Version 1

Multivariable Loop Shaping

Model Reduction for Robust Control

Worst-Case Gain Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-20 Summary of Robustness Analysis Tools . . . . . . . . . . . . . . . . 4-23

H-Infinity and Mu Synthesis

Functions for Control Design . . . . . . . . . . . . . . . . . . . . . . . . . 5-24

Building Uncertain Models

Generalized Robustness Analysis

Introduction to Linear Matrix Inequalities

The LMI Lab

9-10 9-12 9-15 9-18

Functions Alphabetical List . . . . . . . . . . . . . . . . . . . . . . . 10-10

What Is the Robust Control Toolbox?

Example: ACC Benchmark Problem

Figure 1-1: ACC benchmark problem

m1 = 10.2 m2 = 10.2 k = 10.2 P(s) u1 + u2 Spring k f1 x1 f2 x2 F(s) y1

Figure 1-2: ACC benchmark two-cart system block diagram y1 = P(s) u1

The upper dashed-line block has transfer function matrix F(s) = 0 1 0 G2 ( s ) 1 1 + G1 ( s ) 1

The resulting plot is shown in Figure 1-3 below.

0.04 0.06 Time (sec)

Figure 1-3: Monte Carlo sampling of uncertain system's step response.

Worst Case Performance

Worst Case Performance

Example: ACC Two Cart Benchmark Problem

[StabilityMargin,Udestab,REPORT] = robuststab(T); REPORT

This displays the REPORT

Trand random samples 2 10

Figure 1-4: Uncertain system closed-loop bode plots.

Worst Case Performance

The resulting plot is shown in Figure 1-4.

Synthesis of Robust MIMO Controllers

Example: Designing a Controller with LOOPSYN

Synthesis of Robust MIMO Controllers

where x e and x are elevator and canard actuator states.

Aileron Canard Flap Rudder

Elevator Elevon x-axis 0 Velocity Horizontal

Figure 1-5: Aircraft configuration and vertical plane geometry.

9.8312e-01 -7.2562e-04 -1.7080e-01 -4.9652e-03; 8.7582e-04 -3.1604e+01 0 0 0 0 -3.0000e+01

Synthesis of Robust MIMO Controllers

desired loop shape G , db d achieved loop shape GK

Model Reduction and Approximation

Example: NASA HIMAT Controller Order Reduction

Model Reduction and Approximation

Hankel SV of Coprime Factors [Nl Ml]

Figure 1-7: Hankel Singular Values of Coprime Factorization of K.

hankelsv(K,'ncf','log');v=axis; hold on; plot(v(1:2), ncfmargin(G,K)*[1 1],'--'); hold off

Hankel SV of Coprime Factors [Nl Ml]

The result is plotted in Figure 1-9.

Model Reduction and Approximation

singular values: openloop GK1 11state reduced K1 GK 16state original K

30 Singular Values (dB)

LMI Solvers feasp gevp mincx dec2mat