{---------------------- POLYNOME.LIB ---------------------------------}

Un programme utilisant cette bibliothèque sur un compatible IBM PC doit
commencer par:

  {* utilise Math.Lib, Entrees.Lib, Polynome.Lib *}
  {$i Math.Lib}
  {$i Entrees.Lib}
  {$i Polynome.Lib}

Un  programme  utilisant  cette  bibliothèque  sur  un  Macintosh  doit
commencer par:

  {* utilise Math.Lib, Entrees.Lib, Polynome.Lib *}
  {$S+}
   uses
    {$S Mac}
        MemTypes, QuickDraw, OSIntf, ToolIntf, Sane,
    {$S Math}
        Math_Lib,
    {$S Entr}
        Entrees_Lib,
    {$S Pol}
        Polynome_Lib;
  {$S}

et dans les deux cas appeler la procédure InitMath.


{------- Définition des polynômes de degré n tel que 0<=n<=30 ---------}

  type
    Polynome = array [0..30] of real;
      { Un polynome de degré n (0<=n<=30) et de coefficients a0,...,an }
      { (tels que an<>0) est representé  par  un  tableau  P  de  type }
      { Polynome tel que:                                              }
      {  P[i]  = ai, i=0,...,n                                         }
      {  P[j]  = 0,  j=n+1,...,30                                      }
      { Tous  les  coefficients  Coef(P,0),  ..., Coef(P,DegMax)  d'un }
      { polynôme   P   doivent   être  initialisés  (par  exemple  par }
      { AffZero(P)), avant d'utiliser ce polynôme P.                   }
      
{--- Sélection  -------------------------------------------------------}

  function DegMax:integer;
    { Retourne le degré maximum des polynômes (30) }
  function Coef(P:Polynome; I:integer):real;
    { Retourne le Ième coefficient de P }
  function DegNul:integer;
    { Retourne le degré du polynôme nul (-maxint) }
  function Deg(P:Polynome):integer;
    { Retourne le degré de P (Deg(0) = DegNul) }
  function ValNul:integer;
    { Retourne la valuation du polynôme nul (maxint) }
  function Val(P:Polynome):integer;
    { Retourne la valuation de P (Val(0) = ValNul) }

{--- Construction ------------------------------------------------------}

  procedure AffCoef(var P:Polynome; I:integer; V:real);
    { Affecter V au Ième coefficient de P }
  procedure AffPol(var P:Polynome; Q:Polynome);
    { P:=Q }
  procedure AffZero(var P:Polynome);
    { P:=0 }
  
{--- Prédicats ---------------------------------------------------------}
  
  function PolNul(P:Polynome):boolean;
   { P=0? } 

{--- Entrée/Sortie -----------------------------------------------------}

  procedure EntrePol(var P:Polynome);
  procedure AffichePol(P:Polynome);
  procedure AffichePolLn(P:Polynome);
   
{--- Opérations --------------------------------------------------------}

  procedure MoinPol(A,B:Polynome; var R:Polynome);
   { R:=A-B }
  procedure PlusPol(A,B:Polynome; var R:Polynome);
   { R:=A+B }
  procedure MuMo(P:Polynome; C:real; N:integer; var R:Polynome);
    {                                      N }
    { Multiplication par un monôme: R:=P*Cx  }
  procedure MultPol(P,Q:Polynome; var R:Polynome);
    { R:=P.Q }
  procedure DiMo(P:Polynome; K:integer; var R:Polynome);
    {                              K                                }
    { Division par un monôme: P = x .R (en supposant que Val(P)>=K) }
  procedure DiviPol(A,B:Polynome; var Q,R:Polynome);
    { Calculer le quotient Q et le reste R de la division de A  par  B }
    { A = BQ + R et Deg(R)<Deg(B)                                      }
  procedure PGCDPol(A,B:Polynome; var R:Polynome);
    { R:=PGCD(A,B) calcule par l'algorithme  d'Euclide  des  divisions }
    { successives:                                                     }
    { A = B Q1 + R1, B = R1 Q2 + R2, Rp-1 = Rp Qp+1 + 0, le  PGCD  est }
    { le dernier reste non nul Rp.                                     }
  procedure DiviPuisCrois(A,B:Polynome; K:integer; var Q,R:Polynome);
    { Calculer le quotient Q et le reste R de la division de A  par  B }
    { selon les puissances croissantes à l'ordre K:                    }
    {          K                                                       }
    {   A=B.Q+x .R avec Deg(Q)<K                                       }

{--- Erreurs ----------------------------------------------------------}

  function ErreurPolynome:integer;
    { Retourne  un code différent de zéro si une erreur s'est produite }
    { lors d'un  calcul  sur  les  polynômes  (Coef:401,  AffCoef:402, }
    { EntrePol:403,   AffichePol:404,  AffichePolLn:405,  MoinPol:406, }
    { PlusPol:407,  MuMo:408,  MultPol:409,   DiMo:410,   DiviPol:411, }
    { PGCDPol:412, DiviPuisCrois:413).                                 }
{----------------------------------------------------------------------}