¿Cómo implementar el algoritmo FFT en lenguaje C?
Primero realice una FFT unidimensional en cada fila y luego realice una FFT unidimensional en cada columna de la nueva matriz transformada. El pseudocódigo correspondiente es el siguiente:
for(int I = 0;i<m;i++)
FFT_1D(line [i], N);
for (int j = 0; j & ltn; j++)
FFT_1D(COL[j], M);
Donde ROW[i] representa la I-ésima fila de la matriz . Tenga en cuenta que esto es sólo una anotación simple y no se puede copiar por completo. También necesitas generar los datos para cada fila a través de algunas declaraciones. De manera similar, COL[i] es una representación simple de la columna I de la matriz.
Por tanto, la clave es la implementación del algoritmo FFT unidimensional.
2. Generales:
#¿Incluir? & ltstdio.h & gt
¿#Contiene? & ltmath.h & gt
¿#Contiene? & ltstdlib.h & gt
#¿Definición? ¿norte? 1000
/*Definir tipos plurales*/
typedef? Estructura {
¿Doble? Verdadero;
¿Doble? img
}Complejo;
¿Complejo? x[N],? *W;? /*Secuencia de entrada, convertir kernel*/
int? size _ x = 0; /*El tamaño de la secuencia de entrada está limitado a la potencia de 2 en este programa*/
¿Doble? PI;? /* Pi */
¿No válido? FFT();? /*Transformada Rápida de Fourier*/
¿No es válida? initW();? /*Inicializar el kernel de conversión*/
¿Obsoleto? cambiar();? /*Índice*/
¿No válido? Suplemento(¿complejo?,¿complicado?,¿complicado?*);? /*Suma compleja*/
¿No es válido? mul(¿complejo?,complejo?,complejo?*);? /*Multiplicación compleja*/
¿No es válido? sub(¿complejo?,¿complejo?,¿complejo?*);? /*Resta compleja*/
¿No es válido? salida();
int? principal(){
int? I;? /*Resultados de salida*/
System("cls");
PI = atan(1)* 4;
printf("¿Por favor? ¿Entrar? ¿Ese? tamaño? en ? &x[i].
img);
initW();
FFT();
salida(); 0;
}
/*Transformada rápida de Fourier*/
¿No es válido? fft(){
int? i=0, j=0, k=0, l = 0;
¿Complejo? arriba, abajo, producto
cambiar();
for(I = 0;i<?log(size_x)/log(2)?;i++){? /*Operación mariposa de primer nivel*/
l = 1 & lt; & lti;
for(j = 0; j & ltsize _ x; j+=? 2 *l? ){?/*Un conjunto de operaciones mariposa*/
for(k = 0; k & ltl; K++){/*Una operación mariposa*/
mul(x[ j+k+l], W[size_x*k/2/l] y amp producto);
add(x[j+k], producto, suma ampup);
sub(x[j+k], producto & abajo);
x[j+k]= arriba;
x[j+ k+l]= abajo;
}
}
}
}
/*Conversión de inicialización Kernel*/
¿No es válido? initW(){
int? i;
W=(complejo?*)malloc(tamañode(plural)?*?size_x);
for(I = 0;i<size_x;i++ ){
W[i]. real = cos(2 * PI/tamaño _ x * I);
W[i]. img =-1 * sin(2 * PI/size _ x * I);
}
}
/*Durante el cálculo del índice, x(n )Inversión de posición del código*/
¿No es válido? Cambiar(){
¿Complicado? Temperatura;
¿Sin firmar? ¿corto? i=0, j=0, k = 0;
¿Doble? t;
for(I = 0;i<size_x;i++){
k = I;j = 0;
t =(log (tamaño _ x )/log(2));
Y (?(t-)>0?){
j = j & lt& lt1;
j |=(k?& amp?1);
k = k & gt& gt1;
}
if(j & gt ;i){
temp = x[I];
x[I]= x[j];
x[j]= temp;
}
}
}
/*Emitir el resultado de la transformada de Fourier*/
¿No es válido? salida(){
int? i;
printf("El ?resultado?es?como?seguir\n");
for(I = 0;i<size_x;i++){
printf("%.4f ",x[i].true);
if(x[i].img & gt=0.0001)printf("+%.4fj\ n ",x[ i].
img);
¿Y si? if(fabs(x[i].img)<0.0001)printf("\n");
¿Y si? printf("%.4fj\n ",x[i].img);
}
}
¿No es válido? Suplemento (¿complejo? 1, ¿complejo? b, ¿complejo? *c) {
c->; número real = a .real+b
c->; = a . img+b . img;
}
¿No es válido? mul(complejo? 1, complejo? b, complejo? *c){
c->; real=a.real*b.real? -?a.img*b.img;
c->;img=a.real*b.img? +?a . img * b .real;
}
¿No es válido? sub(complejo? uno, ¿complejo? b, ¿complejo? *c) {
c->; número real = a .real-b . = a . img-b .