Problème transformée de Fourier, un peu d'aide ?
:salut: je voudrais de l'aide pour mon programme de calcule de transforme de Fourier .Dans mon cas je me contente de séparer en cos et sin une fonction de type porte rectangle le problème étant que les valeurs trouver après TF me semble bisard(je dois tracer le sinc) si quelqu'un pouvais jeter un œil et me dire si je n'est pas fait d'erreur dans le code ?
je poste les partie du main et de la transformé de fourier
ne faite pas attention à tout le programme n'est pas complet et comporte d'autre header;
merci d'avance
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
printf("donner la borne inferieur\n");//consignes
scanf("%lf",&a);
printf("donner la borne superieur\n");
scanf("%lf",&b);
delta=fabs(b-a);
printf("l'intervalle des positions vaut:\n%lf\n",delta);
printf ("entrez la condition sur mu:\n");
scanf("%lf", &mu);
printf ("donnez le pas d'espace:\n");
scanf("%lf",&h);
printf ("donnez la duree d'etude:\n");
scanf("%lf", &i);
printf ("donnez le pas de temps:\n");
scanf("%lf", &j);
/**********************************************************************/
if(x<=b && x>=a)
{Fx=1;
}
else
{Fx=0;
}
/**********************************************************************/
pointstemps = i/j; //calcul du nombre points en temps et en espace delta est linterval d'etude de la fonction
pointsespace=(delta/h);
/**********************************************************************/
tab=(double**)malloc(pointsespace*sizeof(double*));//allocation de la mémoire de la premiere colonne du tableau
/**********************************************************************/
for (r=0; r < pointsespace; r++)//allocation de la mémoire nécessaire aux lignes du tableau
{
tab[r]=(double*)malloc(pointstemps*sizeof(double));
}
for (r=0; r < pointsespace; r++)//initialisation de toutes les cases du tableau à 0
{
for (s=0; s < pointstemps; s++)
{
tab[r][s]=0;
}
}
/**********************************************************************/
tabk = (complexe**) malloc( pointsespace * sizeof(complexe*));//allocation de la mémoire du tableau complexe
for (q=0; q < pointsespace; q++)
{
tabk[q] =(complexe*)malloc( pointstemps * sizeof(complexe));
}
/**********************************************************************/
for (q=0; q < pointsespace; q++)//initialisation du tableau de complexe à 0
for (d=0; d < pointstemps; d++)
{
complexe temp;
temp.reel=0;
temp.im=0;
tabk[q][d] = temp;
tabk[q][d].reel=0;
tabk[q][d].im=0;
}
printf ("declaration ok\n");
system ("PAUSE");
/**********************************************************************/
for (n = 0 ; n < pointsespace ; n++)//calcul de la fonction initiale dans l'intervalle d'étude
{
x = a+h*n;
tab[n][0] = Fx;
m = n+1;
printf("point Nunmero %ld = %lf\n", m, tab[n][0]);
fprintf(XX, " %lf\n",x);
}
printf ("calcul fonction ok\n");
system ("PAUSE");
/**********************************************************************/
fourier (tab,tabk,pointsespace,a,h);//TF directe
printf ("fourier direct ok\n");
system ("PAUSE");
/**********************************************************************/
/**********************************************************************/
/**********************************************************************/
for (r=0; r < pointsespace; r++)//libération de la mémoire allouée
{
free(tab[r]);
}
free(tab);
for (q=0; q < pointsespace; q++)
{
free(tabk[q]);
}
free(tabk);
/**********************************************************************/
printf ("liberation ok\n");
system("PAUSE");
return 0;
} |
voici la partie du code qui calcule la transformé
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
typedef struct complexe complexe;
struct complexe
{
complex reel;
complex im;
};
void fourier (double** tab, complexe** tabk, double pointsespace, double a,double h)//fonction transformée de fourrier
{
int e=0;//déclaration des variables nécessaires
double x2=0;
int k2=0;
int d=0;
/*********************************************************************************/
FILE* flot = NULL;
FILE* flo = NULL;
FILE* fl = NULL;
FILE* result = NULL;
flot = fopen("p.xls","w+");
flo = fopen("pc.xls","w+");
fl = fopen("pcc.xls","w+");
result = fopen("resultats/resultats.xls","w+");
fprintf (result,"k\tpartie reelle\tpartie imaginaire:\n");
/*********************************************************************************/
for (k2=0; k2 < pointsespace; k2++)//on calcul ici la partie réelle de la TF
{
for (e=0; e < pointsespace; e++)
{
x2=a+e*h;
tabk[k2][d].reel+=(tab[e][d]*cos(2*3.14*x2*k2/pointsespace));
tabk[k2][d].im+=(tab[e][d]*sin(2*3.14*x2*k2/pointsespace));
}
printf ("resultat fourier reel:\n");
printf ("%lf\n", tabk[k2][d].reel);
fprintf(fl, " reel%lf\n",tabk[k2][d].reel);
fprintf(flot, " k= %ld\n ",k2);
printf ("resultat fourier imaginaire:\n");
printf ("%lf\n", tabk[k2][d].im);
fprintf(flo, " im%lf\n",tabk[k2][d].im);
e=k2+1;
fprintf (result,"%ld\t%lf\t%lf\n", e, tabk[k2][d].reel, tabk[k2][d].im);
}
fclose(flot);
fclose(flo);
fclose(fl);
fclose(result);
}; |
si vous trouvez quelque chose je suis preneur merci
