ARIMAProcess [{a1,…,ap},d,{b1,…,bq},v]
represents an autoregressive integrated moving-average process such that its d^(th) difference is a weakly stationary ARMAProcess [{a1,…,ap},{b1,…,bq},v].
ARIMAProcess [{a1,…,ap},d,{b1,…,bq},Σ]
represents a vector ARIMA process (y1(t),… ,yn(t)) such that its (d,…,d)^(th) difference is a vector weakly stationary ARMAProcess .
ARIMAProcess [{a1,…,ap},{d1,…,dn},{b1,…,bq},Σ]
represents a vector ARIMA process (y1(t),… ,yn(t)) such that its (d1,…,dn)^(th) difference is a vector weakly stationary ARMAProcess .
ARIMAProcess [{a1,…,ap},d,{b1,…,bq},v,init]
represents an ARIMA process with initial data init.
ARIMAProcess [c,…]
represents an ARIMA process with a constant c.
ARIMAProcess
ARIMAProcess [{a1,…,ap},d,{b1,…,bq},v]
represents an autoregressive integrated moving-average process such that its d^(th) difference is a weakly stationary ARMAProcess [{a1,…,ap},{b1,…,bq},v].
ARIMAProcess [{a1,…,ap},d,{b1,…,bq},Σ]
represents a vector ARIMA process (y1(t),… ,yn(t)) such that its (d,…,d)^(th) difference is a vector weakly stationary ARMAProcess .
ARIMAProcess [{a1,…,ap},{d1,…,dn},{b1,…,bq},Σ]
represents a vector ARIMA process (y1(t),… ,yn(t)) such that its (d1,…,dn)^(th) difference is a vector weakly stationary ARMAProcess .
ARIMAProcess [{a1,…,ap},d,{b1,…,bq},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 ai, bj, and c, non-negative integer integration order d, and a positive variance v.
- An -dimensional vector ARIMA process should have real coefficient matrices ai and bj of dimensions ×, real vector c of length , integer non-negative integrating orders di 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 allBasic Examples (2)
Simulate an ARIMA process with a linear trend:
SeedRandom[234];sample = RandomFunction[ARIMAProcess[{-.1}, 1, {.2}, .1], {1, 10 ^ 2}]ListPlot[sample, Filling -> Axis]Simulate an ARIMA process with a quadratic trend:
SeedRandom[19];sample = RandomFunction[ARIMAProcess[.2, {-.6}, 2, {.8}, .1], {1, 50}]ListPlot[sample, Filling -> Axis]Scope (25)
Basic Uses (9)
Simulate an ensemble of paths:
data = RandomFunction[ARIMAProcess[1, {.5}, 1, {.7}, 1], {30}, 4]ListLinePlot[data, Filling -> Axis]Simulate with given precision:
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:
sproc[x_] := ARIMAProcess[0, {.6}, 1, {.3}, 1, {x}];pts = {-4, 0, 4, 8};samples = Table[SeedRandom[4];RandomFunction[sproc[x], {100}], {x, pts}];ListLinePlot[samples, DataRange -> {0, 12}, PlotLegends -> (StringJoin["x = ", ToString[#]]& /@ pts)]In the presence of a nonzero constant:
tproc[x_] := ARIMAProcess[0.2, {1.1}, 1, {.3}, 1, {x}];tsamples = Table[SeedRandom[4];RandomFunction[tproc[x], {30}], {x, pts}];ListLinePlot[tsamples, DataRange -> {0, 12}, PlotLegends -> (StringJoin["x = ", ToString[#]]& /@ pts)]Simulate a two-dimensional process:
α = {{.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:
s = TimeSeries[sample, ResamplingMethod -> Automatic];
f = s["PathFunction"];
g[t_ ? NumericQ] := f[t]The color of the path is the function of time:
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:
gg[t_ ? NumericQ] := Join[{t}, f[t]]Color of the path is the function of time:
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:
α = {{.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:
s = TimeSeries[sample, ResamplingMethod -> Automatic];
f = s["PathFunction"];
g[t_ ? NumericQ] := f[t]The color of the path is the function of time:
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:
SeedRandom[314];sample = RandomFunction[ARIMAProcess[.3, {.2}, 1, {.3}, .1], {1, 1000}];Find model parameters:
eproc = EstimatedProcess[sample, ARIMAProcess[1, d, 1]]Use TimeSeriesModel to automatically find orders:
tsm = TimeSeriesModelFit[sample]tsm["Process"]Estimate a vector process:
proc = ARIMAProcess[{1, 2}, {{{.2, .1}, {.5, .3}}}, {1, 0}, {{{.9, .2}, {-.5, -.2}}}, {{1, .3}, {.3, .5}}];
data = RandomFunction[proc, {10 ^ 2}];eproc = EstimatedProcess[data, ARIMAProcess[1, {1, 0}, 1]]Forecast future values:
proc = ARIMAProcess[.4, {.3}, 2, {-.5}, 1];
sample = RandomFunction[proc, {1, 10 ^ 2}];
forecast = TimeSeriesForecast[proc, sample, {15}]Show forecast path:
forecast["Path"]Plot the data and the forecasted values:
ListLinePlot[{sample, forecast}, InterpolationOrder -> 0, Filling -> Axis]Find a forecast for a vector-valued time series process:
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:
forecast = TimeSeriesForecast[proc, data, {10}]Plot the data and the forecast for each component:
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:
WeakStationarity[ARIMAProcess[c, {Subscript[a, 1], Subscript[a, 2]}, d, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]Find invertibility conditions:
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 :
methods = {Automatic, "MethodOfMoments", "MaximumConditionalLikelihood", "MaximumLikelihood", "SpectralEstimator"};SeedRandom[3];
data = RandomFunction[ARIMAProcess[.3, {.4}, 1, {.3}, 1], {100}];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:
solvers = {Automatic, "FindRoot", "NSolve"};SeedRandom[3];
data = RandomFunction[ARIMAProcess[{.4}, 1, {.3}, 1], {100}];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:
EstimatedProcess[data, ARIMAProcess[c, {.4, b}, d, {m}, v], ProcessEstimator -> "MethodOfMoments"]Some relations between parameters are also permitted:
EstimatedProcess[data, ARIMAProcess[c, {a * b, b}, d, {a}, v], ProcessEstimator -> "MethodOfMoments"]Maximum conditional likelihood method allows the following solvers:
solvers = {Automatic, "FindMaximum", "NMaximize"};SeedRandom[3];
data = RandomFunction[ARIMAProcess[2, {.4}, 1, {.3}, 1], {100}];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:
EstimatedProcess[data, ARIMAProcess[c, {.1, b}, d, {m}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]Some relations between parameters are also permitted:
EstimatedProcess[data, ARIMAProcess[c, {b, b}, d, {m}, v], ProcessEstimator -> "MaximumConditionalLikelihood"]Maximum likelihood method allows the following solvers:
solvers = {Automatic, "FindMaximum", "NMaximize"};SeedRandom[3];
data = RandomFunction[ARIMAProcess[2, {.4, .2}, 1, {.3}, 1], {100}];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:
EstimatedProcess[data, ARIMAProcess[c, {.1, b}, d, {m}, v], ProcessEstimator -> "MaximumLikelihood"]Some relations between parameters are also permitted:
EstimatedProcess[data, ARIMAProcess[c, {b, b}, d, {m}, v], ProcessEstimator -> "MaximumLikelihood"]Spectral estimator allows to specify windows used for PowerSpectralDensity calculation:
SeedRandom[3];
data = RandomFunction[ARIMAProcess[2, {.4, .2}, 1, {.3}, 1], {100}];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:
solvers = {Automatic, "FindMinimum", "NMinimize"};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:
EstimatedProcess[data, ARIMAProcess[c, {.1, b}, d, {m}, v], ProcessEstimator -> "SpectralEstimator"]Some relations between parameters are also permitted:
EstimatedProcess[data, ARIMAProcess[c, {b, b}, d, {m}, v], ProcessEstimator -> "SpectralEstimator"]Process Slice Properties (5)
Single time SliceDistribution :
SliceDistribution[ARIMAProcess[c, {a}, d, {b}, σ ^ 2], t]//MeanMultiple time slice distributions:
SliceDistribution[ARIMAProcess[1.2, {.2}, 1, {.3}, 1, {}], {1, 3}]//CovarianceSliceDistribution[ARIMAProcess[1, {.2}, 1, {.3}, 1], {1, 2, 3}]//MeanSlice distribution of a vector-valued time series:
α = {{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]//MeanFirst-order probability density function:
pdf[t_] = PDF[ARIMAProcess[{1 / 4}, 1, {1 / 3}, 1, {5}][t], x]//Simplifytimes = {1, 2, 3, 4};Plot[Evaluate@Table[pdf[t], {t, times}], {x, -10, 12}, Filling -> Axis, PlotLegends -> (StringJoin["t = ", ToString[#]]& /@ times)]Compute the expectation of an expression:
Expectation[x[t] ^ 2, xARIMAProcess[c, {a}, 1, {b}, σ^2], Assumptions -> t > 0]//SimplifyCalculate the probability of an expression:
Probability[x[t] < 6, xARIMAProcess[c, {a}, 1, {b}, σ^2], Assumptions -> t > 0]//SimplifySkewness and kurtosis are constant:
Skewness[ARMAProcess[c, {a}, {b}, σ^2][t]]Kurtosis[ARMAProcess[c, {a}, {b}, σ^2][t]]Moment of order r:
Table[Moment[ARMAProcess[c, {a}, {b}, σ^2][t], r], {r, 0, 4}]//TogetherGenerating functions:
CharacteristicFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]MomentGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]CentralMoment and its generating function:
Table[CentralMoment[ARMAProcess[c, {a}, {b}, σ^2][t], r], {r, 0, 4}]CentralMomentGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]FactorialMoment has no closed form for symbolic order:
Table[FactorialMoment[ARMAProcess[c, {a}, {b}, σ^2][t], r]//Simplify, {r, 0, 3}]FactorialMomentGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]Cumulant and its generating function:
Table[Cumulant[ARMAProcess[c, {a}, {b}, σ^2][t], r], {r, 0, 4}]CumulantGeneratingFunction[ARMAProcess[c, {a}, {b}, σ^2][t], w]Representations (4)
Approximate with an MA process:
MAProcess[ARIMAProcess[.4, {.2, .3}, 4, {.1}, 1, {}], 5]Approximate with an AR process:
proc = ARIMAProcess[{.2, .3}, 1, {.5}, 1, {}];
aproc = ARProcess[proc, 5]Compare sample paths:
SeedRandom[13];sample = RandomFunction[proc, {100}];
SeedRandom[13];asample = RandomFunction[aproc, {100}];
ListLinePlot[{sample, asample}, PlotLegends -> {"ARIMA", "AR"}]Approximate a vector process:
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:
proc = ARIMAProcess[{a}, 2, {b}, 1];
newproc = ARMAProcess[proc]It is usually not weakly stationary:
WeakStationarity[newproc]//SimplifyTransferFunctionModel representation:
TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 2, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]For a vector-valued process:
α = {{.2, .3}, {0, .1}};
β = {{-.3, 0}, {.5, -.4}};
δ = {1, 0};
Σ = {{1, 0}, {0, 1}};
TransferFunctionModel[ARIMAProcess[{α}, δ, {β}, Σ], z]StateSpaceModel representation:
StateSpaceModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 2, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]For a vector-valued process:
α = {{.2, .3}, {0, .1}};
β = {{-.3, .9}, {.5, -.4}};
δ = {1, 2};
Σ = {{1, 0}, {0, 1}};
StateSpaceModel[ARIMAProcess[{α}, δ, {β}, Σ]]Applications (3)
Forecast annual revenue of commercial airlines:
ExampleData[{"Statistics", "AirlinePassengerMiles"}, "LongDescription"]revenue = ExampleData[{"Statistics", "AirlinePassengerMiles"}, "TimeSeries"]ListLinePlot[revenue, InterpolationOrder -> 0, Filling -> Axis]Data has a linear trend that can be confirmed using UnitRootTest :
UnitRootTest[revenue, Automatic, "TestConclusion"]Fit an ARIMA model to the time series:
eproc = EstimatedProcess[revenue, ARIMAProcess[2, 1, 2]]Find the forecast for 10 years ahead:
forecast = TimeSeriesForecast[eproc, revenue, {10}]ListLinePlot[{revenue, forecast}, InterpolationOrder -> 0, Filling -> Axis]Global yearly mean temperature compared to 1951–1980 baseline:
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.];ListPlot[gmt, Joined -> True, AxesOrigin -> {1880, -.5}]Find order of integration with UnitRootTest :
Table[UnitRootTest[Differences[gmt, k]], {k, 0, 3}]Estimate an ARIMA with integration order equal to 1:
eproc = EstimatedProcess[gmt, ARIMAProcess[1, 1, 1]]Find the forecast for the next 20 years:
forecast = TimeSeriesForecast[eproc, gmt, {20}]ListPlot[{gmt, forecast}, Joined -> True, AxesOrigin -> {1880, -.5}]Forecast stock prices:
data = FinancialData["SBUX", "Close", {{2013, 1, 1}, {2013, 12, 1}, "Week"}];Check if regularly sampled:
RegularlySampledQ[data]Resample to obtain regularly sampled time series:
stocks = TimeSeriesResample[data]RegularlySampledQ[stocks]Plot the prices:
DateListPlot[stocks, Filling -> Axis]Fit an ARIMA process:
eproc = EstimatedProcess[stocks, ARIMAProcess[3, 1, 0], ProcessEstimator -> "MaximumConditionalLikelihood"]Forecast to the next half a year:
forecast = TimeSeriesForecast[eproc, stocks, {26}];DateListPlot[{stocks, forecast}, Filling -> Axis]Properties & Relations (4)
ARIMAProcess is a generalization of an ARMAProcess :
TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 0, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]TransferFunctionModel[ARMAProcess[{Subscript[a, 1], Subscript[a, 2]}, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]% - %%ARIMAProcess is a generalization of an ARProcess :
TransferFunctionModel[ARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, 0, {}, σ^2], z]TransferFunctionModel[ARProcess[{Subscript[a, 1], Subscript[a, 2]}, σ^2], z]% - %%ARIMAProcess is a generalization of an MAProcess :
TransferFunctionModel[ARIMAProcess[{}, 0, {Subscript[b, 1], Subscript[b, 2]}, σ^2], z]TransferFunctionModel[MAProcess[{Subscript[b, 1], Subscript[b, 2]}, σ^2], z]% - %%ARIMA process follows WienerProcess in discrete steps:
wiener = WienerProcess[];
arima = ARIMAProcess[{}, 1, {}, 1, {}];Single time slice properties:
Mean /@ {wiener[t], arima[t]}PDF[#, x]& /@ {wiener[t + 1], arima[t]}//Simplify[#, t > 0]&Mixed moments:
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:
Correlation[ARIMAProcess[{1 / 2}, 1, {1 / 4}, 1][{Subscript[t, 1], Subscript[t, 2], Subscript[t, 3]}]]Correlation[ARIMAProcess[{1 / 2}, 1, {1 / 4}, 1][{1, 4, 8}]]Some properties are defined only for weakly stationary processes:
CovarianceFunction[ARIMAProcess[{2, .3}, 1, {.3, .2}, σ^2], h]Use FindInstance to find a weakly stationary process:
FindInstance[a > 0 && WeakStationarity[ARIMAProcess[{a, .2}, d, {.3, .2}, σ^2]], {a, d}]CovarianceFunction[ARIMAProcess[{.4, .2}, 0, {.3, .2}, σ^2], h]Slice distribution properties with inexact parameters may be ill-conditioned for symbolic times:
var[t_] = Variance[ARIMAProcess[{.4}, 10, {-.5}, 1, {}][t]];The negative result is incorrect:
var[2]Use numeric times:
Variance[ARIMAProcess[{.4}, 10, {-.5}, 1, {}][2]]Or use exact values of parameters:
v[t_] = Variance[ARIMAProcess[{4 / 10}, 10, {-1 / 2}, 1, {}][t]];v[2]N[%]ToInvertibleTimeSeries does not always exist:
ToInvertibleTimeSeries[ARIMAProcess[{.2}, 1, {.3, 1}, .2]]There are zeros of the TransferFunctionModel on the unit circle:
TransferFunctionZeros[TransferFunctionModel[ARIMAProcess[{.2}, 1, {.3, 1}, .2]]]Abs[%]The method of moments may not find a solution in estimation:
SeedRandom[4];
data = RandomFunction[ARIMAProcess[2, {.4}, 1, {.3}, 1], {100}];EstimatedProcess[data, ARIMAProcess[c, {.4, b}, 1, {1}, v], ProcessEstimator -> {"MethodOfMoments", Method -> "NSolve"}]Use the "FindRoot" method instead:
EstimatedProcess[data, ARIMAProcess[c, {.4, a}, 1, {b}, v], ProcessEstimator -> {"MethodOfMoments", Method -> "FindRoot"}]Neat Examples (2)
Simulate a three-dimensional ARIMAProcess :
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"];Graphics3D@Table[{ColorData["SolarColors"][RandomReal[]], Tube@Line@data[[i]]}, {i, k}]Simulate paths from an ARIMA process:
SeedRandom[154];data = RandomFunction[ARIMAProcess[.4, {.3}, 1, {.6}, 1], {50}, 300];Take a slice at 50 and visualize its distribution:
sd = data["SliceData", 50];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:
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}}]Related Guides
Text
Wolfram Research (2012), ARIMAProcess, Wolfram Language function, https://reference.wolfram.com/language/ref/ARIMAProcess.html (updated 2014).
CMS
Wolfram Language. 2012. "ARIMAProcess." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014. https://reference.wolfram.com/language/ref/ARIMAProcess.html.
APA
Wolfram Language. (2012). ARIMAProcess. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ARIMAProcess.html
BibTeX
@misc{reference.wolfram_2026_arimaprocess, author="Wolfram Research", title="{ARIMAProcess}", year="2014", howpublished="\url{https://reference.wolfram.com/language/ref/ARIMAProcess.html}", note=[Accessed: 13-August-2026]}
BibLaTeX
@online{reference.wolfram_2026_arimaprocess, organization={Wolfram Research}, title={ARIMAProcess}, year={2014}, url={https://reference.wolfram.com/language/ref/ARIMAProcess.html}, note=[Accessed: 13-August-2026]}