xcorr

R2026b

Cross-correlation

collapse all in page

Syntax

r = xcorr(x,y)

r = xcorr(x)

r = xcorr(___,maxlag)

r = xcorr(___,scaleopt)

r = xcorr(___,LagSelection=range)

[r,lags]
= xcorr(___)

Description

r = xcorr(x,y) returns the cross-correlation of two discrete-time sequences. Cross-correlation measures the similarity between a vector x and shifted (lagged) copies of a vector y as a function of the lag. If x and y have different lengths, the function appends zeros to the end of the shorter vector so it has the same length as the other.

example

r = xcorr(x) returns the autocorrelation sequence of x. If x is a matrix, then r is a matrix whose columns contain the autocorrelation and cross-correlation sequences for all combinations of the columns of x.

example

r = xcorr(___,maxlag) limits the lag range from -maxlag to maxlag for either of the previous syntaxes.

example

r = xcorr(___,scaleopt) also specifies a normalization option for the cross-correlation or autocorrelation. Any option other than "none" (the default) requires x and y to have the same length.

example

r = xcorr(___,LagSelection=range) specifies whether to return the cross-correlation for only nonnegative lags, only nonpositive lags, or all lags. (since R2026b)

example

[r,lags] = xcorr(___) also returns the lags at which the correlations are computed.

example

Examples

collapse all

Cross-Correlation of Two Vectors

Open Live Script

Create a vector x and a vector y that is equal to x shifted by 5 elements to the right. Compute and plot the estimated cross-correlation of x and y. The largest spike occurs at the lag value when the elements of x and y match exactly (-5).

n = 0:15;
x = 0.84.^n;
y = circshift(x,5);
[c,lags] = xcorr(x,y);
stem(lags,c)

Figure contains an axes object. The axes object contains an object of type stem.

Autocorrelation of Vector

Open Live Script

Compute and plot the estimated autocorrelation of a vector x. The largest spike occurs at zero lag, when x matches itself exactly.

n = 0:15;
x = 0.84.^n;
[c,lags] = xcorr(x);
stem(lags,c)

Figure contains an axes object. The axes object contains an object of type stem.

Normalized Cross-Correlation

Open Live Script

Compute and plot the normalized cross-correlation of vectors x and y with unity peak, and specify a maximum lag of 10.

n = 0:15;
x = 0.84.^n;
y = circshift(x,5);
[c,lags] = xcorr(x,y,10,'normalized');
stem(lags,c)

Figure contains an axes object. The axes object contains an object of type stem.

Return Only Nonpositive Lags

Open Live Script

Create two signals where y is a delayed copy of x, and use cross-correlation to determine the delay.

x = [1 0 0 0 0];
y = [0 0 0 1 0];

In the cross-correlation of x and y, a negative lag means y is delayed relative to x, and a positive lag means x is delayed relative to y.

If you know that y is delayed relative to x, the peak cross-correlation must be at a negative lag. Specify LagSelection="nonpositive" to return only the nonpositive lags.

[c,lags] = xcorr(x,y,LagSelection="nonpositive")

c = 1×5

         0    1.0000         0   -0.0000         0

lags = 1×5

    -4    -3    -2    -1     0

Determine the delay between the signals by finding the lag at the peak of the cross-correlation. The result indicates that y lags 3 samples behind x.

[~,idx] = max(c);
delay = lags(idx)

delay = 
-3

Input Arguments

collapse all

`x` — Input array
vector | matrix | multidimensional array

Input array, specified as a vector, matrix, or multidimensional array. If x is a multidimensional array, then xcorr operates column-wise across all dimensions and returns each autocorrelation and cross-correlation as the columns of a matrix.

The input array x can be a sparse matrix or vector of type double or single. (since R2026b)

Data Types: double | single
Complex Number Support: Yes

`y` — Input array
vector

Input array, specified as a vector.

The input array y can be a sparse vector of type double or single. (since R2026b)

Data Types: double | single
Complex Number Support: Yes

`maxlag` — Maximum lag
integer scalar

Maximum lag, specified as an integer scalar. The maximum lag is the farthest number of samples that xcorr shifts one input sequence relative to the other. If you specify maxlag, xcorr computes the cross-correlation for lags from -maxlag to maxlag. If you do not specify maxlag, the default maximum lag is N - 1, where N is the greater of the lengths of x and y, and xcorr computes the cross-correlation for lags from -(N - 1) to N - 1.

Data Types: single | double

`scaleopt` — Normalization option
`"none"` (default) | `"biased"` | `"unbiased"` | `"normalized"` | `"coeff"`

Normalization option, specified as one of the following.

"none" — Raw, unscaled cross-correlation. "none" is the only valid option when x and y have different lengths.
"biased" — Biased estimate of the cross-correlation:
${\hat{R}}_{x y, biased} (m) = \frac{1}{N} {\hat{R}}_{x y} (m) .$
"unbiased" — Unbiased estimate of the cross-correlation:
${\hat{R}}_{x y, unbiased} (m) = \frac{1}{N - | m |} {\hat{R}}_{x y} (m) .$
"normalized" or "coeff" — Normalizes the sequence so that the autocorrelations at zero lag equal 1:
${\hat{R}}_{x y, coeff} (m) = \frac{1}{\sqrt{{\hat{R}}_{x x} (0) {\hat{R}}_{y y} (0)}} {\hat{R}}_{x y} (m) .$

`range` — Selection of lags to include in output
`"all"` (default) | `"nonnegative"` | `"nonpositive"`

Since R2026b

Selection of lags to include in the output, specified as one of these values:

"all" — Return the cross-correlation for all lags from -maxlag to maxlag.
"nonnegative" — Return the cross-correlation for nonnegative lags only, from 0 to maxlag.
"nonpositive" — Return the cross-correlation for nonpositive lags only, from -maxlag to 0.

Output Arguments

collapse all

`r` — Cross-correlation or autocorrelation
vector | matrix

Cross-correlation or autocorrelation, returned as a vector or matrix.

If x is an M × N matrix, then xcorr(x) returns a (2M – 1) × N² matrix with the autocorrelations and cross-correlations of the columns of x. If you specify maxlag, then r has size (2 × maxlag + 1) × N².

If you specify LagSelection as "nonnegative" or "nonpositive", then r has maxlag + 1 rows instead of 2 x maxlag + 1 rows.

For example, if S has three columns, $S = (\begin{matrix} x_{1} & x_{2} & x_{3} \end{matrix})$ , then the result of R = xcorr(S) is organized as

$R = (\begin{array}{l} R_{x_{1} x_{1}} & R_{x_{1} x_{2}} & R_{x_{1} x_{3}} & R_{x_{2} x_{1}} & R_{x_{2} x_{2}} & R_{x_{2} x_{3}} & R_{x_{3} x_{1}} & R_{x_{3} x_{2}} & R_{x_{3} x_{3}} \end{array}) .$

`lags` — Lag indices
vector

Lag indices, returned as a vector.

More About

collapse all

Cross-Correlation and Autocorrelation

The result of xcorr can be interpreted as an estimate of the correlation between two random sequences or as the deterministic correlation between two deterministic signals.

The true cross-correlation sequence of two jointly stationary random processes, x_n and y_n, is given by

$R_{x y} (m) = E {x_{n + m} y_{n}^{*}} = E {x_{n} y_{n - m}^{*}},$

where −∞ < n < ∞, the asterisk denotes complex conjugation, and E is the expected value operator. xcorr can only estimate the sequence because, in practice, only a finite segment of one realization of the infinite-length random process is available.

By default, xcorr computes raw correlations with no normalization:

${\hat{R}}_{x y} (m) = {\begin{array}{l} \sum_{n = 0}^{N - m - 1} x_{n + m} y_{n}^{*}, & m \geq 0, \\ {\hat{R}}_{y x}^{*} (- m), & m < 0. \end{array}$

The output vector, c, has elements given by

$c (m) = {\hat{R}}_{x y} (m - N), m = 1, 2, \dots, 2 N - 1.$

In general, the correlation function requires normalization to produce an accurate estimate. You can control the normalization of the correlation by using the input argument scaleopt.

References

[1] Buck, John R., Michael M. Daniel, and Andrew C. Singer. Computer Explorations in Signals and Systems Using MATLAB^®. 2nd Edition. Upper Saddle River, NJ: Prentice Hall, 2002.

[2] Stoica, Petre, and Randolph Moses. Spectral Analysis of Signals. Upper Saddle River, NJ: Prentice Hall, 2005.

Extended Capabilities

expand all

Tall Arrays
Calculate with arrays that have more rows than fit in memory.

The xcorr function supports tall arrays with the following usage notes and limitations:

The x input must be a tall column vector.
The y input must be a non-tall vector.
The syntax xcorr(x) is not supported.
The scaleopt option is not supported.
If you specify maxlag, then it must satisfy maxlag <= max(numel(x),numel(y))-1.
The lags output is returned as a tall column vector.

For more information, see Tall Arrays.

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

Leading ones in size(x) (dimension lengths of 1 before the first dimension length not equal to 1) must be constant for every input x. If x is variable-size and is a row vector, it must be 1-by-:. It cannot be :-by-: with size(x,1) = 1 at run time.

GPU Code Generation
Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Refer to the usage notes and limitations in the C/C++ Code Generation section. The same usage notes and limitations apply to GPU code generation.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

The xcorr function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

The xcorr function supports GPU array input with these usage notes and limitations:

Sparse gpuArray input is not supported.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Version History

Introduced before R2006a

expand all

R2026b: Select nonnegative or nonpositive lags

Return the cross-correlation for only nonnegative or nonpositive lags by specifying the LagSelection name-value argument.

R2026b: Compute cross-correlation using sparse inputs

The xcorr function now supports sparse inputs. You can compute cross-correlation using sparse inputs to significantly reduce memory usage and improve processing performance when the inputs contain many elements that are zero.

R2019a: Moved to MATLAB from Signal Processing Toolbox

Previously, xcorr required Signal Processing Toolbox™.

xcorr

Syntax

Description

Examples

Cross-Correlation of Two Vectors

Autocorrelation of Vector

Normalized Cross-Correlation

Return Only Nonpositive Lags

Input Arguments

x — Input array vector | matrix | multidimensional array

y — Input array vector

maxlag — Maximum lag integer scalar

scaleopt — Normalization option "none" (default) | "biased" | "unbiased" | "normalized" | "coeff"

range — Selection of lags to include in output "all" (default) | "nonnegative" | "nonpositive"

Output Arguments

r — Cross-correlation or autocorrelation vector | matrix

lags — Lag indices vector

More About

Cross-Correlation and Autocorrelation

References

Extended Capabilities

Tall Arrays Calculate with arrays that have more rows than fit in memory.

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

GPU Code Generation Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Thread-Based Environment Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool.

GPU Arrays Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Version History

R2026b: Select nonnegative or nonpositive lags

R2026b: Compute cross-correlation using sparse inputs

R2019a: Moved to MATLAB from Signal Processing Toolbox

See Also

`x` — Input array
vector | matrix | multidimensional array

`y` — Input array
vector

`maxlag` — Maximum lag
integer scalar

`scaleopt` — Normalization option
`"none"` (default) | `"biased"` | `"unbiased"` | `"normalized"` | `"coeff"`

`range` — Selection of lags to include in output
`"all"` (default) | `"nonnegative"` | `"nonpositive"`

`r` — Cross-correlation or autocorrelation
vector | matrix

`lags` — Lag indices
vector

Tall Arrays
Calculate with arrays that have more rows than fit in memory.

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

GPU Code Generation
Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.