Herezh_dev/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.cc

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

#include "Courbe_expression_litterale_avec_derivees_1D.h"
#include "Sortie.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "ParaGlob.h"
#include "MotCle.h"

    // CONSTRUCTEURS :
Courbe_expression_litterale_avec_derivees_1D::Courbe_expression_litterale_avec_derivees_1D(string nom) :
 Courbe1D(nom,COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D)
 ,ax(-ConstMath::tresgrand),bx(ConstMath::tresgrand)
 ,expression_fonction(),p(),fVal()
 ,expression_der_fonct(" "),fVal_der()
 ,expression_der2_fonct(" "),fVal_der2()

// ,ordre_troncature(2)
  {};
    
    // de copie
Courbe_expression_litterale_avec_derivees_1D::Courbe_expression_litterale_avec_derivees_1D(const Courbe_expression_litterale_avec_derivees_1D& Co) :
 Courbe1D(Co),ax(Co.ax),bx(Co.bx)
 ,expression_fonction(Co.expression_fonction),p(),fVal(Co.fVal)
 ,fVal_der(Co.fVal_der)
 ,fVal_der2(Co.fVal_der2)
// ,ordre_troncature(Co.ordre_troncature)
  { // arrivée ici on définie la fonction et la variable attachée
    p.SetExpr(expression_fonction);
    p.DefineVar("x", &fVal);
    der_p.SetExpr(expression_der_fonct);
    der_p.DefineVar("x", &fVal_der);
    der2_p.SetExpr(expression_der2_fonct);
    der2_p.DefineVar("x", &fVal_der2);
  };
    // de copie à partir d'une instance générale
Courbe_expression_litterale_avec_derivees_1D::Courbe_expression_litterale_avec_derivees_1D(const Courbe1D& Coo) :
 Courbe1D(Coo)
 ,expression_fonction(),p(),fVal()
 ,expression_der_fonct(" "),fVal_der()
 ,expression_der2_fonct(" "),fVal_der2()
  { if (Coo.Type_courbe() != COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D)
      { cout << "\n erreur dans le constructeur de copie pour une courbe Courbe_expression_litterale_avec_derivees_1D "
             << " à partir d'une instance générale ";
        cout << "\n Courbe_expression_litterale_avec_derivees_1D::Courbe_expression_litterale_avec_derivees_1D(const Courbe1D& Co) ";
           Sortie(1);          
          };
    // définition des données
    Courbe_expression_litterale_avec_derivees_1D & Co = (Courbe_expression_litterale_avec_derivees_1D&) Coo;
    ax = Co.ax; bx = Co.bx;
    fVal=Co.fVal;
    expression_fonction = Co.expression_fonction;
    p.SetExpr(expression_fonction);
    p.DefineVar("x", &fVal);
   
    fVal_der=Co.fVal_der;
    expression_der_fonct = Co.expression_der_fonct;
    der_p.SetExpr(expression_der_fonct);
    der_p.DefineVar("x", &fVal_der);

    fVal_der2=Co.fVal_der2;
    expression_der2_fonct = Co.expression_der2_fonct;
    der2_p.SetExpr(expression_der2_fonct);
    der2_p.DefineVar("x", &fVal_der2);
   
  };

    // DESTRUCTEUR :
Courbe_expression_litterale_avec_derivees_1D::~Courbe_expression_litterale_avec_derivees_1D()
  {};
    
    // METHODES PUBLIQUES :
    
    // --------- virtuelles ---------
    
    // affichage de la courbe
void Courbe_expression_litterale_avec_derivees_1D::Affiche() const
  { cout << "\n Courbe_expression_litterale_avec_derivees_1D: nom_ref= " << nom_ref << " ";
    cout << "\n a=" << ax << " b= " << bx << " "
         << "\n f(x)= " << expression_fonction
         << "\n f'(x)= " << expression_der_fonct
         << "\n f\"(x)= " << expression_der2_fonct
         <<" ";
   };

    // vérification que tout est ok, pres à l'emploi
    // ramène true si ok, false sinon
bool Courbe_expression_litterale_avec_derivees_1D::Complet_courbe()const
 { bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
   // puis les variables propres
   return ret;
  } ;

    // Lecture des donnees de la classe sur fichier
    // le nom passé en paramètre est le nom de la courbe
    // s'il est vide c-a-d = "", la methode commence par lire le nom sinon
    // ce nom remplace le nom actuel
void Courbe_expression_litterale_avec_derivees_1D::LectDonnParticulieres_courbes(const string& nom,UtilLecture * entreePrinc)
  {  expression_fonction = "aucune_expression"; // init pour le traitement d'erreur
     expression_der_fonct = "aucune_expression"; // init pour le traitement d'erreur
     expression_der2_fonct = "aucune_expression"; // init pour le traitement d'erreur
  
     if (nom == "")  { *(entreePrinc->entree) >> nom_ref;}
     else {nom_ref=nom;};
       // on lit sans tenir compte des < éventuelles
       {entreePrinc->NouvelleDonneeSansInf();};


      // on lit tant que l'on ne rencontre pas la ligne contenant "fin_parametres_courbe_expression_litterale_"
      // ou un nouveau mot clé global auquel cas il y a pb !!
      MotCle motCle; // ref aux mots cle
      string titi;
      while (strstr(entreePrinc->tablcar,"fin_parametres_courbe_expression_litterale_")==0)
       {
        // si on a  un mot clé global dans la ligne courante c-a-d dans tablcar --> erreur
        if ( motCle.SimotCle(entreePrinc->tablcar))
         { cout << "\n erreur de lecture des parametre de definition d'une courbe avec expression litterale : on n'a pas trouve le mot cle "
                << " fin_parametres_courbe_expression_litterale_ et par contre la ligne courante contient un mot cle global  ";
           entreePrinc->MessageBuffer("** erreur des parametres d'une courbe expression litterale **");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
         };
         
        // lecture d'un mot clé
        *(entreePrinc->entree) >> titi;
        
        if ((entreePrinc->entree)->rdstate() == 0) 
          {} // lecture normale
        #ifdef ENLINUX 
        else  if ((entreePrinc->entree)->fail())
           // on a atteind la fin de la ligne et on appelle un nouvel enregistrement 
          {   // on lit sans tenir compte des < éventuelles
              entreePrinc->NouvelleDonneeSansInf();;
              *(entreePrinc->entree) >>titi;
           }
        #else
        else  if ((entreePrinc->entree)->eof())
          // la lecture est bonne mais on a atteind la fin de la ligne
          { if(titi != "fin_parametres_courbe_expression_litterale_")
              {entreePrinc->NouvelleDonneeSansInf();
               *(entreePrinc->entree) >> titi;
              };
          } 
        #endif
        else // cas d'une erreur de lecture
         { cout << "\n erreur de lecture inconnue  ";
           entreePrinc->MessageBuffer("** erreur2 des parametres d'une courbe expression litterale**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
         };

        // mini x
        if (titi == "a=")
         {*(entreePrinc->entree) >> ax;
         }
        // maxi x
        else if (titi == "b=")
         {*(entreePrinc->entree) >> bx;
         }
        // on lit maintenant l'expression littérale
        else if (titi == "f(x)=")
         { std::getline (*(entreePrinc->entree), expression_fonction);
         }
        // on lit maintenant l'expression littérale
        else if (titi == "f'(x)=")
         { std::getline (*(entreePrinc->entree), expression_der_fonct);
         }
        // on lit maintenant l'expression littérale
        else if (titi == "f\"(x)=")
         { std::getline (*(entreePrinc->entree), expression_der2_fonct);
         }
        // cas de la lecture du niveau d'impression pour les erreurs
        else if(titi == "permet_affichage_")
         {*(entreePrinc->entree) >> permet_affichage;
         }
        // sinon ce n'est pas un mot clé connu, on le signale
        else if(titi != "fin_parametres_courbe_expression_litterale_")
         { cout << "\n erreur en lecture d'un parametre, le mot cle est inconnu "
                << " on a lu : " << titi << endl;
           entreePrinc->MessageBuffer("**Courbe_expression_litterale_avec_derivees_1D::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);
         };
        
       }; //-- fin du while
   
     // on vérifie que l'on a bien lue une expression
     if (expression_fonction == "aucune_expression")
      {cout << "\n erreur en lecture de l'expression litterale de la fonction f(x) , l'expression est absente "
            << " ou il y a une erreur de syntaxe ";
       entreePrinc->MessageBuffer("**Courbe_expression_litterale_avec_derivees_1D::LectureDonneesParticulieres**");
       throw (UtilLecture::ErrNouvelleDonnee(-1));
       Sortie(1);
      };
     if (expression_der_fonct == "aucune_expression")
      {cout << "\n erreur en lecture de l'expression litterale de la derivee  f'(x) , l'expression est absente "
            << " ou il y a une erreur de syntaxe ";
       entreePrinc->MessageBuffer("**Courbe_expression_litterale_avec_derivees_1D::LectureDonneesParticulieres**");
       throw (UtilLecture::ErrNouvelleDonnee(-1));
       Sortie(1);
      };
     if (expression_der2_fonct == "aucune_expression")
      {cout << "\n erreur en lecture de l'expression litterale de la derivee seconde f\"(x) , l'expression est absente "
            << " ou il y a une erreur de syntaxe ";
       entreePrinc->MessageBuffer("**Courbe_expression_litterale_avec_derivees_1D::LectureDonneesParticulieres**");
       throw (UtilLecture::ErrNouvelleDonnee(-1));
       Sortie(1);
      };
   
     // arrivée ici on définie la fonction et la variable attachée
     p.SetExpr(expression_fonction);
     p.DefineVar("x", &fVal);
   
     der_p.SetExpr(expression_der_fonct);
     der_p.DefineVar("x", &fVal_der);
   
     der2_p.SetExpr(expression_der2_fonct);
     der2_p.DefineVar("x", &fVal_der2);
   
   };
    
// def info fichier de commande
void Courbe_expression_litterale_avec_derivees_1D::Info_commande_Courbes1D(UtilLecture & entreePrinc)
  {  
     ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
     sort << "\n#............................................"
          << "\n# exemple de definition d'une courbe Courbe_expression_litterale_avec_derivees_1D ( f(x) = une expression de x   |"
          << "\n#    avec la definition explicite de la derivee premiere f'(x) et de la derivee seconde f\"(x)= :  "
          << "\n#    les parametres (tous optionnels) de la courbe sont (ordre quelconque) :  "
          << "\n#     . une limite inferieur pour x, ex: a= -1 , par defaut= -l'infini "
          << "\n#     . une limite superieur pour x, ex: b= 4  , par defaut= +l'infini "
          << "\n#      exemple complet "
          << "\n courbe_monte   COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D  # nom de la courbe puis le type de la courbe "
          << "\n      # def des coeff de la courbe= mini et maxi de x "
          << "\n      # pour x < a => f=f(a), pour x>b => f=f(b)"
          << "\n      # a et b sont facultatif, par defaut = -l'infini et + l'infini "
          << "\n      a= 0. b= 1.   "
          << "\n      f(x)= (x^2+3.)+cos(3.*x)  "
          << "\n      f'(x)= 2.*x -3.*sin(x)  "
          << "\n      f\"(x)= 2.-9.*cos(x)  "
          << "\n   fin_parametres_courbe_expression_litterale_  "
          << endl;
   };
        
    // ramène la valeur 
double Courbe_expression_litterale_avec_derivees_1D::Valeur(double x)
  { double ret=0.;
    try
     {if (x < ax)      {fVal = ax;}
      else if (x > bx) {fVal = bx;}
      else             {fVal = x;};
      ret = p.Eval();
      if (permet_affichage >2)
       { cout << "\n retour courbe " << nom_ref << " x= "<< x
              << " valeur= "<<ret << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de la fonction "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
    return ret;
  };

    // ramène la valeur et la dérivée en paramètre
Courbe1D::ValDer Courbe_expression_litterale_avec_derivees_1D::Valeur_Et_derivee(double x)
  { ValDer ret; // def de la valeur de retour
    try
     {if (x < ax)      {fVal = fVal_der  = ax;}
      else if (x > bx) {fVal = fVal_der   = bx;}
      else             {fVal = fVal_der  = x;};
      ret.valeur = p.Eval();
      ret.derivee = der_p.Eval();
      if (permet_affichage >2)
       { cout << "\n retour courbe " << nom_ref << " x= "<< x
              << " valeur= "<<ret.valeur << " derivee= "<< ret.derivee << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de la fonction et derivee "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
    return ret;
  };
    
    // ramène la dérivée 
double Courbe_expression_litterale_avec_derivees_1D::Derivee(double x)
  { double ret=0.; // def de la valeur de retour
    try
     {if (x < ax)      {fVal_der = ax;}
      else if (x > bx) {fVal_der = bx;}
      else             {fVal_der = x;};
      ret = der_p.Eval();
      if (permet_affichage >2)
       { cout << "\n retour courbe " << nom_ref << " x= "<< x
              << " derivee= "<< ret << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de derivee de la fonction  "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
    return ret;
  };
        
    // ramène la valeur et les dérivées première et seconde en paramètre
Courbe1D::ValDer2 Courbe_expression_litterale_avec_derivees_1D::Valeur_Et_der12(double x)
  { ValDer2 ret; // def de la valeur de retour
    try
     {if (x < ax)      {fVal = fVal_der = fVal_der2 = ax;}
      else if (x > bx) {fVal = fVal_der = fVal_der2  = bx;}
      else             {fVal = fVal_der = fVal_der2  = x;};
      ret.valeur = p.Eval();
      ret.derivee = der_p.Eval();
      ret.der_sec = der2_p.Eval();
      if (permet_affichage >2)
       { cout << "\n retour courbe " << nom_ref << " x= "<< x
              << " valeur= "<<ret.valeur << " derivee= "<< ret.derivee
              << " der_sec= " << ret.der_sec
              << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de la fonction et derivee et derivee seconde "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
    return ret;
  };
        
    // ramène la dérivée seconde
double Courbe_expression_litterale_avec_derivees_1D::Der_sec(double x)
  { double ret=0.;
    try
     {if (x < ax)      {fVal_der2 = ax;}
      else if (x > bx) {fVal_der2 = bx;}
      else             {fVal_der2 = x;};
      
      ret = der2_p.Eval();
      if (permet_affichage >2)
       { cout << "\n retour courbe " << nom_ref << " x= "<< x
              << " der_sec= " << ret
              << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de la derivee seconde de la fonction "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
    return ret;
  };
    
    // ramène la valeur si dans le domaine strictement de définition
    // si c'est inférieur au x mini, ramène la valeur minimale possible de y
    // si supérieur au x maxi , ramène le valeur maximale possible de y
Courbe1D::Valbool  Courbe_expression_litterale_avec_derivees_1D::Valeur_stricte(double x)
  { Valbool ret; // def de la valeur de retour
    try
     {if (x < ax) {fVal = ax;
                   ret.valeur = p.Eval();
                   ret.dedans = false;
                  }
      else if (x > bx) {fVal = bx;
                        ret.valeur = p.Eval();
                        ret.dedans = false;
                       }
      else {fVal = x;
            ret.valeur = p.Eval();
            ret.dedans = true;
           };
      if (permet_affichage >2)
       { cout << "\n retour courbe " << nom_ref << " x= "<< x
              << " valeur= "<<ret.valeur << " dedans domaine de def: "<< ret.dedans
              << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de la fonction "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
  };
    
    // ramène la valeur et la dérivée si dans le domaine strictement de définition
    // si c'est inférieur au x mini, ramène la valeur minimale possible de y et Y' correspondant
    // si supérieur au x maxi , ramène le valeur maximale possible de y et Y' correspondant
Courbe1D::ValDerbool  Courbe_expression_litterale_avec_derivees_1D::Valeur_Et_derivee_stricte(double x)
  { ValDerbool ret; // def de la valeur de retour
    try
     {if (x < ax) {fVal = fVal_der  = ax;
                   ret.dedans = false;
                  }
      else if (x > bx) {fVal = fVal_der  =  bx;
                   ret.dedans = false;
                  }
      else          {fVal = fVal_der  =  x;
                   ret.dedans = true;
                  };
      ret.valeur = p.Eval();
      ret.derivee = der_p.Eval();
      if (permet_affichage >2)
       { cout << "\n retour courbe(domaine stricte) " << nom_ref << " x= "<< x
              << " valeur= "<<ret.valeur << " derivee= "<< ret.derivee
              << flush;
       };
     }
    catch(mu::Parser::exception_type &e)
     { cout << "\n ** erreur dans l'appel de la fonction et derivee "<< expression_fonction
            << " x= "<<x;
       cout << "\n Message:  " << e.GetMsg() << "\n";
       cout << "Formula:  " << e.GetExpr() << "\n";
       cout << "Token:    " << e.GetToken() << "\n";
       cout << "Position: " << e.GetPos() << "\n";
       cout << "Errc:     " << e.GetCode() << "\n" << endl ;
       Sortie(1);
     };
  };
    
	//----- lecture écriture de restart -----
	// cas donne le niveau de la récupération
    // = 1 : on récupère tout
    // = 2 : on récupère uniquement les données variables (supposées comme telles)
void Courbe_expression_litterale_avec_derivees_1D::Lecture_base_info(ifstream& ent,const int cas)
  { // on n'a que des grandeurs constantes
    if (cas == 1)
      { string nom;
        // lecture et vérification de l'entête
        ent >> nom;
        if (nom != "Courbe_expression_litterale_avec_derivees_1D")
         { cout << "\n erreur dans la vérification du type de courbe lue ";    
           cout << "\n Courbe_expression_litterale_avec_derivees_1D::Lecture_base_info(... ";
           Sortie(1); 
           } 
        // lecture des infos
        ent >> nom >> ax >> nom >> bx  ;
        ent >> nom >> expression_fonction ;
        p.SetExpr(expression_fonction);
        p.DefineVar("x", &fVal);
        ent >> nom >> expression_der_fonct ;
        p.SetExpr(expression_der_fonct);
        p.DefineVar("x", &fVal_der);
        ent >> nom >> expression_der2_fonct ;
        p.SetExpr(expression_der2_fonct);
        p.DefineVar("x", &fVal_der2);
       }
   };

    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Courbe_expression_litterale_avec_derivees_1D::Ecriture_base_info(ofstream& sort,const int cas)
  { // on n'a que des grandeurs constantes
    if (cas == 1)
      { sort << " Courbe_expression_litterale_avec_derivees_1D ";
        sort << "  a= " << ax  << " b= " << bx 
         << "\n f(x)= " << expression_fonction
         << "\n f'(x)= " << expression_der_fonct
         << "\n f\"(x)= " << expression_der2_fonct
         << " ";
       }
   };
         
// sortie du schemaXML: en fonction de enu 
void Courbe_expression_litterale_avec_derivees_1D::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu)
  {
	switch (enu)
	{ case XML_TYPE_GLOBAUX :
		{
		 break;
		}
		case XML_IO_POINT_INFO :
		{
		 break;
		}
		case XML_IO_POINT_BI :
		{
		 break;
		}
		case XML_IO_ELEMENT_FINI :
		{
		 break;
		}
	};		
  };