Structure et pow

Bonjour,

Je viens de finir mon programme et au moment fatidique de la compilation j'ai évidemment eu droit à des erreurs, dont 3 qui me causent quelques soucis.

Les erreurs :
In function 'eval_pol':|
157|error: incompatible types in assignment|
In function 'prim':|
386|error: incompatible types in assignment|
392|error: invalid operands to binary -|
||=== Build finished: 3 errors, 0 warnings ===|

Le fichier.c:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "main.h"

int main(void)
{
    int choix1, choix2;

 do
 {
     affiche_menu('g');
     scanf("%d",&choix1);
     switch(choix1)
 {
     case 1:
     saisie_pol();
     break;

     case 2:
     affiche_menu('o');
     scanf("%d",&choix2);
     switch(choix1)
     {
         case 1:
         eval_pol();
         break;
         case 2:
         add_pol();
         break;
         case 3:
         sous_pol();
         break;
         case 4:
         deriv();
         break;
         case 5:
         prim();
         break;
         case 6:
         prod();
         break;
         case 7:
         liste_poly();
         break;
         case 0:
         return 0;
         break;
         default :
         continue;
         break;
     }
     default:
     continue;
     break;
 }
 }
 while(1);
 return 0;
}



void saisie_pol()//fonction permettant la saisie du polynome
{
    Polynome pol_temp;
    char chaine[TAILLE_MAX]={0};
    int i = 0, j, cas ;
    scanf("%s",chaine);
    for (j=0; chaine[i]!='\0'; j++)
    {
        cas = 0;
        if (chaine[i]=='-')
        pol_temp.monome[j].num *= -1;
        for (; chaine[i]!='+' && chaine[i]!='\0' && chaine[i]!='-'; i++)
        {
            if (chaine[i]=='x')
            {
                continue;
            }
            if (chaine[i]=='/')
            {
                cas=1;
                continue;
            }
            if (chaine[i]=='^')
            {
                cas=2;
                continue;
            }
            if (cas==0) //pour gérer num, den et degre
            {
                pol_temp.monome[j].num = atoi(&chaine[i]) +pol_temp.monome[j].num*10;
            }
            else if (cas==1)
                pol_temp.monome[j].den = atoi(&chaine[i])+pol_temp.monome[j].den*10;
            else if (cas==2)
                pol_temp.monome[j].degre = atoi(&chaine[i])+pol_temp.monome[j].degre*10;
            if (pol_temp.monome[j].num == 0 )
                pol_temp.monome[j].num = 1;
            if (pol_temp.monome[j].den == 0 )
                pol_temp.monome[j].den = 1;
            }
        }
        pol_temp.nbmo=j+1;
        save_pol(pol_temp);
}

void affiche_poly(Polynome polynome)// permet d'afficher un polynome
{
    int j;
    if(polynome.monome[j].den!=1 && polynome.monome[j].degre ==0)
    printf("%d/%d",polynome.monome[j].num, polynome.monome[j].den);
    else if(polynome.monome[j].den==1 && polynome.monome[j].degre!=0)
    printf("%dx^%d",polynome.monome[j].num, polynome.monome[j].degre);
    else if(polynome.monome[j].den==1 && polynome.monome[j].degre==0)
    printf("%d",polynome.monome[j].num);
    else if(polynome.monome[j].num==1 && polynome.monome[j].den==1)
    printf("x^%d",polynome.monome[j].degre);
    else
    {
    printf("%d/%dx^%d",polynome.monome[j].num, polynome.monome[j].den, polynome.monome[j].degre);
    }
    printf("\n");
}

void affiche_menu(char mode)// permet d'afficher le menu
{
    if(mode == 'g')
    {
    printf("\n\n*** MENU PRINCIPAL ***\n");
    printf("1. Creer un polynome\n2. Effectuer une operation\n3.Afficher les polynômes");
    printf("\n4. Quitter\n");
    }
    else if(mode == 'o')
    {
        printf("\n\n*** MENU OPERATIONS ***\n");
        printf("1. Evaluer le polynome en un x donne\n2. Additionner deux polynomes\n");
        printf("3. Soustraire deux polynomes\n\t4. Deriver un polynome\n5. Primitive s'annulant en un point donne\n\t6. Multiplier deux polynomes");
        printf("\n7. Afficher les polynomes sauvegardes\n0. Quitter sans rien faire\n");
        printf("8.Revenir au menu precedant\n");
    }
}

void eval_pol()// permet de donné la valeur du polynome en fonction de x
{
    int j, x;
    int choix;
    Polynome poly_eval;
    Polynome *ppoly_eval = &poly_eval;
    printf("Polynome a evaluer :\n");
    load(ppoly_eval);
    printf("Quelle valeur affecter a x ?\n");
    scanf("%d", &x);
    for(j=0;j<poly_eval.nbmo;j++)
    {
    poly_eval = (poly_eval.monome[j].num / poly_eval.monome[j].den) * pow(x, poly_eval.monome[j].degre);
    }
    affiche_poly(poly_eval);
    do
    {
    printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n");
    scanf("%d", &choix);
    switch(choix)
    {
        case 1:
        save_pol(poly_eval);
        break;
        default:
        break;
    }
    }
    while(choix != 1 && choix != 2);
}

void liste_poly()
{
    printf("A :");
    affiche_poly(A);
    printf("\n");
    printf("B :");
    affiche_poly(B);
    printf("\n");
    printf("C :");
    affiche_poly(C);
    printf("\n");
    printf("D :");
    affiche_poly(D);
    printf("\n");
    printf("E :");
    affiche_poly(E);
    printf("\n");
    printf("F :");
    affiche_poly(F);
    printf("\n");
    printf("G :");
    affiche_poly(G);
    printf("\n");
    printf("H :");
    affiche_poly(H);
    printf("\n");
    printf("I :");
    affiche_poly(I);
    printf("\n");
    printf("J :");
    affiche_poly(J);
    printf("\n");
}

void save_pol(Polynome poly_save)// permet de sauvegarder un polynome
{
    char slot;
     do
     {
     printf("Dans quel slot voulez-vous sauvegarder ce polynome (A à J) ?");
     scanf("%c", &slot);
     switch(slot)
    {
        case 'A':
        A = poly_save;
        break;
        case 'B':
        B = poly_save;
        break;
        case 'C':
        C = poly_save;
        break;
        case 'D':
        D = poly_save;
        break;
        case 'E':
        E = poly_save;
        break;
        case 'F':
        F = poly_save;
        break;
        case 'H':
        H = poly_save;
        break;
        case 'I':
        I = poly_save;
        break;
        case 'J':
        J = poly_save;
        break;
        default:
        break;
    }
     }
     while(slot != 'A' && slot != 'B' && slot != 'C' && slot != 'D' && slot != 'E' && slot != 'F' && slot != 'G' && slot != 'H' && slot != 'I' && slot != 'J');
     }

void add_pol ()// permet d'additionner deux polynomes
{
    int i, j;
    int choix;
    Polynome poly_res, poly_add2;
    Polynome *ppoly_res = &poly_res;
    Polynome *ppoly_add2 = &poly_add2;
    printf("Premier polynome a additionner :\n");
    load(ppoly_res);
    printf("Second polynome a additionner :\n");
    load(ppoly_add2);
    for(i=0;i<poly_res.nbmo;i++)
    {
        for(j=0; j<poly_add2.nbmo;j++)
        {
            if(poly_res.monome[i].degre==poly_add2.monome[j].degre)
            {
                poly_res.monome[i].num=poly_res.monome[i].num + poly_add2.monome[j].num;
                poly_res.monome[i].den=poly_res.monome[i].den + poly_add2.monome[j].den;
            }
        }
    }
    affiche_poly(poly_res);
    do
    {
    printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n");
    scanf("%d", &choix);
    switch(choix)
    {
        case 1:
        save_pol(poly_res);
        break;
        default:
        break;
    }
    }
    while(choix != 1 && choix != 2);
}

void sous_pol()// permet de soustraire deux polynomes
{
    int i, j;
    int choix;
    Polynome poly_res, poly_sous2;
    Polynome *ppoly_res=&poly_res;
    Polynome *ppoly_sous2=&poly_sous2;
    printf("Soustraire le polyome :\n");
    load(ppoly_res);
    printf("Par le polynome :\n");
    load(ppoly_sous2);
    for(i=0;i<poly_res.nbmo;i++)
    {
        for(j=0; j<poly_sous2.nbmo;j++)
        {
            if(poly_res.monome[i].degre==poly_sous2.monome[j].degre)
            {
                poly_res.monome[i].num=poly_res.monome[i].num - poly_sous2.monome[j].num;
                poly_res.monome[i].den=poly_res.monome[i].den - poly_sous2.monome[j].den;
            }
        }
    }
    affiche_poly(poly_res);
    do
    {
    printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n");
    scanf("%d", &choix);
    switch(choix)
    {
        case 1:
        save_pol(poly_res);
        break;
        default:
        break;
    }
    }
    while(choix != 1 && choix != 2);
}

void deriv()// permet de deriver un polynome
{
    int j;
    int choix;
    Polynome poly_deriv;
    Polynome *ppoly_deriv = &poly_deriv;
    printf("Polynome a deriver :\n");
    load(ppoly_deriv);
    for(j=0;j<poly_deriv.nbmo;j++)
    {
    if(poly_deriv.monome[j].degre ==0)
    {
    poly_deriv.monome[j].num=0;
    poly_deriv.monome[j].den=0;
    }
    else
    {
    poly_deriv.monome[j].num=poly_deriv.monome[j].num*poly_deriv.monome[j].degre;
    poly_deriv.monome[j].degre=poly_deriv.monome[j].degre-1;
    }
    }
        do
    {
    printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n");
    scanf("%d", &choix);
    switch(choix)
    {
        case 1:
        save_pol(poly_deriv);
        break;
        default:
        break;
    }
    }
    while(choix != 1 && choix != 2);
}

void prim()// permet d'integrer
{
    Polynome poly_prim, poly_eval;
    Polynome *ppoly_prim = &poly_prim;
    int l, k, j, x;
    int choix;
    printf("Polynome a integrer :\n");
    load(ppoly_prim);
    if(poly_prim.monome[j].degre==0)
    poly_prim.monome[j].degre=1;
    else
    {
    poly_prim.monome[j].den=poly_prim.monome[j].den*(poly_prim.monome[j].degre+1);
    poly_prim.monome[j].degre=poly_prim.monome[j].degre+1;
    }
    printf("S'annule pour x = :\n");
    scanf("%d", &x);
    poly_eval = poly_prim;
    poly_eval=(poly_eval.monome[j].num/poly_eval.monome[j].den)*pow(x, poly_eval.monome[j].degre);
    for(j=0;j<poly_prim.nbmo;j++)
    {
    l = -(poly_eval.monome[j].num/poly_eval.monome[j].den);
    k=k + l;
    }
    poly_prim=poly_prim - k;
     do
    {
    printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n");
    scanf("%d", &choix);
    switch(choix)
    {
        case 1:
        save_pol(poly_prim);
        break;
        default:
        break;
    }
    }
    while(choix != 1 && choix != 2);
}

void prod()// permet de multiplier deux polynomes
{
    int i, j, k;
    int choix;
    Polynome poly_prod, poly_prod2, poly_res;
    Polynome *ppoly_prod=&poly_prod;
    Polynome *ppoly_prod2=&poly_prod2;
    printf("Multiplier le polynome :\n");
    load(ppoly_prod);
    printf("Par le polynome :\n");
    load(ppoly_prod2);
    for(i=0;i<poly_prod.nbmo;i++)
    {
        for(j=0;j<poly_prod2.nbmo;j++)
        {
            poly_res.monome[k].num=poly_prod.monome[i].num * poly_prod2.monome[j].num;
            poly_res.monome[k].den=poly_prod.monome[i].den * poly_prod2.monome[j].den;
            poly_res.monome[k].degre=poly_prod.monome[i].degre +poly_prod2.monome[j].degre;
            k++;
        }
    }
        affiche_poly(poly_res);
    do
    {
    printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n");
    scanf("%d", &choix);
    switch(choix)
    {
        case 1:
        save_pol(poly_res);
        break;
        default:
        break;
    }
    }
    while(choix != 1 && choix != 2);
}


void load(Polynome *load_pol)// permet de charger un polynome
{
    char slot;
    do
     {
     scanf("%c", &slot);
     switch(slot)
    {
        case 'A':
        *load_pol = A;
        break;
        case 'B':
        *load_pol = B;
        break;
        case 'C':
        *load_pol = C;
        break;
        case 'D':
        *load_pol = D;
        break;
        case 'E':
        *load_pol = E;
        break;
        case 'F':
        *load_pol = F;
        break;
        case 'G':
        *load_pol = G;
        break;
        case 'H':
        *load_pol = H;
        break;
        case 'I':
        *load_pol = I;
        break;
        case 'J':
        *load_pol = J;
        default:
        break;
    }
     }
        while(slot != 'A' && slot != 'B' && slot != 'C' && slot != 'D' && slot != 'E' && slot != 'F' && slot != 'G' && slot != 'H' && slot != 'I' && slot != 'J');
}

Le fichier.h:

/* Declaration des fonctions utilisées dans le fichier main.c ainsi que de la structure polynome et des variables globales */

#define MAX 50
#define TAILLE_MAX 5

typedef struct mon
{
int degre, num, den;
}Monome;

typedef struct poly
{
Monome monome[MAX];
int nbmo;
} Polynome;

extern Polynome A;
extern Polynome B;
extern Polynome C;
extern Polynome D;
extern Polynome E;
extern Polynome F;
extern Polynome G;
extern Polynome H;
extern Polynome I;
extern Polynome J;

void load(Polynome *load_pol);
void saisie_pol();
void affiche_poly(Polynome polynome);
void affiche_menu(char mode);
void eval_pol();
void save_pol(Polynome poly_save);
void add_pol ();
void sous_pol();
void deriv();
void prim();
void prod();
void liste_poly();

Pour la fonction pow je pense que le problème vient du fait qu'elle n'accepte pas les structures, et pour l'autre erreur qu'une structure moins un int ne passe pas non plus.
Mais à vrai dire je ne vois pas du tout comment m'en sortir.
I need your help :euh:

Au passage si quelqu'un saurait de quel manière je puisse réaliser une division euclidienne avec ce programme je suis preneur.

Merci d'avance.