fftshift

Verschieben der Nullfrequenz-Komponente zur Mitte des Spektrums

Syntax

Y = fftshift(X)

Y = fftshift(X,dim)

Beschreibung

Y = fftshift(X) ordnet eine Fourier-Transformation X um, indem die Nullfrequenz-Komponente zur Mitte des Arrays verschoben wird.

• Wenn X ein Vektor ist, tauscht fftshift die linke und rechte Hälfte von X.

• Wenn X eine Matrix ist, tauscht fftshift den ersten und den dritten Quadranten sowie den zweiten und vierten Quadranten von X.

• Wenn X ein mehrdimensionales Array ist, tauscht fftshift die Halbräume von X entlang jeder Dimension.

Y = fftshift(X,dim) wird entlang der Dimension dim von X ausgeführt. Wenn X beispielsweise eine Matrix ist, deren Zeilen mehrere 1D-Transformationen darstellen, tauscht fftshift(X,2) die Hälften jeder Zeile von X.

Beispiele

Verschieben von Vektorelementen

Tauschen Sie die linke und rechte Hälfte eines Zeilenvektors. Wenn ein Vektor eine ungerade Anzahl Elemente aufweist, wird das mittlere Element der linken Hälfte des Vektors zugerechnet.

Xeven = [1 2 3 4 5 6];
fftshift(Xeven)

ans = 1×6

     4     5     6     1     2     3

Xodd = [1 2 3 4 5 6 7];
fftshift(Xodd)

ans = 1×7

     5     6     7     1     2     3     4

Verschieben eines 1D-Signals

Bei der Analyse der Frequenzkomponente von Signalen kann es nützlich sein, die Nullfrequenz-Komponenten zur Mitte zu verschieben.

Erstellen Sie ein Signal S, berechnen Sie dessen Fourier-Transformation und plotten Sie die Leistung.

fs = 100;               % sampling frequency
t = 0:(1/fs):(10-1/fs); % time vector
S = cos(2*pi*15*t);
n = length(S);
X = fft(S);
f = (0:n-1)*(fs/n);     %frequency range
power = abs(X).^2/n;    %power
plot(f,power)

Verschieben Sie die Nullfrequenz-Komponenten und plotten Sie die null-zentrierte Leistung.

Y = fftshift(X);
fshift = (-n/2:n/2-1)*(fs/n); % zero-centered frequency range
powershift = abs(Y).^2/n;     % zero-centered power
plot(fshift,powershift)

Verschieben von Signalen in der Matrix

Sie können mehrere 1D-Signale verarbeiten, indem Sie diese als Zeilen in einer Matrix darstellen. Daraufhin können Sie über das Argument „Dimension“ die Fourier-Transformation berechnen und die Nullfrequenz-Komponenten für jede Zeile verschieben.

Erstellen Sie eine Matrix A, deren Zeilen zwei 1D-Signale darstellen und berechnen Sie die Fourier-Transformation jedes Signals. Plotten Sie die Leistung jedes Signals.

fs = 100;               % sampling frequency
t = 0:(1/fs):(10-1/fs); % time vector
S1 = cos(2*pi*15*t);
S2 = cos(2*pi*30*t);
n = length(S1);
A = [S1; S2];
X = fft(A,[],2);
f = (0:n-1)*(fs/n);     % frequency range
power = abs(X).^2/n;    % power
plot(f,power(1,:),f,power(2,:))

Verschieben Sie die Nullfrequenz-Komponenten und plotten Sie die null-zentrierte Leistung jedes Signals.

Y = fftshift(X,2);
fshift = (-n/2:n/2-1)*(fs/n); % zero-centered frequency range
powershift = abs(Y).^2/n;     % zero-centered power
plot(fshift,powershift(1,:),fshift,powershift(2,:))

Eingabeargumente

X — Eingabearray

Vektor | Matrix | mehrdimensionales Array

Eingabearray, angegeben als Vektor, Matrix oder mehrdimensionales Array.

Datentypen: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical
Unterstützung komplexer Zahlen: Ja

dim — Dimension, entlang der die Operation erfolgt

positiver ganzzahliger Skalar

Dimension, entlang der die Operation erfolgt, angegeben als positiver ganzzahliger Skalar. Ist kein Wert angegeben, tauscht fftshift entlang aller Dimensionen.

• Angenommen, es liegt eine Eingabematrix Xc vor: Die Operation fftshift(Xc,1) tauscht die Hälften jeder Spalte von Xc.

  

• Angenommen, es liegt eine Matrix Xr vor: Die Operation fftshift(Xr,2) tauscht die Hälften jeder Zeile von Xr.

  

Datentypen: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Erweiterte Fähigkeiten

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

GPU-Codegenerierung
Generieren von CUDA® Code für NVIDIA® Grafikprozessoren mit dem GPU Coder™.

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 fftshift 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).

Verteilte Arrays

Partitionieren von großen Arrays über den kombinierten Speicher Ihres Clusters mit Parallel Computing Toolbox™.

Diese Funktion bietet vollständige Unterstützung für verteilte Arrays. Weitere Informationen finden Sie unter Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Versionsverlauf

Eingeführt vor R2006a

Siehe auch

ifftshift | fft | fft2 | fftn | fftw