Un exemple d'implémentation de polynomes et d'opérations associées!

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 577 fois - Téléchargée 29 fois

Contenu du snippet

Ce programme permet de créer des polynômes à partir de l'utilisation de pointeurs! Vous pourrez donc faire les opérations usuelles sur les polynômes sans vous cassez la tête! Il y a même un manuel d'utilisation qui y est ajouté!

Source / Exemple :


#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<alloc.h>
#include<dos.h>
#include<ctype.h>

/*******************************************************************

  • Les structures du programme *
                                                                                                                                        • /
typedef struct element { int degre; float coef; struct element *monomesvt; }monome; typedef struct ensemble { char nom; monome *ptrtetepolynome; struct ensemble *polynomesvt; }polynome; typedef struct saisie { int code; struct saisie *codesvt; }entree; /*******************************************************************
  • Elements constitutifs des bureaux de travail *
                                                                                                                                        • /
void fenetre(int x,int y,int x1,int y1,int color) { textbackground(color); window(x,y,x1,y1); clrscr(); } void squel(void) { int i,j; clrscr(); fenetre(1,1,80,25,0); textcolor(WHITE); gotoxy(17,1); cprintf("------------------------------------------------------------"); gotoxy(17,3); cprintf("------------------------------------------------------------"); gotoxy(17,21); cprintf("------------------------------------------------------------"); gotoxy(17,24); cprintf("------------------------------------------------------------"); gotoxy(17,25); textcolor(RED); cprintf("FLECHES DIR. ENTREE ECHAP ."); textcolor(WHITE); gotoxy(29,25); cprintf("parcourir (menu)"); gotoxy(53,25); cprintf("valider"); gotoxy(67,25); cprintf("Sortie"); gotoxy(15,1); while(wherey()<25) { gotoxy(15,wherey()); cprintf("|\n\r"); } } void bureau(void) { int i,j; squel(); textcolor(RED); gotoxy(20,2); cprintf("%c Cr&#8218;ation %c",toascii(16),toascii(17)); textcolor(7); gotoxy(40,2); cprintf("%c Recherche %c",toascii(16),toascii(17)); gotoxy(60,2); cprintf("%c D&#8218;rivation %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(17,22); cprintf("Cr&#8218;er des polyn&#8220;mes &#8230; utiliser dans les op&#8218;rations..."); } void bureau1(void) { int i,j; squel(); textcolor(7); gotoxy(20,2); cprintf("%c Cr&#8218;ation %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(40,2); cprintf("%c Recherche %c",toascii(16),toascii(17)); gotoxy(60,2); textcolor(7); cprintf("%c D&#8218;rivation %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(27,22); cprintf("v&#8218;rifier si un polyn&#8220;me existe..."); } void bureau2(void) { int i,j; squel(); textcolor(7); gotoxy(20,2); cprintf("%c Cr&#8218;ation %c",toascii(16),toascii(17)); gotoxy(40,2); cprintf("%c Recherche %c",toascii(16),toascii(17)); gotoxy(60,2); textcolor(RED); cprintf("%c D&#8218;rivation %c",toascii(16),toascii(17)); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(27,22); cprintf("D&#8218;river un polyn&#8220;me d&#8218;ja existant ..."); } void operation(void) { int i,j; squel(); textcolor(RED); gotoxy(20,2); cprintf("%c Addition %c",toascii(16),toascii(17)); textcolor(7); gotoxy(50,2); cprintf("%c Multiplication %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); textcolor(WHITE); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(27,22); cprintf("Additionner des polyn&#8220;mes d&#8218;j&#8230; existants ..."); } void operation1(void) { int i,j; squel(); textcolor(7); gotoxy(20,2); cprintf("%c Addition %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(50,2); cprintf("%c Multiplication %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); textcolor(WHITE); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(27,22); cprintf("Multiplier des polyn&#8220;mes d&#8218;j&#8230; existants ..."); } void divers(void) { int i,j; squel(); textcolor(RED); gotoxy(20,2); cprintf("%c Aide programme %c",toascii(16),toascii(17)); textcolor(7); gotoxy(50,2); cprintf("%c A propos %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); textcolor(RED); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); textcolor(WHITE); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(17,22); cprintf("Donner une explication des entit&#8218;s du programme ..."); } void divers1(void) { int i,j; squel(); textcolor(7); gotoxy(20,2); cprintf("%c Aide programme %c",toascii(16),toascii(17)); textcolor(RED); gotoxy(50,2); cprintf("%c A propos %c",toascii(16),toascii(17)); textcolor(WHITE); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); textcolor(RED); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(1,12); textcolor(WHITE); cprintf("%c Quitter %c",toascii(16),toascii(17)); gotoxy(27,22); cprintf("Pr&#8218;sentation du programme et de ses auteurs ..."); } void quitter(void) { int i,j; squel(); textcolor(WHITE); gotoxy(1,3); cprintf("%c Polynomes %c",toascii(16),toascii(17)); gotoxy(1,6); cprintf("%c Op&#8218;ration %c",toascii(16),toascii(17)); gotoxy(1,9); cprintf("%c Divers %c",toascii(16),toascii(17)); gotoxy(27,22); cprintf("Quitter le programme..."); gotoxy(1,12); textcolor(RED); cprintf("%c Quitter %c",toascii(16),toascii(17)); } /*******************************************************************
  • La fonction de tri du polynome saisi *
Objectif:Avoir un polynome ordonn&#8218; et o&#8212; on additionne les monomes de m&#710;me degr&#8218;. L'addition et la multiplication s'appuient sur cette fonction. Par exemple pour l'addition il suffit de concatener les polynomes dans une m&#710;me liste et faire le tri...
                                                                                                                                        • /
void tri(monome *tete) { monome *teteref,*tetetmp,*chiffon,*prec; int degretmp; float coeftmp; teteref=(tete); while(teteref->monomesvt!=NULL) { tetetmp=teteref->monomesvt; prec=teteref; while(tetetmp!=NULL) { if(teteref->degre<tetetmp->degre) { degretmp=teteref->degre; coeftmp=teteref->coef; teteref->degre=tetetmp->degre; teteref->coef=tetetmp->coef; tetetmp->degre=degretmp; tetetmp->coef=coeftmp; } else if(teteref->degre==tetetmp->degre) { teteref->coef=teteref->coef+tetetmp->coef; chiffon=tetetmp; while(chiffon->monomesvt!=NULL) { degretmp=chiffon->degre; coeftmp=chiffon->coef; chiffon->degre=(chiffon->monomesvt)->degre; chiffon->coef=(chiffon->monomesvt)->coef; (chiffon->monomesvt)->degre=degretmp; (chiffon->monomesvt)->coef=coeftmp; chiffon=chiffon->monomesvt; } chiffon->coef=0; chiffon->degre=-1; tetetmp=prec; } prec=prec->monomesvt; tetetmp=tetetmp->monomesvt; } teteref=teteref->monomesvt; } } /*******************************************************************
  • La fonction d'inversion de la saisie *
Objectif:Pouvoir faire une premiŠre transformation de la saisie.
                                                                                                                                        • /
void inverse(entree *init,entree **vrai) { entree *t; int recule; recule=0; (*vrai)=NULL; while(init!=NULL) { if(init->code!=-40) { t=(entree*)malloc(sizeof(entree)); t->code=init->code; t->codesvt=(*vrai); (*vrai)=t; init=init->codesvt; } else { do { recule++; init=init->codesvt; } while(init->code==-40); while(recule>0) { init=init->codesvt; recule--; } } } } /*******************************************************************
  • La fonction de saisie du programme *
Objectif: pouvoir saisir le polynome comme un texte en tapant '*'avant le degre et '+'ou'-' pour separer les polynomes.
                                                                                                                                        • /
void saisie(entree **tete,int lieu) { int entry,place,verif,limitcoef,limitdegre,debut; char output; entree *tetetmp,*vraitete; place=lieu; verif=0; limitcoef=0; limitdegre=0; debut=1; (*tete)=NULL; vraitete=NULL; do { entry=getch(); if(place==lieu) { limitdegre=0; if((entry>=48)&&(entry<=57)&&(limitcoef<3)) { gotoxy(wherex(),place); tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=entry-48; tetetmp->codesvt=vraitete; vraitete=tetetmp; output=toascii(entry); cprintf("%c",output); limitcoef++; debut++; if(verif==2) verif=0; else if(verif!=0) verif=3; } else if(((entry==44)||(entry==46))&&(verif==0)&&(debut!=1)) { gotoxy(wherex(),place); tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=entry; tetetmp->codesvt=vraitete; vraitete=tetetmp; output=toascii(entry); cprintf("%c",output); verif=1; limitcoef=0; } else if(((entry==43)||(entry==45))&&((verif==3)||(verif==0))) { gotoxy(wherex(),place); tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=entry; tetetmp->codesvt=vraitete; vraitete=tetetmp; output=toascii(entry); cprintf("%c",output); verif=2; limitcoef=0; } else if(entry==42) { gotoxy(wherex(),place); cprintf("X"); tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=entry; tetetmp->codesvt=vraitete; vraitete=tetetmp; if(place==lieu) place--; gotoxy(wherex(),place); debut=1; } else if((entry==8)&&(wherex()>=27)) { gotoxy(wherex()-1,place); cprintf(" "); gotoxy(wherex()-1,place-1); cprintf(" "); gotoxy(wherex()-1,place); limitcoef--; tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=-40; tetetmp->codesvt=vraitete; vraitete=tetetmp; } } else { limitcoef=0; if((entry>=48)&&(entry<=57)&&(limitdegre<2)) { gotoxy(wherex(),place); tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=entry-48; tetetmp->codesvt=vraitete; vraitete=tetetmp; output=toascii(entry); cprintf("%c",output); limitdegre++; debut++; } else if((entry==43)||(entry==45)) { tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=entry; tetetmp->codesvt=vraitete; vraitete=tetetmp; output=toascii(entry); gotoxy(wherex(),lieu); cprintf("%c",output); verif=0; debut=1; limitdegre=0; if(place==(lieu-1)) place++; verif=2; } else if((entry==8)&&(wherex()>=27)) { gotoxy(wherex()-1,place); cprintf(" "); gotoxy(wherex()-1,place+1); cprintf(" "); gotoxy(wherex()-1,place+1); limitdegre--; tetetmp=(entree*)malloc(sizeof(entree)); tetetmp->code=-40; tetetmp->codesvt=vraitete; vraitete=tetetmp; } } } while((entry!=13)&&(wherex()<79)); if(vraitete!=NULL) inverse(vraitete,&(*tete)); } /*******************************************************************
  • Fonctions de transformation de la saisie *
                                                                                                                                        • /
/**************-*La fonction suivante est celle qui fait la transformation lorsque la saisie commence par le signe '-'*/ void recuperermoins(float *coef,int *degre,entree **t) { int i,j,tab[4]; float tmp[4]; tab[0]=1;tab[1]=10;tab[2]=100;tab[3]=1000; tmp[0]=0.1;tmp[1]=0.01;tmp[2]=0.001;tmp[3]=0.0001; i=-1; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*coef)+=((*t)->code)*tab[(3-i)]; (*t)=(*t)->codesvt; } if(i>(-1)) { (*coef)/=tab[(3-i)]; if(((*t)->code==44)||((*t)->code==46)) { i=-1; (*t)=(*t)->codesvt; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*coef)+=((*t)->code)*tmp[i]; (*t)=(*t)->codesvt; } } (*coef)=(-1)*(*coef); } else (*coef)=0; if((*t)->code==42) { if((*coef)==0) (*coef)=-1; i=-1; (*t)=(*t)->codesvt; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*degre)+=(*t)->code*tab[(3-i)]; (*t)=(*t)->codesvt; } if(i<0) (*degre)=1; else (*degre)/=tab[(3-i)]; } else if(((*t)->code==43)||((*t)->code==45)) (*degre)=0; } /**************-*La fonction suivante est celle qui fait la transformation par d&#8218;faut*/ void recupererplus(float *coef,int *degre,entree **t) { int i,j,tab[4]; float tmp[4]; tab[0]=1;tab[1]=10;tab[2]=100;tab[3]=1000; tmp[0]=0.1;tmp[1]=0.01;tmp[2]=0.001;tmp[3]=0.0001; i=-1; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*coef)+=(*t)->code*tab[(3-i)]; (*t)=(*t)->codesvt; } if(i>(-1)) { (*coef)/=tab[(3-i)]; if(((*t)->code==44)||((*t)->code==46)) { i=-1; (*t)=(*t)->codesvt; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*coef)+=((*t)->code)*tmp[i]; (*t)=(*t)->codesvt; } } } else (*coef)=0; if((*t)->code==42) { if((*coef)==0) (*coef)=1; i=-1; (*t)=(*t)->codesvt; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*degre)+=(*t)->code*tab[(3-i)]; (*t)=(*t)->codesvt; } if(i<0) (*degre)=1; else (*degre)/=tab[(3-i)]; } else if(((*t)->code==43)||((*t)->code==45)) (*degre)=0; } /**************-*La fonction suivante est celle qui fait la transformation lorsque la saisie commence par le signe '*' */ void recupererX(float *coef,int *degre,entree **t) { int i,j,tab[4]; tab[0]=1;tab[1]=10;tab[2]=100;tab[3]=1000; i=-1; while(((*t)->code<=9)&&((*t)->code>=0)&&(*t!=NULL)) { i++; (*degre)+=(*t)->code*tab[(3-i)]; (*t)=(*t)->codesvt; } if(i<0) (*degre)=1; else (*degre)/=tab[(3-i)]; if((*coef)==0) (*coef)=1; } /************-*Fonction mŠre de la transformation*/ void transforme(entree *init,monome **tete) { monome *tmp; (*tete)=NULL; int degretmp; float coeftmp; coeftmp=0; degretmp=0; while(init!=NULL) { if(init->code==43) { init=init->codesvt; recupererplus(&coeftmp,&degretmp,&init); tmp=(monome*)malloc(sizeof(monome)); tmp->coef=coeftmp; tmp->degre=degretmp; tmp->monomesvt=(*tete); (*tete)=tmp; coeftmp=0; degretmp=0; } else if(init->code==45) { init=init->codesvt; recuperermoins(&coeftmp,&degretmp,&init); tmp=(monome*)malloc(sizeof(monome)); tmp->coef=coeftmp; tmp->degre=degretmp; tmp->monomesvt=(*tete); (*tete)=tmp; coeftmp=0; degretmp=0; } else if(init->code==42) { init=init->codesvt; recupererX(&coeftmp,&degretmp,&init); tmp=(monome*)malloc(sizeof(monome)); tmp->coef=coeftmp; tmp->degre=degretmp; tmp->monomesvt=(*tete); (*tete)=tmp; coeftmp=0; degretmp=0; } else if((init->code<=9)&&(init->code>=0)) { recupererplus(&coeftmp,&degretmp,&init); tmp=(monome*)malloc(sizeof(monome)); tmp->coef=coeftmp; tmp->degre=degretmp; tmp->monomesvt=(*tete); (*tete)=tmp; coeftmp=0; degretmp=0; } } } /*******************************************************************
  • La fonction de cr&#8218;ation de polynome *
Objectif:Preparer le champ de travail . On ne pourra cr&#8218;er que 5 polynomes &#8230; la fois et des noms arbitraires leur seront attribu&#8218;es. NB:SI VOUS OUTREPASSEZ CETTE OPERATION VOUS NE POUREZ RIEN FAIRE !!!
                                                                                                                                        • /
void creator(polynome **tp,int *n) { int entry,fin,x,y,i,retour,verify; char nomtmp; entree *teteentry,*entre; monome *tete; polynome *tmp; fin=0; x=20; y=5; do { gotoxy(x,y); cprintf("Entrez le nombre de polyn&#8220;me(s) &#8230; cr&#8218;er:[ ]"); gotoxy(wherex()-2,y); fin=getch()-48; if((fin<=5)&&(fin>=1)) { gotoxy(wherex(),y); cprintf("%d",fin); } } while(((fin>5)||(fin<1))&&(fin!=-21)); do verify=getch(); while(verify!=13); gotoxy(1,25); clreol(); gotoxy(1,24); gotoxy(x,y); clreol(); i=0; gotoxy(17,25); cprintf("Avant degre TAPEZ '*'.Avant monome TAPEZ '+'ou'-'.ENTREE en fin."); while(i<fin) { gotoxy(x,y); if((*n)<=26) nomtmp=toascii((*n)+64); else nomtmp=toascii((*n)+70); cprintf("%c [X]=",nomtmp); saisie(&teteentry,y); if(teteentry!=NULL) { tmp=(polynome*)malloc(sizeof(polynome)); tmp->nom=nomtmp; transforme(teteentry,&tmp->ptrtetepolynome); tri(tmp->ptrtetepolynome); tri(tmp->ptrtetepolynome); tmp->polynomesvt=(*tp); (*tp)=tmp; (*n)++; } else cprintf(" Non pris en compte."); i++; y=y+2; } gotoxy(17,25); clreol(); gotoxy(20,25); textcolor(RED); cprintf("ENTREE"); gotoxy(27,25); textcolor(WHITE); cprintf("Pour revenir"); do retour=getch(); while(retour!=13); } /*******************************************************************
  • Fonction d\'affichage de polynomes *
                                                                                                                                        • /
void afficher (monome *tete,int x,int y) { int i; i=1; gotoxy(17,y); clreol(); gotoxy(x,y); textcolor(WHITE); while(tete!=NULL) { if(tete->coef!=0.00) { if(wherex()>64) { if(y>18) { gotoxy(17,22); clreol(); cprintf("SUITE:"); gotoxy(17,23); clreol(); gotoxy(20,23); y=23; } else { gotoxy(17,y+2); clreol(); gotoxy(17,y+2); y=y+2; } } i++; textcolor(LIGHTGRAY); gotoxy(wherex(),y); cprintf("(%.2f)",tete->coef); if(tete->degre>0) { cprintf("X"); textcolor(WHITE); gotoxy(wherex(),y-1); cprintf("%d",tete->degre); } if(tete->monomesvt!=NULL) { gotoxy(wherex(),y); cprintf("+"); } } tete=tete->monomesvt; } if(i==1) { gotoxy(wherex(),y); cprintf("0.00"); } } /*******************************************************************
  • Fonction de recherche de polynome *
                                                                                                                                        • /
void search(polynome *tete) { char nom; int nomtmp,retour; monome *resultat; gotoxy(17,25); clreol(); textcolor(WHITE); gotoxy(25,9); cprintf("Quel est le nom du polynome:"); nomtmp=getch(); if(((nomtmp<=90)&&(nomtmp>=65))||((nomtmp<=122)&&(nomtmp>=97))) { nom=toascii(nomtmp); cprintf(" %c",nom); while((tete!=NULL)&&(tete->nom!=nom)) { tete=tete->polynomesvt; } if(tete!=NULL) { resultat=(monome*)malloc(sizeof(monome)); resultat=tete->ptrtetepolynome; gotoxy(20,13); textcolor(7); cprintf("Le polyn&#8220;me %c existe; sa valeur est:",nom); textcolor(WHITE); afficher(resultat,20,15); } else { gotoxy(20,15); textcolor(7); cprintf("Le polyn&#8220;me specifi&#8218; n\'existe pas!"); } } else { gotoxy(20,15); textcolor(7); cprintf("Le polyn&#8220;me specifi&#8218; n\'existe pas!"); } gotoxy(17,25); textcolor(RED); cprintf("ENTREE"); textcolor(WHITE); cprintf(" pour revenir."); do retour=getch(); while(retour!=13); } /*******************************************************************
  • La fonction de d&#8218;rivation de polynome *
Objectif:Permettre de d&#8218;river un polynome d&#8218;j&#8230; cr&#8218;e . NB:S'il n'y a aucun polynome vous devrez repartir &#8230; la cr&#8218;ation...
                                                                                                                                        • /
/*************-*Fonction mŠre de la d&#8218;rivation*/ void chercherderiver(polynome *tetetmp,char nomtmp) { monome *tmp,*ref,*tete; while((tetetmp!=NULL)&&(tetetmp->nom!=nomtmp)) tetetmp=tetetmp->polynomesvt; if(tetetmp->nom==nomtmp) { tete=tetetmp->ptrtetepolynome; ref=NULL; while(tete!=NULL) { tmp=(monome*)malloc(sizeof(monome)); if(tete->degre>=1) { tmp->coef=(tete->coef)*(tete->degre); tmp->degre=(tete->degre)-1; } else tmp->coef=0; tmp->monomesvt=ref; ref=tmp; tete=tete->monomesvt; } tri(ref); tri(ref); gotoxy(17,wherey()+2); textcolor(RED); cprintf("Resultat="); textcolor(WHITE); afficher(ref,17,wherey()+2); } else { gotoxy(17,19); cprintf("Le polynome specifi&#8218; n'existe pas!!!"); } } /*************-*Fonction de coordination de la d&#8218;rivation*/ void derive(polynome *tete) { monome *tmp,*ref; int j,retour; char nomtmp; j=0; gotoxy(17,25); clreol(); textcolor(WHITE); gotoxy(17,5);clreol(); gotoxy(17,25);clreol(); gotoxy(20,5); cprintf("Quel est le nom du polynome:"); j=getch(); if(j!=27) { nomtmp=toascii(j); gotoxy(wherex(),wherey()); cprintf("%c",nomtmp); chercherderiver(tete,nomtmp); } gotoxy(17,25); textcolor(RED); cprintf("ENTREE"); gotoxy(24,25); textcolor(WHITE); cprintf("pour revenir"); do retour=getch(); while(retour!=13); } /*******************************************************************
  • La fonction d'addition de polynomes *
Objectif:Permettre l'addition de polynomes existants.
                                                                                                                                        • /
/*************-*Fonction de selection des polynomes &#8230; additionner*/ void parcourselect(polynome *tete,monome **polyp) { monome *tmp,*val; int x,y,coche,nb,test; x=20; y=6; nb=1; test=1; (*polyp)=NULL; while(tete!=NULL) { if(nb<(12*test)) gotoxy(x,y); else { test++; x=x+18; y=6; gotoxy(x,y); } cprintf("%c:[ ]",tete->nom); gotoxy(x+3,y); coche=getch(); if(coche==32) { cprintf("Ajout&#8218;"); tmp=tete->ptrtetepolynome; while(tmp!=NULL) { val=(monome*)malloc(sizeof(monome)); val->degre=tmp->degre; val->coef=tmp->coef; val->monomesvt=(*polyp); (*polyp)=val; tmp=tmp->monomesvt; } } else cprintf("refut&#8218;"); tete=tete->polynomesvt; y++; nb++; } } /*************-*Fonction de coordination de l'addition*/ void add(polynome *tete) { monome *resultat; char nomtmp; int retour; gotoxy(17,25); clreol(); gotoxy(17,4); cprintf("SELECTIONNER PAR BARRE D'ESPACEMENT LES POLYNOMES A ADDITIONNER."); textcolor(WHITE); parcourselect(tete,&resultat); tri(resultat); tri(resultat); gotoxy(17,wherey()+2); if((resultat!=NULL)&&(resultat->coef!=0)) { cprintf("Resultat="); afficher(resultat,17,wherey()+2); } else if(resultat->coef!=0) { gotoxy(17,18); cprintf("Aucun polyn&#8220;me pour l'op&#8218;ration."); } gotoxy(17,25); textcolor(RED); cprintf("ENTREE"); gotoxy(24,25); textcolor(WHITE); cprintf("pour revenir"); do retour=getch(); while(retour!=13); } /******************************************************************* /* La fonction de multiplication des polynomes * Objectif:Permettre la mutiplication de polynomes existants.
                                                                                                                                      • /
/*************-*Fonction de selection des polynomes &#8230; multiplier*/ void parcourselect(polynome *tete,polynome **polyp) { polynome *tmp; int x,y,coche,nb,test; x=20; y=6; test=1; nb=1; (*polyp)=NULL; while(tete!=NULL) { if(nb<(12*test)) gotoxy(x,y); else { test++; x=x+18; y=6; gotoxy(x,y); } cprintf("%c:[ ]",tete->nom); gotoxy(x+3,y); coche=getch(); if(coche==32) { cprintf("Ajout&#8218;"); tmp=(polynome*)malloc(sizeof(polynome)); tmp->ptrtetepolynome=tete->ptrtetepolynome; tmp->nom=tete->nom; tmp->polynomesvt=(*polyp); (*polyp)=tmp; } else cprintf("refut&#8218;"); tete=tete->polynomesvt; y++; nb++; } } /*************-*Fonction mŠre de la multiplication*/ void multiplierpolynomes(monome *polyp,monome *polyq,monome **result) { monome *resultat,*resultattmp,*ptmp,*qtmp; if((polyp!=NULL)&&(polyq!=NULL)) { ptmp=polyp; qtmp=polyq; resultat=(monome*)malloc(sizeof(monome)); resultat=NULL; while(ptmp!=NULL) { while(qtmp!=NULL) { resultattmp=(monome*)malloc(sizeof(monome)); resultattmp->degre=ptmp->degre; resultattmp->coef=ptmp->coef; resultattmp->monomesvt=resultat; resultat=resultattmp; qtmp=qtmp->monomesvt; } qtmp=polyq; ptmp=ptmp->monomesvt; } (*result)=(monome*)malloc(sizeof(monome)); (*result)=resultat; while(resultat!=NULL) { qtmp=polyq; while(qtmp!=NULL) { resultat->degre=(resultat->degre)+(qtmp->degre); resultat->coef=(resultat->coef)*(qtmp->coef); resultat=resultat->monomesvt; qtmp=qtmp->monomesvt; } } tri(*result); tri(*result); } } /*************-*Fonction de coordination de la multiplication*/ void multiply(polynome *tete) { polynome *polytmp; monome *produit,*oper1,*oper2; int retour; gotoxy(17,25); clreol(); gotoxy(17,4); cprintf("SELECTIONNER PAR BARRE D'ESPACEMENT LES POLYNOMES A MULTIPLIER."); textcolor(WHITE); parcourselect(tete,&polytmp); oper1=NULL; oper2=NULL; if(polytmp!=NULL) { oper1=polytmp->ptrtetepolynome; polytmp=polytmp->polynomesvt; oper2=polytmp->ptrtetepolynome; polytmp=polytmp->polynomesvt; if((oper1!=NULL)&&(oper2!=NULL)) { multiplierpolynomes(oper1,oper2,&produit); while(polytmp!=NULL) { oper2=produit; multiplierpolynomes(polytmp->ptrtetepolynome,oper2,&produit); polytmp=polytmp->polynomesvt; } gotoxy(17,wherey()+2); if((produit!=NULL)&&(produit->coef!=0)) { cprintf("Resultat="); afficher(produit,17,wherey()+2); } else cprintf("Aucun polyn&#8220;me pour l'op&#8218;ration."); } else { gotoxy(17,20); cprintf("Pas assez de polyn&#8220;mes!!!"); } } else { gotoxy(17,20); cprintf("Pas assez de polyn&#8220;mes!!!"); } gotoxy(17,25); textcolor(RED); cprintf("ENTREE"); gotoxy(24,25); textcolor(WHITE); cprintf("pour revenir"); do retour=getch(); while(retour!=13); } /******************************************************************
  • Fonction proposant de l'aide sur le programme *
                                                                                                                                        • /
void touche(void) { int i,verify,retour; i=1; verify=0; gotoxy(25,5); cprintf("Cochez (taper 1) la fonction sp&#8218;cifi&#8218;e:"); textcolor(7); gotoxy(20,8); cprintf("Cr&#8218;ation de polyn&#8220;mes [ ]"); gotoxy(49,8); verify=getch(); if(verify==49) { textcolor(WHITE); gotoxy(20,8); cprintf("Cr&#8218;ation de polyn&#8220;mes "); gotoxy(25,11); textcolor(7); cprintf("Permet de cr&#8218;er les polyn&#8220;mes sur lesquels vous allez"); gotoxy(17,12); cprintf("travailler."); gotoxy(25,13); cprintf("Tapez directement le polyn&#8220;me en vous mettant en t&#710;te"); gotoxy(17,14); cprintf("que pour entrer un degr&#8218; il faut d\'abord taper le signe de"); gotoxy(17,15); cprintf("la multiplication avant, un signe d\'addition (-,+ ) aprŠs."); gotoxy(17,16); cprintf("Aussi les monomes sont separ&#8218;s par un signe d\'addition."); } else { i++; gotoxy(20,10); cprintf("D&#8218;rivation de polyn&#8220;mes [ ]"); gotoxy(49,10); verify=getch(); if(verify==49) { textcolor(WHITE); gotoxy(20,10); cprintf("D&#8218;rivation de polyn&#8220;mes "); gotoxy(25,12); textcolor(7); cprintf("Permet de d&#8218;river un polyn&#8220;me d&#8218;j&#8230; existant."); gotoxy(25,13); cprintf("Tapez d\'abord le nom du polyn&#8220;me &#8230; d&#8218;river afin que"); gotoxy(17,14); cprintf("l\'on soit s&#8211;r qu\'il existe. C\'est seulement ce que vous"); gotoxy(17,15); cprintf("aurez &#8230; faire g&#8218;neralement."); } else { i++; gotoxy(20,12); cprintf("Addition de polyn&#8220;mes [ ]"); gotoxy(49,12); verify=getch(); if(verify==49) { textcolor(WHITE); gotoxy(20,12); cprintf("Addition de polyn&#8220;mes "); gotoxy(25,13); textcolor(7); cprintf("Permet de faire la somme de polyn&#8220;mes que "); gotoxy(17,14); cprintf("vous devrez selectionner auparavant."); } else { i++; gotoxy(20,14); cprintf("Multiplication de polyn&#8220;mes [ ]"); gotoxy(49,14); verify=getch(); if(verify==49) { textcolor(WHITE); gotoxy(20,14); cprintf("Multiplication de polyn&#8220;mes "); gotoxy(25,15); textcolor(7); cprintf("Permet de faire le produit de polyn&#8220;mes que "); gotoxy(17,16); cprintf("vous devrez selectionner auparavant."); } } } } gotoxy(17,25); clreol(); textcolor(RED); cprintf("ENTREE "); textcolor(WHITE); cprintf("pour revenir"); retour=getch(); while(retour!=13) retour=getch(); } /*******************************************************************
  • Fonction dedi&#8218;e &#8230; la pr&#8218;sentation du logiciel et des auteurs *
                                                                                                                                      • /
void copyright(void) { int retour; textcolor(7); gotoxy(25,5); cprintf("Ce logiciel est un outil performant pour les problŠmes"); gotoxy(18,6); cprintf("classiques de d&#8218;rivation et op&#8218;rations avec les polyn&#8220;mes.Son"); gotoxy(18,7); cprintf("utilisation est assez facile mais il est plut&#8220;t bas&#8218; sur le "); gotoxy(18,8); cprintf("principe DEFENSIF (on emp&#710;che l\'utilisateur de commettre des"); gotoxy(18,9); cprintf("b&#8218;vues).Mais vous pourrez toujours vous en rendre compte..."); gotoxy(25,11); cprintf("Les auteurs (OUATTARA J.S.Dimitri et YAGO S.S&#8218;raphin)"); gotoxy(18,12); cprintf("viennent evidemment tous de R&#8218;MI2. Ce projet nous a surtout "); gotoxy(18,13); cprintf("appris comment traiter des saisies quelconques,impl&#8218;menter "); gotoxy(18,14); cprintf("les op&#8218;rations d'addition ou de multiplication &#8230; partir de "); gotoxy(18,15); cprintf("tris sp&#8218;cifiques. Nous restons ouverts &#8230; toutes les sugges- "); gotoxy(18,16); cprintf("tions et mettons ce code &#8230; disposition pour tout le monde. "); gotoxy(25,18); cprintf("Fait &#8230; Bobo-Dioulasso le 10-01-2005"); textcolor(WHITE); gotoxy(25,20); cprintf("Contact:ouattaradimitri@yahoo.fr "); gotoxy(17,25); clreol(); textcolor(RED); cprintf("ENTREE"); textcolor(WHITE); cprintf(" pour revenir"); do retour=getch(); while(retour!=13); } /*******************************************************************
  • Fonction de sortie du programme *
                                                                                                                                        • /
void logout(void) { int i; gotoxy(17,25); clreol(); textcolor(YELLOW); gotoxy(30,10); cprintf("Ce projet a &#8218;t&#8218; &#8218;labor&#8218; par:"); textcolor(WHITE); gotoxy(30,12); cprintf("Y"); delay(250); cprintf("A"); delay(250); cprintf("G"); delay(250); cprintf("O"); delay(250); cprintf(" "); delay(250); cprintf("S."); delay(250); cprintf(" "); delay(250); cprintf("S"); delay(250); cprintf("o"); delay(250); cprintf("u"); delay(250); cprintf("m"); delay(250); cprintf("a"); delay(250); cprintf("&#8249;"); delay(250); cprintf("l"); delay(250); cprintf("a "); delay(250); gotoxy(20,15); cprintf("ET"); gotoxy(30,18); cprintf(" O"); delay(250); cprintf("U"); delay(250); cprintf("A"); delay(250); cprintf("T"); delay(250); cprintf("T"); delay(250); cprintf("A"); delay(250); cprintf("R"); delay(250); cprintf("A"); delay(250); cprintf(" "); delay(250); cprintf("J"); delay(250); cprintf("."); delay(250); cprintf("S"); delay(250); cprintf("."); delay(250); cprintf(" "); delay(250); cprintf("D"); delay(250); cprintf("i"); delay(250); cprintf("m"); delay(250); cprintf("i"); delay(250); cprintf("t"); delay(250); cprintf("r"); delay(250); cprintf("i"); delay(250); cprintf("..."); delay(250); textcolor(YELLOW); gotoxy(20,20); cprintf("CRAFDEMO,,POLYNOME_AND_PLUS_SOFTWARE ver0.1.2"); delay(1500); textcolor(WHITE); abort(); } /*******************************************************************
  • La fonction de base de la selection des menus *
                                                                                                                                        • /
void parcours(int *place,int *special) { int i,j; i=getch(); if(i==0) { j=getch(); switch(j) { case 72:(*place)--; if((*place)<1) (*place)=4; (*special)=1; break; case 80:(*place)++; if((*place)>4) (*place)=1; (*special)=1; break; case 77:(*special)++; switch((*place)) { case 1:if((*special)>3) (*special)=1; break; case 2:if((*special)>2) (*special)=1;; break; case 3:if((*special)>2) (*special)=1;; break; default:; } break; case 75:(*special)--; if((*special)<1) switch((*place)) { case 1:(*special)=3; break; case 2:(*special)=2;; break; case 3:(*special)=2;; break; default:; } break; } } else if(i==13) (*place)=0-(*place); else if(i==27) (*place)=0; } /*******************************************************************
  • La fonction de coordination du programme *
                                                                                                                                        • /
void selection(void) { polynome *teteprincipale; int demo,vertical,horiz,nom; vertical=1; nom=1; horiz=1; teteprincipale=NULL; while((vertical!=0)) { parcours(&vertical,&horiz); switch(vertical) { case 1:clrscr(); switch(horiz) { case 1:bureau(); break; case 2:bureau1(); break; case 3:bureau2(); break; } break; case 2:clrscr(); switch(horiz) { case 1:operation(); break; case 2:operation1(); break; } break; case 3:clrscr(); switch(horiz) { case 1:divers(); break; case 2:divers1(); break; } break; case 4:clrscr() ; quitter(); break; case -1:switch(horiz) { case 1:creator(&teteprincipale,&nom); break; case 2:search(teteprincipale); break; case 3:derive(teteprincipale); break; }; break; case -2:switch(horiz) { case 1:add(teteprincipale); break; case 2:multiply(teteprincipale); break; }; break; case -3:switch(horiz) { case 1:touche(); break; case 2:copyright(); break; }; break; case -4:logout(); break; } } } /*******************************************************************
  • La fonction de d&#8218;but du programme *
                                                                                                                                        • /
void present(void) { int i,j; j=1; clrscr(); textmode(C80); textcolor(BLUE); fenetre(10,3,70,22,7); gotoxy(wherex()+9,wherey()+3); cprintf("CrafDemo,,POLYNOME_AND_PLUS_SOFTWARE ver0.1.2"); textcolor(0); gotoxy(wherex()-30,wherey()+5); cprintf("Presented by:"); textcolor(1); gotoxy(wherex()-20,wherey()+2); cprintf("-*-OUATTARA Jean Serge Dimitri"); gotoxy(wherex()-30,wherey()+1); cprintf("-*-YAGO Souma&#8249;la S&#8218;raphin"); fenetre(30,20,50,20,0); fenetre(30,18,50,18,0); textcolor(BLUE); while(j<5) { i=1; while(i<=11) { if(i>1) fenetre(30+2*(i-2),20,30+2*(i-2),20,0); fenetre(30+2*(i-1),20,30+2*(i-1),20,1); if(i<11) fenetre(30+2*i,20,30+2*i,20,1); if(i<10) fenetre(30+2*(i+1),20,30+2*(i+1),20,1); i++; delay(100); } fenetre(50,20,50,20,0); fenetre(30,18,30+(5*j),18,1); j++; } fenetre(30,20,50,20,7); } /*******************************************************************
  • La fonction d'entr&#8218;e du programme *
                                                                                                                                        • /
void demarer(void) { int entree,numtache,position; present(); textcolor(0); fenetre(15,22,27,22,7); textcolor(0); cprintf("EXI"); textcolor(5); cprintf("T/ECHAP"); textcolor(5); fenetre(55,22,67,22,7); cprintf("ENTREE/E"); textcolor(0); cprintf("NTER"); textcolor(7); fenetre(63,20,63,20,7); do entree=getch(); while((entree!=13)&&(entree!=27)&&(entree!=69)&&(entree!=84)&&(entree!=101)&&(entree!=116)); if((entree==69)||(entree==101)||(entree==13)) { clrscr(); bureau(); selection(); } else exit; } /*******************************************************************
  • La fonction principale du programme *
                                                                                                                                        • /
void main() { demarer(); }

Conclusion :


je compte ameliorez ce code avec les critiques que vous ferrez!

A voir également

Ajouter un commentaire

Commentaires

Messages postés
5
Date d'inscription
mardi 14 novembre 2000
Statut
Membre
Dernière intervention
2 mai 2010

Cette année je suis les TDs et TPs en algorithmiques des prémières années dans mon université.
Je vais profiter corriger ce code et le leur donner comme base de projet.
Messages postés
5
Date d'inscription
mardi 14 novembre 2000
Statut
Membre
Dernière intervention
2 mai 2010

C'est vrai que c'est long! je crois qu'avec vos critiques je pourrai performer plus!
merci!
Messages postés
121
Date d'inscription
mardi 3 mai 2005
Statut
Membre
Dernière intervention
31 décembre 2005

je pense k ton prog est assez long
mais je dois dire kel fonctionne bien
a part ca t'aurai du utliser une procedure ou une fonction
+ utilisation de eof(end of file)
Messages postés
5
Date d'inscription
mardi 14 novembre 2000
Statut
Membre
Dernière intervention
2 mai 2010

je m'y mets dès que je peux!
Messages postés
54
Date d'inscription
dimanche 27 février 2005
Statut
Membre
Dernière intervention
21 juin 2007
1
J'ai pas eu le courage de lire le code , ça serait sympa de mettre un zip avec une séparation en plusieurs fichiers !

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.