xcorr

Cross-correlation

Syntax

r = xcorr(x,y)

r = xcorr(x)

r = xcorr(___,maxlag)

r = xcorr(___,scaleopt)

[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.

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.

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

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.

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

Examples

Cross-Correlation of Two Vectors

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)

Autocorrelation of Vector

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)

Normalized Cross-Correlation

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)

Input Arguments

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.

Data Types: single | double
Complex Number Support: Yes

y — Input array

vector

Input array, specified as a vector.

Data Types: single | double
Complex Number Support: Yes

maxlag — Maximum lag

integer scalar

Maximum lag, specified as an integer scalar. If you specify maxlag, the returned cross-correlation sequence ranges from -maxlag to maxlag. If you do not specify maxlag, the lag range equals 2N – 1, where N is the greater of the lengths of x and y.

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:

  $${\widehat{R}}_{xy,\text{biased}}(m)=\frac{1}{N}{\widehat{R}}_{xy}(m).$$

• 'unbiased' — Unbiased estimate of the cross-correlation:

  $${\widehat{R}}_{xy,\text{unbiased}}(m)=\frac{1}{N-\left|m\right|}{\widehat{R}}_{xy}(m).$$

• 'normalized' or 'coeff' — Normalizes the sequence so that the autocorrelations at zero lag equal 1:

  $${\widehat{R}}_{xy,\text{coeff}}(m)=\frac{1}{\sqrt{{\widehat{R}}_{xx}(0){\widehat{R}}_{yy}(0)}}{\widehat{R}}_{xy}(m).$$

Output Arguments

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².

For example, if S has three columns, $$\text{S}=\left(\begin{array}{ccc}{x}_1& x_2& x_3\end{array}\right)$$, then the result of R = xcorr(S) is organized as

$$\text{R}=\left(\begin{array}{lllllllll}{R}_{x_1{x}_1}\hfill & R_{x_1{x}_2}\hfill & R_{x_1{x}_3}\hfill & R_{x_2{x}_1}\hfill & R_{x_2{x}_2}\hfill & R_{x_2{x}_3}\hfill & R_{x_3{x}_1}\hfill & R_{x_3{x}_2}\hfill & R_{x_3{x}_3}\hfill \end{array}\right).$$

lags — Lag indices

vector

Lag indices, returned as a vector.

More About

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_{xy}(m)=E\left\{x_{n+m}{y}_n^{*}\right\}=E\left\{x_n{y}_{n-m}^{*}\right\},$$

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:

$${\widehat{R}}_{xy}(m)=\{\begin{array}{ll}{\displaystyle \sum _{n=0}^{N-m-1}{x}_{n+m}{y}_n^{\ast },}\hfill & m\ge 0,\hfill \\ {\widehat{R}}_{yx}^{*}(-m),\hfill & m<0.\hfill \end{array}$$

The output vector, c, has elements given by

$$\text{c}(\text{m})={\widehat{R}}_{xy}(m-N),m=1,2,\dots ,2N-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

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.

Thread-Based Environment

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

This 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 fully supports GPU arrays. To run the function on a GPU, specify the input data as a gpuArray (Parallel Computing Toolbox). For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

For example, create a gpuArray object from a signal x and compute the normalized autocorrelation.

t = 0:0.001:10-0.001;
x = cos(2*pi*10*t) + randn(size(t));  
X = gpuArray(x);                       
[r,lags] = xcorr(X,200,'normalized');     
r = gather(r);

Version History

Introduced before R2006a

R2019a: Moved to MATLAB from Signal Processing Toolbox

Previously, xcorr required Signal Processing Toolbox™.