Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

fftfilt

Filtrado FIR basado en FFT utilizando el método de superposición-adición

Sintaxis

y = fftfilt(b,x)
y = fftfilt(b,x,n)
y = fftfilt(d,x)
y = fftfilt(d,x,n)
y = fftfilt(gpuArrayb,gpuArrayX,n)

Descripción

filtra los datos utilizando el método basado en FFT eficiente de, una técnica de filtrado de dominio de frecuencia que sólo funciona para los filtros FIR.fftfiltoverlap-add

y = fftfilt(b,x) filtra los datos en Vector con el filtro descrito por vector de coeficiente.xb Devuelve el vector de datos.y La operación realizada por se describe en la ecuación de diferencia:fftfilttime domain

y(n)=b(1)x(n)+b(2)x(n1)++b(nb+1)x(nnb)

Una representación equivalente es la transformación Z o la descripción:frequency domain

Y(z)=(b(1)+b(2)z1++b(nb+1)znb)X(z)

De forma predeterminada, elige una longitud FFT y una longitud de bloque de datos que garantizan un tiempo de ejecución eficiente.fftfilt

Si es una matriz, filtra sus columnas.xfftfilt Si es una matriz, aplica el filtro en cada columna del vector de señal.bfftfiltbx Si y son ambas matrices con el mismo número de columnas, la columna TH de se utiliza para filtrar la columna TH de.bxibix

y = fftfilt(b,x,n) utiliza para determinar la longitud de la FFT.n Consulte para obtener información.Algoritmos

y = fftfilt(d,x) filtra los datos en Vector con un objeto,.xdigitalFilterd Se utiliza para generar según las especificaciones de frecuencia-respuesta.designfiltd

y = fftfilt(d,x,n) utiliza para determinar la longitud de la FFT.n

y = fftfilt(gpuArrayb,gpuArrayX,n) filtra los datos en el objeto, con los coeficientes del filtro FIR en el,.gpuArraygpuArrayXgpuArraygpuArrayb Consulte para obtener más información sobre los objetos.Run MATLAB Functions on a GPU (Parallel Computing Toolbox)gpuArray El uso de objetos requiere software.fftfiltgpuArrayParallel Computing Toolbox™ Consulte para ver qué GPU son compatibles.GPU Support by Release (Parallel Computing Toolbox) Los datos filtrados,, es un objeto.ygpuArray Vea por ejemplo el filtrado de superposición-agregar en la GPU.Superposición-añadir filtrado en la GPU

funciona tanto para entradas reales como complejas.fftfilt

Comparación con la funciónfilter

Cuando la señal de entrada es relativamente grande, es ventajoso utilizar en vez de, que realiza multiplicaciones para cada muestra en, donde está la longitud del filtro. realiza 2 operaciones FFT — la FFT del bloque de señal de longitud más el FT inverso del producto de las FFTs — a costa defftfiltfilterNxNfftfiltL

1/2 logL2L

donde está la longitud del bloque.L A continuación, realiza multiplicaciones puntuales para un costo total deL

+ logLL2= (1 + logLL2)L

Multiplicaciones. Por lo tanto, la relación de coste

(1 + logL2)/() = (1 + logLNL2)/LN

que es aproximadamente log2/  .LN

Por lo tanto, se vuelve ventajoso cuando el registrofftfilt2es menor que.LN

Ejemplos

contraer todo

Compruebe que es más eficaz para los operandos más pequeños y es más eficaz para los operandos de gran tamaño.filterfftfilt Filtro

<math display="inline">
<mrow>
<msup>
<mrow>
<mn>10</mn>
</mrow>
<mrow>
<mn>6</mn>
</mrow>
</msup>
</mrow>
</math>
números aleatorios con dos filtros aleatorios: uno corto, con 20 grifos, y uno largo, con 2000. Utilice y para medir los tiempos de ejecución.tictoc Repite el experimento 100 veces para mejorar las estadísticas.

rng default  N = 100;  shrt = 20; long = 2000;  tfs = 0; tls = 0; tfl = 0; tll = 0;  for kj = 1:N          x = rand(1,1e6);      bshrt = rand(1,shrt);      tic     sfs = fftfilt(bshrt,x);     tfs = tfs+toc/N;      tic     sls = filter(bshrt,1,x);     tls = tls+toc/N;      blong = rand(1,long);      tic     sfl = fftfilt(blong,x);     tfl = tfl+toc/N;          tic     sll = filter(blong,1,x);     tll = tll+toc/N;  end

Compare los tiempos promedio.

fprintf('%4d-tap filter averages: fftfilt: %f s; filter: %f s\n',shrt,tfs,tls)
  20-tap filter averages: fftfilt: 0.390918 s; filter: 0.018025 s 
fprintf('%4d-tap filter averages: fftfilt: %f s; filter: %f s\n',long,tfl,tll)
2000-tap filter averages: fftfilt: 0.119884 s; filter: 0.251052 s 

Este ejemplo requiere el software Parallel Computing Toolbox™. Consulte para ver qué GPU son compatibles.GPU Support by Release (Parallel Computing Toolbox)

Cree una señal consistente en una suma de ondas sinusoidales en el ruido de aditivo gaussiano blanco. Las frecuencias de onda sinusoidal son 2,5, 5, 10 y 15 kHz. La frecuencia de muestreo es de 50 kHz.

Fs = 50e3; t = 0:1/Fs:10-(1/Fs); x = cos(2*pi*2500*t)+0.5*sin(2*pi*5000*t)+0.25*cos(2*pi*10000*t)+ ...     0.125*sin(2*pi*15000*t)+randn(size(t));

Diseñe un filtro de equirizo de abeto paso bajo usando.designfilt

d = designfilt('lowpassfir','SampleRate',Fs, ...     'PassbandFrequency',5500,'StopbandFrequency',6000, ...     'PassbandRipple',0.5,'StopbandAttenuation',50); B = d.Coefficients;

Filtre los datos de la GPU mediante el método de superposición y adición. Ponga los datos en la GPU usando.gpuArray Devuelva la salida al espacio de trabajo de MATLAB® mediante y trace la estimación de la densidad espectral de potencia de los datos filtrados.gather

y = fftfilt(gpuArray(B),gpuArray(x)); periodogram(gather(y),rectwin(length(y)),length(y),50e3)

Algoritmos

utiliza para implementar la, una técnica que combina bloques de frecuencia sucesivos filtrados de una secuencia de entrada. rompe una secuencia de entrada en bloques de datos de longitud, donde L debe ser mayor que la longitud de filtro N.fftfiltfftoverlap-add method[1]fftfiltxL

y convoluciona cada bloque con el filtro porb

y = ifft(fft(x(i:i+L-1),nfft).*fft(b,nfft)); 

donde está la longitud FFT. solapa las secciones de salida sucesivas por puntos, donde es la longitud del filtro y las suma.nfftfftfiltn-1n

elige los parámetros clave y de diferentes maneras, dependiendo de si se suministra una longitud FFT y en las longitudes del filtro y la señal.fftfiltLnfftn Si no especifica un valor para (que determina la longitud de FFT), elige estos parámetros clave automáticamente:nfftfilt

  • Si es mayor que, elige valores que minimicen el número de bloques multiplicado por el número de fracasos por FFT.length(x)length(b)fftfilt

  • Si es mayor o igual que, utiliza un único FFT de longitudlength(b)length(x)fftfilt

    2^nextpow2(length(b) + length(x) - 1) 

    Esto esencialmente computa

    y = ifft(fft(B,nfft).*fft(X,nfft)) 

Si proporciona un valor para, elige una longitud FFT, y una longitud de bloque de datos de-+.nfftfiltnfft2^nextpow2(n)nfftlength(b)1 Si es menor que, establece en.nlength(b)fftfiltnlength(b)

Referencias

[1] Oppenheim, Alan V., Ronald W. Schafer, and John R. Buck. Discrete-Time Signal Processing. 2nd Ed. Upper Saddle River, NJ: Prentice Hall, 1999.

Capacidades ampliadas

Consulte también

| | | |

Introducido antes de R2006a