fft

Transformada rápida de Fourier

Sintaxis

Y = fft(X)

Y = fft(X,n)

Y = fft(X,n,dim)

Descripción

Y = fft(X) calcula la transformada discreta de Fourier (DFT) de X usando 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 array multidimensional, fft(X) trata los valores a lo largo de la primera dimensión del array cuyo tamaño no sea igual a 1 como vectores y devuelve la transformada de Fourier de cada vector.

Y = fft(X,n) devuelve la DFT del punto n. 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, entonces X se rellena con ceros finales hasta la longitud de n.

• Si X es un vector y la longitud de X es mayor que n, entonces X se trunca hasta la longitud de n.

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

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

Y = fft(X,n,dim) devuelve la transformada de Fourier a lo largo de la dimensión dim. Por ejemplo, si X es una matriz, fft(X,n,2) devuelve la transformada de Fourier del punto n de cada fila.

Ejemplos

Señal ruidosa

Utilice 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 que contenga una sinusoide de 50 Hz de amplitud 0,7 y una sinusoide de 120 Hz de amplitud 1.

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

Dañe la señal con ruido blanco de media cero con una variación de 4.

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

Trace la señal ruidosa en el dominio del tiempo. Es difícil identificar los componentes de frecuencia observando 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)')

Calcule la transformada de Fourier de la señal.

Y = fft(X);

Calcule el espectro bilateral P2. A continuación, calcule el espectro unilateral P1 basado en P2 y la longitud de la señal de valor uniforme 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 gráficamente el espectro de amplitud unilateral P1. Las amplitudes no son exactamente de 0,7 y 1, como se esperaba, debido al ruido añadido. Como promedio, 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)|')

Ahora, tome la transformada de Fourier de la señal original, la señal sin dañar 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)|')

Pulso gaussiano

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

Defina los parámetros de la 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 gráficamente el pulso en el dominio del tiempo.

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

Para utilizar la función fft a fin de 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 la 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 trace las frecuencias únicas.

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

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

Ondas cosenoidales

Compare las ondas cosenoidales en el dominio del tiempo y el 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 donde cada fila represente una onda cosenoidal con la frecuencia escalada. El resultado, X, es una matriz de 3 por 1000. 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];

Trace las primeras 100 entradas de cada fila de X en una sola 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

Para fines de rendimiento del algoritmo, fft 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 potencia superior de 2 de la longitud actual. Defina la nueva longitud mediante la función nextpow2.

n = 2^nextpow2(L);

Especifique el argumento dim para utilizar fft a lo largo de 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 bilateral y el espectro unilateral 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 gráficamente el espectro de amplitud unilateral para cada fila en una sola 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

Argumentos de entrada

X — Array de entrada

vector | matriz | array multidimensional

Array de entrada, especificado como vector, matriz o array multidimensional.

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

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

n — Longitud de transformada

[] (predeterminado) | escalar entero no negativo

Longitud de la transformada, especificada como [] o un escalar entero no negativo. La especificación de un escalar entero positivo para la longitud de la transformada puede aumentar el rendimiento de fft. La longitud se especifica normalmente como una potencia de 2 o un valor que puede ser factorizado en un producto de números primos pequeños. Si n es menor que la longitud de la señal, fft omite los valores de señal restantes más allá de la n.ª 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

dim — Dimensión en la que operar

escalar entero positivo

Dimensión en la que operar, especificada como un escalar entero positivo. Si no se especifica ningún valor, la opción predeterminada es la primera dimensión del array cuyo tamaño no sea igual a 1.

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

  

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

  

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

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

Argumentos de salida

Y — Representación del dominio de la frecuencia

vector | matriz | array multidimensional

Representación del dominio de la frecuencia que se devuelve como vector, matriz o array multidimensional.

Si X es del tipo single, fft realiza el cálculo de forma nativa con precisión simple, y Y es también del tipo single. De lo contrario, Y se devuelve con el 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 de todas las demás dimensiones permanece 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

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 con una longitud n, estas transformadas se definen como sigue:

$$\begin{array}{l}Y(k)={\displaystyle \sum _{j=1}^{n}X}(j)W_n^{(j-1)\text{}(k-1)}\\ X(j)=\frac{1}{n}{\displaystyle \sum _{k=1}^{n}Y}(k)W_n{}^{-(j-1)\text{}(k-1)},\end{array}$$

donde

$$W_n=e^{(-2\pi i)/n}$$

es una de las n raíces de la unidad.

Sugerencias

• El tiempo de ejecución de fft depende de la longitud de la transformada. El tiempo es más rápido para las potencias de dos y casi tan rápido para las longitudes que solo tienen factores primos pequeños. El tiempo es típicamente varias veces más lento para las longitudes que son primas o que tienen factores primos grandes.

• Para la mayoría de los valores de n, las DFT de entrada real requieren aproximadamente la mitad del tiempo de cálculo que las DFT de entrada compleja. Sin embargo, cuando n tiene factores primos grandes, hay poca o ninguna diferencia de velocidad.

• Puede aumentar potencialmente la velocidad de fft mediante la función de utilidad fftw. Esta función controla la optimización del algoritmo utilizado para calcular una FFT de un tamaño y una dimensión concretos.

Algoritmos

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

Referencias

[1] FFTW (http://www.fftw.org)

[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 C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas de uso y limitaciones:

• Para ver las limitaciones relacionadas con los datos de tamaño variable, consulte Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

• Para la salida MEX, MATLAB^® Coder™ utiliza la librería que MATLAB emplea para los algoritmos FFT. Para el código C/C++ independiente, de forma predeterminada, el generador de código produce código para los algoritmos FFT en lugar de producir llamadas a la librería FFT. Para generar llamadas a una librería FFTW instalada específica, proporcione una clase de devolución de llamada a librería FFT. Para obtener más información acerca de una clase de devolución de llamada a librería FFT, consulte coder.fftw.StandaloneFFTW3Interface (MATLAB Coder).

• Para la simulación de un bloque MATLAB Function, el software de simulación utiliza la librería que MATLAB emplea para los algoritmos FFT. Para la generación de código de C/C++, de forma predeterminada, el generador de código produce código para los algoritmos FFT en lugar de producir llamadas a librería FFT. Para generar llamadas a una librería FFTW instalada específica, proporcione una clase de devolución de llamada a librería FFT. Para obtener más información acerca de una clase de devolución de llamada a librería FFT, consulte coder.fftw.StandaloneFFTW3Interface (MATLAB Coder).

Consulte también

fft2 | fftn | fftshift | fftw | ifft

Temas

• Fourier Transforms

Introducido antes de R2006a

×

Abrir ejemplo

Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?

No, sobrescribir la versión modificada Sí