## TF01MX

### Output sequence of a linear time-invariant open-loop system given its system matrix

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

Purpose

```  To compute the output sequence of a linear time-invariant
open-loop system given by its discrete-time state-space model
with an (N+P)-by-(N+M) general system matrix S,

( A  B )
S = (      ) .
( C  D )

The initial state vector x(1) must be supplied by the user.

The input and output trajectories are stored as in the SLICOT
Library routine TF01MY.

```
Specification
```      SUBROUTINE TF01MX( N, M, P, NY, S, LDS, U, LDU, X, Y, LDY,
\$                   DWORK, LDWORK, INFO )
C     .. Scalar Arguments ..
INTEGER           INFO, LDS, LDU, LDWORK, LDY, M, N, NY, P
C     .. Array Arguments ..
DOUBLE PRECISION  DWORK(*), S(LDS,*), U(LDU,*), X(*), Y(LDY,*)

```
Arguments

Input/Output Parameters

```  N       (input) INTEGER
The order of the matrix A.  N >= 0.

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

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

NY      (input) INTEGER
The number of output vectors y(k) to be computed.
NY >= 0.

S       (input) DOUBLE PRECISION array, dimension (LDS,N+M)
The leading (N+P)-by-(N+M) part of this array must contain
the system matrix S.

LDS     INTEGER
The leading dimension of array S.  LDS >= MAX(1,N+P).

U       (input) DOUBLE PRECISION array, dimension (LDU,M)
The leading NY-by-M part of this array must contain the
input vector sequence u(k), for k = 1,2,...,NY.
Specifically, the k-th row of U must contain u(k)'.

LDU     INTEGER
The leading dimension of array U.  LDU >= MAX(1,NY).

X       (input/output) DOUBLE PRECISION array, dimension (N)
On entry, this array must contain the initial state vector
x(1) which consists of the N initial states of the system.
On exit, this array contains the final state vector
x(NY+1) of the N states of the system at instant NY+1.

Y       (output) DOUBLE PRECISION array, dimension (LDY,P)
The leading NY-by-P part of this array contains the output
vector sequence y(1),y(2),...,y(NY) such that the k-th
row of Y contains y(k)' (the outputs at instant k),
for k = 1,2,...,NY.

LDY     INTEGER
The leading dimension of array Y.  LDY >= MAX(1,NY).

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

LDWORK  INTEGER
The length of the array DWORK.
LDWORK >= 0,        if MIN(N,P,NY) = 0;  otherwise,
LDWORK >= N+P,      if M = 0;
LDWORK >= 2*N+M+P,  if M > 0.
For better performance, LDWORK should be larger.

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

```
Method
```  Given an initial state vector x(1), the output vector sequence
y(1), y(2),..., y(NY) is obtained via the formulae

( x(k+1) )     ( x(k) )
(        ) = S (      ) ,
(  y(k)  )     ( u(k) )

where each element y(k) is a vector of length P containing the
outputs at instant k, and k = 1,2,...,NY.

```
References
```   Luenberger, D.G.
Introduction to Dynamic Systems: Theory, Models and
Applications.
John Wiley & Sons, New York, 1979.

```
Numerical Aspects
```  The algorithm requires approximately (N + M) x (N + P) x NY

```
```  The implementation exploits data locality as much as possible,
given the workspace length.

```
Example

Program Text

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