## TB01VD

### Conversion of a linear discrete-time system into the output normal form

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

Purpose

```  To convert the linear discrete-time system given as (A, B, C, D),
with initial state x0, into the output normal form , with
parameter vector THETA. The matrix A is assumed to be stable.
The matrices A, B, C, D and the vector x0 are converted, so that
on exit they correspond to the system defined by THETA.

```
Specification
```      SUBROUTINE TB01VD( APPLY, N, M, L, A, LDA, B, LDB, C, LDC, D, LDD,
\$                   X0, THETA, LTHETA, DWORK, LDWORK, INFO )
C     .. Scalar Arguments ..
CHARACTER         APPLY
INTEGER           INFO, L, LDA, LDB, LDC, LDD, LDWORK, LTHETA, M,
\$                  N
C     .. Array Arguments ..
DOUBLE PRECISION  A(LDA,*), B(LDB,*), C(LDC,*), D(LDD,*),
\$                  DWORK(*), THETA(*), X0(*)

```
Arguments

Mode Parameters

```  APPLY   CHARACTER*1
Specifies whether or not the parameter vector should be
transformed using a bijective mapping, as follows:
= 'A' : apply the bijective mapping to the N vectors in
THETA corresponding to the matrices A and C;
= 'N' : do not apply the bijective mapping.
The transformation performed when APPLY = 'A' allows
to get rid of the constraints norm(THETAi) < 1, i = 1:N.
A call of the SLICOT Library routine TB01VY associated to
a call of TB01VD must use the same value of APPLY.

```
Input/Output Parameters
```  N       (input) INTEGER
The order of the system.  N >= 0.

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

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

A       (input/output) DOUBLE PRECISION array, dimension (LDA,N)
On entry, the leading N-by-N part of this array must
contain the system state matrix A, assumed to be stable.
On exit, the leading N-by-N part of this array contains
the transformed system state matrix corresponding to the
output normal form with parameter vector THETA.

LDA     INTEGER
The leading dimension of array A.  LDA >= MAX(1,N).

B       (input/output) DOUBLE PRECISION array, dimension (LDB,M)
On entry, the leading N-by-M part of this array must
contain the system input matrix B.
On exit, the leading N-by-M part of this array contains
the transformed system input matrix corresponding to the
output normal form with parameter vector THETA.

LDB     INTEGER
The leading dimension of array B.  LDB >= MAX(1,N).

C       (input/output) DOUBLE PRECISION array, dimension (LDC,N)
On entry, the leading L-by-N part of this array must
contain the system output matrix C.
On exit, the leading L-by-N part of this array contains
the transformed system output matrix corresponding to the
output normal form with parameter vector THETA.

LDC     INTEGER
The leading dimension of array C.  LDC >= MAX(1,L).

D       (input) DOUBLE PRECISION array, dimension (LDD,M)
The leading L-by-M part of this array must contain the
system input/output matrix D.

LDD     INTEGER
The leading dimension of array D.  LDD >= MAX(1,L).

X0      (input/output) DOUBLE PRECISION array, dimension (N)
On entry, this array must contain the initial state of the
system, x0.
On exit, this array contains the transformed initial state
of the system, corresponding to the output normal form
with parameter vector THETA.

THETA   (output) DOUBLE PRECISION array, dimension (LTHETA)
The leading N*(L+M+1)+L*M part of this array contains the
parameter vector that defines a system (A, B, C, D, x0)
which is equivalent up to a similarity transformation to
the system given on entry. The parameters are:

THETA(1:N*L)                      : parameters for A, C;
THETA(N*L+1:N*(L+M))              : parameters for B;
THETA(N*(L+M)+1:N*(L+M)+L*M)      : parameters for D;
THETA(N*(L+M)+L*M+1:N*(L+M+1)+L*M): parameters for x0.

LTHETA  INTEGER
The length of array THETA.  LTHETA >= N*(L+M+1)+L*M.

```
Workspace
```  DWORK   DOUBLE PRECISION array, dimension (LDWORK)
On exit, if INFO = 0, DWORK(1) returns the optimal value
of LDWORK.

LDWORK  INTEGER
The length of the array DWORK.
LDWORK >= MAX(1, N*N*L + N*L + N,
N*N + MAX(N*N + N*MAX(N,L) + 6*N + MIN(N,L),
N*M)).
For optimum performance LDWORK should be larger.

```
Error Indicator
```  INFO    INTEGER
= 0:  successful exit;
< 0:  if INFO = -i, the i-th argument had an illegal
value;
= 1:  if the Lyapunov equation A'*Q*A - Q = -scale^2*C'*C
could only be solved with scale = 0;
= 2:  if matrix A is not discrete-time stable;
= 3:  if the QR algorithm failed to converge for
matrix A.

```
Method
```  The matrices A and C are converted to output normal form.
First, the Lyapunov equation

A'*Q*A - Q = -scale^2*C'*C,

is solved in the Cholesky factor T, T'*T = Q, and then T is used
to get the transformation matrix.

The matrix B and the initial state x0 are transformed accordingly.

Then, the QR factorization of the transposed observability matrix
is computed, and the matrix Q is used to further transform the
system matrices. The parameters characterizing A and C are finally
obtained by applying a set of N orthogonal transformations.

```
References
```   Peeters, R.L.M., Hanzon, B., and Olivi, M.
Balanced realizations of discrete-time stable all-pass
systems and the tangential Schur algorithm.
Proceedings of the European Control Conference,
31 August - 3 September 1999, Karlsruhe, Germany.
Session CP-6, Discrete-time Systems, 1999.

```
```  None
```
Example

Program Text

```  None
```
Program Data
```  None
```
Program Results
```  None
```