Estimate parameters of ARX, ARIX, AR, or ARI model (2025)

Estimate parameters of ARX, ARIX, AR, or ARI model

collapse all in page

Syntax

sys = arx(tt,[na nb nk])

sys = arx(u,y,[na nb nk])

sys = arx(data,[na nb nk])

sys = arx(___,Name,Value)

sys = arx(___,opt)

[sys,ic] = arx(___)

Description

Estimate AR or ARX Model

example

sys = arx(tt,[na nb nk]) estimates the parameters of an ARX or an AR idpoly model sys using the data contained in the variables of timetable tt. The software uses the first Nu variables as inputs and the next Ny variables as outputs, where Nu and Ny are determined from the dimensions of nb and na, respectively.

For AR models, which have no input signals, use sys = arx(tt,na). In this case, the software fits the model using the first Ny variables.

arx performs the estimation using a least-squares method and the polynomial orders specified in [na nb nk]. The model properties include covariances (parameter uncertainties) and goodness of fit between the estimated and measured data.

To select specific input and output channels from tt, use name-value syntax to set 'InputName' and 'OutputName' to the corresponding timetable variable names.

sys = arx(u,y,[na nb nk]) uses the time-domain input and output signals in the comma-separated matrices u,y. The software assumes that the data sample time is 1 second. To change the sample time, set Ts using name-value syntax.

example

sys = arx(data,[na nb nk]) uses the time-domain or frequency-domain data in the data object data. Use this syntax especially when you want to estimate a model using frequency-domain or frequency-response data, or when you want to take advantage of the additional information, such as data sample time or experiment labeling, that data objects provide.

Specify Additional Options

example

sys = arx(___,Name,Value) specifies additional options using one or more name-value pair arguments. For instance, using the name-value pair argument 'IntegrateNoise',1 estimates an ARIX or ARI structure model, which is useful for systems with nonstationary disturbances. You can use this syntax with any of the previous input-argument combinations.

example

sys = arx(___,opt) specifies estimation options using the option set opt.

Return Estimated Initial Conditions

example

[sys,ic] = arx(___) returns the estimated initial conditions as an initialCondition object. Use this syntax if you plan to simulate or predict the model response using the same estimation input data and then compare the response with the same estimation output data. Incorporating the initial conditions yields a better match during the first part of the simulation.

Examples

collapse all

ARX Model

Open Live Script

Generate output data based on a specified ARX model and use the output data to estimate the model.

Specify a polynomial model sys0 with the ARX structure. The model includes an input delay of one sample, expressed as a leading zero in the B polynomial.

A = [1 -1.5 0.7];B = [0 1 0.5];sys0 = idpoly(A,B);

Generate a measured input signal u that contains random binary noise and an error signal e that contains normally distributed noise. With these signals, simulate the measured output signal y of sys0.

u = iddata([],idinput(300,'rbs'));e = iddata([],randn(300,1));y = sim(sys0,[u e]);

Combine y and u into a single iddata object z. Estimate a new ARX model using z and the same polynomial orders and input delay as the original model.

z = [y,u];sys = arx(z,[2 2 1])

sys =Discrete-time ARX model: A(z)y(t) = B(z)u(t) + e(t) A(z) = 1 - 1.524 z^-1 + 0.7134 z^-2 B(z) = z^-1 + 0.4748 z^-2 Sample time: 1 seconds Parameterization: Polynomial orders: na=2 nb=2 nk=1 Number of free coefficients: 4 Use "polydata", "getpvec", "getcov" for parameters and their uncertainties.Status: Estimated using ARX on time domain data "sys0". Fit to estimation data: 81.36% (prediction focus)FPE: 1.025, MSE: 0.9846

The output displays the polynomial containing the estimated parameters alongside other estimation details. Under Status, Fit to estimation data shows that the estimated model has 1-step-ahead prediction accuracy above 80%.

AR Model

Open Live Script

Estimate a time-series AR model using the arx function. An AR model has no measured input.

Load the data, which is in a timetable that contains the time series tt9 with noise.

load sdata9 tt9

Estimate a fourth-order AR model by specifying only the na order in [na nb nk].

sys = arx(tt9,4);

Examine the estimated A polynomial parameters and the fit of the estimate to the data.

param = sys.Report.Parameters.ParVector

param = 4×1 -0.7923 -0.4780 -0.0921 0.4698

fit = sys.Report.Fit.FitPercent

fit = 79.4835

ARIX Model

Open Live Script

Estimate the parameters of an ARIX model. An ARIX model is an ARX model with integrated noise.

Specify a polynomial model sys0 with an ARX structure. The model includes an input delay of one sample, expressed as a leading zero in B.

A = [1 -1.5 0.7];B = [0 1 0.5];sys0 = idpoly(A,B);

Simulate the output signal of sys0 using the random binary input signal u and the normally distributed error signal e.

u = iddata([],idinput(300,'rbs'));e = iddata([],randn(300,1));y = sim(sys0,[u e]);

Integrate the output signal and store the result yi in the iddata object zi.

yi = iddata(cumsum(y.y),[]);zi = [yi,u];

Estimate an ARIX model from zi. Set the name-value pair argument 'IntegrateNoise' to true.

sys = arx(zi,[2 2 1],'IntegrateNoise',true);

Predict the model output using 5-step prediction and compare the result with yi.

compare(zi,sys,5)

ARX Model with Regularization

Open Live Script

Use arxRegul to determine regularization constants automatically and use the values for estimating an FIR model with an order of 50.

Obtain the lambda and R values.

load regularizationExampleData eData;orders = [0 50 0];[lambda,R] = arxRegul(eData,orders);

Use the returned lambda and R values for regularized ARX model estimation.

opt = arxOptions;opt.Regularization.Lambda = lambda;opt.Regularization.R = R;sys = arx(eData,orders,opt);

Obtain Initial Conditions

Open Live Script

Load the data.

load iddata1ic z1i

Estimate a second-order ARX model sys and return the initial conditions in ic.

na = 2;nb = 2;nk = 1;[sys,ic] = arx(z1i,[na nb nk]);ic

ic = initialCondition with properties: A: [2x2 double] X0: [2x1 double] C: [0 2] Ts: 0.1000

ic is an initialCondition object that encapsulates the free response of sys, in state-space form, to the initial state vector in X0. You can incorporate ic when you simulate sys with the z1i input signal and compare the response with the z1i output signal.

Input Arguments

collapse all

`tt` — Timetable-based estimation data
timetable | cell array of timetables.

Estimation data, specified as a timetable that uses a regularly spaced time vector. tt contains variables representing input and output channels. For multiexperiment data, tt is a cell array of timetables of length Ne, where Ne is the number of experiments

The software determines the number of input and output channels to use for estimation from the dimensions of the specified polynomial orders. The input/output channel selection depends on whether the 'InputName' and 'OutputName' name-value arguments are specified.

If 'InputName' and 'OutputName' are not specified, then the software uses the first Nu variables of tt as inputs and the next Ny variables of tt as outputs.
If 'InputName' and 'OutputName' are specified, then the software uses the specified variables. The number of specified input and output names must be consistent with Nu and Ny.
For functions that can estimate a time series model, where there are no inputs, 'InputName' does not need to be specified.

For more information about working with estimation data types, see Data Domains and Data Types in System Identification Toolbox.

`u`, `y` — Matrix-based estimation data
matrices | cell array of matrices

Estimation data, specified for SISO systems as a comma-separated pair of N_s-by-1 real-valued matrices that contain uniformly sampled input and output time-domain signal values. Here, N_s is the number of samples.

For MIMO systems, specify u,y as an input/output matrix pair with the following dimensions:

u — N_s-by-N_u, where N_u is the number of inputs.
y — N_s-by-N_y, where N_y is the number of outputs.

For multiexperiment data, specify u,y as a pair of 1-by-N_e cell arrays, where N_e is the number of experiments. The sample times of all the experiments must match.

For time series data, which contains only outputs and no inputs, specify [],y.

Limitations

Matrix-based data does not support estimation from frequency-domain data. You must use a data object such as an iddata object or idfrd object (see data).

For more information about working with estimation data types, see Data Domains and Data Types in System Identification Toolbox.

`data` — Estimation data
`iddata` object | `frd` object | `idfrd` object

Estimation data, specified as an iddata object, an frd (Control System Toolbox) object, or an idfrd frequency-response object. For AR and ARI time-series models, the input channel in data must be empty.

`[na nb nk]` — Polynomial orders and delays
integer row vector | row vector of integer matrices | scalar

Polynomial orders and delays for the model, specified as a 1-by-3 vector or vector of matrices [na nb nk]. The polynomial order is equal to the number of coefficients to estimate in that polynomial.

For an AR or ARI time-series model, which has no input, set [na nb nk] to the scalar na. For an example, see AR Model.

For a model with N_y outputs and N_u inputs:

`opt` — Estimation options
`arxOptions` option set

Estimation options for ARX model identification, specified as an arOptions option set. Options specified by opt include the following:

Initial condition handling — Use this option only for frequency-domain data. For time-domain data, the signals are shifted such that unmeasured signals are never required in the predictors.
Input and output data offsets — Use these options to remove offsets from time-domain data during estimation.
Regularization — Use this option to control the tradeoff between bias and variance errors during the estimation process.

For more information, see arxOptions. For an example, see ARX Model with Regularization.

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose Name in quotes.

Example: 'IntegrateNoise',true adds an integrator in the noise channel.

`InputName` — Input channel names
string | character vector | string array | cell array of character vectors

Input channel names, specified as a string, character vector, string array, or cell array of character vectors.

If you are using a timetable for the data source, the names in InputName must be a subset of the timetable variables.

Example: sys = arx(tt,__,'InputName',["u1" "u2"]) selects the variables u1 and u2 as the input channels from the timetable tt to use for the estimation.

`OutputName` — Output channel names
string | character vector | string array | cell array of character vectors

Output channel names, specified as a string, character vector, string array, or cell array of character vectors.

If you are using a timetable for the data source, the names in OutputName must be a subset of the timetable variables.

Example: sys = arx(tt,__,'OutputName',["y1" "y3"]) selects the variables y1 and y3 as the output channels from the timetable tt to use for the estimation.

`Ts` — Sample time
`1` (default) | positive scalar

Sample time, specified as the comma-separated pair consisting of 'Ts' and the sample time in the units specified by TimeUnit. When you use matrix-based data (u,y), you must specify Ts if you require a sample time other than the assumed sample time of 1 second.

To obtain the data sample time for a timetable tt, use the timetable property tt.Properties.Timestep.

Example: arx(umat1,ymat1,___,'Ts',0.08) computes a model with sample time of 0.08 seconds.

`InputDelay` — Input delays
0 (default) | integer scalar | positive integer vector

Input delays expressed as integer multiples of the sample time, specified as the comma-separated pair consisting of 'InputDelay' and one of the following:

N_u-by-1 vector, where N_u is the number of inputs — Each entry is a numerical value representing the input delay for the corresponding input channel.
Scalar value — Apply the same delay to all input channels.

Example: arx(data,[2 1 3],'InputDelay',1) estimates a second-order ARX model with one input channel that has an input delay of three samples.

`IODelay` — Transport delays
0 (default) | integer scalar | integer array

Transport delays for each input-output pair, expressed as integer multiples of the sample time, and specified as the comma-separated pair consisting of 'IODelay' and one of the following:

N_y-by-N_u matrix, where N_y is the number of outputs and N_u is the number of inputs — Each entry is an integer value representing the transport delay for the corresponding input-output pair.
Scalar value — Apply the same delay is applied to all input-output pairs. This approach is useful when the input-output delay parameter nk results in a large number of fixed leading zeros in the B polynomial. You can factor out max(nk-1,0) lags by moving those lags from nk into the 'IODelay' value.
For instance, suppose that you have a system with two inputs, where the first input has a delay of three samples and the second input has a delay of six samples. Also suppose that the B polynomials for these inputs are order n. You can express these delays using the following:
- nk = [3 6] — This results in B polynomials of [0 0 0 b11 ... b1n] and [0 0 0 0 0 0 b21 ... b2n].
- nk = [3 6] and 'IODelay',3 — This results in B polynomials of [b11 ... b1n] and [0 0 0 b21 ... b2n].

`IntegrateNoise` — Addition of integrators in noise channel
`false` (default) | logical vector

Addition of integrators in the noise channel, specified as the comma-separated pair consisting of 'IntegrateNoise' and a logical vector of length Ny, where Ny is the number of outputs.

Setting 'IntegrateNoise' to true for a particular output creates an ARIX or ARI model for that channel. Noise integration is useful in cases where the disturbance is nonstationary.

When using 'IntegrateNoise', you must also integrate the output channel data. For an example, see ARIX Model.

Output Arguments

collapse all

`sys` — ARX model
`idpoly` object

ARX model that fits the estimation data, returned as a discrete-time idpoly object. This model is created using the specified model orders, delays, and estimation options.

Information about the estimation results and options used is stored in the Report property of the model. Report has the following fields.

Report Field	Description
`Status`	Summary of the model status, which indicates whether the model was created by construction or obtained by estimation
`Method`	Estimation command used
`InitialCondition`	Handling of initial conditions during model estimation,returned as one of the following values: `'zero'` — The initial conditionswere set to zero. `'estimate'` — The initialconditions were treated as independent estimation parameters. This field is especially useful to viewhow the initial conditions were handled when the `InitialCondition` optionin the estimation option set is `'auto'`.
`Fit`	Quantitative assessment of the estimation, returned as a structure. See Loss Function and Model Quality Metrics for more information on these quality metrics. The structure has these fields. `FitPercent` — Normalized root mean squared error (NRMSE) measure of how well the response of the model fits the estimation data, expressed as the percentage fitpercent = 100(1-NRMSE) `LossFcn` — Value of the loss function when the estimation completes `MSE` — Mean squared error (MSE) measure of how well the response of the model fits the estimation data `FPE` — Final prediction error for the model `AIC` — Raw Akaike Information Criteria (AIC) measure of model quality `AICc` — Small-sample-size corrected AIC `nAIC` — Normalized AIC `BIC` — Bayesian Information Criteria (BIC)
`Parameters`	Estimated values of model parameters
`OptionsUsed`	Option set used for estimation. If no custom options were configured, this is a set of default options. See arxOptions for more information.
`RandState`	State of the random number stream at the start of estimation. Empty, `[]`, if randomization was not used during estimation. For more information, see rng.
`DataUsed`	Attributes of the data used for estimation, returned as a structure with the following fields. `Name` — Name of the data set `Type` — Data type `Length` — Number of data samples `Ts` — Sample time `InterSample` — Input intersample behavior, returned as one of the following values: `'zoh'` — A zero-order hold maintains a piecewise-constant input signal between samples. `'foh'` — A first-order hold maintains a piecewise-linear input signal between samples. `'bl'` — Band-limited behavior specifies that the continuous-time input signal has zero power above the Nyquist frequency. `InputOffset` — Offset removed from time-domain input data during estimation. For nonlinear models, it is `[]`. `OutputOffset` — Offset removed from time-domain output data during estimation. For nonlinear models, it is `[]`.

For more information on using Report, see Estimation Report.

`ic` — Initial conditions
`initialCondition` object | object array of `initialCondition` values

Estimated initial conditions, returned as an initialCondition object or an object array of initialCondition values.

For a single-experiment data set, ic represents, in state-space form, the free response of the transfer function model (A and C matrices) to the estimated initial states (x₀).
For a multiple-experiment data set with N_e experiments, ic is an object array of length N_e that contains one set of initialCondition values for each experiment.

For more information, see initialCondition. For an example of using this argument, see Obtain Initial Conditions.

More About

collapse all

ARX Structure

The ARX model name stands for Autoregressive with Extra Input, because, unlike the AR model, the ARX model includes an input term. ARX is also known as Autoregressive with Exogenous Variables, where the exogenous variable is the input term. The ARX model structure is given by the following equation:

$\begin{array}{l} y (t) + a_{1} y (t - 1) + ... + a_{n a} y (t - n a) = \\ b_{1} u (t - n k) + ... + b_{n b} u (t - n b - n k + 1) + e (t) \end{array}$

The parameters na and nb are the orders of the ARX model, and nk is the delay.

$y (t)$ — Output at time $t$
$n_{a}$ — Number of poles
$n_{b}$ — Number of zeros
$n_{k}$ — Number of input samples that occur before the input affects the output, also called the dead time in the system
$y (t - 1) \dots y (t - n_{a})$ — Previous outputs on which the current output depends
$u (t - n_{k}) \dots u (t - n_{k} - n_{b} + 1)$ — Previous and delayed inputs on which the current output depends
$e (t)$ — White-noise disturbance value

A more compact way to write the difference equation is

$A (q) y (t) = B (q) u (t - n_{k}) + e (t)$

q is the delay operator. Specifically,

$A (q) = 1 + a_{1} q^{- 1} + \dots + a_{n_{a}} q^{- n_{a}}$

$B (q) = b_{1} + b_{2} q^{- 1} + \dots + b_{n_{b}} q^{- n_{b} + 1}$

ARIX Model

The ARIX (Autoregressive Integrated with Extra Input) model is an ARX model with an integrator in the noise channel. The ARIX model structure is given by the following equation:

$A (q) y (t) = B (q) u (t - n k) + \frac{1}{1 - q^{- 1}} e (t)$

where $\frac{1}{1 - q^{- 1}}$ is the integrator in the noise channel, e(t).

AR Time-Series Models

For time-series data that contains no inputs, one output, and the A polynomial order na, the model has an AR structure of order na.

The AR (Autoregressive) model structure is given by the following equation:

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

ARI Model

The ARI (Autoregressive Integrated) model is an AR model with an integrator in the noise channel. The ARI model structure is given by the following equation:

$A (q) y (t) = \frac{1}{1 - q^{- 1}} e (t)$

Multiple-Input, Single-Output Models

For multiple-input, single-output systems (MISO) with nu inputs, nb and nk are row vectors where the ith element corresponds to the order and delay associated with the ith input in column vector u(t). Similarly, the coefficients of the B polynomial are row vectors. The ARX MISO structure is then given by the following equation:

$A (q) y (t) = B_{1} (q) u_{1} (t - n k_{1}) + B_{2} (q) u_{2} (t - n k_{2}) + \dots + B_{n u} (q) u_{n u} (t - n k_{n u})$

Multiple-Input, Multiple-Output Models

For multiple-input, multiple-output systems, na, nb, and nk contain one row for each output signal.

In the multiple-output case, arx minimizes the trace of the prediction error covariance matrix, or the norm

$\sum_{t = 1}^{N} e^{T} (t) e (t)$

To transform this norm to an arbitrary quadratic norm using a weighting matrix Lambda

$\sum_{t = 1}^{N} e^{T} (t) Λ^{- 1} e (t)$

use the following syntax:

opt = arxOptions('OutputWeight',inv(lambda))m = arx(data,orders,opt)

Initial Conditions

For time-domain data, the signals are shifted such that unmeasured signals are never required in the predictors. Therefore, there is no need to estimate initial conditions.

For frequency-domain data, it might be necessary to adjust the data by initial conditions that support circular convolution.

Set the 'InitialCondition' estimation option (see arxOptions) to one of the following values:

'zero' — No adjustment
'estimate' — Perform adjustment to the data by initial conditions that support circular convolution
'auto' — Automatically choose 'zero' or 'estimate' based on the data

Algorithms

QR factorization solves the overdetermined set of linear equations that constitutes the least-squares estimation problem.

Without regularization, the ARX model parameters vector θ is estimated by solving the normal equation

$(J^{T} J) θ = J^{T} y$

where J is the regressor matrix and y isthe measured output. Therefore,

$θ = {(J^{T} J)}^{- 1} J^{T} y$

Using regularization adds the regularization term

$θ = {(J^{T} J + λ R)}^{- 1} J^{T} y$

where λ and R are the regularization constants. For more information on the regularization constants, see arxOptions.

When the regression matrix is larger than the MaxSize specified in arxOptions, the data is segmented and QR factorization is performed iteratively on the data segments.

Version History

Introduced before R2006a

expand all

R2022b: Time-domain estimation data is accepted in the form of timetables and matrices

Most estimation, validation, analysis, and utility functions now accept time-domain input/output data in the form of a single timetable that contains both input and output data or a pair of matrices that contain the input and output data separately. These functions continue to accept iddata objects as a data source as well, for both time-domain and frequency-domain data.

MATLAB Command

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.

Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

Americas

América Latina (Español)
Canada (English)
United States (English)

Europe

Belgium (English)
Denmark (English)
Deutschland (Deutsch)
España (Español)
Finland (English)
France (Français)
Ireland (English)
Italia (Italiano)
Luxembourg (English)

Netherlands (English)
Norway (English)
Österreich (Deutsch)
Portugal (English)
Sweden (English)
Switzerland
- Deutsch
- English
- Français
United Kingdom (English)

Asia Pacific

Australia (English)
India (English)
New Zealand (English)
中国
- 简体中文
- English
日本 (日本語)
한국 (한국어)

Contact your local office

Estimate parameters of ARX, ARIX, AR, or ARI model (2025)

Syntax

Description

Estimate AR or ARX Model

Specify Additional Options

Return Estimated Initial Conditions

Examples

ARX Model

AR Model

ARIX Model

ARX Model with Regularization

Obtain Initial Conditions

Input Arguments

tt — Timetable-based estimation data timetable | cell array of timetables.

u, y — Matrix-based estimation data matrices | cell array of matrices

Limitations

data — Estimation data iddata object | frd object | idfrd object

[na nb nk] — Polynomial orders and delays integer row vector | row vector of integer matrices | scalar

opt — Estimation options arxOptions option set

Name-Value Arguments

InputName — Input channel names string | character vector | string array | cell array of character vectors

OutputName — Output channel names string | character vector | string array | cell array of character vectors

Ts — Sample time 1 (default) | positive scalar

InputDelay — Input delays 0 (default) | integer scalar | positive integer vector

IODelay — Transport delays 0 (default) | integer scalar | integer array

IntegrateNoise — Addition of integrators in noise channel false (default) | logical vector

Output Arguments

sys — ARX model idpoly object

ic — Initial conditions initialCondition object | object array of initialCondition values

More About

ARX Structure

ARIX Model

AR Time-Series Models

ARI Model

Multiple-Input, Single-Output Models

Multiple-Input, Multiple-Output Models

Initial Conditions

Algorithms

Version History

R2022b: Time-domain estimation data is accepted in the form of timetables and matrices

See Also

Topics

MATLAB Command

Americas

Europe

Asia Pacific

`tt` — Timetable-based estimation data
timetable | cell array of timetables.

`u`, `y` — Matrix-based estimation data
matrices | cell array of matrices

`data` — Estimation data
`iddata` object | `frd` object | `idfrd` object

`[na nb nk]` — Polynomial orders and delays
integer row vector | row vector of integer matrices | scalar

`opt` — Estimation options
`arxOptions` option set

`InputName` — Input channel names
string | character vector | string array | cell array of character vectors

`OutputName` — Output channel names
string | character vector | string array | cell array of character vectors

`Ts` — Sample time
`1` (default) | positive scalar

`InputDelay` — Input delays
0 (default) | integer scalar | positive integer vector

`IODelay` — Transport delays
0 (default) | integer scalar | integer array

`IntegrateNoise` — Addition of integrators in noise channel
`false` (default) | logical vector

`sys` — ARX model
`idpoly` object

`ic` — Initial conditions
`initialCondition` object | object array of `initialCondition` values