La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

fftshift

Décaler le composant à fréquence nulle au centre du spectre

Syntaxe

Y = fftshift(X)

Y = fftshift(X,dim)

Description

Y = fftshift(X) réorganiser une Transformée de Fourier X en décalant le composant à fréquence nulle au centre du tableau.

• Si X est un vecteur, alors fftshift inverses les moitiés droite et gauche de X.

• Si X est une matrice, alors fftshift inverse le premier quadrant de X avec le troisième, et le deuxième avec la quatrième.

• Si X est un tableau multidimensionnel, alors fftshift inverse les demi-espaces de X le long de chaque dimension.

Y = fftshift(X,dim) opère le long de la dimension dim de X. Par exemple, si X est une matrice dont les lignes représentent plusieurs transformées en 1D, alors fftshift(X,2) inverse les moitiés de chaque ligne de X.

Exemples

Décaler les éléments d'un vecteur

Inversez les moitiés droite et gauche d’un vecteur ligne. Si un vecteur a un nombre impair d’éléments, l’élément du milieu est considéré comme appartenant à la moitié gauche du vecteur.

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

Décaler un signal 1D

Lorsque vous analysez les composants de fréquence des signaux, le fait de décaler les composants à fréquence nulle au centre peut s’avérer pertinent.

Créez un signal S, calculez sa transformée de Fourier et tracez la puissance.

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)

Décalez les composants à fréquence nulle et tracez la puissance centrée sur zéro.

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)

Décaler les signaux dans une matrice

Vous pouvez traiter de multiples signaux 1D en les représentant en tant que lignes dans une matrice. Utilisez ensuite l’argument de dimension pour calculer la transformée de Fourier et décaler les composants à fréquence nulle pour chaque ligne.

Créez une matrice A dont les lignes représentent deux signaux 1D, puis calculez la transformée de Fourier de chaque signal. Tracez la puissante pour chaque signal.

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

Décalez les composants à fréquence nulle et tracez la puissance centrée sur zéro de chaque signal.

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

Arguments d'entrée

X — Tableau en entrée

vecteur | matrice | tableau multidimensionnel

Tableau d’entrées, spécifié sous forme de vecteur, de matrice ou de tableau multidimensionnel.

Types de données : double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical
Support des nombres complexes : Oui

dim — Dimension sur laquelle opérer

scalaire entier positif

Dimension sur laquelle opérer, spécifiée en tant que scalaire entier positif. Si aucune valeur n’est spécifiée, alors fftshift effectue l’inversion le long de toutes les dimensions.

• Prenez une matrice d’entrées Xc. L’opération fftshift(Xc,1) inverse les moitiés de chaque colonne de Xc.

  

• Prenez une matrice Xr. L’opération fftshift(Xr,2) inverse les moitiés de chaque ligne de Xr.

  

Types de données : double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Capacités étendues

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

Génération de code GPU
Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

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

Cette fonction supporte entièrement les GPU arrays. Pour plus d’informations, consultez Exécutez les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Distributed arrays

Divisez les tableaux volumineux dans la mémoire combinée de votre cluster avec Parallel Computing Toolbox™.

Cette fonction supporte entièrement les distributed arrays. Pour plus d’informations, consultez Exécuter des fonctions MATLAB avec des tableaux distribués (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

Voir aussi

ifftshift | fft | fft2 | fftn | fftw