## TB01VY

### Conversion of the output normal form to a state-space representation

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

Purpose

```  To convert the linear discrete-time system given as its output
normal form [1], with parameter vector THETA, into the state-space
representation (A, B, C, D), with the initial state x0.

```
Specification
```      SUBROUTINE TB01VY( APPLY, N, M, L, THETA, LTHETA, A, LDA, B, LDB,
\$                   C, LDC, D, LDD, X0, 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 TB01VD associated to
a call of TB01VY 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.

THETA   (input) DOUBLE PRECISION array, dimension (LTHETA)
The leading N*(L+M+1)+L*M part of this array must contain
the parameter vector that defines a system (A, B, C, D),
with the initial state x0. 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.

A       (output) DOUBLE PRECISION array, dimension (LDA,N)
The leading N-by-N part of this array contains the 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       (output) DOUBLE PRECISION array, dimension (LDB,M)
The leading N-by-M part of this array contains the 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       (output) DOUBLE PRECISION array, dimension (LDC,N)
The leading L-by-N part of this array contains the 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       (output) DOUBLE PRECISION array, dimension (LDD,M)
The leading L-by-M part of this array contains the system
input/output matrix corresponding to the output normal
form with parameter vector THETA.

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

X0      (output) DOUBLE PRECISION array, dimension (N)
This array contains the initial state of the system, x0,
corresponding to the output normal form with parameter
vector THETA.

```
Workspace
```  DWORK   DOUBLE PRECISION array, dimension (LDWORK)

LDWORK  INTEGER
The length of the array DWORK.
LDWORK >= N*(N+L+1).

```
Error Indicator
```  INFO    INTEGER
= 0:  successful exit;
< 0:  if INFO = -i, the i-th argument had an illegal
value.

```
Method
```  The parameters characterizing A and C are used to build N
orthogonal transformations, which are then applied to recover
these matrices.

```
```  None
```
Example

Program Text

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