### Computing the output of a Wiener system

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

Purpose

```  To calculate the output y of the Wiener system

x(t+1) = A*x(t) + B*u(t)
z(t)   = C*x(t) + D*u(t),

y(t)   = f(z(t),wb(1:L)),

where t = 1, 2, ..., NSMP, and f is a nonlinear function,
evaluated by the SLICOT Library routine NF01AY. The parameter
vector X is partitioned as X = ( wb(1), ..., wb(L), theta ),
where wb(i), i = 1:L, correspond to the nonlinear part, theta
corresponds to the linear part, and the notation is fully
described below.

```
Specification
```      SUBROUTINE NF01AD( NSMP, M, L, IPAR, LIPAR, X, LX, U, LDU, Y, LDY,
\$                   DWORK, LDWORK, INFO )
C     .. Scalar Arguments ..
INTEGER           INFO, L, LDU, LDWORK, LDY, LX, LIPAR, M, NSMP
C     .. Array Arguments ..
INTEGER           IPAR(*)
DOUBLE PRECISION  DWORK(*), U(LDU,*), X(*), Y(LDY,*)

```
Arguments

Input/Output Parameters

```  NSMP    (input) INTEGER
The number of training samples.  NSMP >= 0.

M       (input) INTEGER
The length of each input sample.  M >= 0.

L       (input) INTEGER
The length of each output sample.  L >= 0.

IPAR    (input) INTEGER array, dimension (LIPAR)
The integer parameters needed.
IPAR(1)  must contain the order of the linear part,
referred to as N below.  N >= 0.
IPAR(2)  must contain the number of neurons for the
nonlinear part, referred to as NN below.
NN >= 0.

LIPAR   (input) INTEGER
The length of IPAR.  LIPAR >= 2.

X       (input) DOUBLE PRECISION array, dimension (LX)
The parameter vector, partitioned as
X = (wb(1), ..., wb(L), theta), where the vectors
wb(i), of length NN*(L+2)+1, are parameters for the
static nonlinearity, which is simulated by the
SLICOT Library routine NF01AY. See the documentation of
NF01AY for further details. The vector theta, of length
N*(M + L + 1) + L*M, represents the matrices A, B, C,
by SLICOT Library routine TB01VD and retranslated by
TB01VY.

LX      (input) INTEGER
The length of the array X.
LX >= ( NN*(L+2)+1 )*L + N*(M + L + 1) + L*M.

U       (input) DOUBLE PRECISION array, dimension (LDU, M)
The leading NSMP-by-M part of this array must contain the
set of input samples,
U = ( U(1,1),...,U(1,M); ...; U(NSMP,1),...,U(NSMP,M) ).

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

Y       (output) DOUBLE PRECISION array, dimension (LDY, L)
The leading NSMP-by-L part of this array contains the
simulated output.

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

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

LDWORK  INTEGER
The length of the array DWORK.
LDWORK >= NSMP*L + MAX( 2*NN, (N + L)*(N + M) + 2*N +
MAX( N*(N + L), N + M + L ) )
if M > 0;
LDWORK >= NSMP*L + MAX( 2*NN, (N + L)*N + 2*N +
MAX( N*(N + L), L ) ),   if M = 0.
A larger value of LDWORK could improve the efficiency.

```
Error Indicator
```  INFO    INTEGER
= 0:  successful exit;
< 0:  if INFO = -i, the i-th argument had an illegal
value.
```
Method
```  BLAS routines are used for the matrix-vector multiplications and
the routine NF01AY is called for the calculation of the nonlinear
function.

```
```  None
```
Example

Program Text

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