You can now estimate models online at
the commandline using new online estimation commands: recursiveAR
, recursiveARMA
, recursiveARX
, recursiveARMAX
, recursiveOE
, recursiveBJ
,
and recursiveLS
. For more information, see Perform Online Parameter Estimation at the Command Line.
You can then deploy the generated code or standalone application in your target hardware using MATLAB^{®} Compiler™ or MATLAB Coder™.
Bayesian Information Criteria (BIC) and Akaike Information Criteria (AIC) are now computed during model estimation. These metrics provide a measure of model quality that you can use to compare different models and pick the best one. The most accurate model has the smallest AIC and BIC values.
The software computes and stores the following new values in
the Report.Fit
property of the estimated model:
Raw AIC (AIC
)
Small samplesize corrected AIC (AICc
)
Normalized AIC (nAIC
)
Bayesian Information Criteria (BIC
)
For more information on these metrics, see Loss Function and Model Quality Metrics.
Alternatively, you can use the value = aic(___,measure)
syntax
to return the various AIC values. For more information, see the aic
reference page.
procest
command returns estimated input offsetsYou can now use the following syntax for returning the estimated value of the offset in input signal:
[sys,offset] = procest(___)
procest
automatically
estimates the input offset when the model contains an integrator,
or when you set the InputOffset
estimation option
to 'estimate'
using procestOptions
.
sim
command for simulating linear and nonlinear identified models The syntaxes for simulating linear and nonlinear identified
models have been unified into a single sim
command.
Starting in R2015b, use a simOptions
option
set to configure your simulation. The previous syntax for nonlinear
model simulation will continue to work in future releases.
If your code uses any of the following functionality when simulating nonlinear models, consider updating the code.
Nonlinear Model  Functionality  Use This Instead 

idnlarx , idnlhw or idnlgrey  Simulate model with additive noise using y = sim(model,u,'Noise')  opt = simOptions('AddNoise',true); y
= sim(model,y,opt); 
idnlarx , idnlhw or idnlgrey  Simulate models with initial states specified using y
= sim(model,u,'InitialState',init)  opt = simOptions('InitialCondition',init); y = sim(model,y,opt); 
idnlgrey  Return simulation final states using [y,y_sd,XFINAL]
= sim(model,u)  [y,y_sd,x] = sim(model,u); XFINAL
= x(end,:)'; 
You can now specify the orientation of inputoutput data plots
created using plot
.
Display options for inputoutput data include:
All in one row
All in one column
All outputs in a column, and all inputs in a second column
All outputs in a row, and all inputs in a second row
To do so in the plot window, rightclick the plot, and choose Orientation option from the context menu.
At the command line, use the Orientation
option
of the iddataPlotOptions
option
set.
compare
command plot interfaceThe plot generated using compare
has
the following changes:
Fit%, the normalized root mean square measure of the goodness of the fit, now displays in the legend of the plot instead of in a separate panel to the right of the plot.
The context menu now has the following new options:
I/O Grouping — Use this option to plot data I/O channels in their own separate axes (None), or group them together (All).
Characteristics > Mean Value — Use this option to view the mean value of the data.
Data Experiment — For multiexperiment data only. Use this option to toggle between data from different experiments. This option replaces the separate tabs that displayed multiexperiment data in the plot.
To access the context menu, rightclick the plot.
To prevent jumps in estimated parameters, the normalized gradient
algorithm now includes a bias term in the scaling factor of the adaptation
gain. For details about the algorithm, see Recursive Algorithms for Online Parameter Estimation. The default
value of the bias is eps
. Increase the bias when
you see jumps in the estimated parameters.
To change the bias in Simulink^{®}, in the Block Parameters dialog box of Recursive Polynomial Model Estimator and Recursive Least Squares Estimator blocks, in the Algorithm and Block options tab, use the Normalization Bias field.
To change the bias at the command line, use the NormalizationBias
property
of the online
estimation commands.
The dimensions of Recursive Polynomial Model Estimator block output and initial estimate specification have changed.
The Parameters outport of the block now outputs the estimated parameters A, B, C, D, and F as row vectors. For MISO polynomial models, B is a matrix where the ith row parameters correspond to the ith input. Previously, the estimated parameters were output as column vectors.
In the block dialog box Model Parameters tab,
if Initial Estimate is set to Internal
,
specify the initial parameter guess (Initial A(q), Initial
B(q), Initial C(q), Initial
D(q), or Initial F(q)) as a row vector
only. Previously, initial guesses could also be specified as column
vectors. For MISO polynomial models, specify Initial B(q) as
a matrix where ith row parameters correspond to
the ith input.
If your Simulink model requires the estimated parameters output from the block outport to be a column vector, transpose the block output as follows:
Split the Parameters outport bus signal into its individual parameter components (A, B, C, D, and/or F; depending on the model choice) by using the Bus Selector block from Simulink Signal Routing library.
Use the Permute Dimensions block from Simulink Math Operations library to convert each signal into a column vector.
Combine the parameters back into a bus signal, if necessary, using the Bus Creator block from Simulink Signal Routing library.
If you specified the initial guess for any of the parameter values (Initial A(q), Initial B(q), Initial C(q), Initial D(q), or Initial F(q)) as column vectors, an error occurs during simulation. Specify them as row vectors. For MISO polynomial models, transpose the Initial B(q) matrix so that the ith row parameters correspond to the ith input.
The Model Type Converter block inport now only accepts bus signal elements specified as row vectors. Previously, you specified the bus elements as column vectors. For MISO data, specify B polynomial coefficients as a matrix where the ith row parameters correspond to the ith input.
If you specified the inport bus signal elements as column vectors, an error occurs during simulation. Specify them as row vectors. For MISO polynomial models, transpose the B matrix so that the ith row parameters correspond to the ith input.
Functionality  Result  Use This Instead  Compatibility Considerations 

rarx  Warns 
 See Online Parameter Estimation Commands: Implement and deploy recursive estimators with MATLAB Compiler or MATLAB Coder for more information. 
rarmax  Warns 
 See Online Parameter Estimation Commands: Implement and deploy recursive estimators with MATLAB Compiler or MATLAB Coder for more information. 
roe  Warns 
 See Online Parameter Estimation Commands: Implement and deploy recursive estimators with MATLAB Compiler or MATLAB Coder for more information. 
rbj  Warns 
 See Online Parameter Estimation Commands: Implement and deploy recursive estimators with MATLAB Compiler or MATLAB Coder for more information. 
y = sim(model,u,'Noise') for idnlarx , idnlhw ,
or idnlgrey models  Still works  opt = simOptions('AddNoise',true); y
= sim(model,y,opt);  See Unified sim command for simulating linear
and nonlinear identified models for more information. 
y = sim(model,u,'InitialState',init) for idnlarx , idnlhw ,
or idnlgrey models  Still works  opt = simOptions('InitialCondition',init); y = sim(model,y,opt);  See Unified sim command for simulating linear
and nonlinear identified models for more information. 
[y,y_sd,XFINAL] = sim(model,u) for idnlgrey models  Still works  [y,y_sd,x] = sim(model,u); XFINAL
= x(end,:)';  See Unified sim command for simulating linear
and nonlinear identified models for more information. 
Simulink model requiring output from Parameters outport of Recursive Polynomial Model Estimator block to be a column vector.  Error  Transpose the block output.  See Change in output and initial estimate specification of Recursive Polynomial Model Estimator block for more information. 
Initial parameter guess specified as column vector in Recursive Polynomial Model Estimator block.  Error  Specify as row vector. For MISO polynomial models, transpose the original Initial B(q) matrix.  See Change in output and initial estimate specification of Recursive Polynomial Model Estimator block for more information. 
Inport bus signal elements specified as column vectors in Model Type Converter block.  Error  Specify the bus elements as row vectors. For MISO polynomial models, transpose the original B matrix.  See, Change in input specification of Model Type Converter block for more information. 
nlgreyest
command for nonlinear greybox model estimationYou can use the nlgreyest
estimator
to estimate nonlinear greybox models. Use the nlgreyestOptions
option
set to configure the model estimation objective and search method
used by the estimator. For more information, see the corresponding
reference pages.
You can use option sets for the nonlinear ARX, HammersteinWiener
and nonlinear greybox model estimators to configure the model estimation
objective and search method. Instead of using namevalue pair input
arguments in nlarx
and nlhw
,
or the Algorithm
property of the model, use the
following commands:
nlarxOptions
—
Option set for nlarx
nlhwOptions
—
Option set for nlhw
nlgreyestOptions
—
Option set for nlgreyest
To learn more about the estimation options, see the corresponding reference pages.
The option sets replace the Algorithm
property
of nonlinear ARX (idnlarx
),
HammersteinWiener (idnlhw
),
and nonlinear greybox (idnlgrey
)
models.
The following table shows the mapping of the fields of Algorithm
to
those of the estimation options set.
Algorithm Property Field  Option Set Field 

LimitError  Advanced.ErrorThreshold 
Criterion/Weighting  OutputWeight

MaxIter  SearchOption.MaxIter 
Tolerance  SearchOption.Tolerance 
MaxSize  Advanced.MaxSize 
Advanced.Search 

For nonlinear ARX models, the Focus
property
has been replaced by the Focus
option in the nlarxOptions
option
set. See the reference page for more information.
A new property of nonlinear models, Report
,
provides information on the estimation. This readonly property replaces
the EstimationInfo
property and provides additional
information regarding:
Estimated parameters. For nonlinear greybox models, it also contains the values of initial states, and parameter and initial state covariance matrices.
The option set used for estimation.
Information on data used for estimation, such as percentage fit to estimation data and the mean square error.
The Report
fields are mostly uniform for
the identified nonlinear models. However, certain fields of Report
are
model dependent.
To learn more about the estimation report, see Estimation Report, and the model and estimator reference pages.
The Report
property replaces the EstimationInfo
property
of nonlinear ARX, HammersteinWiener, and nonlinear greybox models.
The following table shows the mapping of the fields of EstimationInfo
to
those of Report
.
EstimationInfo Field  Report Field 

LossFcn  Fit.LossFcn 
FPE  Fit.FPE 
DataName  DataUsed.Name 
DataLength  DataUsed.Length 
DataTs  DataUsed.Ts 
DataDomain  DataUsed.Type 
DataInterSample  DataUsed.InterSample 
WhyStop  Termination.WhyStop 
UpdateNorm  Termination.UpdateNorm 
LastImprovement  Termination.LastImprovement 
Iterations  Termination.Iterations 
InitialState  No replacement 
Warning  No replacement 
For nonlinear greybox models, the SimulationOptions
algorithm
property is now a property of the idnlgrey
model
itself. See the model reference page for more information.
findopOptions
command to create option set for operating point computation of nonlinear ARX or HammersteinWiener
modelsYou can use findopOptions
to
create an option set for computing the operating point of a nonlinear
ARX (idnlarx
)
or HammersteinWiener (idnlhw
)
model. Use the option set with idnlarx/findop
and idnlhw/findop
to
specify the optimization search options.
findstates
command for nonlinear modelsThe findstates
methods of nonlinear ARX,
HammersteinWiener, and nonlinear greybox models have been replaced
with a single findstates
command
which provides a more unified syntax. You can also use findstatesOptions
to
create an option set for estimating initial states of the nonlinear
models.
Functionality  What Happens When You Use This Functionality?  Use This Instead  Compatibility Considerations 

Algorithm property  Still works  nlarxOptions nlhwOptions  See Estimation options for nonlinear ARX, HammersteinWiener, and nonlinear greybox model estimators 
Focus property of idnlarx models  Still works  Focus option in the nlarxOptions option
set  See Estimation options for nonlinear ARX, HammersteinWiener, and nonlinear greybox model estimators 
EstimationInfo property  Still works  Report property  See Reorganization of nonlinear model estimation reports 
The Recursive Polynomial Model Estimator block has been enhanced to estimate the coefficients of linear timeinvariant and linear timevarying AR, ARMA, OutputError (OE) or BoxJenkins (BJ) models. The parameters are estimated as new data becomes available during the operation of the system. For more information, see Online Estimation.
You can also estimate a statespace model online from these
models by using the Recursive Polynomial Model Estimator and Model
Type Converter blocks together. Connect the outport
of the Recursive Polynomial Model Estimator block to
the inport of the Model Type Converter block to obtain
online values of the statespace matrices. The conversion ignores
the noise component of the models. In other words, the statespace
matrices only capture the y[k]/u[k]
relationship,
which is B(q)/F(q)
for OE and BJ models.
Use the Kalman Filter block to estimate the states of linear timeinvariant and linear timevarying systems online. The states are estimated as new data becomes available during the operation of the system. The system can be continuoustime or discretetime. You can generate code for this block using code generation products such as Simulink Coder.
You can access this block from the Estimators sublibrary of System Identification Toolbox library. For an example of using this block, see State Estimation Using TimeVarying Kalman Filter.
The first element of the initial guesses for the A(q)
and C(q)
polynomials
in the Recursive
Polynomial Model Estimator block must be specified
as 1. When the Initial Estimate option is Internal
,
you specify these values in the Initial A(q) and Initial
C(q) parameters in the Block Parameters dialog box. When
the Initial Estimate option is External
,
you specify these values using the InitialParameters inport
of the block.
In previous releases, the software autoscaled these values to 1.
If you specified the Initial Estimate parameter
as Internal
, an error occurs during simulation.
If you specified this parameter as External
,
a warning occurs. Before you simulate the model, scale the initial
guesses for the A(q)
and C(q)
polynomials
by dividing both these vectors by their first elements.
ident
command renamed to systemIdentification
The ident
command to open the System Identification
app has been renamed to systemIdentification
.
Functionality  What Happens When You Use This Functionality?  Use This Instead  Compatibility Considerations 

AR Estimator , ARMAX Estimator , ARX
Estimator , BJ Estimator , and OE
Estimator blocks  Still works  Recursive Polynomial Model Estimator  Consider replacing these blocks with the Recursive Polynomial Model Estimator block to perform recursive estimation. 
PEM Estimator block  Still works  No replacement  Not applicable 
Use the Recursive Least Squares Estimator and Recursive Polynomial Model Estimator blocks to perform online model parameter estimation in Simulink. Online parameter estimation, also known as online estimation or online tuning, refers to estimating model parameters as new data becomes available during the operation of the model. You can generate code for these blocks using code generation products such as Simulink Coder. For example, you can estimate the coefficients of a timevarying plant from measured inputoutput data and feed them to an adaptive controller. After validating the online estimation in simulation, you can generate code for your Simulink model and deploy the same to an embedded target.
These blocks are in the Estimators library.
For examples of how to use these blocks, see Preprocess Online Estimation Data and Validate Online Estimation Results.
The following blocks will be removed in a future release: AR Estimator, ARMAX Estimator, ARX Estimator, BJ Estimator, OE Estimator, and PEM Estimator.
As a part of the control design workflow, you can interactively identify a plant using measured data in the PID Tuner app in Control System Toolbox™. For example, to design a PID controller for a manufacturing process, you can start with response data from a bump test on your system. You can import this data instead of a plant model in the tuner. You can then interactively identify a linear plant model whose response fits the response data.
The PID Tuner automatically tunes a PID controller for the identified model. You can then interactively adjust the PID controller gains, and save the identified plant and tuned controller. For more information, see System Identification for PID Control.
To access the PID Tuner, enter pidtool
at
the MATLAB command line. For an example, see Interactively
Estimate Plant Parameters from Response Data.
You can obtain a linear representation of a Simulink model and tune the gains of a PID Controller block for the plant in the PID Tuner app. The identificationbased approach serves as an alternative to the linearizationbased approach and is useful where linearization fails to yield a good plant model. This functionality requires Simulink Control Design™ software.
The identification works by simulating the Simulink model and then using the simulated inputoutput data to obtain a plant model. You identify the plant using interactive graphical tools in the PID Tuner app. Next, you use the identified model to tune your PID Controller block. For example, suppose you want to tune the PID Controller block in a model that contains a Triggered Subsystem block. The analytical blockbyblock linearization algorithm does not support eventbased subsystems, and therefore the model linearizes to zero. Now, you can simulate the Simulink model for a chosen input and use the simulated data to identify a plant model. The PID Tuner automatically tunes the PID controller for the identified model. You can then interactively adjust the performance of the tuned control system, and save the identified plant and tuned controller. For more information, see System Identification for PID Control.
To access the PID Tuner, in the PID Controller block dialog box, click Tune. For an example, see "Design a PID Controller Using Simulated I/O Data" in the Simulink Control Design documentation.
ssregest
, a regularizationbased statespace model estimator, for improved accuracy on short, noisy data setsYou can use ssregest
to
estimate statespace models. This estimator is known to perform better
than n4sid
for
short, noisy data sets. For some problems, the quality of fit using n4sid
is
sensitive to options, such as N4Horizon
, whose
values can be difficult to determine. In comparison, the quality of
fit with ssregest
is less sensitive to its options,
which makes ssregest
simpler to use.
ssregest
estimates a regularized ARX model
and converts the ARX model to a statespace model. The software then
uses balanced model reduction techniques to reduce the statespace
model to the specified order. You can specify estimation options for ssregest
using ssregestOptions
.
You can also select this estimator in the System Identification
Tool. In the State Space Models dialog box, expand Estimation
Options and select Regularized Reduction
from
the Estimation Method dropdown list.
plot
command for iddata
object enhancedMultiexperiment data or datasets with more than one input or output channels are plotted on a single plot
Input and output channels can be grouped together
You can customize the plot, such as group and ungroup channels, and explore data characteristics, such as peak and mean value, using the rightclick menu.
You can also customize the plot, such as specify axes labels,
using iddataPlotOptions
.
arxRegul
command You can now use arxRegulOptions
to
specify regularization options for arxRegul
.
Regularization options include the regularization kernel to use, such
as 'TC'
and 'SE'
, and search
method for estimating regularization constants.
You can also specify input delay and presence of a noise source
integrator as NameValue
pair arguments in arxRegul
.
Replace [lambda,R] = arxRegul(data,orders,kernel)
and [lambda,R]
= arxRegul(data,orders,kernel,max_size)
syntaxes with [lambda,R]
= arxRegul(data,orders,options)
syntax. Specify kernel
and max_size
in
the options set created using arxRegulOptions
.
You can now obtain regularized estimates of parameters for linear
and nonlinear models. Previously, you could specify this option for
correlation model estimation only, using impulseestOptions
.
Regularization reduces variance of estimated model parameters by trading variance for bias. Regularization is useful for:
Identifying overparameterized models, such as nonlinear ARX models
Imposing apriori knowledge of model parameters in structured models, such as greybox models
Incorporating knowledge of system behavior in ARX and FIR models
Using regularization adds a penalty proportional to the parameter dimension and values in the cost function that is minimized for estimation. Without regularization, the parameter estimates are obtained by minimizing a weighted quadratic norm of the prediction errors ε(t,θ):
$$\begin{array}{l}{V}_{N}\left(\theta \right)=\frac{1}{N}{\displaystyle \sum _{t=1}^{N}{\epsilon}^{2}(t,\theta )}\\ \end{array}$$
where t is the time variable, N is the number of data samples and ε(t,θ) is the predicted error computed as the difference between the observed output and the predicted output of the model.
A regularized estimation minimizes:
$${\widehat{V}}_{N}\left(\theta \right)=\frac{1}{N}{\displaystyle \sum _{t=1}^{N}{\epsilon}^{2}\left(t,\theta \right)+\text{}}\frac{1}{N}\lambda {\theta}^{T}R\theta $$,
where λ is a constant that trades off variance for bias in the estimated values of parameters θ. R is an associated weighting matrix.
For more information on regularization, see Regularized Estimates of Model Parameters.
You can specify the regularization constants Lambda
, R
,
and Nominal
at the command line or in the System
Identification Tool:
At the command line, use the Regularization
option
available in the estimation options set (tfestOptions
, ssestOptions
,...)
for linear models.
For nonlinear models, the option is available in the Algorithm
property
of idnlarx
, idnlhw
,
and idnlgrey
models.
For ARX models, you can generate Lambda
and R
values
automatically from a given regularization kernel using the arxRegul
command.
See the estimator reference pages and Regularized Identification of Dynamic Systems for examples.
In the System Identification Tool, click Regularization in the linear model estimation dialog box or click Estimation Options in the Nonlinear Models dialog box.
For an example, see Estimate Regularized ARX Model Using System Identification Tool.
ssarx
subspace identification method for robust estimation of statespace models using closedloop dataN4Weight
, which represents the weighting
scheme used for singularvalue decomposition by the N4SID algorithm,
now includes a ssarx
option. This option is an
ARX estimationbased algorithm to compute the weighting. Specifying
this option allows the N4SID algorithm to compute unbiased estimates
of the model parameters when using data that is collected in a closedloop
operation. For more information about the algorithm, see Jansson,
M., "Subspace identification and ARX modeling", 13th IFAC
Symposium on System Identification, Rotterdam, The Netherlands,
2003.
To specify this option:
At the command line, set the N4Weight
option
in n4sidOptions
or ssestOptions
to 'ssarx'
.
In the System Identification Tool, in the State Space
Models dialog box, expand Estimation Options and
select SSARX
from the N4Weight dropdown
list.
For an example of using the subspace algorithm for closedloop
data, see the n4sid
reference
page.
The State Space Models and Linear Model Refinement dialog boxes have been redesigned to improve statespace model estimation and initial model refinement workflows.
To open the State Space Models dialog box, select Estimate > State Space Models in the System Identification Tool.
To access the redesigned Linear Model Refinement dialog box, in the System Identification Tool, select Estimate > Refine Existing Models.
The initial model must be in the Model Board of the System Identification Tool or a variable in the MATLAB workspace. This model can be a statespace, polynomial, process, or transfer function model.
For more information, click Help in the dialog boxes.
getpar
and setpar
commands to obtain and set parameter attributes of identified linear modelsYou can now use getpar
with identified
linear models to obtain parameter values, free or fixed status, minimum/maximum
bounds, and labels. Identified linear models include process, inputoutput
polynomial, statespace, transfer function, and greybox models.
Similarly, use setpar
to set these
parameter attributes.
You can now estimate unstable models in the System Identification Tool. You can use this option to:
Estimate transfer function models using frequencydomain data.
Estimate statespace models using time or frequencydomain data.
Refine linear models using time and frequencydomain data.
This functionality is the same as setting the estimation option Focus
to 'prediction'
at
the command line.
The option allows the estimation process to use parameter values that might lead to unstable models. An unstable model is delivered only if it produces a better fit to the data than other stable models computed during the estimation process. Such an unstable model might be useful, if, for example, you plan to design a controller for the model.
To set this option in the Transfer Function dialog box, expand Estimation Options and select the Allow unstable models check box. In the State Space Models and Linear Model Refinement dialog boxes, this option is selected by default.
SamplingGrid
property for tracking dependence of array of sampled models on variable valuesFor arrays of identified linear (IDLTI) models that are derived
by sampling one or more independent variables, the new SamplingGrid
property
keeps track of the variable values associated with each model in the
array. This information is shown when displaying or plotting the model
array. The information is useful to trace results back to the independent
variables.
Set this property to a structure whose fields are named after the sampling variables and contain the sample values associated with each model. All sampling variables should be numeric and scalar valued, and all arrays of sample values should be commensurate with 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 sys
is an array containing three identified
models obtained at rpms 1000, 5000, and 10000, respectively.
impulseest
You can obtain regularized estimates of impulse response using
the regularization kernel (RegulKernel
) estimation
option. Regularization reduces variance of estimated model coefficients
and produces a smoother response by trading variance for bias. You
can also configure estimation options such as prefilter order and
data offsets. You use impulseestOptions
to
specify the estimation options and pass them as an input to impulseest
.
You can also specify filter orders and transport delays as inputs
to impulseest
.
Using a time vector as an input to impulseest
or
specifying the 'noncausal'
flag warns and will
be removed in a future version. Specify the order of the impulse response
model instead.
To compute the acausal part of the response up to
a negative lag L
, set the input delay input argument
to L
.
translatecov
command for translating model covariance across transformationsYou can use translatecov
to
translate model covariance across model transformations such as continuous
and discretetime conversions, concatenation and conversions to different
model types. Previously, model covariance was lost when you performed
such operations on a model directly. translatecov
lets
you perform these operations while also translating the covariance
data. For example, transform an estimated continuoustime model mc
to
discretetime:
md = c2d(mc,Ts); md2 = translatecov(@(x)c2d(x,Ts),mc)
The first operation produces a discretetime model, md
,
which does not contain parameter covariance data. The second operation
produces the model, md2
, which has the same structure
and parameter values as md
but contains parameter
covariance data.
ssform
command for quick configuration of statespace model structureYou can use ssform
to
configure model parameterization, feedthrough and disturbance dynamics.
This command lets you quickly configure these properties when estimating
statespace models in a structured way. You can use this command as
a simpler alternative to explicitly modifying the Structure
property
of the idss
model
for some commonly applied changes. For example, typing ssform(model,'Form','canonical','DisturbanceModel','estimate')
configures
the model structure such that:
Its A
, B
, and C
matrices
are in observability canonical form
The K
matrix entries are all treated
as free parameters
Feedthrough
specification for discretetime transfer function model estimationWhen estimating a discretetime transfer function model, you
can specify whether the model has feedthrough. Use the Feedthrough
namevalue
pair in tfest
or
click Feedthrough in the graphical interface.
For MIMO systems, you can specify feedthrough for individual channels
or a common value across all channels.
Important new features and changes in the System Identification Toolbox™ software for this release include:
New functions that perform continuoustime estimation for statespace and transfer function models.
Support for multioutput estimation for polynomial models (such as ARMAX, OE, and BJ) and process models.
A new, uniform design for linear, parametric models. You can specify whether a coefficient should be estimated and now impose minimum/maximum bounds on estimated coefficients in a standardized manner.
Consolidation of the functions dealing with linear timeinvariant systems in the Control System Toolbox software. This unification of code allows for a streamlined workflow in estimating models and analyzing them and improves numerical accuracy and consistency.
Many commands now have a more unified syntax, but, with few exceptions, old syntax continues to work in this release for backward compatibility. Incompatibilities introduced this release mainly involve configuration of estimation options, translation of parameter covariance, reordering of output arguments for some functions and the treatment of certain model properties.
Note: Instances where the changes will break existing code or yield different results have been marked as "Backward incompatibility". 
New features this release include:
ContinuousTime Transfer Function Identification for Time and FrequencyDomain Data
TimeSeries Modeling and Forecasting, Including Generating ARIMA Models
A new function, tfest
,
lets you estimate a linear transfer function based on a system's
response. tfest
can be used for time and frequencydomain
data.
The output of tfest
is an idtf
model,
which is a new identified linear model. An idtf
model
stores the identified numerator, denominator, and any transport delays
using its num
, den
, and ioDelay
properties,
respectively.
For information regarding estimating a continuoustime transfer function using timedomain data, see How to Estimate Transfer Function Models by Specifying Number of Poles.
For information regarding estimating a continuoustime transfer function using frequencydomain data, see How to Estimate Transfer Function Models with Transport Delay to Fit Given Frequency Response Data.
A new function, forecast
, lets you forecast
the response of an identified linear model for a specified future
time interval. You may also specify the future inputs for models that
are not timeseries models.
forecast
complements the functionality
of predict
, which evaluates fixedstep ahead
predictions on historic data.
Use forecastOptions
to create an option
set to specify forecasting options.
For more information, see forecast
and forecastOptions
.
A new property for idpoly
models, IntegrateNoise
,
designates if a model output contains an integrator in its noise source.
Use the IntegrateNoise
property to create, for
example, ARI, ARIMA, ARIX, and ARIMAX models.
The IntegrateNoise
property takes a logical
vector of length Ny
, where Ny
is
the number of outputs.
For more information, see Estimating ARIMA Models.
idpoly
models
can now represent multioutput polynomial models. Use idpoly
to
create a multioutput polynomial model. You can also use the various
estimator functions (ar
, arx
, bj
, oe
,
and armax
)
to estimate a multioutput idpoly
model.
A new function, polyest
, may also be used
to estimate a multioutput polynomial model of arbitrary structure.
For more information, see polyest
and polyestOptions
.
Compatibility Consideration:Backward incompatibility. See idarx Models No Longer Returned in MultiOutput Model Estimation.
idproc
models
can now represent multioutput process models. Use idproc
to
create a multioutput process model. You can also use the new process
model estimator function, procest
, to estimate
a multioutput idproc
model.
For more information, see procest
and procestOptions
.
Enhanced response plots for identified linear models allow you to interactively:
Choose the system characteristics that are displayed. To view a system characteristic, rightclick on the plot, select Characteristics, and then select the system characteristic of interest.
Modify plot properties, such as whether the grid is on or off, axes labels and units, advanced plot options, etc. To modify the plot properties, rightclick on the plot, and select Properties. The Property Editor dialog box opens. Modify the plot property of interest.
You can plot the confidence intervals associated with identified
linear models. You can now plot the confidence interval interactively,
by rightclicking on the plot and selecting Characteristics > Confidence Region. You can
also use the new function, showConfidence
,
to display the confidence region on a plot via the command line.
Identified linear models that you create using System Identification Toolbox software can now be used directly with Control System Toolbox analysis and compensator design commands. In previous releases, doing so required conversion to Control System Toolbox model types.
Identified linear models include idfrd
, idss
, idproc
, idtf
, idgrey
,
and idpoly
models.
Identified linear models can be used directly with:
Any Control System Toolbox or Robust Control Toolbox™ functions that operate on dynamic systems, including:
For a complete list of these functions, type:
methods('DynamicSystem')
Analysis and design tools such as ltiview
, sisotool
,
and pidtool
.
The LTI System block in Simulink models.
Algorithm sharing between the System Identification Toolbox and
the Control System Toolbox products increase the accuracy and consistency
of results for various operations. Operations affected include frequencyresponse
and polezero computation, model conversion, settlingtime deduction,
and model discretization (c2d
and d2c
).
The handling of parameter covariance for overparameterized systems has also improved. You can now fetch parameter covariance data in a factored form for overparameterized systems, where the raw covariance matrix is illdefined.
You can use the new estimating functions tfest
, ssest
, procest
, greyest
, polyest
,
and impulseest
to estimate various model types.
The new functions are based on the prediction error method, PEM.
Also, you can now configure model estimation objective functions and search schemes using dedicated option sets. To create and configure the option set for a model estimating function, use the corresponding option set function:
Model Estimating Function  Options Set Function  Estimated Linear Model Type 

ar  arOptions  idpoly (AR structure polynomial) 
armax  armaxOptions  idpoly (ARMAX structure polynomial) 
arx  arxOptions  idpoly (ARX structure polynomial) 
bj  bjOptions  idpoly (BoxJenkins polynomial) 
greyest  greyestOptions  idgrey 
iv4  iv4Options  idpoly 
n4sid  n4sidOptions  idss 
oe  oeOptions  idpoly (Outputerror polynomial) 
polyest  polyestOptions  idpoly 
procest  procestOptions  idproc 
ssest  ssestOptions  idss 
tfest  tfestOptions  idtf 
For more information regarding these functions, enter doc
function_name
at the MATLAB command prompt.
The option sets replace the Algorithm
model
property.
The Algorithm
property is no longer supported.
The fields of Algorithm
map to estimation options
as follows:
Algorithm Property Field  Options Set Field 

LimitError  Advanced.ErrorThreshold 
Advanced.Threshold.Zstability  Advanced.StabilityThreshold.z 
Advanced.Threshold.Sstability  Advanced.StabilityThreshold.s 
Advanced.Threshold.AutoInitThreshold  Advanced.AutoInitThreshold 
Criterion/Weighting  OutputWeight

FixedParameter  No replacement. Use the Structure property
of the identified linear model to designate its fixed parameters. 
MaxIter  SearchOption.MaxIter 
Tolerance  SearchOption.Tolerance 
MaxSize  Advanced.MaxSize 
Advanced.Search 

You can now use option sets to configure the various attributes of model simulation and prediction commands. The option sets configure, among other things, how the initial conditions and data offsets are handled. They replace the propertyvalue pairs used by the analysis commands as input arguments. To create and configure the option set for an analysis or validation function, use the corresponding option set creating function:
Analysis/Validation Function  Options Set Function 

predict  predictOptions 
compare  compareOptions 
sim  simOptions 
simsd  simsdOptions 
forecast  forecastOptions 
findstates  findstatesOptions 
pe  peOptions 
For more information regarding these functions, enter doc
function_name
at the MATLAB command prompt.
Specifying Initial Conditions and Noise
Data To specify the initial conditions and noise specifications
for sim
or simsd
, use the
corresponding option set with the InitialCondition
, AddNoise
,
and NoiseData
options set appropriately. In previous
releases, you could use name and value pair input arguments to specify
these options.
You can now specify minimum/maximum bounds for, and fix or free
for estimation, any parameter of an identified linear model. You use
the new model property, Structure
, to access a
parameter and configure it.
You can now create arrays of identified linear models to analyze
multiple models simultaneously. You can create an array using array
subassignment. For example, sys(:,:,k) = new sys;
.
You can also use the stack
function to
create an identified linear model array. For more information, see stack
.
You can also use the new function, rsample
,
to create an array of models that sample an identified linear model
within the uncertainty limits of its parameters. For more information
see rsample
.
You can use the new Report
property of identified
linear models for information regarding the estimation performed to
obtain the model.
For more information, see Reorganization of Estimation Reports.
Use the new function, noise2meas
, to convert
a timeseries model, which has no measured inputs, to an inputoutput
model for linear analysis. noise2meas
complements
the functionality of noisecnv
, which converts
an identified model with noise channels to a model with only measured
inputs.
For more information, see noise2meas
.
You can now specify subsystems as input/output models for all
identified linear models, except idgrey
models.
For example, sys(i,j) = sys0;
You can now group inputs and outputs for identified linear models
using the InputGroup
and OutputGroup
properties,
respectively.
For more information regarding specifying input groups, enter help
idlti.InputGroup
at the MATLAB command prompt.
For more information regarding specifying output groups, enter help
idlti.OutputGroup
at the MATLAB command prompt.
New commands for interacting with the parameters of identified linear models include:
getpvec
— Fetch the model
parameters.
setpvec
— Set the model
parameters.
getcov
— Fetch the parameter
covariance matrix.
setcov
— Set the parameter
covariance matrix.
nparams
— Fetch number
of model parameters.
For more information regarding these functions, enter doc
function_name
at the MATLAB command prompt.
The new rsample
function creates a set
of perturbed systems corresponding to an identified linear model.
Use this random sampling of an identified linear model for MonteCarlo
analysis.
For more information see rsample
.
The recommended usage and workflow has changed for some model parameters. Where possible, backward compatibility is maintained in this release. However, adoption of the recommended changes is strongly encouraged as obsoleted model properties and workflows may not be supported in the future.
The following table lists affected model properties:
Property  Model Types Affected  What Happens in R2012a  Use This Instead 

ParameterVector  idss , idpoly , idgrey ,
and idproc  Still available.  Use the new function getpvec to access
model parameters. The list of parameters obtained from 
PName  idss , idpoly , idgrey ,
and idproc  Still available.  Each identified linear model now has a Structure property,
which consists of the parameters relevant to the model. Each of the
parameters has an Info field, which may be used
to store information regarding the parameter. To store the parameter
name, use Info.Label . 
Algorithm  idss , idpoly , idgrey ,
and idproc  Still available.  See Estimating Functions and Estimation Option Sets. 
CovarianceMatrix  idss , idpoly , idgrey ,
and idproc  Still available.  Use the new functions, getcov and setcov ,
to interact with the covariance matrix of the model. Also, after
a model, 
All identified linear models.  Backward incompatibility. Parameter
covariance is no longer translated for the following operations with
identified linear models:
 N/A  
EstimationInfo  idss , idpoly , idgrey ,
and idproc  Still available.  Replaced by the new model property, Report .For more information, see Reorganization of Estimation Reports. 
InputName ,OutputName  All identified linear models.  Backward incompatibility. By
default, the input/output channel names are set to iddata object,
it will inherit the input/output channels names from the iddata object.  N/A 
TimeUnit  All identified models.  You can now specify the  N/A 
Ts  idss and idpoly  Backward incompatibility. For
discretetime models, default is Ts = 1 , which
indicates an unspecified sample time. In previous releases, the default
value of Ts was 1 .  N/A 
Noise Channel Treatment When Converting Identified Linear Model to Numeric LTI Model
Backward incompatibility. You can convert an identified linear model to a numeric LTI model for use in Control System Toolbox. When you do so, the model returned contains only the measured components of the original model. In previous releases, the noise channels of the original model were also returned as extra inputs of the resulting model.
For example, consider the following polynomial model:
sys = idpoly([1 1],[1 2 3],[1 2])
In previous releases, executing sys_tf = tf(sys)
returned
a transfer function model with two inputs. The first input corresponded
to the measured component, B/A
. The second input
corresponded to the noise component, C/A
. size(sys,2)
is 1
but size(sys_tf,2)
is 2
.
Thus, sys
had one input, while sys_tf
had
two inputs.
In this release, sys_tf = tf(sys)
returns
a SISO transfer function with one input. This input corresponds to
the measured component, B/A
.sys
and sys_tf
both
have the same number of inputs.
To obtain the noise input channels in addition to the measured
inputs, as in previous releases, use the string 'augmented'
as
an additional input.
sys_tf = tf(sys,'augmented');
The inputs of sys_tf
are grouped in the InputGroup
property.
The inputs from the measured dynamics belong to the Measured
input
group, and the noiserelated inputs belong to the Noise
input
group.
To obtain a model containing just the noise component of the
original model, use the string 'noise'
as an additional
input:
sys_tf = tf(sys,'noise');
Conversion to Identified Linear Model of Numeric LTI Models Ignores Input Groups
Backward incompatibility. In
previous releases, when you converted a numeric LTI model that had
an input group named 'noise'
into an identified
linear model, the corresponding inputs were converted to noise channels
in the resulting model. This behavior is no longer supported. You
can use the 'split'
input argument when you convert
a numeric LTI model to an identified model. Using the 'split'
input
argument results in the last Ny inputs being treated
as noise channels in the identified model. Here, Ny is
the number of outputs.
For example, in previous releases:
sys = rss(2,2,5); sys.InputGroup = struct('noise',4:5); sys_idss = idss(sys);
resulted in sys_idss
having the fourth and
fifth inputs of sys
being treated as noise channels.
In this release, use:
sys_idss = idss(sys,'split');
As sys
has two outputs and five inputs, its
last two input channels are converted to noise channels in sys_idss
. sys_idss
has
three measured input channels.
Input Channel Referencing for Measured Components
You can configure an estimated model to be free of the influence
of noise by setting the NoiseVariance
property
value to 0
. In previous releases, you achieved
this result by subreferencing the inputs of the model using the 'measured'
string,
as in sys(:,'measured')
. This type of subreferencing
is provided in this release for backward compatibility only and may
not be supported in the future.
Input Channel Referencing for Noise Components
You can now extract only the noise components of an identified linear model using the syntax:
sys_noise_only = sys(:,[]);
Here, the :
indexes all the outputs and []
specifies
that none of the measured inputs are extracted. sys_noise_only
has
zero measured inputs and is consequently a noise model.
In previous releases, you achieved this result by subreferencing
the inputs of the model using the 'noise'
string,
as in sys(:,'noise')
. This type of subreferencing
is provided in this release for backward compatibility only and may
not be supported in the future.
Model Precedence Rules
The precedence order among identified linear models is idfrd
> idss > idpoly > idtf > idproc
and idss
> idgrey
.
When you combine a numeric LTI model with an identified model,
the resulting model is a numeric LTI model. Interconnecting and combining
identified linear models using functions such as series
, parallel
,
and feedback
, and performing model addition results
in a numeric LTI model. Inputoutput concatenation and model stacking
of identified models returns an identified model object.
Simultaneous ModelType Conversion and Property Value Setting
Model conversion functions will not support setting model property values in the future.
Replace calls such as:
sys_idfrd = idfrd(sys,w,'InputName','u1','InputDelay',3);
With:
sys_idfrd = idfrd(sys,w); set(sys_idfrd,'InputName','u1','InputDelay',3);
Replace inpd2nk with absorbDelay
The inpd2nk
is now obsolete. Use absorbDelay
instead
to absorb all time delays of a dynamic system model into the system
dynamics or the frequency response data. In this release, calling inpd2nk
results
in the toolbox making an internal call to absorbDelay
.
For more information, see absorbDelay
.
You can now estimate transfer functions using the System Identification Tool GUI.
To open the Transfer Function dialog box:
Import a data set into the System Identification Tool GUI.
In the Estimate list, select Transfer Function Models.
For more information regarding transfer function estimation, open the Transfer Function dialog box, and click Help.
You can now estimate multioutput process models using the System Identification Tool GUI.
To open the Process Models dialog box:
Import a data set into the System Identification Tool GUI.
In the Estimate list, select Process Models.
For more information regarding process model estimation, open the Process Model dialog box and click Help.
You can now use the System Identification Tool GUI for these operations:
Estimate continuoustime statespace models.
Specify the parameterization form, such as canonical or modal.
Specify feedthrough, which determines whether the D matrix of the statespace model is treated as free estimation parameter or fixed to zero.
Specify input delay.
To open the Polynomial and State Space Models dialog box:
Import a data set into the System Identification Tool GUI.
In the Estimate list, select State Space Models.
For more information regarding statespace estimation, open the Polynomial and State Space Models dialog box and click Help.
You can now specify noise integration and input delays when estimating polynomial models using the System Identification Tool GUI.
You can also estimate multioutput polynomial models by specifying the appropriate model order.
To open the Polynomial and State Space Models dialog box:
Import a data set into the System Identification Tool GUI.
In the Estimate list, select Polynomial Models.
For more information regarding polynomial estimation, open the Polynomial and State Space Models dialog box and click Help.
Compatibility Consideration: You no longer select Linear parameteric models to open the Polynomial and State Space Models dialog box.
Changes introduced in this version:
A new property of identified linear models, Report
,
provides information regarding the performed estimation. This property
replaces the EstimationInfo
property and provides
additional information regarding:
All estimated quantities — Parameter values and covariance, initiate state values for statespace models and values of input levels for process models.
The option set used for estimation.
Additional fit criteria — Percentage fit to estimation data and the mean square error.
The Report
field is mostly uniform for the
various identified linear models. However, certain fields of Report
are
model dependent.
To access the Report
property of an identified
linear model, sys
, use sys.Report
.
Report
replaces the EstimationInfo
property.
The fields of EstimationInfo
map to those of Report
as:
EstimationInfo Field  Report Field 

LossFcn  Fit.LossFcn 
FPE  Fit.FPE 
DataName  DataUsed.Name 
DataLength  DataUsed.Length 
DataTs  DataUsed.Ts 
DataDomain  DataUsed.Type 
DataInterSample  DataUsed.InterSample 
WhyStop  Termination.WhyStop

UpdateNorm  Termination.UpdateNorm

LastImprovement  Termination.LastImprovement

Iterations  Termination.Iterations

InitialState  Either:

Warning  No replacement. 
Use the new function, polyest
, to estimate
a polynomial model containing an arbitrary subset of A, B, C, D, and
F polynomials.
For more information, see polyest
and polyestOptions
.
Also, the functions ar
, arx
, bj
, oe
,
and armax
now
support multioutput polynomial estimation.
You can now introduce integrators in the dynamics of the disturbances added to the output of the model.
For more information, see Generating ARIMA Models.
idarx
models are no longer returned when
you use estimating functions for multioutput ARX models. Support
for idarx
models may not be provided in the future.
Use idpoly
models to estimate and represent multioutput
ARX models instead.
Compatibility Consideration: Backward incompatibility. arx
, iv4
,
and ivx
now return idpoly
models
for multioutput estimation. In previous releases, they returned idarx
models.
To convert an existing idarx
model, sys_idarx
,
to an idpoly
model, use idpoly(sys_idarx)
.
Similarly, to convert an existing idpoly
model, sys_idpoly
,
to an idarx
model, use idarx(sys_idpoly)
.
Use the new idpoly
property, ioDelay
to
specify the transport delays for individual input/output pairs.
You can use ioDelay
as an alternative to
the nk
order when estimating polynomial models.
Using ioDelay
reduces the complexity of the model
by factoring out the leading zeros of the B
polynomials,
controlled by nk
.
For example:
load iddata1 z1 load iddata2 z2 data = [z1 z2(1:300)]; na = [2 3; 1 2]; nb = [1 2; 2 2]; nk = [2 1; 7 0]; sys1 = arx(data,[na nb nk]); sys2 = arx(data,[na nb zeros(2)],'ioDelay',nk);
In this case, sys1
and sys2
are
equivalent, but sys2.b
shows fewer terms in each B
polynomial
than sys1.b
.
For more information, see idpoly
.
You can now specify the variable used to display model equations
for idpoly
models. Use the new model property, Variable
.
For continuoustime models, specify either 's'
or 'p'
as
the variable. For discretetime models, use either 'z^1'
or 'q^1'
as
the lag variable.
For more information, see idpoly
.
For estimating multioutput ARX models, use the OutputWeight
estimation
option to specify the output weighting. You create the option set
for ARX model estimation using arxOptions
.
In previous releases, to do so you specified a NoiseVariance
namevalue
pair input for arx
.
arx
uses the following syntaxes for assigning
output weight:
Syntax  Output Weight Value 

arx(data,[na,bk,nk])  eye(Ny) , where Ny is
the number of outputs 
arx(data,[na nb nk],opt) , where opt is
an option set created using arxOptions  opt.OutputWeight If 
arx(data,init_model) , where init_model is
an estimation initialization model  init_model.NoiseVariance 
arx(data,init_model,opt)  opt.OutputWeight If 
The new Structure
property of idpoly
models
stores the adjustable parameters, which include:
The active polynomials
For example, consider the ARX model:
A = [1 2 1]; B = [0 3 4]; sys = idpoly(A,B);
sys.Structure
lists the polynomials A and
B as parameters. You can specify nominal values and constraints for
these parameters.
sys.Structure
does not list the C, D, and
F polynomials.
The transport delays and integrate noise flag
You can set these delays and the flag for models of any polynomial configuration.
You interact with the Structure
property
to specify constraints (such as maximum/minimum bounds) for the various
parameters. To change only the values of the polynomials or the transport
delays, use the relevant idpoly
model property,
viz a
, b
, c
, d
, f
, ioDelay
,
and IntegrateNoise
.
For more information, see idpoly
.
The recommended usage and workflow has changed for some model parameters and functionality. Where possible, backward compatibility is maintained in this release. However, adoption of the recommended changes is strongly encouraged as obsoleted model properties and workflow may not be supported in the future.
The following table lists affected functionality:
Functionality  What Happens in R2012a  Use This Instead 

Model properties that store the polynomial order — na , nb , nc , nd , nf ,
and nk  You may still modify the value of these properties as long
as their sizes are compatibility with the input/output sizes. The
estimation commands for polynomial models will continue to support
the specification of "inmodel" delays using  Use idpoly to create a new model of desired
orders.Use 
Model properties that store standard deviation information
— da , db , dc , dd ,
and df  You may still access these model properties using dot notation.
For example, sys.da .  Use the functions getpvec and polydata to
access parameters and their standard deviations. 
Treatment of the leading zeros of the B polynomials  If you have a discretetime idpoly model
that has nk leading zeros, then nk1 of
them are treated as delays. When you convert such a model into another
linear model, these delays are set to the appropriate delay related
property.For example, sys = idpoly([1 2],... The  N/A 
Model property — InitialState  Still works.  Use the option, InitialCondition , when creating
the relevant option set for estimation, prediction, simulation, and
comparison. 
Storage of the B and F polynomials  For multiinput models, the b and f properties
are no longer saved as a matrix of doubles. These properties will
now be saved using cell arrays. To continue storing these properties
as a matrix of doubles, use  N/A 
Treatment of the trailing zeros of the B and F polynomials  Trailing zeros in the B and F polynomials
of a discretetime idpoly model are not discarded. For example, in previous releases: sys = idpoly([1 2],... [2 4] as
the B polynomial for sys . Now,
the same code gives  N/A 
The new function, ssest
, can be used to
estimate a discretetime or continuoustime identified statespace
model. You can use timedomain or frequencydomain data with ssest
and
perform both structured and unstructured model estimation. You can
also choose a canonical form of the identified statespace model.
To configure the handling of initial conditions and other initialization
choices, data offsets and search algorithm, use the associated option
command, ssestOptions
.
For more information, see ssest
and ssestOptions
.
For a structured statespace model, which is an idss model with
finite parameters, you can use either pem
or ssest
to
update the values of those parameters for measured inputoutput data.
The subspace estimator function, n4sid
,
now supports new parameterization options, such as modal and companion
canonical forms and the presence of feedthrough.
To configure the handling of initial conditions and other initialization
choices and data offsets, use the associated option command, n4sidOptions
.
For more information, see n4sid
and n4sidOptions
.
The new Structure
property of idss
models
stores the adjustable parameters, which include the a
, b
, c
, d
and k
matrices.
You interact with the Structure
property
to specify constraints (such as maximum/minimum bounds) for the various
parameters. To only change the values of the matrices, use the relevant idss
model
property, viz a
, b
, c
, d
,
and k
.
For more information, see idss
.
The recommended usage and workflow has changed for some model parameters. Where possible, backward compatibility is maintained in this release. However, adoption of the recommended changes is strongly encouraged as obsoleted model properties and workflow may not be supported in the future.
The following table lists affected model properties:
Model Property  What Happens in R2012a  Use This Instead  

X0 , InitialState  Still available.  Use the InitialState option for estimation
and the InitialCondition option for prediction,
simulation, and comparison. For example, replace: sys = n4sid(data,2,... opt = n4sidOptions(...  
As , Bs , Cs , Ds , Ks ,
and X0s  Still available.  Use the Structure property to specify constraints
(such as maximum/minimum bounds) for A, B, C, D, and K. Use the InitialState estimation
option to specify constraints on the initial state vector. For example, instead of: sys = idss(A,B,C,D,K); sys.X0s = [nan;1] syse = pem(data, sys); opt = ssestOptions; X0 = idpar([nan; 1]); X0.Free(2) = false; opt.InitialState = X0; sys = idss(A,B,C,D,K); syse = ssest(data, sys, opt);  
da , db , dc , dd ,
and dk  Still available.  Use the new function idssdata to obtain
the statespace matrix standard deviations.  
nk  Still available but may cause a backward
incompatibility. If you previously specified both load iddata1 z1; sys = pem(z1,4,... sys.nk is 3,
whereas sys.nk was 5 in earlier releases.  For estimation, use the InputDelay and Feedthrough estimation
properties instead. When creating an idss model,
specify the InputDelay and Structure.d properties.
 
SSParameterization  Still available. However, when you use 
 
DisturbanceModel  Still available.  For estimation, specify DisturbanceModel as
an option for estimation.For changing the model structure,
for its disturbance component, use DisturbanceModel = 'none' corresponds
to setting model.Structure.k.Value to zeros and model.Structure.k.Free to false .  
CanonicalIndices  Still available if the model is in canonical form.  Use canon and ss2ss to
change the statespace form. 
The new function, procest
, lets you estimate
process models using timedomain or frequencydomain data. You can
also specify the handling of input offsets and disturbances using
an option set for this function using procestOptions
.
For more information, see procest
and procestOptions
.
You can now create and estimate multioutput process models.
For more information, see MultiOutput Process Models
Use the new property NoiseTF
of idproc
models
to specify the value of the noise transfer function in numerical form. NoiseTF
is
a structure with the fields num
(numerator) and den
(denominator)
representing the noisetransfer function. This property replaces the DisturbanceModel
property.
The InputDelay
property of idproc
model
represents input delays and is now independent of the Td
property.
The Td
property represents the transport
delay, which is thus similar to the ioDelay
property
of idpoly
and idtf
models.
For more information, see idproc
.
The Structure
property of idproc
models
houses active parameters. These parameters are a subset of Kp
, Tp1
, Tp2
, Tp3
, Tw
, Zeta
, Td
,
and Tz
, depending on the Type
option
used to create the model. Structure
also contains
the Integration
property whose value determines
if the model structure contains an integrator.
You use the Structure
property to specify
constraints (such as maximum/minimum bounds) for the various active
parameters.
Structure
is an Ny
byNu
array,
where Ny
is the number of outputs and Nu
is
the number of inputs. The array specifies a transfer function for
each input/output pair.
For example:
sys = idproc({'p2u' 'p0' 'p3zi'; 'p1' 'p2d' 'p2uz'});
In this case, sys.Structure
is a 2by3 array. sys.Structure(1,1).Zeta
is
a parameter, while sys.Structure(1,2)
does not
have a Zeta
field, as this parameter is inactive
for the (1,2) outputinput pair.
To change the list of active parameters, you must create a new
model. However, you may change the Integration
property
at any time.
The minimum value permitted for the time constants of an idproc
model, Tp1
, Tp2
, Tp3
, Tw
,
and Zeta
is now 0
. In previous
releases, you could not specify for these constraints a value smaller
than 0.001
. For wellconditioned estimations, it
is still recommended that you specify reasonable upper and lower bounds
around the timeconstant values.
The recommended usage and workflow has changed for some model parameters. Where possible, backward compatibility is maintained in this release. However, adoption of the recommended changes is strongly encouraged as obsoleted model properties and workflow may not be supported in the future.
The following table lists affected model properties:
Model Property  What Happens in R2012a  Use This Instead 

InputLevel  Still available.  Use the InputOffset option for estimation
using procestOptions . For advanced control,
you can specify the InputOffset option as 'estimate' or
a param.Continuous object. 
InitialState  Still available.  Use the InitialCondition option for estimation,
prediction, simulation and comparison. For example, replace: sys = pem(data,'p1d',... opt = procestOptions(... 
DisturbanceModel  Still available.  The DisturbanceModel property of idproc models
in previous releases represented both the estimation flag and as the
actual value of the noise transfer function. The DisturbanceModel property
has now been replaced by:
For example, replace: load iddata1 z1; sys = pem(z1,'p1d',... 'DisturbanceModel','arma1'); NoiseTF = sys.DisturbaceModel{2}; with: load iddata1 z1; opt = procestOptions(... 'DisturbanceModel','arma1'); sys = pem(z1,'p1d',opt); NoiseTF = sys.NoiseTF; For
more information, see 
X0  Still available.  There is no replacement for this model property as idproc is
not a statespace model. Continuing to use X0 may
produce bad results. 
Kp , Tp1 , Tp2 , Tp3 , Tw , Zeta , Td ,
and Tz  Backward incompatibility. These properties are now saved as double matrices. In previous releases, they were stored as structures. Assigning the value of these parameters to structures will continue to work: model = idproc('p1','Tp1',1,'Kp',2) model.Tp1.value = 5; model = idproc('p1','Tp1',1,'Kp',2) Tp1 = model.Tp1; Tp1.status % throws error model = idproc('p1','Tp1',1,'Kp',2) model.Tp1.status % returns {‘estimate'}  Use the Structure property to specify parameter
constraints.

Call Replacements
Replace a Call Like...  With... 

model.Tp1.status = {‘estimate'}  model.Structure.Tp1.Free = true; 
model.Tp1.status = {‘zero'}  model.Structure.Tp1.Free = false; model.Structure.Tp1.Value = 0; 
model.Tp1.status ={ ‘fixed'}  model.Structure.Tp1.Free = false; 
model.Tp1.min = value  model.Structure.Tp1.Minimum = value 
model.Tp1.max = value  model.Structure.Tp1.Maximum = value 
model.Tp1.value = value  model.Structure.Tp1.Value = value 
For multiinput models: model.Tp1.status{2} = ‘estimate'  model.Structure(1,2).Tp1.Free = true; 
For multiinput models: model.Tp1.value(2)= value  model.Structure(1,2).Tp1.Value = value 
The new function greyest
lets you estimate
the parameters of a linear greybox model. You can specify an option
set for the estimation by using the function, greyestOptions
.
For more information, see greyest
and greyestOptions
.
You can now parameterize a real system using complexconjugate
pairs of parameters in an idgrey
model.
When the parameters of such a system are estimated, they continue to be complex conjugates. Thus, symmetry is maintained across the real axis.
For more information, see the related example in the greyest
reference
page.
You can now specify an arbitrary number of parameters as independent input arguments to the ODE file. In previous releases, the parameters of the model had to be consolidated into a single vector that was then passed as the first input argument of the ODE file. Now, you can pass independent parameters as separate input arguments. The same holds true for the optional input arguments.
Old syntax:
ODEFUN(ParameterVector, Ts, OptionalArg)
New syntax:
ODEFUN(Par1, Par2, …, ParN, Ts, OptArg1, OptArg2, …)
If all the model parameters are scalars, you can still combine them into a single vector and pass them as a single input argument to the ODE file.
Also, specifying the value for the output arguments K
and X0
is
now optional. In earlier releases, you were required to set a value
for K
and X0
even if you did
not want to parameterize them. Now, you can omit them entirely from
the output argument list. For more information, see idgrey
.
The Structure
property of the idgrey
model
stores information on the ODE function and its parameters. Structure
contains
the following properties:
Property  Role 

FcnType  The sample time handling behavior of the linear ODE model. FcnType specifies
whether the ODE file returns statespace data that corresponds to
one of the following:
Compatibility Consideration: Use
instead of the 
Function  Name or function handle to the MATLAB function that parameterizes
the statespace structure. Compatibility
Consideration: Use instead of the 
Parameters  Vector of parameter objects, with an entry for each model parameter. Use the parameter object to specify initial values and minimum/maximum constraints. You can also indicate whether the parameter is a free or fixed estimation parameter. 
ExtraArgs  Option input arguments used by the ODE file to compute the
statespace data. Compatibility Consideration: Use
instead of the 
StateName  Model state names. 
StateUnit  Model state units. 
The recommended usage and workflow has changed for some model parameters. Where possible, backward compatibility is maintained in this release. However, adoption of the recommended changes is strongly encouraged as obsoleted model properties and workflow may not be supported in the future.
The following table lists affected model properties:
Model Property  What Happens in R2012a  Use This Instead 

MfileName  Still available.  Use the Structure.Function property to specify
the ODE function name or function handle instead. 
X0  Still available.  Use the InitialState option when you create
an estimation option set using greyestOptions . 
dA , dB , dC , dD , dK and dX0  Still available.  Use the functions getpvec and idssdata to
access parameters and their standard deviations. 
FileArgument  Still available.  Use the Structure.ExtraArgs property to
specify the additional ODE function arguments. 
CDmfile  Still available.  Use the Structure.FcnType property to specify
sample time handling behavior. 
InitialState  Still available.  Use the InitialState option for estimation
and the InitialCondition option for prediction,
simulation and comparison. 
DisturbanceModel  Still available.  Use the DisturbanceModel estimation option
in the option set created using greyestOptions . 
You can use the new InterSample
property
of idfrd
models to specify the behavior of the
input signals between samples for model transformations between discretetime
and continuoustime. This property is relevant only for discretetime idfrd
models.
For more information, see the InterSample
property
information in idfrd
.
Use the new property FrequencyUnit
of idfrd
models
to specify the units for frequencydomain data.
For a list of the supported units for FrequencyUnit
,
see idfrd
.
Compatibility Consideration: The FrequencyUnit
property
replaces the Unit
property.
Input Delay Treatment (Backward incompatibility.) When you convert
an identified model into an idfrd
model, its InputDelay
and ioDelay
properties
are translated into the corresponding properties of the idfrd
model.
In previous releases, the delays were absorbed into the ResponseData
property
as additional phase lag.
The OutputDelay
property of an identified
model is converted to the ioDelay
property of an idfrd
model.
Use the new property FrequencyUnit
of iddata
objects
to specify the units for frequencydomain data.
For a list of the supported units for FrequencyUnit
,
see iddata
.
Compatibility Consideration: The FrequencyUnit
property
replaces the Unit
property.
Plot the impulse or step response for iddata
objects
by estimating a discretetime transfer function model using impulseest
.
Use the resulting model as the input argument for impulse
or step
.
In the previous release, you could plot the step response without first estimating a discretetime transfer function model:
load iddata1 z1; step(z1);
z1
is an iddata
object.Now, you must use impulseest
to estimate
a discretetime transfer function. Then, plot the appropriate response
for the model. For example:
load iddata1 z1; sys = impulseest(z1); step(sys);
For more information, see impulseest
.
Compatibility Consideration: Backward incompatibility. To see the step or
impulse response for negative time values, use the noncausal
input
argument with impulseest
. In previous releases,
you could call impulse(data)
to do this.
Supported Units for TimeUnit Property You
can now specify the TimeUnit
property of an iddata
object
as only one of the supported units. Supported units include: 'nanoseconds'
,
'microseconds'
, 'milliseconds'
, 'seconds'
, 'minutes'
, 'hours'
, 'days'
, 'weeks'
, 'months'
,
and 'years'
.
Function  What Has Changed in R2012a 

predict 

compare 

step 

impulse 

bode 

pzmap  Compatibility Considerations:

nyquist 

c2d 

d2c 

ssdata 

tfdata  Compatibility Consideration: Backward incompatibility. The new syntax is: [num,den,Ts,sdnum,sdden] = tfdata(sys);

zpkdata  Compatibility Consideration: Backward incompatibility. The new syntax is: [z,p,k,z,Ts,covz,covp,covk] = zpkdata(sys) covz , covp and covk are
the covariance of the zeros, poles and gain of sys . 
canon  You can use the new function canon to
transform idss models into various canonical
forms. For more information, see 
findstates(idParametric)  You can now specify arbitrary prediction horizons for findstates . You
can use an option set to specify the option for findstatesOptions to create
the option set. For more information, see 
ffplot  ffplot is no longer supported. Use bodeplot instead.
Use bodeoptions to
set the frequency units and scale. 
setstruc  setstruct is no longer supported. Use
the Structure property of the idss model
to configure the model parameters. 
setpname  setpname is no longer supported. Use the Info.Label field
of the Structure property associated with the model
parameter. 
idprops  idprops is no longer supported. For information
regarding a model, enter doc model_name . 
idhelp  idhelp is no longer supported. For information
regarding a model or function, enter doc model_or_function_name . 
Functionality  What Happens When You Use This Functionality?  Use This Instead  Compatibility Considerations 

sys.LinearModel , for idnlhw model, sys  Returns an idpoly model.  N/A  The LinearModel property of idnlhw models
is no longer returned as a statespace model for multioutput models.
Instead, idnlhw returns an idpoly model. 
You can now use the following discretetime linear models for initializing a nonlinear blackbox estimation.
Discretetime Linear Model  Use for Initializing... 

Singleoutput polynomial model of ARX structure (idpoly )  Singleoutput nonlinear ARX model estimation 
Multioutput polynomial model of ARX structure (idarx )  Multioutput nonlinear ARX model estimation 
Singleoutput polynomial model of OutputError (OE) structure
(idpoly ) or statespace model with no
disturbance component (idss )
object with K = 0  Singleoutput HammersteinWiener model estimation 
Statespace model with no disturbance component (idss object with K = 0)  Multioutput HammersteinWiener model estimation 
During estimation, the software uses the linear model orders and delay as initial values of the nonlinear model orders and delay. For nonlinear ARX models, this initialization always provides a better fit to the estimation data than the linear ARX model.
You can use a linear model as an alternative approach to using model orders and delay for nonlinear estimation of the same system.
You can estimate or construct the linear model and then use
this model for constructing (see idnlarx
and idnlhw
)
or estimating (see nlarx
or nlhw
)
the nonlinear model. For more information, see Using
Linear Model for Nonlinear ARX Estimation, and Using
Linear Model for HammersteinWiener Estimation in the System
Identification Toolbox User's Guide.
You can now use cell arrays to specify the B and F polynomials
of multiinput polynomial models. The B and F polynomials
are represented by the b
and f
properties
of an idpoly
object
These properties are currently double matrices.
For multiinput polynomial models, these polynomials will be
represented by cell arrays only in a future version. If your code
performs operations on the b
and f
properties,
make one of the following changes in the code:
When you construct the model using the idpoly
command,
use cell arrays to specify the B and F polynomials.
Using cell arrays causes the b
and f
properties
to be represented by cell arrays.
After you construct or estimate the model, use the
new setPolyFormat
command
to:
Convert b
and f
properties
to cell arrays.
Make the model backward compatible to continue using
double matrices for b
and f
properties.
This operation ensures that operations on b
and f
properties
that use matrix syntax continue to work without errors in a future
version.
When you use cell arrays, you must also update your code to
use cell array syntax on b
and f
properties
instead of matrix syntax.
Note:
For singleinput polynomial models, the 
Function or Function Element Name  What Happens When you Use the Function or Element?  Use This Instead  Compatibility Considerations 

Double matrix support for b and f properties
of multiinput idpoly models.  Warns  Use cell array to specify the b and f properties
of multiinput polynomial models.  If your code performs operations on the b and f properties,
update the code to be compatible with a future release. See New Cell Array Support for B and F Polynomials of MultiInput
Polynomial Models. 
This version of the product includes new and expanded functionality for handling offsets and trends in signals. This data processing operation is necessary for estimating more accurate linear models because linear models cannot capture arbitrary differences between the input and output signal levels.
The previous version of the product let you remove mean values
or linear trends from steadystate signals using the GUI and the detrend
function.
For transient signals, you had to remove offsets and trends using
matrix manipulation.
The GUI functionality for removing means and linear trends from signals is unchanged. However, you can now do the following at the command line:
Save the values of means or linear trends removed
during detrending using a new detrend
output
argument. You can use this saved trend information to detrend other
data sets. You can also restore subtracted trends to the output simulated
by a linear model that was estimated from detrended data.
For example, this syntax computes and removes mean values from
the data, and saves these values to the output variable T
: [data_d,T]=detrend(data)
. T
is
an object with properties that store offset and slope information
for input and output signals.
Remove any offset or linear trend from the data using
a new detrend
input argument. This is useful
for removing arbitrary nonzero offsets from transient data or applying
previously saved trend information to any data set.
For example, this syntax removes an offset or trend specified
by T
: data_d = detrend(data,T)
.
Add an arbitrary offset or linear trend to data signals. This is useful when you want to simulate the response of a linear model about a nonzero equilibrium inputoutput level and this model was estimated from detrended data.
For example, this syntax adds trend information to a simulated
model output y_sim
, which is an iddata
object: y
= retrend(y_sim,T)
. T
specifies the offset
and slope information for inputs and outputs.
For more information, see Handling Offsets and Trends in Data.
The getreg
command can now return the numerical
values of regressors in nonlinear ARX models and provides an intermediate
output of nonlinear ARX models.
This advanced functionality converts input and output values
to regressors, and passes the regressor values to the evaluate
command
to compute the model response. This incremental step lets you gain
insight into the propagation of information through the nonlinear
ARX model.
For more information, see the getreg
reference
page. To learn more about the nonlinear ARX model structure, see Nonlinear BlackBox
Model Identification.
You can now simulate nonlinear ARX and HammersteinWiener models in Simulink using the nonlinear ARX and the HammersteinWiener model blocks in the System Identification Toolbox block library. This is useful in the following situations:
Representing dynamics of a physical component in a Simulink model using a databased nonlinear model
Replacing a complex Simulink subsystem with a simpler databased nonlinear model
Note: Nonlinear ARX Model and HammersteinWiener Model blocks read variables from the MATLAB (base) workspace or model workspace. When the MATLAB workspace and model workspace contain a variable with the same name and this variable is referenced by a Simulink block, the variable in the model workspace takes precedence. 
If you have installed RealTime Workshop^{®} software, you can generate code from models containing nonlinear ARX and the HammersteinWiener model blocks. However, you cannot generate code when:
You can access the new System Identification Toolbox blocks from the Simulink Library Browser. For more information about these blocks, see the IDNLARX Model (nonlinear ARX model) and the IDNLHW Model (HammersteinWiener model) block reference pages.
You can now use the linearize
command to
linearize nonlinear blackbox models, including nonlinear ARX and
HammersteinWiener models, at specified operating points. Linearization
produces a firstorder Taylor series approximation of the system about
an operating point. An operating point is defined
by the set of constant input and state values for the model.
If you do not know the operating point, you can use the findop
command
to compute it from specifications, such as steadystate requirements
or values of these quantities at a given time instant from the simulation
of the model.
For nonlinear ARX models, if all of the steadystate input and
output values are known, you can map these values to the model state
values using the data2state
command.
linearize
replaces lintan
and
removes the restriction for linearizing models containing custom regressors
or specific nonlinearity estimators, such as neuralnet
and treepartition
.
If you have installed Simulink Control Design software, you can linearize nonlinear ARX and HammersteinWiener models in Simulink after importing them into Simulink.
For more information, see:
Linear Approximation of Nonlinear BlackBox Models about computing operating points and linearizing models
Simulating Identified Model Output in Simulink about importing nonlinear blackbox models into Simulink
You can now specify a custom weighted trace criterion for minimization when estimating linear and nonlinear blackbox models for multipleoutput systems. This feature is useful for controlling the relative importance of output channels during the estimation process.
The Algorithm
property of linear and nonlinear
models now provides the Criterion
field for choosing
the minimization criterion. This new field can have the following
values:
det
— (Default) Specify
this option to minimize the determinant of the prediction error covariance.
This choice leads to maximum likelihood estimates of model parameters.
It implicitly uses the inverse of estimated noise variance as the
weighting function. This option was already available in previous
releases.
trace
— Specify this option
to define your own weighing function that controls the relative weights
of output signals during the estimation. This criterion minimizes
the weighted sum of least square prediction errors. You can specify
the relative weighting of prediction errors for each output using
the new Weighting
field of the Algorithm
property.
By default, Weighting
is an identity matrix, which
means that all outputs are weighed equally. Set Weighting
to
a positive semidefinite symmetric matrix.
For more information about Algorithm fields for nonlinear estimation,
see the idnlarx
and idnlhw
reference
pages.
Note:
If you are estimating a singleoutput model, 
The following are new options to handle initial states for nonlinear models:
For nonlinear ARX models (idnlarx
),
you can now specify a numerical vector for initial states when using sim
or predict
by
setting the Init
argument. For example:
predict(model,data,'init',[1;2;3;4])
where the last argument is the state vector.
For more information, see the sim
and predict
reference
pages.
For HammersteinWiener models (idnlhw
),
you can now choose to estimate the initial states when using predict
or nlhw
by
setting INIT='e'
.
For more information, see the predict
and nlhw
reference
pages.
If you want to specify your own initial states, see the corresponding model reference pages for a definition of the states for each model type.
If you do not know the states, you can use the findop
or
the findstates
command to compute the states.
For more information about using these commands, see the findop(idnlarx)
, findop(idnlhw)
, findstates(idnlarx)
,
and findstates(idnlhw)
reference
pages.
To help you interpret the states of a nonlinear ARX model, you
can use the getDelayInfo
command. For more information,
see the getDelayInfo
reference
page.
The findstates
command is available for
all linear and nonlinear models. Also
see the findstates(idnlgrey)
reference
page.
The following improvements are available for the Algorithm
property
of linear models to align linear and nonlinear models (where appropriate)
and improve robustness for default settings:
The SearchDirection
field (model.Algorithm.SearchDirection
)
has been renamed to SeachMethod
(model.Algorithm.SearchMethod
)
to be consistent with the nonlinear models, where the corresponding
field is SeachMethod
.
The new lsqnonlin
option for specifying SearchMethod
is
available. model.Algorithm.SearchMethod='lsqnonlin'
uses
the lsqnonlin
optimizer
from the Optimization Toolbox™ software. You must have Optimization Toolbox software
installed to use this option.
The improved gn
algorithm (subspace
GaussNewton method) is available for specifying SearchDirection
.
The updated gn
algorithm better handles the scale
of the parameter Jacobians and is also consistent with the algorithm
used for nonlinear model estimation.
The default values for the LimitError
field
of the Algorithm
property (modelname.Algorithm.LimitError
)
is changed to 0, which is consistent with the corresponding option
for estimating nonlinear models. In previous releases, LimitError
default
value was 1.6, which robustified the estimation process against data
outliers by associating a linear penalty for large errors, rather
than a quadratic penalty. Now, there is no robustification by default
(LimitError=0
). You can estimate the model with
the default setting and plot the prediction errors using pe(data.model)
.
If the resulting plot shows occasional large values, repeat the estimation
with model.Algorithm.LimitError
set to a value
between 1 and 2.
The model.Algorithm.Advanced
property
has a new tolerance field GnPinvConst
corresponding
to the gn
SearchMethod
. GnPinvConst
specifies
that singular values of the Jacobian that are smaller than GnPinvConst*max(size(J))*norm(J)*eps
are
discarded when computing the search direction. You can assign a positive
real value for this field. Default value is 1e4
.
The default value of model.Algorithm.Advanced.Zstability
property
has been changed from 1.01
to 1+sqrt(eps)
.
The new default reduces the possibility of a situation where the estimation
algorithm does not converge (predictor becomes unstable) while still
allowing enough flexibility to capture lightly damped modes.
New documentation for System Identification Toolbox blocks is provided. For more information, see Block Reference in the System Identification Toolbox reference documentation.
Function or Property Name  What Happens When You Use Function or Property?  Use This Instead  Compatibility Considerations 

lintan  Still runs  linearize(idnlhw) linearize(idnlarx)  See Linearizing Nonlinear BlackBox Models at UserSpecified Operating Points. 
 Still runs  model.Algorithm.  See Improved Algorithm Options for Linear Models. 
 Still runs  gn  See Improved Algorithm Options for Linear Models. 
 Still runs  GnPinvConst  See Improved Algorithm Options for Linear Models. 
You can now estimate nonlinearities for HammersteinWiener models using a singlevariable polynomial at either the input or the output. This nonlinearity estimator is available at the command line.
For more information, see the poly1d
reference
pages. For more information about estimating HammersteinWiener models,
see Identifying
HammersteinWiener Models in the System Identification Toolbox documentation.
You can now estimate nonlinear discretetime blackbox models for both singleoutput and multipleoutput timedomain data. The System Identification Toolbox product supports the following types of nonlinear blackbox models:
HammersteinWiener
Nonlinear ARX
To learn how to estimate nonlinear blackbox models using the System Identification Tool GUI or commands in the MATLAB Command Window, see the System Identification Toolbox documentation.
Note: You can estimate HammersteinWiener blackbox models from inputoutput data only. These models do not support timeseries data, where there is no input. 
New demos are available to help you explore nonlinear blackbox functions. For more information, see the collection of demos in the Tutorials on Nonlinear ARX and HammersteinWiener Model Identification category.
You can now estimate nonlinear discretetime and continuoustime models for arbitrary nonlinear ordinary differential equations using singleoutput and multipleoutput timedomain data, or timeseries data (no measured inputs). Models that you can specify as a set of nonlinear ordinary differential equations (ODEs) are called greybox models.
To learn how to estimate nonlinear greybox models using the commands in the MATLAB Command Window, see System Identification Toolbox documentation.
Specify the ODE in a function or a MEXfile. The template file
for writing the MEXfile, IDNLGREY_MODEL_TEMPLATE.c
,
is located in matlab/toolbox/ident/nlident
.
To estimate the equation parameters, first construct an idnlgrey
object
to specify the ODE file and the parameters you want to estimate. Use pem
to
estimate the ODE parameters. For more information, see the idnlgrey
and pem
reference
pages.
New demos are available to help you explore nonlinear greybox functions. For more information, see the collection of demos in the Tutorials on Nonlinear GreyBox Model Identification category.
The System Identification Toolbox product now provides a new Getting Started Guide. This guide introduces fundamental identification concepts and provides the following tutorials to help you get started quickly:
Tutorial – Identifying Linear Models Using the GUI — Tutorial for using the System Identification Tool graphical user interface (GUI) to estimate linear blackbox models for singleinput and singleoutput (SISO) data.
Tutorial – Identifying LowOrder Transfer Functions (Process Models) Using the GUI — Tutorial for using the System Identification Tool graphical user interface (GUI) to estimate loworder transfer functions to fit singleinput and singleoutput (SISO) data.
Tutorial – Identifying Linear Models Using the Command Line — Tutorial for estimating models using System Identification Toolbox objects and methods for multipleinput and singleoutput (MISO) data.
The System Identification Toolbox documentation has been revised and expanded.
The System Identification Toolbox product now supports the MATLAB Compiler product.
You can use MATLAB Compiler to take MATLAB files as input and generate redistributable, standalone applications that include System Identification Toolbox functionality, including the following:
Creating data and model objects
Preprocessing and manipulating data
Simulating models
Transforming models, including conversions between continuous and discrete time and model reduction
Plotting transient and frequency response
To use these features, write a function that uses System Identification Toolbox commands. Use the MATLAB Compiler software to create a standalone application from the MATLAB Compiler file. For more information, see the MATLAB Compiler documentation.
Standalone applications that include System Identification Toolbox functionality have the following limitations:
No access to the System Identification library in
the Simulink software (slident
)
No support for model estimation
An adaptive GaussNewton method is now available for computing
the direction of the line search for costfunction minimization. Use
this method when you observe convergence problems in the estimation
results, or as an alternative to the LevenbergMarquard (lm
)
method.
The gna
search method was suggested by Adrian
Wills, Brett Ninness, and Stuart Gibson in their paper "On GradientBased
Search for Multivariable System Estimates", presented at the IFAC
World Congress in Prague in 2005. gna
is an adaptive
version of gns
and uses a cutoff value for the
singular values of the criterion Hessian, which is adjusted adaptively
depending on the success of the line search.
Specify the gna
method by setting the SearchDirection
property
to 'gna'
. For example:
m = pem(data,model_structure,'se','gna')
The default initial value of gamma
in the gna
search
is 10^4
. You can set a different value using the InitGnaTol
property.
The default value for the MaxBisections
property,
which is the maximum number of bisections along the search direction
used by line search, is increased from 10
to 25
.
This increases the number of attempts to find a lower criterion value
along the search vector.
Function or Property Name  What Happens When You Use Function or Property?  Use This Instead  Compatibility Considerations 

idmodred  Still runs  balred  See balred Introduced for Model Reduction. 
Release  Features or Changes with Compatibility Considerations 

R2015b 

R2015a  
R2014b  Initial guesses for A(q) and C(q) polynomials in Recursive Polynomial Model Estimator block 
R2014a  
R2013b  None 
R2013a  None 
R2012b  Regularized estimates of impulse response, specification of
transport delays and estimation options using impulseest 
R2012a  
R2011b  None 
R2011a  None 
R2010b  None 
R2010a  Functions and Function Elements Being Removed 
R2009b  None 
R2009a  None 
R2008b  Functions and Properties Being Removed 
R2008a  Functions and Properties Being Removed 
R2007b  None 
R2007a  None 
R2006b  None 
R2006a  Functions and Properties Being Removed 
R14SP3  None 
R14SP2  None 
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.