xcov

Cross-covariance

Syntax

c = xcov(x,y)

c = xcov(x)

c = xcov(___,maxlag)

c = xcov(___,scaleopt)

[c,lags]
= xcov(___)

Description

c = xcov(x,y) returns the cross-covariance of two discrete-time sequences. Cross-covariance 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

c = xcov(x) returns the autocovariance sequence of x. If x is a matrix, then c is a matrix whose columns contain the autocovariance and cross-covariance sequences for all combinations of the columns of x.

example

c = xcov(___,maxlag) sets the lag range from -maxlag to maxlag for either of the previous syntaxes.

example

c = xcov(___,scaleopt) also specifies a normalization option for the cross-covariance or autocovariance. Any option other than 'none' (the default) requires the inputs x and y to have the same length.

example

[c,lags] = xcov(___) also returns the lags at which the covariances are computed.

example

Examples

collapse all

Cross-Covariance of Two Random Vectors

Open Live Script

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

rng default
x = rand(20,1);
y = circshift(x,3);
[c,lags] = xcov(x,y);
stem(lags,c)

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

Autocovariance of Random Vector

Open Live Script

Create a 20-by-1 random vector, then compute and plot the estimated autocovariance. The largest spike occurs at zero lag, where the vector is exactly equal to itself.

rng default
x = rand(20,1);
[c,lags] = xcov(x);
stem(lags,c)

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

Normalized Autocovariance of Noise

Open Live Script

Compute and plot the estimated autocovariance of white Gaussian noise, $c (m)$ , for $- 10 \leq m \leq 10$ . Normalize the sequence so that it is unity at zero lag.

rng default
x = randn(1000,1);
maxlag = 10;
[c,lags] = xcov(x,maxlag,'normalized');
stem(lags,c)

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

Biased Cross-Covariance of Two Shifted Signals

Open Live Script

Create a signal made up of two signals that are circularly shifted from each other by 50 samples.

rng default
shft = 50;
s1 = rand(150,1);
s2 = circshift(s1,[shft 0]);
x = [s1 s2];

Compute and plot biased estimates of the autocovariance and mutual cross-covariance sequences. The output matrix c is organized as four column vectors such that $c = (\begin{array}{c} c_{s_{1} s_{1}} & c_{s_{1} s_{2}} & c_{s_{2} s_{1}} & c_{s_{2} s_{2}} \end{array})$ . $c_{s_{1} s_{2}}$ has maxima at -50 and +100 and $c_{s_{2} s_{1}}$ has maxima at +50 and -100 as a result of the circular shift.

[c,lags] = xcov(x,'biased');
plot(lags,c)
legend('c_{s_1s_1}','c_{s_1s_2}','c_{s_2s_1}','c_{s_2s_2}')

$Figure contains an axes object. The axes object contains 4 objects of type line. These objects represent c_{s_1s_1}, c_{s_1s_2}, c_{s_2s_1}, c_{s_2s_2}.$

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 xcov operates column-wise across all dimensions and returns each autocovariance and cross-covariance 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-covariance sequence ranges from -maxlag to maxlag. By default, the lag range equals 2N – 1, where N is the greater of the lengths of inputs 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-covariance. 'none' is the only valid option when inputs x and y have different lengths.
'biased' — Biased estimate of the cross-covariance.
'unbiased' — Unbiased estimate of the cross-covariance.
'normalized' or 'coeff' — Normalizes the sequence so that the autocovariances at zero lag equal 1.

Output Arguments

collapse all

`c` — Cross-covariance or autocovariance
vector | matrix

Cross-covariance or autocovariance, returned as a vector or matrix.

If x is an M × N matrix, then xcov(x) returns a (2M – 1) × N² matrix with the autocovariances and cross-covariances of the columns of x. If you specify a maximum lag maxlag, then the output c has size (2 × maxlag + 1) × N².

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

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

`lags` — Lag indices
vector

Lag indices, returned as a vector.

More About

collapse all

Cross-Covariance and Autocovariance

xcov computes the mean of its inputs, subtracts the mean, and then calls xcorr.

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

The true cross-covariance sequence of two jointly stationary random processes, x_n and y_n, is the cross-correlation of mean-removed sequences,

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

where μ_x and μ_y are the mean values of the two stationary random processes, the asterisk denotes complex conjugation, and E is the expected value operator. xcov 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, xcov computes raw covariances with no normalization:

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

The output vector c has elements given by

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

The covariance function requires normalization to estimate the function properly. You can control the normalization of the correlation by using the input argument scaleopt.

References

[1] Orfanidis, Sophocles J. Optimum Signal Processing: An Introduction. 2nd Edition. New York: McGraw-Hill, 1996.

[2] Larsen, Jan. “Correlation Functions and Power Spectra.” November, 2009. https://www2.imm.dtu.dk/pubdb/edoc/imm4932.pdf

Extended Capabilities

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

The xcov 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 xcov(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™.

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 xcov 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 estimated autocovariance.

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

Version History

Introduced before R2006a

expand all

R2019a: Moved to MATLAB from Signal Processing Toolbox

Previously, xcov required Signal Processing Toolbox™.

xcov

Syntax

Description

Examples

Cross-Covariance of Two Random Vectors

Autocovariance of Random Vector

Normalized Autocovariance of Noise

Biased Cross-Covariance of Two Shifted Signals

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'

Output Arguments

c — Cross-covariance or autocovariance vector | matrix

lags — Lag indices vector

More About

Cross-Covariance and Autocovariance

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

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

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'`

`c` — Cross-covariance or autocovariance
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™.

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