Polynôme
Répondre à la discussion
Affichage des résultats 1 à 18 sur 18

Polynôme



  1. #1
    lolo1546

    Polynôme


    ------

    Bonjour j'ai un programme en langage C sur les polynôme
    Lors de la compilation tout mes coefficients sont tous nuls et je n'arrive pas à trouver le problème, pareillement pour l'affichage de l'addition de 2 polynômes le calcul est faux
    est ce que quelqu'un pourrait m'aider à trouver quelles sont les procédures qui sont fausses ??
    sachant que c'est sous forme de représentation contiguë.
    cordialement

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    
    #include "booleens.h"
    
    
    #define LMAX 70
    
    typedef struct{
        float coeff[LMAX];
        int degre;
    }Polynome;
    
    #include "polyt.h"
    
    
    
    
    void zero(Polynome *P) { //Polynôme nul
        (*P).degre=0;
    }
    
    void plus(Polynome *P, float coeff, int deg) { //Addition d'un monôme à un polynôme
        int i;
    
       for(i=0; i<(*P).degre; i++){
        if(i==deg){
            (*P).coeff[i]=(*P).coeff[i]+coeff;
        }
       }
    
    }
    
    
    void add(Polynome P1,Polynome P2, Polynome *P3) { //Addition de deux polynômes
      int i;
     int j;
     int k;
    
        if(P1.degre + P2.degre > LMAX){
            printf("ERREUR TROP ELEMENTS");
        }else{
            i=0;
            j=0;
            k=0;
            while(i<=P1.degre && j<=P2.degre){
                (*P3).coeff[k] = P1.coeff[i] + P2.coeff[j];
                k=k+1;
                i=i+1;
                j=j+1;
            }
            if(i>P1.degre){
                for(j=j; j<P2.degre; j++){
                    (*P3).coeff[k]=P2.coeff[j];
                    k=k+1;
                }
            }else{
                for(i=i; i<P1.degre; i++){
                    (*P3).coeff[k]= P1.coeff[i];
                    k=k+1;
                }
            }
            if(P1.degre>=P2.degre){
                (*P3).degre = P1.degre;
            }else{
                (*P3).degre=P2.degre;
            }
        }
    }
    
    void soust(Polynome P1,Polynome P2, Polynome *P3) { //Soustraction de deux polynômes
     int i;
     int j;
     int k;
    
        if(P1.degre + P2.degre > LMAX){
            printf("ERREUR TROP ELEMENTS");
        }else{
            i=0;
            j=0;
            k=0;
            while(i<=P1.degre && j<=P2.degre){
                if(P1.coeff[i]>=P2.coeff[j]){
                    (*P3).coeff[k]=P1.coeff[i]-P2.coeff[j];
                }else{
                    (*P3).coeff[k]=P2.coeff[j]-P1.coeff[i];
                }
                i=i+1;
                j=j+1;
                k=k+1;
            }
    
            if(i>P1.degre){
                for(j=j; j<P2.degre; j++){
                    (*P3).coeff[k]=P2.coeff[j];
                    k=k+1;
                }
                if((*P3).coeff[k]>0){
                    (*P3).coeff[k]=P1.coeff[i];
                }
            }else{
                for(i=i; i<P1.degre; i++){
                    (*P3).coeff[k]=P1.coeff[i];
                    k=k+1;
                }
                if((*P3).coeff[k]>0){
                    (*P3).degre=k;
                }
            }
        }
    }
    
    void mult(Polynome P1, Polynome P2,Polynome *P3) { // Multiplication de deux polynomes
        int i;
        int j;
        int k;
    
        if(P1.degre == 0){
            (*P3).degre = 0;
        }else{
            if(P2.degre == 0 ){
                (*P3).degre = 0 ;
            }else{
                for(k=0; k<(*P3).degre; k++){
                    (*P3).coeff[k]=0;
                }
                i=0;
                j=0;
                do{
                    while(j<=P2.degre){
                        k=i+j;
                        (*P3).coeff[k] = (P1.coeff[i]*P2.coeff[j])+(*P3).coeff[k];
                        j=j+1;
                    }
                    i=i+1;
                    j=0;
                }while(i==P1.degre - 1);
                (*P3).degre = (P1.degre + P2.degre) - 2;
            }
        }
    }
    
    void multr(Polynome *P, float r) { //Multiplication d'un polynôme par un reel
        int i;
    
    for(i=0; i<(*P).degre; i++){
        (*P).coeff[i]=(*P).coeff[i]*r;
    }
    
    }
    
    void multm(Polynome *P, float coeff, int deg) { //Multiplication d'un polynôme par un monôme
        int i;
        int j;
      i=0;
      while(i<=(*P).degre){
        j=i+deg;
        (*P).coeff[j]=(*P).coeff[j]*coeff;
        i=i+1;
      }
      (*P).degre = (*P).degre + deg;
    }
    
    void deriv(Polynome P1,Polynome *P2) {// Dérivation d'un polynôme
        int i;
        for(i=0; i<P1.degre; i++){
            if(P1.coeff[i+1]>0){
                (*P2).coeff[i]=P1.coeff[i+1]*(i+1);
            }
        }
        (*P2).degre= P1.degre -1;
    }
    
    void copie(Polynome P1, Polynome *P2) { //Copie d'un polynôme
        int i;
        for(i=0; i<P1.degre; i++){
            (*P2).coeff[i]=P1.coeff[i];
    
        }
        (*P2).degre=P1.degre;
    }
    
    Bool nul(Polynome P) { //Vrai si P est nul, Faux sinon
        return (P.degre==0);
    }
    
    int degre(Polynome P) { //Degre du polynôme
        return(P.coeff[P.degre - 1]);
        return -1;
    }
    
    float coef(Polynome P, int i) { //Coefficient du monôme de degre i
        return(P.coeff[i]);
        return -1.0;
    }
    
    float poly(Polynome P, float x) { //Evaluation du Polynôme en un point
        int y;
        int i;
    
        y=P.coeff[P.degre];
        for(i=P.degre; i>0; i--){
            y=y*x+P.coeff[i];
        }
        return(y);
        return -1.0;
    }
    
    void affpol(Polynome P) { //Affichage d'un polynome
        int i;
    
    
        if( nul(P) ) {
            printf("Polynome NUL.");
        }else {
            for(i=0; i<P.degre; i++){
                if(P.coeff[i]>0){
                    printf("%6.1fX^%d\t",P.coeff[i],i);
                    printf("+");
                    }else {
                        printf("%6.1fX^%d",P.coeff[i],i);
                    }
                }
    
            }
    }

    -----

  2. #2
    lolo1546

    Re : Polynôme

    j'ai oublié mon main c'est

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    #include "polyt.h"    // ou #include "polyp.h"
    
    // Pour afficher les MAX premiers polynômes de Tchebychev
    const int MAX=12;
    
    void afficher(Polynome tn)
    {
      Polynome tnp, d;
      zero(&tnp);
      zero(&d);
    
      printf("polynome\n"); affpol(tn);printf("\n\n");
      printf("tn(1) = %f\n",poly(tn,1));
      printf("tn(-1) = %f\n\n",poly(tn,-1));
      deriv(tn,&tnp);
      printf("polynome derive\n"); affpol(tnp);printf("\n\n");
      add(tn,tnp,&d);
      printf("addition\n"); affpol(d);printf("\n\n");
      soust(tn,tnp,&d);
      printf("soustraction\n"); affpol(d);printf("\n\n");
      mult(tn,tnp,&d);
      printf("multiplication\n"); affpol(d);printf("\n\n");
      printf("______________________________________________________________\n");
      getchar();
    }
    
    int main()
    {
        Polynome t0, t1, tn, tn1, tn2;
    
        int i;
    
        zero(&t0); plus(&t0,1,0);   // t0 = T_0(x) = 1
    	zero(&t1); plus(&t1,1,1);   // t1 = T_1(x) = x
    	afficher(t0); afficher(t1);
        copie(t0,&tn2); copie(t1,&tn1); //  tn2 = t0 ; tn1 = t1
    	for (i=2; i<=MAX; i++)
        {
            copie(tn2, &t0);copie(tn1, &t1); //  t0 = tn2 = T_i-2(x) = ; t1 = tn1 = T_i-1(x)
     		multm(&t1,2,1); // t1 = 2 x * tn1 = 2 x * T_i-1(x)
    		multr(&t0,1);   // t0 = tn2 = T_i-2(x) - inutile mais pour tester multr
    		soust(t1,t0,&tn);   // T_n = 2 x * T_i-1(x) - T_i-2(x)
    		printf("n=%i\n",i); afficher(tn);
    		copie(tn1,&tn2); copie(tn,&tn1); // tn2 = T_i-2(x) ; tn1 = T_i-1(x)
        }
        getchar();
    
        return 0;
    }

  3. #3
    Chanur

    Re : Polynôme

    Bonjour,

    Disons que si tu nous donnais tout on pourrait essayer de le compiler pour voir ce que ça donne.

    Moi, pour l'instant j'ai :
    erreur fatale: booleens.h : Aucun fichier ou dossier de ce type
    erreur fatale: polyt.h : Aucun fichier ou dossier de ce type

    Et si je les mets en commentaire :
    erreur: unknown type name ‘Polynome’

    Je peux créer un type Polynome pour voir si j'aurai les mêmes erreurs que toi, mais c'est franchement hasardeux ...
    Ou alors tu peux tout nous donner et pas seulement des morceaux.
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

  4. #4
    lolo1546

    Re : Polynôme

    Excusez moi vs avez raison je vous envoie le dossier en piece jointe (compressé) cordialement
    Fichiers attachés Fichiers attachés
    Dernière modification par lolo1546 ; 14/09/2015 à 07h30.

  5. A voir en vidéo sur Futura
  6. #5
    Chanur

    Re : Polynôme

    Maintenant que ta pièce jointe est validée, on peut reprendre.
    Je ne suis pas allé loin. Le début du main :
    zero(&t0); plus(&t0,1,0);
    "zero" met à 0 le degré du polynôme qu'on lui passe
    "plus" balaie donc le polynôme en partant de i=0, tant que i < 0 et donc ne fait rien.

    Deuxième ligne, idem.

    Après ça se complique peut-être, mais comme tu réutilises les mêmes polynômes et qu'ils ne contiennent pas ce que tu voudrais, si ça donnait le bon résultat, ce serait forcément une erreur.
    Il vaut mieux corriger le début avant de continuer.

    A toi de jouer !
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

  7. #6
    lolo1546

    Re : Polynôme

    Merci pour votre aide
    mais je ne comprend pas tout à fait ce que vous voulez dire?
    cordialement

  8. #7
    Chanur

    Re : Polynôme

    Je ne comprends pas. C'est toi qui l'as programmé et tu n'arrive pas à le lire ?
    Que fait la fonction "zero" ?
    Que fait la fonction "plus" ?
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

  9. #8
    lolo1546

    Re : Polynôme

    excusez moi
    en effet moi j'écris juste les procédures mais tout le programme c'est le prof qui donne

    en effet la procedure zero = "c'est un polynome null "
    et la procédure plus = "c'est l'addition d'un monôme par un polynôme"

    j'ai regardé mon projet et j'ai fais quelques modification

    mais ma seul procedure qui ne fonctionne pas c'est la procédure mult qui calcule le produit de deux polynomes mais je vois pas l'erreur dans cette procédure, en plus de ça si j'enlève la procédure mult programme fonctionne et si je remets le programme s'arrête au polynôme tn (avec n=2 procedure de Tchebeychev)


    est ce possible de m'aider s'il vous plait

    merci

    cordialement
    Fichiers attachés Fichiers attachés

  10. #9
    imoca

    Re : Polynôme

    Code:
    void zero(Polynome *P) { //Polynôme nul
        (*P).degre=0;
        for(int i=0;i<LMAX;i++){
            (*P).coeff[i]=0;
        }
    }
    Mais le polynome nul n'est pas de degré 0.

    Code:
    void plus(Polynome *P, float coeff, int deg) { //Addition d'un monôme à un polynôme
            (*P).coeff[deg]=(*P).coeff[deg]+coeff;
            if((*P).degre<degre){
               (*P).degre=degre;
            }    
       }
    
    }
    Code:
    void add(Polynome P1,Polynome P2, Polynome *P3) { //Addition de deux polynômes
      for(int i=0;i<LMAX;i++){
           (*P3).coeff[i]=P1.coeff[i]+P2.coeff[i];
    }
    if(P1.degre>P2.degre){
    (*P3).degre=P1.degre;
    }else{
    (*P3).degre=P2.degre;
    }
    }

  11. #10
    lolo1546

    Re : Polynôme

    Merci bcp pour la procédure zero vs avez raison et si c'est possible de verifier ma procédure mult //multiplication de deux polynomes car mon programme beug encore s'il vs plait car je suis sûr à 100% que l'erreur viens de la multiplication et voici certaine modif que j'ai fais dans le projet
    Code:
    void mult(Polynome P1, Polynome P2,Polynome *P3) { //multiplication de deux polynome
         int i;
        int j;
        int k;
    
       if(nul(P1)){
        zero(P3);
       }else{
            if(nul(P2)){
                zero(P3);
            }else{
                (*P3).degre = P1.degre + P2.degre;
                for(k=0; k <(*P3).degre; k++){
                    (*P3).coeff[k]=0;
                }
                i=0;
                j=0;
                k=0;
                do{
                    while(i<P1.degre && j<P2.degre){
                        if(P1.coeff[i] != 0){
                            k = i + j;
                            (*P3).coeff[k] = (P1.coeff[i]*P2.coeff[j])+(*P3).coeff[k];
                            j=j+1;
                        }
                    }
                    i = i+1;
                    j=0;
                }while(i == P1.degre);
    
            }
       }
    }
    Fichiers attachés Fichiers attachés

  12. #11
    imoca

    Re : Polynôme

    Code:
    void mult(Polynome P1, Polynome P2,Polynome *P3) { //multiplication de deux polynomes
                // on considérera P3 = poly nul
                for(int i=0;i<LMAX;i++){
                     for(int j=0; j<LMAX-i;j++){
                                (*P3).coeff[i+j]+=P1.coeff[i]*P2.coeff[j];
                     }
                }
                (*P3).degre=P1.degre+P2.degre;
        
    }

  13. #12
    lolo1546

    Re : Polynôme

    Je vous remercie bcp pour votre aide
    cordialement

  14. #13
    lolo1546

    Re : Polynôme

    Bonjour

    est ce que quelqu'un pourrait m'aider à m'indiquer mon erreur car lors de la compilation il m'affiche un polynome nul sachant que je travail avec des pointeurs

    cordialement
    Fichiers attachés Fichiers attachés

  15. #14
    imoca

    Re : Polynôme

    Code:
    void plus(Polynome *P, float coeff, int deg) {
        Cellule* q;
        Cellule* R;
        Cellule* S;
    
        if(nul(*P) == True){
            printf("Polynome nul\n");
        }else{
            if(coeff != 0){
                q = malloc(sizeof(Cellule));
                (*q).element.degre = deg;
                (*q).element.coeff = coeff;
                if(*P == NULL || deg < (*(*P)).element.degre){
                    (*q).lien = *P;
                    *P = q;
    Code:
    void zero(Polynome *P) {
    
    
        (*P) = NULL;
        Cellule* q = (*P);
        while( q != NULL){
            free(q);
            q = (*q).lien;
        }
    
    }
    Dans ton main, tu fais des zero(&t1)...; donc les polynomes pointes sur null.
    Ensuite la fonction plus(p,c,d) fait un if P==null sans opération,alors le polynome null est retourné au lieu du monome.

  16. #15
    lolo1546

    Re : Polynôme

    Haou pardon de répondre très tardivement
    donc j'ai fais quelques modif dans la plus part de mes procédures mais lors de la compilation bloque et il affiche un degré négatif
    serait-il possible que quelqu'un m'aide s'il vous plait cordialement
    Fichiers attachés Fichiers attachés

  17. #16
    imoca

    Re : Polynôme

    Le degré négatif est une erreur de pointeur, tu affiche l'adresse mémoire et non son contenue.

  18. #17
    imoca

    Re : Polynôme

    main.c

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    #include "poly.h"
    
    
    int main()
    {
        Polynome *poly = zero();
        Polynome *poly2 = zero();
    
        add_monome(poly,2,1);
        add_monome(poly2,2,-1);
        add_monome(poly2,1,-1);
        printf("poly=");afficherPolynome(poly);
        printf("poly2=");afficherPolynome(poly2);
        Polynome *poly3=addition(poly,poly2);
        printf("poly3=");afficherPolynome(poly3);
        printf("deg= %d \n",degre(poly3));
        printf("derivé de poly2=");afficherPolynome(derivation(poly2));
        float a=2;
        afficherPolynome(soustraction(poly,poly3));
        afficherPolynome(produit(poly,poly2));
        return 0;
    }
    poly.c
    Code:
    #include <stdio.h>
    #include <stdlib.h>
    #include "poly.h"
    
    Polynome *zero()
    {
        Polynome *p = malloc(sizeof(*p));
        Element *element = malloc(sizeof(*element));
    
        if (p == NULL || element == NULL)
        {
            exit(EXIT_FAILURE);
        }
    
        element->exp = 0;
        element->coef = 0.00;
        element->suivant = NULL;
        p->premier = element;
    
        return p;
    }
    
    
    void add_monome(Polynome *p, int exp, float coef)
    {
        /* Création du nouvel élément */
        Element *nouveau = malloc(sizeof(*nouveau));
        if (p == NULL || nouveau == NULL)
        {
            exit(EXIT_FAILURE);
        }
        nouveau->exp = exp;
        nouveau->coef = coef;
    
    
        /* Insertion de l'élément au début de polynome */
        nouveau->suivant = p->premier;
        p->premier = nouveau;
    }
    
    void afficherPolynome(Polynome *p)
    {
        if (p == NULL)
        {
            exit(EXIT_FAILURE);
        }
    
        Element *actuel = p->premier;
        int depart=0;
        while (actuel != NULL)
        {
            if(actuel->coef!=0.00){
            if(depart>0){
                if(actuel->coef>0){
                    printf("+");
                }
            }else{depart=1;}
            if(actuel->exp!=0){
                printf("%f X^%d", actuel->coef,actuel->exp);}
            else{
                printf("%f ", actuel->coef);
            }
            }
            actuel = actuel->suivant;
        }
        printf("\n");
    }
    
    Polynome* copyPolynome(Polynome *p){
        Polynome *q=zero();
        q->premier=NULL;
        if(p->premier!=NULL){
            Element *pr = malloc(sizeof(*pr));
            pr->coef=p->premier->coef;
            pr->exp=p->premier->exp;
            Polynome *aux=zero();
            aux->premier=p->premier->suivant;
            pr->suivant=copyPolynome(aux)->premier;
            q->premier=pr;
        }
        return q;
    }
    
    Polynome* concatPolynome(Polynome* p1, Polynome *p2){
        Polynome *q;
        printf("concat \n");
        q=copyPolynome(p2);
        Element *actuel = p1->premier;
        while (actuel != NULL)
        {
            add_monome(q,actuel->exp,actuel->coef);
            actuel = actuel->suivant;
        }
        return q;
    }
    
    Polynome* Simplify(Polynome *p){
        Polynome* t=copyPolynome(p);
        Polynome* q=malloc(sizeof(*q));
        Element *actuel = p->premier;
        while (actuel != NULL)
        {
            int exp=actuel->exp;
            float coef=actuel->coef;
            Element *actuel2 = actuel->suivant;
            while (actuel2 != NULL)
            {
                if(actuel2->exp==exp){
                    coef+=actuel2->coef;
                    actuel2->coef=0.00;
                    actuel2->exp=-1;
                }
                actuel2=actuel2->suivant;
            }
            if(coef!=0){
                add_monome(q,exp,coef);
            }
            actuel = actuel->suivant;
        }
        return q;
    
    }
    
    Polynome* addition(Polynome *p1, Polynome *p2){
        return Simplify(concatPolynome(p1,p2));
    }
    
    int degre(Polynome *p){
        //retourne -1 pour le polynome nul
        int d=-1;
        Element *actuel = p->premier;
        while (actuel != NULL)
        {
            if(actuel->exp>d && actuel->coef!=0.00){
                d=actuel->exp;
            }
            actuel = actuel->suivant;
        }
        return d;
    }
    
    Polynome* derivation(Polynome *p){
        Polynome *q=copyPolynome(p);
        Element *actuel = q->premier;
        while (actuel != NULL)
        {
            if(actuel->exp!=0){
                actuel->coef=(actuel->coef)*actuel->exp;
                actuel->exp=(actuel->exp)-1;
            }else{
                actuel->coef=0.00;
                actuel->exp=0;}
            actuel = actuel->suivant;
        }
        return Simplify(q);
    
    }
    
    void Factor(Polynome *p, float a){
        printf("%f \n",a);
        Element *actuel = p->premier;
        while (actuel != NULL)
        {
            actuel->coef=a*(actuel->coef);
            actuel = actuel->suivant;
        }
    }
    Polynome* soustraction(Polynome *p1,Polynome *p2){
        Polynome *q=copyPolynome(p2);
        Factor(q,-1);
        return addition(p1,q);
    }
    
    Polynome* produit(Polynome *p1,Polynome *p2){
        Polynome *q=zero();
        Element *actuel = p1->premier;
        while (actuel != NULL)
        {
            Element *actuel2 = p2->premier;
            while (actuel2 != NULL)
            {
                add_monome(q,(actuel->exp)+(actuel2->exp),(actuel->coef)*(actuel2->coef));
                actuel2=actuel2->suivant;
            }
            actuel = actuel->suivant;
        }
        return Simplify(q);
    
    }
    poly.h
    Code:
    #ifndef H_POLY
    #define H_POLY
    
    typedef struct Element Element;
    struct Element
    {
        float coef;
        int exp;
        Element *suivant;
    };
    
    typedef struct Liste Polynome;
    struct Liste
    {
        Element *premier;
    };
    
    Polynome *zero();
    void add_monome(Polynome *p, int exp, float coef);
    void afficherPolynome(Polynome *p);
    Polynome *add(Polynome *p1,Polynome *p2);
    Polynome* copyPolynome(Polynome *p);
    Polynome* concatPolynome(Polynome* p1, Polynome *p2);
    void Factor(Polynome *p, float a);
    #endif

  19. #18
    lolo1546

    Re : Polynôme

    merci bcp les ami(e)s

Discussions similaires

  1. Polynome or not Polynome (complexe)
    Par comfiss dans le forum Mathématiques du supérieur
    Réponses: 4
    Dernier message: 31/10/2013, 16h26
  2. Aide, polynome non constants de C[X] divisibles par leur polynome dérivé.
    Par loupixx dans le forum Mathématiques du supérieur
    Réponses: 16
    Dernier message: 05/11/2012, 20h22
  3. polynome
    Par invite9e382d96 dans le forum Mathématiques du supérieur
    Réponses: 1
    Dernier message: 27/07/2012, 17h23
  4. Automatique. Passage d'un polynôme en p à un polynôme en Z
    Par invite1bf94880 dans le forum Physique
    Réponses: 1
    Dernier message: 14/03/2008, 11h03
  5. polynome, m paramètre , différentes valeurs degré du polynome
    Par invited7a80298 dans le forum Mathématiques du collège et du lycée
    Réponses: 8
    Dernier message: 15/10/2007, 17h54