545 lines
22 KiB
C++
Executable file
545 lines
22 KiB
C++
Executable file
// 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-2021 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;
|
|
}
|
|
};
|
|
};
|
|
|