xcorr

Kreuzkorrelation

Syntax

r = xcorr(x,y)

r = xcorr(x)

r = xcorr(___,maxlag)

r = xcorr(___,scaleopt)

[r,lags] = xcorr(___)

Beschreibung

r = xcorr(x,y) gibt die Kreuzkorrelation zweier zeitdiskreter Sequenzen zurück. Die Kreuzkorrelation misst die Ähnlichkeit zwischen einem Vektor x und verschobenen (verzögerten) Kopien eines Vektors y als Funktion der Verzögerung. Wenn x und y unterschiedliche Längen aufweisen, hängt die Funktion Nullen an das Ende des kürzeren Vektors an, sodass er dieselbe Länge wie der andere Vektor hat.

r = xcorr(x) gibt die Autokorrelationssequenz von x zurück. Wenn x eine Matrix ist, ist r eine Matrix, deren Spalten die Autokorrelations- und Kreuzkorrelationssequenzen für alle Kombinationen der Spalten von x enthalten.

r = xcorr(___,maxlag) begrenzt den Verzögerungsbereich in den vorstehenden Syntaxen von -maxlag bis maxlag.

r = xcorr(___,scaleopt) gibt zudem eine Normalisierungsoption für die Kreuzkorrelation oder Autokorrelation an. Eine andere Option als 'none' (Standardeinstellung) erfordert, dass x und y dieselbe Länge aufweisen.

[r,lags] = xcorr(___) gibt zudem die Verzögerungen zurück, bei denen die Korrelationen berechnet werden.

Beispiele

Kreuzkorrelation zweier Vektoren

Erstellen Sie einen Vektor x und einen Vektor y, der x nach Verschiebung um fünf Elemente nach rechts entspricht. Berechnen und plotten Sie die geschätzte Kreuzkorrelation von x und y. Die größte Spitze tritt bei dem Verzögerungswert auf, wenn die Elemente x und y sich präzise entsprechen (-5).

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

Autokorrelation eines Vektors

Berechnen und plotten Sie die geschätzte Autokorrelation eines Vektors x. Die größte Spitze tritt bei Null Verzögerung auf, wenn x exakt sich selbst entspricht.

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

Normalisierte Kreuzkorrelation

Berechnen und plotten Sie die normalisierte Kreuzkorrelation der Vektoren x und y mit Spitze Einselement und geben Sie eine maximale Verzögerung von 10 an.

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

Eingabeargumente

x — Eingabearray

Vektor | Matrix | mehrdimensionales Array

Eingabearray, angegeben als Vektor, Matrix oder mehrdimensionales Array. Wenn x ein mehrdimensionales Array ist, operiert xcorr spaltenweise über alle Dimensionen hinweg und gibt jede Autokorrelation und Kreuzkorrelation als Spalten einer Matrix zurück.

Datentypen: single | double
Unterstützung komplexer Zahlen: Ja

y — Eingabearray

Vektor

Eingabearray, angegeben als Vektor.

Datentypen: single | double
Unterstützung komplexer Zahlen: Ja

maxlag — Maximale Verzögerung

Ganzzahliger Skalar

Maximale Verzögerung, angegeben als ganzzahliger Skalar. Wenn Sie maxlag angeben, reicht die zurückgegebene Kreuzkorrelationssequenz von -maxlag bis maxlag. Wenn Sie maxlag nicht angeben, entspricht der Verzögerungsbereich 2N – 1, wobei N die größere Länge von x und y ist.

Datentypen: single | double

scaleopt — Normalisierungsoption

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

Normalisierungsoption, angegeben als eine der folgenden Optionen:

• 'none' – Nicht skalierte Kreuzkorrelation. 'none' ist die einzige gültige Option, wenn x und y unterschiedliche Längen aufweisen.

• 'biased' – Verzerrte Schätzung der Kreuzkorrelation:

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

• 'unbiased' – Unverzerrte Schätzung der Kreuzkorrelation:

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

• 'normalized' oder 'coeff' – Normalisiert die Sequenz, sodass die Autokorrelationen bei null Verzögerung 1 entsprechen:

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

Ausgabeargumente

r — Kreuzkorrelation oder Autokorrelation

Vektor | Matrix

Kreuzkorrelation oder Autokorrelation, zurückgegeben als Vektor oder Matrix.

Wenn x eine M × N-Matrix ist, gibt xcorr(x) eine (2M – 1) × N²-Matrix mit den Autokorrelationen und Kreuzkorrelationen der Spalten von x zurück. Wenn Sie maxlag angeben, weist r die Größe (2 x maxlag + 1) x N² auf.

Wenn S beispielsweise drei Spalten $$\text{S}=\left(\begin{array}{ccc}{x}_1& x_2& x_3\end{array}\right)$$ aufweist, wird das Ergebnis von R = xcorr(S) als

$$\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).$$

organisiert.

lags — Verzögerungsindizes

Vektor

Verzögerungsindizes, zurückgegeben als Vektor.

Mehr über

Kreuzkorrelation und Autokorrelation

Das Ergebnis von xcorr kann als Schätzung der Korrelation zweier zufälliger Sequenzen oder als deterministische Korrelation zweier deterministischer Signale interpretiert werden.

Die wahre Kreuzkorrelationssequenz zweier gemeinsamer stationärer Zufallsprozesse x_n und y_n, errechnet sich durch

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

wobei −∞ < n < ∞, das Sternchen für komplexe Konjugation steht und E der erwartete Wertoperator ist. xcorr kann die Sequenz nur schätzen, da in der Praxis nur ein finites Segment einer Realisierung des Zufallsprozesses mit unendlicher Länge verfügbar ist.

Standardmäßig berechnet xcorr „rohe“ Korrelationen ohne Normalisierung:

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

Der Ausgabevektor c verfügt über Elemente, die von

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

zurückgegeben werden

Im Allgemeinen benötigt die Korrelationsfunktion eine Normalisierung, um eine präzise Schätzung zu erzielen. Sie können die Normalisierung der Korrelation mit dem Eingabeargument scaleopt steuern.

Referenzen

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

Erweiterte Fähigkeiten

Tall Arrays

Rechnen mit Arrays, die mehr Zeilen haben, als in den Speicher passen.

Die Funktion xcorr unterstützt Tall-Arrays mit folgenden Verwendungshinweisen und Einschränkungen:

• Die Eingabe x muss ein Tall-Spaltenvektor sein.

• Die Eingabe y muss ein Nicht-Tall-Vektor sein.

• Die Syntax xcorr(x) wird nicht unterstützt.

• Die Option scaleopt wird nicht unterstützt.

• Wenn Sie maxlag angeben, muss dies maxlag <= max(numel(x),numel(y))-1 entsprechen.

• Die Ausgabe lags wird als Tall-Spaltenvektor zurückgegeben.

Weitere Informationen finden Sie unter Tall-Arrays.

C/C++ Codegenerierung

Generieren Sie C und C++ Code mit MATLAB® Coder™.

Hinweise zur Verwendung und Einschränkungen:

• Vorstehende Einsen in size(x) (Dimensionslänge 1 vor der ersten Dimensionslänge ungleich 1) müssen für jede Eingabe x konstant sein. Wenn x ein Zeilenvektor variabler Größe ist, muss er 1-mal-: sein. :-mal-: mit size(x,1) = 1 zur Laufzeit ist nicht zulässig.

Thread-Based Environment

Führen Sie mithilfe von MATLAB® backgroundPool den Code im Hintergrund aus oder machen Sie den Code mit der Parallel Computing Toolbox™ ThreadPool schneller.

Diese Funktion bietet vollständige Unterstützung für thread-basierte Umgebungen. Weitere Informationen finden Sie unter Run MATLAB Functions in Thread-Based Environment.

GPU-Arrays

Schnellere Codeausführung durch Ausführen auf einer Grafikkarte (GPU) mit der Parallel Computing Toolbox™.

Die Funktion xcorr bietet vollständige Unterstützung für Grafikkarten-Arrays. Zum Ausführen der Funktion auf einer Grafikkarte geben Sie die Eingabedaten als gpuArray (Parallel Computing Toolbox) an. Weitere Informationen finden Sie unter Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Erstellen Sie beispielsweise ein gpuArray-Objekt aus einem Signal x und berechnen Sie die normalisierte Autokorrelation.

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

Versionsverlauf

Eingeführt vor R2006a

R2019a: Von Signal Processing Toolbox zu MATLAB verschoben

Zuvor wurde für xcorr Signal Processing Toolbox™ benötigt.

Siehe auch

conv | corrcoef | cov | xcov