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

fftshift

Spostare il componente a frequenza zero al centro dello spettro

Sintassi

Y = fftshift(X)

Y = fftshift(X,dim)

Descrizione

Y = fftshift(X) riorganizza una trasformata di Fourier X spostando il componente a frequenza zero al centro dell'array.

• Se X è un vettore, fftshift inverte la metà destra e sinistra di X.

• Se X è una matrice, fftshift inverte il primo quadrante di X con il terzo e il secondo quadrante con il quarto.

• Se X è un array multidimensionale, fftshift inverte la metà degli spazi di X lungo ciascuna dimensione.

Y = fftshift(X,dim) opera lungo la dimensione dim di X. Ad esempio, se X è una matrice le cui righe rappresentano più trasformate monodimensionali, fftshift(X,2) inverte le metà di ciascuna riga di X.

Esempi

Spostamento di elementi del vettore

Invertire le metà destra e sinistra di un vettore di riga. Se un vettore ha un numero dispari di elementi, l'elemento centrale viene considerato parte della metà sinistra del vettore.

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

Spostamento di segnale monodimensionale

Quando si analizzano i componenti di frequenza dei segnali, può risultare utile spostare i componenti a frequenza zero verso il centro.

Creare un segnale S, calcolare la sua trasformata di Fourier e tracciare la potenza.

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)

Spostare i componenti a frequenza zero e tracciare la potenza centrata sullo zero.

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)

Spostamento dei segnali nella matrice

È possibile elaborare più segnali monodimensionali rappresentandoli come righe di una matrice. Utilizzare quindi l'argomento dimensione per calcolare la trasformata di Fourier e spostare i componenti a frequenza zero per ciascuna riga.

Creare una matrice A le cui righe rappresentino due segnali monodimensionali e calcolare la trasformata di Fourier di ciascun segnale. Tracciare la potenza per ciascun segnale.

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,:))

Spostare i componenti a frequenza zero e tracciare la potenza centrata sullo zero di ciascun segnale.

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,:))

Argomenti di input

X — Array di input

vettore | matrice | array multidimensionale

Array di input, specificato come vettore, matrice o array multidimensionale.

Tipi di dati: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical
Supporto numeri complessi: Sì

dim — Dimensione lungo la quale operare

scalare intero positivo

Dimensione lungo la quale operare, specificata come scalare intero positivo. Se non è specificato alcun valore, fftshift esegue l'inversione lungo tutte le dimensioni.

• Considerare una matrice di input Xc. L'operazione fftshift(Xc,1) inverte le metà di ciascuna colonna di Xc.

  

• Considerare una matrice Xr. L'operazione fftshift(Xr,2) inverte le metà di ciascuna riga di Xr.

  

Tipi di dati: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Funzionalità estese

Generazione di codice C/C++
Genera codice C e C++ con MATLAB® Coder™.

Generazione di codice GPU
Genera codice CUDA® per GPU NVIDIA® con GPU Coder™.

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

Array distribuiti

Partiziona array di grandi dimensioni nella memoria combinata del cluster con Parallel Computing Toolbox™.

Questa funzione supporta completamente gli array distribuiti. Per maggiori informazioni, vedere Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Cronologia versioni

Introduzione prima di R2006a

Vedi anche

ifftshift | fft | fft2 | fftn | fftw