Wolfram Language & System Documentation Center

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{s,{α₁,…,α_m},{β₁,…,β_r}},v]

represents a weakly stationary seasonal autoregressive moving-average process with ARMA coefficients a_i and b_j, seasonal order s, seasonal ARMA coefficients α_i and β_j, and normal white noise with variance v.

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{s,{α₁,…,α_m},{β₁,…,β_r}},Σ]

represents a weakly stationary vector SARMA process driven by normal white noise, with covariance matrix Σ.

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{{s₁,…},{α₁,…,α_m},{β₁,…,β_r}},Σ]

represents a weakly stationary vector SARMA process with multiple seasonal orders s_i.

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{s,{α₁,…,α_m},{β₁,…,β_r}},v,init]

represents a SARMA process with initial data init.

SARMAProcess[c,…]

represents a SARMA process with a constant c.

SARMAProcess

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{s,{α₁,…,α_m},{β₁,…,β_r}},v]

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{s,{α₁,…,α_m},{β₁,…,β_r}},Σ]

represents a weakly stationary vector SARMA process driven by normal white noise, with covariance matrix Σ.

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{{s₁,…},{α₁,…,α_m},{β₁,…,β_r}},Σ]

represents a weakly stationary vector SARMA process with multiple seasonal orders s_i.

SARMAProcess[{a₁,…,a_p},{b₁,…,b_q},{s,{α₁,…,α_m},{β₁,…,β_r}},v,init]

represents a SARMA process with initial data init.

SARMAProcess[c,…]

represents a SARMA process with a constant c.

Details

SARMAProcess is a discrete-time and continuous-state random process.
The SARMA process is described by the difference equation , with , 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 SARMA process should have real coefficients a_i, α_i, b_j, β_j, and c, positive integer seasonality coefficients s, and a positive variance v.
An -dimensional vector SARMA process should have real coefficient matrices a_i, α_i, b_j, and β_j of dimensions ×, real vector c of length , integer positive seasonality constants s_i or integer positive seasonality constant s, and the covariance matrix Σ should be symmetric positive definite of dimensions ×.
The SARMA process with zero constant has transfer function , where , , , , and is an n-dimensional unit.
SARMAProcess[p,q,{s,sp,sq}] represents a SARMA process with autoregressive and moving-average orders p and q, their seasonal counterparts sp and sq, and seasonality s for use in EstimatedProcess and related functions.
SARMAProcess can be used with such functions as CovarianceFunction, RandomFunction, and TimeSeriesForecast.

Examples

open all close all

Basic Examples (3)

Simulate a SARMA process:

Wolfram Language code: SeedRandom[13];sample = RandomFunction[SARMAProcess[1, {.5}, {.2}, {12, {.8}, {-.2}}, 1], {1, 10 ^ 2}]

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

Covariance function:

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

Wolfram Language code:

DiscretePlot3D[CovarianceFunction[SARMAProcess[{}, {}, {6, {.6}, {4}}, 1.], s, t], {s, 0, 25}, {t, 0, 25}, ExtentSize -> 1 / 2, ColorFunction -> "Rainbow"]

Correlation function:

Wolfram Language code: DiscretePlot[CorrelationFunction[SARMAProcess[{.4}, {1}, {12, {.8}, {.4}}, 1], h], {h, 0, 60}, ExtentSize -> 1 / 2]

Partial correlation function:

Wolfram Language code:

DiscretePlot[PartialCorrelationFunction[SARMAProcess[{.4}, {1}, {12, {.8}, {.4}}, 1], h], {h, 1, 40}, ExtentSize -> 1 / 2]

Scope (33)

Basic Uses (9)

Simulate an ensemble of paths:

Wolfram Language code: data = RandomFunction[SARMAProcess[1, {.5}, {}, {12, {.6}, {.1}}, 1], {50}, 4]

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

Simulate with given precision:

Wolfram Language code:

RandomFunction[SARMAProcess[1, {2 / 10, 1 / 10}, {2 / 7}, {12, {2 / 10}, {2}}, 1 / 10, {1 / 3}], {1, 4}, WorkingPrecision -> 20]["Path"]

Simulate a scalar process with different seasonalities:

Wolfram Language code: sample[s_] := (SeedRandom[3];RandomFunction[SARMAProcess[{.8}, {}, {s, {.9}, {2}}, .1], {1, 2 10 ^ 2}]);

Sample paths for positive and negative values of the parameter:

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

Simulate a weakly stationary process with given initial values:

Wolfram Language code: sproc[x_] := SARMAProcess[.1, {.6}, {.3}, {4, {.6}, {-.2}}, 1, {x}];

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

Wolfram Language code: samples = Table[SeedRandom[4];RandomFunction[sproc[x], {50}], {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_] := SARMAProcess[.1, {.9}, {.3}, {4, {1.1}, {-.2}}, 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[SARMAProcess[{α}, {β}, {4, {α}, {β}}, Σ], {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])], 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[SARMAProcess[{}, {β}, {{6, 3, 4}, {α}, {}}, Σ], {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:

sample = RandomFunction[SARMAProcess[.2, {}, {}, {4, {.8}, {.4}}, 1], {1, 10 ^ 3}];
eproc = EstimatedProcess[sample, SARMAProcess[c, {}, {}, {4, {a}, {b}}, v]]

Compare the sample correlation functions with that of the estimated process:

Wolfram Language code:

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

Use TimeSeriesModel to automatically find orders:

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

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

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

Wolfram Language code:

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

Forecast future values:

Wolfram Language code:

proc = SARMAProcess[.5, {.1, .4}, {-.3}, {4, {.6}, {2}}, .1];
sample = RandomFunction[proc, {1, 50}];

Find the forecast for the next 20 steps:

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

Show the path of the forecast:

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 = SARMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, {{{.9, .3}, {-.3, .5}}}, {4, {{{-.7, .2}, {.3, .4}}}, {{{.8, .1}, {.3, -.2}}}}, {{1, .3}, {.3, .5}}];
data = RandomFunction[proc, {0, 30}];

Find the forecast for the next 15 steps:

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

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

Closed-form correlation function for low order:

Wolfram Language code: CorrelationFunction[SARMAProcess[{}, {}, {4, {.1}, {.2}}, 1], h]//FullSimplify

Correlation matrix:

Wolfram Language code: Correlation[SARMAProcess[{.2}, {.1}, {12, {.3}, {.1}}, 1][{1, 5}]]//MatrixForm

Covariance matrix:

Wolfram Language code: Covariance[SARMAProcess[{-.4}, {2}, {4, {.9}, {.2}}, 1][{1, 5}]]//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}};
α = {{a, 0}, {0, b}};
β = {{c, 0}, {0, d}};

Wolfram Language code: CovarianceFunction[SARMAProcess[{α}, {}, {4, {β}, {}}, Σ], 0]//MatrixForm

Power spectral density:

Wolfram Language code: proc = SARMAProcess[{-.6, -.7}, {.4, .3}, {12, {.3, .2}, {.1, .8}}, 1];

Wolfram Language code: Plot[PowerSpectralDensity[proc, w], {w, -π, π}, Filling -> Axis]

Wolfram Language code: PowerSpectralDensity[SARMAProcess[{a}, {b}, {3, {g}, {h}}, σ^2], w]

Vector SARMAProcess:

Wolfram Language code:

a = {{1 / 9, 0}, {1 / 3, 1 / 2}};
b = {{1 / 3, 1 / 4}, {1 / 2, 0}};
Σ = {{1, 0}, {0, 1}};
proc = SARMAProcess[{}, {}, {4, {b}, {a}}, Σ];

Wolfram Language code:

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

Stationarity and Invertibility (4)

Check if a time series is weakly stationary:

Wolfram Language code: WeakStationarity[SARMAProcess[2, {1, 2}, {3}, {12, {.4}, {.3}}, 1, {}]]

For a vector process:

Wolfram Language code:

WeakStationarity[SARMAProcess[{{{.3, .2}, {-.4, .1}}}, {{{-.5, .2}, {0, .4}}}, {12, {{{.4, .2}, {-.6, .2}}}, {{{.3, .6}, {.9, .8}}}}, {{1, .4}, {.4, .8}}]]

Find conditions for a process to be weakly stationary:

Wolfram Language code:

WeakStationarity[SARMAProcess[c, {Subscript[a, 1], Subscript[a, 2]}, {Subscript[b, 1]}, {s, {Subscript[g, 1], Subscript[g, 2]}, {Subscript[h, 1]}}, σ^2]]

Stationarity conditions depend only on the autoregressive coefficients:

Wolfram Language code: WeakStationarity[SARMAProcess[{}, {b}, {s, {}, {g}}, σ^2]]

Check if a time series is invertible:

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

Wolfram Language code: TimeSeriesInvertibility[proc]

Find its invertible representation:

Wolfram Language code: ToInvertibleTimeSeries[proc]

For a vector process:

Wolfram Language code:

TimeSeriesInvertibility[SARMAProcess[{{{.3, .2}, {-.4, .1}}}, {{{-.5, .2}, {0, .4}}}, {12, {{{.4, .2}, {-.6, .2}}}, {{{.3, .6}, {.9, .8}}}}, {{1, .4}, {.4, .8}}]]

Find invertibility conditions:

Wolfram Language code:

TimeSeriesInvertibility[SARMAProcess[c, {Subscript[a, 1]}, {Subscript[b, 1], Subscript[b, 2]}, {s, {Subscript[g, 1]}, {Subscript[h, 1]}}, σ^2]]

Estimation Methods (5)

The available methods for estimating a SARMAProcess:

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

Wolfram Language code:

SeedRandom[121];
data = RandomFunction[SARMAProcess[{.4}, {.3}, {3, {.2}, {}}, 1], {200}];

Wolfram Language code:

Grid[res = Table[{m, Quiet@EstimatedProcess[data, SARMAProcess[1, 1, {3, 1, 0}], 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"};

Wolfram Language code:

SeedRandom[13241];
data = RandomFunction[SARMAProcess[.2, {.1}, {.1}, {4, {.2}, {}}, 1], {300}];

Wolfram Language code:

Grid[Table[{m, Quiet@EstimatedProcess[data, SARMAProcess[1, 1, {4, 1, 0}], 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, SARMAProcess[c, {.4, b}, {m}, {3, {.2}, {w}}, v], ProcessEstimator -> "MethodOfMoments"]

Some relations between parameters are also permitted:

Wolfram Language code: EstimatedProcess[data, SARMAProcess[c, {a * b, b}, {a}, {3, {b}, {w}}, 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[SARMAProcess[2, {.4}, {.3}, {3, {.2}, {.1}}, 1], {100}];

Wolfram Language code:

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

Some relations between parameters are also permitted:

Wolfram Language code:

EstimatedProcess[data, SARMAProcess[c, {b, b}, {m}, {3, {b}, {w}}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]

Maximum likelihood method allows the following solvers:

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

Wolfram Language code:

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

Wolfram Language code:

Grid[Table[{m, Quiet@EstimatedProcess[data, SARMAProcess[1, 1, {3, 1, 0}], 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, SARMAProcess[c, {b}, {.3}, {3, {.2}, {w}}, v], ProcessEstimator -> "MaximumLikelihood"]

Some relations between parameters are also permitted:

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

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

Wolfram Language code:

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

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Process Slice Properties (5)

Single time SliceDistribution:

Wolfram Language code: Mean@SARMAProcess[1, {.2}, {.3}, {4, {}, {.1}}, 1][2]

Multiple time slice distributions:

Wolfram Language code: Mean@SARMAProcess[1, {.2}, {.3}, {4, {}, {.1}}, 1, {}][{1, 3}]

Slice distribution of a vector-valued time series:

Wolfram Language code:

α = {{.1, .2}, {0., -.3}};
β = {{.3, 0.}, {.9, -.2}};
γ = {{.2, .1}, {0., -.1}};
δ = {{0., .1}, {-.1, .2}};
Σ = {{1, 0}, {0, 1}};
Mean@SARMAProcess[{α}, {β}, {3, {γ}, {δ}}, Σ][t]

First-order stationary probability density function:

Wolfram Language code: pdf := PDF[SARMAProcess[1, {.4}, {.3}, {4, {.6}, {.1}}, 1, {}][t], x]

Wolfram Language code: times = Table[i, {i, 1, 13, 3}];

Wolfram Language code:

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

Stationary mean and variance:

Wolfram Language code: μ = Mean[SARMAProcess[1, {.4}, {.3}, {4, {.6}, {.1}}, 1][∞]]

Wolfram Language code: v = Variance[SARMAProcess[{.4}, {.3}, {4, {.6}, {.1}}, 1][∞]]

Compare with the density function of a normal distribution:

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

Wolfram Language code: FullSimplify[% - PDF[SARMAProcess[1, {.4}, {.3}, {4, {.6}, {.1}}, 1][∞], x]]

Compute the expectation of an expression:

Wolfram Language code: Expectation[x[4] ^ 2, xSARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1]]

Calculate a probability:

Wolfram Language code: Probability[x[7] < 6, xSARMAProcess[1, {.2}, {.3}, {4, {}, {.1}}, 1]]

Skewness and kurtosis:

Wolfram Language code: Skewness[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][∞]]

Wolfram Language code: Kurtosis[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][∞]]

Moment of order r:

Wolfram Language code: Table[Moment[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], r], {r, 0, 4}]

Generating functions:

Wolfram Language code: CharacteristicFunction[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], w]

Wolfram Language code: MomentGeneratingFunction[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], w]

CentralMoment and its generating function:

Wolfram Language code: Table[CentralMoment[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], r], {r, 0, 4}]

Wolfram Language code: CentralMomentGeneratingFunction[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], w]

FactorialMoment has no closed form for symbolic order:

Wolfram Language code: Table[FactorialMoment[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], r], {r, 0, 4}]

Wolfram Language code: FactorialMomentGeneratingFunction[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], w]

Cumulant and its generating function:

Wolfram Language code: Table[Cumulant[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], r], {r, 0, 4}]

Wolfram Language code: CumulantGeneratingFunction[SARMAProcess[{.2}, {.3}, {4, {}, {.1}}, 1][t], w]

Representations (5)

Approximate with an ARProcess:

Wolfram Language code:

proc = SARMAProcess[1, {.2, -.3, -.1}, {.6, .2}, {12, {.3}, {}}, 1];
aproc = ARProcess[proc, 10]

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

Wolfram Language code:

DiscretePlot[CovarianceFunction[#, h], {h, 0, 20}, ExtentSize -> 1 / 2, PlotRange -> All, PlotLabel -> Head[#]]& /@ {proc, aproc}

For a vector process:

Wolfram Language code:

proc = SARMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, {{{.9, .3}, {-.3, .5}}}, {4, {{{-.7, .2}, {.3, .4}}}, {{{.8, .1}, {.3, -.2}}}}, {{1, .3}, {.3, .5}}];

Wolfram Language code: ARProcess[proc, 3]

Approximate with an MAProcess:

Wolfram Language code:

proc = SARMAProcess[1, {.2, -.3, -.1}, {.6, .2}, {12, {.3}, {}}, 1, {}];
aproc = MAProcess[proc, 12]

Compare sample paths:

Wolfram Language code:

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

For a vector process:

Wolfram Language code:

proc = SARMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, {{{.9, .3}, {-.3, .5}}}, {4, {{{-.7, .2}, {.3, .4}}}, {{{.8, .1}, {.3, -.2}}}}, {{1, .3}, {.3, .5}}];

Wolfram Language code: MAProcess[proc, 3]

Represent as equivalent ARMAProcess:

Wolfram Language code:

proc = SARMAProcess[1, {2 / 10, -3 / 10}, {6 / 10, 2 / 10}, {12, {3 / 10}, {}}, 1];
aproc = ARMAProcess[proc]

Compare covariance functions:

Wolfram Language code:

DiscretePlot[CovarianceFunction[#, h], {h, 0, 20}, ExtentSize -> 1 / 2, PlotRange -> All, PlotLabel -> Head[#]]& /@ {proc, aproc}

TransferFunctionModel representation:

Wolfram Language code: TransferFunctionModel[SARMAProcess[{a}, {b}, {12, {g}, {h}}, σ^2], z]

For a vector-valued process:

Wolfram Language code:

A = {{.2, .3}, {0, .1}};
B = {{-.3, 0}, {.5, -.4}};
Σ = {{1, 0}, {0, 1}};
TransferFunctionModel[SARMAProcess[{}, {A}, {4, {B}, {}}, Σ], z]

StateSpaceModel representation:

Wolfram Language code: StateSpaceModel[SARMAProcess[{a}, {b}, {4, {g}, {h}}, σ^2]]

For a vector-valued process:

Wolfram Language code:

A = {{.2, .3}, {0, .1}};
B = {{-.3, .1}, {.5, -.4}};
Σ = {{1, 0}, {0, 1}};
StateSpaceModel[SARMAProcess[{}, {A}, {3, {B}, {}}, Σ]]

Applications (3)

Use a SARMA process to model daily, monthly, and half-yearly autocorrelations:

Wolfram Language code: proc = SARMAProcess[{.1}, {}, {30, {.3, 0, 0, 0, 0, .5}, {}}, 1];

The covariance function shows the serial correlations:

Wolfram Language code: cov = CovarianceFunction[proc, k];

Wolfram Language code: DiscretePlot[cov, {k, 1, 3 * 365}, PlotRange -> All]

Daily mean temperature readings on the first of each month from the years 2000–2011 near your location:

Wolfram Language code:

temp = TemporalData[TimeSeries, {{{-1.22, -4.2, 2.14, 9.92, 18.05, 20.6, 25.11, 23.63, 18.85, 10.11, 4.42, 
    -0.59, -4.52, -0.63, 4.72, 13.81, 14.6, 22.48, 23.41, 23.75, 19.75, 12.52, 7.45, -2.27, -7.41, 
    -3.33, 4.81, 9.41, 22.12, 21.34, 25.7, 23.2 ... , 1}, {"Discrete", 1}, 1, 
  {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, 
   MetaInformation -> {"Source" -> HoldForm[WeatherData[FindGeoLocation[], "MeanTemperature", 
        {{1980, 1}, {2012, 1}, "Month"}]]}}}, True, 10.1];

Wolfram Language code: temp["Source"]

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

Find process parameters:

Wolfram Language code: tsm = TimeSeriesModelFit[temp]

The estimated time series process:

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

Forecast future values for the next three years:

Wolfram Language code: forecast = TimeSeriesForecast[eproc, temp, {3 * 12}];

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

Fit a SARMA 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:

eproc = EstimatedProcess[temp, SARMAProcess[Mean[temp], {a1, a2}, {b}, {12, {c1, c2}, {d1}}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]

Check if the process is weakly stationary:

Wolfram Language code: WeakStationarity[eproc]

The SARMA model does capture the seasonal trend well:

Wolfram Language code:

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

Properties & Relations (3)

SARMAProcess is a generalization of an ARMAProcess:

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

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

Wolfram Language code: Simplify[% - %%]

SARMAProcess is a generalization of an ARProcess:

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

Wolfram Language code: TransferFunctionModel[ARProcess[{a + g, -a g}, σ^2], z]

Wolfram Language code: Simplify[% - %%]

SARMAProcess is a generalization of an MAProcess:

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

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

Wolfram Language code: Simplify[% - %%]

Possible Issues (2)

Some properties are defined only for weakly stationary processes:

Wolfram Language code: CovarianceFunction[SARMAProcess[{2}, {.2}, {3, {.1}, {.3}}, 1], h]

Use FindInstance to find a weakly stationary process:

Wolfram Language code: FindInstance[a > 0 && WeakStationarity[SARMAProcess[{a}, {.2}, {3, {.1}, {.3}}, 1]], a]

Wolfram Language code: CovarianceFunction[SARMAProcess[{1 / 2}, {.2}, {3, {.1}, {.3}}, 1], h]

ToInvertibleTimeSeries does not always exist:

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

There are zeros of TransferFunctionModel lying on the unit circle:

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

Wolfram Language code: Abs[%]

Neat Examples (2)

Simulate a weakly stationary three-dimensional SARMAProcess:

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}};
proc1 = SARMAProcess[{}, {}, {12, {A}, {B}}, S];
data1 = RandomFunction[proc1, {100}]["PathStates"];

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 = SARMAProcess[{a}, {B}, {12, {a}, {A}}, S, {{0, 0, 0}}];
data2 = RandomFunction[proc2, {100}]["PathStates"];

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

Simulate paths from a SARMA process:

Wolfram Language code: SeedRandom[154];data = RandomFunction[SARMAProcess[{.3}, {.6}, {6, {.8}, {.2}}, 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 -> 60]&[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], PlotRangePadding -> {{0, 15}, {.5, .5}}]

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

SARMAProcess

Details

Examples

Basic Examples (3)

Scope (33)

Basic Uses (9)

Covariance and Spectrum (5)

Stationarity and Invertibility (4)

Estimation Methods (5)

Process Slice Properties (5)

Representations (5)

Applications (3)

Properties & Relations (3)

Possible Issues (2)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

SARMAProcess

Details

Examples

Basic Examples (3)

Scope (33)

Basic Uses (9)

Covariance and Spectrum (5)

Stationarity and Invertibility (4)

Estimation Methods (5)

Process Slice Properties (5)

Representations (5)

Applications (3)

Properties & Relations (3)

Possible Issues (2)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX