Documentation

# ssm class

Superclasses:

Create state-space model

## Description

`ssm` creates a standard, linear, state-space model object with independent Gaussian state disturbances and observation innovations.

You can:

• Specify a time-invariant or time-varying model.

• Specify whether states are stationary, static, or nonstationary.

• Explicitly by providing the matrices

• Implicitly by providing a function that maps the parameters to the matrices, that is, a parameter-to-matrix mapping function

Once you have specified a model:

## Construction

`Mdl = ssm(A,B,C)` creates a state-space model (`Mdl`) using state-transition matrix `A`, state-disturbance-loading matrix `B`, and measurement-sensitivity matrix `C`.

`Mdl = ssm(A,B,C,D)` creates a state-space model using state-transition matrix `A`, state-disturbance-loading matrix `B`, measurement-sensitivity matrix `C`, and observation-innovation matrix `D`.

`Mdl = ssm(___,Name,Value)` uses any of the input arguments in the previous syntaxes and additional options that you specify by one or more `Name,Value` pair arguments.

`Name` can also be a property name and `Value` is the corresponding value. `Name` must appear inside single quotes (`''`). You can specify several name-value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

`Mdl = ssm(ParamMap)` creates a state-space model using a parameter-to-matrix mapping function (`ParamMap`) that you write. The function maps a vector of parameters to the matrices `A`, `B`, and `C`. Optionally, `ParamMap` can map parameters to `D`, `Mean0`, or `Cov0`. To specify the types of states, the function can return `StateType`. To accommodate a regression component in the observation equation, `ParamMap` can also return deflated observation data.

`Mdl = ssm(DSSMMdl)` converts a diffuse state-space model object (`DSSMMdl`) to a state-space model object (`Mdl`). `ssm` sets all initial variances of diffuse states in `SSMMdl.Cov0` to `1e07`.

### Input Arguments

expand all

State-transition coefficient matrix for explicit state-space model creation, specified as a matrix or cell vector of matrices.

The state-transition coefficient matrix, At, specifies how the states, xt, are expected to transition from period t – 1 to t, for all t = 1,...,T. That is, the expected state-transition equation at period t is E(xt|xt–1) = Atxt–1.

For time-invariant state-space models, specify `A` as an m-by-m matrix, where m is the number of states per period.

For time-varying state-space models, specify `A` as a T-dimensional cell array, where `A{t}` contains an mt-by-mt – 1 state-transition coefficient matrix. If the number of states changes from period t – 1 to t, then mtmt – 1.

`NaN` values in any coefficient matrix indicate unique, unknown parameters in the state-space model. `A` contributes:

• `sum(isnan(A(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `A` at each period.

• `numParamsA` unknown parameters to time-varying state-space models, where ```numParamsA = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),A,'UniformOutput',0)))```. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `A`.

You cannot specify `A` and `ParamMap` simultaneously.

Data Types: `double` | `cell`

State-disturbance-loading coefficient matrix for explicit state-space model creation, specified as a matrix or cell vector of matrices.

The state disturbances, ut, are independent Gaussian random variables with mean 0 and standard deviation 1. The state-disturbance-loading coefficient matrix, Bt, specifies the additive error structure in the state-transition equation from period t – 1 to t, for all t = 1,...,T. That is, the state-transition equation at period t is xt = Atxt–1 + Btut.

For time-invariant state-space models, specify `B` as an m-by-k matrix, where m is the number of states and k is the number of state disturbances per period. `B*B'` is the state-disturbance covariance matrix for all periods.

For time-varying state-space models, specify `B` as a T-dimensional cell array, where `B{t}` contains an mt-by-kt state-disturbance-loading coefficient matrix. If the number of states or state disturbances changes at period t, then the matrix dimensions between `B{t-1}` and `B{t}` vary. `B{t}*B{t}'` is the state-disturbance covariance matrix for period `t`.

`NaN` values in any coefficient matrix indicate unique, unknown parameters in the state-space model. `B` contributes:

• `sum(isnan(B(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `B` at each period.

• `numParamsB` unknown parameters to time-varying state-space models, where `numParamsB = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),B,'UniformOutput',0)))`. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `B`.

You cannot specify `B` and `ParamMap` simultaneously.

Data Types: `double` | `cell`

Measurement-sensitivity coefficient matrix for explicit state-space model creation, specified as a matrix or cell vector of matrices.

The measurement-sensitivity coefficient matrix, Ct, specifies how the states are expected to linearly combine at period t to form the observations, yt, for all t = 1,...,T. That is, the expected observation equation at period t is E(yt|xt) = Ctxt.

For time-invariant state-space models, specify `C` as an n-by-m matrix, where n is the number of observations and m is the number of states per period.

For time-varying state-space models, specify `C` as a T-dimensional cell array, where `C{t}` contains an nt-by-mt measurement-sensitivity coefficient matrix. If the number of states or observations changes at period t, then the matrix dimensions between `C{t-1}` and `C{t}` vary.

`NaN` values in any coefficient matrix indicate unique, unknown parameters in the state-space model. `C` contributes:

• `sum(isnan(C(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `C` at each period.

• `numParamsC` unknown parameters to time-varying state-space models, where `numParamsC = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),C,'UniformOutput',0)))`. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `C`.

You cannot specify `C` and `ParamMap` simultaneously.

Data Types: `double` | `cell`

Observation-innovation coefficient matrix for explicit state-space model creation, specified as a matrix or cell vector of matrices.

The observation innovations, εt, are independent Gaussian random variables with mean 0 and standard deviation 1. The observation-innovation coefficient matrix, Dt, specifies the additive error structure in the observation equation at period t, for all t = 1,...,T. That is, the observation equation at period t is yt = Ctxt + Dtεt.

For time-invariant state-space models, specify `D` as an n-by-h matrix, where n is the number of observations and h is the number of observation innovations per period. `D*D'` is the observation-innovation covariance matrix for all periods.

For time-varying state-space models, specify `D` as a T-dimensional cell array, where `D{t}` contains an nt-by-ht matrix. If the number of observations or observation innovations changes at period t, then the matrix dimensions between `D{t-1}` and `D{t}` vary. `D{t}*D{t}'` is the observation-innovation covariance matrix for period `t`.

`NaN` values in any coefficient matrix indicate unique, unknown parameters in the state-space model. `D` contributes:

• `sum(isnan(D(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `D` at each period.

• `numParamsD` unknown parameters to time-varying state-space models, where `numParamsD = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),D,'UniformOutput',0)))`. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `D`.

By default, `D` is an empty matrix indicating no observation innovations in the state-space model.

You cannot specify `D` and `ParamMap` simultaneously.

Data Types: `double` | `cell`

Parameter-to-matrix mapping function for implicit state-space model creation, specified as a function handle.

`ParamMap` must be a function that takes at least one input argument and returns at least three output arguments. The requisite input argument is a vector of unknown parameters, and the requisite output arguments correspond to the coefficient matrices `A`, `B`, and `C`, respectively. If your parameter-to-mapping function requires the input parameter vector argument only, then implicitly create a state-space model by entering the following:

`Mdl = ssm(@ParamMap)`

In general, you can write an intermediate function, for example, `ParamFun`, using this syntax:

```function [A,B,C,D,Mean0,Cov0,StateType,DeflateY] = ... ParamFun(params,...otherInputArgs...)```

In this general case, create the state-space model by entering

`Mdl = ssm(@(params)ParamMap(params,...otherInputArgs...))`

However:

• Follow the order of the output arguments.

• `params` is a vector, and each element corresponds to an unknown parameter.

• `ParamFun` must return `A`, `B`, and `C`, which correspond to the state-transition, state-disturbance-loading, and measurement-sensitivity coefficient matrices, respectively.

• If you specify more input arguments than the parameter vector (`params`), such as observed responses and predictors, then implicitly create the state-space model using the syntax pattern

`Mdl = ssm(@(params)ParamFun(params,y,z))`

• For the optional output arguments `D`, `Mean0`, `Cov0`, `StateType`, and `DeflateY`:

• The optional output arguments correspond to the observation-innovation coefficient matrix `D` and the name-value pair arguments `Mean0`, `Cov0`, and `StateType`.

• To skip specifying an optional output argument, set the argument to `[]` in the function body. For example, to skip specifying `D`, then set `D = [];` in the function.

• `DeflateY` is the deflated-observation data, which accommodates a regression component in the observation equation. For example, in this function, which has a linear regression component, `Y` is the vector of observed responses and `Z` is the vector of predictor data.

```function [A,B,C,D,Mean0,Cov0,StateType,DeflateY] = ParamFun(params,Y,Z) ... DeflateY = Y - params(9) - params(10)*Z; ... end```

• For the default values of `Mean0`, `Cov0`, and `StateType`, see Algorithms.

• It is best practice to:

• Load the data to the MATLAB® Workspace before specifying the model.

• Create the parameter-to-matrix mapping function as its own file.

If you specify `ParamMap`, then you cannot specify any name-value pair arguments or any other input arguments.

Data Types: `function_handle`

Diffuse state-space model to convert to a state-space model, specified as a `dssm` model object.

`ssm` sets all initial variances of diffuse states in `DSSMMdl.Cov0` from `Inf` to `1e7`. Any diffuse states with variance other than `Inf` retain their values.

To apply the standard Kalman filter instead of the diffuse Kalman filter for filtering, smoothing, and parameter estimation, convert a diffuse state-space model to a state-space model.

#### 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`.

Initial state mean for explicit state-space model creation, specified as the comma-separated pair consisting of `'Mean0'` and a numeric vector with length equal to the number of initial states. For the default values, see Algorithms.

If you specify `ParamMap`, then you cannot specify `Mean0`. Instead, specify the initial state mean in the parameter-to-matrix mapping function.

Data Types: `double`

Initial state covariance matrix for explicit state-space model creation, specified as the comma-separated pair consisting of `'Cov0'` and a square matrix with dimensions equal to the number of initial states. For the default values, see Algorithms.

If you specify `ParamMap`, then you cannot specify `Cov0`. Instead, specify the initial state covariance in the parameter-to-matrix mapping function.

Data Types: `double`

Initial state distribution indicator for explicit state-space model creation, specified as the comma-separated pair consisting of `'StateType'` and a numeric vector with length equal to the number of initial states. This table summarizes the available types of initial state distributions.

ValueInitial State Distribution Type
`0`Stationary (for example, ARMA models)
`1`The constant 1 (that is, the state is 1 with probability 1)
`2`Diffuse or nonstationary (for example, random walk model, seasonal linear time series) or static state

For example, suppose that the state equation has two state variables: The first state variable is an AR(1) process, and the second state variable is a random walk. Specify the initial distribution types by setting ```'StateType',[0; 2]```.

If you specify `ParamMap`, then you cannot specify `Mean0`. Instead, specify the initial state distribution indicator in the parameter-to-matrix mapping function.

For the default values, see Algorithms.

Data Types: `double`

## Properties

expand all

State-transition coefficient matrix for explicitly created state-space models, specified as a matrix, a cell vector of matrices, or an empty array (`[]`). For implicitly created state-space models and before estimation, `A` is `[]` and read only.

The state-transition coefficient matrix, At, specifies how the states, xt, are expected to transition from period t – 1 to t, for all t = 1,...,T. That is, the expected state-transition equation at period t is E(xt|xt–1) = Atxt–1.

For time-invariant state-space models, `A` is an m-by-m matrix, where m is the number of states per period.

For time-varying state-space models, `A` is a T-dimensional cell array, where `A{t}` contains an mt-by-mt – 1 state-transition coefficient matrix. If the number of states changes from period t – 1 to t, then mtmt – 1.

`NaN` values in any coefficient matrix indicate unknown parameters in the state-space model. `A` contributes:

• `sum(isnan(A(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `A` at each period.

• `numParamsA` unknown parameters to time-varying state-space models, where ```numParamsA = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),A,'UniformOutput',0)))```. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `A`.

Data Types: `double` | `cell`

State-disturbance-loading coefficient matrix for explicitly created state-space models, specified as a matrix, a cell vector of matrices, or an empty array (`[]`). For implicitly created state-space models and before estimation, `B` is `[]` and read only.

The state disturbances, ut, are independent Gaussian random variables with mean 0 and standard deviation 1. The state-disturbance-loading coefficient matrix, Bt, specifies the additive error structure in the state-transition equation from period t – 1 to t, for all t = 1,...,T. That is, the state-transition equation at period t is xt = Atxt–1 + Btut.

For time-invariant state-space models, `B` is an m-by-k matrix, where m is the number of states and k is the number of state disturbances per period. `B*B'` is the state-disturbance covariance matrix for all periods.

For time-varying state-space models, `B` is a T-dimensional cell array, where `B{t}` contains an mt-by-kt state-disturbance-loading coefficient matrix. If the number of states or state disturbances changes at period t, then the matrix dimensions between `B{t-1}` and `B{t}` vary. `B{t}*B{t}'` is the state-disturbance covariance matrix for period `t`.

`NaN` values in any coefficient matrix indicate unknown parameters in the state-space model. `B` contributes:

• `sum(isnan(B(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `B` at each period.

• `numParamsB` unknown parameters to time-varying state-space models, where `numParamsB = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),B,'UniformOutput',0)))`. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `B`.

Data Types: `double` | `cell`

Measurement-sensitivity coefficient matrix for explicitly created state-space models, specified as a matrix, a cell vector of matrices, or an empty array (`[]`). For implicitly created state-space models and before estimation, `C` is `[]` and read only.

The measurement-sensitivity coefficient matrix, Ct, specifies how the states are expected to combine linearly at period t to form the observations, yt, for all t = 1,...,T. That is, the expected observation equation at period t is E(yt|xt) = Ctxt.

For time-invariant state-space models, `C` is an n-by-m matrix, where n is the number of observations and m is the number of states per period.

For time-varying state-space models, `C` is a T-dimensional cell array, where `C{t}` contains an nt-by-mt measurement-sensitivity coefficient matrix. If the number of states or observations changes at period t, then the matrix dimensions between `C{t-1}` and `C{t}` vary.

`NaN` values in any coefficient matrix indicate unknown parameters in the state-space model. `C` contributes:

• `sum(isnan(C(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `C` at each period.

• `numParamsC` unknown parameters to time-varying state-space models, where `numParamsC = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),C,'UniformOutput',0)))`. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `C`.

Data Types: `double` | `cell`

Observation-innovation coefficient matrix for explicitly created state-space models, specified as a matrix, a cell vector of matrices, or an empty array (`[]`). For implicitly created state-space models and before estimation, `D` is `[]` and read only.

The observation innovations, εt, are independent Gaussian random variables with mean 0 and standard deviation 1. The observation-innovation coefficient matrix, Dt, specifies the additive error structure in the observation equation at period t, for all t = 1,...,T. That is, the observation equation at period t is yt = Ctxt + Dtεt.

For time-invariant state-space models, `D` is an n-by-h matrix, where n is the number of observations and h is the number of observation innovations per period. `D*D'` is the observation-innovation covariance matrix for all peroids.

For time-varying state-space models, `D` is a T-dimensional cell array, where `D{t}` contains an nt-by-ht matrix. If the number of observations or observation innovations changes at period t, then the matrix dimensions between `D{t-1}` and `D{t}` vary. `D{t}*D{t}'` is the state-disturbance covariance matrix for period `t`.

`NaN` values in any coefficient matrix indicate unknown parameters in the state-space model. `D` contributes:

• `sum(isnan(D(:)))` unknown parameters to time-invariant state-space models. In other words, if the state-space model is time invariant, then the software uses the same unknown parameters defined in `D` at each period.

• `numParamsD` unknown parameters to time-varying state-space models, where `numParamsD = sum(cell2mat(cellfun(@(x)sum(sum(isnan(x))),D,'UniformOutput',0)))`. In other words, if the state-space model is time varying, then the software assigns a new set of parameters for each matrix in `D`.

Data Types: `double` | `cell`

Initial state mean, specified as a numeric vector or an empty array (`[]`). `Mean0` has length equal to the number of initial states (`size(A,1)` or `size(A{1},1)`).

`Mean0` is the mean of the Gaussian distribution of the states at period 0.

For implicitly created state-space models and before estimation, `Mean0` is `[]` and read only. However, `estimate` specifies `Mean0` after estimation.

Data Types: `double`

Initial state covariance matrix, specified as a square matrix or an empty array (`[]`). `Cov0` has dimensions equal to the number of initial states (`size(A,1)` or `size(A{1},1)`).

`Cov0` is the covariance of the Gaussian distribution of the states at period 0.

For implicitly created state-space models and before estimation, `Cov0` is `[]` and read only. However, `estimate` specifies `Cov0` after estimation.

Data Types: `double`

Initial state distribution indicator, specified as a numeric vector or empty array (`[]`). `StateType` has length equal to the number of initial states.

For implicitly created state-space models or models with unknown parameters, `StateType` is `[]` and read only.

This table summarizes the available types of initial state distributions.

ValueInitial State Distribution Type
`0`Stationary (e.g., ARMA models)
`1`The constant 1 (that is, the state is 1 with probability 1)
`2`Nonstationary (e.g., random walk model, seasonal linear time series) or static state

For example, suppose that the state equation has two state variables: The first state variable is an AR(1) process, and the second state variable is a random walk. Then, `StateType` is `[0; 2]`.

For nonstationary states, `ssm` sets `Cov0` to `1e7` by default. Subsequently, the software implements the Kalman filter for filtering, smoothing, and parameter estimation. This specification imposes relatively weak knowledge on the initial state values of diffuse states, and uses initial state covariance terms between all states.

Data Types: `double`

Parameter-to-matrix mapping function, specified as a function handle or an empty array (`[]`). `ParamMap` completely specifies the structure of the state-space model. That is, `ParamMap` defines `A`, `B`, `C`, `D`, and, optionally, `Mean0`, `Cov0`, and `StateType`. For explicitly created state-space models, `ParamMap` is `[]` and read only.

Data Types: `function_handle`

## Methods

 disp Display summary information for state-space model estimate Maximum likelihood parameter estimation of state-space models filter Forward recursion of state-space models forecast Forecast states and observations of state-space models refine Refine initial parameters to aid state-space model estimation simsmooth State-space model simulation smoother simulate Monte Carlo simulation of state-space models smooth Backward recursion of state-space models

## Copy Semantics

Value. To learn how value classes affect copy operations, see Copying Objects (MATLAB).

## Examples

collapse all

Create a standard state-space model containing two independent, autoregressive states, and the observations are the deterministic sum of the two states. Symbolically, the system of equations is

`$\left[\begin{array}{c}{x}_{t,1}\\ {x}_{t,2}\end{array}\right]=\left[\begin{array}{cc}{\varphi }_{1}& 0\\ 0& {\varphi }_{2}\end{array}\right]\left[\begin{array}{c}{x}_{t-1,1}\\ {x}_{t-1,2}\end{array}\right]+\left[\begin{array}{cc}{\sigma }_{1}& 0\\ 0& {\sigma }_{2}\end{array}\right]\left[\begin{array}{c}{u}_{t,1}\\ {u}_{t,2}\end{array}\right]$`

`${y}_{t}=\left[\begin{array}{cc}1& 1\end{array}\right]\left[\begin{array}{c}{x}_{t,1}\\ {x}_{t,2}\end{array}\right].$`

Specify the state-transition matrix.

`A = [NaN 0; 0 NaN];`

`B = [NaN 0; 0 NaN];`

Specify the measurement-sensitivity matrix.

`C = [1 1];`

Define the state-space model using `ssm`.

`Mdl = ssm(A,B,C)`
```Mdl = State-space model type: ssm State vector length: 2 Observation vector length: 1 State disturbance vector length: 2 Observation innovation vector length: 0 Sample size supported by model: Unlimited Unknown parameters for estimation: 4 State variables: x1, x2,... State disturbances: u1, u2,... Observation series: y1, y2,... Observation innovations: e1, e2,... Unknown parameters: c1, c2,... State equations: x1(t) = (c1)x1(t-1) + (c3)u1(t) x2(t) = (c2)x2(t-1) + (c4)u2(t) Observation equation: y1(t) = x1(t) + x2(t) Initial state distribution: Initial state means are not specified. Initial state covariance matrix is not specified. State types are not specified. ```

`Mdl` is an `ssm` model containing unknown parameters. A detailed summary of `Mdl` prints to the Command Window.

It is good practice to verify that the state and observation equations are correct. If the equations are not correct, then it might help to expand the state-space equation manually.

Create a state-space model containing two independent, autoregressive states, and the observations are the sum of the two states, plus Gaussian error. Symbolically, the equation is

`$\left[\begin{array}{c}{x}_{t,1}\\ {x}_{t,2}\end{array}\right]=\left[\begin{array}{cc}{\varphi }_{1}& 0\\ 0& {\varphi }_{2}\end{array}\right]\left[\begin{array}{c}{x}_{t-1,1}\\ {x}_{t-1,2}\end{array}\right]+\left[\begin{array}{cc}{\sigma }_{1}& 0\\ 0& {\sigma }_{2}\end{array}\right]\left[\begin{array}{c}{u}_{t,1}\\ {u}_{t,2}\end{array}\right]$`

`${y}_{t}=\left[\begin{array}{cc}1& 1\end{array}\right]\left[\begin{array}{c}{x}_{t,1}\\ {x}_{t,2}\end{array}\right]+{\sigma }_{3}{\epsilon }_{t}.$`

Define the state-transition matrix.

`A = [NaN 0; 0 NaN];`

`B = [NaN 0; 0 NaN];`

Define the measurement-sensitivity matrix.

`C = [1 1];`

Define the observation-innovation matrix.

`D = NaN;`

Create the state-space model using `ssm`.

` Mdl = ssm(A,B,C,D)`
```Mdl = State-space model type: ssm State vector length: 2 Observation vector length: 1 State disturbance vector length: 2 Observation innovation vector length: 1 Sample size supported by model: Unlimited Unknown parameters for estimation: 5 State variables: x1, x2,... State disturbances: u1, u2,... Observation series: y1, y2,... Observation innovations: e1, e2,... Unknown parameters: c1, c2,... State equations: x1(t) = (c1)x1(t-1) + (c3)u1(t) x2(t) = (c2)x2(t-1) + (c4)u2(t) Observation equation: y1(t) = x1(t) + x2(t) + (c5)e1(t) Initial state distribution: Initial state means are not specified. Initial state covariance matrix is not specified. State types are not specified. ```

`Mdl` is an `ssm` model containing unknown parameters. A detailed summary of `Mdl` prints to the Command Window.

It is good practice to verify that the state and observations equations are correct. If the equations are not correct, then it might help to expand the state-space equation manually.

Pass the data and `Mdl` to `estimate` to estimate the parameters.

Create a state-space model, where the state equation is an AR(2) model. The state disturbances are mean zero Gaussian random variables with standard deviation of 0.3. The observation equation is the difference between the current and previous state plus a mean zero Gaussian observation innovation with a standard deviation of 0.1. Symbolically, the state-space model is

`$\left[\begin{array}{c}{x}_{1,t}\\ {x}_{2,t}\\ {x}_{3,t}\end{array}\right]=\left[\begin{array}{ccc}0.6& 0.2& 0.5\\ 1& 0& 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_{1,t-1}\\ {x}_{2,t-1}\\ {x}_{3,t-1}\end{array}\right]+\left[\begin{array}{c}0.3\\ 0\\ 0\end{array}\right]{u}_{1,t}$`

`${y}_{t}=\left[\begin{array}{ccc}1& -1& 0\end{array}\right]\left[\begin{array}{c}{x}_{1,t}\\ {x}_{2,t}\\ {x}_{3,t}\end{array}\right]+0.1{\epsilon }_{t}.$`

There are three states: ${x}_{1,t}$ is the AR(2) process, ${x}_{2,t}$ represents ${x}_{1,t-1}$, and ${x}_{3,t}$ is the AR(2) model constant.

Define the state-transition matrix.

`A = [0.6 0.2 0.5; 1 0 0; 0 0 1];`

`B = [0.3; 0; 0];`

Define the measurement-sensitivity matrix.

`C = [1 -1 0];`

Define the observation-innovation matrix.

`D = 0.1;`

Use `ssm` to create the state-space model. Set the initial-state mean (`Mean0`) and covariance matrix (`Cov0`). Identify the type of initial state distributions (`StateType`) by noting the following:

• ${x}_{1,t}$ is a stationary, AR(2) process.

• ${x}_{2,t}$ is also a stationary, AR(2) process.

• ${x}_{3,t}$ is the constant 1 for all periods.

```Mean0 = [0; 0; 1]; % The mean of the AR(2) varAR2 = 0.3*(1 - 0.2)/((1 + 0.2)*((1 - 0.2)^2 - 0.6^2)); % The variance of the AR(2) Cov1AR2 = 0.6*0.3/((1 + 0.2)*((1 - 0.2)^2) - 0.6^2); % The covariance of the AR(2) Cov0 = zeros(3); Cov0(1:2,1:2) = varAR2*eye(2) + Cov1AR2*flip(eye(2)); StateType = [0; 0; 1]; Mdl = ssm(A,B,C,D,'Mean0',Mean0,'Cov0',Cov0,'StateType',StateType)```
```Mdl = State-space model type: ssm State vector length: 3 Observation vector length: 1 State disturbance vector length: 1 Observation innovation vector length: 1 Sample size supported by model: Unlimited State variables: x1, x2,... State disturbances: u1, u2,... Observation series: y1, y2,... Observation innovations: e1, e2,... State equations: x1(t) = (0.60)x1(t-1) + (0.20)x2(t-1) + (0.50)x3(t-1) + (0.30)u1(t) x2(t) = x1(t-1) x3(t) = x3(t-1) Observation equation: y1(t) = x1(t) - x2(t) + (0.10)e1(t) Initial state distribution: Initial state means x1 x2 x3 0 0 1 Initial state covariance matrix x1 x2 x3 x1 0.71 0.44 0 x2 0.44 0.71 0 x3 0 0 0 State types x1 x2 x3 Stationary Stationary Constant ```

`Mdl` is an `ssm` model.

You can display properties of `Mdl` using dot notation. For example, display the initial state covariance matrix.

`Mdl.Cov0`
```ans = 3×3 0.7143 0.4412 0 0.4412 0.7143 0 0 0 0 ```

Use a parameter mapping function to create a time-invariant state-space model, where the state model is AR(1) model. The states are observed with bias, but without random error. Set the initial state mean and variance, and specify that the state is stationary.

Write a function that specifies how the parameters in `params` map to the state-space model matrices, the initial state values, and the type of state. Symbolically, the model is

``` % Copyright 2015 The MathWorks, Inc. function [A,B,C,D,Mean0,Cov0,StateType] = timeInvariantParamMap(params) % Time-invariant state-space model parameter mapping function example. This % function maps the vector params to the state-space matrices (A, B, C, and % D), the initial state value and the initial state variance (Mean0 and % Cov0), and the type of state (StateType). The state model is AR(1) % without observation error. varu1 = exp(params(2)); % Positive variance constraint A = params(1); B = sqrt(varu1); C = params(3); D = []; Mean0 = 0.5; Cov0 = 100; StateType = 0; end ```

Save this code as a file named `timeInvariantParamMap.m` to a folder on your MATLAB® path.

Create the state-space model by passing the function `timeInvariantParamMap` as a function handle to `ssm`.

```Mdl = ssm(@timeInvariantParamMap); ```

`ssm` implicitly creates the state-space model. Usually, you cannot verify implicitly defined state-space models.

If you estimate, filter, or smooth a diffuse state-space model containing at least one diffuse state, then the software uses the diffuse Kalman filter. To use the standard Kalman filter instead, convert the diffuse state-space model to a standard state-space model. `ssm` attributes a large initial state variance (`1e7`) for diffuse states. A standard state-space model treatment results in an approximation to the results of the diffuse Kalman filter. However, `estimate` uses all of the data to fit the model, and `filter` and `smooth` return filtered and smoothed estimates for all periods, respectively.

Explicitly create a one-dimensional diffuse state-space model. Specify that the first state equation is ${x}_{t}={x}_{t-1}+{u}_{t}$, and that the observation model is ${y}_{t}={x}_{t}+{\epsilon }_{t}$.

```A = 1; B = 1; C = 1; D = 1; DSSMMdl = dssm(A,B,C,D)```
```DSSMMdl = State-space model type: dssm State vector length: 1 Observation vector length: 1 State disturbance vector length: 1 Observation innovation vector length: 1 Sample size supported by model: Unlimited State variables: x1, x2,... State disturbances: u1, u2,... Observation series: y1, y2,... Observation innovations: e1, e2,... State equation: x1(t) = x1(t-1) + u1(t) Observation equation: y1(t) = x1(t) + e1(t) Initial state distribution: Initial state means x1 0 Initial state covariance matrix x1 x1 Inf State types x1 Diffuse ```

`DSSMMdl` is a `dssm` model object. Because the model does not contain any unknown parameters, `dssm` infers the initial state distribution and its parameters. In particular, the initial state variance is `Inf` because the nonstationary state has a diffuse distribution by default.

Convert `DSSMMdl` to a standard state-space model.

`Mdl = ssm(DSSMMdl)`
```Mdl = State-space model type: ssm State vector length: 1 Observation vector length: 1 State disturbance vector length: 1 Observation innovation vector length: 1 Sample size supported by model: Unlimited State variables: x1, x2,... State disturbances: u1, u2,... Observation series: y1, y2,... Observation innovations: e1, e2,... State equation: x1(t) = x1(t-1) + u1(t) Observation equation: y1(t) = x1(t) + e1(t) Initial state distribution: Initial state means x1 0 Initial state covariance matrix x1 x1 1e+07 State types x1 Diffuse ```

`Mdl` is an `ssm` model object. The structures of `Mdl` and `DSSMMdl` are equivalent, except that the initial state variance of the state in `Mdl` is `1e7`.

To see the difference between the two models, simulate 10 periods of data from a state-space model that is similar to `Mdl`, except it has known initial state mean of 5 and variance 2.

```SimMdl = ssm(A,B,C,D,'Mean0',5,'Cov0',2,'StateType',2); T = 10; rng(1); % For reproducibility y = simulate(SimMdl,T);```

Obtain filtered and smoothed states from `Mdl` and `DSSMMdl` using the simulated data.

```fMdl = filter(Mdl,y); fDSSMMdl = filter(DSSMMdl,y); sMdl = smooth(Mdl,y); sDSSMMdl = smooth(DSSMMdl,y);```

Plot the filtered and smoothed states.

```figure; plot(1:T,y,'-o',1:T,fMdl,'-d',1:T,fDSSMMdl,'-*'); legend('Simulated Data','Filtered States -- Mdl','Filtered States -- DSSMMdl');```

```figure; plot(1:T,y,'-o',1:T,sMdl,'-d',1:T,sDSSMMdl,'-*'); legend('Simulated Data','Smoothed States -- Mdl','Smoothed States -- DSSMMdl');```

Besides apparent transient behavior, the filtered and smoothed states between the standard and diffuse state-space models appear nearly equivalent. The slight difference occurs because `filter` and `smooth` set all diffuse state estimates in the diffuse state-space model to 0 while they implement the diffuse Kalman filter. Once the covariance matrices of the smoothed states attain full rank, `filter` and `smooth` switch to using the standard Kalman filter. In this case, the switching time occurs after the first period.

expand all

## Tips

Specify `ParamMap` in a more general or complex setting, where, for example:

• The initial state values are parameters.

• In time-varying models, you want to use the same parameters for more than one period.

• You want to impose parameter constraints.

## Algorithms

• Default values for `Mean0` and `Cov0`:

• If you explicitly specify the state-space model (that is, you provide the coefficient matrices `A`, `B`, `C`, and optionally `D`), then:

• For stationary states, the software generates the initial value using the stationary distribution. If you provide all values in the coefficient matrices (that is, your model has no unknown parameters), then `ssm` generates the initial values. Otherwise, the software generates the initial values during estimation.

• For states that are always the constant 1, `ssm` sets `Mean0` to 1 and `Cov0` to `0`.

• For diffuse states, the software sets `Mean0` to 0 and `Cov0` to `1e7` by default.

• If you implicitly create the state-space model (that is, you provide the parameter vector to the coefficient-matrices-mapping function `ParamMap`), then the software generates any initial values during estimation.

• For static states that do not equal 1 throughout the sample, the software cannot assign a value to the degenerate, initial state distribution. Therefore, set static states to `2` using the name-value pair argument `StateType`. Subsequently, the software treats static states as nonstationary and assigns the static state a diffuse initial distribution.

• It is best practice to set `StateType` for each state. By default, the software generates `StateType`, but this behavior might not be accurate. For example, the software cannot distinguish between a constant 1 state and a static state.

• The software cannot infer `StateType` from data because the data theoretically comes from the observation equation. The realizations of the state equation are unobservable.

• `ssm` models do not store observed responses or predictor data. Supply the data wherever necessary using the appropriate input or name-value pair arguments.

• Suppose that you want to create a state-space model using a parameter-to-matrix mapping function with this signature:

`[A,B,C,D,Mean0,Cov0,StateType,DeflateY] = paramMap(params,Y,Z)`
and you specify the model using an anonymous function
`Mdl = ssm(@(params)paramMap(params,Y,Z))`
The observed responses `Y` and predictor data `Z` are not input arguments in the anonymous function. If `Y` and `Z` exist in the MATLAB Workspace before you create `Mdl`, then the software establishes a link to them. Otherwise, if you pass `Mdl` to `estimate`, the software throws an error.

The link to the data established by the anonymous function overrides all other corresponding input argument values of `estimate`. This distinction is important particularly when conducting a rolling window analysis. For details, see Rolling-Window Analysis of Time-Series Models.

## References

[1] Durbin J., and S. J. Koopman. Time Series Analysis by State Space Methods. 2nd ed. Oxford: Oxford University Press, 2012.