Wolfram Language & System Documentation Center

SARIMAProcess

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

represents a seasonal integrated autoregressive moving-average process with ARIMA coefficients a_i, d, and b_j; seasonal order s; seasonal ARIMA coefficients α_i, δ, and β_j; seasonal integration order δ; and normal white noise with variance v.

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

represents a vector SARIMA process with coefficient matrices a_i, b_j, α_i, and β_j and covariance matrix Σ.

SARIMAProcess[{a₁,…},{d₁,…},{b₁,…},{{s₁,…},{α₁,…},{δ₁,…},{β₁,…}},Σ]

represents a vector SARIMA process with multiple integration orders d_i, seasonal orders s_j, and seasonal integration orders δ_k.

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

represents a SARIMA process with initial data init.

SARIMAProcess[c,…]

represents a SARIMA process with constant c.

SARIMAProcess

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

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

represents a vector SARIMA process with coefficient matrices a_i, b_j, α_i, and β_j and covariance matrix Σ.

SARIMAProcess[{a₁,…},{d₁,…},{b₁,…},{{s₁,…},{α₁,…},{δ₁,…},{β₁,…}},Σ]

represents a vector SARIMA process with multiple integration orders d_i, seasonal orders s_j, and seasonal integration orders δ_k.

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

represents a SARIMA process with initial data init.

SARIMAProcess[c,…]

represents a SARIMA process with constant c.

Details

SARIMAProcess is a discrete-time and continuous-state random process.
The SARIMA process is effectively the composition of an ARIMA process and a seasonal version of an ARIMA process.
The SARIMA 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 SARIMA process should have real coefficients a_i, b_j, α_i, β_j, and c, positive integer seasonality order s, non-negative integer integration orders d and δ, and a positive variance v.
An -dimensional vector SARIMA process should have real coefficient matrices a_i, b_j, α_i, and β_j of dimensions ×; vector c of length ; positive integer seasonality orders s_i or s; non-negative integer integration orders d_i or d, as well as δ_i or δ; and symmetric positive definite covariance matrix Σ of dimension ×.
The SARIMA process with zero constant has transfer function , where , , , , , and is an n-dimensional unit.
SARIMAProcess[p,d,q,{s,sp,sd,sq}] represents a SARIMA process with autoregressive and moving-average orders p and q and integration order d, their seasonal counterparts sp, sq, and sd, and seasonality s for use in EstimatedProcess and related functions.
SARIMAProcess can be used with such functions as CovarianceFunction, RandomFunction, and TimeSeriesForecast.

Examples

open all close all

Basic Examples (3)

Simulate a SARIMA process:

Wolfram Language code: sample = RandomFunction[SARIMAProcess[{.3}, 1, {.2}, {12, {.4}, 3, {.2}}, 1], {1, 10 ^ 2}]

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

Simulate SARIMA with seasonal trend:

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

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

Simulate SARIMA with linear trend:

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

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

Scope (28)

Basic Uses (9)

Simulate an ensemble of paths:

Wolfram Language code: data = RandomFunction[SARIMAProcess[1, {.5}, 0, {.3}, {12, {.5}, 1, {.1}}, 1], {50}, 4]

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

Simulate with given precision:

Wolfram Language code:

RandomFunction[SARIMAProcess[{2 / 10, 1 / 10}, 1, {2 / 7}, {12, {2 / 10}, 2, {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[SARIMAProcess[{}, 1, {}, {s, {}, 1, {}}, .1], {1, 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 process with given initial values:

Wolfram Language code: sproc[x_] := SARIMAProcess[0, {.4}, 0, {.3}, {4, {.6}, 1, {-.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)]

A process with both linear and seasonal trend:

Wolfram Language code: tproc[x_] := SARIMAProcess[.3, {.9}, 1, {.3}, {4, {1.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}};
SeedRandom[4];sample = RandomFunction[SARIMAProcess[{}, 1, {β}, {12, {α}, 1, {}}, Σ], {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[SARIMAProcess[{α}, {0, 1, 0}, {β}, {{3, 4, 6}, {α}, {1, 0, 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: sample = RandomFunction[SARIMAProcess[.3, {.1}, 0, {.2}, {4, {.3}, 1, {.4}}, .1], {1, 100}];

Find model parameters:

Wolfram Language code: eproc = EstimatedProcess[sample, SARIMAProcess[1, 1, {4, 1, 1}]]

Use TimeSeriesModel to automatically find orders:

Wolfram Language code: tsm = TimeSeriesModelFit[sample, "SARIMA"]

Wolfram Language code: tsm["BestFit"]

Forecast future values:

Wolfram Language code:

proc = SARIMAProcess[.3, {.1, .4}, 0, {-.3}, {4, {.2}, 2, {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 forecast 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 = SARIMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, 0, {{{.9, .3}, {-.3, .5}}}, {6, {{{-.7, .2}, {.3, .4}}}, {1, 0}, {{{.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}]

Stationarity and Invertibility (4)

Check if a time series is weakly stationary:

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

For a vector process:

Wolfram Language code:

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

Find conditions for a process to be weakly stationary:

Wolfram Language code:

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

Check if a time series is invertible:

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

Wolfram Language code: TimeSeriesInvertibility[proc]

Find its invertible representation:

Wolfram Language code: ToInvertibleTimeSeries[proc]

For a vector process:

Wolfram Language code:

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

Find invertibility conditions:

Wolfram Language code:

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

Estimation Methods (5)

The available methods for estimating a SARIMAProcess:

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

Wolfram Language code:

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

Wolfram Language code:

Grid[res = Table[{m, Quiet@EstimatedProcess[data, SARIMAProcess[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[1341];
data = RandomFunction[SARIMAProcess[.2, {.1}, 1, {.1}, {4, {.2}, 1, {}}, 1], {300}];

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Wolfram Language code:

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

Some relations between parameters are also permitted:

Wolfram Language code:

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

Maximum likelihood method allows the following solvers:

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

Wolfram Language code:

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

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

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

Wolfram Language code:

SeedRandom[214];
data = RandomFunction[SARIMAProcess[2, {}, 1, {.3}, {3, {.2}, 1, {}}, 1], {100}];

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Process Slice Properties (5)

Single time SliceDistribution:

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

Multiple time slice distributions:

Wolfram Language code: Mean@SARIMAProcess[1, {.2}, 1, {.3}, {4, {}, 1, {.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@SARIMAProcess[{α}, {1, 2}, {β}, {3, {γ}, {0, 1}, {δ}}, Σ][t]

First-order stationary probability density function:

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

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

Wolfram Language code:

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

Compute the expectation of an expression:

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

Calculate a probability:

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

Skewness and kurtosis:

Wolfram Language code: Skewness[SARIMAProcess[{.2}, 1, {.3}, {4, {}, 1, {.1}}, 1][t]]

Wolfram Language code: Kurtosis[SARIMAProcess[{.2}, 1, {.3}, {4, {}, 1, {.1}}, 1][t]]

Moment of order r:

Wolfram Language code: Moment[SARIMAProcess[{.2}, 1, {.3}, {4, {}, 1, {.1}}, 1][3], r]

Generating functions:

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

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

CentralMoment and its generating function:

Wolfram Language code: CentralMoment[SARIMAProcess[{.2}, 1, {.3}, {4, {}, 1, {.1}}, 1][3], r]

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

FactorialMoment and its generating function:

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

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

Cumulant and its generating function:

Wolfram Language code: Cumulant[SARIMAProcess[{.2}, 1, {.3}, {4, {}, 1, {.1}}, 1][3], r]

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

Representations (5)

Approximate with an ARProcess:

Wolfram Language code:

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

Compare random paths:

Wolfram Language code:

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

For a vector process:

Wolfram Language code:

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

Wolfram Language code: ARProcess[proc, 3]

Approximate with an MAProcess:

Wolfram Language code:

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

Compare random paths:

Wolfram Language code:

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

For a vector process:

Wolfram Language code:

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

Wolfram Language code: MAProcess[proc, 3]

Represent as equivalent ARMAProcess:

Wolfram Language code:

proc = SARIMAProcess[1, {1 / 3, 1 / 4}, 1, {1 / 2, 1 / 3}, {12, {1 / 3}, 1, {}}, 1];
aproc = ARMAProcess[proc]

TransferFunctionModel representation:

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

For a vector-valued process:

Wolfram Language code:

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

StateSpaceModel representation:

Wolfram Language code: StateSpaceModel[SARIMAProcess[{a}, 1, {b}, {4, {g}, 1, {h}}, 1]]

For a vector-valued process:

Wolfram Language code:

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

Applications (3)

Weather Data (1)

Average temperature on the first day of a month in Chicago, IL:

Wolfram Language code:

temp = TemporalData[TimeSeries, {{{-1.16, -0.98, 2.7, 12.08, 16.83, 20.78, 24.32, 24.92, 19.28, 13.34, 
    11.19, 3.3, 1.91, 2.02, 2.36, 10.27, 13.16, 22.26, 26.67, 24.55, 22.07, 11.81, 5.49, 0.88, 
    -3.71, -2.51, 4.42, 9.55, 13.82, 19.35, 23.29, 24.0 ...  {2012, 1, 1, 0, 0, 0.}, {1, "Month"}]}, 
  1, {"Discrete", 1}, {"Discrete", 1}, 1, 
  {MetaInformation -> {"Source" -> Defer[WeatherData["Chicago", "Temperature", 
        {{2001, 1, 1, 0, 0, 0.}, {2012, 1, 1, 0, 0, 0.}, "Month"}]]}}}, True, 10.];

Wolfram Language code: temp["Source"]

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

Fit a SARIMA process:

Wolfram Language code: eproc = EstimatedProcess[temp, SARIMAProcess[1, 0, 0, {12, 2, 1, 1}]]

Forecast the average temperatures on the first day of a month for the next three years:

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

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

Airline Passengers (2)

The following data contains the monthly total number of US international airline passengers (in thousands) from January, 1949 to December, 1960:

Wolfram Language code: passengers = ExampleData[{"Statistics", "InternationalAirlinePassengers"}, "TimeSeries"]

Wolfram Language code: DateListPlot[passengers, Joined -> True]

Find a time series model:

Wolfram Language code: tsm = TimeSeriesModelFit[passengers, {"SARIMA", 12}]

Wolfram Language code: tsm["Process"]

Forecast for the next five years:

Wolfram Language code:

k = 5;
start = "December 1st, 1960";

Wolfram Language code: forecastDates = DateRange[start, DatePlus[start, {k, "Year"}], "Month"];

Wolfram Language code: forecast = tsm /@ forecastDates;

Calculate prediction bands:

Wolfram Language code: bands = tsm["PredictionLimits"][#]& /@ forecastDates;

Plot a forecast within a 95% confidence interval:

Wolfram Language code:

pforecast = DateListPlot[{bands[[All, 1]], forecast, bands[[All, 2]]}, {start, Automatic, "Month"}, Joined -> True, Filling -> {1 -> {3}}, PlotStyle -> {Directive[{Dashed, Gray}], Automatic, Directive[{Dashed, Gray}]}]

Use a simulation to forecast the number of passengers:

Wolfram Language code: passengers = ExampleData[{"Statistics", "InternationalAirlinePassengers"}, "TimeSeries"]

The fitted model:

Wolfram Language code: tsm = TimeSeriesModelFit[passengers, {"SARIMA", 12}]

Simulate the next five years:

Wolfram Language code:

k = 5;
sim = RandomFunction[tsm, {0, 12 * k}, 100];

Wolfram Language code: psim = DateListPlot[sim, PlotStyle -> Directive[Opacity[.25]], Joined -> True, PlotRange -> All]

Find the mean function of the simulated paths:

Wolfram Language code: smean = TimeSeriesThread[Mean, sim]

Wolfram Language code: Show[psim, DateListPlot[smean, PlotStyle -> Black, Joined -> True]]

Properties & Relations (6)

SARIMAProcess is a generalization of an ARIMAProcess:

Wolfram Language code: TransferFunctionModel[SARIMAProcess[{1 / 2}, 2, {3}, {1, {1 / 3}, 3, {2}}, 1], z]

Wolfram Language code: TransferFunctionModel[ARIMAProcess[{5 / 6, -1 / 6}, 5, {5, 6}, 1], z]

Wolfram Language code: FullSimplify[% - %%]

SARIMAProcess is a generalization of a SARMAProcess:

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

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

Wolfram Language code: FullSimplify[% - %%]

SARIMAProcess is a generalization of an ARMAProcess:

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

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

Wolfram Language code: Simplify[% - %%]

SARIMAProcess is a generalization of an ARProcess:

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

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

Wolfram Language code: Simplify[% - %%]

SARIMAProcess is a generalization of an MAProcess:

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

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

Wolfram Language code: Simplify[% - %%]

Compare integration orders:

Wolfram Language code:

sarima1 = SARIMAProcess[{}, 0, {}, {4, {}, 1, {}}, 1];
sarima2 = SARIMAProcess[{}, 1, {}, {4, {}, 0, {}}, 1];
sarima3 = SARIMAProcess[{}, 1, {}, {4, {}, 1, {}}, 1];

Create random samples for each process:

Wolfram Language code: samples = Table[SeedRandom[3];RandomFunction[s, {100}], {s, {sarima1, sarima2, sarima3}}];

Plot samples with various integrations:

Wolfram Language code: ListLinePlot[samples, PlotLegends -> {seasonal, serial, both}]

Possible Issues (4)

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

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

Wolfram Language code: Correlation[SARIMAProcess[{1 / 2}, 1, {}, {3, {}, 1, {1 / 4}}, 1][{1, 4, 9}]]

Some properties are defined only for weakly stationary processes:

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

Use FindInstance to find a weakly stationary process:

Wolfram Language code: {inst} = FindInstance[a > 0 && WeakStationarity[SARIMAProcess[{a}, d, {.2}, {3, {.1}, sd, {.3}}, 1]], {a, d, sd}]

Wolfram Language code: CovarianceFunction[SARIMAProcess[{a}, d, {.2}, {3, {.1}, sd, {.3}}, 1] /. inst, h]

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

Wolfram Language code: var[t_] = Variance[SARIMAProcess[{.4}, 1, {}, {4, {.6}, 1, {}}, 1, {}][t]];

The negative result is incorrect:

Wolfram Language code: var[2]

Use numeric times:

Wolfram Language code: Variance[SARIMAProcess[{.4}, 1, {}, {4, {.6}, 1, {}}, 1, {}][2]]

Or use exact values of parameters:

Wolfram Language code: v[t_] = Variance[SARIMAProcess[{4 / 10}, 1, {}, {4, {6 / 10}, 1, {}}, 1, {}][t]];

Wolfram Language code: v[2]

Wolfram Language code: N[%]

ToInvertibleTimeSeries does not always exist:

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

There are zeros of TransferFunctionModel lying on the unit circle:

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

Wolfram Language code: Abs[%]

Neat Examples (2)

Simulate a three-dimensional SARIMAProcess starting at the origin:

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 = SARIMAProcess[{-A}, {1, 1, 1}, {B}, {12, {A}, {3, 3, 3}, {B}}, S, {{0, 0, 0}}];
data = RandomFunction[proc, {100}, k = 20]["ValueList"];

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

Simulate paths from a SARIMA process:

Wolfram Language code: SeedRandom[154];data = RandomFunction[SARIMAProcess[{.3}, 0, {.6}, {6, {.7}, 1, {.4}}, 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 -> 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, 10.5}], 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

SARIMAProcess

Details

Examples

Basic Examples (3)

Scope (28)

Basic Uses (9)

Stationarity and Invertibility (4)

Estimation Methods (5)

Process Slice Properties (5)

Representations (5)

Applications (3)

Weather Data (1)

Airline Passengers (2)

Properties & Relations (6)

Possible Issues (4)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

SARIMAProcess

Details

Examples

Basic Examples (3)

Scope (28)

Basic Uses (9)

Stationarity and Invertibility (4)

Estimation Methods (5)

Process Slice Properties (5)

Representations (5)

Applications (3)

Weather Data (1)

Airline Passengers (2)

Properties & Relations (6)

Possible Issues (4)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX