==================================
Documentation de l'unité UEVAL.PAS
==================================

   L'unité UEval.Pas utilise l'unité UPCalc.

   Elle permet d'évaluer des expressions mathématiques fournies sous forme de 
chaînes de caractères. Ces expressions peuvent contenir des noms de variables
et des noms de fonctions.

====================
Utilisation minimale
====================

 _ Function Eval(S:String; var Erreur:Boolean):Real;
   --------------------------------------
   Cette fonction renvoie le résultat du calcul indiqué dans S.
   La variable booléenne Erreur indique si une erreur s'est produite.
   Exemples : Eval('2+5') renvoie 7
              Eval('5²-3*4') renvoie 13
              Eval('9-2^4') renvoie -7
              Eval('5*(2+8)') renvoie 50
              Eval('sin(pi/2)') renvoie 1
   Les opérations utilisables sont +, -, *, / et ^.
   Les règles de priorités entre opérations sont respectées.
   Les parenthèses peuvent modifier cet ordre.
   Les arguments des fonctions doivent être entre parenthèses.

   En cas d'erreur le résultat renvoyé est 0.

 _ Function FormateReal(R:Real;dec:integer):String;
   ------------------------------------------------
   Ecrit le nombre réel contenu dans R avec dec chiffres après la virgule.

 _ Liste des fonctions reconnues
   -----------------------------
   'ABS';       { valeur absolue }
   'ARCCOS';    { arc cosinus }
   'ARCSIN';    { arc sinus }
   'ARCTAN';    { arc tangente }
   'ARGCH';     { argument cosinus hyperbolique }
   'ARGSH';     { argument sinus hyperbolique }
   'ARGTH';     { argument tangente hyperbolique }
   'CAR';       { carré }
   'CH';        { cosinus hyperbolique }
   'COS';       { cosinus }
   'ENT';       { partie entière }
   'EXP';       { exponentielle }
   'FRAC';      { partie fractionnaire }
   'LN';        { logarithme népérien }
   'LOG';       { logarithme décimal }
   'RAC';       { racine carrée }
   'SH';        { sinus hyperbolique }
   'SIN';       { sinus }
   'TAN';       { tangente }
   'TH';        { tangente hyperbolique }
   Le symbole ² peut être utilisé pour les carrés.


===================
UTILISATION EVOLUEE
===================

   Pour effectuer des calculs nombreux avec une fonction il est nécessaire
d'utiliser d'autres notions. On utilisera deux objets : le premier représente
un dictionnaire, le second représente un arbre de calcul.

 _ Objet dictionnaire
   ------------------
   Les noms de fonctions et de variables sont contenus dans un dictionnaire.
   Celui-ci est représenté par un objet de type TMathDico.
   La création du dictionnaire peut être obtenue à l'aide des deux fonctions
   suivantes :

  - Function BasicMathDico:PMathDico;
    Fournit un pointeur sur un dictionnaire contenant les fonctions
    mathématiques de base.

  - Function ExtendedMathDico:PMathDico;
    Fournit un pointeur sur un dictionnaire contenant les fonctions
    mathématiques de base et les fonctions hyperboliques.

   Les deux méthodes suivantes seront utilisées :

  - Destructor Done; virtual;
    Permet de libérer la mémoire occupée par le dictionnaire.

  - Procedure DefVar(Id:TIdentItem; r:Real);
    Permet d'ajouter ou de modifier une variable nommée Id en lui affectant
    la valeur r.


 _ Objet arbre d'évaluation
   ------------------------

    L'évaluation se fait par l'intermédiaire d'un objet de type TCalcNode.
  Il s'agit d'un arbre de calcul qui est créé à partir d'une chaine de
  caractères en liaison avec un dictionnaire.

    On obtient un pointeur sur un arbre de calcul en utilisant la fonction
  GetNode(S:String; dic:PMathDico) où S est la chaîne à évaluer et dic le
  dictionnaire utilisé.
    Après une tentative de création d'un arbre, la variable ParseErrorFlag
  indique si une erreur de syntaxe s'est produite. La fonction
  GetParseErrorMsg renvoie un message d'erreur.

    Pour effectuer le calcul de l'arbre on appelle sa méthode GetVal. Après
  appel de cette méthode, la fonction IsPCalcError indique si une erreur
  de calcul s'est produite. La fonction GetPCalcErrorMsg renvoie un message
  d'erreur.

    Lorsque l'arbre est devenu inutile, on le détruit avec son destructeur
  Done pour libérer la mémoire.


====================
Exemple de programme
====================

Program Calc;
{ évaluateur d'expressions mathématiques }
{ Kostrzewa Bruno, février 1996 }
{ révision mai 1996 }

{$A+,B-,D-,E-,F-,I+,L-,N-,R-,S-,V-,W+,X+}

Uses UPCalc, UEval;

Var S : String;
    r : Real;
    M : PCalcNode;
    D : PMathDico;

Begin
 writeln('CALC 1.0 (Evaluateur d''expressions mathématiques) K.B 96');
 writeln('--------------------------------------------------------');
 writeln;
 D:=ExtendedMathDico;
 M:=nil;
 repeat
  write('> ');
  readln(S);
  if S=''
   then begin
         if M<>nil then dispose(M,Done);
         dispose(D,Done);
         writeln('Au revoir...');
         halt(0);
        end;
  if M<>nil then dispose(M,Done);
  M:=GetNode(S,D);
  if ParseErrorFlag<>0
   then writeln(#7,GetParseErrorMsg)
   else begin
         r:=M^.GetVal;
         if IsPCalcError
          then writeln(#7,GetPCalcErrorMsg)
          else writeln('  = ',FormateReal(r,6));
        end;
 until false;
End.

K.B. avril 1996