# idpoly

Polynomial model with identifiable parameters

## Description

An `idpoly`

model represents a system as a continuous-time or
discrete-time polynomial model with identifiable (estimable) coefficients. Use
`idpoly`

to create a polynomial model or to convert Dynamic System Models to
polynomial form.

A polynomial model of a system with input vector *u*, output vector
*y*, and disturbance *e* takes the following form in
discrete time:

$$A(q)y(t)=\frac{B(q)}{F(q)}u(t)+\frac{C(q)}{D(q)}e(t)$$

The variables *A*, *B*, *C*,
*D*, and *F* are polynomials expressed with the time-shift
operator *q ^{-1}*. For instance, the

*A*polynomial takes this form:

$$A(q)=1+{a}_{1}{q}^{-1}+{a}_{2}{q}^{-2}+\cdots +{a}_{na}{q}^{-na}$$

Here, *na* is the order of the *A*
polynomial.
*q ^{-1}*

*y*(

*t*) is equivalent to

*y*(

*t*-

*1*).

For example, if *A*(*q*) = 1 +
*a _{1}*

*q*+

^{-1}*a*q

_{2}^{-2}, then

*A*(

*y*(

*t*)) = 1 +

*a*(

_{1}*t-1*) +

*a*(

_{2}*t-2*).

The *C*, *D*, and *F* polynomials take
the same form as the *A* polynomial, starting with 1. The
*B* polynomial does not start with 1.

In continuous time, a polynomial model takes the following form:

$$A(s)Y(s)=\frac{B(s)}{F(s)}U(s)+\frac{C(s)}{D(s)}E(s)$$

*U*(*s*) contains the Laplace transformed inputs to
`sys`

. *Y*(*s*) contains the Laplace
transformed outputs. *E*(*s*) contains the Laplace transform
of the disturbances for each output.

For `idpoly`

models, the coefficients of the polynomials
*A*, *B*, *C*, *D*, and
*F* can be estimable parameters. The `idpoly`

model stores
the values of these matrix elements in the `A`

, `B`

,
`C`

, `D`

, and `F`

properties of the
model.

Time-series models are special cases of polynomial models for systems without measured
inputs. For AR models, `B`

and `F`

are empty, and
`C`

and `D`

are 1 for all outputs. For ARMA models,
`B`

and `F`

are empty, while `D`

is
1.

Although `idpoly`

supports continuous-time models,
`idtf`

and `idproc`

enable more choices for estimation of
continuous-time models. Therefore, for most continuous-time applications, these other model
types are preferable.

For more information about polynomial models, see What Are Polynomial Models?

## Creation

You can obtain an `idpoly`

model in one of three ways.

Estimate the

`idpoly`

model based on output or input-output measurements of a system by using commands such as`polyest`

,`arx`

,`armax`

,`oe`

,`bj`

,`iv4`

, or`ivar`

. These commands estimate the values of the free polynomial coefficients. The estimated values are stored in the`A`

,`B`

,`C`

,`D`

, and`F`

properties of the resulting`idpoly`

model. The`Report`

property of the resulting model stores information about the estimation, such as information on the handling of initial conditions and options used in estimation.When you obtain an

`idpoly`

model by estimation, you can extract estimated coefficients and their uncertainties from the model using commands such as`polydata`

,`getpar`

, or`getcov`

.Create an

`idpoly`

model using the`idpoly`

command. You can create an`idpoly`

model to configure an initial parameterization for estimation of a polynomial model to fit measured response data. When you do so, you can specify constraints on the polynomial coefficients. For example, you can fix the values of some coefficients, or specify minimum or maximum values for the free coefficients. You can then use the configured model as an input argument to`polyest`

to estimate parameter values with those constraints.Convert an existing dynamic system model to an

`idpoly`

model using the`idpoly`

command.

### Syntax

### Description

#### Create Input-Output Polynomial Model

creates a polynomial model with identifiable coefficients. `sys`

= idpoly(`A,B,C,D,F`

,`NoiseVariance`

,`Ts`

)`A`

,
`B`

, `C`

, `D`

, and
`F`

specify the initial values of the coefficients.
`NoiseVariance`

specifies the initial value of the variance of the
white noise source. `Ts`

is the model sample time.

creates a polynomial model using additional options specified by one or more name-value
pair arguments.`sys`

= idpoly(`A,B,C,D,F`

,`NoiseVariance`

,`Ts`

,`Name,Value`

)

#### Create Time-Series Model

creates a time-series
model with only an autoregressive term. In this case, `sys`

= idpoly(A)`sys`

represents
the AR model given by *A*(*q*)
*y*(*t*) =
*e*(*t*). The noise *e*(*t*) has variance 1.
`A`

specifies the initial values of the estimable coefficients.

creates a time-series model with an autoregressive and a moving average term. The inputs
`sys`

= idpoly(A,[],C,D,[],`NoiseVariance`

,`Ts`

)`A`

, `C`

, and `D`

, specify the
initial values of the estimable coefficients. `NoiseVariance`

specifies the initial value of the noise *e*(*t*).
`Ts`

is the model sample time. (Omit
`NoiseVariance`

and `Ts`

to use their default
values.)

If `D`

is set to `[]`

, then `sys`

represents the ARMA model given by

$$A(q)y(t)=C(q)e(t)$$

creates a time-series model using additional options specified by one or more name-value
pair arguments.`sys`

= idpoly(A,[],C,D,[],`NoiseVariance`

,`Ts`

,`Name,Value`

)

#### Convert Dynamic System Model to Polynomial Model

converts the dynamic system model `sys`

= idpoly(`sys0`

)`sys0`

to `idpoly`

model form. `sys0`

can be any dynamic system model.

converts `sys`

= idpoly(`sys0`

,'split')`sys0`

to `idpoly`

model form, and treats
the last *N _{y}* input channels of

`sys0`

as noise channels in the returned model.
`sys0`

must be a numeric `tf`

(Control System Toolbox), `zpk`

(Control System Toolbox), or `ss`

(Control System Toolbox) model object. Also, `sys0`

must have at least as many
inputs as outputs.### Input Arguments

## Properties

## Object Functions

In general, any function applicable to Dynamic System Models is
applicable to an `idpoly`

model object. These functions are of four general types.

Functions that operate and return

`idpoly`

model objects enable you to transform and manipulate`idpoly`

models. For instance:Functions that perform analytical and simulation functions on

`idpoly`

models, such as`bode`

and`sim`

Functions that retrieve or interpret model information, such as

`advice`

and`getpar`

Functions that convert

`idpoly`

models into a different model type, such as`idtf`

for time domain or`idfrd`

for frequency domain

The following lists contain a representative subset of the functions that you can use with
`idpoly`

models.

## Examples

## Version History

**Introduced before R2006a**