Wolfram Language & System Documentation Center

FARIMAProcess

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

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

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

represents a vector autoregressive fractionally integrated moving-average process (y₁(t),… ,y_n(t)) such that its (d,…,d) difference is a vector ARMAProcess.

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

represents a vector autoregressive fractionally integrated moving-average process (y₁(t),… ,y_n(t)) such that its (d₁,…,d_n) difference is a vector ARMAProcess.

FARIMAProcess

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

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

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

represents a vector autoregressive fractionally integrated moving-average process (y₁(t),… ,y_n(t)) such that its (d,…,d) difference is a vector ARMAProcess.

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

represents a vector autoregressive fractionally integrated moving-average process (y₁(t),… ,y_n(t)) such that its (d₁,…,d_n) difference is a vector ARMAProcess.

Details

FARIMAProcess is also known as ARFIMA or long-memory time series.
FARIMAProcess is a discrete-time and continuous-state random process.
The FARIMA process is described by the difference equations , where is the state output, is the white noise input, and is the shift operator.
The scalar FARIMA process has transfer function , where .
The vector FARIMA process has transfer matrix , where , and where is the × identity matrix.
A scalar FARIMA process should have real coefficients a_i, b_j, real integrating parameter d such that , and a positive variance v.
An -dimensional vector FARIMA process should have real coefficient matrices a_i and b_j of dimensions ×, real integrating parameters d_i such that or real integrating parameter d such that , and the covariance matrix Σ should be symmetric positive definite of dimensions ×.
FARIMAProcess[p,d,q] and FARIMAProcess[p,q] represent a FARIMA process of orders p and q with known or unknown integration order d for use in EstimatedProcess and related functions.
FARIMAProcess can be used with such functions as CovarianceFunction, RandomFunction, and TimeSeriesForecast.

Examples

open all close all

Basic Examples (3)

Simulate a FARIMA process:

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

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

Covariance function:

Wolfram Language code: CovarianceFunction[FARIMAProcess[{}, d, {}, σ^2], s, t]

Wolfram Language code:

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

Correlation function:

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

Partial correlation function:

Wolfram Language code: DiscretePlot[PartialCorrelationFunction[FARIMAProcess[{}, .2, {}, 1], h], {h, 1, 30}, ExtentSize -> 1 / 2]

Scope (25)

Basic Uses (8)

Simulate an ensemble of paths:

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

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

Simulate with given precision:

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

Simulate a first-order scalar process:

Wolfram Language code: sample[d_] := (SeedRandom[3];RandomFunction[FARIMAProcess[{.1}, d, {.2}, .1], {1, 2 10 ^ 2}]);

Sample paths for positive and negative values of the integration parameter:

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

Simulate a two-dimensional process:

Wolfram Language code:

α = {{.2, .1}, {-.3, .2}};
β = {{.2, .5}, {-.2, .9}};
δ = {.2, -.4};
Σ = {{1, 0}, {0, .3}};
sample = RandomFunction[FARIMAProcess[{α}, δ, {β}, Σ], {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}};
δ = {.2, .4, .3};
Σ = {{1, 0, 0}, {0, .3, 0}, {0, 0, .1}};
SeedRandom[4];sample = RandomFunction[FARIMAProcess[{α}, δ, {β}, Σ], {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[FARIMAProcess[{.3}, .2, {.5}, .1], {1, 10 ^ 3}];
eproc = EstimatedProcess[sample, FARIMAProcess[1, 1]]

Compare the sample covariance function with that of the estimated process:

Wolfram Language code:

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

Estimate integration order of the fractional noise:

Wolfram Language code:

sample = RandomFunction[FARIMAProcess[{}, .2, {}, .1], {1, 10 ^ 3}];
eproc = EstimatedProcess[sample, FARIMAProcess[0, d, 0], ProcessEstimator -> "MethodOfMoments"]

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

Wolfram Language code:

Show[ListPlot[CorrelationFunction[sample, {12}], Filling -> 0, PlotStyle -> {PointSize[Large], Orange}, PlotRange -> {0, 1}], DiscretePlot[CorrelationFunction[eproc, h], {h, 0, 12}, ExtentSize -> 1 / 2, 
	PlotRange -> {0, 1}]]

Forecast future values:

Wolfram Language code: proc = FARIMAProcess[{.7}, .4, {-.3}, .1];sample = RandomFunction[proc, {1, 10 ^ 2}];

Find the forecast for the next 20 steps:

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

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]

Covariance and Spectrum (5)

Closed-form correlation function for pure FARIMA:

Wolfram Language code: CorrelationFunction[FARIMAProcess[{}, d, {}, σ^2], h]

For FARIMA with autoregressive and moving-average components available numerically:

Wolfram Language code: Table[CorrelationFunction[FARIMAProcess[{1 / 3}, .2, {1, 2}, 1], h], {h, 0, 5}]

Partial correlation has closed form for special case:

Wolfram Language code: PartialCorrelationFunction[FARIMAProcess[{}, d, {}, σ^2], h]

Correlation matrix:

Wolfram Language code: Correlation[FARIMAProcess[{.1}, .3, {.4}, 1][{1, 2, 3}]]//MatrixForm

Special case of pure FARIMA:

Wolfram Language code: Correlation[FARIMAProcess[{}, d, {}, σ^2][{s, t}]]//MatrixForm

Covariance matrix:

Wolfram Language code: Covariance[FARIMAProcess[{.1}, .3, {.4}, 1][{1, 2, 3}]]//MatrixForm

Special case of pure FARIMA:

Wolfram Language code: Covariance[FARIMAProcess[{}, d, {}, σ^2][{s, t}]]//MatrixForm

Power spectral density:

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

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

Vector FARIMAProcess:

Wolfram Language code:

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

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[FARIMAProcess[{1, 2}, .2, {3}, 1]]

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

Find conditions for a process to be weakly stationary:

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

Find invertibility conditions:

Wolfram Language code: TimeSeriesInvertibility[FARIMAProcess[{Subscript[a, 1], Subscript[a, 2]}, d, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

Check if a time series is invertible:

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

Wolfram Language code: TimeSeriesInvertibility[proc]

Find its invertible representation:

Wolfram Language code: ToInvertibleTimeSeries[proc]

Estimation Methods (2)

The available methods for estimating a FARIMAProcess:

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

Wolfram Language code:

SeedRandom[111];
data = RandomFunction[FARIMAProcess[{.4}, -.4, {.3}, 1], {100}];

Wolfram Language code:

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

Compare log likelihoods:

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

The available methods for estimating fractional noise:

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

Wolfram Language code:

SeedRandom[11];
data = RandomFunction[FARIMAProcess[{}, -.4, {}, 1], {100}];

Wolfram Language code:

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

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

Wolfram Language code:

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

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Process Slice Properties (5)

Single time SliceDistribution:

Wolfram Language code: SliceDistribution[FARIMAProcess[{.1}, .2, {.4}, 1], t]

Multiple time slice distributions:

Wolfram Language code: SliceDistribution[FARIMAProcess[{.1}, .2, {.4}, 1], {s, s + 3}]

Wolfram Language code: SliceDistribution[FARIMAProcess[{.1}, .2, {.4}, 1], {1, 2, 3}]

First-order probability density function:

Wolfram Language code: pdf = PDF[FARIMAProcess[{.1}, .2, {.4}, 1][t], x]

Wolfram Language code: Plot[pdf, {x, -4, 4}, Filling -> Axis]

Stationary mean and variance:

Wolfram Language code: μ = Mean[FARIMAProcess[{.1}, .2, {.4}, 1][∞]]

Wolfram Language code: v = Variance[FARIMAProcess[{.1}, .2, {.4}, 1][∞]]

Compare with the density function of a normal distribution:

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

Wolfram Language code: FullSimplify[% - PDF[FARIMAProcess[{.1}, .2, {.4}, 1][∞], x]]

Compute the expectation of an expression:

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

Calculate a probability:

Wolfram Language code: Probability[x[t] < 6, xFARIMAProcess[{.1}, .2, {.4}, 1]]

Skewness and kurtosis:

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

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

Moment of order r:

Wolfram Language code: Moment[FARIMAProcess[{.1}, .2, {.4}, 1][t], r]

Generating functions:

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

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

CentralMoment and its generating function:

Wolfram Language code: CentralMoment[FARIMAProcess[{.1}, .2, {.4}, 1][t], r]

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

FactorialMoment has no closed form for symbolic order:

Wolfram Language code: FactorialMoment[FARIMAProcess[{.1}, .2, {.4}, 1][t], 3]

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

Cumulant and its generating function:

Wolfram Language code: Cumulant[FARIMAProcess[{.1}, .2, {.4}, 1][t], r]

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

Representations (1)

Approximate with an ARMAProcess:

Wolfram Language code: ARMAProcess[FARIMAProcess[{.2, .3}, .4, {.1}, 1], {5, 3}]

Approximate with an MAProcess:

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

Approximate with an ARProcess:

Wolfram Language code:

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

Compare random samples of the process and its approximation:

Wolfram Language code:

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

Applications (1)

Consider the time series of yearly minimal water levels of the Nile River for the years 622–1284:

Wolfram Language code:

NileFlow = TemporalData[TimeSeries, {{{1157, 1088, 1169, 1169, 984, 1322, 1178, 1103, 1211, 1292, 1124, 1171, 
    1133, 1227, 1142, 1216, 1259, 1299, 1232, 1117, 1155, 1232, 1083, 1020, 1394, 1196, 1148, 1083, 
    1189, 1133, 1034, 1157, 1034, 1097, 1299, 1 ... 1187, 1254, 1198, 1263, 1283, 1252, 1160, 
    1234, 1234, 1232, 1306, 1205, 1054, 1151, 1108, 1097}}, {{622, 1284, 1}}, 1, {"Continuous", 1}, 
  {"Discrete", 1}, 1, {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 
 10.1];

Wolfram Language code: ListLinePlot[NileFlow, Filling -> Axis, PlotRange -> {{622, 1284}, All}]

Centralize the data:

Wolfram Language code: cNileFlow = Standardize[NileFlow, Mean, 1&]

Find a FARIMA model:

Wolfram Language code: eproc = EstimatedProcess[cNileFlow, FARIMAProcess[{a}, d, {}, v]]

Forecast the future values:

Wolfram Language code: f = TimeSeriesForecast[eproc, cNileFlow, {1, 100}]

Adjust back to the mean level and proper time stamps:

Wolfram Language code: forecast = Mean[NileFlow] + f

Plot Nile minimum flow together with the hundred-year forecast:

Wolfram Language code: ListLinePlot[{NileFlow, forecast}, Filling -> Axis, PlotRange -> {{622, 1384}, All}]

Properties & Relations (5)

The correlations are summable for -1/2<d<0:

Wolfram Language code: Sum[CorrelationFunction[FARIMAProcess[{}, d, {}, 1], h], {h, 0, ∞}, Assumptions -> -1 / 2 < d < 0]

For 0<d<1/2, the sum of correlations diverges:

Wolfram Language code:

sums = Accumulate[CorrelationFunction[FARIMAProcess[{}, .3, {}, 1], {0, 1000}]];
ListPlot[sums]

FARIMAProcess has a long memory for positive integration orders:

Wolfram Language code: proc[d_] := FARIMAProcess[{}, d, {}, 1];

Wolfram Language code:

DiscretePlot[CovarianceFunction[proc[#], k], {k, 1, 50, 5}, ExtentSize -> 1 / 2, PlotRange -> {-.3, .6}, PlotLabel -> StringJoin["d = ", ToString[#]]]& /@ {-.3, -.2, .2, .3}

FARIMAProcess is a generalization of an ARMAProcess:

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

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

Wolfram Language code: % - %%

FARIMAProcess is a generalization of an ARProcess:

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

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

Wolfram Language code: % - %%

FARIMAProcess is a generalization of an MAProcess:

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

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

Wolfram Language code: % - %%

Possible Issues (2)

ToInvertibleTimeSeries does not always exist:

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

Method of moments is only supported for estimation of fractional noise:

Wolfram Language code: sample = RandomFunction[FARIMAProcess[{}, .2, {}, .1], {1, 10 ^ 3}];

Wolfram Language code: EstimatedProcess[sample, FARIMAProcess[{a}, d, {b}, v], ProcessEstimator -> "MethodOfMoments"]

Use the other solver:

Wolfram Language code: EstimatedProcess[sample, FARIMAProcess[{a}, d, {b}, v], ProcessEstimator -> Automatic]

Neat Examples (2)

Simulate a three-dimensional FARIMAProcess:

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}};
proc = FARIMAProcess[{A}, {.3, .2, .4}, {B}, S];
data = RandomFunction[proc, {100}, k = 3]["ValueList"];

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

Simulate paths from a FARIMA process:

Wolfram Language code: data = RandomFunction[FARIMAProcess[{.3}, .2, {.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, 10}], 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

FARIMAProcess

Details

Examples

Basic Examples (3)

Scope (25)

Basic Uses (8)

Covariance and Spectrum (5)

Stationarity and Invertibility (4)

Estimation Methods (2)

Process Slice Properties (5)

Representations (1)

Applications (1)

Properties & Relations (5)

Possible Issues (2)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

FARIMAProcess

Details

Examples

Basic Examples (3)

Scope (25)

Basic Uses (8)

Covariance and Spectrum (5)

Stationarity and Invertibility (4)

Estimation Methods (2)

Process Slice Properties (5)

Representations (1)

Applications (1)

Properties & Relations (5)

Possible Issues (2)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX