# arx

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

## Syntax

``sys = arx(data,[na nb nk])``
``````sys = arx(data,[na nb nk],Name,Value)``````
``````sys = arx(data,[na nb nk],___,opt)``````

## Description

example

````sys = arx(data,[na nb nk])` estimates the parameters of an ARX or an AR `idpoly` model `sys` 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.```

example

``````sys = arx(data,[na nb nk],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.```

example

``````sys = arx(data,[na nb nk],___,opt)``` specifies estimation options using the option set `opt`. Specify `opt` after all other input arguments.```

## Examples

collapse all

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 "z". 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%.

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

Load the data, which contains the time series `z9` with noise.

`load iddata9 z9`

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

`sys = arx(z9,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 ```

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)` Use `arxRegul` to determine regularization constants automatically and use the values for estimating an FIR model with an order of 50.

Obtain the l`ambda` and `R` values.

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

Use the returned l`ambda` and `R` values for regularized ARX model estimation.

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

## Input Arguments

collapse all

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

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 Ny outputs and Nu inputs:

• `na` is the order of polynomial A(q), specified as an Ny-by-Ny matrix of nonnegative integers.

• `nb` is the order of polynomial B(q) + 1, specified as an Ny-by-Nu matrix of nonnegative integers.

• `nk` is the input-output delay, also known as the transport delay, specified as an Ny-by-Nu matrix of nonnegative integers. `nk` is represented in ARX models by fixed leading zeros in the B polynomial.

For instance, suppose that without transport delays, `sys.b` is `[5 6]`.

• Because `sys.b` + 1 is a second-order polynomial, `nb` = 2.

• Specify a transport delay of `nk` = `3`. Specifying this delay adds three leading zeros to `sys.b` so that `sys.b` is now `[0 0 0 5 6]`, while `nb` remains equal to 2.

• These coefficients represent the polynomial B(q) = 5 q-3 + 6q-4.

You can also implement transport delays using the name-value pair argument `'IODelay'`.

.

Example: `arx(data,[2 1 1])` computes, from an `iddata` object, a second-order ARX model with one input channel that has an input delay of one sample.

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 Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'IntegrateNoise',true` adds an integrator in the noise source s

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

• Nu-by-1 vector, where Nu 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.

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:

• Ny-by-Nu matrix, where Ny is the number of outputs and Nu 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.

Transport delays, specified as the comma-separated pair consisting of `'IODelay'` and an Ny-by-Nu integer array, where Ny is the number of outputs and Nu is the number of inputs. Each array entry represents the transport delay for the corresponding input-output pair. Specify `'IODelay'` in integer multiples of the estimation-data sample time.

You can also specify `'IODelay'` as a scalar value to apply the same delay 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]```.

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

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 FieldDescription
`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 conditions were set to zero.

• `'estimate'` — The initial conditions were treated as independent estimation parameters.

This field is especially useful to view how the initial conditions were handled when the `InitialCondition` option in 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 the following fields:

FieldDescription
`FitPercent`

Normalized root mean squared error (NRMSE) measure of how well the response of the model fits the estimation data, expressed as a percentage.

`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` in the MATLAB® documentation.

`DataUsed`

Attributes of the data used for estimation, returned as a structure with the following fields:

FieldDescription
`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'` — Zero-order hold maintains a piecewise-constant input signal between samples.

• `'foh'` — 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.

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\left(t\right)+{a}_{1}y\left(t-1\right)+...+{a}_{na}y\left(t-na\right)=\\ {b}_{1}u\left(t-nk\right)+...+{b}_{nb}u\left(t-nb-nk+1\right)+e\left(t\right)\end{array}$`

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

• $y\left(t\right)$ — 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\left(t-1\right)\dots y\left(t-{n}_{a}\right)$ — Previous outputs on which the current output depends

• $u\left(t-{n}_{k}\right)\dots u\left(t-{n}_{k}-{n}_{b}+1\right)$ — Previous and delayed inputs on which the current output depends

• $e\left(t\right)$ — White-noise disturbance value

A more compact way to write the difference equation is

`$A\left(q\right)y\left(t\right)=B\left(q\right)u\left(t-{n}_{k}\right)+e\left(t\right)$`

q is the delay operator. Specifically,

`$A\left(q\right)=1+{a}_{1}{q}^{-1}+\dots +{a}_{{n}_{a}}{q}^{-{n}_{a}}$`
`$B\left(q\right)={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\left(q\right)y\left(t\right)=B\left(q\right)u\left(t-nk\right)+\frac{1}{1-{q}^{-1}}e\left(t\right)$`

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\left(q\right)y\left(t\right)=e\left(t\right)$`

### 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\left(q\right)y\left(t\right)=\frac{1}{1-{q}^{-1}}e\left(t\right)$`

### 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\left(q\right)y\left(t\right)={B}_{1}\left(q\right){u}_{1}\left(t-n{k}_{1}\right)+{B}_{2}\left(q\right){u}_{2}\left(t-n{k}_{2}\right)+\cdots +{B}_{nu}\left(q\right){u}_{nu}\left(t-n{k}_{nu}\right)$`

### 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}\left(t\right)e\left(t\right)$`

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

`$\sum _{t=1}^{N}{e}^{T}\left(t\right){\Lambda }^{-1}e\left(t\right)$`

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

$\left({J}^{T}J\right)\theta ={J}^{T}y$

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

$\theta ={\left({J}^{T}J\right)}^{-1}{J}^{T}y$

Using regularization adds the regularization term

$\theta ={\left({J}^{T}J+\lambda R\right)}^{-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.

#### Introduced before R2006a

##### Support Get trial now