Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

fft

Transformada rápida de Fourier

Descripción

ejemplo

Y = fft(X) calcula la transformada discreta de Fourier (DFT) de X utilizando un algoritmo de transformada rápida de Fourier (FFT).

  • Si X es un vector, fft(X) devuelve la transformada de Fourier del vector.

  • Si X es una matriz, fft(X) trata las columnas de X como vectores y devuelve la transformada de Fourier de cada columna.

  • Si X es un arreglo multidimensional, fft(X) trata los valores en la primera dimensión del arreglo cuyo tamaño no es igual a 1 como vectores y devuelve la transformada de Fourier de cada vector.

ejemplo

Y = fft(X,n) devuelve la DFT de n puntos. Si no se especifica ningún valor, Y tiene el mismo tamaño que X.

  • Si X es un vector y la longitud de X es menor que n, X se rellena con ceros finales hasta la longitud n.

  • Si X es un vector y la longitud de X es mayor que n, X está truncado a la longitud n.

  • Si X es una matriz, cada columna se trata como en el caso del vector.

  • Si X es un arreglo multidimensional, la primera dimensión del arreglo cuyo tamaño no es igual a 1 se trata como en el caso del vector.

ejemplo

Y = fft(X,n,dim) devuelve la transformada de Fourier en la dimensión dim. Por ejemplo, si X es una matriz, fft(X,n,2) devuelve la transformada de Fourier de n puntos de cada fila.

Ejemplos

contraer todo

Use las transformadas de Fourier para encontrar los componentes de frecuencia de una señal enterrada en ruido.

Especifique los parámetros de una señal con una frecuencia de muestreo de 1 kHz y una duración de señal de 1,5 segundos.

Fs = 1000;            % Sampling frequency                    
T = 1/Fs;             % Sampling period       
L = 1500;             % Length of signal
t = (0:L-1)*T;        % Time vector

Forme una señal con una sinusoide de 50 Hz de 0,7 de amplitud y una sinusoide de 120 Hz de 1 de amplitud.

S = 0.7*sin(2*pi*50*t) + sin(2*pi*120*t);

Corrompa la señal con ruido blanco de media cero con una varianza de 4.

X = S + 2*randn(size(t));

Represente la señal ruidosa en el dominio del tiempo. Es difícil identificar los componentes de frecuencia mirando la señal X(t).

plot(1000*t(1:50),X(1:50))
title('Signal Corrupted with Zero-Mean Random Noise')
xlabel('t (milliseconds)')
ylabel('X(t)')

Figure contains an axes object. The axes object with title Signal Corrupted with Zero-Mean Random Noise contains an object of type line.

Calcule la transformada de Fourier de la señal.

Y = fft(X);

Calcule el espectro de dos lados P2. Luego calcule el espectro de un lado P1 basado en P2 y la longitud de señal de valor par L.

P2 = abs(Y/L);
P1 = P2(1:L/2+1);
P1(2:end-1) = 2*P1(2:end-1);

Defina el dominio de la frecuencia f y represente el espectro de amplitud de un lado P1. Las amplitudes no están exactamente en 0,7 y 1, tal y como se esperaba, debido al ruido añadido. De media, las señales más largas producen mejores aproximaciones de frecuencia.

f = Fs*(0:(L/2))/L;
plot(f,P1) 
title('Single-Sided Amplitude Spectrum of X(t)')
xlabel('f (Hz)')
ylabel('|P1(f)|')

Figure contains an axes object. The axes object with title Single-Sided Amplitude Spectrum of X(t) contains an object of type line.

Ahora tome la transformada de Fourier de la señal original sin corromper y recupere las amplitudes exactas, 0,7 y 1,0.

Y = fft(S);
P2 = abs(Y/L);
P1 = P2(1:L/2+1);
P1(2:end-1) = 2*P1(2:end-1);

plot(f,P1) 
title('Single-Sided Amplitude Spectrum of S(t)')
xlabel('f (Hz)')
ylabel('|P1(f)|')

Figure contains an axes object. The axes object with title Single-Sided Amplitude Spectrum of S(t) contains an object of type line.

Convierta un pulso gaussiano del dominio del tiempo al dominio de la frecuencia.

Defina los parámetros de señal y un pulso gaussiano, X.

Fs = 100;           % Sampling frequency
t = -0.5:1/Fs:0.5;  % Time vector 
L = length(t);      % Signal length

X = 1/(4*sqrt(2*pi*0.01))*(exp(-t.^2/(2*0.01)));

Represente el pulso en el dominio del tiempo.

plot(t,X)
title('Gaussian Pulse in Time Domain')
xlabel('Time (t)')
ylabel('X(t)')

Figure contains an axes object. The axes object with title Gaussian Pulse in Time Domain contains an object of type line.

Para usar la función fft para convertir la señal al dominio de la frecuencia, identifique primero una nueva longitud de entrada que sea la siguiente potencia de 2 de la longitud de señal original. Esto rellenará la señal X con ceros finales para mejorar el rendimiento de fft.

n = 2^nextpow2(L);

Convierta el pulso gaussiano al dominio de la frecuencia.

Y = fft(X,n);

Defina el dominio de la frecuencia y represente las frecuencias únicas.

f = Fs*(0:(n/2))/n;
P = abs(Y/n).^2;

plot(f,P(1:n/2+1)) 
title('Gaussian Pulse in Frequency Domain')
xlabel('Frequency (f)')
ylabel('|P(f)|^2')

Figure contains an axes object. The axes object with title Gaussian Pulse in Frequency Domain contains an object of type line.

Compare las ondas de coseno del dominio del tiempo y del dominio de la frecuencia.

Especifique los parámetros de una señal con una frecuencia de muestreo de 1 kHz y una duración de señal de 1 segundo.

Fs = 1000;                    % Sampling frequency
T = 1/Fs;                     % Sampling period
L = 1000;                     % Length of signal
t = (0:L-1)*T;                % Time vector

Cree una matriz en la que cada fila represente una onda de coseno con frecuencia escalada. El resultado, X, es una matriz de 3 por 1.000. La primera fila tiene una frecuencia de onda de 50, la segunda fila tiene una frecuencia de onda de 150 y la tercera fila tiene una frecuencia de onda de 300.

x1 = cos(2*pi*50*t);          % First row wave
x2 = cos(2*pi*150*t);         % Second row wave
x3 = cos(2*pi*300*t);         % Third row wave

X = [x1; x2; x3];

Represente las primeras 100 entradas de cada fila de X en una única figura en orden y compare sus frecuencias.

for i = 1:3
    subplot(3,1,i)
    plot(t(1:100),X(i,1:100))
    title(['Row ',num2str(i),' in the Time Domain'])
end

Figure contains 3 axes objects. Axes object 1 with title Row 1 in the Time Domain contains an object of type line. Axes object 2 with title Row 2 in the Time Domain contains an object of type line. Axes object 3 with title Row 3 in the Time Domain contains an object of type line.

Para fines de rendimiento del algoritmo, fft le permite rellenar la entrada con ceros finales. En este caso, rellene cada fila de X con ceros para que la longitud de cada fila sea la siguiente mayor potencia de 2 de la longitud actual. Defina la nueva longitud utilizando la función nextpow2.

n = 2^nextpow2(L);

Especifique el argumento dim para usar fft en las filas de X, es decir, para cada señal.

dim = 2;

Calcule la transformada de Fourier de las señales.

Y = fft(X,n,dim);

Calcule el espectro de dos lados y el espectro de un lado de cada señal.

P2 = abs(Y/L);
P1 = P2(:,1:n/2+1);
P1(:,2:end-1) = 2*P1(:,2:end-1);

En el dominio de la frecuencia, represente el espectro de amplitud de un lado para cada fila en una única figura.

for i=1:3
    subplot(3,1,i)
    plot(0:(Fs/n):(Fs/2-Fs/n),P1(i,1:n/2))
    title(['Row ',num2str(i),' in the Frequency Domain'])
end

Figure contains 3 axes objects. Axes object 1 with title Row 1 in the Frequency Domain contains an object of type line. Axes object 2 with title Row 2 in the Frequency Domain contains an object of type line. Axes object 3 with title Row 3 in the Frequency Domain contains an object of type line.

Argumentos de entrada

contraer todo

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

Si X es una matriz de 0 por 0 vacía, fft(X) devuelve una matriz de 0 por 0 vacía.

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

Longitud de transformada, especificada como [] o un escalar entero no negativo. Especificar un escalar entero positivo para la longitud de transformada puede mejorar el rendimiento de fft. La longitud se especifica normalmente como una potencia de 2 o un valor que puede factorizarse en un producto de números primos pequeños. Si n es menor que la longitud de la señal, fft ignora el resto de valores de señal más allá de la n-ésima entrada y devuelve el resultado truncado. Si n es 0, fft devuelve una matriz vacía.

Ejemplo: n = 2^nextpow2(size(X,1))

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

Dimensión en la que operar, especificada como escalar entero positivo. Si no especifica la dimensión, el valor predeterminado es la primera dimensión del arreglo de tamaño mayor que 1.

  • fft(X,[],1) opera en las columnas de X y devuelve la transformada de Fourier de cada columna.

    fft(X,[],1) column-wise operation

  • fft(X,[],2) opera en las filas de X y devuelve la transformada de Fourier de cada fila.

    fft(X,[],2) row-wise operation

Si dim es mayor que ndims(X), fft(X,[],dim) devuelve X. Si se especifica n, fft(X,n,dim) rellena o trunca X a la longitud n en la dimensión dim.

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

Argumentos de salida

contraer todo

Representación del dominio de la frecuencia devuelta como vector, matriz o arreglo multidimensional.

Si X es del tipo single, fft calcula de forma nativa en precisión simple e Y es también del tipo single. De lo contrario, Y se devuelve como tipo double.

El tamaño de Y es el siguiente:

  • Para Y = fft(X) o Y = fft(X,[],dim), el tamaño de Y es igual al tamaño de X.

  • Para Y = fft(X,n,dim), el valor de size(Y,dim) es igual a n, mientras que el tamaño del resto de dimensiones se mantiene como en X.

Si X es real, Y es simétrica conjugada y el número de puntos únicos en Y es ceil((n+1)/2).

Tipos de datos: double | single

Más acerca de

contraer todo

Transformada discreta de Fourier de un vector

Y = fft(X) y X = ifft(Y) implementan la transformada de Fourier y la transformada inversa de Fourier, respectivamente. Para X e Y de longitud n, estas transformadas se definen de la siguiente manera:

Y(k)=j=1nX(j)Wn(j1)(k1)X(j)=1nk=1nY(k)Wn(j1)(k1),

donde

Wn=e(2πi)/n

es una de n raíces de unidad.

Sugerencias

  • El tiempo de ejecución para fft depende de la longitud de la transformada. Las longitudes de transformada que solo tienen factores primos pequeños son significativamente más rápidas que las que son primas o tienen factores primos grandes.

  • Para la mayoría de valores de n, las DFT de entrada real requieren aproximadamente la mitad de tiempo de cálculo que las DFT de entrada compleja. No obstante, cuando n tiene factores primos grandes la diferencia de velocidad es nula o mínima.

  • Es posible aumentar la velocidad de fft utilizando la función de utilidades, fftw. Esta función controla la optimización del algoritmo usado para calcular una FFT de tamaño y dimensiones específicos.

Algoritmos

Las funciones FFT (fft, fft2, fftn, ifft, ifft2, ifftn) se basan en una biblioteca llamada FFTW [1] [2].

Referencias

[2] Frigo, M., and S. G. Johnson. “FFTW: An Adaptive Software Architecture for the FFT.” Proceedings of the International Conference on Acoustics, Speech, and Signal Processing. Vol. 3, 1998, pp. 1381-1384.

Capacidades ampliadas

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

Historial de versiones

Introducido antes de R2006a

Consulte también

| | | |