Wolfram Language & System Documentation Center

ARMAProcess

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

represents a weakly stationary autoregressive moving-average process with AR coefficients a_i, MA coefficients b_j, and normal white noise variance v.

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

represents a weakly stationary vector ARMA process with coefficient matrices a_i and b_j and covariance matrix Σ.

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

represents an ARMA process with initial data init.

ARMAProcess[c,…]

represents an ARMA process with a constant c.

ARMAProcess

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

represents a weakly stationary autoregressive moving-average process with AR coefficients a_i, MA coefficients b_j, and normal white noise variance v.

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

represents a weakly stationary vector ARMA process with coefficient matrices a_i and b_j and covariance matrix Σ.

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

represents an ARMA process with initial data init.

ARMAProcess[c,…]

represents an ARMA process with a constant c.

Details

ARMAProcess is also known as ARMA and VARMA (vector ARMA).
ARMAProcess is a discrete-time and continuous‐state random process.
The ARMA process is described by the difference equation , where is the state output, is 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 ARMA process should have real coefficients a_i, b_j, and c, and a positive variance v.
An -dimensional vector ARMA process should have real coefficient matrices a_i and b_j of dimensions ×, real vector c of length n, and the covariance matrix Σ should be symmetric positive definite of dimensions ×.
The ARMA process with zero constant has transfer function , where equals:
scalar process

vector process; is the × identity matrix
ARMAProcess[tproc,{p,q}] for a time series process tproc gives an ARMA process of orders p and q, such that its transfer function agrees with PadeApproximant about zero with degrees {q,p} of the transfer function of tproc.
ARMAProcess[tproc] attempts to return an ARMA process such that its transfer function is the same as the one of tproc.
Possible time series processes tproc include ARProcess, SARMAProcess, and SARIMAProcess.
ARMAProcess[p,q] represents an ARMA process of orders p and q for use in EstimatedProcess and related functions.
ARMAProcess can be used with such functions as CovarianceFunction, RandomFunction, and TimeSeriesForecast.

Examples

open all close all

Basic Examples (3)

Simulate an ARMA process:

Wolfram Language code: sample = RandomFunction[ARMAProcess[1, {-.3, .1}, {.4}, 1], {0, 10 ^ 2}]

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

Covariance function:

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

Wolfram Language code:

DiscretePlot3D[CovarianceFunction[ARMAProcess[{.7, -.4, .5}, {1, .4}, 1.], s, t], {s, 0, 10}, {t, 0, 10}, ExtentSize -> 1 / 2, ColorFunction -> "Rainbow"]

Correlation function:

Wolfram Language code: DiscretePlot[CorrelationFunction[ARMAProcess[{.4, .2}, {1, .1}, 1], h], {h, 0, 20}, ExtentSize -> 1 / 2]

Partial correlation function:

Wolfram Language code: DiscretePlot[PartialCorrelationFunction[ARMAProcess[{.4, .2}, {1, .1}, 1], h], {h, 1, 20}, ExtentSize -> 1 / 2]

Scope (38)

Basic Uses (11)

Simulate an ensemble of paths:

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

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

Simulate with given precision:

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

Simulate a first-order scalar process:

Wolfram Language code: sample[{a_, b_}] := RandomFunction[ARMAProcess[{a}, {b}, .1], {1, 10 ^ 2}];

Sample paths for positive and negative values of the parameter:

Wolfram Language code: ListPlot[sample[#], Filling -> Axis, PlotLabel -> StringJoin["{a, b} = ", ToString[#]]]& /@ {{-0.9, -0.9}, {0.9, 0.9}}

Simulate a weakly stationary process with given initial values:

Wolfram Language code: sproc[x_] := ARMAProcess[{.7}, {.3}, 1, {x}];

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

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

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

For a process with a trend, initial values influence the behavior of the whole path:

Wolfram Language code: tproc[x_] := ARMAProcess[{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[ARMAProcess[{α}, {β}, Σ], {1, 10 ^ 2}];

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]]

The 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[ARMAProcess[{α}, {β}, Σ], {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 parameters:

Wolfram Language code:

sample = RandomFunction[ARMAProcess[{.2}, {.1}, 1], {1, 10 ^ 3}];
eproc = EstimatedProcess[sample, ARMAProcess[1, 1]]

Compare the sample covariance functions with the one of the estimated process:

Wolfram Language code:

Show[ListPlot[CovarianceFunction[sample, {8}], Filling -> 0, PlotStyle -> PointSize[Medium]], DiscretePlot[CovarianceFunction[eproc, h], {h, 0, 8}, ExtentSize -> 1 / 2]]

Use TimeSeriesModel to automatically find orders:

Wolfram Language code: TimeSeriesModelFit[sample, "ARMA"]

Wolfram Language code: bestfit = %["BestFit"]

Compare the sample covariance functions with the best time series model:

Wolfram Language code:

Show[ListPlot[CovarianceFunction[sample, {8}], Filling -> 0, PlotStyle -> PointSize[Medium]], DiscretePlot[CovarianceFunction[bestfit, h], {h, 0, 8}, ExtentSize -> 1 / 2]]

Find maximum likelihood estimator:

Wolfram Language code: proc = ARMAProcess[1, {.3}, {.4}, 1];

Wolfram Language code: SeedRandom[23];data = RandomFunction[proc, {100}];

Fix the constant and the variance and estimate the remaining parameters:

Wolfram Language code: res = FindProcessParameters[data, ARMAProcess[1, {a}, {b}, 1], ProcessEstimator -> "MaximumLikelihood"]

Plot the log-likelihood function together with the position of the estimated parameters:

Wolfram Language code: logℒ[x_Real, y_Real] := LogLikelihood[ARMAProcess[1, {x}, {y}, 1], data]

Wolfram Language code: ContourPlot[logℒ[x, y], {x, 0.1, .8}, {y, 0.1, .8}, Epilog -> {Red, Point[{a, b} /. res]}, Contours -> 16]

Estimate a vector autoregressive moving average process:

Wolfram Language code:

proc = ARMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, {{{-.3, .2}, {.8, -.1}}}, {{1, .3}, {.3, .5}}];
data = RandomFunction[proc, {10 ^ 3}];

Wolfram Language code: eproc = EstimatedProcess[data, ARMAProcess[1, 1]]

Compare covariance functions for each component:

Wolfram Language code:

Table[Show[ListPlot[CovarianceFunction[data["PathComponent", i], {8}], Filling -> 0, PlotStyle -> PointSize[Medium], PlotRange -> All], DiscretePlot[CovarianceFunction[eproc, h][[i, i]], {h, 0, 8}, ExtentSize -> 1 / 2]], {i, 1, 2}]

Forecast future values:

Wolfram Language code:

proc = ARMAProcess[.4, {.1, .4}, {-.3}, .1];
sample = RandomFunction[proc, {1, 50}];

Find the forecast for the next 10 steps:

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

Show the 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 = ARMAProcess[{{{.3, .1}, {.9, .1}}}, {{{.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}]

Covariance and Spectrum (6)

Closed-form correlation function for low order:

Wolfram Language code: CorrelationFunction[ARMAProcess[{a}, {b}, σ^2], h]//PiecewiseExpand

Wolfram Language code: CorrelationFunction[ARMAProcess[{1 / 3}, {1, 2}, 1], h]//PiecewiseExpand

Partial correlation function:

Wolfram Language code: Table[PartialCorrelationFunction[ARMAProcess[{Subscript[a, 1]}, {Subscript[b, 1]}, σ^2], h], {h, 2}]//FullSimplify

Correlation matrix:

Wolfram Language code: Correlation[ARMAProcess[{Subscript[a, 1]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2][{1, 5}]]//Factor//MatrixForm

Covariance matrix:

Wolfram Language code: Covariance[ARMAProcess[{Subscript[a, 1]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2][{1, 5}]]//Factor//MatrixForm

Covariance function for a vector-valued process:

Wolfram Language code:

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

Wolfram Language code: TraditionalForm@CovarianceFunction[ARMAProcess[{α}, {β}, Σ], 0]

Wolfram Language code: TraditionalForm@CovarianceFunction[ARMAProcess[{α}, {β}, Σ], 1]

Power spectral density:

Wolfram Language code: Plot[PowerSpectralDensity[ARMAProcess[{-.1, -.4, .3}, {.2, .3}, 1], w], {w, -π, π}, Filling -> Axis]

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

Vector ARProcess:

Wolfram Language code:

a = {{1 / 7, 0}, {1 / 3, 0}};
Σ = {{1, -1 / 3}, {-1 / 3, 1}};
proc = ARProcess[{a}, Σ];

Wolfram Language code:

psd = PowerSpectralDensity[proc, ω];
psd//MatrixForm

Stationarity and Invertibility (5)

Check if a time series is weakly stationary:

Wolfram Language code: WeakStationarity[ARMAProcess[.2, {1, 2}, {3}, 1, {}]]

Wolfram Language code: WeakStationarity[ARMAProcess[2, {.1, .2}, {3}, 1]]

For a vector process:

Wolfram Language code: WeakStationarity[ARMAProcess[{{{.3, .2}, {-.4, .1}}}, {{{.8, -.4}, {.1, .3}}}, {{1, .3}, {.3, .6}}]]

Find conditions for a process to be weakly stationary:

Wolfram Language code: cond2D = WeakStationarity[ARMAProcess[{Subscript[a, 1], Subscript[a, 2]}, {Subscript[b, 1]}, σ^2]]

Wolfram Language code: RegionPlot[cond2D, {Subscript[a, 1], -2, 2}, {Subscript[a, 2], -2, 2}, FrameLabel -> Automatic]

Find conditions for higher autoregressive order:

Wolfram Language code: cond3D = WeakStationarity[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1]}, σ^2]]

Wolfram Language code:

RegionPlot3D[cond3D, {Subscript[a, 1], -2, 2}, {Subscript[a, 2], -2, 2}, {Subscript[a, 3], -2, 2}, PlotPoints -> 40, AxesLabel -> Automatic]

Check if a time series is invertible:

Wolfram Language code: proc = ARMAProcess[1, {2 / 3}, {1 / 4, 2}, 1];

Wolfram Language code: TimeSeriesInvertibility[proc]

For a vector process:

Wolfram Language code: TimeSeriesInvertibility[ARMAProcess[{{{.3, .2}, {-.4, .1}}}, {{{.8, -.4}, {.1, .3}}}, {{1, .3}, {.3, .6}}]]

Find an invertible representation:

Wolfram Language code:

proc = ARMAProcess[1, {1 / 3}, {1, 2}, 1];
TimeSeriesInvertibility[proc]

Wolfram Language code: iproc = ToInvertibleTimeSeries[proc]

The moments are being conserved:

Wolfram Language code: Mean /@ {proc[t], iproc[t]}

Wolfram Language code: CovarianceFunction[#, s, t]& /@ {proc, iproc}

Find invertibility conditions:

Wolfram Language code:

cond2D = TimeSeriesInvertibility[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

Wolfram Language code: RegionPlot[cond2D, {Subscript[b, 1], -2, 2}, {Subscript[b, 2], -2, 2}, FrameLabel -> Automatic]

Find conditions for higher moving-average order:

Wolfram Language code:

cond3D = TimeSeriesInvertibility[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}, σ^2]]

Wolfram Language code:

RegionPlot3D[cond3D, {Subscript[b, 1], -2, 2}, {Subscript[b, 2], -2, 2}, {Subscript[b, 3], -2, 2}, PlotPoints -> 50, AxesLabel -> Automatic, ViewPoint -> {1, 1, 1}]

Estimation Methods (5)

The available methods for estimating an ARMAProcess:

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

Wolfram Language code:

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

Wolfram Language code:

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

Compare log-likelihoods:

Wolfram Language code: LogLikelihood[#[[2]], data]& /@ res

Method of moments admits the following solvers:

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

Wolfram Language code:

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

Wolfram Language code:

Grid[res = Table[{m, EstimatedProcess[data, ARMAProcess[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, ARMAProcess[c, {.4, b}, {m}, v], ProcessEstimator -> "MethodOfMoments"]

Some relations between parameters are also permitted:

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

Maximum conditional likelihood method allows the following solvers:

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

Wolfram Language code:

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

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARMAProcess[2, 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, ARMAProcess[c, {.1, b}, {m}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]

Some relations between parameters are also permitted:

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

Maximum likelihood method allows the following solvers:

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

Wolfram Language code:

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

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARMAProcess[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, ARMAProcess[c, {.1, b}, {m}, v], ProcessEstimator -> "MaximumLikelihood"]

Some relations between parameters are also permitted:

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

Spectral estimator allows users to specify windows used for PowerSpectralDensity calculation:

Wolfram Language code:

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

Wolfram Language code:

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

Spectral estimator allows the following solvers:

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

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, ARMAProcess[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, ARMAProcess[c, {.1, b}, {m}, v], ProcessEstimator -> "SpectralEstimator"]

Some relations between parameters are also permitted:

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

Process Slice Properties (5)

Single time SliceDistribution:

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

Multiple time slice distributions:

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

Wolfram Language code: SliceDistribution[ARMAProcess[{.2}, {.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}};
ARMAProcess[{α}, {β}, Σ][t]//Mean

First-order probability density function:

Wolfram Language code: pdf[t_] = PDF[ARMAProcess[c, {a}, {b}, σ^2, {}][t], x]//PiecewiseExpand//Simplify[#, σ > 0]&

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

Wolfram Language code:

Plot[Evaluate@Table[pdf[t] /. {c -> 1.5, a -> .7, b -> .6, σ -> 1}, {t, times}], {x, -4, 12}, Filling -> Axis, PlotLegends -> (StringJoin["t = ", ToString[#]]& /@ times)]

Stationary mean and variance:

Wolfram Language code: μ = Mean[ARMAProcess[c, {a}, {b}, σ^2][∞]]

Wolfram Language code: v = Variance[ARMAProcess[c, {a}, {b}, σ^2][∞]]

Compare with the density function of a normal distribution:

Wolfram Language code: PDF[NormalDistribution[μ, Sqrt[v]], x]

Wolfram Language code: FullSimplify[% - PDF[ARMAProcess[c, {a}, {b}, σ^2][∞], x]]

Compute the expectation of an expression:

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

Calculate a probability:

Wolfram Language code: Probability[x[t] < 6, xARMAProcess[c, {a}, {b}, σ^2]]

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 (6)

Approximate a SARMA process with an ARMAProcess[4,3]:

Wolfram Language code:

proc = SARMAProcess[.4, {-.3, -.1}, {.5}, {12, {-.2}, {.3}}, 1];
aproc = ARMAProcess[proc, {4, 3}]

Compare the covariance function for the original and the approximate processes:

Wolfram Language code: DiscretePlot[CovarianceFunction[#, h], {h, 0, 10}, ExtentSize -> 1 / 2, PlotLabel -> Head[#]]& /@ {proc, aproc}

Approximate a vector process:

Wolfram Language code:

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

Approximate an ARIMA process with fixed initial conditions by an ARMA process:

Wolfram Language code:

proc = ARIMAProcess[{.2, -.3, -.2}, 1, {.8, -.2, .7}, 1., {}];
aproc = ARMAProcess[proc, {2, 3}]

Compare sample paths:

Wolfram Language code:

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

Approximate a SARIMA process with fixed initial conditions with an ARMA process:

Wolfram Language code:

proc = SARIMAProcess[{.2, -.3, -.1}, 1, {.6, .2}, {4, {.3}, 1, {}}, 1];
aproc = ARMAProcess[proc, {8, 12}]

Compare sample paths:

Wolfram Language code:

SeedRandom[13];sample = RandomFunction[proc, {150}];
SeedRandom[13];asample = RandomFunction[aproc, {150}];
ListLinePlot[{sample, asample}, PlotLegends -> {"SARIMA", "ARMA"}]

Represent an AR process as an equivalent ARMA process:

Wolfram Language code: ARMAProcess[ARProcess[c, {Subscript[a, 1], Subscript[a, 2]}, v]]

MA:

Wolfram Language code: ARMAProcess[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, v]]

ARIMA with known integration order:

Wolfram Language code: ARMAProcess[ARIMAProcess[c, {Subscript[a, 1], Subscript[a, 2]}, 1, {Subscript[b, 1], Subscript[b, 2]}, v]]

SARMA with known seasonal order:

Wolfram Language code:

ARMAProcess[SARMAProcess[c, {Subscript[a, 1], Subscript[a, 2]}, {Subscript[b, 1], Subscript[b, 2]}, {4, {Subscript[α, 1], Subscript[α, 2]}, {Subscript[β, 1], Subscript[β, 2]}}, v]]

SARIMA with known integration and seasonal orders:

Wolfram Language code:

ARMAProcess[SARIMAProcess[c, {Subscript[a, 1]}, 2, {Subscript[b, 1]}, {4, {Subscript[α, 1]}, 1, {Subscript[β, 1]}}, v]]

TransferFunctionModel representation:

Wolfram Language code:

TransferFunctionModel[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

For a vector-valued process:

Wolfram Language code:

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

StateSpaceModel representation:

Wolfram Language code:

StateSpaceModel[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

For a vector-valued process:

Wolfram Language code:

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

Applications (4)

Fit an ARMA model for the hourly measurements of temperature in August:

Wolfram Language code:

temp = TemporalData[TimeSeries, {{{21.1, 20.6, 20, 19.4, 18.9, 20.6, 22.8, 25, 27.2, 28.9, 30, 30.6, 31.7, 
    32.2, 32.2, 32.8, 32.2, 30.6, 26.7, 23.9, 21.7, 21.7, 19.4, 18.3, 18.3, 17.2, 16.7, 16.1, 15.6, 
    17.2, 22.8, 26.1, 28.9, 31.7, 32.8, 33.9,  ...  1}, 1, 
  {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, 
   MetaInformation -> {"Source" -> Defer[WeatherData["Champaign", "Temperature", {2012, 8}]], 
     "Unit" -> "DegreesCelsius"}, TemporalRegularity -> True}}, True, 10.1];

Wolfram Language code: temp["Source"]

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

Find process parameters:

Wolfram Language code: tsm = TimeSeriesModelFit[temp, "ARMA"]

Wolfram Language code: eproc = tsm["BestFit"]

Check if the process is weakly stationary:

Wolfram Language code: WeakStationarity[eproc]

The low-order ARMA model does not capture the seasonal trend well:

Wolfram Language code:

ListPlot[CorrelationFunction[#, {100}]& /@ {temp, eproc}, PlotLegends -> {"Data", "Model"}, PlotStyle -> PointSize[Medium]]

Daily mean temperature readings in September 2012 near your location:

Wolfram Language code:

temp = TemporalData[TimeSeries, {{{24.78, 23.22, 22.94, 25.89, 22.72, 21, 20.06, 17.67, 13.39, 14.44, 
    19.06, 21.44, 22, 15.89, 12.5, 17.5, 18.61, 15.11, 12.44, 17.78, 10.56, 10.17, 5.89, 5.89, 
    15.83, 19.22, 16.83, 13.89, 14.39, 12.83}}, 
  {Temp ...  {"Discrete", 1}, 1, 
  {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, 
   MetaInformation -> {"Source" -> HoldForm[WeatherData[FindGeoLocation[], "MeanTemperature", 
        {{2012, 9, 1}, {2012, 9, 30}, "Day"}]]}}}, True, 10.1];

Wolfram Language code: temp["Source"]

Wolfram Language code: DateListPlot[temp, Joined -> True, Filling -> Bottom]

Find model parameters:

Wolfram Language code: eproc = EstimatedProcess[temp, ARMAProcess[3, 1]]

Check if the process is weakly stationary:

Wolfram Language code: WeakStationarity[eproc]

Forecast for a week ahead:

Wolfram Language code: forecast = TimeSeriesForecast[eproc, temp, {7}]

Plot forecast with original data:

Wolfram Language code: DateListPlot[{temp, forecast}, Joined -> True, Filling -> Axis]

The daily exchange rates of the euro to the dollar from May 2012 through September 2012:

Wolfram Language code:

data = TemporalData[Automatic, {{{1.31, 1.31, 1.31, 1.3, 1.3, 1.3, 1.29, 1.29, 1.29, 1.27, 1.28, 1.28, 
    1.27, 1.26, 1.26, 1.26, 1.25, 1.24, 1.24, 1.23, 1.24, 1.24, 1.25, 1.26, 1.25, 1.26, 1.25, 1.25, 
    1.26, 1.26, 1.26, 1.26, 1.27, 1.27, 1.25, 1.25 ... ata`DateSpecification[{2012, 5, 2}, {2012, 9, 28}, "BusinessDay", "DayRange"]}, 1, 
  {"Discrete", 1}, {"Discrete", 1}, 1, 
  {{MetaInformation -> {"Source" -> Defer[FinancialData]["EUR/USD", 
        {{2012, 5, 1}, {2012, 9, 30}}]}}}}, True, 10.];

Wolfram Language code: data["Source"]

Wolfram Language code: DateListPlot[data, Joined -> True, Filling -> Bottom]

Fit an ARMA process to the exchange rates:

Wolfram Language code: eproc = EstimatedProcess[data, ARMAProcess[2, 1]]

Forecast for 10 business days ahead:

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

Plot forecast with original data:

Wolfram Language code: DateListPlot[{data, forecast}, Joined -> True, Filling -> Axis]

Monthly water levels on Lake Mead:

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

Create TemporalData starting with observation from February 1935:

Wolfram Language code: levels = ExampleData[{"Statistics", "LakeMeadLevels"}, "TimeSeries"]

Wolfram Language code: DateListPlot[levels]

Find a time series model:

Wolfram Language code: tsm = TimeSeriesModelFit[levels, "ARMA"]

Wolfram Language code: eproc = tsm["Process"]

Check if the residuals exhibit any significant serial correlation:

Wolfram Language code: {#["ACFPlot"], #["PACFPlot"]}&@tsm["FitResiduals"]

Forecast the water level for the next 10 years:

Wolfram Language code: forecast = TimeSeriesForecast[eproc, levels, {120}];

Wolfram Language code: DateListPlot[{levels, forecast}, Joined -> True, Filling -> Axis]

Properties & Relations (7)

ARMAProcess is a generalization of MAProcess:

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

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

Wolfram Language code: % - %%

ARMAProcess is a generalization of ARProcess:

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

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

Wolfram Language code: % - %%

ARMAProcess is a special case of ARIMAProcess:

Wolfram Language code:

TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, 0, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code:

TransferFunctionModel[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code: % - %%

ARMAProcess is a special case of FARIMAProcess:

Wolfram Language code:

TransferFunctionModel[FARIMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, 0, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code:

TransferFunctionModel[ARMAProcess[{Subscript[a, 1], Subscript[a, 2], Subscript[a, 3]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]

Wolfram Language code: % - %%

ARMAProcess is a special case of SARMAProcess:

Wolfram Language code: TransferFunctionModel[SARMAProcess[{a}, {b}, {1, {α}, {β}}, σ^2], z]

Wolfram Language code: TransferFunctionModel[ARMAProcess[{a + α, -a α}, { b + β, b β}, σ^2], z]

Wolfram Language code: Simplify[% - %%]

ARMAProcess is a special case of SARIMAProcess:

Wolfram Language code: TransferFunctionModel[SARIMAProcess[{a}, 0, {b}, {1, {α}, 0, {β}}, σ^2], z]

Wolfram Language code: TransferFunctionModel[ARMAProcess[{a + α, -a α}, { b + β, b β}, σ^2], z]

Wolfram Language code: Simplify[% - %%]

Squared values of a GARCHProcess follow an ARMA process:

Wolfram Language code: proc = GARCHProcess[1, {.2, .3}, {.2}];

Wolfram Language code: SeedRandom[34];data = RandomFunction[proc, {10 ^ 6}];

CorrelationFunction and PartialCorrelationFunction of squared values:

Wolfram Language code:

dataSQ = data ^ 2;
ListPlot[#[dataSQ, {1, 30}], Filling -> Axis, PlotRange -> {-.2, 1}, PlotLabel -> #]& /@ {CorrelationFunction, PartialCorrelationFunction}

The corresponding ARMA process:

Wolfram Language code: arma = ARMAProcess[proc]

CorrelationFunction and PartialCorrelationFunction of the ARMA process:

Wolfram Language code:

ListPlot[#[arma, {1, 30}], Filling -> Axis, PlotRange -> {-.2, 1}, PlotLabel -> #]& /@ {CorrelationFunction, PartialCorrelationFunction}

Possible Issues (3)

Some properties are defined only for weakly stationary processes:

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

Use FindInstance to find a weakly stationary process:

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

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

ToInvertibleTimeSeries does not always exist:

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

There are zeros of the TransferFunctionModel on the unit circle:

Wolfram Language code: TransferFunctionZeros[TransferFunctionModel[ARMAProcess[{.2}, {.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[ARMAProcess[2, {.4}, {.3}, 1], {100}];

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

Use the "FindRoot" method instead:

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

Neat Examples (2)

Simulate a weakly stationary three-dimensional ARMAProcess:

Wolfram Language code:

A = {{.2, .1, .1}, {0, -.2, .3}, {.2, -.1, .3}};
B = {{.1, .2, -.1}, {-.1, .3, .1}, {.1, .1, 0}};
S = {{.8, .1, -.2}, {.1, .5, .1}, {-.2, .1, .3}};
proc1 = ARMAProcess[{A}, {B}, S];
data1 = RandomFunction[proc1, {100}]["Values"];

Wolfram Language code: Graphics3D[{ColorData["SolarColors"][RandomReal[]], Tube@Line@data1}]

Non-weakly stationary process, starting at the origin:

Wolfram Language code:

a = {{.9, .2, .8}, {-.2, .8, -.3}, {.2, .2, .4}};
proc2 = ARMAProcess[{a}, {B}, S, {}];
data2 = RandomFunction[proc2, {100}]["Values"];

Wolfram Language code: Graphics3D[{ColorData["SolarColors"][RandomReal[]], Tube@Line@data2}]

Simulate paths from an ARMA process:

Wolfram Language code:

SeedRandom[154];
data = RandomFunction[ARMAProcess[{.3}, {.6}, 1], {50}, 200];

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 -> 55]&[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, 11}], PlotStyle -> (cf /@ Rescale[sd]), BaseStyle -> Directive[Thin, Opacity[0.5]], PlotRangePadding -> {{0, 15}, {.5, .5}}]

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

ARMAProcess

Details

Examples

Basic Examples (3)

Scope (38)

Basic Uses (11)

Covariance and Spectrum (6)

Stationarity and Invertibility (5)

Estimation Methods (5)

Process Slice Properties (5)

Representations (6)

Applications (4)

Properties & Relations (7)

Possible Issues (3)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

ARMAProcess

Details

Examples

Basic Examples (3)

Scope (38)

Basic Uses (11)

Covariance and Spectrum (6)

Stationarity and Invertibility (5)

Estimation Methods (5)

Process Slice Properties (5)

Representations (6)

Applications (4)

Properties & Relations (7)

Possible Issues (3)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX