Polynomial model with identifiable parameters
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 sys
= idpoly(A,B,C,D,F
,NoiseVariance
,Ts
,Name,Value
)Name,Value
pair
arguments.
creates a timeseries model with only an autoregressive term. In this
case, sys
= idpoly(A)sys
represents the AR model given by A(q^{–1}) y(t) = e(t).
The noise e(t) has variance
1. A
specifies the initial values of the estimable
coefficients.
creates
a timeseries 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 = []
, then sys
represents
the ARMA model given by:
$$A\left({q}^{1}\right)y\left(t\right)=C\left({q}^{1}\right)e\left(t\right).$$
creates
a timeseries model using additional options specified by one or more sys
= idpoly(A,[],C,D,[],NoiseVariance
,Ts
,Name,Value
)Name,Value
pair
arguments.
converts
any dynamic system model, sys
= idpoly(sys0
)sys0
, to idpoly
model
form.
An idpoly
model represents a system as
a continuoustime or discretetime polynomial model with identifiable
(estimable) coefficients.
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)$$
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) are the Laplace transformed
inputs to sys
. Y(s)
are the Laplace transformed outputs. E(s)
is the Laplace transform of the disturbance.
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.
Timeseries 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.
There are three ways to obtain an idpoly
model:
Estimate the idpoly
model based
on output or inputoutput measurements of a system, 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 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.

Initial values of polynomial coefficients. For SISO models, specify the initial values of the polynomial coefficients as row vectors. Specify the coefficients in order of:
The leading coefficients of For MIMO models with N_{y} outputs
and N_{u} inputs,
The leading coefficients of the diagonal entries of Use Default:  

Sample time. For continuoustime models, Default: –1 (discretetime model with unspecified sample time)  

The variance (covariance matrix) of the model innovations e. An identified model includes a white, Gaussian noise component e(t). For SISO models, Default: N_{y}byN_{y} identity matrix  

Dynamic system. Any dynamic system to be converted into an When For the syntax 
Specify optional
commaseparated pairs of Name,Value
arguments. Name
is
the argument name and Value
is the corresponding value.
Name
must appear inside quotes. You can specify several name and value
pair arguments in any order as
Name1,Value1,...,NameN,ValueN
.
Use Name,Value
arguments to specify additional properties of idpoly
models
during model creation. For example, idpoly(A,B,C,D,F,1,0,'InputName','Voltage')
creates
an idpoly
model with the InputName
property
set to Voltage
.
idpoly
object properties include:

Values of polynomial coefficients. If you create an If you obtain an For an For SISO polynomial models, the values of the numerator coefficients are stored as a row vector in order of:
The leading coefficients of For MIMO models with N_{y} outputs
and N_{u} inputs,
The leading coefficients of the diagonal entries of For a time series (a model with no measured inputs), Default:  

Polynomial model display variable, specified as one of the following values:
The value of  

Transport delays. If you create an For an For continuoustime systems, transport delays are expressed
in the time unit stored in the For a MIMO system with Default: 0 for all input/output pairs  

Logical vector, denoting presence or absence of integration on noise channels. Specify
Default: 0 for all output channels  

Information about the estimable parameters of the
For a MIMO model with
An inactive polynomial, such as the  

The variance (covariance matrix) of the model innovations e. An identified model includes a white Gaussian noise component e(t). For SISO models,  

Summary report that contains information about the estimation
options and results when the polynomial model is obtained using estimation
commands, such as
The contents of m = idpoly({[1 0.5]},{[1 5]},{[1 0.01]}); m.Report.OptionsUsed ans = [] If you obtain the polynomial model using estimation commands,
the fields of load iddata2 z2; m = polyest(z2,[2 2 3 3 2 1]); m.Report.OptionsUsed Option set for the polyest command: InitialCondition: 'auto' Focus: 'prediction' EstimateCovariance: 1 Display: 'off' InputOffset: [] OutputOffset: [] Regularization: [1x1 struct] SearchMethod: 'auto' SearchOptions: [1x1 idoptions.search.identsolver] Advanced: [1x1 struct]
For more information on this property and how to use it, see the Output Arguments section of the corresponding estimation command reference page and Estimation Report.  

Input delay for each input channel, specified as a scalar value
or numeric vector. For continuoustime systems, specify input delays
in the time unit stored in the For a system with You can also set Default: 0  

Output delays. For identified systems, such as  

Sample time. For continuoustime models, Changing this property does not discretize or resample the model.
Use Default: –1 (discretetime model with unspecified sample time)  

Units for the time variable, the sample time
Changing this property has no effect on other properties, and
therefore changes the overall system behavior. Use Default:  

Input channel names, specified as one of the following:
Alternatively, use automatic vector expansion to assign input
names for multiinput models. For example, if sys.InputName = 'controls'; The input names automatically expand to When you estimate a model using an You can use the shorthand notation Input channel names have several uses, including:
Default:  

Input channel units, specified as one of the following:
Use Default:  

Input channel groups. The sys.InputGroup.controls = [1 2]; sys.InputGroup.noise = [3 5]; creates input groups named sys(:,'controls') Default: Struct with no fields  

Output channel names, specified as one of the following:
Alternatively, use automatic vector expansion to assign output
names for multioutput models. For example, if sys.OutputName = 'measurements'; The output names automatically expand to When you estimate a model using an You can use the shorthand notation Output channel names have several uses, including:
Default:  

Output channel units, specified as one of the following:
Use Default:  

Output channel groups. The sys.OutputGroup.temperature = [1]; sys.InputGroup.measurement = [3 5]; creates output groups named sys('measurement',:) Default: Struct with no fields  

System name, specified as a character vector. For example, Default:  

Any text that you want to associate with the system, stored as a string or a cell array of
character vectors. The property stores whichever data type you
provide. For instance, if sys1.Notes = "sys1 has a string."; sys2.Notes = 'sys2 has a character vector.'; sys1.Notes sys2.Notes ans = "sys1 has a string." ans = 'sys2 has a character vector.' Default:  

Any type of data you want to associate with system, specified as any MATLAB^{®} data type. Default:  

Sampling grid for model arrays, specified as a data structure. For arrays of identified linear (IDLTI) models that are derived by sampling one or more independent variables, this property tracks the variable values associated with each model. This information appears when you display or plot the model array. Use this information to trace results back to the independent variables. Set the field names of the data structure to the names of the sampling variables. Set the field values to the sampled variable values associated with each model in the array. All sampling variables should be numeric and scalar valued, and all arrays of sampled values should match the dimensions of the model array. For example, if you collect data at various operating points of a system, you can identify a model for each operating point separately and then stack the results together into a single system array. You can tag the individual models in the array with information regarding the operating point: nominal_engine_rpm = [1000 5000 10000];
sys.SamplingGrid = struct('rpm', nominal_engine_rpm) where For model arrays generated by linearizing a Simulink^{®} model
at multiple parameter values or operating points, the software populates Default: 
Although idpoly
supports continuoustime
models, idtf
and idproc
enable
more choices for estimation of continuoustime models. Therefore,
for some continuoustime applications, these model types are preferable.
ar
 armax
 arx
 bj
 idproc
 idss
 idtf
 iv4
 ivar
 oe
 polydata
 polyest
 setPolyFormat
 translatecov