WOLFRAM

Wolfram Language & System Documentation Center

CorrelationFunction[data,hspec]

estimates the correlation function at lags hspec from data.

CorrelationFunction[proc,hspec]

represents the correlation function at lags hspec for the random process proc.

CorrelationFunction[proc,s,t]

represents the correlation function at times s and t for the random process proc.

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Empirical Estimates  
Random Processes  
Applications  
Properties & Relations  
Possible Issues  
See Also
Related Guides
History
Cite this Page

CorrelationFunction

CorrelationFunction[data,hspec]

estimates the correlation function at lags hspec from data.

CorrelationFunction[proc,hspec]

represents the correlation function at lags hspec for the random process proc.

CorrelationFunction[proc,s,t]

represents the correlation function at times s and t for the random process proc.

Details

  • CorrelationFunction is also known as autocorrelation or cross-correlation function (ACF or CCF).
  • The following specifications can be given for hspec:
  • τat time or lag τ
    {τmax}unit spaced from 0 to τmax
    {τmin,τmax}unit spaced from τmin to τmax
    {τmin,τmax,dτ}from τmin to τmax in steps of dτ
    {{τ1,τ2,…}}use explicit {τ1,τ2,…}
  • CorrelationFunction[{x1,…,xn},h] is equivalent to with =Mean[{x1,…,xn}].
  • When data is TemporalData containing an ensemble of paths, the output represents the average across all paths.
  • CorrelationFunction of the process proc is the CovarianceFunction c normalized by the outer product of the standard deviation function σ at times s and t:
  • c[s,t]/(σ[s]σ[t])for scalar-valued data or processes
    c[s,t]/(σ[s] ⊗ σ[t])for vector-valued data or processes
  • The symbol ⊗ represents KroneckerProduct.
  • CorrelationFunction[proc,h] is defined only if proc is a weakly stationary process and is equivalent to CorrelationFunction[proc,h,0].
  • The process proc can be any random process, such as ARMAProcess and WienerProcess.

Examples

open all close all

Basic Examples  (4)

Estimate the correlation function at lag 2:

Wolfram Language code: CorrelationFunction[{2, 3, 4, 3}, 2]

The sample correlation function for a random sample from an autoregressive time series:

Wolfram Language code: data = RandomFunction[ARProcess[{.2, .3, .4}, 1], {1, 10 ^ 4}];
Wolfram Language code: ListPlot[CorrelationFunction[data, {20}], Filling -> Axis, PlotRange -> All]

The correlation function for a discrete-time process:

Wolfram Language code: CorrelationFunction[BinomialProcess[p], s, t]
Wolfram Language code: DiscretePlot3D[Evaluate[% /. {p -> 2 / 3}], {s, 1, 10}, {t, 1, 10}, ExtentSize -> 1 / 2, ColorFunction -> "Rainbow"]

The correlation function for a continuous-time process:

Wolfram Language code: CorrelationFunction[WienerProcess[μ, σ], s, t]
Wolfram Language code: Plot3D[Evaluate[% /. {μ -> 1, σ -> 2}], {s, 0, 10}, {t, 0, 10}, ColorFunction -> "Rainbow"]

Scope  (13)

Empirical Estimates  (7)

Estimate the correlation function for some data at lag 9:

Wolfram Language code: CorrelationFunction[Range[10], 9]

Obtain empirical estimates of the correlation function up to lag 9:

Wolfram Language code: CorrelationFunction[Range[10], {9}]

Compute the correlation function for lags 1 to 9 in steps of 2:

Wolfram Language code: CorrelationFunction[Range[10], {1, 9, 2}]

Compute the correlation function for a time series:

Wolfram Language code: ts = TemporalData[TimeSeries, {{{-2.9904395734335427, -1.5547517217370468, -2.007044987914736, -0.7114933373063236, -1.5920036118254968, 0.23183536513859127, 0.056774681349179124, 0.32394041932443046, 0.10382798659711348, -0.684046765274114, - ... 1687325555, 3.410933732368106, 2.5200924558212163, 2.008558601261935, 0.43151331467691206, 0.6249727955196763}}, {{1, 1000, 1}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, {ValueDimensions -> 1, ResamplingMethod -> None}}, False, 10.1];

The correlation function of a time series for multiple lags is given as a time series:

Wolfram Language code: corr = CorrelationFunction[ts, {100}]
Wolfram Language code: ListPlot[corr, Filling -> Axis]

Estimate the correlation function for an ensemble of paths:

Wolfram Language code: data = RandomFunction[ARProcess[{.8}, 1], {0, 500}, 10]
Wolfram Language code: corr = CorrelationFunction[data, {12}];
Wolfram Language code: ListPlot[corr, Filling -> 0]

Compare empirical and theoretical correlation functions:

Wolfram Language code: proc = MAProcess[{.4, .3, .5, .6, .3}, 1.];
Wolfram Language code: data = RandomFunction[proc, {0, 1000}];
Wolfram Language code: ListPlot[TemporalData[CorrelationFunction[#, {10}]& /@ {proc, data}], Filling -> {1 -> {2}}, PlotStyle -> PointSize[Medium]]

Plot the cross-correlation for vector data:

Wolfram Language code: proc = ARProcess[{{{.3, .1}, {.6, .3}}}, {{1, .3}, {.3, .6}}]; data = RandomFunction[proc, {100}]; cov = CorrelationFunction[data, {-6, 6}];
Wolfram Language code: Table[ListPlot[cov["Values"][[All, i, j]], Filling -> 0, PlotLabel -> {i, j}], {i, 1, 2}, {j, 1, 2}]

Random Processes  (6)

The correlation function for a weakly stationary discrete-time process:

Wolfram Language code: CorrelationFunction[ARProcess[{a}, σ^2], s, t]//PiecewiseExpand
Wolfram Language code: DiscretePlot3D[Evaluate[% /. {a -> 2 / 3, σ -> 1}], {s, 0, 10}, {t, 0, 10}, ExtentSize -> 1 / 2, ColorFunction -> "Rainbow"]

The correlation function only depends on the antidiagonal :

Wolfram Language code: CorrelationFunction[ARProcess[{a}, σ^2], h]//PiecewiseExpand
Wolfram Language code: DiscretePlot[Evaluate[% /. {a -> 2 / 3, σ -> 1}], {h, 0, 10}, ExtentSize -> 1 / 2, ColorFunction -> "Rainbow", AxesLabel -> {h, None}]

The correlation function for a weakly stationary continuous-time process:

Wolfram Language code: CorrelationFunction[OrnsteinUhlenbeckProcess[μ, σ, θ], s, t]
Wolfram Language code: Plot3D[Evaluate[% /. {μ -> 1, σ -> 2, θ -> 1 / 3}], {s, 0, 10}, {t, 0, 10}, ColorFunction -> "Rainbow"]

The correlation function only depends on the antidiagonal :

Wolfram Language code: CorrelationFunction[OrnsteinUhlenbeckProcess[μ, σ, θ], h]
Wolfram Language code: Plot[Evaluate[% /. {μ -> 1, σ -> 2, θ -> 1 / 3}], {h, 0, 10}, ColorFunction -> "Rainbow", Filling -> Axis, AxesLabel -> {h, None}]

The correlation function for a non-weakly stationary discrete-time process:

Wolfram Language code: CorrelationFunction[BinomialProcess[p], s, t]
Wolfram Language code: DiscretePlot3D[Evaluate[% /. p -> 1 / 3], {s, 1, 10}, {t, 1, 10}, ExtentSize -> 1 / 2, ColorFunction -> "Rainbow"]

The correlation function depends on both time arguments:

Wolfram Language code: antidiagonals = CorrelationFunction[BinomialProcess[1 / 3], t, t + h]
Wolfram Language code: DiscretePlot[Evaluate@Table[antidiagonals, {t, 1, 4}], {h, 0, 5}, ExtentSize -> 1 / 2, PlotLegends -> (Row[{"t = ", #}]& /@ Range[1, 4]), AxesLabel -> {h, None}]

The correlation function for a non-weakly stationary continuous-time process:

Wolfram Language code: CorrelationFunction[PoissonProcess[μ], s, t]
Wolfram Language code: Plot3D[Evaluate[% /. μ -> 3], {s, 0, 10}, {t, 0, 10}, ColorFunction -> "Rainbow"]

The correlation function depends on both time arguments:

Wolfram Language code: antidiagonals = CorrelationFunction[PoissonProcess[3], t, t + h]
Wolfram Language code: Plot[Evaluate@Table[antidiagonals, {t, 1, 4}], {h, 0, 5}, PlotLegends -> (Row[{"t = ", #}]& /@ Range[1, 4]), AxesLabel -> {h, None}]

The correlation function for some time series processes:

Wolfram Language code: proc1 = ARProcess[{.8}, 1]; proc2 = MAProcess[{-.4, -.7, .6, -1}, 1]; proc3 = SARMAProcess[{}, {}, {3, {.6}, {.1}}, 1]; proc4 = FARIMAProcess[{}, 1 / 3, {}, 1];
Wolfram Language code: DiscretePlot[CorrelationFunction[#, h], {h, 0, 15}, ExtentSize -> 1 / 2, PlotRange -> All, PlotLabel -> Head[#]]& /@ {proc1, proc2, proc3, proc4}

Cross-correlation plots for a vector ARProcess:

Wolfram Language code: proc = ARProcess[{{{.3, .1}, {.6, .3}}}, {{1, .3}, {.3, .6}}]; cov = CorrelationFunction[proc, h];
Wolfram Language code: Table[DiscretePlot[cov[[i, j]], {h, -6, 6}, ExtentSize -> 1 / 2, PlotLabel -> {i, j}], {i, 1, 2}, {j, 1, 2}]

Applications  (2)

Determine whether the following data is best modeled with an MAProcess or an ARProcess:

Wolfram Language code: ListLinePlot[data = TemporalData[TimeSeries, {{{-1.4735257611469446, -0.9158187257309729, -1.9060205147226934, -1.6174582169404574, -2.633459084244463, -2.104839842098871, -2.8701276893108894, -2.4118183939601607, -0.5125633448622677, -1.2356329399850385, 1. ... 26394036266876, -0.16380797769527589, 0.3559909972777121, 1.5343047104249412, 0.10763337590714506}}, {{0, 100, 1}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 10.1]]

It is difficult to determine the underlying process from sample paths:

Wolfram Language code: candidates = {MAProcess[{.5, .4}, 1], ARProcess[{.5, .4}, 1]};
Wolfram Language code: SeedRandom[2];ListLinePlot[RandomFunction[#, {0, 100}]]& /@ candidates

The correlation function of the data decays slowly:

Wolfram Language code: ListPlot[CorrelationFunction[data, {10}], Filling -> 0]

ARProcess is clearly a better candidate model than MAProcess:

Wolfram Language code: ListPlot[CorrelationFunction[#, {10}], PlotLabel -> Head[#], Filling -> 0]& /@ candidates

Create an ACF plot with white-noise confidence bands:

Wolfram Language code: data = RandomFunction[MAProcess[{.6, .4, .5}, .1], {1, 500}];
Wolfram Language code: acf[data_, lmax_, clev_ : 0.95] := Show[ListPlot[CorrelationFunction[data, {0, lmax}], Filling -> Axis, PlotRange -> {{0, lmax}, All}, PlotStyle -> PointSize[Medium]], Graphics[{Dashed, Line[{{0, #}, {lmax, #}}]}]& /@ (Quantile[NormalDistribution[], {(1 - clev/2), 1 - (1 - clev/2)}]/Sqrt[data["PathLengths"][[1]]])]

Plot the correlation for lags 0 to 20 with 95% white-noise confidence bands:

Wolfram Language code: acf[data, 20, .95]

Compare to uncorrelated white noise:

Wolfram Language code: acf[TemporalData[RandomVariate[NormalDistribution[], 500], Automatic], 20, .95]

Properties & Relations  (12)

Sample correlation function is a biased estimator for the process correlation function:

Wolfram Language code: proc = ARMAProcess[1, {5 / 6, -1 / 6}, {2 / 3}, 1]; paths = RandomFunction[proc, {0, n = 10}, 10 ^ 3];

Calculate the sample correlation function:

Wolfram Language code: CorrelationFunction[paths, {10}]
Wolfram Language code: scorr = TimeSeriesMapThread[#2(n + 1) / (n + 1 - #1)&, %]

Correlation function for the process:

Wolfram Language code: corr = CorrelationFunction[proc, {10}]

Plot both functions:

Wolfram Language code: ListPlot[{scorr, corr}, Filling -> 0]

Correlation function for a process is the off-diagonal entry in the Correlation matrix:

Wolfram Language code: 𝒫 = WienerProcess[μ, σ];
Wolfram Language code: Correlation[𝒫[{s, t}], 1, 2]
Wolfram Language code: CorrelationFunction[𝒫, s, t]
Wolfram Language code: Simplify[%% - %, 0 < s < t]

Sample correlation at lag 0 is always 1:

Wolfram Language code: Simplify[CorrelationFunction[{x, y, z}, 0], {x, y, z}∈Reals]

Sample correlation function is related to CovarianceFunction:

Wolfram Language code: data = Range[10];
Wolfram Language code: CorrelationFunction[data, {Length[data] - 1}]

Scaled sample covariance function:

Wolfram Language code: CovarianceFunction[data, {Length[data] - 1}] / CovarianceFunction[data, 0]
Wolfram Language code: % - %%

Sample correlation function is related to AbsoluteCorrelationFunction:

Wolfram Language code: data = Range[10]; n = Length[data];
Wolfram Language code: AbsoluteCorrelationFunction[data - Mean[data], {n - 1}]

Scale by the first element:

Wolfram Language code: % / First[%]

Compare to the sample correlation function:

Wolfram Language code: CorrelationFunction[data, {n - 1}]
Wolfram Language code: % - %%

Use Expectation to calculate correlation:

Wolfram Language code: 𝒫 = WienerProcess[μ, σ];

Define mean and standard deviation functions:

Wolfram Language code: sd[s_] := StandardDeviation[𝒫[s]] m[s_] := Mean[𝒫[s]]
Wolfram Language code: Expectation[(x[s] - m[s])(x[t] - m[t]) / (sd[s] sd[t]), x𝒫]
Wolfram Language code: CorrelationFunction[𝒫, s, t]
Wolfram Language code: Simplify[% - %%, 0 < s < t]

Correlation function for equal times reduces to 1:

Wolfram Language code: CorrelationFunction[PoissonProcess[μ], t, t]//Simplify[#, t > 0]&

Correlation function is related to the CovarianceFunction :

Wolfram Language code: 𝒫 = OrnsteinUhlenbeckProcess[μ, σ, θ]; sd[s_] := StandardDeviation[𝒫[s]]
Wolfram Language code: CorrelationFunction[𝒫, s, t]

For , the standard deviation function is :

Wolfram Language code: CovarianceFunction[𝒫, s, t] / (sd[s] sd[t])
Wolfram Language code: % - %%

The correlation function is related to the Correlation:

Wolfram Language code: 𝒫 = WienerProcess[μ, σ];
Wolfram Language code: CorrelationFunction[𝒫, s, t]

It is the off-diagonal entry in the covariance matrix:

Wolfram Language code: Correlation[𝒫[{s, t}], 1, 2]
Wolfram Language code: Simplify[%% - %, 0 < s < t]

Correlation function is invariant for ToInvertibleTimeSeries:

Wolfram Language code: TimeSeriesInvertibility[proc = MAProcess[{2, 4}, 1]]
Wolfram Language code: iproc = ToInvertibleTimeSeries@proc
Wolfram Language code: CorrelationFunction[#, s, t]& /@ {proc, iproc}

Correlation function is invariant to centralizing:

Wolfram Language code: data = RandomFunction[ARIMAProcess[{}, 1, {}, 1], {0, 100}];

The data has nonzero mean:

Wolfram Language code: Mean[data]

Centralize data:

Wolfram Language code: newdata = Standardize[data, Mean, 1&];

Compare correlation functions:

Wolfram Language code: ListPlot[CorrelationFunction[#, {20}], Filling -> 0]& /@ {data, newdata}

Sum of the sample correlation function is constant:

Wolfram Language code: n = 100; sample = RandomInteger[n, n];

The sample is random:

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

Calculate the sample correlation function from 1 to n-1:

Wolfram Language code: corr = CorrelationFunction[sample, {1, n - 1}]; ListLinePlot[corr]

Calculate the sum:

Wolfram Language code: Total@corr

Possible Issues  (1)

CorrelationFunction output may contain DifferenceRoot:

Wolfram Language code: CorrelationFunction[ARProcess[{a, b}, σ^2], t] //Simplify[#, t > 0]&

Use FunctionExpand to recover explicit powers:

Wolfram Language code: %//FunctionExpand
Wolfram Research (2012), CorrelationFunction, Wolfram Language function, https://reference.wolfram.com/language/ref/CorrelationFunction.html.

Text

Wolfram Research (2012), CorrelationFunction, Wolfram Language function, https://reference.wolfram.com/language/ref/CorrelationFunction.html.

CMS

Wolfram Language. 2012. "CorrelationFunction." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/CorrelationFunction.html.

APA

Wolfram Language. (2012). CorrelationFunction. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/CorrelationFunction.html

BibTeX

@misc{reference.wolfram_2026_correlationfunction, author="Wolfram Research", title="{CorrelationFunction}", year="2012", howpublished="\url{https://reference.wolfram.com/language/ref/CorrelationFunction.html}", note=[Accessed: 12-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_correlationfunction, organization={Wolfram Research}, title={CorrelationFunction}, year={2012}, url={https://reference.wolfram.com/language/ref/CorrelationFunction.html}, note=[Accessed: 12-June-2026]}