Wolfram Language & System Documentation Center

ARIMAProcess

ARIMAProcess[{a₁,…,a_p},d,{b₁,…,b_q},v]

represents an autoregressive integrated moving-average process such that its difference is a weakly stationary ARMAProcess[{a₁,…,a_p},{b₁,…,b_q},v].

ARIMAProcess[{a₁,…,a_p},d,{b₁,…,b_q},Σ]

represents a vector ARIMA process (y₁(t),… ,y_n(t)) such that its (d,…,d) difference is a vector weakly stationary ARMAProcess.

ARIMAProcess[{a₁,…,a_p},{d₁,…,d_n},{b₁,…,b_q},Σ]

represents a vector ARIMA process (y₁(t),… ,y_n(t)) such that its (d₁,…,d_n) difference is a vector weakly stationary ARMAProcess.

ARIMAProcess[{a₁,…,a_p},d,{b₁,…,b_q},v,init]

represents an ARIMA process with initial data init.

ARIMAProcess[c,…]

represents an ARIMA process with a constant c.

ARIMAProcess

ARIMAProcess[{a₁,…,a_p},d,{b₁,…,b_q},v]

represents an autoregressive integrated moving-average process such that its difference is a weakly stationary ARMAProcess[{a₁,…,a_p},{b₁,…,b_q},v].

ARIMAProcess[{a₁,…,a_p},d,{b₁,…,b_q},Σ]

represents a vector ARIMA process (y₁(t),… ,y_n(t)) such that its (d,…,d) difference is a vector weakly stationary ARMAProcess.

ARIMAProcess[{a₁,…,a_p},{d₁,…,d_n},{b₁,…,b_q},Σ]

represents a vector ARIMA process (y₁(t),… ,y_n(t)) such that its (d₁,…,d_n) difference is a vector weakly stationary ARMAProcess.

ARIMAProcess[{a₁,…,a_p},d,{b₁,…,b_q},v,init]

represents an ARIMA process with initial data init.

ARIMAProcess[c,…]

represents an ARIMA process with a constant c.

Details

ARIMAProcess is a discrete-time and continuous-state random process.
An ARIMAProcess[…,d,…,v] has a polynomial trend of degree d for d≥1.
The ARIMA process is described by the difference equation , where is the state output, is the white noise input, is the shift operator and the constant c is taken to be zero if not specified.
The initial data init can be given as a list {…,y[-2],y[-1]} or a single-path TemporalData object with time stamps understood as {…,-2,-1}.
A scalar ARIMA process should have real coefficients a_i, b_j, and c, non-negative integer integration order d, and a positive variance v.
An -dimensional vector ARIMA process should have real coefficient matrices a_i and b_j of dimensions ×, real vector c of length , integer non-negative integrating orders d_i or integer non-negative integrating order d, and the covariance matrix Σ should be symmetric positive definite of dimensions ×.
The ARIMA process with zero constant has transfer function , where , , and where is an -dimensional unit.
ARIMAProcess[p,d,q] represents an ARIMA process with autoregressive and moving average orders p and q and integration order d for use in EstimatedProcess and related functions.
ARIMAProcess can be used with such functions as CovarianceFunction, RandomFunction, and TimeSeriesForecast.

Examples

open all close all

Basic Examples (2)

Simulate an ARIMA process with a linear trend:

Wolfram Language code: SeedRandom[234];sample = RandomFunction[ARIMAProcess[{-.1}, 1, {.2}, .1], {1, 10 ^ 2}]

Wolfram Language code: ListPlot[sample, Filling -> Axis]

Simulate an ARIMA process with a quadratic trend:

Wolfram Language code: SeedRandom[19];sample = RandomFunction[ARIMAProcess[.2, {-.6}, 2, {.8}, .1], {1, 50}]

Wolfram Language code: ListPlot[sample, Filling -> Axis]

Scope (25)

Basic Uses (9)

Simulate an ensemble of paths:

Wolfram Language code: data = RandomFunction[ARIMAProcess[1, {.5}, 1, {.7}, 1], {30}, 4]

Wolfram Language code: ListLinePlot[data, Filling -> Axis]

Simulate with given precision:

Wolfram Language code: RandomFunction[ARIMAProcess[1 / 4, {2 / 10, 1 / 10}, 2, {2 / 7}, 1 / 10], {1, 4}, WorkingPrecision -> 20]["Paths"]

Simulate a process with given initial values:

Wolfram Language code: sproc[x_] := ARIMAProcess[0, {.6}, 1, {.3}, 1, {x}];

Wolfram Language code: pts = {-4, 0, 4, 8};

Wolfram Language code: samples = Table[SeedRandom[4];RandomFunction[sproc[x], {100}], {x, pts}];

Wolfram Language code: ListLinePlot[samples, DataRange -> {0, 12}, PlotLegends -> (StringJoin["x = ", ToString[#]]& /@ pts)]

In the presence of a nonzero constant:

Wolfram Language code: tproc[x_] := ARIMAProcess[0.2, {1.1}, 1, {.3}, 1, {x}];

Wolfram Language code: tsamples = Table[SeedRandom[4];RandomFunction[tproc[x], {30}], {x, pts}];

Wolfram Language code: ListLinePlot[tsamples, DataRange -> {0, 12}, PlotLegends -> (StringJoin["x = ", ToString[#]]& /@ pts)]

Simulate a two-dimensional process:

Wolfram Language code:

α = {{.2, .1}, {-.3, .2}};
β = {{.2, .5}, {-.2, .9}};
Σ = {{1, 0}, {0, .3}};
sample = RandomFunction[ARIMAProcess[{α}, {1, 1}, {β}, Σ], {1, 10 ^ 3}];

Create a 2D sample path function from the data:

Wolfram Language code:

s = TimeSeries[sample, ResamplingMethod -> Automatic];
f = s["PathFunction"];
g[t_ ? NumericQ] := f[t]

The color of the path is the function of time:

Wolfram Language code:

ParametricPlot[g[t], {t, 1, 100}, ColorFunction -> Function[{x, y, t}, (ColorData["BlueGreenYellow"][t])], PlotStyle -> Thick, AspectRatio -> 1, AxesLabel -> {x, y}]

Create a 3D sample path function with time:

Wolfram Language code: gg[t_ ? NumericQ] := Join[{t}, f[t]]

Color of the path is the function of time:

Wolfram Language code:

ParametricPlot3D[gg[t], {t, 1, 100}, ColorFunction -> Function[{t, x, y}, (ColorData["BlueGreenYellow"][t])], PlotStyle -> Thick, BoxRatios -> 1, AxesLabel -> {t, x, y}]

Simulate a three-dimensional process:

Wolfram Language code:

α = {{.2, .1, .1}, {-.3, .2, .1}, {-.3, .2, -.1}};
β = {{.2, .5, .1}, {-.2, .9, .5}, {.3, .1, -.4}};
Σ = {{1, 0, 0}, {0, .3, 0}, {0, 0, .1}};
SeedRandom[4];sample = RandomFunction[ARIMAProcess[{α}, 1, {β}, Σ], {1, 10 ^ 2}];

Create a sample path function from the data:

Wolfram Language code:

s = TimeSeries[sample, ResamplingMethod -> Automatic];
f = s["PathFunction"];
g[t_ ? NumericQ] := f[t]

The color of the path is the function of time:

Wolfram Language code:

ParametricPlot3D[g[t], {t, 1, 100}, ColorFunction -> Function[{x, y, z, t}, (ColorData["BlueGreenYellow"][t])], PlotStyle -> Thick, BoxRatios -> 1, AxesLabel -> {x, y, z}]

Estimate process parameters:

Wolfram Language code: SeedRandom[314];sample = RandomFunction[ARIMAProcess[.3, {.2}, 1, {.3}, .1], {1, 1000}];

Find model parameters:

Wolfram Language code: eproc = EstimatedProcess[sample, ARIMAProcess[1, d, 1]]

Use TimeSeriesModel to automatically find orders:

Wolfram Language code: tsm = TimeSeriesModelFit[sample]

Wolfram Language code: tsm["Process"]

Estimate a vector process:

Wolfram Language code:

proc = ARIMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, {1, 0}, {{{.9, .2}, {-.5, -.2}}}, {{1, .3}, {.3, .5}}];
data = RandomFunction[proc, {10 ^ 2}];

Wolfram Language code: eproc = EstimatedProcess[data, ARIMAProcess[1, {1, 0}, 1]]

Forecast future values:

Wolfram Language code:

proc = ARIMAProcess[.4, {.3}, 2, {-.5}, 1];
sample = RandomFunction[proc, {1, 10 ^ 2}];
forecast = TimeSeriesForecast[proc, sample, {15}]

Show forecast path:

Wolfram Language code: forecast["Path"]

Plot the data and the forecasted values:

Wolfram Language code: ListLinePlot[{sample, forecast}, InterpolationOrder -> 0, Filling -> Axis]

Find a forecast for a vector-valued time series process:

Wolfram Language code:

proc = ARIMAProcess[{{{.3, .1}, {.9, .1}}}, {1, 2}, {{{.4, -.2}, {.1, .7}}, {{.2, -.4}, {.5, -.3}}}, {{1, .2}, {.2, .6}}];
data = RandomFunction[proc, {0, 15}];

Find the forecast for the next 10 steps:

Wolfram Language code: forecast = TimeSeriesForecast[proc, data, {10}]

Plot the data and the forecast for each component:

Wolfram Language code:

Row@Table[ListLinePlot[#["PathComponent", j]& /@ {data, forecast}, PlotLabel -> Subscript[x, j], PlotLegends -> {"data", "forecast"}], {j, 1, 2}]

Stationarity and Invertibility (2)

Find conditions for a process to be weakly stationary:

Wolfram Language code: WeakStationarity[ARIMAProcess[c, {Subscript[a, 1], Subscript[a, 2]}, d, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

Find invertibility conditions:

Wolfram Language code:

TimeSeriesInvertibility[ARIMAProcess[c, {Subscript[a, 1], Subscript[a, 2]}, d, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

Estimation Methods (5)

The available methods for estimating an ARIMAProcess:

Wolfram Language code: methods = {Automatic, "MethodOfMoments", "MaximumConditionalLikelihood", "MaximumLikelihood", "SpectralEstimator"};

Wolfram Language code:

SeedRandom[3];
data = RandomFunction[ARIMAProcess[.3, {.4}, 1, {.3}, 1], {100}];

Wolfram Language code:

Grid[res = Table[{m, EstimatedProcess[data, ARIMAProcess[1, 1], ProcessEstimator -> m]}, {m, methods}], Frame -> All, Spacings -> {1, 2}, Alignment -> {Left, Center}]

Method of moments admits the following solvers:

Wolfram Language code: solvers = {Automatic, "FindRoot", "NSolve"};

Wolfram Language code:

SeedRandom[3];
data = RandomFunction[ARIMAProcess[{.4}, 1, {.3}, 1], {100}];

Wolfram Language code:

Grid[res = Table[{m, EstimatedProcess[data, ARIMAProcess[1, 1], ProcessEstimator -> {"MethodOfMoments", Method -> m}]}, {m, solvers}], Frame -> All, Spacings -> {1, 2}, Alignment -> {Left, Center}]

This method allows for fixed parameters:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {.4, b}, d, {m}, v], ProcessEstimator -> "MethodOfMoments"]

Some relations between parameters are also permitted:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {a * b, b}, d, {a}, v], ProcessEstimator -> "MethodOfMoments"]

Maximum conditional likelihood method allows the following solvers:

Wolfram Language code: solvers = {Automatic, "FindMaximum", "NMaximize"};

Wolfram Language code:

SeedRandom[3];
data = RandomFunction[ARIMAProcess[2, {.4}, 1, {.3}, 1], {100}];

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARIMAProcess[1, 1], ProcessEstimator -> {"MaximumConditionalLikelihood", Method -> m}]}, {m, solvers}], Frame -> All, Spacings -> {1, 2}, Alignment -> {Left, Center}]

This method allows for fixed parameters:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {.1, b}, d, {m}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]

Some relations between parameters are also permitted:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {b, b}, d, {m}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]

Maximum likelihood method allows the following solvers:

Wolfram Language code: solvers = {Automatic, "FindMaximum", "NMaximize"};

Wolfram Language code:

SeedRandom[3];
data = RandomFunction[ARIMAProcess[2, {.4, .2}, 1, {.3}, 1], {100}];

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARIMAProcess[2, 1], ProcessEstimator -> {"MaximumLikelihood", Method -> m}]}, {m, solvers}], Frame -> All, Spacings -> {1, 2}, Alignment -> {Left, Center}]

This method allows for fixed parameters:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {.1, b}, d, {m}, v], ProcessEstimator -> "MaximumLikelihood"]

Some relations between parameters are also permitted:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {b, b}, d, {m}, v], ProcessEstimator -> "MaximumLikelihood"]

Spectral estimator allows to specify windows used for PowerSpectralDensity calculation:

Wolfram Language code:

SeedRandom[3];
data = RandomFunction[ARIMAProcess[2, {.4, .2}, 1, {.3}, 1], {100}];

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARIMAProcess[2, 1], ProcessEstimator -> {"SpectralEstimator", "Window" -> m}]}, {m, {10, BartlettWindow, {3, HannWindow}}}], Frame -> All, Spacings -> {1, 2}, Alignment -> {Left, Center}]

Spectral estimator allows following solvers:

Wolfram Language code: solvers = {Automatic, "FindMinimum", "NMinimize"};

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARIMAProcess[2, 1], ProcessEstimator -> {"SpectralEstimator", Method -> m}]}, {m, solvers}], Frame -> All, Spacings -> {1, 2}, Alignment -> {Left, Center}]

This method allows for fixed parameters:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {.1, b}, d, {m}, v], ProcessEstimator -> "SpectralEstimator"]

Some relations between parameters are also permitted:

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {b, b}, d, {m}, v], ProcessEstimator -> "SpectralEstimator"]

Process Slice Properties (5)

Single time SliceDistribution:

Wolfram Language code: SliceDistribution[ARIMAProcess[c, {a}, d, {b}, σ ^ 2], t]//Mean

Multiple time slice distributions:

Wolfram Language code: SliceDistribution[ARIMAProcess[1.2, {.2}, 1, {.3}, 1, {}], {1, 3}]//Covariance

Wolfram Language code: SliceDistribution[ARIMAProcess[1, {.2}, 1, {.3}, 1], {1, 2, 3}]//Mean

Slice distribution of a vector-valued time series:

Wolfram Language code:

α = {{Subscript[a, 1], 0}, {0, Subscript[a, 2]}};
β = {{Subscript[b, 1], 0}, {0, Subscript[b, 2]}};
Σ = {{Subscript[σ, 1]^2, ρ Subscript[σ, 1]Subscript[σ, 2]}, {ρ Subscript[σ, 1]Subscript[σ, 2], Subscript[σ, 2]^2}};
ARIMAProcess[{α}, {1, 2}, {β}, Σ][t]//Mean

First-order probability density function:

Wolfram Language code: pdf[t_] = PDF[ARIMAProcess[{1 / 4}, 1, {1 / 3}, 1, {5}][t], x]//Simplify

Wolfram Language code: times = {1, 2, 3, 4};

Wolfram Language code:

Plot[Evaluate@Table[pdf[t], {t, times}], {x, -10, 12}, Filling -> Axis, PlotLegends -> (StringJoin["t = ", ToString[#]]& /@ times)]

Compute the expectation of an expression:

Wolfram Language code: Expectation[x[t] ^ 2, xARIMAProcess[c, {a}, 1, {b}, σ^2], Assumptions -> t > 0]//Simplify

Calculate the probability of an expression:

Wolfram Language code: Probability[x[t] < 6, xARIMAProcess[c, {a}, 1, {b}, σ^2], Assumptions -> t > 0]//Simplify

Skewness and kurtosis are constant:

Wolfram Language code: Skewness[ARMAProcess[c, {a}, {b}, σ^2][t]]

Wolfram Language code: Kurtosis[ARMAProcess[c, {a}, {b}, σ^2][t]]

Moment of order r:

Wolfram Language code: Table[Moment[ARMAProcess[c, {a}, {b}, σ^2][t], r], {r, 0, 4}]//Together

Generating functions:

Wolfram Language code: CharacteristicFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]

Wolfram Language code: MomentGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]

CentralMoment and its generating function:

Wolfram Language code: Table[CentralMoment[ARMAProcess[c, {a}, {b}, σ^2][t], r], {r, 0, 4}]

Wolfram Language code: CentralMomentGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]

FactorialMoment has no closed form for symbolic order:

Wolfram Language code: Table[FactorialMoment[ARMAProcess[c, {a}, {b}, σ^2][t], r]//Simplify, {r, 0, 3}]

Wolfram Language code: FactorialMomentGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]

Cumulant and its generating function:

Wolfram Language code: Table[Cumulant[ARMAProcess[c, {a}, {b}, σ^2][t], r], {r, 0, 4}]

Wolfram Language code: CumulantGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]

Representations (4)

Approximate with an MA process:

Wolfram Language code: MAProcess[ARIMAProcess[.4, {.2, .3}, 4, {.1}, 1, {}], 5]

Approximate with an AR process:

Wolfram Language code:

proc = ARIMAProcess[{.2, .3}, 1, {.5}, 1, {}];
aproc = ARProcess[proc, 5]

Compare sample paths:

Wolfram Language code:

SeedRandom[13];sample = RandomFunction[proc, {100}];
SeedRandom[13];asample = RandomFunction[aproc, {100}];
ListLinePlot[{sample, asample}, PlotLegends -> {"ARIMA", "AR"}]

Approximate a vector process:

Wolfram Language code:

proc = ARIMAProcess[{{{.2, .5}, {-.3, .5}}}, {1, 2}, {{{.2, .3}, {0, .4}}}, {{.6, .2}, {.2, .4}}];
aproc = ARProcess[proc, 3]

Represent as the equivalent ARMA process:

Wolfram Language code:

proc = ARIMAProcess[{a}, 2, {b}, 1];
newproc = ARMAProcess[proc]

It is usually not weakly stationary:

Wolfram Language code: WeakStationarity[newproc]//Simplify

TransferFunctionModel representation:

Wolfram Language code: TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 2, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

For a vector-valued process:

Wolfram Language code:

α = {{.2, .3}, {0, .1}};
β = {{-.3, 0}, {.5, -.4}};
δ = {1, 0};
Σ = {{1, 0}, {0, 1}};
TransferFunctionModel[ARIMAProcess[{α}, δ, {β}, Σ], z]

StateSpaceModel representation:

Wolfram Language code: StateSpaceModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 2, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

For a vector-valued process:

Wolfram Language code:

α = {{.2, .3}, {0, .1}};
β = {{-.3, .9}, {.5, -.4}};
δ = {1, 2};
Σ = {{1, 0}, {0, 1}};
StateSpaceModel[ARIMAProcess[{α}, δ, {β}, Σ]]

Applications (3)

Forecast annual revenue of commercial airlines:

Wolfram Language code: ExampleData[{"Statistics", "AirlinePassengerMiles"}, "LongDescription"]

Wolfram Language code: revenue = ExampleData[{"Statistics", "AirlinePassengerMiles"}, "TimeSeries"]

Wolfram Language code: ListLinePlot[revenue, InterpolationOrder -> 0, Filling -> Axis]

Data has a linear trend that can be confirmed using UnitRootTest:

Wolfram Language code: UnitRootTest[revenue, Automatic, "TestConclusion"]

Fit an ARIMA model to the time series:

Wolfram Language code: eproc = EstimatedProcess[revenue, ARIMAProcess[2, 1, 2]]

Find the forecast for 10 years ahead:

Wolfram Language code: forecast = TimeSeriesForecast[eproc, revenue, {10}]

Wolfram Language code: ListLinePlot[{revenue, forecast}, InterpolationOrder -> 0, Filling -> Axis]

Global yearly mean temperature compared to 1951–1980 baseline:

Wolfram Language code:

gmt = TemporalData[Automatic, {{{-0.32, -0.32, -0.23, -0.29, -0.3, -0.34, -0.33, -0.29, -0.36, -0.29, 
    -0.18, -0.41, -0.29, -0.34, -0.35, -0.36, -0.28, -0.2, -0.16, -0.3, -0.19, -0.18, -0.28, -0.33, 
    -0.37, -0.28, -0.22, -0.42, -0.36, -0.37, -0.3 ... 1, 0.06, 0.28, 0.33, 
    0.33, 0.21, 0.36, 0.14, 0.14, 0.14, 0.4, 0.31, 0.31, 0.42, 0.34, 0.36, 0.36, 0.49, 0.56, 0.49, 
    0.49, 0.62, 0.59, 0.44, 0.44, 0.57, 0.51}}, {{1880, 2011, 1}}, 1, {"Discrete", 1}, 
  {"Discrete", 1}, 1, {}}, False, 9.];

Wolfram Language code: ListPlot[gmt, Joined -> True, AxesOrigin -> {1880, -.5}]

Find order of integration with UnitRootTest:

Wolfram Language code: Table[UnitRootTest[Differences[gmt, k]], {k, 0, 3}]

Estimate an ARIMA with integration order equal to 1:

Wolfram Language code: eproc = EstimatedProcess[gmt, ARIMAProcess[1, 1, 1]]

Find the forecast for the next 20 years:

Wolfram Language code: forecast = TimeSeriesForecast[eproc, gmt, {20}]

Wolfram Language code: ListPlot[{gmt, forecast}, Joined -> True, AxesOrigin -> {1880, -.5}]

Forecast stock prices:

Wolfram Language code: data = FinancialData["SBUX", "Close", {{2013, 1, 1}, {2013, 12, 1}, "Week"}];

Check if regularly sampled:

Wolfram Language code: RegularlySampledQ[data]

Resample to obtain regularly sampled time series:

Wolfram Language code: stocks = TimeSeriesResample[data]

Wolfram Language code: RegularlySampledQ[stocks]

Plot the prices:

Wolfram Language code: DateListPlot[stocks, Filling -> Axis]

Fit an ARIMA process:

Wolfram Language code: eproc = EstimatedProcess[stocks, ARIMAProcess[3, 1, 0], ProcessEstimator -> "MaximumConditionalLikelihood"]

Forecast to the next half a year:

Wolfram Language code: forecast = TimeSeriesForecast[eproc, stocks, {26}];

Wolfram Language code: DateListPlot[{stocks, forecast}, Filling -> Axis]

Properties & Relations (4)

ARIMAProcess is a generalization of an ARMAProcess:

Wolfram Language code: TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 0, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code: TransferFunctionModel[ARMAProcess[{Subscript[a, 1], Subscript[a, 2]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code: % - %%

ARIMAProcess is a generalization of an ARProcess:

Wolfram Language code: TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 0, {}, σ^2], z]

Wolfram Language code: TransferFunctionModel[ARProcess[{Subscript[a, 1], Subscript[a, 2]}, σ^2], z]

Wolfram Language code: % - %%

ARIMAProcess is a generalization of an MAProcess:

Wolfram Language code: TransferFunctionModel[ARIMAProcess[{}, 0, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code: TransferFunctionModel[MAProcess[{Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code: % - %%

ARIMA process follows WienerProcess in discrete steps:

Wolfram Language code:

wiener = WienerProcess[];
arima = ARIMAProcess[{}, 1, {}, 1, {}];

Single time slice properties:

Wolfram Language code: Mean /@ {wiener[t], arima[t]}

Wolfram Language code: PDF[#, x]& /@ {wiener[t + 1], arima[t]}//Simplify[#, t > 0]&

Mixed moments:

Wolfram Language code: MatrixForm[Covariance[#]]& /@ {wiener[{s + 1, t + 1}], arima[{s, t}]}//Simplify[#, 0 < s < t]&

Possible Issues (5)

Multi-time-slice properties may not evaluate for symbolic time stamps:

Wolfram Language code: Correlation[ARIMAProcess[{1 / 2}, 1, {1 / 4}, 1][{Subscript[t, 1], Subscript[t, 2], Subscript[t, 3]}]]

Wolfram Language code: Correlation[ARIMAProcess[{1 / 2}, 1, {1 / 4}, 1][{1, 4, 8}]]

Some properties are defined only for weakly stationary processes:

Wolfram Language code: CovarianceFunction[ARIMAProcess[{2, .3}, 1, {.3, .2}, σ^2], h]

Use FindInstance to find a weakly stationary process:

Wolfram Language code: FindInstance[a > 0 && WeakStationarity[ARIMAProcess[{a, .2}, d, {.3, .2}, σ^2]], {a, d}]

Wolfram Language code: CovarianceFunction[ARIMAProcess[{.4, .2}, 0, {.3, .2}, σ^2], h]

Slice distribution properties with inexact parameters may be ill-conditioned for symbolic times:

Wolfram Language code: var[t_] = Variance[ARIMAProcess[{.4}, 10, {-.5}, 1, {}][t]];

The negative result is incorrect:

Wolfram Language code: var[2]

Use numeric times:

Wolfram Language code: Variance[ARIMAProcess[{.4}, 10, {-.5}, 1, {}][2]]

Or use exact values of parameters:

Wolfram Language code: v[t_] = Variance[ARIMAProcess[{4 / 10}, 10, {-1 / 2}, 1, {}][t]];

Wolfram Language code: v[2]

Wolfram Language code: N[%]

ToInvertibleTimeSeries does not always exist:

Wolfram Language code: ToInvertibleTimeSeries[ARIMAProcess[{.2}, 1, {.3, 1}, .2]]

There are zeros of the TransferFunctionModel on the unit circle:

Wolfram Language code: TransferFunctionZeros[TransferFunctionModel[ARIMAProcess[{.2}, 1, {.3, 1}, .2]]]

Wolfram Language code: Abs[%]

The method of moments may not find a solution in estimation:

Wolfram Language code:

SeedRandom[4];
data = RandomFunction[ARIMAProcess[2, {.4}, 1, {.3}, 1], {100}];

Wolfram Language code: EstimatedProcess[data, ARIMAProcess[c, {.4, b}, 1, {1}, v], ProcessEstimator -> {"MethodOfMoments", Method -> "NSolve"}]

Use the "FindRoot" method instead:

Wolfram Language code:

EstimatedProcess[data, ARIMAProcess[c, {.4, a}, 1, {b}, v], ProcessEstimator -> {"MethodOfMoments", Method -> "FindRoot"}]

Neat Examples (2)

Simulate a three-dimensional ARIMAProcess:

Wolfram Language code:

A = {{.2, .1, .1}, {0, -.2, .3}, {.2, -.1, .3}};
B = {{.4, .2, 0}, {-.2, .8, -.3}, {0, .2, 0}};
S = {{.8, .1, -.2}, {.1, .5, .1}, {-.2, .1, .3}};
proc = ARIMAProcess[{A}, 1, {B}, S];
data = RandomFunction[proc, {100}, k = 8]["ValueList"];

Wolfram Language code: Graphics3D@Table[{ColorData["SolarColors"][RandomReal[]], Tube@Line@data[[i]]}, {i, k}]

Simulate paths from an ARIMA process:

Wolfram Language code: SeedRandom[154];data = RandomFunction[ARIMAProcess[.4, {.3}, 1, {.6}, 1], {50}, 300];

Take a slice at 50 and visualize its distribution:

Wolfram Language code: sd = data["SliceData", 50];

Wolfram Language code:

cf = ColorData["Rainbow"];
sliced = BarChart[Last[#], Axes -> False, BarOrigin -> Left, AspectRatio -> 4, ChartStyle -> (cf /@ Rescale[MovingAverage[First[#], 2], {Min[sd], Max[sd]}, {0, 1}]), ImageSize -> 65]&[HistogramList[sd, {Range[Min[sd], Max[sd], (Max[sd] - Min[sd]) / 20]}]];

Plot paths and histogram distribution of the slice distribution at 50:

Wolfram Language code:

ListLinePlot[data, ImageSize -> 400, PlotRange -> All, 
	AspectRatio -> 3 / 4, Epilog -> Inset[sliced, {51, 0}, {0, 4}], PlotStyle -> (Directive[Thin, cf[#]]& /@ Rescale[sd]), PlotRangePadding -> {{0, 15}, {5, 20}}]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

ARIMAProcess

Details

Examples

Basic Examples (2)

Scope (25)

Basic Uses (9)

Stationarity and Invertibility (2)

Estimation Methods (5)

Process Slice Properties (5)

Representations (4)

Applications (3)

Properties & Relations (4)

Possible Issues (5)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

ARIMAProcess

Details

Examples

Basic Examples (2)

Scope (25)

Basic Uses (9)

Stationarity and Invertibility (2)

Estimation Methods (5)

Process Slice Properties (5)

Representations (4)

Applications (3)

Properties & Relations (4)

Possible Issues (5)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX