xcorr

Corrélation croisée

Syntaxe

r = xcorr(x,y)

r = xcorr(x)

r = xcorr(___,maxlag)

r = xcorr(___,scaleopt)

[r,lags] = xcorr(___)

Description

r = xcorr(x,y) renvoie la corrélation croisée de deux séquences à temps discret. La corrélation croisée mesure la similarité entre un vecteur x et des copies décalées (retardées) d’un vecteur y en fonction du décalage. Si x et y n’ont pas la même longueur, la fonction ajoutez des zéros à la fin du vecteur le plus court pour qu’il soit de même longueur que l’autre.

r = xcorr(x) renvoie la séquence d’autocorrélation de x. Si x est une matrice, r est une matrice dont les colonnes contiennent les séquences d’autocorrélation et de corrélation croisée pour toutes les combinaisons des colonnes de x.

r = xcorr(___,maxlag) limite la plage de décalage de -maxlag à maxlag pour l’une ou l’autre des syntaxes précédentes.

r = xcorr(___,scaleopt) spécifie également une option de normalisation pour la corrélation croisée ou l’autocorrélation. Toute autre option que 'none' (option par défaut) nécessite que x et y aient la même longueur.

[r,lags] = xcorr(___) renvoie également les décalages auxquels les corrélations ont été calculées.

Exemples

Corrélation croisée de deux vecteurs

Créez un vecteur x et un vecteur y égal à x décalé de 5 éléments vers la droite. Calculez et tracez la corrélation croisée estimée de x et y. Le pic le plus élevé se produit à la valeur de décalage pour laquelle les éléments de x et y sont exactement identiques (-5).

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

Autocorrélation d’un vecteur

Calculez et tracez l’autocorrélation estimée du vecteur x. Le pic le plus élevé se produit au décalage nul, quand x est exactement identique à lui-même.

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

Corrélation croisée normalisée

Calculez et tracez la corrélation croisée normalisée des vecteurs x et y avec un pic unitaire et spécifiez un décalage maximal de 10.

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

Arguments d'entrée

x — Tableau en entrée

vecteur | matrice | tableau multidimensionnel

Tableau en entrée, spécifié sous forme de vecteur, de matrice ou de tableau multidimensionnel. Si x est un tableau multidimensionnel, xcorr traite chacune des colonnes pour toutes les dimensions et renvoie chaque autocorrélation et corrélation croisée en tant que colonnes d’une matrice.

Types de données : single | double
Support des nombres complexes : Oui

y — Tableau en entrée

vecteur

Tableau en entrée, spécifié sous forme de vecteur.

Types de données : single | double
Support des nombres complexes : Oui

maxlag — Décalage maximal

scalaire entier

Décalage maximal, spécifié sous forme d’un scalaire entier. Si vous spécifiez maxlag, la séquence de corrélation croisée renvoyée est comprise entre -maxlag et maxlag. Si vous ne spécifiez pas maxlag, la plage de décalage est égale à 2N – 1 où N est la plus élevée des longueurs de x et y.

Types de données : single | double

scaleopt — Option de normalisation

'none' (par défaut) | 'biased' | 'unbiased' | 'normalized' | 'coeff'

Option de normalisation, spécifiée sous une des formes suivantes.

• 'none' : corrélation croisée brute sans mise à l’échelle. 'none' est la seule option valide quand x et y n’ont pas la même longueur.

• 'biased' : estimation biaisée de la corrélation croisée :

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

• 'unbiased' : estimation non biaisée de la corrélation croisée :

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

• 'normalized' ou 'coeff' : normalise la séquence pour que les autocorrélations à décalage nul soient égales à 1 :

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

Arguments de sortie

r — Corrélation croisée ou autocorrélation

vecteur | matrice

Corrélation croisée ou autocorrélation, renvoyée sous forme de vecteur ou de matrice.

Si x est une matrice M × N, xcorr(x) renvoie une matrice (2M – 1) × N² avec les autocorrélations et corrélations croisées des colonnes de x. Si vous spécifiez maxlag, r a une taille de (2 × maxlag + 1) × N².

Par exemple, si S contient trois colonnes $$\text{S}=\left(\begin{array}{ccc}{x}_1& x_2& x_3\end{array}\right)$$, le résultat de R = xcorr(S) est organisé comme suit :

$$\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 — Indices de décalage

vecteur

Indices de décalage, renvoyés sous forme de vecteur.

En savoir plus

Corrélation croisée et autocorrélation

Le résultat de xcorr peut être interprété comme une estimation de la corrélation entre deux séquences aléatoires ou comme la corrélation déterministe entre deux signaux déterministes.

La séquence de corrélation croisée réelle de deux processus aléatoires conjointement stationnaires x_n et y_n est donnée par :

$$R_{xy}(m)=E\left\{x_{n+m}{y}_n^{*}\right\}=E\left\{x_n{y}_{n-m}^{*}\right\},$$

où −∞ < n < ∞, l’astérisque indique une conjugaison complexe et E est l’opérateur d’espérance mathématique. xcorr peut seulement estimer la séquence, car en pratique, seul un segment fini d’une réalisation du processus aléatoire de longueur infinie est disponible.

Par défaut, xcorr calcule les corrélations brutes sans normalisation :

$${\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}$$

Le vecteur en sortie c a des éléments donnés par :

$$\text{c}(\text{m})={\widehat{R}}_{xy}(m-N),m=1,2,\dots ,2N-1.$$

En général, la fonction de corrélation nécessite une normalisation pour produire une estimation précise. Vous pouvez contrôler la normalisation de la corrélation avec l’argument en entrée scaleopt.

Références

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

Capacités étendues

Tall arrays

Calculer avec des arrays possédant plus de rangées que la mémoire ne peut en contenir.

La fonction xcorr supporte les tall arrays avec les notes d’usage et limitations suivantes :

• L’entrée x doit être un vecteur colonne tall.

• L’entrée y doit être un vecteur non tall.

• La syntaxe xcorr(x) n’est pas supportée.

• L’option scaleopt n’est pas supportée.

• Si vous spécifiez maxlag, il doit être tel que maxlag <= max(numel(x),numel(y))-1.

• La sortie lags est renvoyée sous forme d’un vecteur colonne tall.

Pour plus d’informations, consultez Tall array.

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• Les uns au début de size(x) (les longueurs de dimension égales à 1 qui précèdent la première longueur de dimension qui n’est pas égale à 1) doivent être constants pour chaque entrée de x. Si x est de taille variable et que c’est un vecteur ligne, il doit être de dimension 1 x :. Il ne peut pas être de dimension : x : avec size(x,1) = 1 au run-time.

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

La fonction xcorr supporte entièrement les GPU arrays. Pour exécuter la fonction sur un GPU, spécifiez les données en entrée en tant que gpuArray (Parallel Computing Toolbox). Pour plus d’informations, consultez Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Par exemple, créez un objet gpuArray à partir d’un signal x et calculez l’autocorrélation normalisée.

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);

Historique des versions

Introduit avant R2006a

R2019a: Déplacement vers MATLAB à partir de Signal Processing Toolbox

Auparavant, xcorr nécessitait Signal Processing Toolbox™.

Voir aussi

conv | corrcoef | cov | xcov