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

Commenter
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 premire 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 mre 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 mre 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 mre 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 (-,+ ) aprs.");
	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 problmes");
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

Un exemple d'implémentation de polynomes et d'opérations associées!
Exemple de page d'authentification - Conseils pratiques -PHP
Exemple de code html page d'accueil ✓ - Forum Graphisme/design
Polynomes de tchebychev - Forum C / C++ / C++.NET
Avl implementation - Forum Java
Sms windev exemple - Forum Autres langages
S'inscrire maintenant
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.
Source / Exemple :

Conclusion :

A voir également

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Vous n'êtes pas encore membre ?

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