Discussion :

[kromartien]

Bonjour,

j'ai un problème dans mon programme, j'ai le message suivant de la
part du compilateur :
error : incompatible types in assignement

Voilà l'endroit où ça arrive :

Code :

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

1
2
3
4
5
6
7
8
 
    vecteur gaussienne_DFT;
 
    /*...*/
 
    gaussienne_DFT = DFT_complexe(vecteur_gauss);/* <-- ICI */
    write_vecteur(gaussienne_DFT,"DFT_gauss.txt");
    write_vecteur(vecteur_gauss,"vecteur_gauss.txt");

je ne comprends pas, car voilà la déclaration de ma fonction,
pour ce qui s'agit de mon fichier d'en-tête :

Code :

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

1
2
3
4
5
6
7
8
9
 
typedef struct {
    double * tab;
    unsigned long size;
    double x_min;
    double x_max;
} vecteur;
/*...*/
vecteur DFT_complex(vecteur);

et voila une partie de la definition de ma fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
vecteur DFT_complex(vecteur vecteur_in)
{
    vecteur vecteur_out;
    /*
    ...
    
    et je termine par :
    */
    return vecteur_out;
}

Savez vous d'où peut venir ce problème ? Je joins l'archive complète du programme
si vous voulez regarder directement dans le programme complet. Merci beaucoup.

[zooro]

Salut,

vecteur n'est pas un type de base, mais une structure.
Tu devrais passer par des pointeurs pour tes affectations et retours de fonctions...

[kromartien]

Voilà, j'ai changé les types de retour, mais j'ai toujours une erreur, et maintenant le message est :

error: invalid lvalue in assignment

[Franck.H]

Voilà, j'ai changé les types de retour, mais j'ai toujours une erreur, et maintenant le message est :

error: invalid lvalue in assignment

Tu peux montrer le code modifié ?

[kromartien]

Tu peux montrer le code modifié ?

finalement ça marche, plus d'erreurs de compilation.
(chercher une erreur de programmation devient d'autant plus difficile que la taille du programme devient importante, désolé).

Par contre j'ai l'impression d'avoir une faute de segmentation, mais c'est normal, un bug en cache toujours un autre.

VOilà toujours la fonction qui posait problème à la compilation et qui fait une segfault maintenant :

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
/*
renvoie un pointeur sur le vecteur TF
du vecteur argument de la fonction
*/
 
vecteur * DFT_complexe(vecteur 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;
    double * complex_table[2];
    /*
    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;
 
    taille_complex_table = (2*nbr_points - 1) * sizeof **complex_table;
 
    /*
    calcul frequences d'echantillonnage
    bande spectrale analysee
    pas d'integration de la DFT
    */
    delta_x = (x_max-x_min)/(nbr_points-1);
    freq_ech = nbr_points/(x_max-x_min);
 
    omega_max = (freq_ech / 10.0) * 2.0 * M_PI;
    omega_min = -omega_max;
    delta_omega = omega_max/(nbr_points - 1);
 
    vecteur_out->size = nbr_points;
    vecteur_out->x_min = 0;
    vecteur_out->x_max = omega_max;
    vecteur_alloc(vecteur_out);
 
    /*
    allocation et initialisation des vecteurs d'integration
    */
    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
        */
        for(k=0;k<(2*nbr_points-1);k++)
        {
            current_omega=omega_min + k*delta_omega;
            for(l=0;l<nbr_points;l++)
            {
                complex_table[0][k] = complex_table[0][k] + vecteur_in.tab[l] *\
                    cos(current_omega * (x_min+(l*delta_x)) );
            }
        }
 
        /*
        partie complexe
        */
        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++)
            {
                complex_table[1][k] = complex_table[1][k] + vecteur_in.tab[l] *\
                    cos(current_omega * (x_min+(l*delta_x)) );
            }
        }
 
        /*
        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;
    return vecteur_out;
}

et la nouvelle archive du code complet est en pièce jointe

[PsychoH13]

Salut,

vecteur n'est pas un type de base, mais une structure.
Tu devrais passer par des pointeurs pour tes affectations et retours de fonctions...

Le fait que ce soit une structure n'empêche en rien de faire une affectation ! Au contraire ! Si une fonction retourne un "vecteur" tu peux l'assigner à une variable de type "vecteur" sans problème.

Juste, petite note, ça ne devrait pas changer grand chose, mais tu devrais mettre une étiquette à ta structure, au lieu de la déclarer comme ceci :

Code :

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

1
2
3
4
5
6
typedef struct {
    double * tab;
    unsigned long size;
    double x_min;
    double x_max;
} vecteur;

Déclare-la comme ceci :

Code :

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

1
2
3
4
5
6
typedef struct vecteur{
    double * tab;
    unsigned long size;
    double x_min;
    double x_max;
} vecteur;

[droggo]

Kio,

Je ne vois pas d'allocation mémoire pour vecteur_out ?

[Montag]

Salut,

Tu devrais apprendre à utiliser un debugger (gdb par exemple) ce qui te permettrait de localiser la ligne responsable du seg fault.
Sinon, comme l'a déjà fait remarquer droggo cette ligne :

Code :

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

vecteur_out->size = nbr_points;

me parait suspecte puisque la valeur de vecteur_out est indéterminée.

[zooro]

ce qui te permettrait de localiser la ligne responsable du seg fault

Disons plutôt: "la ligne provoquant l'erreur de segmentation"
Celle qui en est responsable peut parfois être plus difficile à trouver.

Je ne vois pas d'allocation mémoire pour vecteur_out ?

Effectivement, d'où l'erreur de segmentation.

Le fait que ce soit une structure n'empêche en rien de faire une affectation ! Au contraire ! Si une fonction retourne un "vecteur" tu peux l'assigner à une variable de type "vecteur" sans problème.

Oui, mais ce n'est pas vraiment une pratique recommandée...
De plus, si vecteur.tab est bien un tableau, l'affectation ne copiera que l'adresse de ce tableau, et non son contenu. De là à provoquer un comportement inattendu lors de l'exécution (par exemple lors de la libération de la variable initiale)...

Juste, petite note, ça ne devrait pas changer grand chose, mais tu devrais mettre une étiquette à ta structure, au lieu de la déclarer comme ceci :

Code :

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

typedef struct {...} vecteur;

Déclare-la comme ceci :

Code :

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

typedef struct vecteur{...} vecteur;

Là, par contre, ça ne sert à rien, si tu n'utilises pas "struct vecteur" dans la structure elle-même.

[kromartien]

Bonjour.

J'ai bien reussi a localiser l'erreur a l'aide de puts(""); bien placés, merci beaucoup. Pour les méthodes sur l'objet vecteur, vous me conseillez donc de n'utiliser que des passages par adresse pour les arguments et les valeurs renvoyées ?

Voilà la fonction vecteur * DFT_complexe(vecteur) modifiée (et qui marche) :

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
128
129
130
131
132
133
134
135
 
#include "DK_H_20070929_Info_pour_la_physique.h"
 
/*
renvoie un pointeur sur le vecteur TF
du vecteur argument de la fonction
*/
 
vecteur * DFT_complexe(vecteur 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 : %d",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;
    return &vecteur_out;
}

(j'emploie une methode speciale pour le type vecteur pour l'allocation memoire, c'est normal que vous ne l'ayez pas remarquer, mais elle fonction. (je n'ai pas envie de tester le retour de malloc 40 fois dans une fonction)

[Emmanuel Delahaye]

Juste, petite note, ça ne devrait pas changer grand chose, mais tu devrais mettre une étiquette à ta structure
<...>
Déclare-la comme ceci :

Code :

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

1
2
3
4
5
6
typedef struct vecteur{
    double * tab;
    unsigned long size;
    double x_min;
    double x_max;
} vecteur;

Ca sert à quoi ?

[kromartien]

Oui pardon voilà j'ai créé une fonction de libération mémoire pour le type spécifique vecteur.
Tout compile, j'ai deux warnings qui subsistent, mais je ne sais pas à quoi ils correspondent. Pouvez vous m'aider ?

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
 
Switching to target: default
Compiling: DFT_complexe.c
Compiling: TD_1_exo_IV_TF.c
TD_1_exo_IV_TF.c: In function `TD_1_exo_IV_TF':
TD_1_exo_IV_TF.c:47: warning: implicit declaration of function `DFT_complexe'
TD_1_exo_IV_TF.c:49: warning: implicit declaration of function `write_vecteur'
Compiling: TD_1_exo_I_integrales.c
Compiling: derivation.c
Compiling: fonctions_mathematiques.c
Compiling: integrateur_Riemann.c
Compiling: integrateur_simpson.c
Compiling: integrateur_trapeze.c
Compiling: main.c
Compiling: struct_vec_1D.c
Compiling: write_vecteur.c
Linking console executable: C:\Users\dkremer\Documents\Info_appliquee_a_la_physique.exe
Process terminated with status 0 (0 minutes, 7 seconds)
0 errors, 2 warnings

La structure typedef struct vecteur contient un tableau de nombres de type double, sa taille (unsigned long), double x_min et double x_max.

le type vecteur représente en fait les valeurs prises par une application de type x |--> f(x), sur un intervalle [x_min;x_max].

Comme ceci je réalise des intégrations et des dérivations, transformées de Fourier, etc. Si vous pensez que ce n'est pas un choix de structure judicieux, merci de me le dire.

Je ne passe plus de type de retour aux fonctions de manipulation du type vecteur, je passe un pointeur en argument pour le vecteur modifié et tout se passe en interne dans la fonction.

Je joins à nouveau l'ensemble du code source dans l'archive .zip (modifiée depuis le temps).

Merci beaucoup si vous voyez encore des choses mauvaises de me le dire.

[DaZumba]

TD_1_exo_IV_TF.c: In function `TD_1_exo_IV_TF':
TD_1_exo_IV_TF.c:47: warning: implicit declaration of function `DFT_complexe'
TD_1_exo_IV_TF.c:49: warning: implicit declaration of function `write_vecteur'

Il n'y a pas de prototype en vue pour ces deux fonctions. Il manque certainement l'inclusion de fichiers d'entete.