octave_packages/control-2.3.52/doc-cache

   1 # Created by Octave 3.6.2, Mon Jun 25 21:47:37 2012 UTC <root@t61>
   2 # name: cache
   3 # type: cell
   4 # rows: 3
   5 # columns: 71
   6 # name: <cell-element>
   7 # type: sq_string
   8 # elements: 1
   9 # length: 8
  10 Anderson
  11
  12
  13 # name: <cell-element>
  14 # type: sq_string
  15 # elements: 1
  16 # length: 64
  17 Frequency-weighted coprime factorization controller reduction.
  18
  19
  20
  21
  22 # name: <cell-element>
  23 # type: sq_string
  24 # elements: 1
  25 # length: 62
  26 Frequency-weighted coprime factorization controller reduction.
  27
  28
  29
  30 # name: <cell-element>
  31 # type: sq_string
  32 # elements: 1
  33 # length: 9
  34 BMWengine
  35
  36
  37 # name: <cell-element>
  38 # type: sq_string
  39 # elements: 1
  40 # length: 1283
  41  -- Function File: SYS = BMWengine ()
  42  -- Function File: SYS = BMWengine ("SCALED")
  43  -- Function File: SYS = BMWengine ("UNSCALED")
  44      Model of the BMW 4-cylinder engine at ETH Zurich's control
  45      laboratory.
  46           OPERATING POINT
  47           Drosselklappenstellung     alpha_DK = 10.3 Grad
  48           Saugrohrdruck              p_s = 0.48 bar
  49           Motordrehzahl              n = 860 U/min
  50           Lambda-Messwert            lambda = 1.000
  51           Relativer Wandfilminhalt   nu = 1
  52
  53           INPUTS
  54           U_1 Sollsignal Drosselklappenstellung   [Grad]
  55           U_2 Relative Einspritzmenge             [-]
  56           U_3 Zuendzeitpunkt                      [Grad KW]
  57           M_L Lastdrehmoment                      [Nm]
  58
  59           STATES
  60           X_1 Drosselklappenstellung     [Grad]
  61           X_2 Saugrohrdruck              [bar]
  62           X_3 Motordrehzahl              [U/min]
  63           X_4 Messwert Lamba-Sonde       [-]
  64           X_5 Relativer Wandfilminhalt   [-]
  65
  66           OUTPUTS
  67           Y_1 Motordrehzahl              [U/min]
  68           Y_2 Messwert Lambda-Sonde      [-]
  69
  70           SCALING
  71           U_1N, X_1N   1 Grad
  72           U_2N, X_4N, X_5N, Y_2N   0.05
  73           U_3N   1.6 Grad KW
  74           X_2N   0.05 bar
  75           X_3N, Y_1N   200 U/min
  76
  77
  78
  79
  80 # name: <cell-element>
  81 # type: sq_string
  82 # elements: 1
  83 # length: 70
  84 Model of the BMW 4-cylinder engine at ETH Zurich's control laboratory.
  85
  86
  87
  88 # name: <cell-element>
  89 # type: sq_string
  90 # elements: 1
  91 # length: 9
  92 Boeing707
  93
  94
  95 # name: <cell-element>
  96 # type: sq_string
  97 # elements: 1
  98 # length: 392
  99  -- Function File: SYS = Boeing707 ()
 100      Creates a linearized state-space model of a Boeing 707-321 aircraft
 101      at V=80 m/s (M = 0.26, GA0 = -3 deg, ALPHA0 = 4 deg, KAPPA = 50
 102      deg).
 103
 104      System inputs: (1) thrust and (2) elevator angle.
 105
 106      System outputs:  (1) airspeed and (2) pitch angle.
 107
 108      *Reference*: R. Brockhaus: `Flugregelung' (Flight Control),
 109      Springer, 1994.
 110
 111
 112
 113
 114 # name: <cell-element>
 115 # type: sq_string
 116 # elements: 1
 117 # length: 80
 118 Creates a linearized state-space model of a Boeing 707-321 aircraft at
 119 V=80 m/s
 120
 121
 122
 123 # name: <cell-element>
 124 # type: sq_string
 125 # elements: 1
 126 # length: 9
 127 MDSSystem
 128
 129
 130 # name: <cell-element>
 131 # type: sq_string
 132 # elements: 1
 133 # length: 156
 134 Robust control of a mass-damper-spring system.  Type `which MDSSystem'
 135 to locate, `edit MDSSystem' to open and simply `MDSSystem' to run the
 136 example file.
 137
 138
 139
 140
 141 # name: <cell-element>
 142 # type: sq_string
 143 # elements: 1
 144 # length: 46
 145 Robust control of a mass-damper-spring system.
 146
 147
 148
 149 # name: <cell-element>
 150 # type: sq_string
 151 # elements: 1
 152 # length: 9
 153 Madievski
 154
 155
 156 # name: <cell-element>
 157 # type: sq_string
 158 # elements: 1
 159 # length: 42
 160 Frequency-weighted controller reduction.
 161
 162
 163
 164
 165 # name: <cell-element>
 166 # type: sq_string
 167 # elements: 1
 168 # length: 40
 169 Frequency-weighted controller reduction.
 170
 171
 172
 173 # name: <cell-element>
 174 # type: sq_string
 175 # elements: 1
 176 # length: 12
 177 WestlandLynx
 178
 179
 180 # name: <cell-element>
 181 # type: sq_string
 182 # elements: 1
 183 # length: 1288
 184  -- Function File: SYS = WestlandLynx ()
 185      Model of the Westland Lynx Helicopter about hover.
 186           INPUTS
 187           main rotor collective
 188           longitudinal cyclic
 189           lateral cyclic
 190           tail rotor collective
 191
 192           STATES
 193           pitch attitude           theta       [rad]
 194           roll attitude            phi         [rad]
 195           roll rate (body-axis)    p           [rad/s]
 196           pitch rate (body-axis)   q           [rad/s]
 197           yaw rate                 xi          [rad/s]
 198           forward velocity         v_x         [ft/s]
 199           lateral velocity         v_y         [ft/s]
 200           vertical velocity        v_z         [ft/s]
 201
 202           OUTPUTS
 203           heave velocity           H_dot       [ft/s]
 204           pitch attitude           theta       [rad]
 205           roll attitude            phi         [rad]
 206           heading rate             psi_dot     [rad/s]
 207           roll rate                p           [rad/s]
 208           pitch rate               q           [rad/s]
 209
 210           Reference:
 211           Skogestad, S. and Postlethwaite I.
 212           Multivariable Feedback Control: Analysis and Design
 213           Second Edition
 214           Wiley 2005
 215           http://www.nt.ntnu.no/users/skoge/book/2nd_edition/matlab_m/matfiles.html
 216
 217
 218
 219
 220 # name: <cell-element>
 221 # type: sq_string
 222 # elements: 1
 223 # length: 50
 224 Model of the Westland Lynx Helicopter about hover.
 225
 226
 227
 228 # name: <cell-element>
 229 # type: sq_string
 230 # elements: 1
 231 # length: 4
 232 augw
 233
 234
 235 # name: <cell-element>
 236 # type: sq_string
 237 # elements: 1
 238 # length: 3059
 239  -- Function File: P = augw (G, W1, W2, W3)
 240      Extend plant for stacked S/KS/T problem.  Subsequently, the robust
 241      control problem can be solved by h2syn or hinfsyn.
 242
 243      *Inputs*
 244     G
 245           LTI model of plant.
 246
 247     W1
 248           LTI model of performance weight.  Bounds the largest singular
 249           values of sensitivity S.  Model must be empty `[]', SISO or
 250           of appropriate size.
 251
 252     W2
 253           LTI model to penalize large control inputs.  Bounds the
 254           largest singular values of KS.  Model must be empty `[]',
 255           SISO or of appropriate size.
 256
 257     W3
 258           LTI model of robustness and noise sensitivity weight.  Bounds
 259           the largest singular values of complementary sensitivity T.
 260           Model must be empty `[]', SISO or of appropriate size.
 261
 262      All inputs must be proper/realizable.  Scalars, vectors and
 263      matrices are possible instead of LTI models.
 264
 265      *Outputs*
 266     P
 267           State-space model of augmented plant.
 268
 269      *Block Diagram*
 270
 271               | W1 | -W1*G |     z1 = W1 r  -  W1 G u
 272               | 0  |  W2   |     z2 =          W2   u
 273           P = | 0  |  W3*G |     z3 =          W3 G u
 274               |----+-------|
 275               | I  |    -G |     e  =    r  -     G u
 276
 277                                                                 +------+  z1
 278                       +---------------------------------------->|  W1  |----->
 279                       |                                         +------+
 280                       |                                         +------+  z2
 281                       |                 +---------------------->|  W2  |----->
 282                       |                 |                       +------+
 283            r   +    e |   +--------+  u |   +--------+  y       +------+  z3
 284           ----->(+)---+-->|  K(s)  |----+-->|  G(s)  |----+---->|  W3  |----->
 285                  ^ -      +--------+        +--------+    |     +------+
 286                  |                                        |
 287                  +----------------------------------------+
 288
 289                          +--------+
 290                          |        |-----> z1 (p1x1)          z1 = W1 e
 291            r (px1) ----->|  P(s)  |-----> z2 (p2x1)          z2 = W2 u
 292                          |        |-----> z3 (p3x1)          z3 = W3 y
 293            u (mx1) ----->|        |-----> e (px1)            e = r - y
 294                          +--------+
 295
 296                          +--------+
 297                  r ----->|        |-----> z
 298                          |  P(s)  |
 299                  u +---->|        |-----+ e
 300                    |     +--------+     |
 301                    |                    |
 302                    |     +--------+     |
 303                    +-----|  K(s)  |<----+
 304                          +--------+
 305
 306           Reference:
 307           Skogestad, S. and Postlethwaite I.
 308           Multivariable Feedback Control: Analysis and Design
 309           Second Edition
 310           Wiley 2005
 311           Chapter 3.8: General Control Problem Formulation
 312
 313      See also: h2syn, hinfsyn, mixsyn
 314
 315
 316
 317
 318
 319 # name: <cell-element>
 320 # type: sq_string
 321 # elements: 1
 322 # length: 40
 323 Extend plant for stacked S/KS/T problem.
 324
 325
 326
 327 # name: <cell-element>
 328 # type: sq_string
 329 # elements: 1
 330 # length: 4
 331 bode
 332
 333
 334 # name: <cell-element>
 335 # type: sq_string
 336 # elements: 1
 337 # length: 890
 338  -- Function File: [MAG, PHA, W] = bode (SYS)
 339  -- Function File: [MAG, PHA, W] = bode (SYS, W)
 340      Bode diagram of frequency response.  If no output arguments are
 341      given, the response is printed on the screen.
 342
 343      *Inputs*
 344     SYS
 345           LTI system.  Must be a single-input and single-output (SISO)
 346           system.
 347
 348     W
 349           Optional vector of frequency values.  If W is not specified,
 350           it is calculated by the zeros and poles of the system.
 351           Alternatively, the cell `{wmin, wmax}' specifies a frequency
 352           range, where WMIN and WMAX denote minimum and maximum
 353           frequencies in rad/s.
 354
 355      *Outputs*
 356     MAG
 357           Vector of magnitude.  Has length of frequency vector W.
 358
 359     PHA
 360           Vector of phase.  Has length of frequency vector W.
 361
 362     W
 363           Vector of frequency values used.
 364
 365      See also: nichols, nyquist, sigma
 366
 367
 368
 369
 370
 371 # name: <cell-element>
 372 # type: sq_string
 373 # elements: 1
 374 # length: 35
 375 Bode diagram of frequency response.
 376
 377
 378
 379 # name: <cell-element>
 380 # type: sq_string
 381 # elements: 1
 382 # length: 7
 383 bodemag
 384
 385
 386 # name: <cell-element>
 387 # type: sq_string
 388 # elements: 1
 389 # length: 831
 390  -- Function File: [MAG, W] = bodemag (SYS)
 391  -- Function File: [MAG, W] = bodemag (SYS, W)
 392      Bode magnitude diagram of frequency response.  If no output
 393      arguments are given, the response is printed on the screen.
 394
 395      *Inputs*
 396     SYS
 397           LTI system.  Must be a single-input and single-output (SISO)
 398           system.
 399
 400     W
 401           Optional vector of frequency values.  If W is not specified,
 402           it is calculated by the zeros and poles of the system.
 403           Alternatively, the cell `{wmin, wmax}' specifies a frequency
 404           range, where WMIN and WMAX denote minimum and maximum
 405           frequencies in rad/s.
 406
 407      *Outputs*
 408     MAG
 409           Vector of magnitude.  Has length of frequency vector W.
 410
 411     W
 412           Vector of frequency values used.
 413
 414      See also: bode, nichols, nyquist, sigma
 415
 416
 417
 418
 419
 420 # name: <cell-element>
 421 # type: sq_string
 422 # elements: 1
 423 # length: 45
 424 Bode magnitude diagram of frequency response.
 425
 426
 427
 428 # name: <cell-element>
 429 # type: sq_string
 430 # elements: 1
 431 # length: 9
 432 bstmodred
 433
 434
 435 # name: <cell-element>
 436 # type: sq_string
 437 # elements: 1
 438 # length: 6097
 439  -- Function File: [GR, INFO] = bstmodred (G, ...)
 440  -- Function File: [GR, INFO] = bstmodred (G, NR, ...)
 441  -- Function File: [GR, INFO] = bstmodred (G, OPT, ...)
 442  -- Function File: [GR, INFO] = bstmodred (G, NR, OPT, ...)
 443      Model order reduction by Balanced Stochastic Truncation (BST)
 444      method.  The aim of model reduction is to find an LTI system GR of
 445      order NR (nr < n) such that the input-output behaviour of GR
 446      approximates the one from original system G.
 447
 448      BST is a relative error method which tries to minimize
 449              -1
 450           ||G  (G-Gr)||    = min
 451                        inf
 452
 453      *Inputs*
 454     G
 455           LTI model to be reduced.
 456
 457     NR
 458           The desired order of the resulting reduced order system GR.
 459           If not specified, NR is chosen automatically according to the
 460           description of key 'ORDER'.
 461
 462     ...
 463           Optional pairs of keys and values.  `"key1", value1, "key2",
 464           value2'.
 465
 466     OPT
 467           Optional struct with keys as field names.  Struct OPT can be
 468           created directly or by command `options'.  `opt.key1 =
 469           value1, opt.key2 = value2'.
 470
 471      *Outputs*
 472     GR
 473           Reduced order state-space model.
 474
 475     INFO
 476           Struct containing additional information.
 477          INFO.N
 478                The order of the original system G.
 479
 480          INFO.NS
 481                The order of the ALPHA-stable subsystem of the original
 482                system G.
 483
 484          INFO.HSV
 485                The Hankel singular values of the phase system
 486                corresponding to the ALPHA-stable part of the original
 487                system G.  The NS Hankel singular values are ordered
 488                decreasingly.
 489
 490          INFO.NU
 491                The order of the ALPHA-unstable subsystem of both the
 492                original system G and the reduced-order system GR.
 493
 494          INFO.NR
 495                The order of the obtained reduced order system GR.
 496
 497      *Option Keys and Values*
 498     'ORDER', 'NR'
 499           The desired order of the resulting reduced order system GR.
 500           If not specified, NR is the sum of NU and the number of
 501           Hankel singular values greater than `MAX(TOL1,NS*EPS)'; NR
 502           can be further reduced to ensure that `HSV(NR-NU) >
 503           HSV(NR+1-NU)'.
 504
 505     'METHOD'
 506           Approximation method for the H-infinity norm.  Valid values
 507           corresponding to this key are:
 508          'SR-BTA', 'B'
 509                Use the square-root Balance & Truncate method.
 510
 511          'BFSR-BTA', 'F'
 512                Use the balancing-free square-root Balance & Truncate
 513                method.  Default method.
 514
 515          'SR-SPA', 'S'
 516                Use the square-root Singular Perturbation Approximation
 517                method.
 518
 519          'BFSR-SPA', 'P'
 520                Use the balancing-free square-root Singular Perturbation
 521                Approximation method.
 522
 523     'ALPHA'
 524           Specifies the ALPHA-stability boundary for the eigenvalues of
 525           the state dynamics matrix G.A.  For a continuous-time system,
 526           ALPHA <= 0 is the boundary value for the real parts of
 527           eigenvalues, while for a discrete-time system, 0 <= ALPHA <=
 528           1 represents the boundary value for the moduli of eigenvalues.
 529           The ALPHA-stability domain does not include the boundary.
 530           Default value is 0 for continuous-time systems and 1 for
 531           discrete-time systems.
 532
 533     'BETA'
 534           Use `[G, beta*I]' as new system G to combine absolute and
 535           relative error methods.  BETA > 0 specifies the
 536           absolute/relative error weighting parameter.  A large
 537           positive value of BETA favours the minimization of the
 538           absolute approximation error, while a small value of BETA is
 539           appropriate for the minimization of the relative error.  BETA
 540           = 0 means a pure relative error method and can be used only
 541           if rank(G.D) = rows(G.D) which means that the feedthrough
 542           matrice must not be rank-deficient.  Default value is 0.
 543
 544     'TOL1'
 545           If 'ORDER' is not specified, TOL1 contains the tolerance for
 546           determining the order of reduced system.  For model
 547           reduction, the recommended value of TOL1 lies in the interval
 548           [0.00001, 0.001].  TOL1 < 1.  If TOL1 <= 0 on entry, the used
 549           default value is TOL1 = NS*EPS, where NS is the number of
 550           ALPHA-stable eigenvalues of A and EPS is the machine
 551           precision.  If 'ORDER' is specified, the value of TOL1 is
 552           ignored.
 553
 554     'TOL2'
 555           The tolerance for determining the order of a minimal
 556           realization of the phase system (see METHOD) corresponding to
 557           the ALPHA-stable part of the given system.  The recommended
 558           value is TOL2 = NS*EPS.  TOL2 <= TOL1 < 1.  This value is
 559           used by default if 'TOL2' is not specified or if TOL2 <= 0 on
 560           entry.
 561
 562     'EQUIL', 'SCALE'
 563           Boolean indicating whether equilibration (scaling) should be
 564           performed on system G prior to order reduction.  Default
 565           value is true if `G.scaled == false' and false if `G.scaled
 566           == true'.  Note that for MIMO models, proper scaling of both
 567           inputs and outputs is of utmost importance.  The input and
 568           output scaling can *not* be done by the equilibration option
 569           or the `prescale' command because these functions perform
 570           state transformations only.  Furthermore, signals should not
 571           be scaled simply to a certain range.  For all inputs (or
 572           outputs), a certain change should be of the same importance
 573           for the model.
 574
 575      BST is often suitable to perform model reduction in order to obtain
 576      low order design models for controller synthesis.
 577
 578      Approximation Properties:
 579         * Guaranteed stability of reduced models
 580
 581         * Approximates simultaneously gain and phase
 582
 583         * Preserves non-minimum phase zeros
 584
 585         * Guaranteed a priori error bound
 586
 587      *Algorithm*
 588      Uses SLICOT AB09HD by courtesy of NICONET e.V.
 589      (http://www.slicot.org)
 590
 591
 592
 593
 594 # name: <cell-element>
 595 # type: sq_string
 596 # elements: 1
 597 # length: 69
 598 Model order reduction by Balanced Stochastic Truncation (BST) method.
 599
 600
 601
 602 # name: <cell-element>
 603 # type: sq_string
 604 # elements: 1
 605 # length: 9
 606 btaconred
 607
 608
 609 # name: <cell-element>
 610 # type: sq_string
 611 # elements: 1
 612 # length: 6173
 613  -- Function File: [KR, INFO] = btaconred (G, K, ...)
 614  -- Function File: [KR, INFO] = btaconred (G, K, NCR, ...)
 615  -- Function File: [KR, INFO] = btaconred (G, K, OPT, ...)
 616  -- Function File: [KR, INFO] = btaconred (G, K, NCR, OPT, ...)
 617      Controller reduction by frequency-weighted Balanced Truncation
 618      Approximation (BTA).  Given a plant G and a stabilizing controller
 619      K, determine a reduced order controller KR such that the
 620      closed-loop system is stable and closed-loop performance is
 621      retained.
 622
 623      The algorithm tries to minimize the frequency-weighted error
 624           ||V (K-Kr) W||    = min
 625                         inf
 626      where V and W denote output and input weightings.
 627
 628      *Inputs*
 629     G
 630           LTI model of the plant.  It has m inputs, p outputs and n
 631           states.
 632
 633     K
 634           LTI model of the controller.  It has p inputs, m outputs and
 635           nc states.
 636
 637     NCR
 638           The desired order of the resulting reduced order controller
 639           KR.  If not specified, NCR is chosen automatically according
 640           to the description of key 'ORDER'.
 641
 642     ...
 643           Optional pairs of keys and values.  `"key1", value1, "key2",
 644           value2'.
 645
 646     OPT
 647           Optional struct with keys as field names.  Struct OPT can be
 648           created directly or by command `options'.  `opt.key1 =
 649           value1, opt.key2 = value2'.
 650
 651      *Outputs*
 652     KR
 653           State-space model of reduced order controller.
 654
 655     INFO
 656           Struct containing additional information.
 657          INFO.NCR
 658                The order of the obtained reduced order controller KR.
 659
 660          INFO.NCS
 661                The order of the alpha-stable part of original
 662                controller K.
 663
 664          INFO.HSVC
 665                The Hankel singular values of the alpha-stable part of K.
 666                The NCS Hankel singular values are ordered decreasingly.
 667
 668      *Option Keys and Values*
 669     'ORDER', 'NCR'
 670           The desired order of the resulting reduced order controller
 671           KR.  If not specified, NCR is chosen automatically such that
 672           states with Hankel singular values INFO.HSVC > TOL1 are
 673           retained.
 674
 675     'METHOD'
 676           Order reduction approach to be used as follows:
 677          'SR', 'B'
 678                Use the square-root Balance & Truncate method.
 679
 680          'BFSR', 'F'
 681                Use the balancing-free square-root Balance & Truncate
 682                method.  Default method.
 683
 684     'WEIGHT'
 685           Specifies the type of frequency-weighting as follows:
 686          'NONE'
 687                No weightings are used (V = I, W = I).
 688
 689          'LEFT', 'OUTPUT'
 690                Use stability enforcing left (output) weighting
 691                               -1
 692                     V = (I-G*K) *G ,  W = I
 693
 694          'RIGHT', 'INPUT'
 695                Use stability enforcing right (input) weighting
 696                                        -1
 697                     V = I ,  W = (I-G*K) *G
 698
 699          'BOTH', 'PERFORMANCE'
 700                Use stability and performance enforcing weightings
 701                               -1                -1
 702                     V = (I-G*K) *G ,  W = (I-G*K)
 703                Default value.
 704
 705     'FEEDBACK'
 706           Specifies whether K is a positive or negative feedback
 707           controller:
 708          '+'
 709                Use positive feedback controller.  Default value.
 710
 711          '-'
 712                Use negative feedback controller.
 713
 714     'ALPHA'
 715           Specifies the ALPHA-stability boundary for the eigenvalues of
 716           the state dynamics matrix K.A.  For a continuous-time
 717           controller, ALPHA <= 0 is the boundary value for the real
 718           parts of eigenvalues, while for a discrete-time controller, 0
 719           <= ALPHA <= 1 represents the boundary value for the moduli of
 720           eigenvalues.  The ALPHA-stability domain does not include the
 721           boundary.  Default value is 0 for continuous-time controllers
 722           and 1 for discrete-time controllers.
 723
 724     'TOL1'
 725           If 'ORDER' is not specified, TOL1 contains the tolerance for
 726           determining the order of the reduced controller.  For model
 727           reduction, the recommended value of TOL1 is c*info.hsvc(1),
 728           where c lies in the interval [0.00001, 0.001].  Default value
 729           is info.ncs*eps*info.hsvc(1).  If 'ORDER' is specified, the
 730           value of TOL1 is ignored.
 731
 732     'TOL2'
 733           The tolerance for determining the order of a minimal
 734           realization of the ALPHA-stable part of the given controller.
 735           TOL2 <= TOL1.  If not specified, ncs*eps*info.hsvc(1) is
 736           chosen.
 737
 738     'GRAM-CTRB'
 739           Specifies the choice of frequency-weighted controllability
 740           Grammian as follows:
 741          'STANDARD'
 742                Choice corresponding to standard Enns' method [1].
 743                Default method.
 744
 745          'ENHANCED'
 746                Choice corresponding to the stability enhanced modified
 747                Enns' method of [2].
 748
 749     'GRAM-OBSV'
 750           Specifies the choice of frequency-weighted observability
 751           Grammian as follows:
 752          'STANDARD'
 753                Choice corresponding to standard Enns' method [1].
 754                Default method.
 755
 756          'ENHANCED'
 757                Choice corresponding to the stability enhanced modified
 758                Enns' method of [2].
 759
 760     'EQUIL', 'SCALE'
 761           Boolean indicating whether equilibration (scaling) should be
 762           performed on G and K prior to order reduction.  Default value
 763           is false if both `G.scaled == true, K.scaled == true' and
 764           true otherwise.  Note that for MIMO models, proper scaling of
 765           both inputs and outputs is of utmost importance.  The input
 766           and output scaling can *not* be done by the equilibration
 767           option or the `prescale' command because these functions
 768           perform state transformations only.  Furthermore, signals
 769           should not be scaled simply to a certain range.  For all
 770           inputs (or outputs), a certain change should be of the same
 771           importance for the model.
 772
 773      *Algorithm*
 774      Uses SLICOT SB16AD by courtesy of NICONET e.V.
 775      (http://www.slicot.org)
 776
 777
 778
 779
 780 # name: <cell-element>
 781 # type: sq_string
 782 # elements: 1
 783 # length: 80
 784 Controller reduction by frequency-weighted Balanced Truncation
 785 Approximation (BT
 786
 787
 788
 789 # name: <cell-element>
 790 # type: sq_string
 791 # elements: 1
 792 # length: 9
 793 btamodred
 794
 795
 796 # name: <cell-element>
 797 # type: sq_string
 798 # elements: 1
 799 # length: 7326
 800  -- Function File: [GR, INFO] = btamodred (G, ...)
 801  -- Function File: [GR, INFO] = btamodred (G, NR, ...)
 802  -- Function File: [GR, INFO] = btamodred (G, OPT, ...)
 803  -- Function File: [GR, INFO] = btamodred (G, NR, OPT, ...)
 804      Model order reduction by frequency weighted Balanced Truncation
 805      Approximation (BTA) method.  The aim of model reduction is to find
 806      an LTI system GR of order NR (nr < n) such that the input-output
 807      behaviour of GR approximates the one from original system G.
 808
 809      BTA is an absolute error method which tries to minimize
 810           ||G-Gr||    = min
 811                   inf
 812
 813           ||V (G-Gr) W||    = min
 814                         inf
 815      where V and W denote output and input weightings.
 816
 817      *Inputs*
 818     G
 819           LTI model to be reduced.
 820
 821     NR
 822           The desired order of the resulting reduced order system GR.
 823           If not specified, NR is chosen automatically according to the
 824           description of key 'ORDER'.
 825
 826     ...
 827           Optional pairs of keys and values.  `"key1", value1, "key2",
 828           value2'.
 829
 830     OPT
 831           Optional struct with keys as field names.  Struct OPT can be
 832           created directly or by command `options'.  `opt.key1 =
 833           value1, opt.key2 = value2'.
 834
 835      *Outputs*
 836     GR
 837           Reduced order state-space model.
 838
 839     INFO
 840           Struct containing additional information.
 841          INFO.N
 842                The order of the original system G.
 843
 844          INFO.NS
 845                The order of the ALPHA-stable subsystem of the original
 846                system G.
 847
 848          INFO.HSV
 849                The Hankel singular values of the ALPHA-stable part of
 850                the original system G, ordered decreasingly.
 851
 852          INFO.NU
 853                The order of the ALPHA-unstable subsystem of both the
 854                original system G and the reduced-order system GR.
 855
 856          INFO.NR
 857                The order of the obtained reduced order system GR.
 858
 859      *Option Keys and Values*
 860     'ORDER', 'NR'
 861           The desired order of the resulting reduced order system GR.
 862           If not specified, NR is chosen automatically such that states
 863           with Hankel singular values INFO.HSV > TOL1 are retained.
 864
 865     'LEFT', 'OUTPUT'
 866           LTI model of the left/output frequency weighting V.  Default
 867           value is an identity matrix.
 868
 869     'RIGHT', 'INPUT'
 870           LTI model of the right/input frequency weighting W.  Default
 871           value is an identity matrix.
 872
 873     'METHOD'
 874           Approximation method for the L-infinity norm to be used as
 875           follows:
 876          'SR', 'B'
 877                Use the square-root Balance & Truncate method.
 878
 879          'BFSR', 'F'
 880                Use the balancing-free square-root Balance & Truncate
 881                method.  Default method.
 882
 883     'ALPHA'
 884           Specifies the ALPHA-stability boundary for the eigenvalues of
 885           the state dynamics matrix G.A.  For a continuous-time system,
 886           ALPHA <= 0 is the boundary value for the real parts of
 887           eigenvalues, while for a discrete-time system, 0 <= ALPHA <=
 888           1 represents the boundary value for the moduli of eigenvalues.
 889           The ALPHA-stability domain does not include the boundary.
 890           Default value is 0 for continuous-time systems and 1 for
 891           discrete-time systems.
 892
 893     'TOL1'
 894           If 'ORDER' is not specified, TOL1 contains the tolerance for
 895           determining the order of the reduced model.  For model
 896           reduction, the recommended value of TOL1 is c*info.hsv(1),
 897           where c lies in the interval [0.00001, 0.001].  Default value
 898           is info.ns*eps*info.hsv(1).  If 'ORDER' is specified, the
 899           value of TOL1 is ignored.
 900
 901     'TOL2'
 902           The tolerance for determining the order of a minimal
 903           realization of the ALPHA-stable part of the given model.
 904           TOL2 <= TOL1.  If not specified, ns*eps*info.hsv(1) is chosen.
 905
 906     'GRAM-CTRB'
 907           Specifies the choice of frequency-weighted controllability
 908           Grammian as follows:
 909          'STANDARD'
 910                Choice corresponding to a combination method [4] of the
 911                approaches of Enns [1] and Lin-Chiu [2,3].  Default
 912                method.
 913
 914          'ENHANCED'
 915                Choice corresponding to the stability enhanced modified
 916                combination method of [4].
 917
 918     'GRAM-OBSV'
 919           Specifies the choice of frequency-weighted observability
 920           Grammian as follows:
 921          'STANDARD'
 922                Choice corresponding to a combination method [4] of the
 923                approaches of Enns [1] and Lin-Chiu [2,3].  Default
 924                method.
 925
 926          'ENHANCED'
 927                Choice corresponding to the stability enhanced modified
 928                combination method of [4].
 929
 930     'ALPHA-CTRB'
 931           Combination method parameter for defining the
 932           frequency-weighted controllability Grammian.  abs(alphac) <=
 933           1.  If alphac = 0, the choice of Grammian corresponds to the
 934           method of Enns [1], while if alphac = 1, the choice of
 935           Grammian corresponds to the method of Lin and Chiu [2,3].
 936           Default value is 0.
 937
 938     'ALPHA-OBSV'
 939           Combination method parameter for defining the
 940           frequency-weighted observability Grammian.  abs(alphao) <= 1.
 941           If alphao = 0, the choice of Grammian corresponds to the
 942           method of Enns [1], while if alphao = 1, the choice of
 943           Grammian corresponds to the method of Lin and Chiu [2,3].
 944           Default value is 0.
 945
 946     'EQUIL', 'SCALE'
 947           Boolean indicating whether equilibration (scaling) should be
 948           performed on system G prior to order reduction.  This is done
 949           by state transformations.  Default value is true if `G.scaled
 950           == false' and false if `G.scaled == true'.  Note that for
 951           MIMO models, proper scaling of both inputs and outputs is of
 952           utmost importance.  The input and output scaling can *not* be
 953           done by the equilibration option or the `prescale' command
 954           because these functions perform state transformations only.
 955           Furthermore, signals should not be scaled simply to a certain
 956           range.  For all inputs (or outputs), a certain change should
 957           be of the same importance for the model.
 958
 959      Approximation Properties:
 960         * Guaranteed stability of reduced models
 961
 962         * Lower guaranteed error bound
 963
 964         * Guaranteed a priori error bound
 965
 966      *References*
 967      [1] Enns, D.  Model reduction with balanced realizations: An error
 968      bound and a frequency weighted generalization.  Proc. 23-th CDC,
 969      Las Vegas, pp. 127-132, 1984.
 970
 971      [2] Lin, C.-A. and Chiu, T.-Y.  Model reduction via
 972      frequency-weighted balanced realization.  Control Theory and
 973      Advanced Technology, vol. 8, pp. 341-351, 1992.
 974
 975      [3] Sreeram, V., Anderson, B.D.O and Madievski, A.G.  New results
 976      on frequency weighted balanced reduction technique.  Proc. ACC,
 977      Seattle, Washington, pp. 4004-4009, 1995.
 978
 979      [4] Varga, A. and Anderson, B.D.O.  Square-root balancing-free
 980      methods for the frequency-weighted balancing related model
 981      reduction.  (report in preparation)
 982
 983      *Algorithm*
 984      Uses SLICOT AB09ID by courtesy of NICONET e.V.
 985      (http://www.slicot.org)
 986
 987
 988
 989
 990 # name: <cell-element>
 991 # type: sq_string
 992 # elements: 1
 993 # length: 80
 994 Model order reduction by frequency weighted Balanced Truncation
 995 Approximation (B
 996
 997
 998
 999 # name: <cell-element>
1000 # type: sq_string
1001 # elements: 1
1002 # length: 4
1003 care
1004
1005
1006 # name: <cell-element>
1007 # type: sq_string
1008 # elements: 1
1009 # length: 1627
1010  -- Function File: [X, L, G] = care (A, B, Q, R)
1011  -- Function File: [X, L, G] = care (A, B, Q, R, S)
1012  -- Function File: [X, L, G] = care (A, B, Q, R, [], E)
1013  -- Function File: [X, L, G] = care (A, B, Q, R, S, E)
1014      Solve continuous-time algebraic Riccati equation (ARE).
1015
1016      *Inputs*
1017     A
1018           Real matrix (n-by-n).
1019
1020     B
1021           Real matrix (n-by-m).
1022
1023     Q
1024           Real matrix (n-by-n).
1025
1026     R
1027           Real matrix (m-by-m).
1028
1029     S
1030           Optional real matrix (n-by-m).  If S is not specified, a zero
1031           matrix is assumed.
1032
1033     E
1034           Optional descriptor matrix (n-by-n).  If E is not specified,
1035           an identity matrix is assumed.
1036
1037      *Outputs*
1038     X
1039           Unique stabilizing solution of the continuous-time Riccati
1040           equation (n-by-n).
1041
1042     L
1043           Closed-loop poles (n-by-1).
1044
1045     G
1046           Corresponding gain matrix (m-by-n).
1047
1048      *Equations*
1049                          -1
1050           A'X + XA - XB R  B'X + Q = 0
1051
1052                                -1
1053           A'X + XA - (XB + S) R  (B'X + S') + Q = 0
1054
1055                -1
1056           G = R  B'X
1057
1058                -1
1059           G = R  (B'X + S')
1060
1061           L = eig (A - B*G)
1062
1063                               -1
1064           A'XE + E'XA - E'XB R   B'XE + Q = 0
1065
1066                                     -1
1067           A'XE + E'XA - (E'XB + S) R   (B'XE + S') + Q = 0
1068
1069                -1
1070           G = R  B'XE
1071
1072                -1
1073           G = R  (B'XE + S)
1074
1075           L = eig (A - B*G, E)
1076
1077      *Algorithm*
1078      Uses SLICOT SB02OD and SG02AD by courtesy of NICONET e.V.
1079      (http://www.slicot.org)
1080
1081      See also: dare, lqr, dlqr, kalman
1082
1083
1084
1085
1086
1087 # name: <cell-element>
1088 # type: sq_string
1089 # elements: 1
1090 # length: 55
1091 Solve continuous-time algebraic Riccati equation (ARE).
1092
1093
1094
1095 # name: <cell-element>
1096 # type: sq_string
1097 # elements: 1
1098 # length: 8
1099 cfconred
1100
1101
1102 # name: <cell-element>
1103 # type: sq_string
1104 # elements: 1
1105 # length: 4348
1106  -- Function File: [KR, INFO] = cfconred (G, F, L, ...)
1107  -- Function File: [KR, INFO] = cfconred (G, F, L, NCR, ...)
1108  -- Function File: [KR, INFO] = cfconred (G, F, L, OPT, ...)
1109  -- Function File: [KR, INFO] = cfconred (G, F, L, NCR, OPT, ...)
1110      Reduction of state-feedback-observer based controller by coprime
1111      factorization (CF).  Given a plant G, state feedback gain F and
1112      full observer gain L, determine a reduced order controller KR.
1113
1114      *Inputs*
1115     G
1116           LTI model of the open-loop plant (A,B,C,D).  It has m inputs,
1117           p outputs and n states.
1118
1119     F
1120           Stabilizing state feedback matrix (m-by-n).
1121
1122     L
1123           Stabilizing observer gain matrix (n-by-p).
1124
1125     NCR
1126           The desired order of the resulting reduced order controller
1127           KR.  If not specified, NCR is chosen automatically according
1128           to the description of key 'ORDER'.
1129
1130     ...
1131           Optional pairs of keys and values.  `"key1", value1, "key2",
1132           value2'.
1133
1134     OPT
1135           Optional struct with keys as field names.  Struct OPT can be
1136           created directly or by command `options'.  `opt.key1 =
1137           value1, opt.key2 = value2'.
1138
1139      *Outputs*
1140     KR
1141           State-space model of reduced order controller.
1142
1143     INFO
1144           Struct containing additional information.
1145          INFO.HSV
1146                The Hankel singular values of the extended system?!?.
1147                The N Hankel singular values are ordered decreasingly.
1148
1149          INFO.NCR
1150                The order of the obtained reduced order controller KR.
1151
1152      *Option Keys and Values*
1153     'ORDER', 'NCR'
1154           The desired order of the resulting reduced order controller
1155           KR.  If not specified, NCR is chosen automatically such that
1156           states with Hankel singular values INFO.HSV > TOL1 are
1157           retained.
1158
1159     'METHOD'
1160           Order reduction approach to be used as follows:
1161          'SR-BTA', 'B'
1162                Use the square-root Balance & Truncate method.
1163
1164          'BFSR-BTA', 'F'
1165                Use the balancing-free square-root Balance & Truncate
1166                method.  Default method.
1167
1168          'SR-SPA', 'S'
1169                Use the square-root Singular Perturbation Approximation
1170                method.
1171
1172          'BFSR-SPA', 'P'
1173                Use the balancing-free square-root Singular Perturbation
1174                Approximation method.
1175
1176     'CF'
1177           Specifies whether left or right coprime factorization is to
1178           be used as follows:
1179          'LEFT', 'L'
1180                Use left coprime factorization.  Default method.
1181
1182          'RIGHT', 'R'
1183                Use right coprime factorization.
1184
1185     'FEEDBACK'
1186           Specifies whether F and L are fed back positively or
1187           negatively:
1188          '+'
1189                A+BK and A+LC are both Hurwitz matrices.
1190
1191          '-'
1192                A-BK and A-LC are both Hurwitz matrices.  Default value.
1193
1194     'TOL1'
1195           If 'ORDER' is not specified, TOL1 contains the tolerance for
1196           determining the order of the reduced system.  For model
1197           reduction, the recommended value of TOL1 is c*info.hsv(1),
1198           where c lies in the interval [0.00001, 0.001].  Default value
1199           is n*eps*info.hsv(1).  If 'ORDER' is specified, the value of
1200           TOL1 is ignored.
1201
1202     'TOL2'
1203           The tolerance for determining the order of a minimal
1204           realization of the coprime factorization controller.  TOL2 <=
1205           TOL1.  If not specified, n*eps*info.hsv(1) is chosen.
1206
1207     'EQUIL', 'SCALE'
1208           Boolean indicating whether equilibration (scaling) should be
1209           performed on system G prior to order reduction.  Default
1210           value is true if `G.scaled == false' and false if `G.scaled
1211           == true'.  Note that for MIMO models, proper scaling of both
1212           inputs and outputs is of utmost importance.  The input and
1213           output scaling can *not* be done by the equilibration option
1214           or the `prescale' command because these functions perform
1215           state transformations only.  Furthermore, signals should not
1216           be scaled simply to a certain range.  For all inputs (or
1217           outputs), a certain change should be of the same importance
1218           for the model.
1219
1220      *Algorithm*
1221      Uses SLICOT SB16BD by courtesy of NICONET e.V.
1222      (http://www.slicot.org)
1223
1224
1225
1226
1227 # name: <cell-element>
1228 # type: sq_string
1229 # elements: 1
1230 # length: 80
1231 Reduction of state-feedback-observer based controller by coprime
1232 factorization (
1233
1234
1235
1236 # name: <cell-element>
1237 # type: sq_string
1238 # elements: 1
1239 # length: 5
1240 covar
1241
1242
1243 # name: <cell-element>
1244 # type: sq_string
1245 # elements: 1
1246 # length: 319
1247  -- Function File: [P, Q] = covar (SYS, W)
1248      Return the steady-state covariance.
1249
1250      *Inputs*
1251     SYS
1252           LTI model.
1253
1254     W
1255           Intensity of Gaussian white noise inputs which drive SYS.
1256
1257      *Outputs*
1258     P
1259           Output covariance.
1260
1261     Q
1262           State covariance.
1263
1264      See also: lyap, dlyap
1265
1266
1267
1268
1269
1270 # name: <cell-element>
1271 # type: sq_string
1272 # elements: 1
1273 # length: 35
1274 Return the steady-state covariance.
1275
1276
1277
1278 # name: <cell-element>
1279 # type: sq_string
1280 # elements: 1
1281 # length: 4
1282 ctrb
1283
1284
1285 # name: <cell-element>
1286 # type: sq_string
1287 # elements: 1
1288 # length: 390
1289  -- Function File: CO = ctrb (SYS)
1290  -- Function File: CO = ctrb (A, B)
1291      Return controllability matrix.
1292
1293      *Inputs*
1294     SYS
1295           LTI model.
1296
1297     A
1298           State transition matrix (n-by-n).
1299
1300     B
1301           Input matrix (n-by-m).
1302
1303      *Outputs*
1304     CO
1305           Controllability matrix.
1306
1307      *Equation*
1308                        2       n-1
1309           Co = [ B AB A B ... A   B ]
1310
1311
1312
1313
1314 # name: <cell-element>
1315 # type: sq_string
1316 # elements: 1
1317 # length: 30
1318 Return controllability matrix.
1319
1320
1321
1322 # name: <cell-element>
1323 # type: sq_string
1324 # elements: 1
1325 # length: 5
1326 ctrbf
1327
1328
1329 # name: <cell-element>
1330 # type: sq_string
1331 # elements: 1
1332 # length: 958
1333  -- Function File: [SYSBAR, T, K] = ctrbf (SYS)
1334  -- Function File: [SYSBAR, T, K] = ctrbf (SYS, TOL)
1335  -- Function File: [ABAR, BBAR, CBAR, T, K] = ctrbf (A, B, C)
1336  -- Function File: [ABAR, BBAR, CBAR, T, K] = ctrbf (A, B, C, TOL)
1337      If Co=ctrb(A,B) has rank r <= n = SIZE(A,1), then there is a
1338      similarity transformation Tc such that Tc = [t1 t2] where t1 is
1339      the controllable subspace and t2 is orthogonal to t1
1340
1341           Abar = Tc \ A * Tc ,  Bbar = Tc \ B ,  Cbar = C * Tc
1342
1343      and the transformed system has the form
1344
1345                  | Ac    A12|           | Bc |
1346           Abar = |----------|,   Bbar = | ---|,  Cbar = [Cc | Cnc].
1347                  | 0     Anc|           |  0 |
1348
1349      where (Ac,Bc) is controllable, and Cc(sI-Ac)^(-1)Bc =
1350      C(sI-A)^(-1)B.  and the system is stabilizable if Anc has no
1351      eigenvalues in the right half plane. The last output K is a vector
1352      of length n containing the number of controllable states.
1353
1354
1355
1356
1357 # name: <cell-element>
1358 # type: sq_string
1359 # elements: 1
1360 # length: 80
1361 If Co=ctrb(A,B) has rank r <= n = SIZE(A,1), then there is a similarity
1362 transfor
1363
1364
1365
1366 # name: <cell-element>
1367 # type: sq_string
1368 # elements: 1
1369 # length: 4
1370 dare
1371
1372
1373 # name: <cell-element>
1374 # type: sq_string
1375 # elements: 1
1376 # length: 1786
1377  -- Function File: [X, L, G] = dare (A, B, Q, R)
1378  -- Function File: [X, L, G] = dare (A, B, Q, R, S)
1379  -- Function File: [X, L, G] = dare (A, B, Q, R, [], E)
1380  -- Function File: [X, L, G] = dare (A, B, Q, R, S, E)
1381      Solve discrete-time algebraic Riccati equation (ARE).
1382
1383      *Inputs*
1384     A
1385           Real matrix (n-by-n).
1386
1387     B
1388           Real matrix (n-by-m).
1389
1390     Q
1391           Real matrix (n-by-n).
1392
1393     R
1394           Real matrix (m-by-m).
1395
1396     S
1397           Optional real matrix (n-by-m).  If S is not specified, a zero
1398           matrix is assumed.
1399
1400     E
1401           Optional descriptor matrix (n-by-n).  If E is not specified,
1402           an identity matrix is assumed.
1403
1404      *Outputs*
1405     X
1406           Unique stabilizing solution of the discrete-time Riccati
1407           equation (n-by-n).
1408
1409     L
1410           Closed-loop poles (n-by-1).
1411
1412     G
1413           Corresponding gain matrix (m-by-n).
1414
1415      *Equations*
1416                                     -1
1417           A'XA - X - A'XB (B'XB + R)   B'XA + Q = 0
1418
1419                                           -1
1420           A'XA - X - (A'XB + S) (B'XB + R)   (B'XA + S') + Q = 0
1421
1422                         -1
1423           G = (B'XB + R)   B'XA
1424
1425                         -1
1426           G = (B'XB + R)   (B'XA + S')
1427
1428           L = eig (A - B*G)
1429
1430                                        -1
1431           A'XA - E'XE - A'XB (B'XB + R)   B'XA + Q = 0
1432
1433                                              -1
1434           A'XA - E'XE - (A'XB + S) (B'XB + R)   (B'XA + S') + Q = 0
1435
1436                         -1
1437           G = (B'XB + R)   B'XA
1438
1439                         -1
1440           G = (B'XB + R)   (B'XA + S')
1441
1442           L = eig (A - B*G, E)
1443
1444      *Algorithm*
1445      Uses SLICOT SB02OD and SG02AD by courtesy of NICONET e.V.
1446      (http://www.slicot.org)
1447
1448      See also: care, lqr, dlqr, kalman
1449
1450
1451
1452
1453
1454 # name: <cell-element>
1455 # type: sq_string
1456 # elements: 1
1457 # length: 53
1458 Solve discrete-time algebraic Riccati equation (ARE).
1459
1460
1461
1462 # name: <cell-element>
1463 # type: sq_string
1464 # elements: 1
1465 # length: 4
1466 dlqe
1467
1468
1469 # name: <cell-element>
1470 # type: sq_string
1471 # elements: 1
1472 # length: 1695
1473  -- Function File: [M, P, Z, E] = dlqe (A, G, C, Q, R)
1474  -- Function File: [M, P, Z, E] = dlqe (A, G, C, Q, R, S)
1475  -- Function File: [M, P, Z, E] = dlqe (A, [], C, Q, R)
1476  -- Function File: [M, P, Z, E] = dlqe (A, [], C, Q, R, S)
1477      Kalman filter for discrete-time systems.
1478
1479           x[k] = Ax[k] + Bu[k] + Gw[k]   (State equation)
1480           y[k] = Cx[k] + Du[k] + v[k]    (Measurement Equation)
1481           E(w) = 0, E(v) = 0, cov(w) = Q, cov(v) = R, cov(w,v) = S
1482
1483      *Inputs*
1484     A
1485           State transition matrix of discrete-time system (n-by-n).
1486
1487     G
1488           Process noise matrix of discrete-time system (n-by-g).  If G
1489           is empty `[]', an identity matrix is assumed.
1490
1491     C
1492           Measurement matrix of discrete-time system (p-by-n).
1493
1494     Q
1495           Process noise covariance matrix (g-by-g).
1496
1497     R
1498           Measurement noise covariance matrix (p-by-p).
1499
1500     S
1501           Optional cross term covariance matrix (g-by-p), s = cov(w,v).
1502           If S is empty `[]' or not specified, a zero matrix is assumed.
1503
1504      *Outputs*
1505     M
1506           Kalman filter gain matrix (n-by-p).
1507
1508     P
1509           Unique stabilizing solution of the discrete-time Riccati
1510           equation (n-by-n).  Symmetric matrix.
1511
1512     Z
1513           Error covariance (n-by-n), cov(x(k|k)-x)
1514
1515     E
1516           Closed-loop poles (n-by-1).
1517
1518      *Equations*
1519           x[k|k] = x[k|k-1] + M(y[k] - Cx[k|k-1] - Du[k])
1520
1521           x[k+1|k] = Ax[k|k] + Bu[k] for S=0
1522
1523           x[k+1|k] = Ax[k|k] + Bu[k] + G*S*(C*P*C' + R)^-1*(y[k] - C*x[k|k-1]) for non-zero S
1524
1525
1526           E = eig(A - A*M*C) for S=0
1527
1528           E = eig(A - A*M*C - G*S*(C*P*C' + Rv)^-1*C) for non-zero S
1529
1530      See also: dare, care, dlqr, lqr, lqe
1531
1532
1533
1534
1535
1536 # name: <cell-element>
1537 # type: sq_string
1538 # elements: 1
1539 # length: 40
1540 Kalman filter for discrete-time systems.
1541
1542
1543
1544 # name: <cell-element>
1545 # type: sq_string
1546 # elements: 1
1547 # length: 4
1548 dlqr
1549
1550
1551 # name: <cell-element>
1552 # type: sq_string
1553 # elements: 1
1554 # length: 1374
1555  -- Function File: [G, X, L] = dlqr (SYS, Q, R)
1556  -- Function File: [G, X, L] = dlqr (SYS, Q, R, S)
1557  -- Function File: [G, X, L] = dlqr (A, B, Q, R)
1558  -- Function File: [G, X, L] = dlqr (A, B, Q, R, S)
1559  -- Function File: [G, X, L] = dlqr (A, B, Q, R, [], E)
1560  -- Function File: [G, X, L] = dlqr (A, B, Q, R, S, E)
1561      Linear-quadratic regulator for discrete-time systems.
1562
1563      *Inputs*
1564     SYS
1565           Continuous or discrete-time LTI model (p-by-m, n states).
1566
1567     A
1568           State transition matrix of discrete-time system (n-by-n).
1569
1570     B
1571           Input matrix of discrete-time system (n-by-m).
1572
1573     Q
1574           State weighting matrix (n-by-n).
1575
1576     R
1577           Input weighting matrix (m-by-m).
1578
1579     S
1580           Optional cross term matrix (n-by-m).  If S is not specified,
1581           a zero matrix is assumed.
1582
1583     E
1584           Optional descriptor matrix (n-by-n).  If E is not specified,
1585           an identity matrix is assumed.
1586
1587      *Outputs*
1588     G
1589           State feedback matrix (m-by-n).
1590
1591     X
1592           Unique stabilizing solution of the discrete-time Riccati
1593           equation (n-by-n).
1594
1595     L
1596           Closed-loop poles (n-by-1).
1597
1598      *Equations*
1599           x[k+1] = A x[k] + B u[k],   x[0] = x0
1600
1601                   inf
1602           J(x0) = SUM (x' Q x  +  u' R u  +  2 x' S u)
1603                   k=0
1604
1605           L = eig (A - B*G)
1606
1607      See also: dare, care, lqr
1608
1609
1610
1611
1612
1613 # name: <cell-element>
1614 # type: sq_string
1615 # elements: 1
1616 # length: 53
1617 Linear-quadratic regulator for discrete-time systems.
1618
1619
1620
1621 # name: <cell-element>
1622 # type: sq_string
1623 # elements: 1
1624 # length: 5
1625 dlyap
1626
1627
1628 # name: <cell-element>
1629 # type: sq_string
1630 # elements: 1
1631 # length: 527
1632  -- Function File: X = dlyap (A, B)
1633  -- Function File: X = dlyap (A, B, C)
1634  -- Function File: X = dlyap (A, B, [], E)
1635      Solve discrete-time Lyapunov or Sylvester equations.
1636
1637      *Equations*
1638           AXA' - X + B = 0      (Lyapunov Equation)
1639
1640           AXB' - X + C = 0      (Sylvester Equation)
1641
1642           AXA' - EXE' + B = 0   (Generalized Lyapunov Equation)
1643
1644      *Algorithm*
1645      Uses SLICOT SB03MD, SB04QD and SG03AD by courtesy of NICONET e.V.
1646      (http://www.slicot.org)
1647
1648      See also: dlyapchol, lyap, lyapchol
1649
1650
1651
1652
1653
1654 # name: <cell-element>
1655 # type: sq_string
1656 # elements: 1
1657 # length: 52
1658 Solve discrete-time Lyapunov or Sylvester equations.
1659
1660
1661
1662 # name: <cell-element>
1663 # type: sq_string
1664 # elements: 1
1665 # length: 9
1666 dlyapchol
1667
1668
1669 # name: <cell-element>
1670 # type: sq_string
1671 # elements: 1
1672 # length: 478
1673  -- Function File: U = dlyapchol (A, B)
1674  -- Function File: U = dlyapchol (A, B, E)
1675      Compute Cholesky factor of discrete-time Lyapunov equations.
1676
1677      *Equations*
1678           A U' U A'  -  U' U  +  B B'  =  0           (Lyapunov Equation)
1679
1680           A U' U A'  -  E U' U E'  +  B B'  =  0      (Generalized Lyapunov Equation)
1681
1682      *Algorithm*
1683      Uses SLICOT SB03OD and SG03BD by courtesy of NICONET e.V.
1684      (http://www.slicot.org)
1685
1686      See also: dlyap, lyap, lyapchol
1687
1688
1689
1690
1691
1692 # name: <cell-element>
1693 # type: sq_string
1694 # elements: 1
1695 # length: 60
1696 Compute Cholesky factor of discrete-time Lyapunov equations.
1697
1698
1699
1700 # name: <cell-element>
1701 # type: sq_string
1702 # elements: 1
1703 # length: 3
1704 dss
1705
1706
1707 # name: <cell-element>
1708 # type: sq_string
1709 # elements: 1
1710 # length: 935
1711  -- Function File: SYS = dss (SYS)
1712  -- Function File: SYS = dss (D)
1713  -- Function File: SYS = dss (A, B, C, D, E, ...)
1714  -- Function File: SYS = dss (A, B, C, D, E, TSAM, ...)
1715      Create or convert to descriptor state-space model.
1716
1717      *Inputs*
1718     SYS
1719           LTI model to be converted to state-space.
1720
1721     A
1722           State transition matrix (n-by-n).
1723
1724     B
1725           Input matrix (n-by-m).
1726
1727     C
1728           Measurement matrix (p-by-n).
1729
1730     D
1731           Feedthrough matrix (p-by-m).
1732
1733     E
1734           Descriptor matrix (n-by-n).
1735
1736     TSAM
1737           Sampling time in seconds.  If TSAM is not specified, a
1738           continuous-time model is assumed.
1739
1740     ...
1741           Optional pairs of properties and values.  Type `set (dss)'
1742           for more information.
1743
1744      *Outputs*
1745     SYS
1746           Descriptor state-space model.
1747
1748      *Equations*
1749             .
1750           E x = A x + B u
1751             y = C x + D u
1752
1753      See also: ss, tf
1754
1755
1756
1757
1758
1759 # name: <cell-element>
1760 # type: sq_string
1761 # elements: 1
1762 # length: 50
1763 Create or convert to descriptor state-space model.
1764
1765
1766
1767 # name: <cell-element>
1768 # type: sq_string
1769 # elements: 1
1770 # length: 5
1771 estim
1772
1773
1774 # name: <cell-element>
1775 # type: sq_string
1776 # elements: 1
1777 # length: 654
1778  -- Function File: EST = estim (SYS, L)
1779  -- Function File: EST = estim (SYS, L, SENSORS, KNOWN)
1780      Return state estimator for a given estimator gain.
1781
1782      *Inputs*
1783     SYS
1784           LTI model.
1785
1786     L
1787           State feedback matrix.
1788
1789     SENSORS
1790           Indices of measured output signals y from SYS.  If omitted,
1791           all outputs are measured.
1792
1793     KNOWN
1794           Indices of known input signals u (deterministic) to SYS.  All
1795           other inputs to SYS are assumed stochastic.  If argument
1796           KNOWN is omitted, no inputs u are known.
1797
1798      *Outputs*
1799     EST
1800           State-space model of estimator.
1801
1802      See also: kalman, place
1803
1804
1805
1806
1807
1808 # name: <cell-element>
1809 # type: sq_string
1810 # elements: 1
1811 # length: 50
1812 Return state estimator for a given estimator gain.
1813
1814
1815
1816 # name: <cell-element>
1817 # type: sq_string
1818 # elements: 1
1819 # length: 4
1820 filt
1821
1822
1823 # name: <cell-element>
1824 # type: sq_string
1825 # elements: 1
1826 # length: 1602
1827  -- Function File: SYS = filt (NUM, DEN, ...)
1828  -- Function File: SYS = filt (NUM, DEN, TSAM, ...)
1829      Create discrete-time transfer function model from data in DSP
1830      format.
1831
1832      *Inputs*
1833     NUM
1834           Numerator or cell of numerators.  Each numerator must be a
1835           row vector containing the coefficients of the polynomial in
1836           ascending powers of z^-1.  num{i,j} contains the numerator
1837           polynomial from input j to output i.  In the SISO case, a
1838           single vector is accepted as well.
1839
1840     DEN
1841           Denominator or cell of denominators.  Each denominator must
1842           be a row vector containing the coefficients of the polynomial
1843           in ascending powers of z^-1.  den{i,j} contains the
1844           denominator polynomial from input j to output i.  In the SISO
1845           case, a single vector is accepted as well.
1846
1847     TSAM
1848           Sampling time in seconds.  If TSAM is not specified, default
1849           value -1 (unspecified) is taken.
1850
1851     ...
1852           Optional pairs of properties and values.  Type `set (filt)'
1853           for more information.
1854
1855      *Outputs*
1856     SYS
1857           Discrete-time transfer function model.
1858
1859      *Example*
1860                           3 z^-1
1861           H(z^-1) = -------------------
1862                     1 + 4 z^-1 + 2 z^-2
1863
1864           octave:1> H = filt ([0, 3], [1, 4, 2])
1865
1866           Transfer function 'H' from input 'u1' to output ...
1867
1868                       3 z^-1
1869            y1:  -------------------
1870                 1 + 4 z^-1 + 2 z^-2
1871
1872           Sampling time: unspecified
1873           Discrete-time model.
1874
1875      See also: tf
1876
1877
1878
1879
1880
1881 # name: <cell-element>
1882 # type: sq_string
1883 # elements: 1
1884 # length: 69
1885 Create discrete-time transfer function model from data in DSP format.
1886
1887
1888
1889 # name: <cell-element>
1890 # type: sq_string
1891 # elements: 1
1892 # length: 6
1893 fitfrd
1894
1895
1896 # name: <cell-element>
1897 # type: sq_string
1898 # elements: 1
1899 # length: 1168
1900  -- Function File: [SYS, N] = fitfrd (DAT, N)
1901  -- Function File: [SYS, N] = fitfrd (DAT, N, FLAG)
1902      Fit frequency response data with a state-space system.  If
1903      requested, the returned system is stable and minimum-phase.
1904
1905      *Inputs*
1906     DAT
1907           LTI model containing frequency response data of a SISO system.
1908
1909     N
1910           The desired order of the system to be fitted.  `n <=
1911           length(dat.w)'.
1912
1913     FLAG
1914           The flag controls whether the returned system is stable and
1915           minimum-phase.
1916          0
1917                The system zeros and poles are not constrained.  Default
1918                value.
1919
1920          1
1921                The system zeros and poles will have negative real parts
1922                in the continuous-time case, or moduli less than 1 in
1923                the discrete-time case.
1924
1925      *Outputs*
1926     SYS
1927           State-space model of order N, fitted to frequency response
1928           data DAT.
1929
1930     N
1931           The order of the obtained system.  The value of N could only
1932           be modified if inputs `n > 0' and `flag = 1'.
1933
1934      *Algorithm*
1935      Uses SLICOT SB10YD by courtesy of NICONET e.V.
1936      (http://www.slicot.org)
1937
1938
1939
1940
1941 # name: <cell-element>
1942 # type: sq_string
1943 # elements: 1
1944 # length: 54
1945 Fit frequency response data with a state-space system.
1946
1947
1948
1949 # name: <cell-element>
1950 # type: sq_string
1951 # elements: 1
1952 # length: 10
1953 fwcfconred
1954
1955
1956 # name: <cell-element>
1957 # type: sq_string
1958 # elements: 1
1959 # length: 3221
1960  -- Function File: [KR, INFO] = fwcfconred (G, F, L, ...)
1961  -- Function File: [KR, INFO] = fwcfconred (G, F, L, NCR, ...)
1962  -- Function File: [KR, INFO] = fwcfconred (G, F, L, OPT, ...)
1963  -- Function File: [KR, INFO] = fwcfconred (G, F, L, NCR, OPT, ...)
1964      Reduction of state-feedback-observer based controller by
1965      frequency-weighted coprime factorization (FW CF).  Given a plant
1966      G, state feedback gain F and full observer gain L, determine a
1967      reduced order controller KR by using stability enforcing frequency
1968      weights.
1969
1970      *Inputs*
1971     G
1972           LTI model of the open-loop plant (A,B,C,D).  It has m inputs,
1973           p outputs and n states.
1974
1975     F
1976           Stabilizing state feedback matrix (m-by-n).
1977
1978     L
1979           Stabilizing observer gain matrix (n-by-p).
1980
1981     NCR
1982           The desired order of the resulting reduced order controller
1983           KR.  If not specified, NCR is chosen automatically according
1984           to the description of key 'ORDER'.
1985
1986     ...
1987           Optional pairs of keys and values.  `"key1", value1, "key2",
1988           value2'.
1989
1990     OPT
1991           Optional struct with keys as field names.  Struct OPT can be
1992           created directly or by command `options'.  `opt.key1 =
1993           value1, opt.key2 = value2'.
1994
1995      *Outputs*
1996     KR
1997           State-space model of reduced order controller.
1998
1999     INFO
2000           Struct containing additional information.
2001          INFO.HSV
2002                The Hankel singular values of the extended system?!?.
2003                The N Hankel singular values are ordered decreasingly.
2004
2005          INFO.NCR
2006                The order of the obtained reduced order controller KR.
2007
2008      *Option Keys and Values*
2009     'ORDER', 'NCR'
2010           The desired order of the resulting reduced order controller
2011           KR.  If not specified, NCR is chosen automatically such that
2012           states with Hankel singular values INFO.HSV > TOL1 are
2013           retained.
2014
2015     'METHOD'
2016           Order reduction approach to be used as follows:
2017          'SR', 'B'
2018                Use the square-root Balance & Truncate method.
2019
2020          'BFSR', 'F'
2021                Use the balancing-free square-root Balance & Truncate
2022                method.  Default method.
2023
2024     'CF'
2025           Specifies whether left or right coprime factorization is to
2026           be used as follows:
2027          'LEFT', 'L'
2028                Use left coprime factorization.
2029
2030          'RIGHT', 'R'
2031                Use right coprime factorization.  Default method.
2032
2033     'FEEDBACK'
2034           Specifies whether F and L are fed back positively or
2035           negatively:
2036          '+'
2037                A+BK and A+LC are both Hurwitz matrices.
2038
2039          '-'
2040                A-BK and A-LC are both Hurwitz matrices.  Default value.
2041
2042     'TOL1'
2043           If 'ORDER' is not specified, TOL1 contains the tolerance for
2044           determining the order of the reduced system.  For model
2045           reduction, the recommended value of TOL1 is c*info.hsv(1),
2046           where c lies in the interval [0.00001, 0.001].  Default value
2047           is n*eps*info.hsv(1).  If 'ORDER' is specified, the value of
2048           TOL1 is ignored.
2049
2050      *Algorithm*
2051      Uses SLICOT SB16CD by courtesy of NICONET e.V.
2052      (http://www.slicot.org)
2053
2054
2055
2056
2057 # name: <cell-element>
2058 # type: sq_string
2059 # elements: 1
2060 # length: 80
2061 Reduction of state-feedback-observer based controller by
2062 frequency-weighted copr
2063
2064
2065
2066 # name: <cell-element>
2067 # type: sq_string
2068 # elements: 1
2069 # length: 6
2070 gensig
2071
2072
2073 # name: <cell-element>
2074 # type: sq_string
2075 # elements: 1
2076 # length: 802
2077  -- Function File: [U, T] = gensig (SIGTYPE, TAU)
2078  -- Function File: [U, T] = gensig (SIGTYPE, TAU, TFINAL)
2079  -- Function File: [U, T] = gensig (SIGTYPE, TAU, TFINAL, TSAM)
2080      Generate periodic signal.  Useful in combination with lsim.
2081
2082      *Inputs*
2083     SIGTYPE = "SIN"
2084           Sine wave.
2085
2086     SIGTYPE = "COS"
2087           Cosine wave.
2088
2089     SIGTYPE = "SQUARE"
2090           Square wave.
2091
2092     SIGTYPE = "PULSE"
2093           Periodic pulse.
2094
2095     TAU
2096           Duration of one period in seconds.
2097
2098     TFINAL
2099           Optional duration of the signal in seconds.  Default duration
2100           is 5 periods.
2101
2102     TSAM
2103           Optional sampling time in seconds.  Default spacing is tau/64.
2104
2105      *Outputs*
2106     U
2107           Vector of signal values.
2108
2109     T
2110           Time vector of the signal.
2111
2112      See also: lsim
2113
2114
2115
2116
2117
2118 # name: <cell-element>
2119 # type: sq_string
2120 # elements: 1
2121 # length: 25
2122 Generate periodic signal.
2123
2124
2125
2126 # name: <cell-element>
2127 # type: sq_string
2128 # elements: 1
2129 # length: 4
2130 gram
2131
2132
2133 # name: <cell-element>
2134 # type: sq_string
2135 # elements: 1
2136 # length: 462
2137  -- Function File: W = gram (SYS, MODE)
2138  -- Function File: WC = gram (A, B)
2139      `gram (SYS, "c")' returns the controllability gramian of the
2140      (continuous- or discrete-time) system SYS.  `gram (SYS, "o")'
2141      returns the observability gramian of the (continuous- or
2142      discrete-time) system SYS.  `gram (A, B)' returns the
2143      controllability gramian WC of the continuous-time system dx/dt = a
2144      x + b u; i.e., WC satisfies a Wc + m Wc' + b b' = 0.
2145
2146
2147
2148
2149
2150 # name: <cell-element>
2151 # type: sq_string
2152 # elements: 1
2153 # length: 80
2154 `gram (SYS, "c")' returns the controllability gramian of the
2155 (continuous- or dis
2156
2157
2158
2159 # name: <cell-element>
2160 # type: sq_string
2161 # elements: 1
2162 # length: 5
2163 h2syn
2164
2165
2166 # name: <cell-element>
2167 # type: sq_string
2168 # elements: 1
2169 # length: 1997
2170  -- Function File: [K, N, GAMMA, RCOND] = h2syn (P, NMEAS, NCON)
2171      H-2 control synthesis for LTI plant.
2172
2173      *Inputs*
2174     P
2175           Generalized plant.  Must be a proper/realizable LTI model.
2176
2177     NMEAS
2178           Number of measured outputs v.  The last NMEAS outputs of P
2179           are connected to the inputs of controller K.  The remaining
2180           outputs z (indices 1 to p-nmeas) are used to calculate the
2181           H-2 norm.
2182
2183     NCON
2184           Number of controlled inputs u.  The last NCON inputs of P are
2185           connected to the outputs of controller K.  The remaining
2186           inputs w (indices 1 to m-ncon) are excited by a harmonic test
2187           signal.
2188
2189      *Outputs*
2190     K
2191           State-space model of the H-2 optimal controller.
2192
2193     N
2194           State-space model of the lower LFT of P and K.
2195
2196     GAMMA
2197           H-2 norm of N.
2198
2199     RCOND
2200           Vector RCOND contains estimates of the reciprocal condition
2201           numbers of the matrices which are to be inverted and
2202           estimates of the reciprocal condition numbers of the Riccati
2203           equations which have to be solved during the computation of
2204           the controller K.  For details, see the description of the
2205           corresponding SLICOT algorithm.
2206
2207      *Block Diagram*
2208
2209           gamma = min||N(K)||             N = lft (P, K)
2210                    K         2
2211
2212                          +--------+
2213                  w ----->|        |-----> z
2214                          |  P(s)  |
2215                  u +---->|        |-----+ v
2216                    |     +--------+     |
2217                    |                    |
2218                    |     +--------+     |
2219                    +-----|  K(s)  |<----+
2220                          +--------+
2221
2222                          +--------+
2223                  w ----->|  N(s)  |-----> z
2224                          +--------+
2225
2226      *Algorithm*
2227      Uses SLICOT SB10HD and SB10ED by courtesy of NICONET e.V.
2228      (http://www.slicot.org)
2229
2230      See also: augw, lqr, dlqr, kalman
2231
2232
2233
2234
2235
2236 # name: <cell-element>
2237 # type: sq_string
2238 # elements: 1
2239 # length: 36
2240 H-2 control synthesis for LTI plant.
2241
2242
2243
2244 # name: <cell-element>
2245 # type: sq_string
2246 # elements: 1
2247 # length: 7
2248 hinfsyn
2249
2250
2251 # name: <cell-element>
2252 # type: sq_string
2253 # elements: 1
2254 # length: 2269
2255  -- Function File: [K, N, GAMMA, RCOND] = hinfsyn (P, NMEAS, NCON)
2256  -- Function File: [K, N, GAMMA, RCOND] = hinfsyn (P, NMEAS, NCON, GMAX)
2257      H-infinity control synthesis for LTI plant.
2258
2259      *Inputs*
2260     P
2261           Generalized plant.  Must be a proper/realizable LTI model.
2262
2263     NMEAS
2264           Number of measured outputs v.  The last NMEAS outputs of P
2265           are connected to the inputs of controller K.  The remaining
2266           outputs z (indices 1 to p-nmeas) are used to calculate the
2267           H-infinity norm.
2268
2269     NCON
2270           Number of controlled inputs u.  The last NCON inputs of P are
2271           connected to the outputs of controller K.  The remaining
2272           inputs w (indices 1 to m-ncon) are excited by a harmonic test
2273           signal.
2274
2275     GMAX
2276           The maximum value of the H-infinity norm of N.  It is assumed
2277           that GMAX is sufficiently large so that the controller is
2278           admissible.
2279
2280      *Outputs*
2281     K
2282           State-space model of the H-infinity (sub-)optimal controller.
2283
2284     N
2285           State-space model of the lower LFT of P and K.
2286
2287     GAMMA
2288           L-infinity norm of N.
2289
2290     RCOND
2291           Vector RCOND contains estimates of the reciprocal condition
2292           numbers of the matrices which are to be inverted and
2293           estimates of the reciprocal condition numbers of the Riccati
2294           equations which have to be solved during the computation of
2295           the controller K.  For details, see the description of the
2296           corresponding SLICOT algorithm.
2297
2298      *Block Diagram*
2299
2300           gamma = min||N(K)||             N = lft (P, K)
2301                    K         inf
2302
2303                          +--------+
2304                  w ----->|        |-----> z
2305                          |  P(s)  |
2306                  u +---->|        |-----+ v
2307                    |     +--------+     |
2308                    |                    |
2309                    |     +--------+     |
2310                    +-----|  K(s)  |<----+
2311                          +--------+
2312
2313                          +--------+
2314                  w ----->|  N(s)  |-----> z
2315                          +--------+
2316
2317      *Algorithm*
2318      Uses SLICOT SB10FD and SB10DD by courtesy of NICONET e.V.
2319      (http://www.slicot.org)
2320
2321      See also: augw, mixsyn
2322
2323
2324
2325
2326
2327 # name: <cell-element>
2328 # type: sq_string
2329 # elements: 1
2330 # length: 43
2331 H-infinity control synthesis for LTI plant.
2332
2333
2334
2335 # name: <cell-element>
2336 # type: sq_string
2337 # elements: 1
2338 # length: 9
2339 hnamodred
2340
2341
2342 # name: <cell-element>
2343 # type: sq_string
2344 # elements: 1
2345 # length: 6621
2346  -- Function File: [GR, INFO] = hnamodred (G, ...)
2347  -- Function File: [GR, INFO] = hnamodred (G, NR, ...)
2348  -- Function File: [GR, INFO] = hnamodred (G, OPT, ...)
2349  -- Function File: [GR, INFO] = hnamodred (G, NR, OPT, ...)
2350      Model order reduction by frequency weighted optimal Hankel-norm
2351      (HNA) method.  The aim of model reduction is to find an LTI system
2352      GR of order NR (nr < n) such that the input-output behaviour of GR
2353      approximates the one from original system G.
2354
2355      HNA is an absolute error method which tries to minimize
2356           ||G-Gr||  = min
2357                   H
2358
2359           ||V (G-Gr) W||  = min
2360                         H
2361      where V and W denote output and input weightings.
2362
2363      *Inputs*
2364     G
2365           LTI model to be reduced.
2366
2367     NR
2368           The desired order of the resulting reduced order system GR.
2369           If not specified, NR is chosen automatically according to the
2370           description of key "ORDER".
2371
2372     ...
2373           Optional pairs of keys and values.  `"key1", value1, "key2",
2374           value2'.
2375
2376     OPT
2377           Optional struct with keys as field names.  Struct OPT can be
2378           created directly or by command `options'.  `opt.key1 =
2379           value1, opt.key2 = value2'.
2380
2381      *Outputs*
2382     GR
2383           Reduced order state-space model.
2384
2385     INFO
2386           Struct containing additional information.
2387          INFO.N
2388                The order of the original system G.
2389
2390          INFO.NS
2391                The order of the ALPHA-stable subsystem of the original
2392                system G.
2393
2394          INFO.HSV
2395                The Hankel singular values corresponding to the
2396                projection `op(V)*G1*op(W)', where G1 denotes the
2397                ALPHA-stable part of the original system G.  The NS
2398                Hankel singular values are ordered decreasingly.
2399
2400          INFO.NU
2401                The order of the ALPHA-unstable subsystem of both the
2402                original system G and the reduced-order system GR.
2403
2404          INFO.NR
2405                The order of the obtained reduced order system GR.
2406
2407      *Option Keys and Values*
2408     'ORDER', 'NR'
2409           The desired order of the resulting reduced order system GR.
2410           If not specified, NR is the sum of INFO.NU and the number of
2411           Hankel singular values greater than `max(tol1,
2412           ns*eps*info.hsv(1)';
2413
2414     'METHOD'
2415           Specifies the computational approach to be used.  Valid
2416           values corresponding to this key are:
2417          'DESCRIPTOR'
2418                Use the inverse free descriptor system approach.
2419
2420          'STANDARD'
2421                Use the inversion based standard approach.
2422
2423          'AUTO'
2424                Switch automatically to the inverse free descriptor
2425                approach in case of badly conditioned feedthrough
2426                matrices in V or W.  Default method.
2427
2428     'LEFT', 'V'
2429           LTI model of the left/output frequency weighting.  The
2430           weighting must be antistable.
2431                || V (G-Gr) . ||  = min
2432                                H
2433
2434     'RIGHT', 'W'
2435           LTI model of the right/input frequency weighting.  The
2436           weighting must be antistable.
2437                || . (G-Gr) W ||  = min
2438                                H
2439
2440     'LEFT-INV', 'INV-V'
2441           LTI model of the left/output frequency weighting.  The
2442           weighting must have only antistable zeros.
2443                || inv(V) (G-Gr) . ||  = min
2444                                     H
2445
2446     'RIGHT-INV', 'INV-W'
2447           LTI model of the right/input frequency weighting.  The
2448           weighting must have only antistable zeros.
2449                || . (G-Gr) inv(W) ||  = min
2450                                     H
2451
2452     'LEFT-CONJ', 'CONJ-V'
2453           LTI model of the left/output frequency weighting.  The
2454           weighting must be stable.
2455                || V (G-Gr) . ||  = min
2456                                H
2457
2458     'RIGHT-CONJ', 'CONJ-W'
2459           LTI model of the right/input frequency weighting.  The
2460           weighting must be stable.
2461                || . (G-Gr) W ||  = min
2462                                H
2463
2464     'LEFT-CONJ-INV', 'CONJ-INV-V'
2465           LTI model of the left/output frequency weighting.  The
2466           weighting must be minimum-phase.
2467                || V (G-Gr) . ||  = min
2468                                H
2469
2470     'RIGHT-CONJ-INV', 'CONJ-INV-W'
2471           LTI model of the right/input frequency weighting.  The
2472           weighting must be minimum-phase.
2473                || . (G-Gr) W ||  = min
2474                                H
2475
2476     'ALPHA'
2477           Specifies the ALPHA-stability boundary for the eigenvalues of
2478           the state dynamics matrix G.A.  For a continuous-time system,
2479           ALPHA <= 0 is the boundary value for the real parts of
2480           eigenvalues, while for a discrete-time system, 0 <= ALPHA <=
2481           1 represents the boundary value for the moduli of eigenvalues.
2482           The ALPHA-stability domain does not include the boundary.
2483           Default value is 0 for continuous-time systems and 1 for
2484           discrete-time systems.
2485
2486     'TOL1'
2487           If 'ORDER' is not specified, TOL1 contains the tolerance for
2488           determining the order of the reduced model.  For model
2489           reduction, the recommended value of TOL1 is c*info.hsv(1),
2490           where c lies in the interval [0.00001, 0.001].  TOL1 < 1.  If
2491           'ORDER' is specified, the value of TOL1 is ignored.
2492
2493     'TOL2'
2494           The tolerance for determining the order of a minimal
2495           realization of the ALPHA-stable part of the given model.
2496           TOL2 <= TOL1 < 1.  If not specified, ns*eps*info.hsv(1) is
2497           chosen.
2498
2499     'EQUIL', 'SCALE'
2500           Boolean indicating whether equilibration (scaling) should be
2501           performed on system G prior to order reduction.  Default
2502           value is true if `G.scaled == false' and false if `G.scaled
2503           == true'.  Note that for MIMO models, proper scaling of both
2504           inputs and outputs is of utmost importance.  The input and
2505           output scaling can *not* be done by the equilibration option
2506           or the `prescale' command because these functions perform
2507           state transformations only.  Furthermore, signals should not
2508           be scaled simply to a certain range.  For all inputs (or
2509           outputs), a certain change should be of the same importance
2510           for the model.
2511
2512      Approximation Properties:
2513         * Guaranteed stability of reduced models
2514
2515         * Lower guaranteed error bound
2516
2517         * Guaranteed a priori error bound
2518
2519      *Algorithm*
2520      Uses SLICOT AB09JD by courtesy of NICONET e.V.
2521      (http://www.slicot.org)
2522
2523
2524
2525
2526 # name: <cell-element>
2527 # type: sq_string
2528 # elements: 1
2529 # length: 77
2530 Model order reduction by frequency weighted optimal Hankel-norm (HNA)
2531 method.
2532
2533
2534
2535 # name: <cell-element>
2536 # type: sq_string
2537 # elements: 1
2538 # length: 4
2539 hsvd
2540
2541
2542 # name: <cell-element>
2543 # type: sq_string
2544 # elements: 1
2545 # length: 403
2546  -- Function File: HSV = hsvd (SYS)
2547  -- Function File: HSV = hsvd (SYS, "OFFSET", OFFSET)
2548  -- Function File: HSV = hsvd (SYS, "ALPHA", ALPHA)
2549      Hankel singular values of the stable part of an LTI model.  If no
2550      output arguments are given, the Hankel singular values are
2551      displayed in a plot.
2552
2553      *Algorithm*
2554      Uses SLICOT AB13AD by courtesy of NICONET e.V.
2555      (http://www.slicot.org)
2556
2557
2558
2559
2560 # name: <cell-element>
2561 # type: sq_string
2562 # elements: 1
2563 # length: 58
2564 Hankel singular values of the stable part of an LTI model.
2565
2566
2567
2568 # name: <cell-element>
2569 # type: sq_string
2570 # elements: 1
2571 # length: 7
2572 impulse
2573
2574
2575 # name: <cell-element>
2576 # type: sq_string
2577 # elements: 1
2578 # length: 1247
2579  -- Function File: [Y, T, X] = impulse (SYS)
2580  -- Function File: [Y, T, X] = impulse (SYS, T)
2581  -- Function File: [Y, T, X] = impulse (SYS, TFINAL)
2582  -- Function File: [Y, T, X] = impulse (SYS, TFINAL, DT)
2583      Impulse response of LTI system.  If no output arguments are given,
2584      the response is printed on the screen.
2585
2586      *Inputs*
2587     SYS
2588           LTI model.
2589
2590     T
2591           Time vector.  Should be evenly spaced.  If not specified, it
2592           is calculated by the poles of the system to reflect
2593           adequately the response transients.
2594
2595     TFINAL
2596           Optional simulation horizon.  If not specified, it is
2597           calculated by the poles of the system to reflect adequately
2598           the response transients.
2599
2600     DT
2601           Optional sampling time.  Be sure to choose it small enough to
2602           capture transient phenomena.  If not specified, it is
2603           calculated by the poles of the system.
2604
2605      *Outputs*
2606     Y
2607           Output response array.  Has as many rows as time samples
2608           (length of t) and as many columns as outputs.
2609
2610     T
2611           Time row vector.
2612
2613     X
2614           State trajectories array.  Has `length (t)' rows and as many
2615           columns as states.
2616
2617      See also: initial, lsim, step
2618
2619
2620
2621
2622
2623 # name: <cell-element>
2624 # type: sq_string
2625 # elements: 1
2626 # length: 31
2627 Impulse response of LTI system.
2628
2629
2630
2631 # name: <cell-element>
2632 # type: sq_string
2633 # elements: 1
2634 # length: 7
2635 initial
2636
2637
2638 # name: <cell-element>
2639 # type: sq_string
2640 # elements: 1
2641 # length: 1546
2642  -- Function File: [Y, T, X] = initial (SYS, X0)
2643  -- Function File: [Y, T, X] = initial (SYS, X0, T)
2644  -- Function File: [Y, T, X] = initial (SYS, X0, TFINAL)
2645  -- Function File: [Y, T, X] = initial (SYS, X0, TFINAL, DT)
2646      Initial condition response of state-space model.  If no output
2647      arguments are given, the response is printed on the screen.
2648
2649      *Inputs*
2650     SYS
2651           State-space model.
2652
2653     X0
2654           Vector of initial conditions for each state.
2655
2656     T
2657           Optional time vector.  Should be evenly spaced.  If not
2658           specified, it is calculated by the poles of the system to
2659           reflect adequately the response transients.
2660
2661     TFINAL
2662           Optional simulation horizon.  If not specified, it is
2663           calculated by the poles of the system to reflect adequately
2664           the response transients.
2665
2666     DT
2667           Optional sampling time.  Be sure to choose it small enough to
2668           capture transient phenomena.  If not specified, it is
2669           calculated by the poles of the system.
2670
2671      *Outputs*
2672     Y
2673           Output response array.  Has as many rows as time samples
2674           (length of t) and as many columns as outputs.
2675
2676     T
2677           Time row vector.
2678
2679     X
2680           State trajectories array.  Has `length (t)' rows and as many
2681           columns as states.
2682
2683      *Example*
2684                              .
2685           Continuous Time:   x = A x ,   y = C x ,   x(0) = x0
2686
2687           Discrete Time:   x[k+1] = A x[k] ,   y[k] = C x[k] ,   x[0] = x0
2688
2689      See also: impulse, lsim, step
2690
2691
2692
2693
2694
2695 # name: <cell-element>
2696 # type: sq_string
2697 # elements: 1
2698 # length: 48
2699 Initial condition response of state-space model.
2700
2701
2702
2703 # name: <cell-element>
2704 # type: sq_string
2705 # elements: 1
2706 # length: 6
2707 isctrb
2708
2709
2710 # name: <cell-element>
2711 # type: sq_string
2712 # elements: 1
2713 # length: 1096
2714  -- Function File: [BOOL, NCON] = isctrb (SYS)
2715  -- Function File: [BOOL, NCON] = isctrb (SYS, TOL)
2716  -- Function File: [BOOL, NCON] = isctrb (A, B)
2717  -- Function File: [BOOL, NCON] = isctrb (A, B, E)
2718  -- Function File: [BOOL, NCON] = isctrb (A, B, [], TOL)
2719  -- Function File: [BOOL, NCON] = isctrb (A, B, E, TOL)
2720      Logical check for system controllability.  For numerical reasons,
2721      `isctrb (sys)' should be used instead of `rank (ctrb (sys))'.
2722
2723      *Inputs*
2724     SYS
2725           LTI model.  Descriptor state-space models are possible.
2726
2727     A
2728           State transition matrix.
2729
2730     B
2731           Input matrix.
2732
2733     E
2734           Descriptor matrix.  If E is empty `[]' or not specified, an
2735           identity matrix is assumed.
2736
2737     TOL
2738           Optional roundoff parameter.  Default value is 0.
2739
2740      *Outputs*
2741     BOOL = 0
2742           System is not controllable.
2743
2744     BOOL = 1
2745           System is controllable.
2746
2747     NCON
2748           Number of controllable states.
2749
2750      *Algorithm*
2751      Uses SLICOT AB01OD and TG01HD by courtesy of NICONET e.V.
2752      (http://www.slicot.org)
2753
2754      See also: isobsv
2755
2756
2757
2758
2759
2760 # name: <cell-element>
2761 # type: sq_string
2762 # elements: 1
2763 # length: 41
2764 Logical check for system controllability.
2765
2766
2767
2768 # name: <cell-element>
2769 # type: sq_string
2770 # elements: 1
2771 # length: 12
2772 isdetectable
2773
2774
2775 # name: <cell-element>
2776 # type: sq_string
2777 # elements: 1
2778 # length: 1509
2779  -- Function File: BOOL = isdetectable (SYS)
2780  -- Function File: BOOL = isdetectable (SYS, TOL)
2781  -- Function File: BOOL = isdetectable (A, C)
2782  -- Function File: BOOL = isdetectable (A, C, E)
2783  -- Function File: BOOL = isdetectable (A, C, [], TOL)
2784  -- Function File: BOOL = isdetectable (A, C, E, TOL)
2785  -- Function File: BOOL = isdetectable (A, C, [], [], DFLG)
2786  -- Function File: BOOL = isdetectable (A, C, E, [], DFLG)
2787  -- Function File: BOOL = isdetectable (A, C, [], TOL, DFLG)
2788  -- Function File: BOOL = isdetectable (A, C, E, TOL, DFLG)
2789      Logical test for system detectability.  All unstable modes must be
2790      observable or all unobservable states must be stable.
2791
2792      *Inputs*
2793     SYS
2794           LTI system.
2795
2796     A
2797           State transition matrix.
2798
2799     C
2800           Measurement matrix.
2801
2802     E
2803           Descriptor matrix.  If E is empty `[]' or not specified, an
2804           identity matrix is assumed.
2805
2806     TOL
2807           Optional tolerance for stability.  Default value is 0.
2808
2809     DFLG = 0
2810           Matrices (A, C) are part of a continuous-time system.
2811           Default Value.
2812
2813     DFLG = 1
2814           Matrices (A, C) are part of a discrete-time system.
2815
2816      *Outputs*
2817     BOOL = 0
2818           System is not detectable.
2819
2820     BOOL = 1
2821           System is detectable.
2822
2823      *Algorithm*
2824      Uses SLICOT AB01OD and TG01HD by courtesy of NICONET e.V.
2825      (http://www.slicot.org) See `isstabilizable' for description of
2826      computational method.
2827
2828      See also: isstabilizable, isstable, isctrb, isobsv
2829
2830
2831
2832
2833
2834 # name: <cell-element>
2835 # type: sq_string
2836 # elements: 1
2837 # length: 38
2838 Logical test for system detectability.
2839
2840
2841
2842 # name: <cell-element>
2843 # type: sq_string
2844 # elements: 1
2845 # length: 6
2846 isobsv
2847
2848
2849 # name: <cell-element>
2850 # type: sq_string
2851 # elements: 1
2852 # length: 1094
2853  -- Function File: [BOOL, NOBS] = isobsv (SYS)
2854  -- Function File: [BOOL, NOBS] = isobsv (SYS, TOL)
2855  -- Function File: [BOOL, NOBS] = isobsv (A, C)
2856  -- Function File: [BOOL, NOBS] = isobsv (A, C, E)
2857  -- Function File: [BOOL, NOBS] = isobsv (A, C, [], TOL)
2858  -- Function File: [BOOL, NOBS] = isobsv (A, C, E, TOL)
2859      Logical check for system observability.  For numerical reasons,
2860      `isobsv (sys)' should be used instead of `rank (obsv (sys))'.
2861
2862      *Inputs*
2863     SYS
2864           LTI model.  Descriptor state-space models are possible.
2865
2866     A
2867           State transition matrix.
2868
2869     C
2870           Measurement matrix.
2871
2872     E
2873           Descriptor matrix.  If E is empty `[]' or not specified, an
2874           identity matrix is assumed.
2875
2876     TOL
2877           Optional roundoff parameter.  Default value is 0.
2878
2879      *Outputs*
2880     BOOL = 0
2881           System is not observable.
2882
2883     BOOL = 1
2884           System is observable.
2885
2886     NOBS
2887           Number of observable states.
2888
2889      *Algorithm*
2890      Uses SLICOT AB01OD and TG01HD by courtesy of NICONET e.V.
2891      (http://www.slicot.org)
2892
2893      See also: isctrb
2894
2895
2896
2897
2898
2899 # name: <cell-element>
2900 # type: sq_string
2901 # elements: 1
2902 # length: 39
2903 Logical check for system observability.
2904
2905
2906
2907 # name: <cell-element>
2908 # type: sq_string
2909 # elements: 1
2910 # length: 8
2911 issample
2912
2913
2914 # name: <cell-element>
2915 # type: sq_string
2916 # elements: 1
2917 # length: 614
2918  -- Function File: BOOL = issample (TS)
2919  -- Function File: BOOL = issample (TS, FLG)
2920      Return true if TS is a valid sampling time.
2921
2922      *Inputs*
2923     TS
2924           Alleged sampling time to be tested.
2925
2926     FLG = 1
2927           Accept real scalars TS > 0.  Default Value.
2928
2929     FLG = 0
2930           Accept real scalars TS >= 0.
2931
2932     FLG = -1
2933           Accept real scalars TS > 0 and TS == -1.
2934
2935     FLG = -10
2936           Accept real scalars TS >= 0 and TS == -1.
2937
2938     FLG = -2
2939           Accept real scalars TS >= 0, TS == -1 and TS == -2.
2940
2941      *Outputs*
2942     BOOL
2943           True if conditions are met and false otherwise.
2944
2945
2946
2947
2948
2949 # name: <cell-element>
2950 # type: sq_string
2951 # elements: 1
2952 # length: 43
2953 Return true if TS is a valid sampling time.
2954
2955
2956
2957 # name: <cell-element>
2958 # type: sq_string
2959 # elements: 1
2960 # length: 14
2961 isstabilizable
2962
2963
2964 # name: <cell-element>
2965 # type: sq_string
2966 # elements: 1
2967 # length: 1786
2968  -- Function File: BOOL = isstabilizable (SYS)
2969  -- Function File: BOOL = isstabilizable (SYS, TOL)
2970  -- Function File: BOOL = isstabilizable (A, B)
2971  -- Function File: BOOL = isstabilizable (A, B, E)
2972  -- Function File: BOOL = isstabilizable (A, B, [], TOL)
2973  -- Function File: BOOL = isstabilizable (A, B, E, TOL)
2974  -- Function File: BOOL = isstabilizable (A, B, [], [], DFLG)
2975  -- Function File: BOOL = isstabilizable (A, B, E, [], DFLG)
2976  -- Function File: BOOL = isstabilizable (A, B, [], TOL, DFLG)
2977  -- Function File: BOOL = isstabilizable (A, B, E, TOL, DFLG)
2978      Logical check for system stabilizability.  All unstable modes must
2979      be controllable or all uncontrollable states must be stable.
2980
2981      *Inputs*
2982     SYS
2983           LTI system.
2984
2985     A
2986           State transition matrix.
2987
2988     B
2989           Input matrix.
2990
2991     E
2992           Descriptor matrix.  If E is empty `[]' or not specified, an
2993           identity matrix is assumed.
2994
2995     TOL
2996           Optional tolerance for stability.  Default value is 0.
2997
2998     DFLG = 0
2999           Matrices (A, B) are part of a continuous-time system.
3000           Default Value.
3001
3002     DFLG = 1
3003           Matrices (A, B) are part of a discrete-time system.
3004
3005      *Outputs*
3006     BOOL = 0
3007           System is not stabilizable.
3008
3009     BOOL = 1
3010           System is stabilizable.
3011
3012      *Algorithm*
3013      Uses SLICOT AB01OD and TG01HD by courtesy of NICONET e.V.
3014      (http://www.slicot.org)
3015           * Calculate staircase form (SLICOT AB01OD)
3016           * Extract unobservable part of state transition matrix
3017           * Calculate eigenvalues of unobservable part
3018           * Check whether
3019             real (ev) < -tol*(1 + abs (ev))   continuous-time
3020             abs (ev) < 1 - tol                discrete-time
3021
3022      See also: isdetectable, isstable, isctrb, isobsv
3023
3024
3025
3026
3027
3028 # name: <cell-element>
3029 # type: sq_string
3030 # elements: 1
3031 # length: 41
3032 Logical check for system stabilizability.
3033
3034
3035
3036 # name: <cell-element>
3037 # type: sq_string
3038 # elements: 1
3039 # length: 6
3040 kalman
3041
3042
3043 # name: <cell-element>
3044 # type: sq_string
3045 # elements: 1
3046 # length: 1539
3047  -- Function File: [EST, G, X] = kalman (SYS, Q, R)
3048  -- Function File: [EST, G, X] = kalman (SYS, Q, R, S)
3049  -- Function File: [EST, G, X] = kalman (SYS, Q, R, [], SENSORS, KNOWN)
3050  -- Function File: [EST, G, X] = kalman (SYS, Q, R, S, SENSORS, KNOWN)
3051      Design Kalman estimator for LTI systems.
3052
3053      *Inputs*
3054     SYS
3055           Nominal plant model.
3056
3057     Q
3058           Covariance of white process noise.
3059
3060     R
3061           Covariance of white measurement noise.
3062
3063     S
3064           Optional cross term covariance.  Default value is 0.
3065
3066     SENSORS
3067           Indices of measured output signals y from SYS.  If omitted,
3068           all outputs are measured.
3069
3070     KNOWN
3071           Indices of known input signals u (deterministic) to SYS.  All
3072           other inputs to SYS are assumed stochastic.  If argument
3073           KNOWN is omitted, no inputs u are known.
3074
3075      *Outputs*
3076     EST
3077           State-space model of the Kalman estimator.
3078
3079     G
3080           Estimator gain.
3081
3082     X
3083           Solution of the Riccati equation.
3084
3085      *Block Diagram*
3086                                            u  +-------+         ^
3087                 +---------------------------->|       |-------> y
3088                 |    +-------+     +       y  |  est  |         ^
3089           u ----+--->|       |----->(+)------>|       |-------> x
3090                      |  sys  |       ^ +      +-------+
3091           w -------->|       |       |
3092                      +-------+       | v
3093
3094           Q = cov (w, w')     R = cov (v, v')     S = cov (w, v')
3095
3096      See also: care, dare, estim, lqr
3097
3098
3099
3100
3101
3102 # name: <cell-element>
3103 # type: sq_string
3104 # elements: 1
3105 # length: 40
3106 Design Kalman estimator for LTI systems.
3107
3108
3109
3110 # name: <cell-element>
3111 # type: sq_string
3112 # elements: 1
3113 # length: 3
3114 lqe
3115
3116
3117 # name: <cell-element>
3118 # type: sq_string
3119 # elements: 1
3120 # length: 1696
3121  -- Function File: [L, P, E] = lqe (SYS, Q, R)
3122  -- Function File: [L, P, E] = lqe (SYS, Q, R, S)
3123  -- Function File: [L, P, E] = lqe (A, G, C, Q, R)
3124  -- Function File: [L, P, E] = lqe (A, G, C, Q, R, S)
3125  -- Function File: [L, P, E] = lqe (A, [], C, Q, R)
3126  -- Function File: [L, P, E] = lqe (A, [], C, Q, R, S)
3127      Kalman filter for continuous-time systems.
3128
3129           .
3130           x = Ax + Bu + Gw   (State equation)
3131           y = Cx + Du + v    (Measurement Equation)
3132           E(w) = 0, E(v) = 0, cov(w) = Q, cov(v) = R, cov(w,v) = S
3133
3134      *Inputs*
3135     SYS
3136           Continuous or discrete-time LTI model (p-by-m, n states).
3137
3138     A
3139           State transition matrix of continuous-time system (n-by-n).
3140
3141     G
3142           Process noise matrix of continuous-time system (n-by-g).  If
3143           G is empty `[]', an identity matrix is assumed.
3144
3145     C
3146           Measurement matrix of continuous-time system (p-by-n).
3147
3148     Q
3149           Process noise covariance matrix (g-by-g).
3150
3151     R
3152           Measurement noise covariance matrix (p-by-p).
3153
3154     S
3155           Optional cross term covariance matrix (g-by-p), s = cov(w,v).
3156           If S is empty `[]' or not specified, a zero matrix is assumed.
3157
3158      *Outputs*
3159     L
3160           Kalman filter gain matrix (n-by-p).
3161
3162     P
3163           Unique stabilizing solution of the continuous-time Riccati
3164           equation (n-by-n).  Symmetric matrix.  If SYS is a
3165           discrete-time model, the solution of the corresponding
3166           discrete-time Riccati equation is returned.
3167
3168     E
3169           Closed-loop poles (n-by-1).
3170
3171      *Equations*
3172           .
3173           x = Ax + Bu + L(y - Cx -Du)
3174
3175           E = eig(A - L*C)
3176
3177      See also: dare, care, dlqr, lqr, dlqe
3178
3179
3180
3181
3182
3183 # name: <cell-element>
3184 # type: sq_string
3185 # elements: 1
3186 # length: 42
3187 Kalman filter for continuous-time systems.
3188
3189
3190
3191 # name: <cell-element>
3192 # type: sq_string
3193 # elements: 1
3194 # length: 3
3195 lqr
3196
3197
3198 # name: <cell-element>
3199 # type: sq_string
3200 # elements: 1
3201 # length: 1353
3202  -- Function File: [G, X, L] = lqr (SYS, Q, R)
3203  -- Function File: [G, X, L] = lqr (SYS, Q, R, S)
3204  -- Function File: [G, X, L] = lqr (A, B, Q, R)
3205  -- Function File: [G, X, L] = lqr (A, B, Q, R, S)
3206  -- Function File: [G, X, L] = lqr (A, B, Q, R, [], E)
3207  -- Function File: [G, X, L] = lqr (A, B, Q, R, S, E)
3208      Linear-quadratic regulator.
3209
3210      *Inputs*
3211     SYS
3212           Continuous or discrete-time LTI model (p-by-m, n states).
3213
3214     A
3215           State transition matrix of continuous-time system (n-by-n).
3216
3217     B
3218           Input matrix of continuous-time system (n-by-m).
3219
3220     Q
3221           State weighting matrix (n-by-n).
3222
3223     R
3224           Input weighting matrix (m-by-m).
3225
3226     S
3227           Optional cross term matrix (n-by-m).  If S is not specified,
3228           a zero matrix is assumed.
3229
3230     E
3231           Optional descriptor matrix (n-by-n).  If E is not specified,
3232           an identity matrix is assumed.
3233
3234      *Outputs*
3235     G
3236           State feedback matrix (m-by-n).
3237
3238     X
3239           Unique stabilizing solution of the continuous-time Riccati
3240           equation (n-by-n).
3241
3242     L
3243           Closed-loop poles (n-by-1).
3244
3245      *Equations*
3246           .
3247           x = A x + B u,   x(0) = x0
3248
3249                   inf
3250           J(x0) = INT (x' Q x  +  u' R u  +  2 x' S u)  dt
3251                    0
3252
3253           L = eig (A - B*G)
3254
3255      See also: care, dare, dlqr
3256
3257
3258
3259
3260
3261 # name: <cell-element>
3262 # type: sq_string
3263 # elements: 1
3264 # length: 27
3265 Linear-quadratic regulator.
3266
3267
3268
3269 # name: <cell-element>
3270 # type: sq_string
3271 # elements: 1
3272 # length: 4
3273 lsim
3274
3275
3276 # name: <cell-element>
3277 # type: sq_string
3278 # elements: 1
3279 # length: 1744
3280  -- Function File: [Y, T, X] = lsim (SYS, U)
3281  -- Function File: [Y, T, X] = lsim (SYS, U, T)
3282  -- Function File: [Y, T, X] = lsim (SYS, U, T, X0)
3283  -- Function File: [Y, T, X] = lsim (SYS, U, T, [], METHOD)
3284  -- Function File: [Y, T, X] = lsim (SYS, U, T, X0, METHOD)
3285      Simulate LTI model response to arbitrary inputs.  If no output
3286      arguments are given, the system response is plotted on the screen.
3287
3288      *Inputs*
3289     SYS
3290           LTI model.  System must be proper, i.e. it must not have more
3291           zeros than poles.
3292
3293     U
3294           Vector or array of input signal.  Needs `length(t)' rows and
3295           as many columns as there are inputs.  If SYS is a
3296           single-input system, row vectors U of length `length(t)' are
3297           accepted as well.
3298
3299     T
3300           Time vector.  Should be evenly spaced.  If SYS is a
3301           continuous-time system and T is a real scalar, SYS is
3302           discretized with sampling time `tsam = t/(rows(u)-1)'.  If
3303           SYS is a discrete-time system and T is not specified, vector
3304           T is assumed to be `0 : tsam : tsam*(rows(u)-1)'.
3305
3306     X0
3307           Vector of initial conditions for each state.  If not
3308           specified, a zero vector is assumed.
3309
3310     METHOD
3311           Discretization method for continuous-time models.  Default
3312           value is zoh (zero-order hold).  All methods from `c2d' are
3313           supported.
3314
3315      *Outputs*
3316     Y
3317           Output response array.  Has as many rows as time samples
3318           (length of t) and as many columns as outputs.
3319
3320     T
3321           Time row vector.  It is always evenly spaced.
3322
3323     X
3324           State trajectories array.  Has `length (t)' rows and as many
3325           columns as states.
3326
3327      See also: impulse, initial, step
3328
3329
3330
3331
3332
3333 # name: <cell-element>
3334 # type: sq_string
3335 # elements: 1
3336 # length: 48
3337 Simulate LTI model response to arbitrary inputs.
3338
3339
3340
3341 # name: <cell-element>
3342 # type: sq_string
3343 # elements: 1
3344 # length: 9
3345 ltimodels
3346
3347
3348 # name: <cell-element>
3349 # type: sq_string
3350 # elements: 1
3351 # length: 144
3352  -- Function File: test ltimodels
3353  -- Function File: ltimodels
3354  -- Function File: ltimodels (SYSTYPE)
3355      Test suite and help for LTI models.
3356
3357
3358
3359
3360 # name: <cell-element>
3361 # type: sq_string
3362 # elements: 1
3363 # length: 35
3364 Test suite and help for LTI models.
3365
3366
3367
3368 # name: <cell-element>
3369 # type: sq_string
3370 # elements: 1
3371 # length: 4
3372 lyap
3373
3374
3375 # name: <cell-element>
3376 # type: sq_string
3377 # elements: 1
3378 # length: 527
3379  -- Function File: X = lyap (A, B)
3380  -- Function File: X = lyap (A, B, C)
3381  -- Function File: X = lyap (A, B, [], E)
3382      Solve continuous-time Lyapunov or Sylvester equations.
3383
3384      *Equations*
3385           AX + XA' + B = 0      (Lyapunov Equation)
3386
3387           AX + XB + C = 0       (Sylvester Equation)
3388
3389           AXE' + EXA' + B = 0   (Generalized Lyapunov Equation)
3390
3391      *Algorithm*
3392      Uses SLICOT SB03MD, SB04MD and SG03AD by courtesy of NICONET e.V.
3393      (http://www.slicot.org)
3394
3395      See also: lyapchol, dlyap, dlyapchol
3396
3397
3398
3399
3400
3401 # name: <cell-element>
3402 # type: sq_string
3403 # elements: 1
3404 # length: 54
3405 Solve continuous-time Lyapunov or Sylvester equations.
3406
3407
3408
3409 # name: <cell-element>
3410 # type: sq_string
3411 # elements: 1
3412 # length: 8
3413 lyapchol
3414
3415
3416 # name: <cell-element>
3417 # type: sq_string
3418 # elements: 1
3419 # length: 479
3420  -- Function File: U = lyapchol (A, B)
3421  -- Function File: U = lyapchol (A, B, E)
3422      Compute Cholesky factor of continuous-time Lyapunov equations.
3423
3424      *Equations*
3425           A U' U  +  U' U A'  +  B B'  =  0           (Lyapunov Equation)
3426
3427           A U' U E'  +  E U' U A'  +  B B'  =  0      (Generalized Lyapunov Equation)
3428
3429      *Algorithm*
3430      Uses SLICOT SB03OD and SG03BD by courtesy of NICONET e.V.
3431      (http://www.slicot.org)
3432
3433      See also: lyap, dlyap, dlyapchol
3434
3435
3436
3437
3438
3439 # name: <cell-element>
3440 # type: sq_string
3441 # elements: 1
3442 # length: 62
3443 Compute Cholesky factor of continuous-time Lyapunov equations.
3444
3445
3446
3447 # name: <cell-element>
3448 # type: sq_string
3449 # elements: 1
3450 # length: 6
3451 margin
3452
3453
3454 # name: <cell-element>
3455 # type: sq_string
3456 # elements: 1
3457 # length: 2742
3458  -- Function File: [GAMMA, PHI, W_GAMMA, W_PHI] = margin (SYS)
3459  -- Function File: [GAMMA, PHI, W_GAMMA, W_PHI] = margin (SYS, TOL)
3460      Gain and phase margin of a system.  If no output arguments are
3461      given, both gain and phase margin are plotted on a bode diagram.
3462      Otherwise, the margins and their corresponding frequencies are
3463      computed and returned.
3464
3465      *Inputs*
3466     SYS
3467           LTI model.  Must be a single-input and single-output (SISO)
3468           system.
3469
3470     TOL
3471           Imaginary parts below TOL are assumed to be zero.  If not
3472           specified, default value `sqrt (eps)' is taken.
3473
3474      *Outputs*
3475     GAMMA
3476           Gain margin (as gain, not dBs).
3477
3478     PHI
3479           Phase margin (in degrees).
3480
3481     W_GAMMA
3482           Frequency for the gain margin (in rad/s).
3483
3484     W_PHI
3485           Frequency for the phase margin (in rad/s).
3486
3487      *Equations*
3488           CONTINUOUS SYSTEMS
3489           Gain Margin
3490                   _               _
3491           L(jw) = L(jw)      BTW: L(jw) = L(-jw) = conj (L(jw))
3492
3493           num(jw)   num(-jw)
3494           ------- = --------
3495           den(jw)   den(-jw)
3496
3497           num(jw) den(-jw) = num(-jw) den(jw)
3498
3499           imag (num(jw) den(-jw)) = 0
3500           imag (num(-jw) den(jw)) = 0
3501
3502           Phase Margin
3503                     |num(jw)|
3504           |L(jw)| = |-------| = 1
3505                     |den(jw)|
3506             _     2      2
3507           z z = Re z + Im z
3508
3509           num(jw)   num(-jw)
3510           ------- * -------- = 1
3511           den(jw)   den(-jw)
3512
3513           num(jw) num(-jw) - den(jw) den(-jw) = 0
3514
3515           real (num(jw) num(-jw) - den(jw) den(-jw)) = 0
3516
3517           DISCRETE SYSTEMS
3518           Gain Margin
3519                                        jwT         log z
3520           L(z) = L(1/z)      BTW: z = e    --> w = -----
3521                                                     j T
3522           num(z)   num(1/z)
3523           ------ = --------
3524           den(z)   den(1/z)
3525
3526           num(z) den(1/z) - num(1/z) den(z) = 0
3527
3528           Phase Margin
3529                    |num(z)|
3530           |L(z)| = |------| = 1
3531                    |den(z)|
3532
3533           L(z) L(1/z) = 1
3534
3535           num(z)   num(1/z)
3536           ------ * -------- = 1
3537           den(z)   den(1/z)
3538
3539           num(z) num(1/z) - den(z) den(1/z) = 0
3540
3541           PS: How to get L(1/z)
3542                     4       3       2
3543           p(z) = a z  +  b z  +  c z  +  d z  +  e
3544
3545                       -4      -3      -2      -1
3546           p(1/z) = a z  +  b z  +  c z  +  d z  +  e
3547
3548                     -4                    2       3       4
3549                  = z   ( a  +  b z  +  c z  +  d z  +  e z  )
3550
3551                         4       3       2                     4
3552                  = ( e z  +  d z  +  c z  +  b z  +  a ) / ( z  )
3553
3554      See also: roots
3555
3556
3557
3558
3559
3560 # name: <cell-element>
3561 # type: sq_string
3562 # elements: 1
3563 # length: 34
3564 Gain and phase margin of a system.
3565
3566
3567
3568 # name: <cell-element>
3569 # type: sq_string
3570 # elements: 1
3571 # length: 6
3572 mixsyn
3573
3574
3575 # name: <cell-element>
3576 # type: sq_string
3577 # elements: 1
3578 # length: 4424
3579  -- Function File: [K, N, GAMMA, RCOND] = mixsyn (G, W1, W2, W3, ...)
3580      Solve stacked S/KS/T H-infinity problem.  Bound the largest
3581      singular values of S (for performance), K S (to penalize large
3582      inputs) and T (for robustness and to avoid sensitivity to noise).
3583      In other words, the inputs r are excited by a harmonic test signal.
3584      Then the algorithm tries to find a controller K which minimizes
3585      the H-infinity norm calculated from the outputs z.
3586
3587      *Inputs*
3588     G
3589           LTI model of plant.
3590
3591     W1
3592           LTI model of performance weight.  Bounds the largest singular
3593           values of sensitivity S.  Model must be empty `[]', SISO or
3594           of appropriate size.
3595
3596     W2
3597           LTI model to penalize large control inputs.  Bounds the
3598           largest singular values of KS.  Model must be empty `[]',
3599           SISO or of appropriate size.
3600
3601     W3
3602           LTI model of robustness and noise sensitivity weight.  Bounds
3603           the largest singular values of complementary sensitivity T.
3604           Model must be empty `[]', SISO or of appropriate size.
3605
3606     ...
3607           Optional arguments of `hinfsyn'.  Type `help hinfsyn' for
3608           more information.
3609
3610      All inputs must be proper/realizable.  Scalars, vectors and
3611      matrices are possible instead of LTI models.
3612
3613      *Outputs*
3614     K
3615           State-space model of the H-infinity (sub-)optimal controller.
3616
3617     N
3618           State-space model of the lower LFT of P and K.
3619
3620     GAMMA
3621           L-infinity norm of N.
3622
3623     RCOND
3624           Vector RCOND contains estimates of the reciprocal condition
3625           numbers of the matrices which are to be inverted and
3626           estimates of the reciprocal condition numbers of the Riccati
3627           equations which have to be solved during the computation of
3628           the controller K.  For details, see the description of the
3629           corresponding SLICOT algorithm.
3630
3631      *Block Diagram*
3632
3633                                               | W1 S   |
3634           gamma = min||N(K)||             N = | W2 K S | = lft (P, K)
3635                    K         inf              | W3 T   |
3636
3637                                                                 +------+  z1
3638                       +---------------------------------------->|  W1  |----->
3639                       |                                         +------+
3640                       |                                         +------+  z2
3641                       |                 +---------------------->|  W2  |----->
3642                       |                 |                       +------+
3643            r   +    e |   +--------+  u |   +--------+  y       +------+  z3
3644           ----->(+)---+-->|  K(s)  |----+-->|  G(s)  |----+---->|  W3  |----->
3645                  ^ -      +--------+        +--------+    |     +------+
3646                  |                                        |
3647                  +----------------------------------------+
3648
3649                          +--------+
3650                          |        |-----> z1 (p1x1)          z1 = W1 e
3651            r (px1) ----->|  P(s)  |-----> z2 (p2x1)          z2 = W2 u
3652                          |        |-----> z3 (p3x1)          z3 = W3 y
3653            u (mx1) ----->|        |-----> e (px1)            e = r - y
3654                          +--------+
3655
3656                          +--------+
3657                  r ----->|        |-----> z
3658                          |  P(s)  |
3659                  u +---->|        |-----+ e
3660                    |     +--------+     |
3661                    |                    |
3662                    |     +--------+     |
3663                    +-----|  K(s)  |<----+
3664                          +--------+
3665
3666                          +--------+
3667                  r ----->|  N(s)  |-----> z
3668                          +--------+
3669
3670           Extended Plant:  P = augw (G, W1, W2, W3)
3671           Controller:      K = mixsyn (G, W1, W2, W3)
3672           Entire System:   N = lft (P, K)
3673           Open Loop:       L = G * K
3674           Closed Loop:     T = feedback (L)
3675
3676           Reference:
3677           Skogestad, S. and Postlethwaite I.
3678           Multivariable Feedback Control: Analysis and Design
3679           Second Edition
3680           Wiley 2005
3681           Chapter 3.8: General Control Problem Formulation
3682
3683      *Algorithm*
3684      Relies on commands `augw' and `hinfsyn', which use SLICOT SB10FD
3685      and SB10DD by courtesy of NICONET e.V. (http://www.slicot.org)
3686
3687      See also: hinfsyn, augw
3688
3689
3690
3691
3692
3693 # name: <cell-element>
3694 # type: sq_string
3695 # elements: 1
3696 # length: 40
3697 Solve stacked S/KS/T H-infinity problem.
3698
3699
3700
3701 # name: <cell-element>
3702 # type: sq_string
3703 # elements: 1
3704 # length: 6
3705 ncfsyn
3706
3707
3708 # name: <cell-element>
3709 # type: sq_string
3710 # elements: 1
3711 # length: 2310
3712  -- Function File: [K, N, GAMMA, INFO] = ncfsyn (G, W1, W2, FACTOR)
3713      Loop shaping H-infinity synthesis.  Compute positive feedback
3714      controller using the McFarlane/Glover normalized coprime factor
3715      (NCF) loop shaping design procedure.
3716
3717      *Inputs*
3718     G
3719           LTI model of plant.
3720
3721     W1
3722           LTI model of precompensator.  Model must be SISO or of
3723           appropriate size.  An identity matrix is taken if W1 is not
3724           specified or if an empty model `[]' is passed.
3725
3726     W2
3727           LTI model of postcompensator.  Model must be SISO or of
3728           appropriate size.  An identity matrix is taken if W2 is not
3729           specified or if an empty model `[]' is passed.
3730
3731     FACTOR
3732           `factor = 1' implies that an optimal controller is required.
3733           `factor > 1' implies that a suboptimal controller is required,
3734           achieving a performance that is FACTOR times less than
3735           optimal.  Default value is 1.
3736
3737      *Outputs*
3738     K
3739           State-space model of the H-infinity loop-shaping controller.
3740
3741     N
3742           State-space model of the closed loop depicted below.
3743
3744     GAMMA
3745           L-infinity norm of N.  `gamma = norm (N, inf)'.
3746
3747     INFO
3748           Structure containing additional information.
3749
3750     INFO.EMAX
3751           Nugap robustness.  `emax = inv (gamma)'.
3752
3753     INFO.GS
3754           Shaped plant.  `Gs = W2 * G * W1'.
3755
3756     INFO.KS
3757           Controller for shaped plant.  `Ks = ncfsyn (Gs)'.
3758
3759     INFO.RCOND
3760           Estimates of the reciprocal condition numbers of the Riccati
3761           equations and a few other things.  For details, see the
3762           description of the corresponding SLICOT algorithm.
3763
3764      *Block Diagram of N*
3765
3766                       ^ z1              ^ z2
3767                       |                 |
3768            w1  +      |   +--------+    |            +--------+
3769           ----->(+)---+-->|   Ks   |----+--->(+)---->|   Gs   |----+
3770                  ^ +      +--------+          ^      +--------+    |
3771                  |                        w2  |                    |
3772                  |                                                 |
3773                  +-------------------------------------------------+
3774
3775      *Algorithm*
3776      Uses SLICOT SB10ID, SB10KD and SB10ZD by courtesy of NICONET e.V.
3777      (http://www.slicot.org)
3778
3779
3780
3781
3782 # name: <cell-element>
3783 # type: sq_string
3784 # elements: 1
3785 # length: 34
3786 Loop shaping H-infinity synthesis.
3787
3788
3789
3790 # name: <cell-element>
3791 # type: sq_string
3792 # elements: 1
3793 # length: 7
3794 nichols
3795
3796
3797 # name: <cell-element>
3798 # type: sq_string
3799 # elements: 1
3800 # length: 894
3801  -- Function File: [MAG, PHA, W] = nichols (SYS)
3802  -- Function File: [MAG, PHA, W] = nichols (SYS, W)
3803      Nichols chart of frequency response.  If no output arguments are
3804      given, the response is printed on the screen.
3805
3806      *Inputs*
3807     SYS
3808           LTI system.  Must be a single-input and single-output (SISO)
3809           system.
3810
3811     W
3812           Optional vector of frequency values.  If W is not specified,
3813           it is calculated by the zeros and poles of the system.
3814           Alternatively, the cell `{wmin, wmax}' specifies a frequency
3815           range, where WMIN and WMAX denote minimum and maximum
3816           frequencies in rad/s.
3817
3818      *Outputs*
3819     MAG
3820           Vector of magnitude.  Has length of frequency vector W.
3821
3822     PHA
3823           Vector of phase.  Has length of frequency vector W.
3824
3825     W
3826           Vector of frequency values used.
3827
3828      See also: bode, nyquist, sigma
3829
3830
3831
3832
3833
3834 # name: <cell-element>
3835 # type: sq_string
3836 # elements: 1
3837 # length: 36
3838 Nichols chart of frequency response.
3839
3840
3841
3842 # name: <cell-element>
3843 # type: sq_string
3844 # elements: 1
3845 # length: 7
3846 nyquist
3847
3848
3849 # name: <cell-element>
3850 # type: sq_string
3851 # elements: 1
3852 # length: 901
3853  -- Function File: [RE, IM, W] = nyquist (SYS)
3854  -- Function File: [RE, IM, W] = nyquist (SYS, W)
3855      Nyquist diagram of frequency response.  If no output arguments are
3856      given, the response is printed on the screen.
3857
3858      *Inputs*
3859     SYS
3860           LTI system.  Must be a single-input and single-output (SISO)
3861           system.
3862
3863     W
3864           Optional vector of frequency values.  If W is not specified,
3865           it is calculated by the zeros and poles of the system.
3866           Alternatively, the cell `{wmin, wmax}' specifies a frequency
3867           range, where WMIN and WMAX denote minimum and maximum
3868           frequencies in rad/s.
3869
3870      *Outputs*
3871     RE
3872           Vector of real parts.  Has length of frequency vector W.
3873
3874     IM
3875           Vector of imaginary parts.  Has length of frequency vector W.
3876
3877     W
3878           Vector of frequency values used.
3879
3880      See also: bode, nichols, sigma
3881
3882
3883
3884
3885
3886 # name: <cell-element>
3887 # type: sq_string
3888 # elements: 1
3889 # length: 38
3890 Nyquist diagram of frequency response.
3891
3892
3893
3894 # name: <cell-element>
3895 # type: sq_string
3896 # elements: 1
3897 # length: 4
3898 obsv
3899
3900
3901 # name: <cell-element>
3902 # type: sq_string
3903 # elements: 1
3904 # length: 459
3905  -- Function File: OB = obsv (SYS)
3906  -- Function File: OB = obsv (A, C)
3907      Return observability matrix.
3908
3909      *Inputs*
3910     SYS
3911           LTI model.
3912
3913     A
3914           State transition matrix (n-by-n).
3915
3916     C
3917           Measurement matrix (p-by-n).
3918
3919      *Outputs*
3920     OB
3921           Observability matrix.
3922
3923      *Equation*
3924                | C        |
3925                | CA       |
3926           Ob = | CA^2     |
3927                | ...      |
3928                | CA^(n-1) |
3929
3930
3931
3932
3933 # name: <cell-element>
3934 # type: sq_string
3935 # elements: 1
3936 # length: 28
3937 Return observability matrix.
3938
3939
3940
3941 # name: <cell-element>
3942 # type: sq_string
3943 # elements: 1
3944 # length: 5
3945 obsvf
3946
3947
3948 # name: <cell-element>
3949 # type: sq_string
3950 # elements: 1
3951 # length: 925
3952  -- Function File: [SYSBAR, T, K] = obsvf (SYS)
3953  -- Function File: [SYSBAR, T, K] = obsvf (SYS, TOL)
3954  -- Function File: [ABAR, BBAR, CBAR, T, K] = obsvf (A, B, C)
3955  -- Function File: [ABAR, BBAR, CBAR, T, K] = obsvf (A, B, C, TOL)
3956      If Ob=obsv(A,C) has rank r <= n = SIZE(A,1), then there is a
3957      similarity transformation Tc such that To = [t1;t2] where t1 is c
3958      and t2 is orthogonal to t1
3959
3960           Abar = To \ A * To ,  Bbar = To \ B ,  Cbar = C * To
3961
3962      and the transformed system has the form
3963
3964                  | Ao     0 |           | Bo  |
3965           Abar = |----------|,   Bbar = | --- |,  Cbar = [Co | 0 ].
3966                  | A21   Ano|           | Bno |
3967
3968      where (Ao,Bo) is observable, and Co(sI-Ao)^(-1)Bo = C(sI-A)^(-1)B.
3969      And system is detectable if Ano has no eigenvalues in the right
3970      half plane. The last output K is a vector of length n containing
3971      the number of observable states.
3972
3973
3974
3975
3976 # name: <cell-element>
3977 # type: sq_string
3978 # elements: 1
3979 # length: 80
3980 If Ob=obsv(A,C) has rank r <= n = SIZE(A,1), then there is a similarity
3981 transfor
3982
3983
3984
3985 # name: <cell-element>
3986 # type: sq_string
3987 # elements: 1
3988 # length: 7
3989 optiPID
3990
3991
3992 # name: <cell-element>
3993 # type: sq_string
3994 # elements: 1
3995 # length: 235
3996 Numerical optimization of a PID controller using an objective function.
3997 The objective function is located in the file `optiPIDfun'.  Type
3998 `which optiPID' to locate, `edit optiPID' to open and simply `optiPID'
3999 to run the example file.
4000
4001
4002
4003
4004 # name: <cell-element>
4005 # type: sq_string
4006 # elements: 1
4007 # length: 71
4008 Numerical optimization of a PID controller using an objective function.
4009
4010
4011
4012 # name: <cell-element>
4013 # type: sq_string
4014 # elements: 1
4015 # length: 11
4016 optiPIDctrl
4017
4018
4019 # name: <cell-element>
4020 # type: sq_string
4021 # elements: 1
4022 # length: 397
4023  ===============================================================================
4024  optiPIDctrl                      Lukas Reichlin                   February 2012
4025  ===============================================================================
4026  Return PID controller with roll-off for given parameters Kp, Ti and Td.
4027  ===============================================================================
4028
4029
4030
4031 # name: <cell-element>
4032 # type: sq_string
4033 # elements: 1
4034 # length: 80
4035  ===============================================================================
4036
4037
4038
4039 # name: <cell-element>
4040 # type: sq_string
4041 # elements: 1
4042 # length: 10
4043 optiPIDfun
4044
4045
4046 # name: <cell-element>
4047 # type: sq_string
4048 # elements: 1
4049 # length: 464
4050  ===============================================================================
4051  optiPIDfun                       Lukas Reichlin                       July 2009
4052  ===============================================================================
4053  Objective Function
4054  Reference: Guzzella, L. (2007) Analysis and Synthesis of SISO Control Systems.
4055             vdf Hochschulverlag, Zurich
4056  ===============================================================================
4057
4058
4059
4060 # name: <cell-element>
4061 # type: sq_string
4062 # elements: 1
4063 # length: 80
4064  ===============================================================================
4065
4066
4067
4068 # name: <cell-element>
4069 # type: sq_string
4070 # elements: 1
4071 # length: 7
4072 options
4073
4074
4075 # name: <cell-element>
4076 # type: sq_string
4077 # elements: 1
4078 # length: 791
4079  -- Function File: OPT = options ("KEY1", VALUE1, "KEY2", VALUE2, ...)
4080      Create options struct OPT from a number of key and value pairs.
4081      For use with order reduction commands.
4082
4083      *Inputs*
4084     KEY, PROPERTY
4085           The name of the property.
4086
4087     VALUE
4088           The value of the property.
4089
4090      *Outputs*
4091     OPT
4092           Struct with fields for each key.
4093
4094      *Example*
4095           octave:1> opt = options ("method", "spa", "tol", 1e-6)
4096           opt =
4097
4098             scalar structure containing the fields:
4099
4100               method = spa
4101               tol =  1.0000e-06
4102
4103           octave:2> save filename opt
4104           octave:3> # save the struct 'opt' to file 'filename' for later use
4105           octave:4> load filename
4106           octave:5> # load struct 'opt' from file 'filename'
4107
4108
4109
4110
4111
4112 # name: <cell-element>
4113 # type: sq_string
4114 # elements: 1
4115 # length: 63
4116 Create options struct OPT from a number of key and value pairs.
4117
4118
4119
4120 # name: <cell-element>
4121 # type: sq_string
4122 # elements: 1
4123 # length: 5
4124 place
4125
4126
4127 # name: <cell-element>
4128 # type: sq_string
4129 # elements: 1
4130 # length: 1978
4131  -- Function File: F = place (SYS, P)
4132  -- Function File: F = place (A, B, P)
4133  -- Function File: [F, INFO] = place (SYS, P, ALPHA)
4134  -- Function File: [F, INFO] = place (A, B, P, ALPHA)
4135      Pole assignment for a given matrix pair (A,B) such that `p = eig
4136      (A-B*F)'.  If parameter ALPHA is specified, poles with real parts
4137      (continuous-time) or moduli (discrete-time) below ALPHA are left
4138      untouched.
4139
4140      *Inputs*
4141     SYS
4142           LTI system.
4143
4144     A
4145           State transition matrix (n-by-n) of a continuous-time system.
4146
4147     B
4148           Input matrix (n-by-m) of a continuous-time system.
4149
4150     P
4151           Desired eigenvalues of the closed-loop system state-matrix
4152           A-B*F.  `length (p) <= rows (A)'.
4153
4154     ALPHA
4155           Specifies the maximum admissible value, either for real parts
4156           or for moduli, of the eigenvalues of A which will not be
4157           modified by the eigenvalue assignment algorithm.  `alpha >=
4158           0' for discrete-time systems.
4159
4160      *Outputs*
4161     F
4162           State feedback gain matrix.
4163
4164     INFO
4165           Structure containing additional information.
4166
4167     INFO.NFP
4168           The number of fixed poles, i.e. eigenvalues of A having real
4169           parts less than ALPHA, or moduli less than ALPHA.  These
4170           eigenvalues are not modified by `place'.
4171
4172     INFO.NAP
4173           The number of assigned eigenvalues.  `nap = n-nfp-nup'.
4174
4175     INFO.NUP
4176           The number of uncontrollable eigenvalues detected by the
4177           eigenvalue assignment algorithm.
4178
4179     INFO.Z
4180           The orthogonal matrix Z reduces the closed-loop system state
4181           matrix `A + B*F' to upper real Schur form.  Note the positive
4182           sign in `A + B*F'.
4183
4184      *Note*
4185           Place is also suitable to design estimator gains:
4186           L = place (A.', C.', p).'
4187           L = place (sys.', p).'   # useful for discrete-time systems
4188
4189      *Algorithm*
4190      Uses SLICOT SB01BD by courtesy of NICONET e.V.
4191      (http://www.slicot.org)
4192
4193
4194
4195
4196 # name: <cell-element>
4197 # type: sq_string
4198 # elements: 1
4199 # length: 74
4200 Pole assignment for a given matrix pair (A,B) such that `p = eig
4201 (A-B*F)'.
4202
4203
4204
4205 # name: <cell-element>
4206 # type: sq_string
4207 # elements: 1
4208 # length: 5
4209 pzmap
4210
4211
4212 # name: <cell-element>
4213 # type: sq_string
4214 # elements: 1
4215 # length: 415
4216  -- Function File: pzmap (SYS)
4217  -- Function File: [P, Z] = pzmap (SYS)
4218      Plot the poles and zeros of an LTI system in the complex plane.
4219      If no output arguments are given, the result is plotted on the
4220      screen.  Otherwise, the poles and zeros are computed and returned.
4221
4222      *Inputs*
4223     SYS
4224           LTI model.
4225
4226      *Outputs*
4227     P
4228           Poles of SYS.
4229
4230     Z
4231           Transmission zeros of SYS.
4232
4233
4234
4235
4236 # name: <cell-element>
4237 # type: sq_string
4238 # elements: 1
4239 # length: 63
4240 Plot the poles and zeros of an LTI system in the complex plane.
4241
4242
4243
4244 # name: <cell-element>
4245 # type: sq_string
4246 # elements: 1
4247 # length: 6
4248 rlocus
4249
4250
4251 # name: <cell-element>
4252 # type: sq_string
4253 # elements: 1
4254 # length: 910
4255  -- Function File: rlocus (SYS)
4256  -- Function File: [RLDATA, K] = rlocus (SYS, INCREMENT, MIN_K, MAX_K)
4257      Display root locus plot of the specified SISO system.
4258
4259      *Inputs*
4260     SYS
4261           LTI model.  Must be a single-input and single-output (SISO)
4262           system.
4263
4264     MIN_K
4265           Minimum value of K.
4266
4267     MAX_K
4268           Maximum value of K.
4269
4270     INCREMENT
4271           The increment used in computing gain values.
4272
4273      *Outputs*
4274     RLDATA
4275           Data points plotted: in column 1 real values, in column 2 the
4276           imaginary values.
4277
4278     K
4279           Gains for real axis break points.
4280
4281      *Block Diagram*
4282            u    +         +---+      +------+             y
4283           ------>(+)----->| k |----->| SISO |-------+------->
4284                   ^ -     +---+      +------+       |
4285                   |                                 |
4286                   +---------------------------------+
4287
4288
4289
4290
4291 # name: <cell-element>
4292 # type: sq_string
4293 # elements: 1
4294 # length: 53
4295 Display root locus plot of the specified SISO system.
4296
4297
4298
4299 # name: <cell-element>
4300 # type: sq_string
4301 # elements: 1
4302 # length: 5
4303 sigma
4304
4305
4306 # name: <cell-element>
4307 # type: sq_string
4308 # elements: 1
4309 # length: 1643
4310  -- Function File: [SV, W] = sigma (SYS)
4311  -- Function File: [SV, W] = sigma (SYS, W)
4312  -- Function File: [SV, W] = sigma (SYS, [], PTYPE)
4313  -- Function File: [SV, W] = sigma (SYS, W, PTYPE)
4314      Singular values of frequency response.  If no output arguments are
4315      given, the singular value plot is printed on the screen;
4316
4317      *Inputs*
4318     SYS
4319           LTI system.  Multiple inputs and/or outputs (MIMO systems)
4320           make practical sense.
4321
4322     W
4323           Optional vector of frequency values.  If W is not specified,
4324           it is calculated by the zeros and poles of the system.
4325           Alternatively, the cell `{wmin, wmax}' specifies a frequency
4326           range, where WMIN and WMAX denote minimum and maximum
4327           frequencies in rad/s.
4328
4329     PTYPE = 0
4330           Singular values of the frequency response H of system SYS.
4331           Default Value.
4332
4333     PTYPE = 1
4334           Singular values of the frequency response `inv(H)'; i.e.
4335           inversed system.
4336
4337     PTYPE = 2
4338           Singular values of the frequency response `I + H'; i.e.
4339           inversed sensitivity (or return difference) if `H = P * C'.
4340
4341     PTYPE = 3
4342           Singular values of the frequency response `I + inv(H)'; i.e.
4343           inversed complementary sensitivity if `H = P * C'.
4344
4345      *Outputs*
4346     SV
4347           Array of singular values.  For a system with m inputs and p
4348           outputs, the array sv has `min (m, p)' rows and as many
4349           columns as frequency points `length (w)'.  The singular
4350           values at the frequency `w(k)' are given by `sv(:,k)'.
4351
4352     W
4353           Vector of frequency values used.
4354
4355      See also: bodemag, svd
4356
4357
4358
4359
4360
4361 # name: <cell-element>
4362 # type: sq_string
4363 # elements: 1
4364 # length: 38
4365 Singular values of frequency response.
4366
4367
4368
4369 # name: <cell-element>
4370 # type: sq_string
4371 # elements: 1
4372 # length: 9
4373 spaconred
4374
4375
4376 # name: <cell-element>
4377 # type: sq_string
4378 # elements: 1
4379 # length: 6224
4380  -- Function File: [KR, INFO] = spaconred (G, K, ...)
4381  -- Function File: [KR, INFO] = spaconred (G, K, NCR, ...)
4382  -- Function File: [KR, INFO] = spaconred (G, K, OPT, ...)
4383  -- Function File: [KR, INFO] = spaconred (G, K, NCR, OPT, ...)
4384      Controller reduction by frequency-weighted Singular Perturbation
4385      Approximation (SPA).  Given a plant G and a stabilizing controller
4386      K, determine a reduced order controller KR such that the
4387      closed-loop system is stable and closed-loop performance is
4388      retained.
4389
4390      The algorithm tries to minimize the frequency-weighted error
4391           ||V (K-Kr) W||    = min
4392                         inf
4393      where V and W denote output and input weightings.
4394
4395      *Inputs*
4396     G
4397           LTI model of the plant.  It has m inputs, p outputs and n
4398           states.
4399
4400     K
4401           LTI model of the controller.  It has p inputs, m outputs and
4402           nc states.
4403
4404     NCR
4405           The desired order of the resulting reduced order controller
4406           KR.  If not specified, NCR is chosen automatically according
4407           to the description of key 'ORDER'.
4408
4409     ...
4410           Optional pairs of keys and values.  `"key1", value1, "key2",
4411           value2'.
4412
4413     OPT
4414           Optional struct with keys as field names.  Struct OPT can be
4415           created directly or by command `options'.  `opt.key1 =
4416           value1, opt.key2 = value2'.
4417
4418      *Outputs*
4419     KR
4420           State-space model of reduced order controller.
4421
4422     INFO
4423           Struct containing additional information.
4424          INFO.NCR
4425                The order of the obtained reduced order controller KR.
4426
4427          INFO.NCS
4428                The order of the alpha-stable part of original
4429                controller K.
4430
4431          INFO.HSVC
4432                The Hankel singular values of the alpha-stable part of K.
4433                The NCS Hankel singular values are ordered decreasingly.
4434
4435      *Option Keys and Values*
4436     'ORDER', 'NCR'
4437           The desired order of the resulting reduced order controller
4438           KR.  If not specified, NCR is chosen automatically such that
4439           states with Hankel singular values INFO.HSVC > TOL1 are
4440           retained.
4441
4442     'METHOD'
4443           Order reduction approach to be used as follows:
4444          'SR', 'S'
4445                Use the square-root Singular Perturbation Approximation
4446                method.
4447
4448          'BFSR', 'P'
4449                Use the balancing-free square-root Singular Perturbation
4450                Approximation method.  Default method.
4451
4452     'WEIGHT'
4453           Specifies the type of frequency-weighting as follows:
4454          'NONE'
4455                No weightings are used (V = I, W = I).
4456
4457          'LEFT', 'OUTPUT'
4458                Use stability enforcing left (output) weighting
4459                               -1
4460                     V = (I-G*K) *G ,  W = I
4461
4462          'RIGHT', 'INPUT'
4463                Use stability enforcing right (input) weighting
4464                                        -1
4465                     V = I ,  W = (I-G*K) *G
4466
4467          'BOTH', 'PERFORMANCE'
4468                Use stability and performance enforcing weightings
4469                               -1                -1
4470                     V = (I-G*K) *G ,  W = (I-G*K)
4471                Default value.
4472
4473     'FEEDBACK'
4474           Specifies whether K is a positive or negative feedback
4475           controller:
4476          '+'
4477                Use positive feedback controller.  Default value.
4478
4479          '-'
4480                Use negative feedback controller.
4481
4482     'ALPHA'
4483           Specifies the ALPHA-stability boundary for the eigenvalues of
4484           the state dynamics matrix K.A.  For a continuous-time
4485           controller, ALPHA <= 0 is the boundary value for the real
4486           parts of eigenvalues, while for a discrete-time controller, 0
4487           <= ALPHA <= 1 represents the boundary value for the moduli of
4488           eigenvalues.  The ALPHA-stability domain does not include the
4489           boundary.  Default value is 0 for continuous-time controllers
4490           and 1 for discrete-time controllers.
4491
4492     'TOL1'
4493           If 'ORDER' is not specified, TOL1 contains the tolerance for
4494           determining the order of the reduced controller.  For model
4495           reduction, the recommended value of TOL1 is c*info.hsvc(1),
4496           where c lies in the interval [0.00001, 0.001].  Default value
4497           is info.ncs*eps*info.hsvc(1).  If 'ORDER' is specified, the
4498           value of TOL1 is ignored.
4499
4500     'TOL2'
4501           The tolerance for determining the order of a minimal
4502           realization of the ALPHA-stable part of the given controller.
4503           TOL2 <= TOL1.  If not specified, ncs*eps*info.hsvc(1) is
4504           chosen.
4505
4506     'GRAM-CTRB'
4507           Specifies the choice of frequency-weighted controllability
4508           Grammian as follows:
4509          'STANDARD'
4510                Choice corresponding to standard Enns' method [1].
4511                Default method.
4512
4513          'ENHANCED'
4514                Choice corresponding to the stability enhanced modified
4515                Enns' method of [2].
4516
4517     'GRAM-OBSV'
4518           Specifies the choice of frequency-weighted observability
4519           Grammian as follows:
4520          'STANDARD'
4521                Choice corresponding to standard Enns' method [1].
4522                Default method.
4523
4524          'ENHANCED'
4525                Choice corresponding to the stability enhanced modified
4526                Enns' method of [2].
4527
4528     'EQUIL', 'SCALE'
4529           Boolean indicating whether equilibration (scaling) should be
4530           performed on G and K prior to order reduction.  Default value
4531           is false if both `G.scaled == true, K.scaled == true' and
4532           true otherwise.  Note that for MIMO models, proper scaling of
4533           both inputs and outputs is of utmost importance.  The input
4534           and output scaling can *not* be done by the equilibration
4535           option or the `prescale' command because these functions
4536           perform state transformations only.  Furthermore, signals
4537           should not be scaled simply to a certain range.  For all
4538           inputs (or outputs), a certain change should be of the same
4539           importance for the model.
4540
4541      *Algorithm*
4542      Uses SLICOT SB16AD by courtesy of NICONET e.V.
4543      (http://www.slicot.org)
4544
4545
4546
4547
4548 # name: <cell-element>
4549 # type: sq_string
4550 # elements: 1
4551 # length: 80
4552 Controller reduction by frequency-weighted Singular Perturbation
4553 Approximation (
4554
4555
4556
4557 # name: <cell-element>
4558 # type: sq_string
4559 # elements: 1
4560 # length: 9
4561 spamodred
4562
4563
4564 # name: <cell-element>
4565 # type: sq_string
4566 # elements: 1
4567 # length: 7167
4568  -- Function File: [GR, INFO] = spamodred (G, ...)
4569  -- Function File: [GR, INFO] = spamodred (G, NR, ...)
4570  -- Function File: [GR, INFO] = spamodred (G, OPT, ...)
4571  -- Function File: [GR, INFO] = spamodred (G, NR, OPT, ...)
4572      Model order reduction by frequency weighted Singular Perturbation
4573      Approximation (SPA).  The aim of model reduction is to find an LTI
4574      system GR of order NR (nr < n) such that the input-output
4575      behaviour of GR approximates the one from original system G.
4576
4577      SPA is an absolute error method which tries to minimize
4578           ||G-Gr||    = min
4579                   inf
4580
4581           ||V (G-Gr) W||    = min
4582                         inf
4583      where V and W denote output and input weightings.
4584
4585      *Inputs*
4586     G
4587           LTI model to be reduced.
4588
4589     NR
4590           The desired order of the resulting reduced order system GR.
4591           If not specified, NR is chosen automatically according to the
4592           description of key 'ORDER'.
4593
4594     ...
4595           Optional pairs of keys and values.  `"key1", value1, "key2",
4596           value2'.
4597
4598     OPT
4599           Optional struct with keys as field names.  Struct OPT can be
4600           created directly or by command `options'.  `opt.key1 =
4601           value1, opt.key2 = value2'.
4602
4603      *Outputs*
4604     GR
4605           Reduced order state-space model.
4606
4607     INFO
4608           Struct containing additional information.
4609          INFO.N
4610                The order of the original system G.
4611
4612          INFO.NS
4613                The order of the ALPHA-stable subsystem of the original
4614                system G.
4615
4616          INFO.HSV
4617                The Hankel singular values of the ALPHA-stable part of
4618                the original system G, ordered decreasingly.
4619
4620          INFO.NU
4621                The order of the ALPHA-unstable subsystem of both the
4622                original system G and the reduced-order system GR.
4623
4624          INFO.NR
4625                The order of the obtained reduced order system GR.
4626
4627      *Option Keys and Values*
4628     'ORDER', 'NR'
4629           The desired order of the resulting reduced order system GR.
4630           If not specified, NR is chosen automatically such that states
4631           with Hankel singular values INFO.HSV > TOL1 are retained.
4632
4633     'LEFT', 'OUTPUT'
4634           LTI model of the left/output frequency weighting V.  Default
4635           value is an identity matrix.
4636
4637     'RIGHT', 'INPUT'
4638           LTI model of the right/input frequency weighting W.  Default
4639           value is an identity matrix.
4640
4641     'METHOD'
4642           Approximation method for the L-infinity norm to be used as
4643           follows:
4644          'SR', 'S'
4645                Use the square-root Singular Perturbation Approximation
4646                method.
4647
4648          'BFSR', 'P'
4649                Use the balancing-free square-root Singular Perturbation
4650                Approximation method.  Default method.
4651
4652     'ALPHA'
4653           Specifies the ALPHA-stability boundary for the eigenvalues of
4654           the state dynamics matrix G.A.  For a continuous-time system,
4655           ALPHA <= 0 is the boundary value for the real parts of
4656           eigenvalues, while for a discrete-time system, 0 <= ALPHA <=
4657           1 represents the boundary value for the moduli of eigenvalues.
4658           The ALPHA-stability domain does not include the boundary.
4659           Default value is 0 for continuous-time systems and 1 for
4660           discrete-time systems.
4661
4662     'TOL1'
4663           If 'ORDER' is not specified, TOL1 contains the tolerance for
4664           determining the order of the reduced model.  For model
4665           reduction, the recommended value of TOL1 is c*info.hsv(1),
4666           where c lies in the interval [0.00001, 0.001].  Default value
4667           is info.ns*eps*info.hsv(1).  If 'ORDER' is specified, the
4668           value of TOL1 is ignored.
4669
4670     'TOL2'
4671           The tolerance for determining the order of a minimal
4672           realization of the ALPHA-stable part of the given model.
4673           TOL2 <= TOL1.  If not specified, ns*eps*info.hsv(1) is chosen.
4674
4675     'GRAM-CTRB'
4676           Specifies the choice of frequency-weighted controllability
4677           Grammian as follows:
4678          'STANDARD'
4679                Choice corresponding to a combination method [4] of the
4680                approaches of Enns [1] and Lin-Chiu [2,3].  Default
4681                method.
4682
4683          'ENHANCED'
4684                Choice corresponding to the stability enhanced modified
4685                combination method of [4].
4686
4687     'GRAM-OBSV'
4688           Specifies the choice of frequency-weighted observability
4689           Grammian as follows:
4690          'STANDARD'
4691                Choice corresponding to a combination method [4] of the
4692                approaches of Enns [1] and Lin-Chiu [2,3].  Default
4693                method.
4694
4695          'ENHANCED'
4696                Choice corresponding to the stability enhanced modified
4697                combination method of [4].
4698
4699     'ALPHA-CTRB'
4700           Combination method parameter for defining the
4701           frequency-weighted controllability Grammian.  abs(alphac) <=
4702           1.  If alphac = 0, the choice of Grammian corresponds to the
4703           method of Enns [1], while if alphac = 1, the choice of
4704           Grammian corresponds to the method of Lin and Chiu [2,3].
4705           Default value is 0.
4706
4707     'ALPHA-OBSV'
4708           Combination method parameter for defining the
4709           frequency-weighted observability Grammian.  abs(alphao) <= 1.
4710           If alphao = 0, the choice of Grammian corresponds to the
4711           method of Enns [1], while if alphao = 1, the choice of
4712           Grammian corresponds to the method of Lin and Chiu [2,3].
4713           Default value is 0.
4714
4715     'EQUIL', 'SCALE'
4716           Boolean indicating whether equilibration (scaling) should be
4717           performed on system G prior to order reduction.  Default
4718           value is true if `G.scaled == false' and false if `G.scaled
4719           == true'.  Note that for MIMO models, proper scaling of both
4720           inputs and outputs is of utmost importance.  The input and
4721           output scaling can *not* be done by the equilibration option
4722           or the `prescale' command because these functions perform
4723           state transformations only.  Furthermore, signals should not
4724           be scaled simply to a certain range.  For all inputs (or
4725           outputs), a certain change should be of the same importance
4726           for the model.
4727
4728      *References*
4729      [1] Enns, D.  Model reduction with balanced realizations: An error
4730      bound and a frequency weighted generalization.  Proc. 23-th CDC,
4731      Las Vegas, pp. 127-132, 1984.
4732
4733      [2] Lin, C.-A. and Chiu, T.-Y.  Model reduction via
4734      frequency-weighted balanced realization.  Control Theory and
4735      Advanced Technology, vol. 8, pp. 341-351, 1992.
4736
4737      [3] Sreeram, V., Anderson, B.D.O and Madievski, A.G.  New results
4738      on frequency weighted balanced reduction technique.  Proc. ACC,
4739      Seattle, Washington, pp. 4004-4009, 1995.
4740
4741      [4] Varga, A. and Anderson, B.D.O.  Square-root balancing-free
4742      methods for the frequency-weighted balancing related model
4743      reduction.  (report in preparation)
4744
4745      *Algorithm*
4746      Uses SLICOT AB09ID by courtesy of NICONET e.V.
4747      (http://www.slicot.org)
4748
4749
4750
4751
4752 # name: <cell-element>
4753 # type: sq_string
4754 # elements: 1
4755 # length: 80
4756 Model order reduction by frequency weighted Singular Perturbation
4757 Approximation
4758
4759
4760
4761 # name: <cell-element>
4762 # type: sq_string
4763 # elements: 1
4764 # length: 4
4765 step
4766
4767
4768 # name: <cell-element>
4769 # type: sq_string
4770 # elements: 1
4771 # length: 1235
4772  -- Function File: [Y, T, X] = step (SYS)
4773  -- Function File: [Y, T, X] = step (SYS, T)
4774  -- Function File: [Y, T, X] = step (SYS, TFINAL)
4775  -- Function File: [Y, T, X] = step (SYS, TFINAL, DT)
4776      Step response of LTI system.  If no output arguments are given,
4777      the response is printed on the screen.
4778
4779      *Inputs*
4780     SYS
4781           LTI model.
4782
4783     T
4784           Time vector.  Should be evenly spaced.  If not specified, it
4785           is calculated by the poles of the system to reflect
4786           adequately the response transients.
4787
4788     TFINAL
4789           Optional simulation horizon.  If not specified, it is
4790           calculated by the poles of the system to reflect adequately
4791           the response transients.
4792
4793     DT
4794           Optional sampling time.  Be sure to choose it small enough to
4795           capture transient phenomena.  If not specified, it is
4796           calculated by the poles of the system.
4797
4798      *Outputs*
4799     Y
4800           Output response array.  Has as many rows as time samples
4801           (length of t) and as many columns as outputs.
4802
4803     T
4804           Time row vector.
4805
4806     X
4807           State trajectories array.  Has `length (t)' rows and as many
4808           columns as states.
4809
4810      See also: impulse, initial, lsim
4811
4812
4813
4814
4815
4816 # name: <cell-element>
4817 # type: sq_string
4818 # elements: 1
4819 # length: 28
4820 Step response of LTI system.
4821
4822
4823
4824 # name: <cell-element>
4825 # type: sq_string
4826 # elements: 1
4827 # length: 6
4828 strseq
4829
4830
4831 # name: <cell-element>
4832 # type: sq_string
4833 # elements: 1
4834 # length: 250
4835  -- Function File: STRVEC = strseq (STR, IDX)
4836      Return a cell vector of indexed strings by appending the indices
4837      IDX to the string STR.
4838
4839           strseq ("x", 1:3) = {"x1"; "x2"; "x3"}
4840           strseq ("u", [1, 2, 5]) = {"u1"; "u2"; "u5"}
4841
4842
4843
4844
4845 # name: <cell-element>
4846 # type: sq_string
4847 # elements: 1
4848 # length: 80
4849 Return a cell vector of indexed strings by appending the indices IDX to
4850 the stri
4851
4852
4853
4854 # name: <cell-element>
4855 # type: sq_string
4856 # elements: 1
4857 # length: 12
4858 test_control
4859
4860
4861 # name: <cell-element>
4862 # type: sq_string
4863 # elements: 1
4864 # length: 1089
4865  -- Script File:  test_control
4866      Execute all available tests at once.  The Octave control package
4867      is based on the SLICOT (http://www.slicot.org) library.  SLICOT
4868      needs a LAPACK library which is also a prerequisite for Octave
4869      itself.  In case of failing test, it is highly recommended to use
4870      Netlib's reference LAPACK (http://www.netlib.org/lapack/) for
4871      building Octave.  Using ATLAS may lead to sign changes in some
4872      entries in the state-space matrices.  In general, these sign
4873      changes are not 'wrong' and can be regarded as the result of state
4874      transformations.  Such state transformations (but not input/output
4875      transformations) have no influence on the input-output behaviour
4876      of the system.  For better numerics, the control package uses such
4877      transformations by default when calculating the frequency
4878      responses and a few other things.  However, arguments like the
4879      Hankel singular Values (HSV) must not change.  Differing HSVs and
4880      failing algorithms are known for using Framework Accelerate from
4881      Mac OS X 10.7.
4882
4883
4884
4885
4886 # name: <cell-element>
4887 # type: sq_string
4888 # elements: 1
4889 # length: 36
4890 Execute all available tests at once.
4891
4892
4893
4894 # name: <cell-element>
4895 # type: sq_string
4896 # elements: 1
4897 # length: 10
4898 tfpoly2str
4899
4900
4901 # name: <cell-element>
4902 # type: sq_string
4903 # elements: 1
4904 # length: 158
4905  -- Function File: STR = tfpoly2str (P)
4906  -- Function File: STR = tfpoly2str (P, TFVAR)
4907      Return the string of a polynomial with string TFVAR as variable.
4908
4909
4910
4911
4912 # name: <cell-element>
4913 # type: sq_string
4914 # elements: 1
4915 # length: 64
4916 Return the string of a polynomial with string TFVAR as variable.
4917
4918
4919
4920 # name: <cell-element>
4921 # type: sq_string
4922 # elements: 1
4923 # length: 10
4924 tfpolyones
4925
4926
4927 # name: <cell-element>
4928 # type: sq_string
4929 # elements: 1
4930 # length: 59
4931 Return (pxm) cell of tfpoly([1]).  For internal use only.
4932
4933
4934
4935
4936 # name: <cell-element>
4937 # type: sq_string
4938 # elements: 1
4939 # length: 33
4940 Return (pxm) cell of tfpoly([1]).
4941
4942
4943
4944 # name: <cell-element>
4945 # type: sq_string
4946 # elements: 1
4947 # length: 11
4948 tfpolyzeros
4949
4950
4951 # name: <cell-element>
4952 # type: sq_string
4953 # elements: 1
4954 # length: 59
4955 Return (pxm) cell of tfpoly([0]).  For internal use only.
4956
4957
4958
4959
4960 # name: <cell-element>
4961 # type: sq_string
4962 # elements: 1
4963 # length: 33
4964 Return (pxm) cell of tfpoly([0]).
4965
4966
4967
4968 # name: <cell-element>
4969 # type: sq_string
4970 # elements: 1
4971 # length: 3
4972 zpk
4973
4974
4975 # name: <cell-element>
4976 # type: sq_string
4977 # elements: 1
4978 # length: 1373
4979  -- Function File: S = zpk ("S")
4980  -- Function File: Z = zpk ("Z", TSAM)
4981  -- Function File: SYS = zpk (SYS)
4982  -- Function File: SYS = zpk (K)
4983  -- Function File: SYS = zpk (Z, P, K, ...)
4984  -- Function File: SYS = zpk (Z, P, K, TSAM, ...)
4985  -- Function File: SYS = zpk (Z, P, K, TSAM, ...)
4986      Create transfer function model from zero-pole-gain data.  This is
4987      just a stop-gap compatibility wrapper since zpk models are not yet
4988      implemented.
4989
4990      *Inputs*
4991     SYS
4992           LTI model to be converted to transfer function.
4993
4994     Z
4995           Cell of vectors containing the zeros for each channel.
4996           z{i,j} contains the zeros from input j to output i.  In the
4997           SISO case, a single vector is accepted as well.
4998
4999     P
5000           Cell of vectors containing the poles for each channel.
5001           p{i,j} contains the poles from input j to output i.  In the
5002           SISO case, a single vector is accepted as well.
5003
5004     K
5005           Matrix containing the gains for each channel.  k(i,j)
5006           contains the gain from input j to output i.
5007
5008     TSAM
5009           Sampling time in seconds.  If TSAM is not specified, a
5010           continuous-time model is assumed.
5011
5012     ...
5013           Optional pairs of properties and values.  Type `set (tf)' for
5014           more information.
5015
5016      *Outputs*
5017     SYS
5018           Transfer function model.
5019
5020      See also: tf, ss, dss, frd
5021
5022
5023
5024
5025
5026 # name: <cell-element>
5027 # type: sq_string
5028 # elements: 1
5029 # length: 56
5030 Create transfer function model from zero-pole-gain data.
5031
5032
5033
5034
5035