#include <iostream.h>
#define MAXPOLY 20
class polynome 
 {
  int degre;
  float coef[MAXPOLY];
 public:
  int get_degre(void) {return degre;} 
  float get_coef(int i) {return coef[i];}
  void raz(void); //degréeacute; 0, coef 0
  void ajuste_degre(void); //si les premiers coef sont nuls, on peut diminuer le degréeacute;
  void saisie(void); 
  void affiche(ostream&);
  void copie(polynome);
  int egal(polynome);  //1 si degre et tous les coefficients sont éeacute;gaux
  float valeur(float x);
  void additionner(float);
  void additionner(polynome);
  void soustraire(float);
  void soustraire(polynome);
  void multiplier(float);
  void multiplier(polynome);
  void deriver(void);
  void integrer(float); //on peut donner la constante (0 par déeacute;f)
  float premiere_racine(float binf,float bsup,float precision); //cherche la 1èegrave;re racine
       // en commençccedil;ant àagrave; la borne inféeacute;rieure, en essayant pas àagrave; pas. S'il ne trouve 
       // pas, rend une valeur supéeacute;rieure àagrave; bsup. 
       // ATTENTION : essaye TOUTES les valeurs, choisissez une préeacute;cision pas trop faible
  float racine(float binf,float bsup,float precision); //cherche la racine entre la borne
          // inféeacute;rieure et supéeacute;rieure,. Il DOIT n'y en avoir qu'UNE dans l'intervale.
          // Optimiséeacute; (dichotomie), vous pouvez demander une bonne préeacute;cision.
}; 
 
/*déeacute;claration de fonctions relatives aux polynomes ******************************************/
ostream& operator << (ostream&, polynome&);
istream& operator >> (istream&, polynome&);
int operator == (polynome&,polynome&);
int operator != (polynome&,polynome&);
polynome operator + (polynome&,polynome&);
polynome operator + (polynome&,float);
polynome operator + (float,polynome&);
polynome operator - (polynome&,polynome&);
polynome operator - (polynome&,float);
polynome operator - (float,polynome&);
polynome operator * (polynome&,polynome&);
polynome operator * (polynome&,float);
polynome operator * (float,polynome&);
polynome operator / (polynome&,float);

/*déeacute;finition des méeacute;thodes des polynomes ******************************************/ 
void polynome::raz(void)
 {
  int i;
  for (i=0;i<MAXPOLY;i++) coef[i]=0;
  degre=0;
 }
void polynome::ajuste_degre(void)
 {
  if(degre>0)while(coef[degre]==0)degre--;
 }
void polynome::saisie(void) 
//ne fonctionne que sur cin/cout, contrairement au prochain
 {
  int i;
  cout<<"degréeacute; ?";
  cin>>degre;
  for(i=degre;i>=0;i--)
   {
    cout<<"coef d'ordre "<<i<<" ? ";
    cin>>coef[i];
   }
  ajuste_degre();
 } 

void polynome::affiche(ostream &flux) 
//flux est en argument car je veux pouvoir utiliser cout mais aussi tout fichier texte
 {
  int i,prem=1;
  for(i=degre;i>0;i--) if (coef[i])
   {
    if(!prem) flux<<"+"; else prem=0;
    if(coef[i]!=1)flux<<coef[i]; //inutile d'éeacute;crire '1x^i', 'x^i' suffit
    flux<<"x";
    if(i!=1)flux<<"^"<<i; //inutile d'éeacute;crire 'x^1', 'x' suffit
   }
  if(prem) flux<<coef[0]; //si c'est le premier (et donc seul) on le met
  else if(coef[i]) flux<<"+"<<coef[0]; //sinon on ne le met que s'il est non nul
 }
void polynome::copie(polynome p)
 {
  int i;
  degre=p.get_degre();;
  for (i=0;i<=degre;i++) coef[i]=p.get_coef(i);
 }
int polynome::egal(polynome p)
 {
  int i;
  ajuste_degre();
  p.ajuste_degre();
  if(degre!=p.get_degre())return 0;
  for(i=0; i<=degre;i++) if(coef[i]!=p.get_coef(i))return 0;
  return 1; //si on est arrivéeacute; jusqu'ici c'est qu'ils sont éeacute;gaux
 } 
float polynome::valeur(float x)
 {
  int i;
  float p=x,r=coef[0];
  for(i=1;i<=degre;i++)
   {
    r+=coef[i]*p;
    p*=x;
   }
  return r;
 } 
void polynome::additionner(float f)
 {
  coef[0]+=f;
 }
void polynome::additionner(polynome p)
 {
  int i,dp;
  if(p.get_degre()>degre)
   {
    for(i=p.get_degre();i>degre;i--)coef[i]=p.get_coef(i);//si P.degre est plus grand, on
        // copie les les coefs au dessus de this.degre. Rq: si plus petit, for ne fait rien
    dp=degre;
    degre=p.get_degre(); //il a grandi !
   }
  else dp=p.get_degre();
  for(i=dp;i>=0;i--)coef[i]+=p.get_coef(i);
  ajuste_degre();
 }
void polynome::soustraire(float f)
 {
  coef[0]-=f;
 }
void polynome::soustraire(polynome p) //surtout il faut le passer par valeur !
 {
  p.multiplier(-1);
  additionner(p);
 }


void polynome::multiplier(float f)
 {
  int i;
  for(i=0;i<=degre;i++)coef[i]*=f;
 }
void polynome::multiplier(polynome p)
 {
  int i,j,nd;
  polynome q;
  q.copie(*this);
  nd=q.get_degre()+p.get_degre();
  if(nd>MAXPOLY)cout<<"multiplication impossible\n";
  for(i=0;i<=nd;i++)coef[i]=0;
  for(i=0;i<=q.get_degre();i++)
   for(j=0;j<=p.get_degre();j++)
    coef[i+j]+=(q.get_coef(i)*p.get_coef(j));
  degre=nd;
 }
void polynome::deriver(void)
 {
  int i;
  for(i=0;i<degre;i++)
    coef[i]=(i+1)*coef[i+1];
  degre--;
 }
void polynome::integrer(float c=0)
 {
  int i;
  for(i=degre;i>=0;i--)
    coef[i+1]=coef[i]/(i+1);
  coef[0]=c;
  degre++;
 }
float polynome::premiere_racine(float binf,float bsup,float precision) 
 {
  float y0,x=binf;
  y0=valeur(x);
  do x+=precision; while ((y0*valeur(x)>0)&&(x<=bsup));
  return x;
 }
float polynome::racine(float binf,float bsup,float precision) 
 {
  float y0,x;
  y0=valeur(binf);
  do 
   {
    x=(binf+bsup)/2.0;
    if(y0*valeur(x)>0) binf=x; else bsup=x;
   }
  while ((bsup-binf)>precision);
  return x;
 }
 
/*implantation des fonctions spéeacute;cifiques aux polynomes **************************************/
ostream& operator << (ostream &flux, polynome &p)
//p par réeacute;féeacute;rence, mais ce n'est pas obligatoire, çccedil;a éeacute;vite une copie locale
 { 
  p.affiche(flux);
  return flux;
 }
istream& operator >> (istream &flux, polynome &p)
//p obligatoirement par réeacute;féeacute;rence car il sera modifiéeacute;
 { 
  if(flux==cin) p.saisie();
  else cout<<"implantation de << uniquement pour cin\n";
  return flux;
 }
int operator == (polynome &p1, polynome &p2)
 {return p1.egal(p2);}
int operator != (polynome &p1, polynome &p2)
 {return !(p1.egal(p2));}
polynome operator + (polynome &p,polynome &q)
 {
  polynome r;
  r.copie(p);
  r.additionner(q);
  return r;
 }
polynome operator + (polynome &p,float f)
 {
  polynome r;
  r.copie(p);
  r.additionner(f);
  return r;
 }
polynome operator + (float f,polynome &p)
 {return(p+f);}
polynome operator - (polynome &p,polynome &q)
 {
  polynome r;
  r.copie(p);
  r.soustraire(q);
  return r;
 }
polynome operator - (polynome &p,float f)
 {
  polynome r;
  r.copie(p);
  r.soustraire(f);
  return r;
 }
polynome operator - (float f,polynome &p)
 {return(p-f);}
polynome operator * (polynome &p,polynome &q)
 {
  polynome r;
  r.copie(p);
  r.multiplier(q);
  return r;
 }
polynome operator * (polynome &p,float f)
 {
  polynome r;
  r.copie(p);
  r.multiplier(f);
  return r;
 }
polynome operator * (float f,polynome &p)
 {return(p*f);}
polynome operator / (polynome &p,float f)
 {return(p*(1/f));}
 

//main
int main(void)
 {
  polynome p1,p2,p3;
  p1.saisie();
  p2.raz();
  p1.affiche(cout);
  cout<<"\n";
  cout<<"entrez un second polynôocirc;me :\n";
  cin>>p2;
  cout<<"le polynome vaut "<<p2<<"\n";
  if(p1==p2)cout<<"ils sont éeacute;gaux\n";
  cout<<p1<<" plus deux fois "<<p2;
  p3=p1+(2*p2);
  cout<<" fait "<<p3<<"\n";
  p3.deriver();
  cout<<"déeacute;rivéeacute;e : "<<p3<<"\n";
  p3.integrer();
  cout<<"intéeacute;grale : "<<p3<<"\n";
 }