Transformada rápida

de Fourier
Autor:
Joseph Leonel Manzo Bustos

Profesor:
Francisco Alarcón Oseguera

Métodos Numéricos

Licenciatura en Física
3er Semestre

Universidad de Guanajuato
División de Ciencias e Ingenierías

1
Contenido
Resumen ......................................................................................................................................... 3
Resultado............................................................................................................................................ 3
Conclusiones .................................................................................................................................. 5
Apéndice (Códigos en C++) .......................................................................................................... 6

2
 Resumen
La transformada rápida de Fourier, conocida por la abreviatura FFT (del inglés Fast
Fourier Transform) es un algoritmo eficiente que permite calcular la transformada de
Fourier discreta (DFT) y su inversa. a FFT es de gran importancia en una amplia variedad
de aplicaciones, desde el tratamiento digital de señales y filtrado digital en general a la
resolución de ecuaciones en derivadas parciales o los algoritmos de multiplicación rápida
de grandes enteros.

Resultado

Para este método necesitamos saber los 2𝑚 − 1 puntos para poder aproximar nuestra
función.
Para esto, ya que conocemos la función, podemos graficarla y poder ver su comportamiento.

Figura 1: Grafico de la función 𝑥 2 𝑐𝑜𝑠(𝑥).

Del gráfico podemos ver que la función realmente es difícil de interpolar, ya que va
creciendo cada vez de forma distinta a la anterior y no sigue algún tipo de patrón.

3
Al calcular el polinomio, los valores para 𝐶2𝑚−1 , 𝐴𝑗 y 𝐵𝑗 son:

M Valor M Valor M 𝑽𝒂𝒍𝒐𝒓 𝑨𝒋 𝑽𝒂𝒍𝒐𝒓 𝑩𝒋

0 4.832465+i(1.521471) 32 -1.48571+i(1.598920) 0 0.073219 -0.055669
1 4.155687+i(1.837065) 33 4.427570+i(1.746712) 1 -0.125930 0.057278
2 4.406941+i(1.890190) 34 4.497113+i(1.521471) 2 0.133544 -0.062875
3 3.663840+i(2.074881) 35 4.018419+i(1.988590) 3 -0.111025 0.061353
4 3.377550+i(2.024654) 36 4.121405+i(1.774778) 4 0.102350 -0.064012
5 2.858866+i(2.112388) 37 3.499135+i(2.204974) 5 -0.086632 0.062095
6 2.539911+i(2.049141) 38 3.636191+i(2.014131) 6 0.076967 -0.060009
7 2.039969+i(1.980297) 39 2.869718+i(2.349795) 7 -0.061817 0.057302
8 1.695806+i(1.890956) 40 3.037096+i(2.194142) 8 0.051388 -0.050713
9 1.261998+i(1.673531) 41 2.147684+i(2.375579) 9 -0.038242 0.046948
10 0.903662+i(1.549270) 42 2.337007+i(2.266435) 10 0.027384 -0.036549
11 0.580428+i(1.206114) 43 1.368607+i(2.239748) 11 -0.017589 0.031610
12 0.220676+i(1.043125) 44 1.567167+i(2.185882) 12 0.006687 -0.018507
13 0.044747+i(0.610734) 45 0.584476+i(1.911030) 13 -0.001356 0.012434
14 -0.30392+i(0.410308) 46 0.776092+i(1.917125) 14 -0.009209 0.001936
15 -0.30775+i(-0.06389) 47 -0.14011+i(1.375221) 15 0.009326 -0.046105
16 1.450720+i(-1.52147) 48 -4.38908+i(-1.01976) 16 0.043961 0.057278
17 1.87624+i(-1.890190) 49 1.855615+i(-1.74671) 17 -0.056856 -0.053485
18 2.120617+i(-1.76499) 50 1.40527+i(-1.521471) 18 0.064261 0.059599
19 2.60902+i(-1.966781) 51 1.51005+i(-2.060656) 19 -0.079061 -0.052776
20 2.85108+i(-1.741597) 52 1.029705+i(-1.88287) 20 0.086396 0.053290
21 3.356125+i(-1.75856) 53 1.31540+i(-2.488031) 21 -0.101701 -0.043379
22 3.56192+i(-1.431514) 54 0.81119+i(-2.367952) 22 0.107937 0.038174
23 4.03163+i(-1.259733) 55 1.310024+i(-2.96742) 23 -0.122171 -0.025449
24 4.166572+i(-0.83983) 56 0.792072+i(-2.91470) 24 0.126260 0.014879
25 4.547779+i(-0.49101) 57 1.509916+i(-3.42670) 25 -0.137811 0.000051
26 4.579953+i(0.001679) 58 0.992395+i(-3.44895) 26 0.138786 -0.015149
27 4.823231+i(0.499930) 59 1.906157+i(-3.79069) 27 -0.146159 0.031370
28 4.726852+i(1.035198) 60 1.406755+i(-3.89192) 28 0.143238 -0.049721
29 4.791477+i(1.640782) 61 2.464777+i(-3.98935) 29 -0.145196 0.066065
30 4.549931+i(2.180147) 62 2.003666+i(-4.16864) 30 0.137877 -0.086042
31 4.408275+i(2.839385) 63 3.129272+i(-3.96567) 31 -0.133584 0.048452
64 3.532089+i(-0.49761) 32 -0.045022
33 -0.134169

4
Conclusiones
Este método es muy eficiente, pero es muy tedioso, ya que trata con números complejos y
tiene múltiples cálculos que, si uno está mal hace que todo lo demás del procedimiento este
mal, es muy largo en comparación de otros métodos, pero es muy preciso al momento de
interpolar.
Este es un método que se necesita de conocimientos tanto de números complejos y de su
aritmética.

5
Apéndice (Códigos en C++)

#include <stdio.h>

#include <math.h>

#include <complex.h>

void bezout (int K, int p, int *k);

double f(double x);

int main(void)

int m, p, M, q, K, L, j, k[p+1],w, K2, K1;

printf("introduzca m: ");

scanf("%i", &m);

printf("introduzca p: ");

scanf("%i", &p);

double y[2*m], b[m], x[2*m];

for(w=0;w<2*m;w++)

x[w]=-M_PI+(w*M_PI)/m;

y[w]=f(x[w]);

double _Complex z, c[2*m], e[2*m+1], a[m+1], n;

M=m;

q=p;

z=cos(M_PI/m)+I*sin(M_PI/m);

for(j=0;j<2*m;j++)

c[j]=y[j]+I*0;

6
 for(j=1;j<=M;j++)

e[j]=cpow(z,j+I*0);

e[j+M]=-e[j];

K=0;

e[0]=1;

for(L=1;L<=p+1;L++)

do

for(j=1;j<M+1;j++)

bezout(K,p,k);

K1=K/pow(2.0,q);

K2=k[q]*pow(2.0,p);

for(w=q+1;w<p+1;w++)

K2=K2+k[w]*pow(2.0,p+q-w);

n=c[K+M]*e[K2];

c[K+M]=c[K]-n;

c[K]=c[K]+n;

K=K+1;

K=K+M;

} while (K<2*m-1);

K=0;

M=M/2.0;

q=q-1;

7
}

do

bezout(K,p,k);

j=k[p];

for(w=0;w<p;w++)

j=j+k[w]*pow(2.0,p-w);

if(K<j)

n=c[j];

c[j]=c[K];

c[K]=n;

K=K+1;

} while (K<2*m-1);

a[0]=c[0]/(2.0*m);

a[m]=creal((cos(M_PI*m)-I*sin(M_PI*m))*c[m]/m);

for(j=1;j<m;j++)

a[j]=creal((cos(M_PI*j)-I*sin(M_PI*j))*c[j]/(m+I*0));

b[j]=cimag((cos(M_PI*j)-I*sin(M_PI*j))*c[j]/(m+I*0));

printf("\n\nel vector de datos c_{i}:\n");

for(w=0;w<2*m-1;w++)

printf("c_{%i}: %lf+i(%lf)\n", w, creal(c[w]), cimag(c[w]));

printf("\n\nel vector de datos a_{i}:\n");

for(w=0;w<=m;w++)

8
 {

printf("a_{%i}: %lf\n", w, creal(a[w]),cimag(a[w]));

printf("\n\nel vector de datos b_{i}:\n");

for(w=1;w<m-1;w++)

printf("b_{%i}: %lf\n", w, b[w]);

return 0;

void bezout(int K, int p, int *k)

int i, a=K, r, twop=1;

for(i=1;i<=p;i++)

twop=twop*2.0;

for(i=p;0<=i;i--)

if(0<=a)

r=a%twop;

if(0!=a-r)

k[i]=(a-r)/pow(2.0,i);

a=a-k[i]*pow(2.0,i);

else

k[i]=0;

9
 }

else

k[i]=0;

if(2<=twop)

twop=twop/2.0;

double f(double x)

double y;

y=fabs(x);

return y;

10