Red de conocimiento informático - Material del sitio web - 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)

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)

Implementación (descripción en lenguaje C)

#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