#include <stdio.h>
#include <stdlib.h>
#include "polynome.h"
#include "liste.h"
#include "complexe.h"

polynome* polynome_creer()
{
    polynome* poly;

    poly = malloc(sizeof(polynome));

    if (poly == NULL)
    {
        printf("Screw you \n");
        printf("Keine Speicher");
        return poly;
    }

    poly -> forme_dev = malloc(sizeof(poly_dev));

    poly -> forme_dev = NULL;

    return poly;
}

polynome* polynome_addition_soustraction (polynome* poly1, polynome* poly2, int choix)
{

    polynome* poly_r;
    poly_r = polynome_creer();

    if (poly_r == NULL)
    {
        printf("Get AIDS please.");
        return poly_r;
    }

    poly_dev* poly1_bas;
    poly_dev* poly2_bas;

    poly_dev* nouveau;

    int degre;
    complexe coeff;

    poly1_bas = liste_parcourir_haut_bas(poly1 -> forme_dev);

    poly2_bas = liste_parcourir_haut_bas(poly2 -> forme_dev);

    do
    {
        if (poly1_bas -> monome.degre == poly2_bas -> monome.degre)
        {

            if (choix == 1)
            {
                degre = poly1_bas -> monome.degre;
                coeff = complexe_addition(poly1_bas -> monome.coeff, poly2_bas -> monome.coeff);
            }

            else
            {
                degre = poly1_bas -> monome.degre;
                coeff = complexe_soustraction(poly1_bas -> monome.coeff, poly2_bas -> monome.coeff);
            }

            nouveau = liste_creer_monome(degre, coeff);

            if (nouveau -> monome.coeff.reelle == 0 && nouveau -> monome.coeff.imaginr == 0)
            {

            }

            else
            {
                poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);
            }

            if (poly1_bas != NULL)
            {
                poly1_bas = poly1_bas -> prev;
            }

            if (poly2_bas != NULL)
            {
                poly2_bas = poly2_bas -> prev;
            }
        }

        else if (poly1_bas -> monome.degre > poly2_bas -> monome.degre)
        {

            if (choix == 1)
            {
                degre = poly2_bas -> monome.degre;
                coeff.reelle = poly2_bas -> monome.coeff.reelle;
                coeff.imaginr = poly2_bas -> monome.coeff.imaginr;
            }

            else
            {
                degre = poly2_bas -> monome.degre;
                coeff.reelle = poly2_bas -> monome.coeff.reelle*(-1);
                coeff.imaginr = poly2_bas -> monome.coeff.imaginr*(-1);
            }


            nouveau = liste_creer_monome(degre, coeff);

            poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);

            if (poly2_bas != NULL)
            {
                poly2_bas = poly2_bas -> prev;;
            }
        }

        else if (poly1_bas -> monome.degre < poly2_bas -> monome.degre)
        {
            if (choix == 1)
            {
                degre = poly1_bas -> monome.degre;
                coeff.reelle = poly1_bas -> monome.coeff.reelle;
                coeff.imaginr = poly1_bas -> monome.coeff.imaginr;
            }

            else
            {
                degre = poly1_bas -> monome.degre;
                coeff.reelle = poly1_bas -> monome.coeff.reelle;
                coeff.imaginr = poly1_bas -> monome.coeff.imaginr;
            }

            nouveau = liste_creer_monome(degre, coeff);

            poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);

            if (poly1_bas != NULL)
            {
                poly1_bas = poly1_bas -> prev;
            }
        }

    }
    while (poly1_bas != NULL && poly2_bas != NULL);

    if (poly1_bas == NULL && poly2_bas == NULL)
    {
        return poly_r;
    }

    else
    {
        if (poly1_bas == NULL)
        {
            do
            {
                if (choix == 1)
                {
                    degre = poly2_bas -> monome.degre;
                    coeff.reelle = poly2_bas -> monome.coeff.reelle;
                    coeff.imaginr = poly2_bas -> monome.coeff.imaginr;
                }

                else
                {
                    degre = poly2_bas -> monome.degre;
                    coeff.reelle = poly2_bas -> monome.coeff.reelle*(-1);
                    coeff.imaginr = poly2_bas -> monome.coeff.imaginr*(-1);

                }

                nouveau = liste_creer_monome(degre, coeff);

                poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);

                if (poly2_bas != NULL)
                {
                    poly2_bas = poly2_bas -> prev;
                }
            }
            while (poly2_bas != NULL);
        }

        else if (poly2_bas == NULL)
        {
            do
            {
                if (choix == 1)
                {
                    degre = poly1_bas -> monome.degre;
                    coeff.reelle = poly1_bas -> monome.coeff.reelle;
                    coeff.imaginr = poly1_bas -> monome.coeff.imaginr;
                }

                else
                {
                    degre = poly1_bas -> monome.degre;
                    coeff.reelle = poly1_bas -> monome.coeff.reelle;
                    coeff.imaginr = poly1_bas -> monome.coeff.imaginr;
                }


                nouveau = liste_creer_monome(degre, coeff);

                poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);

                if (poly1_bas != NULL)
                {
                    poly1_bas = poly1_bas -> prev;
                }
            }
            while (poly2_bas != NULL);
        }

        return poly_r;
    }
}

polynome* polynome_multiplication(polynome* poly1, polynome* poly2)
{
    polynome* poly_r;
    poly_r = polynome_creer();

    if (poly_r == NULL)
    {
        printf("Burn in hell.");
        return poly_r;
    }

    poly_dev* poly1_bas;
    poly_dev* poly2_bas;

    poly_dev* poly_tmp;

    poly_dev* nouveau;

    int degre;
    complexe coeff;

    poly1_bas = liste_parcourir_haut_bas(poly1 -> forme_dev);

    poly2_bas = liste_parcourir_haut_bas(poly2 -> forme_dev);

    do
    {
            if (poly1_bas -> monome.degre == 0)
            {
                degre = poly2_bas -> monome.degre;
            }

            else if (poly1_bas -> monome.degre == 1)
            {
                degre = 1 + poly2_bas -> monome.degre;
            }

            else if (poly2_bas -> monome.degre == 1)
            {
                degre = 1 + poly1_bas -> monome.degre;
            }

            else if (poly2_bas -> monome.degre == 0)
            {
                degre = poly1_bas -> monome.degre;
            }

            else
            {
                degre = poly1_bas -> monome.degre + poly2_bas -> monome.degre;
            }

            coeff = complexe_multiplication(poly1_bas -> monome.coeff, poly2_bas -> monome.coeff);

            nouveau = liste_creer_monome(degre, coeff);

            if (poly_r -> forme_dev != NULL)
            {
                if (degre < poly_r -> forme_dev -> monome.degre)
                {
                    nouveau -> next = poly_r -> forme_dev -> next;
                    poly_r -> forme_dev -> next -> prev = nouveau;
                    poly_r -> forme_dev -> next = nouveau;
                    nouveau -> prev = poly_r -> forme_dev;
                }

                else if (degre == poly_r -> forme_dev -> monome.degre)
                {
                    poly_r -> forme_dev -> monome.coeff = complexe_multiplication(poly_r -> forme_dev -> monome.coeff, coeff);
                }

                else
                {
                    poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);
                }
            }

            else
            {
                poly_r -> forme_dev = liste_ajout_tete(nouveau, poly_r -> forme_dev);
            }


            if (poly1_bas != NULL)
            {
                poly_tmp = poly1_bas;
                poly1_bas = poly1_bas -> prev;
            }

            if (poly1_bas == NULL)
            {
                poly1_bas = liste_parcourir_haut_bas(poly_tmp);
                poly2_bas = poly2_bas -> prev;
            }
    }
    while (poly2_bas != NULL);

    return poly_r;
}

polynome* polynome_conjugaison(polynome* poly1)
{
    polynome* tmp;

    tmp = polynome_creer();

    polynome* poly1_bas;
    poly1_bas = polynome_creer();

    poly_dev* nouveau;

    complexe coeff;

    int degre;

    poly1_bas = liste_parcourir_haut_bas(poly1 -> forme_dev);

    do
    {
        coeff = complexe_conjugaison(poly1_bas -> forme_dev -> monome.coeff);
        degre = poly1_bas -> forme_dev -> monome.degre;

        tmp -> forme_dev = liste_ajout_tete(nouveau, tmp -> forme_dev);

        poly1_bas -> forme_dev = poly1_bas -> forme_dev -> prev;
    }
    while (poly1_bas != NULL);

    return tmp;
}

void polynome_comparaison(polynome* poly1, polynome* poly2)
{
    int sup = 0;

    polynome* tmp1;

    tmp1 = polynome_creer();

    tmp1 = poly1;

    polynome* tmp2;

    tmp2 = polynome_creer();

    tmp2 = poly2;

    while (tmp1 -> forme_dev != NULL && tmp2 -> forme_dev != NULL)
    {
        if (tmp1 -> forme_dev -> monome.degre > tmp2 -> forme_dev -> monome.degre)
        {
            printf("Le premier polynome est de plus haut degre que le second \n");
            sup = 1;
            return;
        }

        else if (tmp1 -> forme_dev -> monome.degre < tmp2 -> forme_dev -> monome.degre)
        {
            printf("Le second polynome est de plus haut degre que le premier \n");
            sup = 2;
            return;
        }

        else
        {
            tmp1 -> forme_dev = tmp1 -> forme_dev -> next;
            tmp2 -> forme_dev = tmp2 -> forme_dev -> next;
        }
    }

    if (sup == 0)
    {
        printf("Les polynomes sont de meme degre et il faut les evaluer pour savoir quel est le plus grand \n");
        return;
    }
}

polynome* polynome_partie_reelle(polynome* poly1)
{
    polynome* poly_reel;
    poly_reel = polynome_creer(poly1);

    if (poly_reel == NULL)
    {
        printf("Ta maman.");
        return poly_reel;
    }

    poly_dev* poly1_bas;

    poly1_bas = liste_parcourir_haut_bas(poly1 -> forme_dev);

    poly_dev* nouveau;

    int degre;
    complexe coeff;

    do
    {
        degre = poly1_bas -> monome.degre;
        coeff.reelle = complexe_partie_reelle(poly1_bas -> monome.coeff);
        coeff.imaginr = 0;

        nouveau = liste_creer_monome(degre, coeff);

        poly_reel -> forme_dev = liste_ajout_tete(nouveau, poly_reel -> forme_dev);

        poly1_bas = poly1_bas -> prev;
    }
    while(poly1_bas != NULL);

    return (poly_reel);
}

polynome* polynome_partie_imaginr(polynome* poly1)
{
    polynome* poly_img;
    poly_img = polynome_creer(poly1);

    if (poly_img == NULL)
    {
        printf("Run away, now.");
        return poly_img;
    }

    poly_dev* poly1_bas;

    poly1_bas = liste_parcourir_haut_bas(poly1 -> forme_dev);

    poly_dev* nouveau;

    int degre;
    complexe coeff;

    do
    {
        degre = poly1_bas -> monome.degre;
        coeff.imaginr = complexe_partie_imaginaire(poly1_bas -> monome.coeff);
        coeff.reelle = 0;


        nouveau = liste_creer_monome(degre, coeff);

        poly_img -> forme_dev = liste_ajout_tete(nouveau, poly_img -> forme_dev);

        poly1_bas = poly1_bas -> prev;
    }
    while(poly1_bas != NULL);

    return (poly_img);
}

polynome* polynome_derivation(polynome* poly)
{
    polynome* poly_deriv;
    poly_deriv = polynome_creer(poly_deriv);

    if (poly_deriv == NULL)
    {
        printf("C'est ta mère que je vais dériver.");
        return poly_deriv;
    }

    poly_dev* poly_bas;
    poly_bas = liste_parcourir_haut_bas(poly -> forme_dev);

    poly_dev* nouveau;

    complexe coeff;
    int degre;

    do
    {
        coeff.reelle = (poly_bas -> monome.coeff.reelle) * (poly_bas -> monome.degre);
        coeff.imaginr = (poly_bas -> monome.coeff.imaginr) * (poly_bas -> monome.degre);
        degre = poly_bas -> monome.degre - 1;

        if (degre >= 0)
        {
            nouveau = liste_creer_monome(degre, coeff);

            poly_deriv -> forme_dev = liste_ajout_tete(nouveau, poly_deriv -> forme_dev);
        }

        poly_bas = poly_bas -> prev;
    }
    while (poly_bas != NULL);

    return poly_deriv;
}

polynome* polynome_integration(polynome* poly)
{
    polynome* poly_intgr;
    poly_intgr = polynome_creer(poly_intgr);

    if (poly_intgr == NULL)
    {
        printf("L'integrale de ta betise par le temps est infinie.");
        return poly_intgr;
    }

    poly_dev* poly_bas;
    poly_bas = liste_parcourir_haut_bas(poly -> forme_dev);

    poly_dev* nouveau;

    complexe coeff;
    int degre;

    do
    {
        coeff.reelle = (poly_bas -> monome.coeff.reelle) / (poly_bas -> monome.degre + 1);
        coeff.imaginr = (poly_bas -> monome.coeff.imaginr) / (poly_bas -> monome.degre + 1);
        degre = poly_bas -> monome.degre + 1;

        if (degre >= 0)
        {
            nouveau = liste_creer_monome(degre, coeff);

            poly_intgr -> forme_dev = liste_ajout_tete(nouveau, poly_intgr -> forme_dev);
        }

        poly_bas = poly_bas -> prev;
    }
    while (poly_bas != NULL);

    return poly_intgr;
}

void polynome_afficher(polynome* poly)
{
    poly_dev* tmp;

    tmp = poly -> forme_dev;

    poly_mono tmp2;

    while (tmp != NULL)
    {
        tmp2 = tmp -> monome;

        if (tmp -> monome.degre != 0)
        {

            if (tmp2.coeff.reelle == 0 && tmp2.coeff.imaginr ==0)
            {
            }

            if (tmp2.coeff.reelle == 0)
            {
                if (tmp2.coeff.imaginr == 0)
                {
                    printf("");
                }

                else if (tmp2.coeff.imaginr != 1 && tmp2.coeff.imaginr != -1)
                {
                    printf("%lf", tmp2.coeff.imaginr);
                    printf("i");
                }

                else if (tmp2.coeff.imaginr == -1)
                {
                    printf("-i");
                }

                else
                {
                    printf("i");
                }
            }

            else if (tmp2.coeff.imaginr == 0)
            {
                if (tmp2.coeff.reelle == 1)
                {
                    printf("");
                }

                else if (tmp2.coeff.reelle == -1)
                {
                    printf("-");
                }

                else
                {
                    printf("%lf", tmp2.coeff.reelle);
                }
            }

            else
            {
                printf("(%lf ", tmp2.coeff.reelle);

                if (tmp2.coeff.imaginr > 1)
                {
                    printf("+ %lfi)", tmp2.coeff.imaginr);
                }

                else if (tmp2.coeff.imaginr == 1)
                {
                    printf("+ i)");
                }

                else if (tmp2.coeff.imaginr == -1)
                {
                    printf("-i)");
                }

                else
                {
                    printf("%lfi)", tmp2.coeff.imaginr);
                }
            }

            if (tmp2.degre == 1)
            {
                if (tmp2.coeff.reelle != 0 || tmp2.coeff.imaginr != 0)
                {
                    printf("x");
                }
            }

            else
            {
                if (tmp2.coeff.reelle != 0 || tmp2.coeff.imaginr != 0)
                {
                    printf("x^%d", tmp2.degre);
                }
            }
        }

        else if (tmp2.degre == 0)
        {
            if (tmp2.coeff.reelle == 0)
            {
                if (tmp2.coeff.imaginr != 1 && tmp2.coeff.imaginr != -1)
                {
                    printf("%lf", tmp2.coeff.imaginr);
                    printf("i");
                }

                else if (tmp2.coeff.imaginr == -1)
                {
                    printf("-i");
                }

                else
                {
                    printf("i");
                }
            }

            else if (tmp2.coeff.imaginr == 0)
            {
                if (tmp2.coeff.reelle == 1)
                {
                    printf("1");
                }

                else if (tmp2.coeff.reelle == -1)
                {
                    printf("-1");
                }

                else
                {
                    printf("%lf", tmp2.coeff.reelle);
                }
            }

            else
            {
                printf("(%lf ", tmp2.coeff.reelle);

                if (tmp2.coeff.imaginr > 0)
                {
                    printf("+ %lfi)", tmp2.coeff.imaginr);
                }

                else
                {
                    printf("%lfi)", tmp2.coeff.imaginr);
                }
            }
        }

        if (tmp -> next != NULL)
        {
            if (tmp -> next -> monome.coeff.reelle > 0)
            {
                printf(" + ");
            }

            else if (tmp -> next -> monome.coeff.reelle == 0 && tmp -> next -> monome.coeff.imaginr > 0)
            {
                printf(" + ");
            }

            else if (tmp -> next -> monome.coeff.reelle < 0 && tmp -> next -> monome.coeff.imaginr != 0)
            {
                printf(" + ");
            }

            else
            {
                printf(" ");
            }
        }

       tmp = tmp -> next;
    }
}
complexe polynome_eval(polynome* poly)
{
    complexe resultat;
    resultat.reelle = 0;
    resultat.imaginr = 0;

    int puissance;
    int verif;
    complexe tmp;

    complexe valeur;

    valeur.reelle = 0;
    valeur.imaginr = 0;

    printf("En quelle valeur (complexe) voulez-vous évaluer le polynome ? \n");

    do
    {
        printf("Partie reelle (virgule = .) \n");
        printf("eval.re = ");
        verif = scanf("%lf", &valeur.reelle);
        scanf ("%*[^\n]");
        getchar ();
        printf("\n");
    }
    while (verif != 1);

    do
    {
        printf("Partie imaginaire (virgule = .) \n");
        printf("eval.img = ");
        verif = scanf("%lf", &valeur.imaginr);
        scanf ("%*[^\n]");
        getchar ();
        printf("\n");
    }
    while (verif != 1);


    while (poly -> forme_dev != NULL)
    {

        if (valeur.reelle == 0)
        {
            tmp.reelle = 0;
            tmp.imaginr = 1;
        }

        else if (valeur.imaginr == 0)
        {
            tmp.imaginr = 0;
            tmp.reelle = 1;
        }

        else
        {
            tmp.reelle = 1;
            tmp.imaginr = 0;
        }


        puissance = poly -> forme_dev -> monome.degre;

        while (puissance > 0)
        {
            tmp = complexe_multiplication(tmp, valeur);
            puissance = puissance - 1;
        }

        resultat.reelle = resultat.reelle + (poly -> forme_dev -> monome.coeff.reelle*tmp.reelle) - (poly->forme_dev -> monome.coeff.imaginr*tmp.imaginr);
        resultat.imaginr = resultat.imaginr + (poly -> forme_dev -> monome.coeff.reelle * tmp.imaginr) + (poly->forme_dev -> monome.coeff.imaginr * tmp.reelle);

        poly -> forme_dev = poly -> forme_dev -> next;
    }

    return resultat;
}

polynome* polynome_division_euclidienne(polynome* poly1, polynome* poly2, polynome** poly_dividende_2)
{
    polynome* poly_dividende;
    poly_dividende = polynome_creer();

    polynome* poly_dividende_stock;
    poly_dividende_stock = polynome_creer();

    polynome* poly_reste;
    poly_reste = polynome_creer();

    poly_dev* poly_stock;

    int degre;
    complexe coeff;

    printf("NE MARCHE QUE POUR LES POLYNOMES A COEFFICIENTS REELS \n");

    poly1 = polynome_partie_reelle(poly1);
    poly2 = polynome_partie_reelle(poly2);


    if (poly_dividende == NULL || poly_dividende_stock == NULL || poly2 -> forme_dev == NULL || poly_reste == NULL)
    {
        printf("C'est ta gueule que je vais diviser.");
        return poly_reste;
    }

    if (poly1 -> forme_dev -> monome.degre < poly2 -> forme_dev -> monome.degre)
    {
        return poly1;
    }

    while (poly1 -> forme_dev -> monome.degre >= poly2 -> forme_dev -> monome.degre)
    {
        coeff.reelle = poly1 -> forme_dev -> monome.coeff.reelle / poly2 -> forme_dev -> monome.coeff.reelle;
        coeff.imaginr = 0;

        degre = poly1 -> forme_dev -> monome.degre - poly2 -> forme_dev -> monome.degre;

        poly_stock = liste_creer_monome(degre, coeff);

        poly_dividende_stock -> forme_dev = liste_ajout_tete(poly_stock, poly_dividende_stock -> forme_dev);

        *poly_dividende_2 = poly_dividende_stock;

        poly_dividende = polynome_multiplication(poly2, poly_dividende_stock);

        poly_reste = polynome_addition_soustraction(poly1, poly_dividende, 2);

        poly1 = poly_reste;

        if (poly_reste -> forme_dev == NULL)
        {
            return poly_reste;
        }

        free(poly_dividende_stock);
        poly_dividende_stock = polynome_creer();
    }

    return poly1;
}

polynome* polynome_PGCD(polynome* poly1, polynome* poly2)
{
    polynome* poly_dividende;
    poly_dividende = polynome_creer();

    polynome* poly_dividende_stock;
    poly_dividende_stock = polynome_creer();

    polynome* poly_reste;
    poly_reste = polynome_creer();

    polynome* poly_reste_1;
    poly_reste_1 = polynome_creer();

    poly_dev* poly_stock;

    int degre;
    complexe coeff;
    coeff.imaginr = 0;

    if (poly_dividende == NULL || poly_dividende_stock == NULL || poly2 -> forme_dev == NULL || poly_reste == NULL)
    {
        printf("C'est ta gueule que je vais diviser.");
        return poly_reste;
    }

    do
    {
        poly_reste = polynome_division_euclidienne(poly1, poly2, &poly_dividende);

        if (poly_reste -> forme_dev != NULL)
        {
            poly_reste_1 = poly_reste;
        }

        poly1 = poly2;

        poly2 = poly_reste;
    }
    while (poly2 -> forme_dev != NULL);

    return poly_reste_1;
}

polynome* polynome_saisir(polynome* poly1)
{
    complexe coeff;

    int continuer;
    int degre;
    int verif;

    poly_dev* nouveau;

    printf("Rentrez le coefficient du monome \n");
    do
    {
        do
        {
            printf("Partie reelle (virgule = .) \n");
            printf("coeff.re = ");
            verif = scanf("%lf", &coeff.reelle);
            scanf ("%*[^\n]");
            getchar ();
            printf("\n");
        }
        while (verif != 1);

        do
        {
            printf("Partie imaginaire (virgule = .) \n");
            printf("coeff.img = ");
            verif = scanf("%lf", &coeff.imaginr);
            scanf ("%*[^\n]");
            getchar ();
            printf("\n");
        }
        while (verif != 1);
    }
    while (coeff.reelle == 0 && coeff.imaginr == 0);

    do
    {
        printf("Rentrez le degre du monome \n");
        printf("degre = ");
        verif = scanf("%d", &degre);
        scanf ("%*[^\n]");
        getchar ();
        printf("\n");
    }
    while (verif != 1 || degre < 0);

    nouveau = liste_creer_monome(degre, coeff);

    poly1 -> forme_dev = liste_ajout_tete(nouveau, poly1->forme_dev);

    do
    {
        printf("Voulez-vous continuer ? (1 : o / 2 : n) \n");
        printf("Continuer = ");
        verif = scanf("%d", &continuer);
        scanf ("%*[^\n]");
        getchar ();
        printf("\n");
    }
    while (verif != 1 || continuer < 1 || continuer > 2);

    while (continuer == 1)
    {
        printf("Rentrez le coefficient du monome \n");
        do
        {
            do
            {
                printf("Partie reelle (virgule = .) \n");
                printf("coeff.re = ");
                verif = scanf("%lf", &coeff.reelle);
                scanf ("%*[^\n]");
                getchar ();
                printf("\n");
            }
            while (verif != 1);

            do
            {
                printf("Partie imaginaire (virgule = .) \n");
                printf("coeff.img = ");
                verif = scanf("%lf", &coeff.imaginr);
                scanf ("%*[^\n]");
                getchar ();
                printf("\n");
            }
            while (verif != 1);
        }
        while (coeff.reelle == 0 && coeff.imaginr == 0);


        do
        {
            printf("Rentrez le degre du monome (superieur au degre precedent) \n");
            printf("degre = ");
            verif = scanf("%d", &degre);
            scanf ("%*[^\n]");
            getchar ();
            printf("\n");
        }
        while ((verif != 1) || (degre <= poly1 -> forme_dev -> monome.degre));

        nouveau = liste_creer_monome(degre, coeff);

        poly1 -> forme_dev = liste_ajout_tete(nouveau, poly1->forme_dev);

        do
        {
            printf("Voulez-vous continuer ? (1 : o / 2 : n) \n");
            printf("Continuer = ");
            verif = scanf("%d", &continuer);
            scanf ("%*[^\n]");
            getchar ();
            printf("\n");
        }
        while (verif != 1 || continuer < 1 || continuer > 2);
    }

    printf("\n \n");
    polynome_afficher(poly1);
    printf("\n \n");

    return poly1;
}

void Menu (polynome* poly1, polynome* poly2)
{
    system("cls");

    int verif;

    int choix;

    int ordre;
    int ordre2;

    complexe resultat;
    resultat.reelle = 0;
    resultat.imaginr = 0;

    polynome* poly_r;
    poly_r = polynome_creer();

    polynome* poly_dividende;
    poly_dividende = polynome_creer();

    poly_dev* a_supprimer;


   do
   {

        printf("polynome 1 : ");

        polynome_afficher(poly1);

        printf("\n");

        printf("polynome 2 : ");

        polynome_afficher(poly2);

        printf("\n");

        printf("polynome resultat : ");

        polynome_afficher(poly_r);

        printf("\n");
        printf("\n");
        printf("\n");

        printf("Que voulez-vous faire ?");

        printf("\n");

        printf("    Additionner (1) ");

        printf("\n");

        printf("    Soustraire (2) ");

        printf("\n");

        printf("    Multiplier (3) ");

        printf("\n");

        printf("    Deriver (4) ");

        printf("\n");

        printf("    Integrer (5) ");

        printf("\n");

        printf("    Comparer (6) ");

        printf("\n");

        printf("    Extraire la partie reelle (7) ");

        printf("\n");

        printf("    Extraire la partie imaginaire (8) ");

        printf("\n");

        printf("    Evaluer (9) ");

        printf("\n");

        printf("    Faire la division euclidienne (10) ");

        printf("\n");

        printf("    Calculer le PGCD (11) ");

        printf("\n");

        printf("    Quitter (12) ");

        do
        {
            printf("\n");

            printf("    Que voulez-vous faire : ");

            verif = scanf("%d", &choix);
            scanf ("%*[^\n]");
            getchar ();
            printf("\n");
        }
        while (verif != 1 || choix < 1 || choix > 13);

        if (choix == 1)
        {
            printf("Quel polynome doit-etre additionne a l'autre ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                printf("Quel polynome doit-on lui additionne ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 3 || ordre2 == ordre);

                if ((ordre == 1 && ordre2 == 2) || (ordre == 2 && ordre2 == 1))
                {
                    poly_r = polynome_addition_soustraction(poly1, poly2, 1);
                }

                else if ((ordre == 1 && ordre2 == 3) || (ordre == 3 && ordre2 == 1))
                {
                    poly_r = polynome_addition_soustraction(poly1, poly_r, 1);
                }

                else if ((ordre == 2 && ordre2 == 3) || (ordre == 3 && ordre2 == 2))
                {
                    poly_r = polynome_addition_soustraction(poly2, poly_r, 1);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                printf("Quel polynome doit-on lui additionne ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 2 || ordre2 == ordre);

                if ((ordre == 1 && ordre2 == 2) || (ordre == 2 && ordre2 == 1))
                {
                    poly_r = polynome_addition_soustraction(poly1, poly2, 1);
                }
            }
        }

        else if (choix == 2)
        {
            printf("Quel polynome doit-etre soustrait a l'autre ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                printf("Quel polynome doit-on lui soustraire ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 3 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_addition_soustraction(poly1, poly2, 2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_addition_soustraction(poly2, poly1, 2);
                }

                else if (ordre == 1 && ordre2 == 3)
                {
                    poly_r = polynome_addition_soustraction(poly1, poly_r, 2);
                }

                else if  (ordre == 3 && ordre2 == 1)
                {
                    poly_r = polynome_addition_soustraction(poly_r, poly1, 2);
                }

                else if (ordre == 2 && ordre2 == 3)
                {
                    poly_r = polynome_addition_soustraction(poly2, poly_r, 2);
                }

                else if (ordre == 3 && ordre2 == 2)
                {
                    poly_r = polynome_addition_soustraction(poly_r, poly2, 2);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                printf("Quel polynome doit-on lui soustraire ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 2 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_addition_soustraction(poly1, poly2, 2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_addition_soustraction(poly2, poly1, 2);
                }
            }
        }

        else if (choix == 3)
        {
            printf("Quel polynome doit-etre multiplier par l'autre ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                printf("Par quel polynome doit-on le multiplier ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 3 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_multiplication(poly1, poly2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_multiplication(poly2, poly1);
                }

                else if (ordre == 1 && ordre2 == 3)
                {
                    poly_r = polynome_multiplication(poly1, poly_r);
                }

                else if  (ordre == 3 && ordre2 == 1)
                {
                    poly_r = polynome_multiplication(poly_r, poly1);
                }

                else if (ordre == 2 && ordre2 == 3)
                {
                    poly_r = polynome_multiplication(poly2, poly_r);
                }

                else if (ordre == 3 && ordre2 == 2)
                {
                    poly_r = polynome_multiplication(poly_r, poly2);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                printf("Par quel polynome doit-on le multiplier ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 2 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_multiplication(poly1, poly2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_multiplication(poly2, poly1);
                }
            }
        }

        else if (choix == 4)
        {
            printf("Quel polynome doit-etre derive ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                if (ordre == 1)
                {
                    poly_r = polynome_derivation(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_derivation(poly2);
                }

                else if  (ordre == 3)
                {
                    poly_r = polynome_derivation(poly_r);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                if (ordre == 1)
                {
                    poly_r = polynome_derivation(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_derivation(poly2);
                }
            }
        }

        else if (choix == 5)
        {
            printf("Quel polynome doit-etre integre ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                if (ordre == 1)
                {
                    poly_r = polynome_integration(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_integration(poly2);
                }

                else if  (ordre == 3)
                {
                    poly_r = polynome_integration(poly_r);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                if (ordre == 1)
                {
                    poly_r = polynome_integration(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_integration(poly2);
                }
            }
        }

        else if (choix == 6)
        {
            printf("Quel polynome doit-on comparer ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                printf("A quel polynome doit-on le comparer ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 3 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                   polynome_comparaison(poly1, poly2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    polynome_comparaison(poly2, poly1);
                }

                else if (ordre == 1 && ordre2 == 3)
                {
                    polynome_comparaison(poly1, poly_r);
                }

                else if  (ordre == 3 && ordre2 == 1)
                {
                    polynome_comparaison(poly_r, poly1);
                }

                else if (ordre == 2 && ordre2 == 3)
                {
                    polynome_comparaison(poly2, poly_r);
                }

                else if (ordre == 3 && ordre2 == 2)
                {
                    polynome_comparaison(poly_r, poly2);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                printf("A quel polynome doit-on le comparer ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 2 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    polynome_comparaison(poly1, poly2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    polynome_comparaison(poly2, poly1);
                }
            }

            system("pause");
        }

        else if (choix == 7)
        {
            printf("De quel polynome doit-on extraire la partie reelle ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                if (ordre == 1)
                {
                    poly_r = polynome_partie_reelle(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_partie_reelle(poly2);
                }

                else if  (ordre == 3)
                {
                    poly_r = polynome_partie_reelle(poly_r);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                if (ordre == 1)
                {
                    poly_r = polynome_partie_reelle(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_partie_reelle(poly2);
                }
            }
        }

        else if (choix == 8)
        {
            printf("De quel polynome doit-on extraire la partie imaginaire ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                if (ordre == 1)
                {
                    poly_r = polynome_partie_imaginr(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_partie_imaginr(poly2);
                }

                else if  (ordre == 3)
                {
                    poly_r = polynome_partie_imaginr(poly_r);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                if (ordre == 1)
                {
                    poly_r = polynome_partie_imaginr(poly1);
                }

                else if (ordre == 2)
                {
                    poly_r = polynome_partie_imaginr(poly2);
                }
            }
        }

        else if (choix == 9)
        {
            printf("Quel polynome doit-etre evalue ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                if (ordre == 1)
                {
                    resultat = polynome_eval(poly1);
                }

                else if (ordre == 2)
                {
                    resultat = polynome_eval(poly2);
                }

                else if  (ordre == 3)
                {
                    resultat = polynome_eval(poly_r);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                if (ordre == 1)
                {
                    resultat = polynome_eval(poly1);
                }

                else if (ordre == 2)
                {
                    resultat = polynome_eval(poly2);
                }

            }

            if (resultat.reelle != 0)
            {
                printf("%lf ", resultat.reelle);
            }

            if (resultat.imaginr > 0)
            {
                if (resultat.imaginr != 0)
                {
                    printf("+ ");

                    if (resultat.imaginr == 1)
                    {
                        printf("i \n \n");
                    }

                    else
                    {
                        printf("%lfi \n \n", resultat.imaginr);
                    }
                }
            }

            else if (resultat.imaginr < 0)
            {
                if (resultat.imaginr == -1)
                {
                    printf("-i \n \n");
                }

                else
                {
                    printf("%lfi \n \n", resultat.imaginr);
                }
            }

            if (resultat.imaginr == 0)
            {
                printf("\n \n");
            }

            system("pause");

        }

        else if (choix == 10)
        {
            printf("Quel polynome doit-etre divise par l'autre ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                printf("Par quel polynome doit-on le diviser ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 3 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_division_euclidienne(poly1, poly2, &poly_dividende);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_division_euclidienne(poly2, poly1, &poly_dividende);
                }

                else if (ordre == 1 && ordre2 == 3)
                {
                    poly_r = polynome_division_euclidienne(poly1, poly_r, &poly_dividende);
                }

                else if  (ordre == 3 && ordre2 == 1)
                {
                    poly_r = polynome_division_euclidienne(poly_r, poly1, &poly_dividende);
                }

                else if (ordre == 2 && ordre2 == 3)
                {
                    poly_r = polynome_division_euclidienne(poly2, poly_r, &poly_dividende);
                }

                else if (ordre == 3 && ordre2 == 2)
                {
                    poly_r = polynome_division_euclidienne(poly_r, poly2, &poly_dividende);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                printf("Par quel polynome doit-on le diviser ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 2 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_division_euclidienne(poly1, poly2, &poly_dividende);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_division_euclidienne(poly2, poly1, &poly_dividende);
                }
            }
        }

        else if (choix == 11)
        {
            printf("De quel polynome voulez-vous le PGCD ? \n");

            if (poly_r -> forme_dev != NULL)
            {
                printf("Polynome 1 (1), Polynome 2 (2) ou Polynome resultat (3) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 3);

                printf("Par rapport a quel polynome ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 3 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_PGCD(poly1, poly2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_PGCD(poly2, poly1);
                }

                else if (ordre == 1 && ordre2 == 3)
                {
                    poly_r = polynome_PGCD(poly1, poly_r);
                }

                else if  (ordre == 3 && ordre2 == 1)
                {
                    poly_r = polynome_PGCD(poly_r, poly1);
                }

                else if (ordre == 2 && ordre2 == 3)
                {
                    poly_r = polynome_PGCD(poly2, poly_r);
                }

                else if (ordre == 3 && ordre2 == 2)
                {
                    poly_r = polynome_PGCD(poly_r, poly2);
                }

            }

            else
            {
                printf("Polynome 1 (1) ou Polynome 2 (2) ?\n");

                do
                {
                    printf("Choix 1 : ");
                    verif = scanf("%d", &ordre);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre < 1 || ordre > 2);

                printf("Par quel polynome doit-on le diviser ? \n");

                do
                {
                    printf("Choix 2 : ");
                    verif = scanf("%d", &ordre2);
                    scanf ("%*[^\n]");
                    getchar ();
                    printf("\n");
                }
                while (verif != 1 || ordre2 < 1 || ordre2 > 2 || ordre2 == ordre);

                if (ordre == 1 && ordre2 == 2)
                {
                    poly_r = polynome_PGCD(poly1, poly2);
                }

                else if (ordre == 2 && ordre2 == 1)
                {
                    poly_r = polynome_PGCD(poly2, poly1);
                }
            }
        }

        if (choix == 6 || choix == 9)
        {
            choix = 12;
        }
    }

    while (choix != 12);

    system("cls");

    if (poly1 -> forme_dev != NULL)
    {
        while (poly1 -> forme_dev -> next != NULL)
        {
            a_supprimer = poly1 -> forme_dev;
            poly1 -> forme_dev = poly1 -> forme_dev -> next;
            free(a_supprimer);
        }
    }

    if (poly2 -> forme_dev != NULL)
    {
        while (poly2 -> forme_dev -> next != NULL)
        {
            a_supprimer = poly2 -> forme_dev;
            poly2 -> forme_dev = poly2 -> forme_dev -> next;
            free(a_supprimer);
        }
    }


    if (poly_r -> forme_dev != NULL)
    {
        while (poly_r -> forme_dev -> next != NULL)
        {
            a_supprimer = poly_r -> forme_dev;
            poly_r -> forme_dev = poly_r -> forme_dev -> next;
            free(a_supprimer);
        }
    }
}