#include <iostream>

#include <math.h>
#include <string>

using namespace std;

struct Monome {
double reel;
int exposant;
};

struct Maillon {
Monome monome;
Maillon *next;
};

struct Polynome {
Maillon *Tete;
Maillon *Queue;
};

//Fonction pour creer un liste :

Polynome *creerPolynome() {
Polynome *p = new Polynome();
p->Tete = NULL;
p->Queue = NULL;
return p;
}

//Fonction pour creer un Maillon :

Maillon *creerMaillon(Monome monome) {
Maillon *maillon = new Maillon;
if (maillon != NULL) {
maillon->monome = monome;
maillon->next = NULL;
}
return maillon;
}

//Fonction pour teste cette la liste vide :

bool EstVide(Polynome p) {
return (p.Tete == NULL);
}

//Fonction pour creer le monome :

Monome creerMonome(double coeff, int exp) {
Monome m;
m.exposant = exp;
m.reel = coeff;
return m;
}

//Fonctin pour Ajouter :

Polynome *AjoutTete(Polynome *p, int degre, double coeff) {
Monome m = creerMonome(coeff, degre);
Maillon *pol = creerMaillon(m);
if (EstVide(*p)) {
p->Tete = p->Queue = pol;
return p;
 } else {
pol->next = p->Tete;
p->Tete = pol;
return p;
}
}

//Fonctin pour calculer la valeur des polynome on X

double EvaluePoly(Polynome *p, double x) {
Maillon *temp = p->Tete;
double value = 0;
while (temp != NULL) {
value += temp->monome.reel * pow(x, temp->monome.exposant);
temp = temp->next;
}
return value;
}

//Fonction pour tester si un monone exist deja et le retourne:

Maillon *EstExist(Polynome *p, Monome m) {
Maillon *temp = p->Tete, *exist = nullptr;
while (temp != NULL) {
if (temp->monome.exposant == m.exposant) {
exist = temp;
break;
}
temp = temp->next;
}
return exist;
}

//Fontion pour trier les monome en ordre deroissant. ex: 2X^3 + X^2 - 1
Polynome *trierPolynome(Polynome *p) {
Maillon *node = p->Tete, *temp = NULL;
int exposant;
double reel; //temp variable pour stocker le exposant

while (node != NULL) {

temp = node;
while (temp->next != NULL) { // boucler jusqu a l avant dernier maillon
if (temp->monome.exposant < temp->next->monome.exposant) {// comparer
les exposants
exposant = temp->monome.exposant; //swap les donnes
reel = temp->monome.reel;
temp->monome.exposant = temp->next->monome.exposant;
temp->monome.reel = temp->next->monome.reel;
temp->next->monome.exposant = exposant;
temp->next->monome.reel = reel;
}
temp = temp->next;
}
node = node->next;
}

return p;
}

//Fonction pour Ajouter Monome a un polynome:

Polynome *AjouteMonome(Polynome *p, Monome m) {
 Maillon *maillon = creerMaillon(m);
if (EstVide(*p)) {
p->Tete = p->Queue = maillon;
return p;
} else if (EstExist(p, m) != NULL) {
Maillon *temp = EstExist(p, m);
temp->monome.reel += m.reel;
} else {
p->Queue->next = maillon;
p->Queue = maillon;
}

return trierPolynome(p);
}

//Fonction pour calculer la somme:

Polynome *SommePolynome(Polynome *p1, Polynome *p2) {
Maillon *temp1 = p2->Tete;
while (temp1 != NULL) {
AjouteMonome(p1, temp1->monome);
temp1 = temp1->next;
}
return p1;
}

//Fonction pour calculer la dirive :

Polynome *DerivePoly(Polynome *p) {
Maillon *temp = p->Tete;
Polynome *derive = creerPolynome();
Monome m;
double coeff;
int exp;

while (temp != NULL) {

coeff = temp->monome.exposant * temp->monome.reel;
exp = temp->monome.exposant - 1;
m.exposant = exp;
m.reel = coeff;
derive = AjouteMonome(derive, m);

temp = temp->next;
}
return derive;
}

//Fonction pour multiplier un polynome par un monome :

Polynome *Multip(Polynome *p, Monome m) {
Maillon *temp = p->Tete;
Monome pM;
Polynome *multP = creerPolynome();
while (temp != NULL) {
pM.exposant = temp->monome.exposant + m.exposant;
pM.reel = temp->monome.reel * m.reel;
multP = AjouteMonome(multP, pM);
temp = temp->next;
}
return multP;
}
//Fonction pour dupliquer une polynome:
Polynome *Dupliquer(Polynome *p) {
Polynome *duplicateP = creerPolynome();
duplicateP = p;
return duplicateP;
}

//Foction pour suprrimer une polynome

void SuppList(Polynome *p) {
Maillon *temp;

while (p->Tete != NULL) {

temp = p->Tete;
p->Tete = p->Tete->next;
free(temp);
}
}

//Fonction pour multiplier 2 polynomes :

Polynome *ProduitP(Polynome *P, Polynome *Q) {
Maillon *temp = P->Tete;
Polynome *R = Dupliquer(P);
Polynome *produit = creerPolynome();
//SuppList(P);
while (temp != NULL) {
produit = SommePolynome(produit, Multip(Q, temp->monome));
temp = temp->next;
}
return produit;
}

//Fonction pour afficher un polynome :

void AfficherPol(string nomP, Polynome *p) {
if (!EstVide(*p)) {
Maillon *temp = p->Tete;
cout << "\n>> " << nomP << "(X) = ";
while (temp != NULL) {
if (temp->monome.exposant > 0) {
cout << temp->monome.reel << "X^" << temp->monome.exposant << " +
";
} else
cout << temp->monome.reel;

temp = temp->next;
}

cout << " 0 \n";

} else
cout << ">> Le polynome est vide !!" << endl;
}

int main(int argc, char **argv) {

int b = 1, c = 8, exp = 1;
double coef = 1, x = 0;
Polynome *P = creerPolynome(), *Q = creerPolynome();
Monome m = creerMonome(coef, exp);

while (true) {
cout << "\n\n";
 cout << "\t\t\t+____________________________________________________+" <<
endl;
cout << "\t\t\t|----------------------------------------------------|" <<
endl;
cout << "\t\t\t| MENU |" <<
endl;
cout << "\t\t\t|----------------------------------------------------|" <<
endl;
cout << "\t\t\t| 1-Ajouter monome. |" <<
endl;
cout << "\t\t\t| 2-La valeur du polynome en un point. |" <<
endl;
cout << "\t\t\t| 3-La derive d'un polynome. |" <<
endl;
cout << "\t\t\t| 4-Libere une polynome. |" <<
endl;
cout << "\t\t\t| 5-Somme de deux polynomes. |" <<
endl;
cout << "\t\t\t| 6-Produit d'un polynomes par un monome. |" <<
endl;
cout << "\t\t\t| 7-Produit de deux polynomes. |" <<
endl;
cout << "\t\t\t| 8-Aficher un polynome. |" <<
endl;
cout << "\t\t\t| 99-Exit le programme. |" <<
endl;
cout << "\t\t\t|____________________________________________________|\n\n"
<< endl;
cout << ">> Entrer un choix (1 -> 8):";
cin >> c;
system("cls");
switch (c) {
case 1:
do {
cout
<< ">> A quelle polynome voulez vous insere?\n\n\t\t\
t1- Polynome P.\n\t\t\t2- Polynome Q.\n\t\t\t0- Annuler.\n\n>> votre choix : ";
cin >> b;
system("cls");
switch (b) {
case 1:
cout << ">> Entrez le degres du monome : ";
cin >> exp;
cout << ">> Entrez le coefficient du monome : ";
cin >> coef;
P = AjouteMonome(P, creerMonome(coef, exp));
if (!EstVide(*P))
cout << "\n>> Monome est ajoutee avec succes au
polynome P(X).\n" << endl;
else
cout << "\n>> Echec d\'ajout le monome a P(X)!!\n"
<< endl;
break;

case 2:
cout << ">> Entrez le degres du monome : ";
cin >> exp;
cout << ">> Entrez le coefficient du monome : ";
cin >> coef;
 Q = AjouteMonome(Q, creerMonome(coef, exp));
if (!EstVide(*Q))
cout << "\n>> Monome est ajoutee avec succes au
polynome Q(X).\n" << endl;
else
cout << "\n>> Echec d\'ajout le monome a Q(X)!!\n"
<< endl;
break;

case 0:
break;

default:
cout << "Choix incorrecte! entre un nombre compris
entre 0 et 2." << endl;
break;
}
} while (b != 0);
b = 0;
break;

case 2:
do {
cout
<< ">> A quelle polynome voulez vous calculer sa
valeur?\n\n\t\t\t1- Polynome P.\n\t\t\t2- Polynome Q.\n\t\t\t0- Annuler.\n\n>>
votre choix : ";
cin >> b;
switch (b) {
case 1:
if (!EstVide(*P)) {
cout << ">> Entrer la valeur du X : ";
cin >> x;
cout << "\n>> La valeur du polynome P au point " <<
x << " est : " << EvaluePoly(P, x)
<< endl << endl;
} else
cout << "\n>> Le polynome est vide !!" << endl;
break;

case 2:
if (!EstVide(*Q)) {
cout << ">> Entrer la valeur du X : ";
cin >> x;
cout << "\n>> La valeur du polynome Q au point " <<
x << " est : " << EvaluePoly(Q, x)
<< endl << endl;
} else
cout << "\n>> Le polynome est vide !!" << endl;
break;

case 0:
break;

default:
cout << "Choix incorrecte! entre un nombre compris
entre 0 et 2." << endl;
break;
}
 } while (b != 0);
b = 0;
break;

case 3:
do {
cout
<< ">> A quelle polynome voulez vous calculer sa
derive?\n\n\t\t\t1- Polynome P.\n\t\t\t2- Polynome Q.\n\t\t\t0- Annuler.\n\n>>
votre choix : ";
cin >> b;
switch (b) {
case 1:
if (!EstVide(*P)) {
AfficherPol("P\'", DerivePoly(P));
} else
cout << ">> Le polynome est vide !!" << endl;
break;

case 2:
if (!EstVide(*Q)) {
AfficherPol(">> Derive du polynome Q.",
DerivePoly(Q));
} else
cout << ">> Le polynome est vide !!" << endl;
break;

case 0:
break;

default:
cout << "Choix incorrecte! entre un nombre compris
entre 0 et 2." << endl;
break;
}
} while (b != 0);
break;

case 4:
do {
cout
<< ">> Quelle polynome voulez vous supprimer?\n\n\t\t\
t1- Polynome P.\n\t\t\t2- Polynome Q.\n\t\t\t0- Annuler.\n\n>> votre choix : ";
cin >> b;
switch (b) {
case 1:
SuppList(P);
if (EstVide(*P))
cout << "Le polynome P est libere avec succes." <<
endl;
else
cout << "Echec de liberation P(X)." << endl;
break;

case 2:
SuppList(Q);
if (EstVide(*Q))
cout << "Le polynome Q est libere avec succes." <<
endl;
 else
cout << "Echec de liberation Q(X).." << endl;
break;

case 0:
break;

default:
cout << "Choix incorrecte! entre un nombre compris
entre 0 et 2." << endl;
break;
}
} while (b != 0);
break;

case 5:
if (EstVide(*P) || EstVide(*Q)) {
cout << "L\'un des deux polynomes est vide!" << endl;
} else {
cout << "La somme des polynomes P(X) et Q(X) est :" << endl;
cout << "\t";
AfficherPol("Somme de P(X) et Q", SommePolynome(P, Q));
}
break;

case 6:
do {
cout
<< "Quelle polynome voulez vous multiplier?\n\n\t\t\t1-
Polynome P.\n\t\t\t2- Polynome Q.\n\t\t\t0- Annuler.\n\n>> votre choix : ";
cin >> b;
switch (b) {
case 1:
if (!EstVide(*P)) {
cout << "Entre le degres du monome : ";
cin >> exp;
cout << "Entre le coefficient du monome : ";
cin >> coef;
m = creerMonome(coef, exp);
cout << "Le produit du poylnome P et " << coef <<
"X^" << exp << " est :" << endl;
cout << "\t";
AfficherPol("Produit du polynome P et le monome ",
Multip(P, m));
} else
cout << "aucun monome n est insere!" << endl;
break;

case 2:
if (!EstVide(*P)) {
cout << "Entre le degres du monome : ";
cin >> exp;
cout << "Entre le coefficient du monome : ";
cin >> coef;
m = creerMonome(coef, exp);
cout << "Le produit du poylnome Q et " << coef <<
"X^" << exp << " est :" << endl;
cout << "\t";
AfficherPol("Produit du polynome Q et le monome ",
Multip(Q, m));
} else
cout << "aucun monome n est insere!" << endl;
break;

case 0:
break;

default:
cout << "Choix incorrecte! entre un nombre compris
entre 0 et 2." << endl;
break;
}
} while (b != 0);
break;

case 7:
if (EstVide(*P) || EstVide(*Q)) {
cout << "L\'un des deux polynomes est vide!" << endl;
} else {
cout << "La produit des polynomes P(X) et Q(X) est :" << endl;
cout << "\t";
AfficherPol("Produit de P et Q", ProduitP(P, Q));
}
break;

case 8:
do {
cout
<< "Quelle polynome voulez vous afficher?\n\n\t\t\t1-
Polynome P.\n\t\t\t2- Polynome Q.\n\t\t\t0- Annuler.\n\n>> votre choix : ";
cin >> b;
switch (b) {
case 1:
AfficherPol("P", P);
break;

case 2:
AfficherPol("Q", Q);
break;

case 0:
break;

default:
cout << "Choix incorrecte! entre un nombre compris
entre 0 et 2." << endl;
break;
}
} while (b != 0);
break;

case 99:
exit(0);
break;

default:
cout << "Choix incorrecte! entre un nombre compris entre 0 et 8."
<< endl;
 break;
}
}

return 0;
}