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

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

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.

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

Señal ruidosa

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

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

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

Pulso gaussiano

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

Especifique los parámetros de una señal con una frecuencia de muestreo de 44,1 kHz y una duración de señal de 1 ms. Cree un pulso gaussiano con una desviación estándar de 0,1 ms.

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

X = 1/(0.4*sqrt(2*pi))*(exp(-t.^2/(2*(0.1*1e-3)^2)));

Represente el pulso en el dominio del tiempo.

plot(t,X)
title("Gaussian Pulse in Time Domain")
xlabel("Time (t)")
ylabel("X(t)")
axis([-1e-3 1e-3 0 1.1]) 

El tiempo de ejecución de fft depende de la longitud de la transformada. Las longitudes de transformada que solo tienen factores primos pequeños dan como resultado tiempos de ejecución significativamente más rápidos que las que tienen factores primos grandes.

En este ejemplo, la longitud de señal L es 44,101, que es un número primo muy grande. Para mejorar el rendimiento de fft, identifique una longitud de entrada que sea la siguiente potencia de 2 de la longitud de señal original. Llamar a fft con esta longitud de entrada rellena el pulso X con ceros al final hasta la longitud de transformada especificada.

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("f (Hz)")
ylabel("|P(f)|^2")

Ondas de coseno

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

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,L,dim);

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

P2 = abs(Y/L);
P1 = P2(:,1:L/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/L):(Fs/2-Fs/L),P1(i,1:L/2))
    title("Row " + num2str(i) + " in the Frequency Domain")
end

Fase de sinusoides

Cree una señal que conste de dos sinusoides de frecuencias 15 Hz y 40 Hz. La primera sinusoide es una onda de coseno con fase $-\pi /4$ y la segunda es una onda de coseno con fase $\pi /2$. Muestree la señal a 100 Hz durante 1 s.

Fs = 100;
t = 0:1/Fs:1-1/Fs;
x = cos(2*pi*15*t - pi/4) + cos(2*pi*40*t + pi/2);

Calcule la transformada de Fourier de la señal. Represente la magnitud de la transformada como una función de frecuencia.

y = fft(x);
z = fftshift(y);

ly = length(y);
f = (-ly/2:ly/2-1)/ly*Fs;
stem(f,abs(z))
title("Double-Sided Amplitude Spectrum of x(t)")
xlabel("Frequency (Hz)")
ylabel("|y|")
grid

Calcule la fase de la transformada eliminando los valores de transformada de magnitud pequeña. Represente la fase como una función de frecuencia.

tol = 1e-6;
z(abs(z) < tol) = 0;

theta = angle(z);

stem(f,theta/pi)
title("Phase Spectrum of x(t)")
xlabel("Frequency (Hz)")
ylabel("Phase/\pi")
grid

Interpolación de FFT

Interpole la transformada de Fourier de una señal rellenándola con ceros.

Especifique los parámetros de una señal con una frecuencia de muestreo de 80 Hz y una duración de señal de 0,8 s.

Fs = 80;
T = 1/Fs;
L = 65;
t = (0:L-1)*T;

Cree una superposición de una señal sinusoidal de 2 Hz y sus armónicos más altos. La señal contiene una onda de coseno de 2 Hz, una onda de coseno de 4 Hz y una onda de seno de 6 Hz.

X = 3*cos(2*pi*2*t) + 2*cos(2*pi*4*t) + sin(2*pi*6*t);

Represente la señal en el dominio del tiempo.

plot(t,X)
title("Signal superposition in time domain")
xlabel("t (ms)")
ylabel("X(t)")

Calcule la transformada de Fourier de la señal.

Y = fft(X);

Calcule el espectro de amplitud de un lado de la señal.

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

En el dominio de la frecuencia, represente el espectro de un lado. Dado que el muestreo de tiempo de la señal es bastante corto, la resolución de frecuencia de la transformada de Fourier no es lo suficientemente precisa para mostrar la frecuencia de pico cerca de 4 Hz.

plot(f,P1,"-o") 
title("Single-Sided Spectrum of Original Signal")
xlabel("f (Hz)")
ylabel("|P1(f)|")

Para evaluar mejor las frecuencias de pico, puede aumentar la longitud de la ventana de análisis rellenando la señal original con ceros. Este método interpola automáticamente la transformada de Fourier de la señal con una resolución de frecuencia más precisa.

Identifique una nueva longitud de entrada que sea la siguiente potencia de 2 de la longitud de señal original. Rellene la señal X con ceros finales para ampliar su longitud. Calcule la transformada de Fourier de la señal rellenada con ceros.

n = 2^nextpow2(L);
Y = fft(X,n);

Calcule el espectro de amplitud de un lado de la señal rellenada. Dado que la longitud de la señal n aumenta de 65 a 128, la resolución de frecuencia se convierte en Fs/n, que es 0,625 Hz.

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

Represente el espectro de un lado de la señal rellenada. Este nuevo espectro muestra las frecuencias de pico cerca de 2 Hz, 4 Hz y 6 Hz dentro de la resolución de frecuencia de 0,625 Hz.

plot(f,P1,"-o") 
title("Single-Sided Spectrum of Padded Signal")
xlabel("f (Hz)")
ylabel("|P1(f)|")

Argumentos de entrada

X — Arreglo de entrada

vector | matriz | arreglo multidimensional

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: Sí

n — Longitud de transformada

[] (predeterminado) | escalar entero no negativo

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 (factores primos no mayores que 7). 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

dim — Dimensión en la que operar

escalar entero positivo

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,[],2) opera en 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. 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

Y — Representación del dominio de la frecuencia

vector | matriz | arreglo multidimensional

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

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:

$$\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 n raíces de unidad.

Sugerencias

• El tiempo de ejecución de fft depende de la longitud de la transformada. Las longitudes de transformada que solo tienen factores primos pequeños (no mayores que 7) dan como resultado tiempos de ejecución significativamente más rápidos que las que son primos 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

[1] FFTW (https://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 y limitaciones de uso:

• Para obtener más información sobre las limitaciones relacionadas con datos de tamaño variable, consulte Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

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

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

• Utilizando la biblioteca de sustitución de código (CRL), puede generar código optimizado que funciona en procesadores ARM^® Cortex^®-A con extensión Neon. Para generar este código optimizado, debe instalar el paquete de soporte Embedded Coder^® para procesadores ARM Cortex-A (Embedded Coder Support Package for ARM Cortex-A Processors). El código generado para ARM Cortex-A utiliza la biblioteca Ne10. Para obtener más información, consulte Condiciones Ne10 para que las funciones de MATLAB sean compatibles con procesadores ARM Cortex-A (Embedded Coder Support Package for ARM Cortex-A Processors).

• Utilizando la biblioteca de sustitución de código (CRL), puede generar código optimizado que funciona en procesadores ARM Cortex-M. Para generar este código optimizado, debe instalar el paquete de soporte Embedded Coder para procesadores ARM Cortex-M (Embedded Coder Support Package for ARM Cortex-M Processors). El código generado para ARM Cortex-M utiliza la biblioteca CMSIS. Para obtener más información, consulte Condiciones CMSIS para que las funciones de MATLAB sean compatibles con procesadores ARM Cortex-M (Embedded Coder Support Package for ARM Cortex-M Processors).

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 Run MATLAB Functions in Thread-Based Environment.

Arreglos GPU

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

Notas y limitaciones de uso:

• La salida Y siempre es compleja, aunque todas las partes imaginarias sean cero.

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

Notas y limitaciones de uso:

• Para arreglos distribuidos, en lugar de utilizar un algoritmo FFT paralelo, fft reúne vectores en un único worker para realizar varias FFT de longitud prima. Para FFT de vector de longitud prima grande pueden aparecer errores de memoria insuficiente.

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

fft2 | fftn | fftw | fftshift | ifft | interpft

Temas

• Transformadas de Fourier

Sitios web externos

• Análisis de Fourier (Recursos de enseñanza de MathWorks)

×

Abrir ejemplo

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

No, sobrescribir la versión modificada Sí