{------------------------------------------------------------------}
  {------------------------- ENTREES.LIB ----------------------------}
  {------------------------------------------------------------------}

  Un programme utilisant cette bibliothèque sur compatible PBM PC
  doit commencer par:
     
    (* utilise Math.Lib, Entrees.Lib *)
    (*$i Math.Lib*)
    (*$i Entrees.Lib*)
    
    
  Un programme utilisant cette bibliothèque sur Macintosh doit
  commencer par:
     
    {* utilise Math.Lib, Entrees.Lib *}
    {$S+}
     uses
       {$S Mac}
          MemTypes,QuickDraw,OSIntf,ToolIntf,Sane,
       {$S Math}
          Math_Lib,
       {$S Entr}
          Entrees_Lib;
    {$S}
    
  et dans les deux cas appeler la procédure InitMath.

  {------------------------------------------------------------------}
  {--- Utilisation de premier niveau --------------------------------}
  {------------------------------------------------------------------}
  
  { Lecture d'un entier ou réel au clavier (sous forme symbolique)   }
        procedure Entre_Entier(var I:integer);
        procedure Entre_Reel(var R:real);
        
  { Lecture d'un booléen au clavier:                                 }
  {   true  : O o V v T t 1, false : N n F f 0                       }
        procedure Entre_Booleen(var B:boolean);

  { Marquer une pause jusqu'à  ce  qu'une  touche  du  clavier  soit }
  { enfoncée.                                                        }
        procedure Pause;

  { Dimension maximale des matrices et vecteurs utilisables (20)     }
        function Max_Dimension:integer;
        
  { Types matrice et vecteur prédéfinis                              }
        type
          Matrice = array[1..20, 1..20] of real;
          Vecteur = array[1..20] of real;
  
  { Ecriture des éléments V[1],...V[Bs] d'un vecteur V:              }
        procedure Affiche_Vecteur(var V; Bs:integer);
         { V est de type "array[1..s] of real" et Bs <= s.           }
         
  { Ecriture des éléments  M[I,J],  I=1,...,Bs1,  J=1,...,Bs2  d'une }
  { matrice M:                                                       }
        procedure Affiche_Matrice(var M:Matrice; Bs1,Bs2:integer);
         { Bs1 <= 20  et  Bs2 <= 20.                                 }
        procedure AfficheMatrice(var M; Bs1,Bs2:integer);
         { M est de type "array[1..s1,1..s2] of real", Bs1 <= s1  et }
         { Bs2=s2.                                                   }
     
   { Lecture d'un vecteur ou  d'une  matrice  (ligne  par  ligne  ou }
   { colonne par colonne) au clavier (sous forme symbolique):        }
        procedure Entre_Vecteur(var V; Bs:integer);
         { V est de type "array[1..s] of real" et Bs <= s.           }
        procedure Entre_Matrice(var M:Matrice; Bs1,Bs2:integer);
         { Bs1 <= 20  et  Bs2 <= 20.                                 }
        procedure EntreMatrice(var M; Bs1,Bs2:integer);
         { M est de type "array[1..s1,1..s2] of real", Bs1 <= s1  et }
         { Bs2=s2.                                                   }
  
   
  {------------------------------------------------------------------}
  {--- Utilisation de deuxième niveau -------------------------------}
  {------------------------------------------------------------------}
  
  {--- Interprétation de fonctions ----------------------------------}
  
        type
          Fonction = ...;

  { Définition,entrée et sortie d'une fonction sous forme symbolique:}
        procedure Definis_Fonction(ListeVariables:Texte; 
                                    Expression:Texte; var F:Fonction);
        { définition de la fonction:                                 }
        {   function F(X1,...,Yn):real;                              }
        {   begin                                                    }
        {     F:=Expression;                                         }
        {   end;                                                     }
        { où ListeVariables = 'X1...Yn'                              }
        
        procedure Entre_Fonction(ListeVariables:Texte; var F:Fonction);
        { définition de la fonction F comme ci-dessus,  l'Expression }
        { étant entrée au clavier.                                   }

        procedure Affiche_Expression(F:Fonction);
        { Ecrire l'Expression constituant le corps de la fonction F  } 
        procedure Affiche_ExpressionLn(F:Fonction);
        { Ecrire l'Expression constituant le corps de la fonction F  }
        { puis passer a la ligne                                     }
       
       function Nombre_Variables(F:Fonction):integer;
        { Retourne le nombre de paramètres formels  dont  dépend  la }
        { fonction symbolique F                                      }


  { Evaluation d'une fonction donnée sous forme symbolique:          }
        function Evalue1(F:Fonction; X:real):real;
          { retourne F(X)                                            }
        function Evalue2(F:Fonction; X,Y:real):real;
          { retourne F(X,Y)                                          }
        function Evalue3(F:Fonction; X,Y,Z:real):real;
          { retourne F(X,Y,Z)                                        }
        function Evalue4(F:Fonction; X,Y,Z,T:real):real;
          { retourne F(X,Y,Z,T)                                      }
  
   {-----------------------------------------------------------------}
   { Par forme symbolique on entend une expression réelle construite }
   { en utilisant:                                                   }
   { . les opérateurs unaires + et -,                                }
   { . les opérateurs binaires +, -, *, / et ^ (puissance),          }
   { . les appels de fonctions définies dans Math.Lib,               }
   { . les nombres entiers ou réels,                                 }
   { . les parenthèses ( et ),                                       }
   { . les variables A,...,D,F,...Z         (dans les définitions de }
   {   fonctions).                                                   }
   {-----------------------------------------------------------------}

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

  function ErreurEntrees:integer;
    { Retourne la valeur de l'indicateur d'erreur et le remet à zéro }
    { s'il désigne une erreur s'étant produite dans la  bibliothèque }
    { Entrees.Lib ou sinon retourne 0 sans changer la valeur de  cet }
    { indicateur d'erreur.                                           }
    
    { Codes     d'erreur     retournés     :   Definis_Fonction:201, }
    { Entre_Fonction:202,  Evalue1:203,  Evalue2:204,   Evalue3:205, }
    { Evalue4:206,  Affiche_Expression:207, AfficheExpressionLn:209, }
    { Nombre_Variables:207, Affiche_Matrice:210,  Entre_Matrice:211, }
    { Affiche_Vecteur:212, Entre_Vecteur:213,    AfficheMatrice:214, }
    { EntreMatrice:215,     Entre_Reel:216,        Entre_Entier:217, }
    { Entre_Booleen:218. }
{--------------------------------------------------------------------}