function lmi_con(action)
%LMI_CON Used for the MATLAB Tour to show functions help

%    Yama Habibzai
%    Copyright (c) 1984-98 by The MathWorks, Inc. All Rights Reserved
%    $Revision: 1.5 $
%    $Date: 1997/12/02 19:33:34 $

if nargin < 1
action = 'init';
end

if strcmp(action, 'init');
prevfig = findobj('type', 'figure', 'name', 'MATLAB Tour ...');

if ~isempty(prevfig)
  listhand = findobj(prevfig, 'style', 'listbox');

  if ~isempty(listhand)
    delete(listhand)
  end
  currfig=prevfig;
else
  figNumber = figure('NumberTitle', 'off', 'name', 'MATLAB Tour ...',...
      'color', [.8 .8 .8], 'position', [345 712 655 420]);
  currfig = figNumber;

end

category = ' LMI Control Toolbox';
ttlStr = 'Click on one of the functions below to see more ...';
hlpstr = {'LMI Control Toolbox: Control Applications                              '
          '                                                                       '
          'A. Analysis and Design Tools                                           '
          '             ----------------------------                              '
          '                                                                       '
          'Nominal performance measures.                                          '
          'norminf     - RMS/Hinf gain in continuous time.                        '
          'dnorminf    - RMS/Hinf gain in discrete time.                          '
          'norm2       - H2-norm of continuous-time systems.                      '
          '                                                                       '
          'Robustness analysis.                                                   '
          'quadstab    - Quadratic stability.                                     '
          'quadperf    - Quadratic Hinf performance.                              '
          'pdlstab     - Robust stability via parametric Lyapunov functions.      '
          'popov       - Popov criterion for robust stability.                    '
          'decay       - Quadratic decay rate.                                    '
          'mubnd       - Upper bound on the structured singular value.            '
          'mustab      - Robust stability margin (mu).                            '
          'muperf      - Robust Hinf performance (mu).                            '
          '                                                                       '
          'Hinf design - continuous time.                                         '
          'msfsyn      - Multi-objective state-feedback design.                   '
          'hinflmi     - LMI-based Hinf design.                                   '
          'hinfmix     - Mixed H2/Hinf design with pole placement.                '
          'lmireg      - Specification of LMI regions for pole placement.         '
          'hinfric     - Riccati-based Hinf design.                               '
          '                                                                       '
          'Hinf design - discrete time.                                           '
          'dhinflmi    - LMI-based Hinf design.                                   '
          'dhinfric    - Riccati-based Hinf design.                               '
          '                                                                       '
          'Loop shaping                                                           '
          'magshape    - GUI for shaping filter specification.                    '
          'sconnect    - Specification of general control loops.                  '
          'frfit       - Rational fit of frequency response data.                 '
          '                                                                       '
          'Gain scheduling                                                        '
          'hinfgs      - Gain-scheduled Hinf design.                              '
          'pdsimul     - Time response along a given parameter trajectory.        '
          '                                                                       '
          'Demos                                                                  '
          'sateldem    - State-feedback control of a satellite attitude.          '
          'radardem    - Loop-shaping design for a radar antenna.                 '
          'misldem     - Gain-scheduled control of a missile autopilot.           '
          '                                                                       '
          '                                                                       '
          'B. Manipulation of Uncertain Linear Systems                            '
          '          -------------------------------------------                  '
          '                                                                       '
          'Linear time-invariant systems.                                         '
          'ltisys      - Store a state-space model as a SYSTEM matrix.            '
          'ltiss       - Extract state-space data from a SYSTEM matrix.           '
          'ltitf       - Compute the transfer function of a SISO system.          '
          'islsys      - Test if input is a SYSTEM matrix.                        '
          'sinfo       - System characteristics.                                  '
          'sresp       - Frequency response of a system.                          '
          'spol        - Get system poles.                                        '
          'ssub        - Extract a subsystem.                                     '
          'sinv        - Compute the inverse of a system.                         '
          'sbalanc     - Numerically balance a state-space realization.           '
          'splot       - Plot time and frequency responses.                       '
          '                                                                       '
          'Polytopic or parameter-dependent systems (P-systems).                  '
          'psys        - Specify a P-system.                                      '
          'psinfo      - Inquire about a P-system.                                '
          'ispsys      - Test if input is a P-system.                             '
          'pvec        - Specify a vector of uncertain or time-varying parameters.'
          'pvinfo      - Read a parameter vector description.                     '
          'polydec     - Polytopic coordinates wrt. the parameter box corners.    '
          'aff2pol     - Conversion affine/polytopic for P-systems.               '
          'pdsimul     - Simulation of P-systems along parameter trajectories.    '
          '                                                                       '
          'Dynamical uncertainty.                                                 '
          'ublock      - Specify an uncertainty block.                            '
          'udiag       - Specify block-diagonal uncertainty.                      '
          'uinfo       - Display block-diagonal uncertainty descriptions.         '
          'aff2lft     - Linear-fractional representation of affine P-systems.    '
          '                                                                       '
          'Interconnection of systems.                                            '
          'sdiag       - Append linear systems.                                   '
          'sderiv      - Applies proportional-derivative action.                  '
          'sadd        - Parallel interconnection of systems.                     '
          'smult       - Series interconnection of systems.                       '
          'sloop       - Elementary feedback loop.                                '
          'slft        - Linear-fractional feedback interconnections.             '
          'sconnect    - Specification of general control loops.                  '
          '                                                                       '
          'Auxilliary functions.                                                  '
          'care        - Solver for continuous-time Riccati equations             '
          'dare        - Solver for discrete-time Riccati equations               '
          'hinfpar     - Extract A,B1,B2,... from the plant SYSTEM matrix         '
          '    (d)goptric  - Gamma-iterations (Riccati-based)                     '
          '    (d)goptlmi  - Hinf optimization (LMI-based)                        '
          'kric        - Central Hinf controller (Riccati-based)                  '
          'klmi        - Central Hinf controller (LMI-based)                      '
          'dkcen       - Central Hinf controller (discrete-time)                  '
          'parrott     - Static Hinf - Parrott problem                            '
          'ricpen      - Generalized Riccati solver (continuous-time)             '
          'dricpen     - Generalized Riccati solver (discrete-time)               '
          'schrcomp    - Schur complement of a symmetric matrix                   '
          'lnull       - Left null space                                          '
          'rnull       - Right null space                                         '};

funhelp;
%======================
% Get a good font for this platform.
[fname,fsize,figwidth] = goodfonts(computer);

h = uicontrol(currfig, 'style', 'list','units','norm',...
'position', [left bottom .9 .75],...
'FontName',fname, ...
'FontSize',fsize, ...
'string', hlpstr, 'callback', 'LMI_CON(''hlp'')',...
'BackGroundColor', [1 1 1],...
'Max', 1);

elseif strcmp(action, 'hlp');
% === When mouse is double clicked ====
if strcmp(get(gcf, 'selectiontype'), 'open')
val = 'dump';
else
val = get(gcbo, 'value');
end

   switch val;

case 93,
ttlStr ='ADDPV';
addp ={'pds = addpv(pds,pv)                                  '
       '                                                     '
       'Adds the parameter vector description to a parameter-'
       'dependent system                                     '};
helpwin(addp, ttlStr);

case 77,
ttlStr ='AFF2LFT';
aff2lf ={'  [sys,delta] = aff2lft(affsys)                        '
         '                                                       '
         'Given an affine parameter-dependent system AFFSYS with '
         'equations                                              '
         '                                                       '
         'E(p) dx/dt  =  A(p) x  +  B(p) u                       '
         'y  =  C(p) x  +  D(p) u                                '
         '                                                       '
         'AFF2LFT generates an equivalent linear fractional      '
         'representation of the form                             '
         '                                                       '
         '___________                                            '
         '                    |         |                        '
         '               |----|  DELTA  |<---|                   '
         '               |    |_________|    |                   '
         '               |                   |                   '
         '               |    ___________    |                   '
         '               |--->|         |----|                   '
         '                    |   SYS   |                        '
         'u  ----->|_________|----->  y                          '
         '                                                       '
         'where                                                  '
         '    * the nominal system SYS corresponds to the AVERAGE'
         'values of the parameters p1, ..., pK                   '
         '    * DELTA is a block-diagonal uncertainty structure  '
         'of the form                                            '
         'DELTA =  blockdiag (d1*I , ... , dK*I)                 '
         'with                                                   '
         '              | dj |  <=  (pj_max - pj_min)/2          '
         '                                                       '
         '                                                       '};
helpwin(aff2lf, ttlStr);

case 70,
ttlStr ='AFF2POL';
aff2po ={'polsys = aff2pol(affsys)                              '
         '                                                      '
         'For uncertain state-space models, AFF2POL converts the'
         'affine parameter-dependent representation AFFSYS to a '
         'polytopic representation POLSYS.                      '};
helpwin(aff2po, ttlStr);

case 89,
ttlStr ='CARES';
care ={'Usage: [X,L,G,RR] = cares(A,B,Q,R,S,E)                                   '
       'Given A,B,Q,R,S,E and the continuous-time algebraic Riccati equation     '
       '                             -1                                          '
       'A''XE + E''XA - (E''XB + S)R  (B''XE + S'') + Q = 0                      '
       'or, equivalently,                                                        '
       '                       -1             -1                         -1      '
       'F''XE + E''XF - E''XBR  B''XE + Q - SR  S'' = 0  (where F = A - BR  S''),'
       'compute the unique symmetric stabilizing nxn solution matrix X.          '
       'Additional optional outputs include an n-vector L of closed-loop         '
       'eigenvalues, the mxn gain matrix G given by                              '
       '       -1                                                                '
       'G = -R  (B''XE + S''),                                                   '
       '                                                                         '
       'and RR, the Frobenius norm of the relative residual matrix.              '
       '                                                                         '
       'Assumptions: E is nonsingular, Q=Q'', R=R'' with R nonsingular, and      '
       'the associated Hamiltonian pencil has no eigenvalues                     '
       'on the imaginary axis.                                                   '
       'Sufficient conditions to guarantee the above are stabilizability,        '
       'detectability, and [Q S;S'' R] >= 0, with R > 0.                         '
       '                                                                         '
       'If S and E are not specified, they are set to the default values         '
       'S = 0 and E = I.  This code version implements a heuristic automatic     '};
helpwin(care, ttlStr);


case 90,
ttlStr ='DARES';
dare ={'Usage: [X,L,G,RR] = dares(A,B,Q,R,S,E)                                         '
       'Given A,B,Q,R,S,E and the discrete-time algebraic Riccati equation             '
       '                                      -1                                       '
       'E''XE = A''XA - (A''XB + S)(B''XB + R)  (A''XB + S)'' + Q                      '
       'or, equivalently, (if R is nonsingular)                                        '
       '                                -1             -1                     -1       '
       'E''XE = F''XF - F''XB(B''XB + R)  B''XF + Q - SR  S''  (where F = A - BR  S''),'
       'compute the unique symmetric stabilizing nxn solution matrix X.                '
       'Additional optional outputs include an n-vector L of closed-loop               '
       'eigenvalues, the mxn gain matrix G given by                                    '
       '                -1                                                             '
       'G = -(B''XB + R)  (B''XA + S''),                                               '
       '                                                                               '
       'and RR, the Frobenius norm of the relative residual matrix.                    '
       '                                                                               '
       'Assumptions: E is nonsingular, Q=Q'', R=R'', and the associated                '
       'symplectic pencil has no eigenvalues on the unit circle.                       '
       'Sufficient conditions to guarantee the above are stabilizability,              '
       'detectability, and [Q S;S'' R] >= 0.                                           '
       '                                                                               '
       'If S and E are not specified, they are set to the default values               '
       'S = 0 and E = I.  This code version implements a heuristic automatic           '};
helpwin(dare, ttlStr);

case 16,
ttlStr ='DECAY';
deca ={'  [rate,P] = decay(pds,options)                             '
       '                                                            '
       'Quadratic decay rate of polytopic or parameter-dependent    '
       'systems                                                     '
       '                                                            '
       'DECAY minimizes t over the Lyapunov matrices Q > 0 such     '
       'that                                                        '
       '                                                            '
       'A(p)*Q*E(p)'' + E(p)*Q*A(p)''  <   t * E(p)*Q*E(p)''        '
       '                                                            '
       'over the range of values of the parameter vector p.  The    '
       'system is quadratically stable if tmin < 0.                 '
       '                                                            '
       'Input:                                                      '
       'PDS       polytopic or parameter-dependent system (see PSYS)'
       'OPTIONS   optional 2-entry vector.                          '
       'OPTIONS(1)=0 :  fast mode (default)                         '
       '                       =1 :  least conservative mode        '
       'OPTIONS(2)   :  bound on the condition number of P          '
       '                             (default = 1e9)                '
       'Output:                                                     '
       'RATE      decay rate                                        '
       'P         Lyapunov matrix P = inv(Q)                        '
       '                                                            '};
helpwin(deca, ttlStr);

case 29,
ttlStr ='DHINFLMI';
dhinflm ={' [gopt,K,X1,X2,Y1,Y2] = dhinflmi(P,r,gmin,tol,options)            '
          '                                                                  '
          'Given a discrete-time plant P(z), computes the best               '
          'H_infinity performance GOPT in the interval [GMIN,GMAX]           '
          'as well as an H_infinity controller  K(z)  that                   '
          '    * internally stabilizes the plant, and                        '
          '    * yields a closed-loop gain no larger than GOPT.              '
          'DHINFLMI implements the LMI-based approach.                       '
          '                                                                  '
          'To compute only GOPT, call DHINFLMI with only one output argument.'
          'The input arguments  GMIN, TOL, and OPTIONS  are optional.        '
          '                                                                  '
          'Assumption on P(z):  stabilizable + detectable.                   '
          '                                                                  '
          'Input:                                                            '
          'P          plant SYSTEM matrix  (see LTISYS)                      '
          'R          1x2 vector specifying the dimensions of D22. That is,  '
          'R(1) = nbr of measurements                                        '
          'R(2) = nbr of controls                                            '
          'GMIN       user-specified target for the closed-loop performance. '
          'Set GMIN=0 to compute GOPT, and set GMIN = GAMA to test           '
          'whether the performance GAMA is achievable.                       '
          'TOL        relative accuracy  required on GOPT (default = 1e-2).  '
          'OPTIONS    optional 3-entry vector of control parameters for      '
          'the numerical computations.                                       '
          'OPTIONS(1:2): not used                                            '
          'OPTIONS(3): default = 1e-3. Reduced-order synthesis is            '
          'performed whenever                                                '
          'rho(X*Y) >=  ( 1 - OPTIONS(3) ) * GOPT^2                          '
          'Output:                                                           '
          'GOPT       best H_infinity performance                            '
          'K          central H_infinity controller for gamma = GOPT         '
          'X1,X2,..   X = X2/X1  and  Y = Y2/Y1  are solutions of the        '
          'two H-infinity Riccati inequalities for gamma = GOPT.             '
          'Equivalently,  R = X1  and  S = Y1  are solutions                 '
          'of the characteristic LMIs since X2=Y2=GOPT*eye .                 '
          '                                                                  '};
helpwin(dhinflm, ttlStr);

case 30,
ttlStr ='DHINFRIC';
dhinfri ={' [gopt,K,X1,X2,Y1,Y2] = dhinfric(P,r,gmin,gmax,tol,options)         '
          '                                                                    '
          'For a discrete-time plant P(z), computes the best                   '
          'H_infinity performance GOPT in the interval [GMIN,GMAX]             '
          'as well as an H_infinity central controller  K(s)  that             '
          '    * internally stabilizes the plant, and                          '
          '    * yields a closed-loop gain no larger than GOPT.                '
          'DHINFRIC implements the Riccati-based approach.                     '
          '                                                                    '
          'To compute just GOPT, call DHINFRIC with only one output argument.  '
          'The input arguments  GMIN, GMAX, TOL, and OPTIONS  may be jointly   '
          'omitted                                                             '
          '                                                                    '
          'Assumptions on P(z):  stabilizable/detectable, D12 and D21 full rank'
          '                                                                    '
          'Input:                                                              '
          'P          plant SYSTEM matrix  (see LTISS)                         '
          'R          1x2 vector specifying the dimensions of D22. That is,    '
          'R(1) = nbr of measurements                                          '
          'R(2) = nbr of controls                                              '
          'GMIN,GMAX  a-priori bounds on GOPT.   If no such bounds are         '
          'available, set  GMIN = GMAX = 0.  To test if some value             '
          'GAMA is feasible, set  GMIN = GMAX = GAMA.                          '
          'TOL        relative accuracy required on GOPT (default = 1e-2).     '
          'OPTIONS    optional 3-entry vector of control parameters for        '
          'numerical computations.                                             '
          'OPTIONS(1): not used                                                '
          'OPTIONS(2): valued in [0,1], default=0. The larger its              '
          'value is, the better the closed-loop damping is                     '
          'in the face of unit-circle zeros.                                   '
          'OPTIONS(3): default=1e-3. Reduced-order synthesis is                '
          'performed whenever                                                  '
          'rho(X*Y) >=  ( 1 - OPTIONS(3) ) * GOPT^2                            '
          'Output:                                                             '
          'GOPT       best H_infinity performance in [GMIN,GMAX]               '
          'K          central H_infinity controller for gamma = GOPT           '
          'X1,X2,..   X = X2/X1  and  Y = Y2/Y1  are the solutions of the two  '
          'H_infinity Riccati equations for  gamma = GOPT.                     '
          '                                                                    '};
helpwin(dhinfri, ttlStr);

case 96,
ttlStr ='DKCEN';
dkce ={' [K,gfin]=dkcen(P,r,gama,X1,X2,Y1,Y2,tolred)                   '
       '                                                               '
       'Given a discrete-time plant P and GAMA > 0,  DKCEN             '
       'computes a "central" H-infinity digital controller K(s) that   '
       '   * internally stabilizes the plant,                          '
       '   * yields a closed-loop gain no larger than GAMA.            '
       'This controller is calculated using either the stabilizing     '
       'solutions X,Y of the two H_infinity Riccati equations          '
       ' (classical approach), or any solutions X,Y  of the Riccati    '
       'inequalities (LMI approach).                                   '
       '                                                               '
       'Input:                                                         '
       'P         plant SYSTEM matrix (see LTISYS)                     '
       'R         size of D22, i.e.,  R = [ NY , NU ]  where           '
       'NY = number of measurements                                    '
       'NU = number of controls.                                       '
       'GAMA      required H-infinity performance                      '
       'X1,X2,..  Riccati approach:   X = X2/X1 and  Y = Y2/Y1         '
       'are the stabilizing solutions of the two                       '
       'Riccati equations                                              '
       'LMI approach: X = X2/X1 and  Y = Y2/Y1 are                     '
       'solutions of the two H_infinity Riccati                        '
       'inequalities.                                                  '
       'TOLRED    optional (default value = 1.0e-4).  Reduced-order    '
       'synthesis is performed whenever                                '
       'rho(X*Y) >=  (1 - TOLRED) * GAMA^2                             '
       'Output:                                               -1       '
       'K         Central controller   K(s) = DK + CK (zI-AK)  BK   in '
       'packed  form.                                                  '
       'GFIN      guaranteed closed-loop performance (GAMA may be reset'
       'to GFIN > GAMA for numerical stability reasons)                '
       '                                                               '};
helpwin(dkce, ttlStr);

case 8,
ttlStr ='DNORMINF';
dnormin ={' [gain,peakf]=dnorminf(sys,tol)                             '
          '                                                            '
          'Computes the peak gain of the discrete-time transfer        '
          'function                                                    '
          '                                   -1                       '
          'G (z) = D + C (zE - A)  B                                   '
          '                                                            '
          'The norm is finite if and only if (A,E) has no eigenvalue   '
          'on the unit circle                                          '
          '                                                            '
          'Input:                                                      '
          'SYS        system matrix description of G(z)  (see LTISYS)  '
          'TOL        relative accuracy required (default = 0.01)      '
          '                                                            '
          'Output:                                                     '
          'GAIN       peak gain  (RMS gain when G is stable)           '
          'PEAKF      "frequency" at which this norm is attained, i.e.:'
          '                                                            '
          'j*PEAKF                                                     '
          '                       || G ( e        ) ||  =  GAIN        '
          '                                                            '};
helpwin(dnormin, ttlStr);

case 99,
ttlStr ='DRICPEN';
dricpe ={' [X1,X2] = dricpen(H,L,n)                                           '
         'X = dricpen(H,L,n)                                                  '
         '                                                                    '
         'Generalized Schur Solver for discrete-time Riccati equations.       '
         '                                                                    '
         'Computes the stabilizing solution  X = X2/X1  of the                '
         'Riccati equation associated with the symplectic pencil              '
         '                                                                    '
         '                   [  A   F   B  ]       [ E   0   0 ]              '
         'H - t L  =  [ -Q   E'' -S  ]  - t  [ 0   A''  0 ]                   '
         '                   [  S''  0   R  ]       [ 0  -B''  0 ]            '
         '                                                                    '
         'The blocks B, S, R   may all be empty. The size of A is             '
         'specified by N (optional unless A is singular)                      '
         '                                                                    '
         'Assumptions:                                                        '
         '    * R and E are invertible,                                       '
         '    * the pencil H - t L has no finite generalized eigenvalue on    '
         'the unit circle.                                                    '
         '                                                                    '
         'When L is omitted, DRICPEN solves the Riccati equation of symplectic'
         'matrix H  (L and R are set to the default value L = I and R = []).  '
         'On output, X, X1, and X2 are empty if H - t L has eigenvalues on    '
         'the unit circle. In addition, X is empty whenever X1 is singular.   '
         '                                                                    '};
helpwin(dricpe, ttlStr);

case 35,
ttlStr ='FRFIT';
frfi ={'  [num,den]=frfit(omega,fresp,r,weight)                    '
       'sys = frfit(omega,fresp,r,weight)                          '
       '                                                           '
       'Called by MAGSHAPE/MRFIT                                   '
       '                                                           '
       'Fits frequency response data points by a stable transfer   '
       'function                                                   '
       'G(s) = NUM(s)/DEN(s)                                       '
       'of order R.                                                '
       '                                                           '
       'The interpolation uses Chebychev polynomials.  OMEGA is    '
       'a vector of frequencies and FRESP contains the frequency   '
       'response at these frequencies.   Frequency-weighted        '
       'interpolation is performed by specifying a vector WEIGHT of'
       'frequency weights.                                         '};
helpwin(frfi, ttlStr);

case 38,
ttlStr ='HINFGS';
hinfg ={' [gopt,pdk,R,S]=hinfgs(pds,r,gmin,tol,tolred)                 '
        '                                                              '
        'Gain-scheduled H-infinity control of parameter-dependent      '
        'systems with an affine dependence on the time-varying         '
        'parameters. These parameters are assumed to be measured       '
        'in real-time.                                                 '
        '                                                              '
        'This function implements the quadratic H-infinity performance '
        'approach.                                                     '
        '                                                              '
        'Input:                                                        '
        'PDS       parameter-dependent plant (see PSYS).               '
        'R         1x2 vector specifying the dimensions of D22:        '
        'R(1) = nbr of measurements                                    '
        'R(2) = nbr of controls                                        '
        'GMIN      target value for GOPT.  Set GMIN = 0 to compute the '
        'optimum GOPT, and set GMIN = GAMMA to test whether            '
        'the performance GAMMA is achievable   (Default = 0)           '
        'TOL       desired relative accuracy on the optimal performance'
        'GOPT  (Default = 1e-2)                                        '
        'TOLRED    optional (default value = 1e-4).  Reduced-order     '
        'synthesis is performed whenever                               '
        'rho(X*Y) >=  (1 - TOLRED) * GAMA^2                            '
        '                                                              '
        'Output                                                        '
        'PDK       polytopic representation  PDK = [K1 , ... , Kn]  of '
        'the gain-scheduled controller. The vertex controller          '
        'Kj  is associated with the  j-th  corner of the               '
        'parameter box as given by POLYDEC                             '
        'GOPT      optimal performance if GMIN=0, and some achievable  '
        'performance < GMIN  otherwise                                 '
        'R,S       solutions of the characteristic LMI system          '
        '                                                              '};
helpwin(hinfg, ttlStr);

case 23,
ttlStr ='HINFLMI';
hinflm ={' [gopt,K] = hinflmi(P,r)                                         '
         ' [gopt,K,X1,X2,Y1,Y2] = hinflmi(P,r,g,tol,options)               '
         '                                                                 '
         'Given the continuous-time plant P(s), computes the best          '
         'H-infinity performance GOPT as well as an H-infinity             '
         'controller  K(s)  that                                           '
         '    * internally stabilizes the plant, and                       '
         '    * yields a closed-loop gain no larger than GOPT.             '
         'HINFLMI implements the LMI-based approach.                       '
         '                                                                 '
         'To compute only GOPT, call HINFLMI with only one output argument.'
         'The input arguments  G, TOL, and OPTIONS  are optional.          '
         '                                                                 '
         'Input:                                                           '
         'P          plant SYSTEM matrix  (see LTISYS)                     '
         'R          1x2 vector specifying the dimensions of D22. That is, '
         'R(1) = nbr of measurements                                       '
         'R(2) = nbr of controls                                           '
         'G          user-specified target for the closed-loop performance.'
         'Set G=0 to compute GOPT, and set  G=GAMMA  to test               '
         'whether the performance GAMMA is achievable.                     '
         'TOL        relative accuracy  required on GOPT   (default=1e-2)  '
         'OPTIONS    optional 3-entry vector of control parameters for     '
         'the numerical computations.                                      '
         'OPTIONS(1): valued in [0,1] (default=0). Reduces the             '
         'norm of R when increased  -> slower                              '
         'controller dynamics                                              '
         'OPTIONS(2): same for S                                           '
         'OPTIONS(3): default = 1e-3. Reduced-order synthesis is           '
         'performed whenever                                               '
         'rho(X*Y) >=  ( 1 - OPTIONS(3) ) * GOPT^2                         '
         'Output:                                                          '
         'GOPT       best H-infinity performance                           '
         'K          central H-infinity controller for gamma = GOPT        '
         'X1,X2,..   X = X2/X1  and  Y = Y2/Y1  are solutions of the       '
         'two H-infinity Riccati inequalities for gamma = GOPT.            '
         'Equivalently,  R = X1  and  S = Y1  are solutions                '
         'of the characteristic LMIs since X2=Y2=GOPT*eye .                '
         '                                                                 '};
helpwin(hinflm, ttlStr);

case 24,
ttlStr ='HINFMIX';
hinfmi ={' [gopt,h2opt,K,R,S] = hinfmix(P,r,obj,region,dkbnd,tol)           '
         '                                                                  '
         'Mixed H2/H-infinity synthesis with regional pole placement        '
         'constraints.                                                      '
         '                                                                  '
         'Given an LTI plant P with state-space equations:                  '
         'dx/dt = A  * x + B1  * w + B2  * u                                '
         'zinf = Ci * x + Di1 * w + Di2 * u                                 '
         'z2  = C2 * x + D21 * w + D22 * u                                  '
         'y  = Cy * x + Dy1 * w + Dy2 * u                                   '
         'HINFMIX computes an output-feedback control u = K(s)*y            '
         'that                                                              '
         '  * keeps the RMS gain G from w to zinf below the value OBJ(1)    '
         '  * keeps the H2-norm  H from w to z2 below the value OBJ(2)      '
         '  * minimizes a trade-off criterion of the form                   '
         'OBJ(3) * G^2 + OBJ(4) * H^2                                       '
         '  * places the closed-loop poles in the LMI region specified      '
         'by REGION.                                                        '
         '                                                                  '
         'Input:                                                            '
         'P        LTI plant                                                '
         'R        1x3 vector listing the lengths of z2, y, and u           '
         'OBJ      4-entry vector specifying the H2/Hinf objective:         '
         'OBJ(1)  : upper bound on the RMS gain w->zinf (0=none)            '
         'OBJ(2)  : upper bound on the H2 norm  w->z2   (0=none)            '
         'OBJ(3:4): relative weighting of the H-infinity and                '
         'H2 performances (see above)                                       '
         'REGION   optional.  Mx(2M) matrix  [L,M]  specifying the pole     '
         'placement region as                                               '
         '                { z :  L + z * M + conj(z) * M'' < 0 }            '
         'Use the interactive function  LMIREG  to generate                 '
         'REGION.  The default  REGION=[]  enforces just                    '
         'closed-loop stability                                             '
         'DKBND    optional: bound on the norm of the static gain DK of K(s)'
         '           (100=default, 0 yields a strictly proper controller)   '
         'TOL      optional: desired relative accuracy on the objective     '
         'value  (default=1e-2)                                             '
         '                                                                  '
         'Output:                                                           '
         'GOPT     guaranteed closed-loop RMS gain from w to zinf           '
         'H2OPT    guaranteed closed-loop  H2 norm from w to z2             '
         'K        optimal output-feedback controller                       '
         'R,S      solutions of the LMI solvability conditions              '
         '                                                                  '};
helpwin(hinfmi, ttlStr);

case 91,
ttlStr ='HINFPAR';
hinfpa ={' [a,b1,b2,c1,c2,d11,d12,d21,d22]=hinfpar(P,r)                       '
         'data = hinfpar(P,r,string)                                          '
         '                                                                    '
         'Unpacks the standard H-infinity plant                               '
         '                                                                    '
         '                    |  a   b1   b2 |                                '
         'P  =   | c1  d11  d12 |                                             '
         '                    | c2  d21  d22 |                                '
         '                                                                    '
         'and returns its state-space matrices  a,b1,b2,...                   '
         'The 2x1 vector R  specifies the size of D22,  that is,              '
         'R = [ NY , NU ]  where                                              '
         'NY = # of measurements,      NU = # of controls.                    '
         'P must have been created with LTISYS.                               '
         '                                                                    '
         'To obtain one particular state-space matrix (e.g., c1),             '
         'set the third argument to one of the strings ''a'',''b1'',''b2'',...'
         'For instance,    c1 = hinfpar(P,r,''c1'')                           '};
helpwin(hinfpa, ttlStr);

case 26,
ttlStr ='HINFRIC';
hinfri ={' [gopt,K] = hinfric(P,r)                                          '
         ' [gopt,K,X1,X2,Y1,Y2,Preg] = hinfric(P,r,gmin,gmax,tol,options)   '
         '                                                                  '
         'For a continuous-time plant  P(s), computes the best              '
         'H-infinity performance GOPT in the interval [GMIN,GMAX]           '
         'as well as an H-infinity central controller  K(s)  that           '
         '    * internally stabilizes the plant, and                        '
         '    * yields a closed-loop gain no larger than GOPT.              '
         'HINFRIC implements the Riccati-based approach. The plant is       '
         'regularized when necessary.                                       '
         '                                                                  '
         'To compute just GOPT, call HINFRIC with only one output argument. '
         'The input arguments  GMIN, GMAX, TOL, and OPTIONS  may be jointly '
         'omitted                                                           '
         '                                                                  '
         'Input:                                                            '
         'P          plant SYSTEM matrix  (see LTISYS)                      '
         'R          1x2 vector specifying the dimensions of D22. That is,  '
         'R(1) = nbr of measurements (inputs of K)                          '
         'R(2) = nbr of controls (outputs of K)                             '
         'GMIN,GMAX  a-priori bounds on GOPT.   If no such bounds are       '
         'available, set  GMIN = GMAX = 0.  To test if some value           '
         'GAMA is feasible, set  GMIN = GMAX = GAMA.                        '
         'TOL        relative accuracy required on GOPT (default = 1e-2).   '
         'OPTIONS    optional 3-entry vector of control parameters for      '
         'numerical computations.                                           '
         'OPTIONS(1): valued in [0,1], default=0. The larger its            '
         'value is, the smaller the norms of the controller                 '
         'state-space matrices are.                                         '
         'OPTIONS(2): valued in [0,1], default=0. The larger its            '
         'value is, the better the closed-loop damping is                   '
         'in the face of jw-axis zeros.                                     '
         'OPTIONS(3): default=1e-3. Reduced-order synthesis is              '
         'performed whenever                                                '
         'rho(X*Y) >=  ( 1 - OPTIONS(3) ) * GOPT^2                          '
         'Output:                                                           '
         'GOPT       best H-infinity performance in [GMIN,GMAX]             '
         'K          central H-infinity controller for gamma = GOPT         '
         'X1,X2,..   X = X2/X1  and  Y = Y2/Y1  are the solutions of the two'
         'H-infinity Riccati equations for  gamma = GOPT.                   '
         'PREG       regularized plant if P(s) was singular                 '
         '                                                                  '};
helpwin(hinfri, ttlStr);

case 54,
ttlStr ='ISLSYS';
islsy ={'bool = islsys(sys)                 '};
helpwin(islsy, ttlStr);

case 66,
ttlStr ='ISPSYS';
ispsy ={'bool = ispsys(sys)                                    '
        '                                                      '
        'Returns 1 if SYS is a polytopic or parameter-dependent'
        'system                                                '};
helpwin(ispsy, ttlStr);


case 95,
ttlStr ='KLMI';
klm ={' [K,gfin]=klmi(P,r,gama,X1,X2,Y1,Y2,tolred)                       '
      '                                                                  '
      'Computes a "central" H-infinity controller K(s) given             '
      'the continuous-time plant P(s) and some GAMA > 0. This            '
      'controller                                                        '
      '   * internally stabilizes the plant, and                         '
      '   * yields a closed-loop gain no larger than GAMA.               '
      'K(s) is computed from the solutions  X=X2/X1  and  Y=Y2/Y1        '
      'of the two H-infinity Riccati inequalities (LMI approach)         '
      '                                                                  '
      'Input:                                                            '
      'P            plant SYSTEM matrix (see LTISYS)                     '
      'R            size of D22, i.e.,  R = [ NY , NU ]  where           '
      'NY = number of measurements                                       '
      'NU = number of controls.                                          '
      'GAMA         required H-infinity performance                      '
      'X1,X2,...    X = X2/X1 and  Y = Y2/Y1 are solutions of the        '
      'two H_infinity Riccati inequalities.                              '
      'TOLRED       optional (default value = 1.0e-4).  Reduced-order    '
      'synthesis is performed whenever                                   '
      'rho(X*Y) >=  (1 - TOLRED) * GAMA^2                                '
      'Output:                                                  -1       '
      'K            central controller   K(s) = DK + CK (sI-AK)  BK   in '
      'SYSTEM matrix form.                                               '
      'GFIN         guaranteed closed-loop performance (GAMA may be reset'
      'to GFIN > GAMA for numerical stability reasons)                   '
      '                                                                  '};
helpwin(klm, ttlStr);

case 94,
ttlStr ='KRIC';
kri ={' [K,gfin]=kric(P,r,gama,X1,X2,Y1,Y2,tolred)                      '
      '                                                                 '
      'Computes a "central" H-infinity controller K(s) given            '
      'the REGULAR continuous-time plant P(s) and some GAMA > 0.        '
      'This controller                                                  '
      '   * internally stabilizes the plant, and                        '
      '   * yields a closed-loop gain no larger than GAMA.              '
      'K(s) is computed from the stabilizing solutions  X=X2/X1         '
      'and  Y=Y2/Y1  of the two H_infinity Riccati equations.           '
      '                                                                 '
      'Input:                                                           '
      'P           plant SYSTEM matrix (see LTISYS)                     '
      'R           size of D22, i.e.,  R = [ NY , NU ]  where           '
      'NY = number of measurements                                      '
      'NU = number of controls.                                         '
      'GAMA        required H-infinity performance                      '
      'X1,X2,...   X = X2/X1 and  Y = Y2/Y1 are the stabilizing         '
      'solutions of the two H_infinity Riccati equations.               '
      'TOLRED      optional (default value = 1.0e-4).  Reduced-order    '
      'synthesis is performed whenever                                  '
      'rho(X*Y) >=  (1 - TOLRED) * GAMA^2                               '
      'Output:                                                -1        '
      'K           central controller  K(s) = DK + CK (sI-AK)  BK  in   '
      'SYSTEM matrix form.                                              '
      'GFIN        guaranteed closed-loop performance (GAMA may be reset'
      'to GFIN > GAMA for numerical stability reasons)                  '};
helpwin(kri, ttlStr);

case 25,
ttlStr ='LMIREG';
lmire ={'region = lmireg                                              '
        'region = lmireg(reg1,reg2,...)                               '
        '                                                             '
        'Interactive specification of LMI regions for state-feedback  '
        'synthesis with pole placement constraints (see MSFSYN).      '
        'The output REGION is a description of the prescribed region  '
        'and can be passed directly to MSFSYN.                        '
        '                                                             '
        'LMIREG can be used either interactively or to intersect a set'
        'of pre-existing LMI regions REG1, REG2, ...   The respective '
        'syntaxes are                                                 '
        'region = lmireg                                              '
        'and                                                          '
        'region = lmireg(reg1,reg2,...)                               '
        '                                                             '};
helpwin(lmire, ttlStr);

case 101,
ttlStr ='LNULL';
lnul ={'Nl = lnull(M,tolabs,tolrel)                                  '
       '                                                             '
       'Computes the left null space of a matrix M based on its SVD. '
       '                                                             '
       'A singular value S(i) is regarded as ``zero'''' when it falls'
       'below the absolute tolerance TOLABS or the relative tolerance'
       'TOLREL.  That is,                                            '
       'S (i)  <  TOLABS    or    S (i)  <  TOLREL * S (1)           '
       'where S(1) is the largest singular value.                    '
       '                                                             '};
helpwin(lnul, ttlStr);

case 52,
ttlStr ='LTISS';
ltis ={'  [a,b,c,d,e]=ltiss(sys)                                    '
       '                                                            '
       'Extracts the state-space matrices A,B,C,D,E from the SYSTEM '
       'matrix representation SYS of the LTI system                 '
       '                                        -1                  '
       'G(s)  =  D + C (s E - A)  B                                 '
       '                                                            '
       'WARNING:  if the output argument E is omitted, LTISS returns'
       'the realization (E\A, E\B, C, D)  of  G(s)                  '
       '                                                            '
       'Input                                                       '
       'SYS          SYSTEM matrix created with LTISYS              '
       '                                                            '
       'Output                                                      '
       'A,B,C,D,E    state-space matrices of SYS                    '
       '                                                            '};
helpwin(ltis, ttlStr);

case 51,
ttlStr ='LTISYS';
ltisy ={'sys = ltisys(a,b,c,d,e)                                         '
        'sys = ltisys(''tf'',n,d)                                        '
        '                                                                '
        'Stores the state-space realization (A,B,C,D,E) of an LTI system '
        'as the SYSTEM matrix                                            '
        '                                                                '
        '                       | A+j(E-I)   B   na  |                   '
        'SYS  =    |    C       D    0  |                                '
        '                       |    0       0  -Inf |                   '
        '                                                                '
        'where  na = size(A,1).  The matrices A through E should be real.'
        'When omitted, D and E are set to the default values  D=0  and   '
        'E=I.  The values 0 and 1 for E are interpreted as E=0  and  E=I.'
        '                                                                '
        'SYS = LTISYS(A)  and  SYS = LTISYS(A,E)  specify the autonomous '
        'systems                                                         '
        'dx/dt = A x     and     E dx/dt = A x .                         '
        '                                                                '
        '                                                                '
        'SISO systems can also be specified via their transfer function  '
        'N(s)/D(s).  The syntax is then   SYS = LTISYS(''tf'',N,D)  where'
        'N and D are the vector representation of the polynomials N(s)   '
        'and D(s).                                                       '
        '                                                                '};
helpwin(ltisy, ttlStr);

case 53,
ttlStr ='LTITF';
ltit ={'   [num,den] = ltitf(sys)                                 '
       '                                                          '
       'For SISO systems, returns the numerator and denominator of'
       'the transfer function  given a state-space realization SYS'
       '                                                          '
       'Input:                                                    '
       'SYS        state-space realization of the system in       '
       'packed form                                               '
       'Output:                                                   '
       'NUM,DEN    numerator and denominator of the transfer      '
       'function  (vectors of the polynomial                      '
       'coefficients)                                             '
       '                                                          '};
helpwin(ltit, ttlStr);

case 33,
ttlStr ='MAGSHAPE';
magshap ={'magshape                                                      '
          '                                                              '
          'Graphical user interface for shaping filter specification.    '
          'Each filter is specified by a few characteristic points of    '
          'its magnitude vs. frequency profile.  A rational fit of       '
          'these data points is then performed and the SYSTEM matrix     '
          'of each filter is written in the MATLAB variable of the same  '
          'name.                                                         '
          '                                                              '
          'Several filters can be specified in parallel. If some filters '
          'are already defined in the MATLAB environment, their magnitude'
          'response is automatically drawn in the MAGSHAPE worksheet.    '
          '                                                              '};
helpwin(magshap, ttlStr);

case 44,
ttlStr ='MISLDEM';
mislde ={'MISLDEM   Gain-scheduling control of a missile autopilot (demo)'};
helpwin(mislde, ttlStr);

case 22,
ttlStr ='MSFSYN';
msfsy ={' [gopt,h2opt,K,Pcl,X] = msfsyn(P,r,obj,region,tol)            '
        '                                                              '
        'Multi-model/multi-objective state-feedback synthesis          '
        '                                                              '
        'Given a plant with state-space equations                      '
        'dx/dt = A  * x + B1  * w + B2  * u                            '
        'zinf  = C1 * x + D11 * w + D12 * u                            '
        'z2    = C2 * x + D21 * w + D22 * u                            '
        'MSFSYN computes a state-feedback control  u = Kx  that        '
        '  * keeps the RMS gain G from w to zinf below the value OBJ(1)'
        '  * keeps the H2-norm  H from w to z2 below the value OBJ(2)  '
        '  * minimizes a trade-off criterion of the form               '
        'OBJ(3) * G^2 + OBJ(4) * H^2                                   '
        '  * places the closed-loop poles in the LMI region specified  '
        'by REGION.                                                    '
        '                                                              '
        'REMARK:  the H2 norm is finite iff. D21=0                     '
        '                                                              '
        'Input:                                                        '
        'P        LTI plant or polytopic/parameter-dependent system    '
        '           (see PSYS)                                         '
        'R        R(1) = # of outputs z2,  R(2) = # of controls u      '
        'OBJ      four-entry vector specifying the H2/Hinf objective:  '
        'OBJ(1)  : upper bound on the RMS gain w->zinf (0=none)        '
        'OBJ(2)  : upper bound on the H2 norm  w->z2   (0=none)        '
        'OBJ(3:4): relative weighting of the H-infinity and            '
        'H2 performances (see above)                                   '
        'REGION   optional.  Mx(2M) matrix  [L,M]  specifying the pole '
        'placement region as                                           '
        '                { z :  L + z * M + conj(z) * M'' < 0 }        '
        'Use the interactive function  LMIREG  to generate             '
        'REGION.  The default  REGION=[]  enforces just                '
        'closed-loop stability                                         '
        'TOL      optional: desired relative accuracy on the objective '
        'value  (Default = 1e-2)                                       '
        '                                                              '
        'Output:                                                       '
        'GOPT     computed bound on the closed-loop RMS gain w -> zinf '
        'H2OPT    computed bound on the closed-loop H2 norm  w -> z2   '
        'K        optimal state-feedback gain                          '
        'Pcl      closed-loop system for u = Kx                        '
        'X        Lyapunov matrix yielding the optimal trade-off       '
        '                                                              '};
helpwin(msfsy, ttlStr);


case 17,
ttlStr ='MUBND';
mubn ={' [mu,D,G]=mubnd(M,delta,target)                     '
       '                                                    '
       'Computes the upper bound  MU  on the mixed-mu       '
       'structured singular value  for the matrix M and     '
       'the norm-bounded uncertainty DELTA.                 '
       '                                                    '
       'If each block  Dj  of DELTA is bounded in norm by   '
       'dj, the matrix   I - M * DELTA  remains invertible  '
       'as long as                                          '
       'MU * || Dj ||  <  dj                                '
       '                                                    '
       '                                                    '
       'When TARGET is specified, the minimization of MU    '
       'stops as soon as  MU <= TARGET  (Default = 1e-3).   '
       'MUBND also returns the optimal D,G scaling matrices.'
       '                                                    '};
helpwin(mubn, ttlStr);

case 19,
ttlStr ='MUPERF';
muper ={' [marg,peakf] = muperf(sys,delta,g,freqs)               '
        ' [grob,peakf] = muperf(sys,delta,0,freqs)               '
        '                                                        '
        'Worst-case RMS performance of uncertain systems with    '
        'norm- or sector-bounded linear time-invariant           '
        'uncertainty:                                            '
        '___________                                             '
        '                   |         |                          '
        '              |----|  DELTA  |<---|                     '
        '              |    |_________|    |                     '
        '              |                   |                     '
        '              |    ___________    |                     '
        '              |--->|         |----|                     '
        '                   |   SYS   |                          '
        'u  ----->|_________|----->  y                           '
        '                                                        '
        '                                                        '
        'Depending on the third argument G, MUPERF computes:     '
        '   * if G > 0, the portion MARGIN of the uncertainty    '
        'bounds where the RMS gain from u to y remains no        '
        'larger than G.  The performance G is robust iff         '
        'MARGIN >= 1.                                            '
        '   * if G = 0, the worst-case RMS gain GROB from u to y.'
        'This gain is finite iff the interconnection is          '
        'robustly stable.                                        '
        'These estimates are based on the mixed-mu upper bound.  '
        '                                                        '
        'Input:                                                  '
        'SYS        dynamical system  (see LTISYS)               '
        'DELTA      uncertainty description  (see UBLOCK)        '
        'G          if positive, RMS performance to be           '
        'robustly maintained    (Default = 0)                    '
        'FREQS      vector of frequencies  (optional)            '
        '                                                        '
        'Output:                                                 '
        'MARGIN     robust performance margin for the            '
        'prescribed maximum gain  G > 0                          '
        'GROB       robust H-infinity performance                '
        'PEAKF      frequency near which it is achieved          '
        '                                                        '};
helpwin(muper, ttlStr);


case 18,
ttlStr ='MUSTAB';
musta ={' [margin,peakf,fs,ds,gs] = mustab(sys,delta,freqs)          '
        '                                                            '
        'Estimates the robust stability margin MARGIN of uncertain   '
        'systems with norm- or sector-bounded linear time-invariant  '
        'uncertainty.                                                '
        '___________                                                 '
        '                   |         |                              '
        '              +----|  DELTA  |<---+                         '
        '              |    |_________|    |                         '
        '              |                   |                         '
        '              |    ___________    |                         '
        '              +--->|         |----+                         '
        '                   |   SYS   |                              '
        'u  ----->|_________|----->  y                               '
        '                                                            '
        '                                                            '
        'The interconnection is robustly stable if MARGIN >= 1.      '
        '                                                            '
        'The reciprocal of MARGIN is the upper bound on the mixed mu.'
        '                                                            '
        'Input:                                                      '
        'SYS         dynamical system (see LTISYS)                   '
        'DELTA       uncertainty structure (see UBLOCK)              '
        'FREQS       optional vector of frequency points             '
        '                                                            '
        'Output:                                                     '
        'MARGIN      robust stability margin                         '
        'PEAKF       frequency near which the margin is weakest      '
        'FS,DS,GS    D,G scalings at the tested frequencies FS.      '
        'The scalings  Di, Gi  at the frequency  FS(i)               '
        'are given by                                                '
        'Di = getdg(DS,i);    Gi = getdg(GS,i);                      '
        '                                                            '};
helpwin(musta, ttlStr);

case 9,
ttlStr ='NORM2';
norm ={'nh2 = norm2(sys)                                           '
       '                                                           '
       'Computes the H2 norm of a stable and strictly proper LTI   '
       'system                                                     '
       '                               -1                          '
       'SYS = C (sE-A)  B                                          '
       '                                                           '
       'This norm is given by                                      '
       '______________                                             '
       '                 /                                         '
       'V  Trace(C*P*C'')                                          '
       '                                                           '
       'where P solves the Lyapunov equation:  A*P+P*A''+B*B'' = 0.'};
helpwin(norm, ttlStr);

case 7,
ttlStr ='NORMINF';
normin ={' [gain,peakf]=norminf(sys,tol)                            '
         '                                                          '
         'Computes the peak gain of the frequency response of       '
         '                                   -1                     '
         'G (s) = D + C (sE - A)  B                                 '
         '                                                          '
         'The norm is finite if and only if (A,E) has no eigenvalue '
         'on the imaginary axis.                                    '
         '                                                          '
         'Input:                                                    '
         'SYS        system matrix description of G(s)  (see LTISYS)'
         'TOL        relative accuracy required  (default = 0.01)   '
         '                                                          '
         'Output:                                                   '
         'GAIN       peak gain  (RMS gain if G is stable)           '
         'PEAKF      frequency at which this norm is attained.      '
         'That is, such that                                        '
         '                                                          '
         '                     || G ( j * PEAKF ) ||  =  GAIN       '
         '                                                          '};
helpwin(normin, ttlStr);

case 97,
ttlStr ='PARROTT';
parrot ={' [gmin,x]=parrott(a,b,c,rx,cx,g);                             '
         '                                                              '
         'Given matrices A,B,C and G > 0, computes a matrix X such that '
         '                                                              '
         '	   	 || A   B ||                                             '
         '    	   	 ||       ||	 <  G                                   '
         '		 || C   X ||2                                               '
         '                                                              '
         ' (the 2-norm is the largest singular value norm). This problem'
         'is solvable if and only if                                    '
         'T   T                                                         '
         'G >=  GMIN := MAX ( || (A , B) || , || (A , C ) || )          '
         '                                                              '
         'Input:                                                        '
         'A,B,C      real matrices of compatible dimensions.            '
         'A can be the empty matrix [].                                 '
         'RX,CX      row and column dimensions of XMIN (optional if A   '
         'is not empty)                                                 '
         'G          target value for the norm (GMIN by default)        '
         '                                                              '
         'Output:                                                       '
         'GMIN       least achievable norm                              '
         'X          solution given by                                  '};
helpwin(parrot, ttlStr);


case 14,
ttlStr ='PDLSTAB';
pdlsta ={' [tau,Q0,Q1,...] = pdlstab(pds,options)                      '
         '                                                             '
         'Robust stability of polytopic or affine parameter-dependent  '
         'systems (P-system)                                           '
         '                                                             '
         'For affine systems,  PDLSTAB seeks a Lyapunov matrix Q(p)    '
         'affine in p and such that the Lyapunov function              '
         '                                                             '
         'V(x) = x''*P(p)*x    with    P(p) = inv(Q(p))                '
         '                                                             '
         'establishes stability along all parameter trajectories.      '
         '                                                             '
         'For time-invariant polytopic systems where either A or E is  '
         'constant, PDLSTAB seeks vertex Lyapunov matrices Q0, Q1,...  '
         'such that the Lyapunov function                              '
         '                                                             '
         'V(x)=x''*inv(Q)*x   with  Q = c0*Q0 + ... + cn*Qn            '
         '                                                             '
         'proves stability for the entire polytope of systems          '
         ' (A,E)=(c0*A0+...+cn*An,E) or (A,E)=(A,c0*E0+...+cn*En).     '
         '                                                             '
         'Input:                                                       '
         'PDS       polytopic or parameter-dependent system (see PSYS) '
         'OPTIONS   optional 2-entry vector.                           '
         'OPTIONS(1)=0 :  tests robust stability   (default)           '
         '                      =1 :  maximizes the stability region by'
         'dilatation of the parameter box                              '
         'around its center (affine PDS only)                          '
         'OPTIONS(2)=0 :  fast mode (default)                          '
         '                      =1 :  least conservative mode          '
         'Output:                                                      '
         'TAU       Depending on OPTIONS(1),  negativity level or      '
         'stability region as a percentage of the parameter            '
         'box specified by PV  (TAU=1 means 100%)                      '
         'Q0,Q1,..  For affine PDS,                                    '
         'Q(p) = Q0 + p1*Q1 + ... + pn*Qn                              '
         'For polytopic PDS,  Q0,Q1,... are the values of Q            '
         'for the vertex systems (A0,E), (A1,E),...                    '
         '                                                             '};
helpwin(pdlsta, ttlStr);

case 71,
ttlStr ='PDSIMUL';
pdsimu ={'  [t,x,y] = pdsimul(pds,''traj'',tf,''ut'',xi,options)         '
         '                                                               '
         'Simulation of an (affine) parameter-dependent system           '
         'along the parameter trajectory specified by the function       '
         '  ''TRAJ''.  The function PDSIMUL calls ODE15s to integrate    '
         'the time response of this linear time-varying system.          '
         '                                                               '
         'Without output arguments, PDSIMUL plots the output             '
         'trajectories.                                                  '
         '                                                               '
         'Input:                                                         '
         'PDS       affine parameter-dependent system (see PSYS)         '
         '   ''TRAJ''    name of the function  p=TRAJ(t)  specifying the '
         'parameter trajectory. This function takes a time               '
         't and returns a value p of the parameter vector.               '
         'TF        final time for the integration (initial=0)           '
         '   ''UT''      name of the input function  u=UT(t). The default'
         'is a step input.                                               '
         'XI        initial state of the system (Default = 0)            '
         'OPTIONS   control parameters for the ODE integration           '
         '             (see ODESET)                                      '
         '                                                               '
         'Output:                                                        '
         'T         integration time points                              '
         'X         state trajectories (X(:,1) = first state, etc.)      '
         'Y         output trajectories (Y(:,1) = first output, etc)     '
         '                                                               '};
helpwin(pdsimu, ttlStr);


case 69,
ttlStr ='POLYDEC';
polyde ={'  [c,vertx] = polydec(pv,p)                             '
         'vertx = polydec(pv)                                     '
         '                                                        '
         'Given a parameter vector PV ranging in a box and a value'
         'P of this parameter vector,  POLYDEC returns the corners'
         'of the parameter box (columns of VERTX) and the convex  '
         'decomposition  C = (c1,...,cn) of P over this set of    '
         '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)                                     '
         '                                                        '};
helpwin(polyde, ttlStr);

case 15,
ttlStr ='POPOV';
popo ={' [tau,P,S,N] = popov(sys,delta,flag)                        '
       '                                                            '
       'Using the Popov criterion, this function tests if the       '
       'interconnection                                             '
       '___________                                                 '
       '                   |         |                              '
       '              +----|  Phi(.) |<---+                         '
       '              |    |_________|    |                         '
       'w  |                   | y                                  '
       '              |    ___________    |                         '
       '              +--->|         |----+                         '
       '                   |   SYS   |                              '
       '             ----->|_________|----->                        '
       '                                                            '
       '                                                            '
       'is stable for any operator Phi in the uncertainty class     '
       'specified by DELTA.   This class can include nonlinear      '
       'and/or time-varying uncertainties with norm or sector       '
       'bounds.                                                     '
       '                                                            '
       'Stability is established when TAU < 0, in which case POPOV  '
       'returns a Lyapunov matrix P and multipliers S and N proving '
       'stability.                                                  '
       '                                                            '
       'Input:                                                      '
       'SYS        dynamical system (see LTISYS)                    '
       'DELTA      description of the uncertainty class (see UBLOCK)'
       'FLAG       optional, 0 by default. Setting FLAG=1 reduces   '
       'conservatism for real parameter uncertainty at              '
       'the expense of more intensive computations                  '
       '                                                            '
       'Output:                                                     '
       'TAU        optimal largest eigenvalue of the corresponding  '
       'LMI feasibility problem.  Robust stability is               '
       'guaranteed when TAU < 0, i.e., when the Popov               '
       'LMIs are feasible                                           '
       'P          x''*P*x  is the quadratic part of the Lyapunov   '
       'function proving stability                                  '
       'S,N        if TAU < 0, S and N are the Popov "multipliers"  '
       'proving stability                                           '
       '                                                            '};
helpwin(popo, ttlStr);

case 65,
ttlStr ='PSINFO';
psinf ={'PSINFO  provides various information about a polytopic or  '
        'parameter-dependent system  PS  specified with PSYS.       '
        '                                                           '
        'PSINFO(PS)                                                 '
        'displays the system characteristics                        '
        '                                                           '
        ' [TYP,K,NS,NI,NO] = PSINFO(PS)                             '
        'returns the type of system (''pol'' for polytopic, ''aff'' '
        'for affine parameter-dependent),  the number K of SYSTEM   '
        'matrices involved in its definition,  and the numbers      '
        'NS, NI, NO  of states, inputs, and outputs.                '
        '                                                           '
        '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  Sk  involved in the        '
        'definition of PS                                           '
        '                                                           '
        'SYS = PSINFO(PS,''eval'',P)                                '
        'instantiates the polytopic or parameter-dependent state-   '
        'space model.  The result is a SYSTEM matrix  SYS  given    '
        'by                                                         '
        'p1*S1 + ... + pk*Sk                                        '
        '     * SYS =  -------------------    if PS is polytopic and'
        'p1 + ... + pk                                              '
        '                                                           '
        'P = (p1,...,pk), pj >= 0  is a set of polytopic            '
        'coordinates                                                '
        '     * SYS = S0 + p1*S1 + ... + pk*Sk   if PS is affine and'
        'P is a particular value of the parameter vector            '
        '                                                           '};
helpwin(psinf, ttlStr);

case 64,
ttlStr ='PSYS';
psy ={'Specification of uncertain state-space models              '
      '                                                           '
      'E dx/dt  =  A x  +  B u                                    '
      'y  =  C x  +  D u                                          '
      '                                                           '
      'where the SYSTEM matrix   S = [ A+jE  B ; C  D ]   either  '
      '  (1) varies in a fixed polytope of SYSTEM matrices, or    '
      '  (2) is a fixed function  S(p)  of some uncertain/time-   '
      'varying parameter vector   p = (p1, p2, ... , pk)          '
      '                                                           '
      'Polytopic systems:                                         '
      ' ------------------                                        '
      'S = PSYS([S1 S2 ... Sk])    defines a polytopic system     '
      'varying in the convex hull of the SYSTEM matrices S1,...,SK'
      '                                                           '
      'Affine parameter-dependent systems:                        '
      ' -----------------------------------                       '
      'S = PSYS(pv,[S0 S1 ... Sk])    specifies a system  S(p)    '
      'depending affinely on the parameter vector p, i.e.,        '
      'S(p)  =  S0 + p1*S1 + ... + pk*Sk                          '
      'where S0,S1,...Sk are given SYSTEM matrices.   The first   '
      'input PV is the parameter vector description (see PVEC).   '
      '                                                           '
      'WARNING: to make E(p) independent of p, set the E matrices '
      'of S1,...,Sk to zero                                       '
      '                                                           '};
helpwin(psy, ttlStr);

case 67,
ttlStr ='PVEC';
pve ={'Quantification of uncertainty on physical parameters.'
      '                                                     '
      'PVEC specifies the range of values and rates of      '
      'variation of an uncertain or time-varying parameter  '
      'vector                                               '
      'p = ( p1, p2, ... , pk )                             '
      'The data stored by PVEC is used in the description of'
      'parameter-dependent systems (see PSYS).              '
      '                                                     '
      'Two types of parameter ranges can be specified:      '
      '                                                     '
      'PV = PVEC(''box'',RANGE,RATE)                        '
      'parameter vector valued in a box.                    '
      'The Kx2 matrices RANGE and RATE specify the          '
      'lower and upper  bounds on pj and its rate of        '
      'variation  dpj/dt:                                   '
      '                                                     '
      'RANGE(j,1)  <=    pj    <=  RANGE(j,2)               '
      'RATE(j,1)   <=  dpj/dt  <=  RATE(j,2)                '
      '                                                     '
      'If RATE is omitted, p is assumed time-invariant.     '
      'Set  RATE(j,1) = -Inf and  RATE(j,2) = Inf  for      '
      'arbitrarily fast or discontinuous variations.        '
      '                                                     '
      'PV = PVEC(''pol'', [V1 V2 ... VN] )                  '
      'parameter vector valued in a polytope of the         '
      'parameter space. The vertices of this polytope       '
      'are "extremal" values  V1,V2,...,VN  of P.           '};
helpwin(pve, ttlStr);

case 68,
ttlStr ='PVINFO';
pvinf ={'Retrieves information about a parameter vector specified         '
        'with PVEC                                                        '
        '                                                                 '
        ' [TYP,K,NV] = PVINFO(PV)   returns the type (''box'' or ''pol''),'
        'the number K of parameters and, in the polytopic                 '
        'case, the number NV of vertices defining the                     '
        'polytopic parameter range.                                       '
        'Box case:                                                        '
        ' ---------                                                       '
        ' [PMIN,PMAX,DPMIN,DPMAX] = PVINFO(PV,''par'',J)                  '
        'returns the lower and upper bounds on the range                  '
        'and rate of variation of the J-th parameter                      '
        '                                                                 '
        'Polytope case:                                                   '
        ' --------------                                                  '
        'Vj = PVINFO(PV,''par'',J)  returns the J-th vertex of the        '
        'polytopic parameter range                                        '
        '                                                                 '
        'P = PVINFO(PV,''eval'',COORD)                                    '
        'Returns the parameter vector value given a set of                '
        'polytopic coordinates.   If PV = [PV1,...,PVk]                   '
        'and  COORD = [c1,...,ck], the result is                          '
        'P = c1*PV1 + ... + ck*PVk                                        '
        '                                                                 '};
helpwin(pvinf, ttlStr);

case 13,
ttlStr ='QUADPERF';
quadper ={' [perf,P] = quadperf(pds,g,options)                                 '
          '                                                                    '
          'Quadratic RMS gain of an affine or polytopic parameter-dependent    '
          'systems PDS.                                                        '
          '                                                                    '
          'If OPTION(1)=0,  QUADPERF estimates the quadratic H-infinity        '
          'performance of PDS if G=0, or tests if the performance G >0         '
          'is robust.                                                          '
          '                                                                    '
          'If OPTION(1)=1,  QUADPERF maximizes the parameter region where the  '
          'quadratic H-infinity performance G >0 can be sustained.  The maximal'
          'region is a dilatation of the prescribed parameter box around its   '
          'center.  This option is only available for affine PDS.              '
          '                                                                    '
          'Input:                                                              '
          'PDS       polytopic or parameter-dependent system (see PSYS)        '
          'G         prescribed performance    (default=0)                     '
          'OPTIONS   optional 3-entry vector.                                  '
          'OPTIONS(1)   :  see above (default=0)                               '
          'OPTIONS(2)=0 :  fast mode (default)                                 '
          '                      =1 :  least conservative mode                 '
          'OPTIONS(3)   :  bound on the condition number of P                  '
          '                            (default = 1e9)                         '
          'Output:                                                             '
          'PERF      if OPTIONS(1)=0, quadratic RMS gain.  Otherwise,          '
          'percentage of the parameter box PV where the                        '
          'performance G can be guaranteed  (PERF=1 means 100%)                '
          'P         Lyapunov matrix P                                         '
          '                                                                    '};
helpwin(quadper, ttlStr);

case 12,
ttlStr ='QUADSTAB';
quadsta ={' [tau,P] = quadstab(pds,options)                                '
          '                                                                '
          'Quadratic stability of polytopic or parameter-dependent         '
          'systems                                                         '
          '                                                                '
          'QUADSTAB seeks a single Lyapunov matrix Q > 0 such that         '
          '                                                                '
          'A(p)*Q*E(p)'' + E(p)*Q*A(p)''  < 0                              '
          '                                                                '
          'over the range of values of the parameter vector p.  The        '
          'Lyapunov function                                               '
          'V(x) = x''*P*x    with    P = inv(Q)                            '
          'then establishes stability over the entire parameter range      '
          'and for arbitrarily fast parameter variations.                  '
          '                                                                '
          'The largest quadratic stability box can be computed by          '
          'setting OPTIONS(1) appropriately.                               '
          '                                                                '
          'Input:                                                          '
          'PDS       polytopic or parameter-dependent system (see PSYS)    '
          'OPTIONS   optional 3-entry vector.                              '
          'OPTIONS(1)=0 :  tests quadratic stability (default)             '
          '                      =1 :  maximizes the stability region by   '
          'dilatation of the parameter box                                 '
          'around its center (affine PDS only)                             '
          'OPTIONS(2)=0 :  fast mode (default)                             '
          '                      =1 :  least conservative mode             '
          'OPTIONS(3)   :  bound on the condition number of P              '
          '                            (default = 1e8)                     '
          'Output:                                                         '
          'TAU       Depending on OPTIONS(1), negativity level or quadratic'
          'stability region as a percentage of the parameter box           '
          'specified by PV  (TAU=1 means 100%)                             '
          'P         Lyapunov matrix P = inv(Q)                            '
          '                                                                '};
helpwin(quadsta, ttlStr);

case 43,
ttlStr ='RADARDEM';
radarde ={'RADARDEM   Loop-shaping design of the velocity loop of a '
          'radar antenna (demo)                                     '};
helpwin(radarde, ttlStr);

case 98,
ttlStr ='RICPEN';
ricpe ={' [X1,X2] = ricpen(H,L)                                              '
        'X = ricpen(H,L)                                                     '
        '                                                                    '
        'Generalized Schur Solver for continuous-time Riccati equations.     '
        '                                                                    '
        'Computes the stabilizing solution  X = X2/X1  of the                '
        'Riccati equation associated with the Hamiltonian pencil             '
        '                                                                    '
        '               [  A     F     S1 ]       [  E   0   0 ]             '
        'H - t L  =  [  G    -A''   -S2 ]  - t  [  0   E''  0 ]              '
        '               [ S2''   S1''     R ]       [  0   0   0 ]           '
        '                                                                    '
        'The blocks   S1, S2, R  may be all empty.                           '
        '                                                                    '
        'Assumptions:                                                        '
        '    * R  and  E are invertible,                                     '
        '    * the pencil H - t L has no finite generalized eigenvalue on    '
        'the imaginary axis.                                                 '
        '                                                                    '
        'When L is omitted, RICPEN solves the Riccati equation of Hamiltonian'
        'matrix H   (L and R are set to the default value L=I and R=[]).     '
        'If  H - t L  has imaginary-axis eigenvalues,  X, X1, and X2 are     '
        'empty on output. In addition, X is empty whenever X1 is singular.   '
        '                                                                    '};
helpwin(ricpe, ttlStr);

case 82,
ttlStr ='SADD';
sad ={'sys = sadd(sys1,sys2,...)                                 '
      '                                                          '
      'Forms the parallel interconnection of the systems  SYS1,  '
      'SYS2, ...   In terms of transfer fucntions, the result is '
      '                                                          '
      'SYS = SYS1 + SYS2 + ...                                   '
      '                                                          '
      'One (and at most one) of these systems can be polytopic or'
      'parameter-dependent.  SADD takes up to 10 input arguments.'
      '                                                          '};
helpwin(sad, ttlStr);

case 42,
ttlStr ='SATELDEM';
satelde ={'SATELDEM   Robust state-feedback control of satellite attitude (demo)'};
helpwin(satelde, ttlStr);

case 60,
ttlStr ='SBALANC';
sbalan ={' [a,b,c] = sbalanc(a,b,c,cond)                                 '
         'sys = sbalanc(sys,cond)                                        '
         '                                                               '
         'Balances and scales the state-space realization (A,B,C) using a'
         'diagonal similarities. This realization can be specified as a  '
         'system matrix (see LTISYS)                                     '
         '                                                               '
         'The optional argument COND is an upper bound on the condition  '
         'number of this similarity  (default = 1.0e8).                  '
         '                                                               '};
helpwin(sbalan, ttlStr);

case 100,
ttlStr ='SCHRCOMP';
schrcom ={'SC = schrcomp(M,n1,n2,tol)                             '
          '                                                       '
          'Computes the Schur complement of the symmetric matrix M'
          'with respect to the block  M(n1:n2,n1:n2)              '
          '                                                       '};
helpwin(schrcom, ttlStr);

case 86,
ttlStr ='SCONNECT';
sconnec ={' [P,r] = sconnect(inputs,outputs,K_in,G1_in,g1,G2_in,g2,...)     '
          '                                                                 '
          'SCONNECT computes the SYSTEM matrix  P  of the standard          '
          'H-infinity plant P(s) associated with a given control            '
          'structure.  It also returns the 1x2 vector R such that           '
          'R(1) = nbr of measurements (controller inputs)                   '
          'R(2) = nbr of controls     (controller outputs)                  '
          '                                                                 '
          'The control structure is described by the relations between      '
          'the various signals flowing in the control loop:                 '
          '                                                                 '
          '    * the string  INPUTS  lists the exogenous input signals.     '
          'For instance,  INPUTS = ''r(2) ; d''  specifies two inputs,      '
          'a vector r of size 2 and a scalar input d                        '
          '    * the string  OUTPUTS  lists the output signals.  The        '
          'output of a system G is denoted simply by G.  For                '
          'instance,  OUTPUTS = ''e=r-G ; G''  specifies two                '
          'output signals e=r-y and y where y is the output of              '
          'the system G                                                     '
          '    * the string  K_IN  gives the inputs of the controller in    '
          'terms of the exogenous inputs and the system outputs.            '
          'For instance,  K_IN = ''K:e''  specifies a controller            '
          'named K and with input e                                         '
          '    * each LTI system G in the loop but the controller is        '
          'specified by its input list   G_IN  and its SYSTEM               '
          'matrix G.  For instance,  G1_IN = ''S:K'' inserts a system       '
          'named S whose input is the output of the controller K            '
          '                                                                 '
          'The syntax G([2,4]) selects the 2nd and 4th output of a system G.'
          'Note that the names given to the various systems are immaterial  '
          'provided that they are consistent throughout.                    '
          '                                                                 '
          'If one of the systems is polytopic or parameter-dependent,       '
          'SCONNECT returns a polytopic model of the interconnection.       '
          '                                                                 '};
helpwin(sconnec, ttlStr);

case 81,
ttlStr ='SDERIV';
sderi ={'dsys = sderiv(sys,chan,pd)                            '
        '                                                      '
        'Multiplication of some input or output channel of     '
        'the LTI system  SYS  by a proportional-derivator      '
        'component  N*s+D :                                    '
        '                                                      '
        '           +-------+     +-----------+                '
        '     ------|       |-----|  s*N + D  |---->           '
        '           |  SYS  |     +-----------+                '
        '     ------|       |---------------------->           '
        '           +-------+                                  '
        '                                                      '
        'Set  CHAN = j  to select the j-th output channel, and '
        'CHAN = -j  to select the j-th input channel.          '
        'To multiply several channels by  N*s+D, set CHAN to   '
        'the corresponding list of channels.                   '
        '                                                      '
        'The real coefficients  N,D  are specified by setting  '
        'PD = [N , D].  SDERIV returns the SYSTEM matrix of the'
        'resulting interconnection.  This function is useful to'
        'append non proper shaping filters to a given plant. It'
        'is applicable to polytopic systems.                   '
        '                                                      '};
helpwin(sderi, ttlStr);

case 80,
ttlStr ='SDIAG';
sdia ={'sys = sdiag(sys1,sys2,...)                                   '
       '                                                             '
       'Appends the systems  SYS1, SYS2 ,... into a single system SYS'
       '                                                             '
       '_______________________                                      '
       '           |       ________      |                           '
       '           |       |      |      |                           '
       '       ----------->| sys1 |----------->                      '
       '           |       |______|      |                           '
       '           |          :          |                           '
       '           |          :          |                           '
       '           |       ________      |                           '
       '           |       |      |      |                           '
       '       ----------->| sysk |----------->                      '
       '           |       |______|      |                           '
       '           |_____________________|                           '
       '                                                             '
       'SYS                                                          '
       '                                                             '
       'One (and at most one) of these systems can be polytopic or   '
       'parameter-dependent.  SDIAG takes up to 10 input arguments.  '
       '                                                             '};
helpwin(sdia, ttlStr);

case 55,
ttlStr ='SINFO';
sinf ={' [ns,ni,no] = sinfo(sys)                                '
       '                                                        '
       'Returns the number of states, inputs, and outputs of the'
       'system SYS                                              '
       '                                                        '
       'Input:                                                  '
       'SYS        system state-space data in packed form       '
       '              (see LTISYS)                              '
       'Output:                                                 '
       'NS,NI,NO   number of states, inputs, and outputs of SYS '
       '                                                        '};
helpwin(sinf, ttlStr);

case 59,
ttlStr ='SINV';
sin ={'sysinv = sinv(sys)                                    '
      '                                                      '
      'Computes the inverse of the system of realization SYS.'
      'If G(s) is the transfer function of SYS, the inverse  '
      'system has transfer function                          '
      '                     -1                               '
      'G(s)                                                  '
      '                                                      '};
helpwin(sin, ttlStr);

case 85,
ttlStr ='SLFT';
slf ={'sys=slft(sys1,sys2,udim,ydim)                        '
      '                                                     '
      'Forms the linear fractional interconnection          '
      '                                                     '
      '_________                                            '
      'w1 -------->|       |-------> z1                     '
      '		       |  SYS1 |                                   '
      '            +-------->|_______|-------+              '
      '            |	 	               |                     '
      'u  |                         | y                     '
      '            |         _________       |              '
      '            +---------|       |<------+              '
      '		       |  SYS2 |                                   '
      'z2 <---------|_______|-------- w2                    '
      '                                                     '
      '                                                     '
      'of the two systems SYS1 and SYS2. The resulting      '
      'system SYS maps  (w1,w2)  to  (z1,z2).               '
      '                                                     '
      'UDIM and YDIM are the lengths of the vectors u and y.'
      'When omitted, they are set to the default values:    '
      '  * if SYS1 has more inputs/outputs than SYS2,       '
      'UDIM = number of outputs of SYS2                     '
      'YDIM = number of inputs of SYS2                      '
      '  * if SYS2 has more inputs/outputs than SYS1,       '
      'UDIM = number of inputs of SYS1                      '
      'YDIM = number of outputs of SYS1                     '
      '                                                     '};
helpwin(slf, ttlStr);

case 84,
ttlStr ='SLOOP';
sloo ={'clsys = sloop(g1,g2,sgn)                                '
       '                                                        '
       'Forms the feedback interconnection                      '
       '______                                                  '
       '        +          |      |                             '
       'r --->O-------->|  G1  |-------+----> y                 '
       '         |         |______|       |                     '
       '     +/- |                        |                     '
       '         |          ______        |                     '
       '         |         |      |       |                     '
       '         |_________|  G2  |<------+                     '
       '                   |______|                             '
       '                                                        '
       'The output CLSYS is a realization of the closed-loop    '
       'transfer function from r to y.                          '
       'SGN = -1 specifies negative feedback (default) and      '
       'SGN = +1 specifies positive feedback.                   '
       '                                                        '
       'Either G1 or G2 can be polytopic or parameter-dependent.'
       '                                                        '};
helpwin(sloo, ttlStr);

case 83,
ttlStr ='SMULT';
smul ={'sys = smult(sys1,sys2,...)                                 '
       '                                                           '
       'Forms the series interconnection                           '
       '                                                           '
       '________    ________                                       '
       '        |      |    |      |                               '
       '    --->| sys1 |--->| sys2 |---> ...                       '
       '        |______|    |______|                               '
       '                                                           '
       '                                                           '
       'of the systems  SYS1, SYS2, etc.   In terms of transfer    '
       'functions, the result is                                   '
       'SYSn * ... * SYS2 * SYS1                                   '
       'One and at most one of the systems can be polytopic or     '
       'parameter-dependent.  SMULT takes up to 10 input arguments.'
       '                                                           '};
helpwin(smul, ttlStr);

case 61,
ttlStr ='SPLOT';
splo ={'splot(sys,choice,xrange)         (continuous-time)         '
       'splot(sys,T,choice,xrange)       (discrete-time)           '
       '                                                           '
       'General-purpose function for plotting the frequency or time'
       'response of the system SYS                                 '
       '                                                           '
       'Input:                                                     '
       'SYS         SYSTEM matrix (see LTISYS)                     '
       'CHOICE      string specifying what should be plotted       '
       '                  ''bo''  :   Bode plot                    '
       '                  ''sv''  :   singular value plot          '
       '                  ''ny''  :   Nyquist plot (SISO)          '
       '                  ''li''  :   Lin-log Nyquist plot (SISO)  '
       '                  ''ni''  :   Black/Nichols chart (SISO)   '
       '                                                           '
       '                  ''st''  :   step response                '
       '                  ''im''  :   impulse response             '
       '                  ''sq''  :   response to a square wave    '
       '                  ''si''  :   response to a sine wave      '
       'XRANGE      user-specified vector of frequencies or        '
       'times (optional).  For options ''sq'' and ''si'',          '
       'XRANGE is simply the period of the input                   '
       'signal.                                                    '
       'T           sampling period in seconds (for discrete-time  '
       'systems)                                                   '
       '                                                           '};
helpwin(splo, ttlStr);

case 57,
ttlStr ='SPOL';
spo ={'poles = spol(sys)                  '
      '                                   '
      'Returns the poles of the system SYS'};
helpwin(spo, ttlStr);

case 56,
ttlStr ='SRESP';
sres ={'resp = sresp(sys,f)                                  '
       '                                      -1             '
       'Returns the response  D + C (j*f*E-A)  B  of a system'
       'SYS at the frequency f.  The realization (A,B,C,D,E) '
       'of SYS should be specified with LTISYS.              '};
helpwin(sres, ttlStr);

case 58,
ttlStr ='SSUB';
ssu ={'subsys = ssub(sys,inputs,outputs)                             '
      '                                                              '
      'Extracts the subsystem  SUBSYS  of  SYS  obtained by selecting'
      'particular inputs and outputs                                 '
      '                                                              '
      'Input:                                                        '
      'SYS          LTI system or polytopic/parameter-dependent      '
      'system                                                        '
      'INPUTS       vector of indices specifying the selected        '
      'inputs.  The first input is the top one in                    '
      'the block-diagram representation of the system.               '
      'OUTPUTS      same for the outputs                             '
      '                                                              '};
helpwin(ssu, ttlStr);

case 74,
ttlStr ='UBLOCK';
ubloc ={'block = ublock(dims,bound,type)                                   '
        '                                                                  '
        'Specification of the individual uncertainty blocks entering       '
        'in the linear-fractional representation of uncertain linear       '
        'systems.                                                          '
        '                                                                  '
        'Input:                                                            '
        'DIMS     dimensions of the block. DIMS = 3 means a 3x3            '
        'block, and DIMS = [1 2] means a 1x2 block                         '
        'BOUND    quantitative information about the uncertainty:          '
        '            * norm-bounded uncertainty:                           '
        'BOUND is either a positive scalar for uniform                     '
        'bounds, or a SISO system W for frequency-                         '
        'weighted bounds:                                                  '
        '                      | Delta (jw) | <  | W(jw) |                 '
        '            * sector-bounded uncertainty:                         '
        'set  BOUND = [a,b]  for uncertainty valued in                     '
        'the sector {a,b}                                                  '
        'TYPE     composite string defining the uncertainty properties:    '
        '            * nature: ''lti''   -> linear time-invariant (Default)'
        '                      ''ltv''   -> linear time-varying            '
        '                      ''nl''    -> arbitrary nonlinear            '
        '                      ''nlm''   -> nonlinear memoryless           '
        '            * structure:  ''f'' -> full block            (Default)'
        '                          ''s'' -> scalar block d*eye(DIMS)       '
        '            * value:      ''c'' -> complex-valued        (Default)'
        '                          ''r'' -> real-valued                    '
        'Output:                                                           '
        'BLOCK    column vector storing this information.                  '
        '                                                                  '
        'Example:  To specify a 2x3 LTI uncertainty block of gain less     '
        'than 1, type                                                      '
        'block = ublock ([2 3],1,''ltifc'')                                '
        'or simply                                                         '
        'block = ublock ([2 3],1)                                          '
        '                                                                  '};
helpwin(ubloc, ttlStr);


case 75,
ttlStr ='UDIAG';
udia ={'delta = udiag(d1,d2,....)                             '
       '                                                      '
       'Gathers the uncertainty blocks  D1, D2, ...  into     '
       'a single block-diagonal structure                     '
       '                                                      '
       '                 [   D1   0   ...    0  ]             '
       '                 [   0    D2   0     0  ]             '
       'DELTA  =   [   :    0    .     :  ]                   '
       '                 [   :           .      ]             '
       '                 [   0   ...         Dn ]             '
       '                                                      '
       'Each block  Dj  is either an individual block created '
       'with  UBLOCK,  or a block-diagonal matrix of such     '
       'blocks formed with  UDIAG.                            '
       'The number of input arguments is limited to 10.       '
       '                                                      '
       'WARNING:  make sure that the ordering of D1, D2,... is'
       'consistent with the ordering of the plant             '
       'inputs and outputs.                                   '
       '                                                      '};
helpwin(udia, ttlStr);

case 76,
ttlStr ='UINFO';
uinf ={'Retrieves information about some block-diagonal uncertainty'
       'structure  DELTA  created with UBLOCK/UDIAG                '
       '                                                           '
       'UINFO(DELTA)    displays the characteristics of each       '
       'uncertainty block in DELTA                                 '
       '                                                           '
       'N = UINFO(DELTA)    returns the number N of uncertainty    '
       'blocks                                                     '
       '                                                           '
       ' [DIMS,TYP,BND] = UINFO(DELTA,K)                           '
       'returns the dimensions, type, and bounds for the           '
       'K-th uncertainty block in DELTA                            '
       '                                                           '};
helpwin(uinf, ttlStr);

   end
end

%-----------------Function GOODFONTS-----------------
function [fname,fsize,figwidth] = goodfonts(computer)
%       Returns a good font for a list box on this platform
%       and return the resulting figure width for an 80 column
%       display.

% fname - string
% fsize - points
% figwidth - pixels, width of the figure with 80 chars displayed.

switch computer

case 'PCWIN'
   fname = 'Courier';
   fsize = 10;
   figwidth = 655;

case 'MAC2'
   fname = 'Monaco';
   fsize = 9;
   figwidth = 512;

otherwise
   fname = 'Courier';
   fsize = 12;
   figwidth = 580;

end
