Discussion :

[goliath23]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Gruik]

Salut,

les valeurs trouvées après TF me semble bisard(je dois tracer le sinc)

En mettant de coté l'ortho, ceci est trop vague, il faudrait qu'on puisse savoir qu'est ce qui est attendu, et isoler un peu plus le problème..
Essaye peut etre d'utiliser un debugger pour voir ce qu'il se passe

A part ça, il manque les types des variables, ça peut etre important