IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Problème : type incompatible lors de l'assignation


Sujet :

C

  1. #1
    Membre éprouvé

    Profil pro
    Inscrit en
    Juin 2006
    Messages
    1 116
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations forums :
    Inscription : Juin 2006
    Messages : 1 116
    Points : 1 111
    Points
    1 111
    Par défaut Problème : type incompatible lors de l'assignation
    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.

  2. #2
    Membre éprouvé Avatar de zooro
    Homme Profil pro
    Développeur Java
    Inscrit en
    Avril 2006
    Messages
    921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Développeur Java

    Informations forums :
    Inscription : Avril 2006
    Messages : 921
    Points : 1 260
    Points
    1 260
    Par défaut
    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...

  3. #3
    Membre éprouvé

    Profil pro
    Inscrit en
    Juin 2006
    Messages
    1 116
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations forums :
    Inscription : Juin 2006
    Messages : 1 116
    Points : 1 111
    Points
    1 111
    Par défaut
    Voilà, j'ai changé les types de retour, mais j'ai toujours une erreur, et maintenant le message est :

    error: invalid lvalue in assignment

  4. #4
    Rédacteur
    Avatar de Franck.H
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Janvier 2004
    Messages
    6 951
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : Service public

    Informations forums :
    Inscription : Janvier 2004
    Messages : 6 951
    Points : 12 462
    Points
    12 462
    Par défaut
    Citation Envoyé par kromartien Voir le message
    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é ?

  5. #5
    Membre éprouvé

    Profil pro
    Inscrit en
    Juin 2006
    Messages
    1 116
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations forums :
    Inscription : Juin 2006
    Messages : 1 116
    Points : 1 111
    Points
    1 111
    Par défaut
    Citation Envoyé par Franck.H Voir le message
    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

  6. #6
    Membre averti
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    309
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 309
    Points : 380
    Points
    380
    Par défaut
    Citation Envoyé par zooro Voir le message
    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;

  7. #7
    Expert confirmé

    Inscrit en
    Août 2006
    Messages
    3 951
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 3 951
    Points : 5 671
    Points
    5 671
    Par défaut
    Kio,

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

  8. #8
    Membre actif
    Profil pro
    Inscrit en
    Août 2007
    Messages
    190
    Détails du profil
    Informations personnelles :
    Localisation : France, Maine et Loire (Pays de la Loire)

    Informations forums :
    Inscription : Août 2007
    Messages : 190
    Points : 219
    Points
    219
    Par défaut
    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.

  9. #9
    Membre éprouvé Avatar de zooro
    Homme Profil pro
    Développeur Java
    Inscrit en
    Avril 2006
    Messages
    921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Développeur Java

    Informations forums :
    Inscription : Avril 2006
    Messages : 921
    Points : 1 260
    Points
    1 260
    Par défaut
    Citation Envoyé par Montag Voir le message
    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.

    Citation Envoyé par droggo Voir le message
    Je ne vois pas d'allocation mémoire pour vecteur_out ?
    Effectivement, d'où l'erreur de segmentation.

    Citation Envoyé par PsychoH13 Voir le message
    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)...

    Citation Envoyé par PsychoH13 Voir le message
    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.

  10. #10
    Membre éprouvé

    Profil pro
    Inscrit en
    Juin 2006
    Messages
    1 116
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations forums :
    Inscription : Juin 2006
    Messages : 1 116
    Points : 1 111
    Points
    1 111
    Par défaut
    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)

  11. #11
    Expert confirmé

    Inscrit en
    Août 2006
    Messages
    3 951
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 3 951
    Points : 5 671
    Points
    5 671
    Par défaut
    Jio,
    Citation Envoyé par kromartien Voir le message
    (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)
    Hum, tu crois que ça marche.

    Moi, je vois que tu retournes l'adresse d'une variable locale (automatique) à une fonction.

    Or, dès la sortie de la fonction, cette adresse n'est plus valide.

    Et les mallocs, vérification, etc., font partie du travail du programmeur en C. Si ça ne te convient pas, change d'urgence de langage.

  12. #12
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par kromartien Voir le message
    Voilà la fonction vecteur * DFT_complexe(vecteur) modifiée (et qui marche) :

    (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)
    Horrible !
    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
     
    Project   : Forums
    Compiler  : GNU GCC Compiler (called directly)
    Directory : C:\dev\forums\
    --------------------------------------------------------------------------------
    Switching to target: default
    Compiling: main.c
    main.c:2:49: DK_H_20070929_Info_pour_la_physique.h: No such file or directory
    main.c:9: error: syntax error before '*' token
    main.c:9: error: syntax error before "vecteur_in"
    main.c:10: warning: return type defaults to `int'
    main.c:10: warning: function declaration isn't a prototype
    main.c: In function `DFT_complexe':
    main.c:12: error: `vecteur' undeclared (first use in this function)
    main.c:12: error: (Each undeclared identifier is reported only once
    main.c:12: error: for each function it appears in.)
    main.c:12: error: syntax error before "vecteur_out"
    main.c:14: error: `size_t' undeclared (first use in this function)
    main.c:14: error: syntax error before "taille_complex_table"
    main.c:20: warning: implicit declaration of function `puts'
    main.c:26: error: `vecteur_in' undeclared (first use in this function)
    main.c:30: warning: implicit declaration of function `printf'
    main.c:30: warning: int format, long unsigned int arg (arg 2)
    main.c:42: error: `M_PI' undeclared (first use in this function)
    main.c:46: error: `vecteur_out' undeclared (first use in this function)
    main.c:51: warning: implicit declaration of function `vecteur_alloc'
    main.c:57: error: `taille_complex_table' undeclared (first use in this function)
    main.c:58: warning: implicit declaration of function `malloc'
    main.c:60: error: `NULL' undeclared (first use in this function)
    main.c:62: warning: implicit declaration of function `perror'
    main.c:92: warning: implicit declaration of function `cos'
    main.c:108: warning: implicit declaration of function `sin'
    main.c:128: warning: implicit declaration of function `sqrt'
    main.c:128: warning: implicit declaration of function `pow'
    main.c:132: warning: implicit declaration of function `free'
    main.c:132: warning: value computed is not used
    main.c:133: warning: value computed is not used
    Process terminated with status 1 (0 minutes, 1 seconds)
    14 errors, 15 warnings
    Ceci devrait fonctionner :
    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
    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;
    }
    Evidemment, il manque la libération de la mémoire...

  13. #13
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par PsychoH13 Voir le message
    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 ?

  14. #14
    Membre éprouvé

    Profil pro
    Inscrit en
    Juin 2006
    Messages
    1 116
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations forums :
    Inscription : Juin 2006
    Messages : 1 116
    Points : 1 111
    Points
    1 111
    Par défaut
    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.

  15. #15
    Membre expérimenté
    Inscrit en
    Décembre 2004
    Messages
    1 478
    Détails du profil
    Informations forums :
    Inscription : Décembre 2004
    Messages : 1 478
    Points : 1 664
    Points
    1 664
    Par défaut
    Citation Envoyé par kromartien Voir le message
    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.

Discussions similaires

  1. Réponses: 4
    Dernier message: 24/04/2015, 11h54
  2. Réponses: 4
    Dernier message: 04/02/2010, 15h44
  3. Types de données incompatibles lors d'une requête sous access
    Par RodEpsi dans le forum Bases de données
    Réponses: 32
    Dernier message: 21/07/2006, 16h51
  4. Problème de "Type incompatible" avec tableau et Vector
    Par pat-trix dans le forum Collection et Stream
    Réponses: 14
    Dernier message: 08/07/2006, 00h42
  5. [LG] Erreur de type incompatible dans assignment
    Par Tuxico dans le forum Langage
    Réponses: 4
    Dernier message: 03/12/2005, 22h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo