Wolfram Language & System Documentation Center

MAProcess

MAProcess[{b₁,…,b_q},v]

represents a moving-average process of order q with normal white noise variance v.

MAProcess[{b₁,…,b_q},Σ]

represents a vector MA process with multinormal white noise covariance matrix Σ.

MAProcess[{b₁,…,b_q},v,init]

represents an MA process with initial data init.

MAProcess[c,…]

represents an MA process with a constant c.

MAProcess

MAProcess[{b₁,…,b_q},v]

represents a moving-average process of order q with normal white noise variance v.

MAProcess[{b₁,…,b_q},Σ]

represents a vector MA process with multinormal white noise covariance matrix Σ.

MAProcess[{b₁,…,b_q},v,init]

represents an MA process with initial data init.

MAProcess[c,…]

represents an MA process with a constant c.

Details

MAProcess is also known as a finite impulse response (FIR) filter.
MAProcess is a discrete-time and continuous-state random process.
The MA process is described by the difference equation , where is the state output, is white noise input, is the shift operator, and the constant c is taken to be zero if not specified.
The initial data init can be given as a list {…,y[-2],y[-1]} or a single-path TemporalData object with time stamps understood as {…,-2,-1}.
A scalar MA process should have real coefficients b_i and c, and a positive variance v.
An -dimensional vector MA process should have real coefficient matrices b_i of dimensions ×, real vector c of length , and the covariance matrix Σ should be symmetric positive definite of dimensions ×.
The MA process with zero constant has transfer function where:
scalar process

vector process; is the × identity matrix
MAProcess[tproc,q] for a time series process tproc gives an MA process of order q such that the series expansions about zero of the corresponding transfer functions agree up to degree q.
Possible time series processes tproc include ARProcess, ARMAProcess, and SARIMAProcess.
MAProcess[q] represents a moving-average process of order q for use in EstimatedProcess and related functions.
MAProcess can be used with such functions as CovarianceFunction, RandomFunction, and TimeSeriesForecast.

Examples

open all close all

Basic Examples (3)

Simulate an MA process:

Wolfram Language code: sample = RandomFunction[MAProcess[2, {.3, -.5}, 1], {0, 100}]

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

Covariance function:

Wolfram Language code: CovarianceFunction[MAProcess[{Subscript[b, 1], Subscript[b, 2]}, σ^2], s, t]

Wolfram Language code:

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

Correlation function:

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

Partial correlation function:

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

Scope (37)

Basic Uses (11)

Simulate an ensemble of paths:

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

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

Simulate with given precision:

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

Simulate a first-order scalar process:

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

Sample paths for positive and negative values of the parameter:

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

Initial values do not influence the process values:

Wolfram Language code: sproc[x_] := MAProcess[0, {.6, .3}, 1, {x}];

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

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

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

Simulate a two-dimensional process:

Wolfram Language code:

β = {{.2, .1}, {-.3, .2}};
Σ = {{1, 0}, {0, .3}};
SeedRandom[4];
sample = RandomFunction[MAProcess[{β}, Σ], {1, 100}];

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[MAProcess[{α, β}, Σ], {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}]

Estimation:

Wolfram Language code:

sample = RandomFunction[MAProcess[{.2, -.6, .8}, 1], {1, 300}];
eproc = EstimatedProcess[sample, MAProcess[3]]

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

Wolfram Language code:

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

Use TimeSeriesModel to automatically find orders:

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

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

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

Wolfram Language code:

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

Find maximum likelihood estimator:

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

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

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

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

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

Wolfram Language code:

ContourPlot[LogLikelihood[MAProcess[1, {x, y}, 1], data], {x, 0.1, .8}, {y, 0.1, .8}, Epilog -> {Red, Point[{a, b} /. res]}, PlotPoints -> 2]

Estimate a vector moving-average process:

Wolfram Language code:

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

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

Compare covariance functions for each component:

Wolfram Language code:

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

Forecast future values:

Wolfram Language code:

proc = MAProcess[{5, 6, 5}, .1];
sample = RandomFunction[proc, {1, 50}];
forecast = TimeSeriesForecast[proc, sample, {10}]

Show the forecast path:

Wolfram Language code: forecast["Path"]

Plot the data and the forecasted values:

Wolfram Language code: ListLinePlot[{sample, forecast}, InterpolationOrder -> 0, Filling -> Axis]

Find a forecast for a vector-valued time series process:

Wolfram Language code:

proc = MAProcess[{{{.3, .1}, {.9, .1}}, {{.2, -.4}, {.5, -.3}}}, {{1, .2}, {.2, .6}}];
data = RandomFunction[proc, {0, 15}];

Find the forecast for the next 10 steps:

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

Plot the data and the forecast for each component:

Wolfram Language code:

Row@Table[ListLinePlot[#["PathComponent", j]& /@ {data, forecast}, PlotLabel -> Subscript[x, j], PlotLegends -> {"data", "forecast"}], {j, 1, 2}]

Covariance and Spectrum (6)

Correlation function exists in closed form:

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

Wolfram Language code:

CorrelationFunction[MAProcess[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3], Subscript[b, 4]}, σ^2], h]//PiecewiseExpand

Closed form of the partial correlation function for the first order:

Wolfram Language code: PartialCorrelationFunction[MAProcess[{b}, σ^2], h]

Covariance matrix:

Wolfram Language code: Covariance[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][{1, 2, 5}]]//MatrixForm

Covariance matrix of an MAProcess is symmetric multidiagonal:

Wolfram Language code: Covariance[MAProcess[{1 / 3, 1 / 4, 1 / 3}, 1][Range[8]]]//MatrixForm

Correlation matrix:

Wolfram Language code: Correlation[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][{1, 2, 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}};
β = {{Subscript[b, 1], 0}, {0, Subscript[b, 2]}};

Wolfram Language code: CovarianceFunction[MAProcess[{β}, Σ], h]//TraditionalForm

Power spectral density:

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

Wolfram Language code: PowerSpectralDensity[MAProcess[{b}, σ^2], w]

Vector MAProcess:

Wolfram Language code:

a = {{1 / 10, 0}, {1 / 3, 0}};
Σ = {{1, 1 / 3}, {1 / 3, 1}};
proc = MAProcess[{a}, Σ];

Wolfram Language code:

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

Stationarity and Invertibility (4)

MAProcess is weakly stationary for any choice of parameters:

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

For a vector process:

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

Check if a time series is invertible:

Wolfram Language code: proc = MAProcess[-2, {1, 2}, 1];

Wolfram Language code: TimeSeriesInvertibility[proc]

For a vector process:

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

Find invertible representation for a moving-average process:

Wolfram Language code:

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

Wolfram Language code: iproc = ToInvertibleTimeSeries[proc]

The moments are being conserved:

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

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

Find invertibility conditions:

Wolfram Language code: cond2D = TimeSeriesInvertibility[MAProcess[{Subscript[b, 1], Subscript[b, 2]}, σ^2]]

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

Find conditions for higher order:

Wolfram Language code: cond3D = TimeSeriesInvertibility[MAProcess[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}, σ^2]]

Wolfram Language code:

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

Estimation Methods (6)

The available methods for estimating an MAProcess:

Wolfram Language code:

methods = {Automatic, "MethodOfMoments", "MaximumConditionalLikelihood", "MaximumLikelihood", "MinimumPredictionError", "SpectralEstimator"};

Wolfram Language code:

SeedRandom[14];
data = RandomFunction[MAProcess[2, {.4, .2}, 1], {50}];

Wolfram Language code:

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

Compare log likelihoods:

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

Method of moments allows following solvers:

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

Wolfram Language code:

SeedRandom[4];
data = RandomFunction[MAProcess[2, {.4, .2}, 1], {100}];

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Maximum conditional likelihood method allows following solvers:

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

Wolfram Language code:

SeedRandom[4];
data = RandomFunction[MAProcess[2, {.4, .2}, 1], {100}];

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Maximum likelihood method allows following solvers:

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

Wolfram Language code:

SeedRandom[4];
data = RandomFunction[MAProcess[2, {.4, .2}, 1], {100}];

Wolfram Language code:

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

Some relations between parameters are also permitted:

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

Spectral estimator allows to specify windows used for PowerSpectralDensity calculation:

Wolfram Language code:

SeedRandom[4];
data = RandomFunction[MAProcess[2, {.4, .2}, 1], {100}];

Wolfram Language code:

Grid[Table[{m, EstimatedProcess[data, MAProcess[2], 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, MAProcess[2], 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, MAProcess[c, {a, .5}, v], ProcessEstimator -> "SpectralEstimator"]

Some relations between parameters are also permitted:

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

Minimum prediction method:

Wolfram Language code:

SeedRandom[4];
data = RandomFunction[MAProcess[2, {.4, .2}, 1], {100}];

Wolfram Language code: EstimatedProcess[data, MAProcess[2], ProcessEstimator -> "MinimumPredictionError"]

This method allows for fixed parameters:

Wolfram Language code: EstimatedProcess[data, MAProcess[c, {b, .1}, v], ProcessEstimator -> "MinimumPredictionError"]

Process Slice Properties (5)

Single time SliceDistribution:

Wolfram Language code: SliceDistribution[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ ^ 2], t]//PDF[#, x]&

Multiple time slice distributions:

Wolfram Language code: SliceDistribution[MAProcess[-.3, {.2, .3}, 1], {s, s + 3}]//Mean

Wolfram Language code: SliceDistribution[MAProcess[1, {.2, .3}, 1], {1, 2, 3}]//Covariance

Slice distribution of a vector-valued time series:

Wolfram Language code:

β = {{Subscript[b, 1], 0}, {0, Subscript[b, 2]}};
Σ = {{Subscript[σ, 1]^2, ρ Subscript[σ, 1]Subscript[σ, 2]}, {ρ Subscript[σ, 1]Subscript[σ, 2], Subscript[σ, 2]^2}};
MAProcess[{Subscript[c, 1], Subscript[c, 2]}, {β}, Σ][t]//Mean

First-order probability density function:

Wolfram Language code: pdf = PDF[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ ^ 2, {}][t], x]//PiecewiseExpand//Simplify

Wolfram Language code:

Plot[Evaluate@Table[pdf /. {c -> 1, Subscript[b, 1] -> 1 / 2, Subscript[b, 2] -> 2 / 3, σ -> 1}, {t, 1, 3}], {x, -3, 5}, Filling -> Axis, PlotLegends -> {"t = 1", "t = 2", "t = 3"}]

Stationary mean and variance:

Wolfram Language code: μ = Mean[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][∞]]

Wolfram Language code: v = Variance[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][∞]]

Compare with the density function of a normal distribution:

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

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

Compute the expectation of an expression:

Wolfram Language code: Expectation[x[t] ^ 2, xMAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2]]

Calculate a probability:

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

Skewness and kurtosis are constant:

Wolfram Language code: Skewness[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t]]

Wolfram Language code: Kurtosis[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t]]

Moment of order r:

Wolfram Language code: Table[Moment[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], r], {r, 0, 4}]//Together

Generating functions:

Wolfram Language code: CharacteristicFunction[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], w]

Wolfram Language code: MomentGeneratingFunction[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], w]

CentralMoment and its generating function:

Wolfram Language code: Table[CentralMoment[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], r], {r, 0, 4}]

Wolfram Language code: CentralMomentGeneratingFunction[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], w]

FactorialMoment has no closed form for symbolic order:

Wolfram Language code: Table[FactorialMoment[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], r], {r, 0, 4}]

Wolfram Language code: FactorialMomentGeneratingFunction[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], w]

Cumulant and its generating function:

Wolfram Language code: Table[Cumulant[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], r], {r, 0, 4}]

Wolfram Language code: CumulantGeneratingFunction[MAProcess[c, {Subscript[b, 1], Subscript[b, 2]}, σ^2][t], w]

Representations (5)

Approximate an AR process with an MA process of order 5:

Wolfram Language code:

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

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

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

Approximate a vector process:

Wolfram Language code:

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

Approximate an ARMA process with an MA process:

Wolfram Language code:

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

Wolfram Language code:

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

Compare sample paths:

Wolfram Language code:

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

Approximate a SARIMA process with an MA process:

Wolfram Language code:

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

Compare sample paths:

Wolfram Language code:

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

TransferFunctionModel representation:

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

For a vector-valued process:

Wolfram Language code:

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

StateSpaceModel representation:

Wolfram Language code: StateSpaceModel[MAProcess[{a, b, c}, σ^2]]

For a vector-valued process:

Wolfram Language code:

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

Applications (1)

Consider the following time series data and determine whether it is adequately modeled by an MAProcess:

Wolfram Language code:

data = TemporalData[TimeSeries, {{{0.359431952050076, 0.1866539833635727, -0.36641699166840047, 
    -0.9169379467434212, -0.4466564157696784, 0.48031513860278385, -0.2340607103049802, 
    -0.2730210796929566, -0.36790928767225356, -0.5061302867683104, - ... 771629790362, 
    -0.6105816570028402, -0.05614428001553993, -0.3663737673270948, 0.387029925025942}}, 
  {{1, 5000, 1}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 10.1];

Wolfram Language code: ListPlot[data, PlotStyle -> PointSize[Tiny]]

The correlation function drops off after lag 3. This is evidence of an MAProcess[3]:

Wolfram Language code:

ListPlot[CorrelationFunction[data, {1, 20}], PlotRange -> All, Filling -> 0, AxesOrigin -> {0, 0}, PlotStyle -> PointSize[Medium]]

The partial correlation alternates and dampens slowly, which also indicates an MAProcess:

Wolfram Language code:

ListPlot[PartialCorrelationFunction[data, {1, 20}], PlotRange -> All, Filling -> 0, AxesOrigin -> {0, 0}, PlotStyle -> PointSize[Medium]]

Fit an MAProcess[3] model to the data:

Wolfram Language code: model = EstimatedProcess[data, MAProcess[3]]

Find residuals between the data and the model:

Wolfram Language code: tsm = TimeSeriesModelFit[data, model]

Wolfram Language code: residuals = tsm["FitResiduals"];

Wolfram Language code: Histogram[residuals["Values"]]

Test if residuals are normal white noise:

Wolfram Language code: DistributionFitTest[residuals, Automatic, "TestDataTable"]

Wolfram Language code: DistributionFitTest[residuals, Automatic, "ShortTestConclusion"]

Properties & Relations (5)

MAProcess is a special case of an ARMAProcess:

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

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

Wolfram Language code: % - %%

MAProcess is a special case of an ARIMAProcess:

Wolfram Language code: TransferFunctionModel[ARIMAProcess[{}, 0, {a, b, c}, σ^2], z]

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

Wolfram Language code: % - %%

MAProcess is a special case of a FARIMAProcess:

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

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

Wolfram Language code: % - %%

MAProcess is a special case of a SARMAProcess:

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

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

Wolfram Language code: Simplify[% - %%]

MAProcess is a special case of a SARIMAProcess:

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

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

Wolfram Language code: Simplify[% - %%]

Possible Issues (3)

ToInvertibleTimeSeries does not always exist:

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

There are zeros of the TransferFunctionModel on the unit circle:

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

Wolfram Language code: Abs[%]

The method of moments may not find a solution in estimation:

Wolfram Language code:

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

Wolfram Language code: EstimatedProcess[data, MAProcess[c, {b, Exp[b]}, v], ProcessEstimator -> {"MethodOfMoments", Method -> "NSolve"}]

Use a different solver:

Wolfram Language code:

EstimatedProcess[data, MAProcess[c, {b, Exp[b]}, v], ProcessEstimator -> {"MethodOfMoments", {Method -> "FindRoot", MaxIterations -> 500}}]

Minimum prediction error estimation method does not allow repeated parameters:

Wolfram Language code:

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

Wolfram Language code: EstimatedProcess[data, MAProcess[c, {b, b}, v], ProcessEstimator -> "MinimumPredictionError"]

Use a different method:

Wolfram Language code: EstimatedProcess[data, MAProcess[c + b, {.1, b}, v]]

Neat Examples (2)

Simulate a three-dimensional MAProcess:

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 = MAProcess[{A, B}, S];
data = RandomFunction[proc, {100}, k = 5]["ValueList"];

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

Simulate paths from an MA process:

Wolfram Language code:

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

Take a slice at 50 and visualize its distribution:

Wolfram Language code: sd = data["SliceData", 50];

Wolfram Language code:

cf = ColorData["Rainbow"];
sliced = BarChart[Last[#], Axes -> False, BarOrigin -> Left, AspectRatio -> 4, ChartStyle -> (cf /@ Rescale[MovingAverage[First[#], 2], {Min[sd], Max[sd]}, {0, 1}]), ImageSize -> 42]&[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

MAProcess

Details

Examples

Basic Examples (3)

Scope (37)

Basic Uses (11)

Covariance and Spectrum (6)

Stationarity and Invertibility (4)

Estimation Methods (6)

Process Slice Properties (5)

Representations (5)

Applications (1)

Properties & Relations (5)

Possible Issues (3)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

MAProcess

Details

Examples

Basic Examples (3)

Scope (37)

Basic Uses (11)

Covariance and Spectrum (6)

Stationarity and Invertibility (4)

Estimation Methods (6)

Process Slice Properties (5)

Representations (5)

Applications (1)

Properties & Relations (5)

Possible Issues (3)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX