fftshift

Desplazar un componente de frecuencia cero al centro del espectro

Sintaxis

Y = fftshift(X)

Y = fftshift(X,dim)

Descripción

Y = fftshift(X) reorganiza una transformada de Fourier X desplazando el componente de frecuencia cero al centro del arreglo.

• Si X es un vector, fftshift intercambia las mitades izquierda y derecha de X.

• Si X es una matriz, fftshift intercambia el primer cuadrante de X por el tercero, y el segundo cuadrante por el cuarto.

• Si X es un arreglo multidimensional, fftshift intercambia semiespacios de X en cada dimensión.

Y = fftshift(X,dim) opera en la dimensión dim de X. Por ejemplo, si X es una matriz cuyas filas representan múltiples transformadas 1D, fftshift(X,2) intercambia las mitades de cada fila de X.

Ejemplos

Desplazar elementos de vector

Intercambie las mitades izquierda y derecha de un vector fila. Si un vector tiene un número impar de elementos, el elemento del medio se considera parte de la mitad izquierda del vector.

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

Desplazar una señal 1D

Al analizar los componentes de frecuencia de señales, puede ser útil desplazar los componentes de frecuencia cero al centro.

Cree una señal S, calcule su transformada de Fourier y represente la potencia.

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)

Desplace los componentes de frecuencia cero y represente la potencia centrada en cero.

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)

Desplazar señales en una matriz

Puede procesar múltiples señales 1D representándolas como filas en una matriz. Después, use el argumento de dimensión para calcular la transformada de Fourier y desplazar los componentes de frecuencia cero para cada fila.

Cree una matriz A cuyas filas representen dos señales 1D y calcule la transformada de Fourier de cada señal. Represente la potencia para cada señal.

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

Desplace los componentes de frecuencia cero y represente la potencia centrada en cero de cada señal.

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

Argumentos de entrada

X — Arreglo de entrada

vector | matriz | arreglo multidimensional

Arreglo de entrada, especificado como vector, matriz o arreglo multidimensional.

Tipos de datos: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical
Soporte de números complejos: Sí

dim — Dimensión en la que operar

escalar entero positivo

Dimensión en la que operar, especificada como escalar entero positivo. Si no se especifica ningún valor, fftshift intercambia en todas las dimensiones.

• Considere una matriz de entrada Xc. La operación fftshift(Xc,1) intercambia mitades de cada columna de Xc.

  

• Considere una matriz Xr. La operación fftshift(Xr,2) intercambia mitades de cada fila de Xr.

  

Tipos de datos: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Capacidades ampliadas

Generación de código C/C++
Genere código C y C++ mediante MATLAB® Coder™.

Generación de código de GPU
Genere código CUDA® para GPU NVIDIA® mediante GPU Coder™.

Entorno basado en subprocesos

Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Esta función es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Ejecutar funciones de MATLAB en un entorno basado en subprocesos.

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

La función fftshift es totalmente compatible con los arreglos de GPU. Para ejecutar la función en una GPU, especifique los datos de entrada como un gpuArray (Parallel Computing Toolbox). Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

Esta función es totalmente compatible con los arreglos distribuidos. Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido antes de R2006a

Consulte también

ifftshift | fft | fft2 | fftn | fftw