{--------------------------------------------------------------}
{----------------------- MATH.LIB -----------------------------}
{--------------------------------------------------------------}

(* Un  programme  utilisant  cette bibliothèque sur compatible
   IBM PC doit commencer par:                                         
     {* utilise Math.Lib *}
     {$i Math.Lib}
       
   Un programme utilisant  cette  bibliothèque  sur  Macintosh
   doit commencer par:
     
     {$S+}
     uses {$S Mac} Sane, {$S Math} Math_Lib;
     {$S}
*)

{--------------------------------------------------------------}
{--- Utilisation de premier niveau ----------------------------}
{--------------------------------------------------------------}
{      Constantes et fonctions mathématiques usuelles          }
{--------------------------------------------------------------}

{ Initialisation (doit être appelée une seule fois au début du }
{ corps du programme): }
    procedure InitMath;
  
{ Constantes mathématiques usuelles: }
    function MaxReal:real;
      { Plus grand réel représentable en machine }
    function MinReal:real;
      { Plus petit réel strictement positif  représentable  en }
      { machine }
    function e:real; { Constante e }
    function pi:real; { Constante pi }
  
{ Fonctions mathématiques usuelles: }
    function AddReal(X,Y:real):real; { Addition, (X+Y) }
    function SubReal(X,Y:real):real; { Soustraction, (X-Y) }
    function MultReal(X,Y:real):real; { Produit, (X*Y) }
    function DivReal(X,Y:real):real; { Division,(X/Y) }
    function PuissReal(X,Y:real):real; { Puissance, (X^Y) }

    function Cos(X:real):real; {  Cosinus de X (en radians) }
    function Sin(X:real):real; { Sinus de X (en radians) }
    function Tg(X:real):real; { Tangente de X (en radians) }
    
    function ACos(X:real):real; { Arc cosinus (en radians) }
    function ASin(X:real):real; { Arc sinus (en radians) }
    function ATg(X:real):real; { Arc tangente (en radians) }
    
    function Ch(X:real):real; { Cosinus hyperbolique }
    function Sh(X:real):real; { Sinus hyperbolique }
    function Th(X:real):real; { Tangente hyperbolique }
  
    function ACh(X:real):real; { Argument cosinus hyperbolique }
    function ASh(X:real):real; { Argument sinus hyperbolique }
    function ATh(X:real):real; { Argument tangente hyperboli. }
    
    function Exp(X:real):real; { Exponentielle }
    function Ln(X:real):real; { Logarithme népérien  }
    function Sqr(X:real):real; { Carré }
    function Sqrt(X:real):real; { Racine carrée }
    function Abs(X:real):real;  { Valeur absolue }
    function Int(X:real):real;  { Partie entière }
    function Frac(X:real):real; { Partie fractionnaire }
        
        
{--------------------------------------------------------------}
{--- Utilisation de deuxième niveau ---------------------------}
{--------------------------------------------------------------}
{      Traitement des erreurs de Math.Lib                      }
{--------------------------------------------------------------}

{ Par défaut, une erreur de débordement arithmétique dans  une }
{ fonction  de la bibliothèque produit un message et conduit à }
{ l'arrêt de l'exécution  du  programme.  Après  appel  de  la }
{ procédure   'ArreterSiErreur(false)',    les    erreurs   ne }
{ conduiront plus à l'arrêt de l'exécution du programme. Elles }
{ seront signalées par positionneront d'un indicateur d'erreur }
{ qui a la valeur nulle si aucune erreur ne s'est produite  et }
{ une  valeur  non  nulle  après  une  erreur  de  débordement }
{ arithmétique réel:                                           }
{   AddReal:1,SubReal:1, MultReal:2, DivReal:3, Sqr:4, Sqrt:5, }
{ Ln:6, Exp:7, Ach:8, Acos:9, Asin:10, Ath:11,  Ch:12,  Sh:13, }
{ Tg:14, PuissReal:15.                                         }
{ Si plusieurs erreurs successives se produisent  l'indicateur }
{ d'erreur  contient  le code  désignant  la première d'entre- }
{ elles. La valeur de l'indicateur d'erreur est retournée puis }
{ remise à zéro par la fonction 'ErreurMath'.                  }
  
{ Pour  éviter  l'arrêt  de  l'exécution  du  programme en cas }
{ d'erreur (B=false) ou pour forcer l'arrêt de l'exécution  du }
{ programme en cas d'erreur, (B=true, option par défaut): }
    procedure ArreterSiErreur(B:boolean);
  
{ Retourner la valeur de l'indicateur d'erreur et le  remettre }
{ au  code  zéro (en retournant zéro sans changer sa valeur si }
{ la dernière erreur ne s'est pas produite dans Math.Lib):     }
    function ErreurMath:integer;
        
{--------------------------------------------------------------}
{--- Utilisation de troisième niveau --------------------------}
{--------------------------------------------------------------}
{      Traitement des erreurs dans les modules du programme    }
{      principal                                               }
{--------------------------------------------------------------}

{ Ce  mode  de  traitement  des  erreurs  peut être étendu aux }
{ modules du programme principal. Par convention  on  choisira }
{ des  codes  d'erreur  négatifs  pour éviter de les confondre }
{ avec ceux des bibliothèques. Une erreur peut être traitée de }
{ trois façons différentes:                                                     }
  
{ 1. Arrêt de  l'exécution  du  programme  (en  produisant  un }
{ message:                                                     }
{  Erreur fatale:M.   (où M est une chaîne de caractères)      }
    procedure Erreur(M:string);

{ 2. Si  l'indicateur  d'erreur  est  nul  (aucune  erreur  ne }
{ s'étant  produite  depuis  l'appel de 'IniMath' ou depuis le }
{ dernier test de  l'indicateur  d'erreur)  alors  positionner }
{ l'indicateur  d'erreur  au code E donné (sans jamais arrêter }
{ l'exécution du programme): }
    procedure ForceErreur(E:integer);
  
{ Retourner la valeur de l'indicateur d'erreur et le  remettre }
{ au code zéro (quel que soit la valeur du code d'erreur):     }
    function CodeErreur:integer;
 
{ 3. Mettre l'indicateur d'erreur à une valeur E donnée  (s'il }
{ n'y a pas d'arrêt en cas d'erreur) ou  (option  par  défaut) }
{ arrêter l'exécution du programme en produisant un message:   }
{  Erreur fatale:M.   (où M est une chaîne de caractères)     }
    procedure SignalerErreur(E:integer; M:string);
 
{--------------------------------------------------------------}
{  Traitement des erreurs dans les modules de bibliothéques    }
{--------------------------------------------------------------}
  
{--- Erreurs transmises à l'utilisateur -----------------------}
{ Commencer le corps  du  module ppppp  où  les  erreurs  sont }
{ repérées par le code nn par:                                 }
{   DebutModule(nn,'ppppp');                                   }
{ et terminer le corps de ce module par:                       }
{   FinModule;                                                 }
    procedure DebutModule(E:integer; M:string);
    procedure FinModule;
{ Quand une erreur est détectée, appeler:                      }
{   SignalerErreur(nn,'mmmmm');                                }
{ où 'mmmmm' est une chaîne de caractères décrivant l'erreur.  }
{ Ecrire une fonction ErreurBbbbb (ou Bbbbb.Lib est le nom  de }
{ la  bibliothèque)  qui  retourne  la  valeur de l'indicateur }
{ d'erreur (grâce à CodeErreur) et le remet à zéro si le  code }
{ correspond  à  Bbbbb.Lib  et  retourne  zéro sans changer la }
{ valeur de l'indicateur d'erreur dans le  cas  contraire.     }

{   function ErreurBbbbb:integer;                              }
{     var AncienneValeurIndicateurDerreur:integer;             }
{   begin                                                      }
{     AncienneValeurIndicateurDerreur:=CodeErreur;             }
{     if ... then                                              }
{       (* Le code  AncienneValeurIndicateurDerreur correspond }
{          à une erreur s'étant produite dans Bbbbb.Lib *)     }
{         ErreurBbbbb:= AncienneValeurIndicateurDerreur        }
{       else begin                                             }
{         ForceErreur(AncienneValeurIndicateurDerreur);        }
{         ErreurBbbbb:=0;                                      }
{      end;                                                    }
{   end;                                                       }

{ Le code et le message d'erreur désigneront le module  appelé }
{ par  le  programme  principal  ayant  conduit directement ou }
{ indirectement (par appels d'autres modules) à l'erreur.      }

{--- Erreurs masquées à l'utilisateur--------------------------}

{ Retourner  l'option  d'arrêt  en  cas  d'erreur  (false: pas }
{ d'arrêt, true: écriture d'un  message  et  arrêt):           }
   function OptionArretSiErreur:boolean;
      
{ Pour  masquer  les erreurs pouvant intervenir dans une suite }
{ d'instructions  I1;...;In,  on  procédera  comme  suit   (la }
{ valeur  de  la  variable  'ErreurMasquee'  étant vraie si et }
{ seulement si une erreur s'est produite lors  de  l'exécution }
{ de I1;...;In):                                               }
{   var                                                        }
{     SauvegardeArretSiErreur, ErreurMasquee : boolean;        }
{     CodeDerniereErreurNonMasquée : integer;                  }
{   ...                                                        }
{   SauvegardeArretSiErreur := OptionArretSiErreur;            }
{   CodeDerniereErreur := CodeErreur;                          }
{   ArreterSiErreur(false);                                    }
{   I1;...In;                                                  }
{   ErreurMasquee := (CodeErreur<>0);                          }
{   ForceErreur(CodeDerniereErreurNonMasquée);                 }
{   ArreterSiErreur(SauvegardeArretSiErreur);                  }
{   (* Si l'erreur doit être signalée à l'utilisateur sous  le }
{   numéro nn avec le message 'mmmmmm', ajouter: *)            }
{   if ErreurMasquee then                                      }
{     SignalerErreur(nn,'mmmmmm');                             }
{--------------------------------------------------------------}