Buscando un programa C de transformada de Fourier bidimensional (¡urgente! ¡Esperando en línea!)
Programa fuente de Transformada Rápida de Fourier (bidimensional)
#include lt;stdio.hgt;
#include lt;stdlib.hgt;
p>
#include lt;math.hgt;
#define PI 3.1415927
struct COMPLEX
{
float re ;
float im;
} cplx, *Hfield, *S, *R, *w;
int n, m;
int ln, lm;
void iniciar ();
void dfft ();
void rdfft ();
void showresult ();
void fft (int l, int k);
int reverso (int t, int k);
void W (int l);
int loop (int l);
void conjugate ();
void add (struct COMPLEX * x, struct COMPLEX). * y , struct COMPLEX * z);
void sub (struct COMPLEX * x, struct COMPLEX * y, struct COMPLEX * z);
void mul (struct COMPLEX * x, struct COMPLEX * y , struct COMPLEX * z);
struct COMPLEX * Hread(int i, int j);
void Hwrite (int i, int j, struct COMPLEX x) ;
int main ()
{
iniciar ();
printf("\nDatos originales:\n");
showresult();
getchar ();
dfft ();
printf("\nEl resultado después de la transformación rápida de Fourier :\ n");
showresult ();
getchar ();
rdfft ();
printf("\ nfast El resultado después de la transformada inversa de Fourier: \n");
showresult ();
getchar ();
free (Hfield);
return 0;
}
void start ()
{/* Operaciones de inicialización del programa, incluida la asignación de memoria y la lectura de datos a procesar. , Visualización, etc.*/
ARCHIVO * df;
df = fopen ("data.txt", "r");
fscanf (df, "5d", & n);
fscanf (df, "5d", amp); ; m);
if ((ln = loop (n)) == -1)
{
printf ("El número de columnas no es 2 Potencia entera");
salir (1);
}
if ((lm = loop (m)) == -1)
{
printf ("El número de líneas no es una potencia entera de 2");
exit (1);
Hfield = (struct COMPLEX *) malloc (n * m * sizeof (cplx));
if (fread (Hfield, sizeof (cplx), m * n, df) != (unsigned) (m * n))
{
if (feof (df)) printf ("Fin prematuro del archivo");
else printf ( "Error de lectura de archivo ");
}
fclose (df
}
void dfft ()<; /p>
{/* Realizar transformada rápida de Fourier bidimensional*/
int i, j
int l, k
l; = n;
k = ln;
w = (struct COMPLEX *) calloc (l, tamaño de (cplx)); *) calloc ( l , tamaño de (cplx));
S = (struct COMPLEX *) calloc (l , tamaño de (cplx));
W (l); p>
for (i = 0; i lt; m; i)
{/* Transformada rápida de Fourier fila por fila*/
for (j = 0; j lt; n; j )
{
S[j].re = Hread (i, j)-gt;re;
S[j] .im = Hread (i, j)-gt; im
}
fft(l, k
para (j = 0; j); lt; n; j )
Hwrite (i , j , R[j]); p> libre ( S);
libre (w);
l = m;
k = lm;
w = (struct COMPLEX *) calloc (l, tamaño de (cplx)) ;
R = (struct COMPLEX *) calloc (l , tamaño de (cplx));
S = (struct COMPLEX *) calloc (l , tamaño de (cplx));
W (l);
for (i = 0; i lt; n; i)
{/* Transformada rápida de Fourier por columna*/< / p>
for(j = 0; j lt; m; j)
{
S[j].re = Hread(j, i)-gt; ;
S[j].im = Hread(j, i)-gt; im;
}
fft(l, k);
p>for (j = 0; j lt; m; j)
Hwrite (j, i, R[j]);
}
gratis (R);
gratis (S);
gratis (w);
}
nulo rdfft ( )
{
conjugado ();
dfft ();
conjugado (
} <); /p>
void showresult()
{
int i , j
for (i = 0; i lt; m; i )
{
printf ( " \nLínea d\n " , i
for (j = 0; j lt; n; j )
{
if (j 4 == 0) printf (" \n ");
printf(" (5.2f, 5.2fi) " , Hread ( i, j)-gt; re, Hread (i, j)-gt; im);
}
}
}
p >void fft (int l, int k)
{
int i, j, s, nv, t;
float c; /p>
struct COMPLEX mp, r;
nv = l;
c = (flotante) l
c = pow (c , 0.5);
para (i = 0; i lt; k; i)
{
> para (t = 0; t lt; l; t = nv)
{
para (j = 0; j lt; nv / 2; j)
{
s = (t j) gt; (k - i -1);
s = reverso(s, k); > r.re = S[t j].re
r.im = S[t j].im
mul (amp; w[s] , amp; S[ t j nv / 2], amp; mp); /* ///////Explica la diferencia entre pasar el puntero de estructura y la estructura misma*/
add (amp; r, amp; mp); , amp; S[t j]);
sub (amp; r , amp; mp , amp; S[t j nv / 2]); p> }
nv = nv gt; gt 1;
}
para (i = 0; i lt; l; i)
{
j = inversa(i, k);
R[j].re = S[i].re/c;
R[ j].im = S[i].im/c;
}
}
int reverso (int t, int k)
{
int i , x , y;
y = 0;
para (i = 0; i lt; k; i)
{
x = t amp 1;
t = t gt; y lt; 1) x;
}
devolver y
}
void W (int l)
{
int i;
flotador c, a;
c = (flotante) l
c; = 2 * PI/c;
for (i = 0; i lt; l; i)
{
a = (flotante) i;
w[i].re = (flotar) cos(a * c);
w[i].im = -(flotar) sin(a * c); p>
}
}
int loop (int l)
{/* Verifique que los datos de entrada sean
Si es una potencia entera de 2, si lo es, devuelve el número de dígitos expresados en binario */
int i, m;
if (l != 0)
p>{
for (i = 1; i lt; 32; i)
{
m = l gt; ; i;
si (m == 0)
romper
}
si (l == (1 lt; lt; (i - 1)))
devolver i - 1
}
devolver
}
conjugado vacío ()
{/* Encuentra la ***matriz de yugo de la matriz compleja*/
int i, j;
para (i = 0; i lt; m; i)
{
para (j = 0; j lt; n; j)
{
Hread (i, j)-gt; im *= -1
}
}
}
struct COMPLEX * Hread (int i, int j)
{/* Devuelve el puntero a la posición especificada en Hfield leyendo la matriz*/
return (Hfield i * n j);
}
void Hwrite (int i, int j, struct COMPLEX x)
{/* Escribe la estructura compleja x en el especificado Posición del campo H según el método de matriz de escritura */
(Hfield i * n j)-gt; re = x.re
(Hfield i * n j)-gt; x.im;
}
void add (struct COMPLEX * x, struct COMPLEX * y, struct COMPLEX * z)
{/* Definir número complejo suma*/
z-gt; re = x-gt; re y-gt;
z-gt; im = x-gt; ;
}
void sub (struct COMPLEX * x, struct COMPLEX * y, struct COMPLEX * z)
{/* Definir resta compleja*/
z-gt ;re = x-gt; re - y-gt; re;
z-gt; im = x-gt; im - y-gt; /p>
}
void mul (struct COMPLEX * x , struct COMPLEX * y , struct COMPLEX
* z)
{/* Definir multiplicación compleja*/
z-gt;re = (x-gt;re) * (y-gt;re) - (x- gt; im) * (y-gt; im);
z-gt; im = (x-gt; im) * (y-gt; re) (x-gt; re) * ( y-gt;im);
}