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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
typedef struct
{
size_t size;
int x_min;
int x_max;
double *tab;
}
vecteur;
void vecteur_alloc (vecteur * this)
{
this->tab = malloc (sizeof *this->tab * this->size);
if (this->tab == NULL)
{
/* horrible, mais c'est ton choix... */
exit (EXIT_FAILURE);
}
}
/*
renvoie un pointeur sur le vecteur TF
du vecteur argument de la fonction
*/
void DFT_complexe (vecteur const *vecteur_in, vecteur * vecteur_out)
{
unsigned long k, l, nbr_points;
size_t taille_complex_table;
double freq_ech, omega_max, omega_min, current_omega, delta_omega;
double current_module, current_imagin, current_real;
double x_min, x_max, delta_x, temp_var;
double *complex_table[2];
puts ("fin declarations");
/*
complex_table[0] : pointeur sur le tableau des parties reelles
complex_table[1] : pointeur sur le tableau des parties imaginaires
*/
nbr_points = vecteur_in->size;
x_min = vecteur_in->x_min;
x_max = vecteur_in->x_max;
printf ("nombre de points du vecteur d'entree : %lu", nbr_points);
/*
calcul frequences d'echantillonnage
bande spectrale analysee
pas d'integration de la DFT
*/
puts ("debut initialisations");
delta_x = (x_max - x_min) / (nbr_points - 1);
freq_ech = nbr_points / (x_max - x_min);
omega_max = (freq_ech / 5.0) * M_PI;
omega_min = -omega_max;
delta_omega = omega_max / (nbr_points - 1);
puts ("debut initialisations sur vecteur_out");
vecteur_out->size = nbr_points;
vecteur_out->x_min = 0;
vecteur_out->x_max = omega_max;
puts ("fin initialisations");
puts ("avant alloc vecteur_out");
vecteur_alloc (vecteur_out);
puts ("apres alloc vecteur_out");
/*
allocation et initialisation des vecteurs d'integration
*/
taille_complex_table = (2 * nbr_points - 1) * sizeof **complex_table;
complex_table[0] = malloc (taille_complex_table);
complex_table[1] = malloc (taille_complex_table);
if (complex_table[0] == NULL || complex_table[1] == NULL)
{
perror ("erreur d'allocation memoire dans la fonction DFT_complexe");
if (complex_table[0] == NULL)
{
perror ("erreur sur la partie reelle");
}
if (complex_table[1] == NULL)
{
perror ("erreur sur la partie complexe");
}
}
else
{
/*
calcul des parties reelles et imaginaires
de la TF apres allocation reussie
*/
/*
partie reelle
*/
puts ("calcul partie reelle");
for (k = 0; k < (2 * nbr_points - 1); k++)
{
if ((k % 100) == 0)
{
puts ("100 points du vecteur de frequence calcules");
printf ("reste %ld", (2 * nbr_points - 1) - k);
}
current_omega = omega_min + (k * delta_omega);
for (l = 0; l < nbr_points; l++)
{
temp_var =
vecteur_in->tab[l] * cos (current_omega *
(x_min + (l * delta_x)));
complex_table[0][k] = complex_table[0][k] + temp_var;
}
}
puts ("fin calcul partie reelle");
/*
partie imaginaire
*/
puts ("calcul partie imaginaire");
current_omega = omega_min;
for (k = 0; k < (2 * nbr_points - 1); k++)
{
current_omega = omega_min + (k * delta_omega);
for (l = 0; l < nbr_points; l++)
{
temp_var =
vecteur_in->tab[l] * sin (current_omega *
(x_min + (l * delta_x)));
complex_table[1][k] = complex_table[1][k] + temp_var;
}
}
puts ("fin calcul partie imaginaire");
/*
remplissage du vecteur de sortie par
calcul du module de la transformee
*/
for (k = 0; k < nbr_points; k++)
{
if (k != 0)
{
current_real = complex_table[0][k] + complex_table[0][-k];
current_imagin = complex_table[1][k] + complex_table[1][-k];
}
else
{
current_real = complex_table[0][k];
current_imagin = complex_table[1][k];
}
current_module =
sqrt (pow (current_real, 2) + pow (current_imagin, 2));
vecteur_out->tab[k] = current_module;
}
}
free (complex_table[0]), complex_table[0] = NULL;
free (complex_table[1]), complex_table[1] = NULL;
}
int main (void)
{
vecteur in = { 4, 0, 0, NULL };
vecteur out = { 0, 0, 0, NULL };
vecteur_alloc (&in);
DFT_complexe (&in, &out);
return 0;
} |
