## IB01PD

### Estimating system matrices and covariances

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

      To estimate the matrices A, C, B, and D of a linear time-invariant
      (LTI) state space model, using the singular value decomposition
      information provided by other routines. Optionally, the system and
      noise covariance matrices, needed for the Kalman gain, are also
      determined.

Specification

          SUBROUTINE IB01PD( METH, JOB, JOBCV, NOBR, N, M, L, NSMPL, R,
         $                   LDR, A, LDA, C, LDC, B, LDB, D, LDD, Q, LDQ,
         $                   RY, LDRY, S, LDS, O, LDO, TOL, IWORK, DWORK,
         $                   LDWORK, IWARN, INFO )
    C     .. Scalar Arguments ..
          DOUBLE PRECISION   TOL
          INTEGER            INFO, IWARN, L, LDA, LDB, LDC, LDD, LDO, LDQ,
         $                   LDR, LDRY, LDS, LDWORK, M, N, NOBR, NSMPL
          CHARACTER          JOB, JOBCV, METH
    C     .. Array Arguments ..
          DOUBLE PRECISION   A(LDA, *), B(LDB, *), C(LDC, *), D(LDD, *),
         $                   DWORK(*),  O(LDO, *), Q(LDQ, *), R(LDR, *),
         $                   RY(LDRY, *), S(LDS, *)
          INTEGER            IWORK( * )

Arguments

Mode Parameters

      METH    CHARACTER*1
              Specifies the subspace identification method to be used,
              as follows:
              = 'M':  MOESP  algorithm with past inputs and outputs;
              = 'N':  N4SID  algorithm.

      JOB     CHARACTER*1
              Specifies which matrices should be computed, as follows:
              = 'A':  compute all system matrices, A, B, C, and D;
              = 'C':  compute the matrices A and C only;
              = 'B':  compute the matrix B only;
              = 'D':  compute the matrices B and D only.

      JOBCV   CHARACTER*1
              Specifies whether or not the covariance matrices are to
              be computed, as follows:
              = 'C':  the covariance matrices should be computed;
              = 'N':  the covariance matrices should not be computed.

Input/Output Parameters

      NOBR    (input) INTEGER
              The number of block rows,  s,  in the input and output
              Hankel matrices processed by other routines.  NOBR > 1.

      N       (input) INTEGER
              The order of the system.  NOBR > N > 0.

      M       (input) INTEGER
              The number of system inputs.  M >= 0.

      L       (input) INTEGER
              The number of system outputs.  L > 0.

      NSMPL   (input) INTEGER
              If JOBCV = 'C', the total number of samples used for
              calculating the covariance matrices.
              NSMPL >= 2*(M+L)*NOBR.
              This parameter is not meaningful if  JOBCV = 'N'.

      R       (input/workspace) DOUBLE PRECISION array, dimension
              ( LDR,2*(M+L)*NOBR )
              On entry, the leading  2*(M+L)*NOBR-by-2*(M+L)*NOBR  part
              of this array must contain the relevant data for the MOESP
              or N4SID algorithms, as constructed by SLICOT Library
              routines IB01AD or IB01ND. Let  R_ij,  i,j = 1:4,  be the
              ij submatrix of  R  (denoted  S  in IB01AD and IB01ND),
              partitioned by  M*NOBR,  L*NOBR,  M*NOBR,  and  L*NOBR
              rows and columns. The submatrix  R_22  contains the matrix
              of left singular vectors used. Also needed, for
              METH = 'N'  or  JOBCV = 'C',  are the submatrices  R_11,
              R_14 : R_44,  and, for  METH = 'M'  and  JOB <> 'C',  the
              submatrices  R_31  and  R_12,  containing the processed
              matrices  R_1c  and  R_2c,  respectively, as returned by
              SLICOT Library routines IB01AD or IB01ND.
              Moreover, if  METH = 'N'  and  JOB = 'A' or 'C',  the
              block-row  R_41 : R_43  must contain the transpose of the
              block-column  R_14 : R_34  as returned by SLICOT Library
              routines IB01AD or IB01ND.
              The remaining part of  R  is used as workspace.
              On exit, part of this array is overwritten. Specifically,
              if  METH = 'M',  R_22  and  R_31  are overwritten if
                  JOB = 'B' or 'D',  and  R_12,  R_22,  R_14 : R_34,
                  and possibly  R_11  are overwritten if  JOBCV = 'C';
              if  METH = 'N',  all needed submatrices are overwritten.

      LDR     INTEGER
              The leading dimension of the array  R.
              LDR >= 2*(M+L)*NOBR.

      A       (input or output) DOUBLE PRECISION array, dimension
              (LDA,N)
              On entry, if  METH = 'N'  and  JOB = 'B' or 'D',  the
              leading N-by-N part of this array must contain the system
              state matrix.
              If  METH = 'M'  or  (METH = 'N'  and JOB = 'A' or 'C'),
              this array need not be set on input.
              On exit, if  JOB = 'A' or 'C'  and  INFO = 0,  the
              leading N-by-N part of this array contains the system
              state matrix.

      LDA     INTEGER
              The leading dimension of the array A.
              LDA >= N,  if  JOB = 'A' or 'C',  or  METH = 'N'  and
                             JOB = 'B' or 'D';
              LDA >= 1,  otherwise.

      C       (input or output) DOUBLE PRECISION array, dimension
              (LDC,N)
              On entry, if  METH = 'N'  and  JOB = 'B' or 'D',  the
              leading L-by-N part of this array must contain the system
              output matrix.
              If  METH = 'M'  or  (METH = 'N'  and JOB = 'A' or 'C'),
              this array need not be set on input.
              On exit, if  JOB = 'A' or 'C'  and  INFO = 0,  or
              INFO = 3  (or  INFO >= 0,  for  METH = 'M'),  the leading
              L-by-N part of this array contains the system output
              matrix.

      LDC     INTEGER
              The leading dimension of the array C.
              LDC >= L,  if  JOB = 'A' or 'C',  or  METH = 'N'  and
                             JOB = 'B' or 'D';
              LDC >= 1,  otherwise.

      B       (output) DOUBLE PRECISION array, dimension (LDB,M)
              If  M > 0,  JOB = 'A', 'B', or 'D'  and  INFO = 0,  the
              leading N-by-M part of this array contains the system
              input matrix. If  M = 0  or  JOB = 'C',  this array is
              not referenced.

      LDB     INTEGER
              The leading dimension of the array B.
              LDB >= N,  if M > 0 and JOB = 'A', 'B', or 'D';
              LDB >= 1,  if M = 0 or  JOB = 'C'.

      D       (output) DOUBLE PRECISION array, dimension (LDD,M)
              If  M > 0,  JOB = 'A' or 'D'  and  INFO = 0,  the leading
              L-by-M part of this array contains the system input-output
              matrix. If  M = 0  or  JOB = 'C' or 'B',  this array is
              not referenced.

      LDD     INTEGER
              The leading dimension of the array D.
              LDD >= L,  if M > 0 and JOB = 'A' or 'D';
              LDD >= 1,  if M = 0 or  JOB = 'C' or 'B'.

      Q       (output) DOUBLE PRECISION array, dimension (LDQ,N)
              If JOBCV = 'C', the leading N-by-N part of this array
              contains the positive semidefinite state covariance matrix
              to be used as state weighting matrix when computing the
              Kalman gain.
              This parameter is not referenced if JOBCV = 'N'.

      LDQ     INTEGER
              The leading dimension of the array Q.
              LDQ >= N,  if JOBCV = 'C';
              LDQ >= 1,  if JOBCV = 'N'.

      RY      (output) DOUBLE PRECISION array, dimension (LDRY,L)
              If JOBCV = 'C', the leading L-by-L part of this array
              contains the positive (semi)definite output covariance
              matrix to be used as output weighting matrix when
              computing the Kalman gain.
              This parameter is not referenced if JOBCV = 'N'.

      LDRY    INTEGER
              The leading dimension of the array RY.
              LDRY >= L,  if JOBCV = 'C';
              LDRY >= 1,  if JOBCV = 'N'.

      S       (output) DOUBLE PRECISION array, dimension (LDS,L)
              If JOBCV = 'C', the leading N-by-L part of this array
              contains the state-output cross-covariance matrix to be
              used as cross-weighting matrix when computing the Kalman
              gain.
              This parameter is not referenced if JOBCV = 'N'.

      LDS     INTEGER
              The leading dimension of the array S.
              LDS >= N,  if JOBCV = 'C';
              LDS >= 1,  if JOBCV = 'N'.

      O       (output) DOUBLE PRECISION array, dimension ( LDO,N )
              If  METH = 'M'  and  JOBCV = 'C',  or  METH = 'N',
              the leading  L*NOBR-by-N  part of this array contains
              the estimated extended observability matrix, i.e., the
              first  N  columns of the relevant singular vectors.
              If  METH = 'M'  and  JOBCV = 'N',  this array is not
              referenced.

      LDO     INTEGER
              The leading dimension of the array  O.
              LDO >= L*NOBR,  if  JOBCV = 'C'  or  METH = 'N';
              LDO >= 1,       otherwise.

Tolerances

      TOL     DOUBLE PRECISION
              The tolerance to be used for estimating the rank of
              matrices. If the user sets  TOL > 0,  then the given value
              of  TOL  is used as a lower bound for the reciprocal
              condition number;  an m-by-n matrix whose estimated
              condition number is less than  1/TOL  is considered to
              be of full rank.  If the user sets  TOL <= 0,  then an
              implicitly computed, default tolerance, defined by
              TOLDEF = m*n*EPS,  is used instead, where  EPS  is the
              relative machine precision (see LAPACK Library routine
              DLAMCH).

Workspace

      IWORK   INTEGER array, dimension (LIWORK)
              LIWORK = N,                   if METH = 'M' and M = 0
                                         or JOB = 'C' and JOBCV = 'N';
              LIWORK = M*NOBR+N,            if METH = 'M', JOB = 'C',
                                            and JOBCV = 'C';
              LIWORK = max(L*NOBR,M*NOBR),  if METH = 'M', JOB <> 'C',
                                            and JOBCV = 'N';
              LIWORK = max(L*NOBR,M*NOBR+N),  if METH = 'M', JOB <> 'C',
                                              and JOBCV = 'C';
              LIWORK = max(M*NOBR+N,M*(N+L)), if METH = 'N'.

      DWORK   DOUBLE PRECISION array, dimension (LDWORK)
              On exit, if  INFO = 0,  DWORK(1) returns the optimal value
              of LDWORK,  and  DWORK(2),  DWORK(3),  DWORK(4),  and
              DWORK(5)  contain the reciprocal condition numbers of the
              triangular factors of the matrices, defined in the code,
              GaL  (GaL = Un(1:(s-1)*L,1:n)),  R_1c  (if  METH = 'M'),
              M  (if  JOBCV = 'C'  or  METH = 'N'),  and  Q  or  T  (see
              SLICOT Library routines IB01PY or IB01PX),  respectively.
              If  METH = 'N',  DWORK(3)  is set to one without any
              calculations. Similarly, if  METH = 'M'  and  JOBCV = 'N',
              DWORK(4)  is set to one. If  M = 0  or  JOB = 'C',
              DWORK(3)  and  DWORK(5)  are set to one.
              On exit, if  INFO = -30,  DWORK(1)  returns the minimum
              value of LDWORK.

      LDWORK  INTEGER
              The length of the array DWORK.
              LDWORK >= max( LDW1,LDW2 ), where, if METH = 'M',
              LDW1 >= max( 2*(L*NOBR-L)*N+2*N, (L*NOBR-L)*N+N*N+7*N ),
                      if JOB = 'C' or JOB = 'A' and M = 0;
              LDW1 >= max( 2*(L*NOBR-L)*N+N*N+7*N,
                           (L*NOBR-L)*N+N+6*M*NOBR, (L*NOBR-L)*N+N+
                           max( L+M*NOBR, L*NOBR +
                                          max( 3*L*NOBR+1, M ) ) )
                      if M > 0 and JOB = 'A', 'B', or 'D';
              LDW2 >= 0,                                 if JOBCV = 'N';
              LDW2 >= max( (L*NOBR-L)*N+Aw+2*N+max(5*N,(2*M+L)*NOBR+L),
                           4*(M*NOBR+N)+1, M*NOBR+2*N+L ),
                                                         if JOBCV = 'C',
              where Aw = N+N*N, if M = 0 or JOB = 'C';
                    Aw = 0,     otherwise;
              and, if METH = 'N',
              LDW1 >= max( (L*NOBR-L)*N+2*N+(2*M+L)*NOBR+L,
                           2*(L*NOBR-L)*N+N*N+8*N, N+4*(M*NOBR+N)+1,
                           M*NOBR+3*N+L );
              LDW2 >= 0, if M = 0 or JOB = 'C';
              LDW2 >= M*NOBR*(N+L)*(M*(N+L)+1)+
                      max( (N+L)**2, 4*M*(N+L)+1 ),
                      if M > 0 and JOB = 'A', 'B', or 'D'.
              For good performance,  LDWORK  should be larger.

Warning Indicator

      IWARN   INTEGER
              = 0:  no warning;
              = 4:  a least squares problem to be solved has a
                    rank-deficient coefficient matrix;
              = 5:  the computed covariance matrices are too small.
                    The problem seems to be a deterministic one.

Error Indicator

      INFO    INTEGER
              = 0:  successful exit;
              < 0:  if INFO = -i, the i-th argument had an illegal
                    value;
              = 2:  the singular value decomposition (SVD) algorithm did
                    not converge;
              = 3:  a singular upper triangular matrix was found.

Method

      In the MOESP approach, the matrices  A  and  C  are first
      computed from an estimated extended observability matrix [1],
      and then, the matrices  B  and  D  are obtained by solving an
      extended linear system in a least squares sense.
      In the N4SID approach, besides the estimated extended
      observability matrix, the solutions of two least squares problems
      are used to build another least squares problem, whose solution
      is needed to compute the system matrices  A,  C,  B,  and  D.  The
      solutions of the two least squares problems are also optionally
      used by both approaches to find the covariance matrices.

References

      [1] Verhaegen M., and Dewilde, P.
          Subspace Model Identification. Part 1: The output-error state-
          space model identification class of algorithms.
          Int. J. Control, 56, pp. 1187-1210, 1992.

      [2] Van Overschee, P., and De Moor, B.
          N4SID: Two Subspace Algorithms for the Identification
          of Combined Deterministic-Stochastic Systems.
          Automatica, Vol.30, No.1, pp. 75-93, 1994.

      [3] Van Overschee, P.
          Subspace Identification : Theory - Implementation -
          Applications.
          Ph. D. Thesis, Department of Electrical Engineering,
          Katholieke Universiteit Leuven, Belgium, Feb. 1995.

      [4] Sima, V.
          Subspace-based Algorithms for Multivariable System
          Identification.
          Studies in Informatics and Control, 5, pp. 335-344, 1996.

Numerical Aspects

      The implemented method is numerically stable.

Further Comments

      In some applications, it is useful to compute the system matrices
      using two calls to this routine, the first one with  JOB = 'C',
      and the second one with  JOB = 'B' or 'D'.  This is slightly less
      efficient than using a single call with  JOB = 'A',  because some
      calculations are repeated. If  METH = 'N',  all the calculations
      at the first call are performed again at the second call;
      moreover, it is required to save the needed submatrices of  R
      before the first call and restore them before the second call.
      If the covariance matrices are desired,  JOBCV  should be set
      to  'C'  at the second call. If  B  and  D  are both needed, they
      should be computed at once.
      It is possible to compute the matrices A and C using the MOESP
      algorithm (METH = 'M'), and the matrices B and D using the N4SID
      algorithm (METH = 'N'). This combination could be slightly more
      efficient than N4SID algorithm alone and it could be more accurate
      than MOESP algorithm. No saving/restoring is needed in such a
      combination, provided  JOBCV  is set to  'N'  at the first call.
      Recommended usage:  either one call with  JOB = 'A',  or
         first  call with  METH = 'M',  JOB = 'C',  JOBCV = 'N',
         second call with  METH = 'M',  JOB = 'D',  JOBCV = 'C',  or
         first  call with  METH = 'M',  JOB = 'C',  JOBCV = 'N',
         second call with  METH = 'N',  JOB = 'D',  JOBCV = 'C'.

Example

Program Text

      None

Program Data

      None

Program Results

      None

Return to Supporting Routines index