Documentation Center 
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.
You 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.
Multiexperiment 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.
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,θ):
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:
,
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.
N4Weight, 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.
You 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.
For 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.
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.
You 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 mdbut contains parameter covariance data.
You 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
When 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.
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  SearchMethod and SearchOptions. These fields are available for only iterative estimation methods, such as tfestOptions. 
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 ParameterVector may differ from the list of parameters returned by getpvec. 
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, sys, is estimated, you may access the estimated covariance matrix using sys.Report.Parameters. 
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 ''. In previous releases, the default channel names were set to {'u1',...} and {'y1',...} for input and output channels, respectively. When an identified linear model is estimated using an 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 TimeUnit as only one of the supported units. Supported units include: 'nanoseconds', 'microseconds', 'milliseconds', 'seconds', 'minutes', 'hours', 'days', 'weeks', 'months', and 'years'.  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 Termination information is not provided for models estimated using a noniterative estimation function, such as arx or n4sid. 
UpdateNorm  Termination.UpdateNorm Termination information is not provided for models estimated using a noniterative estimation function, such as arx or n4sid. 
LastImprovement  Termination.LastImprovement Termination information is not provided for models estimated using a noniterative estimation function, such as arx or n4sid. 
Iterations  Termination.Iterations Termination information is not provided for models estimated using a noniterative estimation function, such as arx or n4sid. 
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 opt.OutputWeight = [], then eye(Ny). 
arx(data,init_model), where init_model is an estimation initialization model  init_model.NoiseVariance 
arx(data,init_model,opt)  opt.OutputWeight If opt.OutputWeight = [], then init_model.NoiseVariance. 
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 nk.  Use idpoly to create a new model of desired
orders. Use ioDelay and InputDelay to specify delays separate from the B polynomial. 
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 ioDelay property of sys2 is 2, and the numerator is {[0 4]}.  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 setPolyFormat  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],...resulted in [2 4] as the B polynomial for sys. Now, the same code gives [2 4 0 0 0] as the B polynomial for sys. Similar considerations apply to leading zeros of B, F polynomials of a continuoustime model.  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,...with: 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);Use: 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 nk and InputDelay, you could see different results in this release. For example,load iddata1 z1; sys = pem(z1,4,...In this release, 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. nk, InputDelay, and Feedthrough are related:

SSParameterization  Still available. However, when you use get to obtain the value of SSParameterization, the software may report a canonical form as the structured form. 

DisturbanceModel  Still available.  For estimation, specify DisturbanceModel as
an option for estimation. For changing the model structure, for its disturbance component, use Structure.k.Value and Structure.k.Free instead. For example, 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 NybyNu 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',...with: 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 procestOptions. 
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;In previous releases, you could obtain the value of a parameter as a structure and access its fields. Now, you will receive an error. model = idproc('p1','Tp1',1,'Kp',2) Tp1 = model.Tp1; Tp1.status % throws errorHowever, subreferencing for a field of the old parameter structure will continue to work: model = idproc('p1','Tp1',1,'Kp',2) model.Tp1.status % returns {‘estimate'}  Use the Structure property to specify parameter
constraints. Structure replaces the specification of process model parameter bounds. See Call Replacements. 
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 CDmfile property. 
Function  Name or function handle to the MATLAB function that parameterizes
the statespace structure. Compatibility Consideration: Use instead of the MfileName property. 
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 FileArgument property. 
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);
where 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. tfdata now returns the sampling time, Ts, as the third output. In previous releases, tfdata returned the numerator standard deviation as the third output. The new syntax is: [num,den,Ts,sdnum,sdden] = tfdata(sys); sdnum and sdden are [] if sys does not contain uncertainty information or for multioutput polynomial models with a nondiagonal A polynomial array. 
zpkdata  Compatibility Consideration: Backward incompatibility. zpkdata now returns the sampling time, Ts, as its fourth output argument. In previous releases, zpkdata returned the standard deviations of the zeros. The new syntax is: [z,p,k,z,Ts,covz,covp,covk] = zpkdata(sys)where 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 canon. 
findstates(idParametric)  You can now specify arbitrary prediction horizons for findstates. You can use an option set to specify the option for findstates. Use the new function findstatesOptions to create the option set.For more information, see findstatesOptions. 
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.
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.
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. 
model.Algorithm.  Still runs  model.Algorithm. SearchMethod  See Improved Algorithm Options for Linear Models. 
gns option of model.Algorithm.  Still runs  gn  See Improved Algorithm Options for Linear Models. 
GnsPinvTol of model.Algorithm.Advanced  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.
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 IdentificationTutorials 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 IdentificationTutorials 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 

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 