La traduzione di questa pagina non è aggiornata. Fai clic qui per vedere l'ultima versione in inglese.

xcorr

Correlazione incrociata

Sintassi

r = xcorr(x,y)

r = xcorr(x)

r = xcorr(___,maxlag)

r = xcorr(___,scaleopt)

[r,lags] = xcorr(___)

Descrizione

r = xcorr(x,y) restituisce la correlazione incrociata di due sequenze a tempo discreto. La correlazione incrociata misura la somiglianza tra un vettore x e le copie spostate (sfasate) di un vettore y in funzione dello sfasamento. Se x e y hanno lunghezze diverse, la funzione aggiunge degli zeri alla fine del vettore più corto in modo che abbia la stessa lunghezza dell'altro.

r = xcorr(x) restituisce la sequenza di autocorrelazione di x. Se x è una matrice, r è una matrice le cui colonne contengono le sequenze di autocorrelazione e di correlazione incrociata per tutte le combinazioni di colonne di x.

r = xcorr(___,maxlag) limita l'intervallo di sfasamento da -maxlag a maxlag per una delle sintassi precedenti.

r = xcorr(___,scaleopt) specifica inoltre un'opzione di normalizzazione per la correlazione incrociata o l'autocorrelazione. Qualsiasi opzione diversa da 'none' (predefinita) richiede che x e y abbiano la stessa lunghezza.

[r,lags] = xcorr(___) restituisce inoltre gli sfasamenti a cui vengono calcolate le correlazioni.

Esempi

Correlazione incrociata di due vettori

Creare un vettore x e un vettore y che sia uguale a x spostato di 5 elementi verso destra. Calcolare e tracciare la correlazione incrociata stimata di x e y. Il picco maggiore si verifica al valore di sfasamento quando gli elementi di x e y coincidono esattamente (-5).

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

Autocorrelazione di vettori

Calcolare e tracciare l'autocorrelazione stimata di un vettore x. Il picco maggiore si verifica con sfasamento zero, quando x corrisponde esattamente a sé stesso.

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

Correlazione incrociata normalizzata

Calcolare e tracciare la correlazione incrociata normalizzata dei vettori x e y con picco unitario e specificare uno sfasamento massimo 10.

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

Argomenti di input

x — Array di input

vettore | matrice | array multidimensionale

Array di input, specificato come vettore, matrice o array multidimensionale. Se x è un array multidimensionale, xcorr opera colonna per colonna su tutte le dimensioni e restituisce ciascuna autocorrelazione e correlazione incrociata come colonne di una matrice.

Tipi di dati: single | double
Supporto numeri complessi: Sì

y — Array di input

vettore

Array di input, specificato come vettore.

Tipi di dati: single | double
Supporto numeri complessi: Sì

maxlag — Sfasamento massimo

scalare intero

Sfasamento massimo, specificato come scalare intero. Se si specifica maxlag, la sequenza di correlazione incrociata va da -maxlag a maxlag. Se non si specifica maxlag, l'intervallo di sfasamento è uguale a 2N – 1, dove N è la maggiore delle lunghezze di x e y.

Tipi di dati: single | double

scaleopt — Opzione di normalizzazione

'none' (predefinito) | 'biased' | 'unbiased' | 'normalized' | 'coeff'

Opzione di normalizzazione, specificata in uno dei seguenti modi.

• 'none': correlazione incrociata grezza, non scalata. 'none' è l'unica opzione valida quando x e y hanno lunghezze diverse.

• 'biased': stima distorta della correlazione incrociata:

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

• 'unbiased': stima non distorta della correlazione incrociata:

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

• 'normalized' o 'coeff': normalizza la sequenza in modo che le autocorrelazioni con zero sfasamento siano uguali a 1:

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

Argomenti di output

r — Correlazione incrociata o autocorrelazione

vettore | matrice

Correlazione incrociata o autocorrelazione, restituite come vettore o matrice.

Se x è una matrice M × N, xcorr(x) restituisce una matrice (2M – 1) × N² con le autocorrelazioni e le correlazioni incrociate delle colonne di x. Se si specifica maxlag, r ha grandezza (2 × maxlag + 1) × N².

Ad esempio, se S ha tre colonne $$\text{S}=\left(\begin{array}{ccc}{x}_1& x_2& x_3\end{array}\right)$$, il risultato di R = xcorr(S) è organizzato come

$$\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 — Indici di sfasamento

vettore

Indici di sfasamento, restituiti come vettore.

Ulteriori informazioni

Correlazione incrociata e autocorrelazione

Il risultato di xcorr può essere interpretato come una stima della correlazione tra due sequenze casuali o come la correlazione deterministica tra due segnali deterministici.

La sequenza reale di correlazione incrociata di due processi casuali congiuntamente stazionari x_n e y_n, è data da

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

dove −∞ < n < ∞, l'asterisco indica il coniugato complesso ed E è l'operatore di valore previsto. xcorr può solo stimare la sequenza perché, in pratica, è disponibile solo un segmento finito di una realizzazione del processo casuale di lunghezza infinita.

Per impostazione predefinita, xcorr calcola le correlazioni grezze senza normalizzazione:

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

Il vettore di output c contiene elementi dati da

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

In generale, la funzione di correlazione richiede una normalizzazione per produrre una stima accurata. È possibile controllare la normalizzazione della correlazione utilizzando l'argomento di input scaleopt.

Riferimenti

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

Funzionalità estese

Tall array

Esegui calcoli con array che hanno più righe di quelle allocabili in memoria.

Note su utilizzo e limitazioni:

• L'input x deve essere un vettore colonna tall.

• L'input y non deve essere un vettore colonna tall.

• La sintassi xcorr(x) non è supportata.

• L’opzione scaleopt non è supportata.

• Se si specifica maxlag, deve soddisfare la condizione maxlag <= max(numel(x),numel(y))-1.

• L'output lags è restituito come vettore colonna tall.

Per maggiori informazioni, vedere Tall Array.

Generazione di codice C/C++

Genera codice C e C++ con MATLAB® Coder™.

Note su utilizzo e limitazioni:

• Gli uno iniziali size(x) (lunghezze di dimensione di 1, prima della prima lunghezza di dimensione non uguale a 1) devono essere costanti per ciascun input x. Se x è di dimensioni variabili ed è un vettore riga, deve essere 1x:. Non può essere : x : con size(x,1) = 1 al tempo di esecuzione.

Ambiente basato su thread

Esegui il codice in background usando MATLAB® backgroundPool oppure accelera il codice con Parallel Computing Toolbox™ ThreadPool.

Questa funzione supporta completamente gli ambienti basati su thread. Per maggiori informazioni, vedere Run MATLAB Functions in Thread-Based Environment.

Array GPU

Accelera il codice mediante esecuzione su un’unità di elaborazione grafica (GPU) con Parallel Computing Toolbox™.

Questa funzione supporta completamente gli array di GPU. Per maggiori informazioni, vedere Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Ad esempio, creare un oggetto gpuArray da un segnale x e calcolare l'autocorrelazione normalizzata.

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

Vedi anche

conv | corrcoef | cov | xcov