{-----------------------------------------------------------------------}
{------------------------- COMPLEXE.LIB --------------------------------}
{-----------------------------------------------------------------------}

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

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

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

  {* utilise Math.Lib,  Entrees.Lib, Complexe.Lib *}
  {$S+}
     uses
       {$S Mac}
          MemTypes,QuickDraw,OSIntf,ToolIntf,Sane,
       {$S Math}
          Math_Lib,
       {$S Entr}
          Entrees_Lib,
       {$S Comp}
          Complexe_Lib;
  {$S}

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

{--- Definition des complexes -------------------------------------------}
  const
    PartieReelle = 0;
    PartieImaginaire = 1;
    
  type
    Complexe = array[0..1] of real;
             { Si Z est de type Complexe alors Z[0] est la partie reelle }
             { de Z et Z[1] est la partie imaginaire de Z.               }
  
{--- Construction -------------------------------------------------------}

  procedure ComplexeRect(X,Y:real; var Z:Complexe);
   { Construction du complexe Z=X+iY donne par ses coordonnees }
   { rectangulaires X et Y.                                    }
  
  procedure RhoTheta(R,Theta:real; var Z:Complexe);
   { Construction du complexe Z =  R.cos(Theta)+iR.sin(Theta) donne par }
   { ses coordonnees polaires R et Theta. }
  
{--- Selection ---------------------------------------------------------}

  function PartReelle(Z:Complexe):real;
   { Retourne la partie reelle X du complexe Z=X+iY. }
  
  function PartImaginaire(Z:Complexe):real;
   { Retourne la partie imaginaire Y du complexe Z=X+iY. }
  
  function Module(Z:Complexe):real;
   { Retourne le module R du complexe Z=(R,Theta). }
  
  function Argument(Z:Complexe):real;
   { Retourne l'argument Theta du complexe Z=(R,Theta). }
  
{--- Predicats ----------------------------------------------------------}

  function EgalComplexe(Z1,Z2:Complexe):boolean;
    { Retourne true si Z1=Z2 et false si Z1<>Z2. } 

{--- Entrees/Sorties ----------------------------------------------------}

  procedure EntreComplexe(var Z:Complexe);
    { Lire Z en coordonnees rectangulaires. }

  procedure EcrisComplexe(Z:Complexe);
    { Ecrire Z en coordonnees rectangulaires. }

  procedure EcrisComplexeLn(Z:Complexe);
    { Ecrire Z en coordonnées rectangulaires puis passer à la ligne. }

  procedure EcrisRhoTheta(Z:Complexe);
    { Ecrire Z en coordonnées polaires. }

  procedure EcrisRhoThetaLn(Z:Complexe);
    { Ecrire Z en coordonnées polaires puis passer à la ligne. }

{--- Operations ---------------------------------------------------------}

  procedure ConjComplexe(Z1:Complexe; var Z:Complexe);
    { Conjugué, Z:=X-iY où Z1=X+iY. }

  procedure Conjugue(var Z:Complexe);
    { Conjugué z'':=X-iY où z'=X+iY et z', z'' sont les valeurs }
    { de Z avant et après l'appel de Conjugue.                  }
  
  procedure OppoComplexe(Z1:Complexe; var Z:Complexe);
    { Opposé, Z:=-Z1. }
  
  procedure SubComplexe(Z1,Z2:Complexe; var Z:Complexe);
    { Soustraction, Z:=Z1-Z2. }
  
  procedure AddComplexe(Z1,Z2:Complexe; var Z:Complexe);
    { Addition, Z:=Z1+Z2. }
  
  procedure ScalMult(X:real; Z1:Complexe; var Z:Complexe);
    { Produit par un reel, Z:=X.Z1. }
  
  procedure MultComplexe(Z1,Z2:Complexe; var Z:Complexe);
    { Produit, Z:=Z1xZ2. }
  
  procedure DivComplexe(Z1,Z2:Complexe; var Z:Complexe);
    {                 Z1   }
    { Division, Z := ____ .}
    {                 Z2   }
  
  procedure InverseComplexe(var Z:Complexe);
    {                  1                                      }
    { Inverse, z'' := ___  où z' et z'' sont les valeurs de Z }
    {                  z'  avant et après l'appel de Inverse. }
  
  procedure CarreComplexe(Z1:Complexe; var Z:Complexe);
    {             2  }
    { Carre, Z:=Z1 . }
  
  procedure PuissanceComplexe(Z1:Complexe; N:integer; var Z:Complexe);
    {                 N  }
    { Puissance, Z:=Z1 . }
    
  procedure RacineComplexe(Z1:Complexe; N:integer; var Z:Complexe);
    {                   n ____  }
    { Racine n-eme, Z:= \/ Z1 . }

  procedure RacCarreeComp(Z1:Complexe; var Z:Complexe);
    {                      ____  }
    { Racine carree, Z:= \/ Z1 . }

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

  function ErreurComplexe:integer;
    { Retourne  un entier différent de zéro si une erreur s'est produite }
    { lors   d'un   calcul   complexe (AddComplexe:300, SubComplexe:301, }
    { MultComplexe:302,   DivComplexe:305,   ScalMult:303,   Module:306, }
    { Argument:309,          InverseComplexe:306,          RhoTheta:310, }
    { PuissanceComplexe:311, RacineComplexe:312,      EcrisRhoTheta:314, }
    { EcrisRhoThetaLn:315,     CarreComplexe:316,      RacCarreeComp:317 }
    { EntreComplexe:307, EcrisComplexe:308, EcrisComplexeLn:313).        }
{------------------------------------------------------------------------}