La optimización del algoritmo basada en FFT se convierte en un programa completo en lenguaje C (utilizando las propiedades de los factores de rotación). Si tiene alguna pregunta, deje un mensaje y gracias (¡¡tengo el código central y !!! Espero orientación)
#include lt;stdio.hgt;
#include lt;math.hgt;
#include lt;stdlib.hgt ;
//#incluye "complejo.h"
//--------------------- --- -----------------------------------------
#define N 8 //64
#define M 3 //6 //2^m=N
#define PI 3.1415926
//------------------------------------------------ --------------------------
giro flotante[N/2] = {1.0, 0.707, 0.0, -0.707 };
flotar x_r[N] = {1, 1, 1, 0, 0, 0, 0, 0};
flotar x_i[N]; 8
/*
giro flotante[N/2] = {1, 0,9951, 0,9808, 0,9570, 0,9239, 0,8820, 0,8317, 0,7733,
0,7075 , 0,6349, 0,5561, 0,4721, 0,3835, 0,2912, 0,1961, 0,0991,
0,0000, -0,0991, - 0,1961, -0,2912, -0,3835, -0,4721, - 0,5561, - 0,6349,
-0.7075, -0.7733, 0.8317, -0.8820, -0.9239, -0.9570, -0.9808, -0.9951}; //N=64
// Factor de rotación, necesita optimización.
..
tw1 = cos(2*PI*(p paso)/pow(2, cur_layer));
tw2 = -sin(2*PI*(p paso) /pow(2, cur_layer));
x_r[k p paso] = tmp_real ( tw1* temp - tw2*x_i[k p paso]
x_i[k p paso] = tmp_imag (tw2*temp tw1*x_i[k p paso]);
printf("k=d, x_r[k]=f, x_i[k]=f\n", k p, x_r[k p ], x_i[k p]);
printf("k=d, x_r[k]=f, x_i[k]=f\n", k p paso, x_r[k p paso], x_i[ k p paso]);
}
/* ¡Activa el salto! :)*/
k = 2*paso;
}
}
}
}
/*
* Posdata:
* Ya sea que las partículas estén en bucle en la capa exterior o la entrada de muestra esté en bucle en la capa exterior, parecen ser similar y la complejidad es exactamente la misma.
* Pero me tomó mucho tiempo descifrar estas docenas de líneas de código.
* Una de las lecciones que me ayudó mucho es que hace mucho tiempo escribí algunos algoritmos, la mayoría de los cuales eran recursivos.
* Se necesitan unas 3 capas para conseguir un patrón. Lo mismo ocurre con la recursividad: escribe una o dos capas y ¡el patrón surgirá!
* 2. Algunas funciones pueden reducir la complejidad mediante pseudocodificación, es decir, sin apresurarse a obtener el resultado, sino agregando resultados lógicos después de la finalización.
* Por ejemplo, puedes escribir el factor de rotación como 1,0. Puede escribir los factores de rotación después del procesamiento.
*En resumen, ¡sudo mucho!
*/
void dft( void )
{
int i, n, k, tx1, tx2;
flotador tw1, tw2
flotante xx_r[N], xx_i[N]
/*
/*
*Borra cualquier dato en Real y escribe 1.0.
> * Borre cualquier dato en las matrices de resultados reales e imaginarios antes de DFT
*/
for(k=0; klt;=N-1; k)
xx_r[k] = xx_i[k] = x_i[k] = 0.0
// Calcular DFT
for(k=0; klt;=(N- 1 ); k )
{
for(n=0; nlt;=(N-1); n )
{
tx1 = (n*k);
tx2 = tx1 ( 3*N)/4
tx1 = tx1(N); tx2(N);
if (tx1 gt; = (N/2))
tw1 = -twiddle[ tx1-(N/2)]
En caso contrario
tw1 = twiddle[tx1];
if (tx2 gt; = (N/2)
tw2 = -twiddle[tx2- ( N/2)];
De lo contrario
tw2 = twiddle[tx2]
xx_r[k] = xx_r[k] x_r[n]* tw1
xx_i[k] = xx_i[k] x_r[n]*tw2
}
xx_i[k] = - xx_i; [k];
}
// mostrar
for(i=0; ilt; N; i)
printf ( " f\tf\n", xx_r[i], xx_i[i]);
}
// ------------- - -------------------------------------------------- -----------
int main( void )
{
fft_init( );
bitrev ( );
// bitrev2( );
//fft1(
fft2( ); ;
sistema( "pausa"
// dft();
devuelve 1;
Este artículo proviene del blog de CSDN, indique la fuente: /sshcx/archive/2007/06/14/1651616.aspx