633 lines
30 KiB
C++
Executable file
633 lines
30 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_ln_cosh.h"
|
|
#include "Sortie.h"
|
|
#include "ConstMath.h"
|
|
#include "MathUtil.h"
|
|
#include "ParaGlob.h"
|
|
#include "MotCle.h"
|
|
|
|
// CONSTRUCTEURS :
|
|
Courbe_ln_cosh::Courbe_ln_cosh(string nom) :
|
|
Courbe1D(nom,COURBE_LN_COSH)
|
|
,ax(-ConstMath::tresgrand),bx(ConstMath::tresgrand)
|
|
,al(1.),be(0.),ga(1.),de(1.),he(0.),ee(1.),ke(1.),ge(0.),re(1.),se(0.)
|
|
,n(1)
|
|
{};
|
|
|
|
// de copie
|
|
Courbe_ln_cosh::Courbe_ln_cosh(const Courbe_ln_cosh& Co) :
|
|
Courbe1D(Co),ax(Co.ax),bx(Co.bx)
|
|
,al(Co.al),be(Co.be),ga(Co.ga),de(Co.de),he(Co.he),ee(Co.ee),ke(Co.ke),ge(Co.ge),re(Co.re)
|
|
,se(Co.se)
|
|
,n(Co.n)
|
|
{};
|
|
// de copie à partir d'une instance générale
|
|
Courbe_ln_cosh::Courbe_ln_cosh(const Courbe1D& Coo) :
|
|
Courbe1D(Coo)
|
|
{ if (Coo.Type_courbe() != COURBE_LN_COSH)
|
|
{ cout << "\n erreur dans le constructeur de copie pour une courbe Courbe_ln_cosh "
|
|
<< " à partir d'une instance générale ";
|
|
cout << "\n Courbe_ln_cosh::Courbe_ln_cosh(const Courbe1D& Co) ";
|
|
Sortie(1);
|
|
};
|
|
// définition des données
|
|
Courbe_ln_cosh & Co = (Courbe_ln_cosh&) Coo;
|
|
ax = Co.ax; bx = Co.bx;
|
|
al=Co.al;be=Co.be;ga=Co.ga;de=Co.de;he=Co.he;ee=Co.ee;ke=Co.ke;ge=Co.ge;re=Co.re;se=Co.se;
|
|
};
|
|
|
|
// DESTRUCTEUR :
|
|
Courbe_ln_cosh::~Courbe_ln_cosh()
|
|
{};
|
|
|
|
// METHODES PUBLIQUES :
|
|
|
|
// --------- virtuelles ---------
|
|
|
|
// affichage de la courbe
|
|
void Courbe_ln_cosh::Affiche() const
|
|
{ cout << "\n Courbe_ln_cosh: nom_ref= " << nom_ref << " ";
|
|
cout << "\n a=" << ax << " b= " << bx << " " ;
|
|
cout << " al= " << al << " be= " << be << " ga= " << ga
|
|
<< " n= " << n << " de= " << de << " he= " << he << " ee= "
|
|
<< ee << " ke= " << ke << " ge= " << ge << " re= " << re
|
|
<< " se= "<< se << " " ;
|
|
};
|
|
|
|
// vérification que tout est ok, pres à l'emploi
|
|
// ramène true si ok, false sinon
|
|
bool Courbe_ln_cosh::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_ln_cosh::LectDonnParticulieres_courbes(const string& nom,UtilLecture * entreePrinc)
|
|
{ if (nom == "") { *(entreePrinc->entree) >> nom_ref;}
|
|
else {nom_ref=nom;};
|
|
entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne
|
|
|
|
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_coefficients_courbe_ln_cosh_"
|
|
// ou un nouveau mot clé global auquel cas il y a pb !!
|
|
MotCle motCle; // ref aux mots cle
|
|
string toto;
|
|
while (strstr(entreePrinc->tablcar,"fin_coefficients_courbe_ln_cosh_")==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 la fonction courbe_ln_cosh : on n'a pas trouve de mot cle "
|
|
<< " fin_coefficients_courbe_ln_cosh_ et par contre la ligne courante contient un mot cle global ";
|
|
entreePrinc->MessageBuffer("** erreur1 de lecture des parametres de la fonction courbe_ln_cosh**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// lecture d'un mot clé
|
|
*(entreePrinc->entree) >> toto;
|
|
|
|
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
|
|
{ entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
|
|
*(entreePrinc->entree) >>nom;
|
|
}
|
|
#else
|
|
else if ((entreePrinc->entree)->eof())
|
|
// la lecture est bonne mais on a atteind la fin de la ligne
|
|
{ if(nom != "fin_coefficients_courbe_ln_cosh_")
|
|
{entreePrinc->NouvelleDonnee(); *(entreePrinc->entree) >> toto;};
|
|
}
|
|
#endif
|
|
else // cas d'une erreur de lecture
|
|
{ cout << "\n erreur de lecture inconnue ";
|
|
entreePrinc->MessageBuffer("** erreur2 de lecture des parametres de la fonction courbe_ln_cosh**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// puis les coefficients
|
|
if(toto == "al=")
|
|
{*(entreePrinc->entree) >> al;}
|
|
else if (toto == "be=")
|
|
{*(entreePrinc->entree) >> be;}
|
|
else if (toto == "ga=")
|
|
{*(entreePrinc->entree) >> ga;}
|
|
else if (toto == "n=")
|
|
{*(entreePrinc->entree) >> n;}
|
|
else if (toto == "de=")
|
|
{*(entreePrinc->entree) >> de;}
|
|
else if (toto == "he=")
|
|
{*(entreePrinc->entree) >> he;}
|
|
else if (toto == "ee=")
|
|
{*(entreePrinc->entree) >> ee;}
|
|
else if (toto == "ke=")
|
|
{*(entreePrinc->entree) >> ke;}
|
|
else if (toto == "ge=")
|
|
{*(entreePrinc->entree) >> ge;}
|
|
else if (toto == "re=")
|
|
{*(entreePrinc->entree) >> re;}
|
|
else if (toto == "se=")
|
|
{*(entreePrinc->entree) >> se;}
|
|
else if (toto == "a=")
|
|
{*(entreePrinc->entree) >> ax;}
|
|
else if (toto == "b=")
|
|
{*(entreePrinc->entree) >> bx;}
|
|
|
|
|
|
}; //-- fin du while
|
|
};
|
|
|
|
// def info fichier de commande
|
|
void Courbe_ln_cosh::Info_commande_Courbes1D(UtilLecture & entreePrinc)
|
|
{
|
|
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
sort << "\n#............................................"
|
|
<< "\n# exemple de definition d'une courbe Courbe_ln_cosh "
|
|
<< "\n# f(x) = al * (be + ga * x)^n * ln (cosh(de *(he+ ee * x)))+ ke * (ge+re * x + se / x) "
|
|
<< "\n# les parametres (tous optionnels) de la courbe sont (ordre a respecter) : "
|
|
<< "\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# . les coefficients qui peuvent etre dans n'importe quel ordre, "
|
|
<< "\n# presents ou non, et sur plusieurs lignes: "
|
|
<< "\n# . al= un_reel ex: al= 3., par defaut= 1. "
|
|
<< "\n# . be= un_reel ex: be= 1., par defaut= 0. "
|
|
<< "\n# . ga= un_reel ex: ga= 3., par defaut= 1. "
|
|
<< "\n# . n= un_entier ex: n= 3, par defaut= 1 "
|
|
<< "\n# . de= un_reel ex: de= 3., par defaut= 1. "
|
|
<< "\n# . he= un_reel ex: he= 3., par defaut= 0. "
|
|
<< "\n# . ee= un_reel ex: ee= 3., par defaut= 1. "
|
|
<< "\n# . ke= un_reel ex: ke= 3., par defaut= 1. "
|
|
<< "\n# . ge= un_reel ex: ge= 3., par defaut= 0. "
|
|
<< "\n# . re= un_reel ex: re= 3., par defaut= 1. "
|
|
<< "\n# . se= un_reel ex: se= 1., par defaut= 0. "
|
|
<< "\n# puis a la fin de la liste des coefs le mot clef "
|
|
<< "\n# fin_coefficients_courbe_ln_cosh_ "
|
|
<< "\n# exemple complet "
|
|
<< "\n courbe_monte COURBE_LN_COSH # 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. al= 2. be= 3. ga= 0.5 ke= 2. "
|
|
<< "\n ge= 0. se= 1. "
|
|
<< "\n fin_coefficients_courbe_ln_cosh_ "
|
|
<< endl;
|
|
};
|
|
|
|
// ramène la valeur
|
|
// f(x) = al * (be + ga * x)^n * ln (cosh(de *(he+ ee * x)))+ ke * (ge+re * x + se / x)
|
|
double Courbe_ln_cosh::Valeur(double x)
|
|
{ double ret=0.;
|
|
try
|
|
{
|
|
if (x < ax)
|
|
{double seSurax= 0.;
|
|
if (se != 0.) seSurax= se / ax;
|
|
ret = al * pow((be + ga * ax),n) * log (cosh(de *(he+ ee * ax)))+ ke * (ge+re * ax+seSurax);}
|
|
else if (x > bx)
|
|
{double seSurbx= 0.;
|
|
if (se != 0.) seSurbx= se / bx;
|
|
ret = al * pow((be + ga * bx),n) * log (cosh(de *(he+ ee * bx)))+ ke * (ge+re * bx+seSurbx);}
|
|
else {double seSurx= 0.;
|
|
if (se != 0.) seSurx= se / x;
|
|
ret = al * pow((be + ga * x),n) * log (cosh(de *(he+ ee * x)))+ ke * (ge+re * x+seSurx);};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la fonction ln_cosh pour la valeur x= "<< x
|
|
<< " on retourne 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la valeur et la dérivée en paramètre
|
|
// f(x) = al * (be + ga * x)^n * ln (cosh(de *(he+ ee * x)))+ ke * (ge+re * x + se / x)
|
|
// f'(x) = de*ee*al*(be+ga*x)^n*tanh(de*(he+ee*x))+al*n*ga*(be+ga*x)^(n-1)*log(cosh(de*(he+ee*x)))
|
|
// + ke*(re-se/x^2)
|
|
Courbe1D::ValDer Courbe_ln_cosh::Valeur_Et_derivee(double x)
|
|
{ ValDer ret; // def de la valeur de retour
|
|
try
|
|
{
|
|
if (x < ax) {double bega = be + ga * ax; double bega_n = pow((be + ga * ax),n);
|
|
double deheee = de *(he+ ee * ax); double cosh_deheee = cosh(deheee);
|
|
double seSurax = 0.; double seSur_ax2 = 0.;
|
|
if (se != 0.) {seSurax = se / ax; seSur_ax2 = seSurax / ax;}
|
|
ret.valeur = al * bega_n * log (cosh_deheee)+ ke * (ge+re * ax+seSurax);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_ax2);
|
|
}
|
|
else if (x > bx)
|
|
{double bega = be + ga * bx; double bega_n = pow((be + ga * bx),n);
|
|
double deheee = de *(he+ ee * bx); double cosh_deheee = cosh(deheee);
|
|
double seSurbx = 0.; double seSur_bx2 = 0.;
|
|
if (se != 0.) {seSurbx = se / bx; seSur_bx2 = seSurbx / bx;}
|
|
ret.valeur = al * bega_n * log (cosh_deheee)+ ke * (ge+re * bx+seSurbx);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_bx2);
|
|
}
|
|
else {double bega = be + ga * x; double bega_n = pow((be + ga * x),n);
|
|
double deheee = de *(he+ ee * x); double cosh_deheee = cosh(deheee);
|
|
double seSurx= 0.; double seSur_x2 = 0.;
|
|
if (se != 0.) {seSurx = se / x; seSur_x2 = seSurx/ x;}
|
|
ret.valeur = al * bega_n * log (cosh_deheee)+ ke * (ge+re * x+seSurx);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_x2);
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la fonction ln_cosh et de sa derivee pour la valeur x= "<< x
|
|
<< " on retourne 0 et 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la dérivée
|
|
// f'(x) = de*ee*al*(be+ga*x)^n*tanh(de*(he+ee*x))+al*n*ga*(be+ga*x)^(n-1)*log(cosh(de*(he+ee*x)))
|
|
// + ke*(re-se/x^2)
|
|
double Courbe_ln_cosh::Derivee(double x)
|
|
{ double ret=0.; // def de la valeur de retour
|
|
try
|
|
{
|
|
if (x < ax) {double bega = be + ga * ax; double bega_n = pow((be + ga * ax),n);
|
|
double deheee = de *(he+ ee * ax); double cosh_deheee = cosh(deheee);
|
|
double seSur_ax2 = 0.;
|
|
if (se != 0.) {seSur_ax2 = se / ax / ax;}
|
|
ret = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_ax2);
|
|
}
|
|
else if (x > bx)
|
|
{double bega = be + ga * bx; double bega_n = pow((be + ga * bx),n);
|
|
double deheee = de *(he+ ee * bx); double cosh_deheee = cosh(deheee);
|
|
double seSur_bx2 = 0.;
|
|
if (se != 0.) {seSur_bx2 = se / bx / bx;}
|
|
ret = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_bx2);
|
|
}
|
|
else {double bega = be + ga * x; double bega_n = pow((be + ga * x),n);
|
|
double deheee = de *(he+ ee * x); double cosh_deheee = cosh(deheee);
|
|
double seSur_x2 = 0.;
|
|
if (se != 0.) {seSur_x2 = se / x / x;}
|
|
ret = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_x2);
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la derivee de la fonction ln_cosh pour la valeur x= "<< x
|
|
<< " on retourne 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la valeur et les dérivées première et seconde en paramètre
|
|
// f(x) = al * (be + ga * x)^n * ln (cosh(de *(he+ ee * x)))+ ke * (ge+re * x + se / x)
|
|
// f'(x) = de*ee*al*(be+ga*x)^n*tanh(de*(he+ee*x))+al*n*ga*(be+ga*x)^(n-1)*log(cosh(de*(he+ee*x)))
|
|
// + ke*(re-se/x^2)
|
|
// f"(x) = de*de*ee*ee*al*(be+ga*x)^n * (1./cosh(de*(he+ee*x)))^2
|
|
// + de*ee*al*n*ga*(be+ga*x)^(n-1) * (tanh(de*(he+ee*x))+ (1./tanh(de*(he+ee*x))))
|
|
// + al*n*ga*ga*(n-1)*(be+ga*x)^(n-2)*log(cosh(de*(he+ee*x)))
|
|
// + 2 * ke * se / (x^3)
|
|
Courbe1D::ValDer2 Courbe_ln_cosh::Valeur_Et_der12(double x)
|
|
{ ValDer2 ret; // def de la valeur de retour
|
|
try
|
|
{
|
|
if (x < ax) {double bega = be + ga * ax; double bega_n = pow((be + ga * ax),n);
|
|
double deheee = de *(he+ ee * ax); double cosh_deheee = cosh(deheee);
|
|
double log_cosh = log (cosh_deheee);
|
|
double seSurax = 0.; double seSur_ax2 = 0.;double seSur_ax3 = 0.;
|
|
if (se != 0.) {seSurax = se / ax; seSur_ax2 = seSurax / ax;seSur_ax3 = seSur_ax2 / ax;}
|
|
ret.valeur = al * bega_n * log_cosh+ ke * (ge+re * ax+seSurax);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log_cosh
|
|
+ ke * (re-seSur_ax2);
|
|
double de2=de*de; double ee2=ee*ee; double unSurCosh = 1. / cosh_deheee;
|
|
double bega_nmoins1 = pow(bega,n-1);
|
|
double bega_nmoins2 = pow(bega,n-2);
|
|
double tanh_deheee = tanh(deheee); double unSurtanh = 1. / tanh_deheee;
|
|
ret.der_sec = de2 * ee2 * al * bega_n * unSurCosh * unSurCosh
|
|
+ de * ee * al * n * ga * bega_nmoins1 * (tanh_deheee + unSurtanh)
|
|
+ al * n * ga * ga * (n-1) * bega_nmoins2 * log_cosh
|
|
+ 2. * ke * seSur_ax3;
|
|
}
|
|
else if (x > bx)
|
|
{double bega = be + ga * bx; double bega_n = pow((be + ga * bx),n);
|
|
double deheee = de *(he+ ee * bx); double cosh_deheee = cosh(deheee);
|
|
double log_cosh = log (cosh_deheee);
|
|
double seSurbx = 0.; double seSur_bx2 = 0.;double seSur_bx3 = 0.;
|
|
if (se != 0.) {seSurbx = se / bx; seSur_bx2 = seSurbx / bx;seSur_bx3 = seSur_bx2 / bx;}
|
|
ret.valeur = al * bega_n * log_cosh+ ke * (ge+re * bx+seSurbx);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log_cosh
|
|
+ ke * (re-seSur_bx2);
|
|
double de2=de*de; double ee2=ee*ee; double unSurCosh = 1. / cosh_deheee;
|
|
double bega_nmoins1 = pow(bega,n-1);
|
|
double bega_nmoins2 = pow(bega,n-2);
|
|
double tanh_deheee = tanh(deheee); double unSurtanh = 1. / tanh_deheee;
|
|
ret.der_sec = de2 * ee2 * al * bega_n * unSurCosh * unSurCosh
|
|
+ de * ee * al * n * ga * bega_nmoins1 * (tanh_deheee + unSurtanh)
|
|
+ al * n * ga * ga * (n-1) * bega_nmoins2 * log_cosh
|
|
+ 2. * ke * seSur_bx3;
|
|
}
|
|
else
|
|
{double bega = be + ga * x; double bega_n = pow((be + ga * x),n);
|
|
double deheee = de *(he+ ee * x); double cosh_deheee = cosh(deheee);
|
|
double log_cosh = log (cosh_deheee);
|
|
double seSurx = 0.; double seSur_x2 = 0.;double seSur_x3 = 0.;
|
|
if (se != 0.) {seSurx = se / x; seSur_x2 = seSurx / x;seSur_x3 = seSur_x2 / x;}
|
|
ret.valeur = al * bega_n * log_cosh+ ke * (ge+re * x+seSurx);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log_cosh
|
|
+ ke * (re-seSur_x2);
|
|
double de2=de*de; double ee2=ee*ee; double unSurCosh = 1. / cosh_deheee;
|
|
double bega_nmoins1 = pow(bega,n-1);
|
|
double bega_nmoins2 = pow(bega,n-2);
|
|
double tanh_deheee = tanh(deheee); double unSurtanh = 1. / tanh_deheee;
|
|
ret.der_sec = de2 * ee2 * al * bega_n * unSurCosh * unSurCosh
|
|
+ de * ee * al * n * ga * bega_nmoins1 * (tanh_deheee + unSurtanh)
|
|
+ al * n * ga * ga * (n-1) * bega_nmoins2 * log_cosh
|
|
+ 2. * ke * seSur_x3;
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la fonction ln_cosh et de ses derivees 1 et 2 pour la valeur x= "<< x
|
|
<< " on retourne 0 , 0 , 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la dérivée seconde
|
|
// f"(x) = de*de*ee*ee*al*(be+ga*x)^n * (1./cosh(de*(he+ee*x)))^2
|
|
// + de*ee*al*n*ga*(be+ga*x)^(n-1) * (tanh(de*(he+ee*x))+ (1./tanh(de*(he+ee*x))))
|
|
// + al*n*ga*ga*(n-1)*(be+ga*x)^(n-2)*log(cosh(de*(he+ee*x)))
|
|
// + 2 * ke * se / (x^3)
|
|
double Courbe_ln_cosh::Der_sec(double x)
|
|
{ double ret=0.;
|
|
try
|
|
{
|
|
if (x < ax) {double bega = be + ga * ax; double bega_n = pow((be + ga * ax),n);
|
|
double deheee = de *(he+ ee * ax); double cosh_deheee = cosh(deheee);
|
|
double log_cosh = log (cosh_deheee);
|
|
double de2=de*de; double ee2=ee*ee; double unSurCosh = 1. / cosh_deheee;
|
|
double bega_nmoins1 = pow(bega,n-1);
|
|
double bega_nmoins2 = pow(bega,n-2);
|
|
double tanh_deheee = tanh(deheee); double unSurtanh = 1. / tanh_deheee;
|
|
double seSur_ax3 = 0.;
|
|
if (se != 0.) {seSur_ax3 = se / (ax * ax * ax);}
|
|
ret = de2 * ee2 * al * bega_n * unSurCosh * unSurCosh
|
|
+ de * ee * al * n * ga * bega_nmoins1 * (tanh_deheee + unSurtanh)
|
|
+ al * n * ga * ga * (n-1) * bega_nmoins2 * log_cosh
|
|
+ 2. * ke * seSur_ax3;
|
|
}
|
|
else if (x > bx)
|
|
{double bega = be + ga * bx; double bega_n = pow((be + ga * bx),n);
|
|
double deheee = de *(he+ ee * bx); double cosh_deheee = cosh(deheee);
|
|
double log_cosh = log (cosh_deheee);
|
|
double de2=de*de; double ee2=ee*ee; double unSurCosh = 1. / cosh_deheee;
|
|
double bega_nmoins1 = pow(bega,n-1);
|
|
double bega_nmoins2 = pow(bega,n-2);
|
|
double tanh_deheee = tanh(deheee); double unSurtanh = 1. / tanh_deheee;
|
|
double seSur_bx3 = 0.;
|
|
if (se != 0.) {seSur_bx3 = se / (bx * bx * bx);}
|
|
ret = de2 * ee2 * al * bega_n * unSurCosh * unSurCosh
|
|
+ de * ee * al * n * ga * bega_nmoins1 * (tanh_deheee + unSurtanh)
|
|
+ al * n * ga * ga * (n-1) * bega_nmoins2 * log_cosh
|
|
+ 2. * ke * seSur_bx3;
|
|
}
|
|
else
|
|
{double bega = be + ga * x; double bega_n = pow((be + ga * x),n);
|
|
double deheee = de *(he+ ee * x); double cosh_deheee = cosh(deheee);
|
|
double log_cosh = log (cosh_deheee);
|
|
double de2=de*de; double ee2=ee*ee; double unSurCosh = 1. / cosh_deheee;
|
|
double bega_nmoins1 = pow(bega,n-1);
|
|
double bega_nmoins2 = pow(bega,n-2);
|
|
double tanh_deheee = tanh(deheee); double unSurtanh = 1. / tanh_deheee;
|
|
double seSur_x3 = 0.;
|
|
if (se != 0.) {seSur_x3 = se / (x * x * x);}
|
|
ret = de2 * ee2 * al * bega_n * unSurCosh * unSurCosh
|
|
+ de * ee * al * n * ga * bega_nmoins1 * (tanh_deheee + unSurtanh)
|
|
+ al * n * ga * ga * (n-1) * bega_nmoins2 * log_cosh
|
|
+ 2. * ke * seSur_x3;
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la derivee seconde de la fonction ln_cosh pour la valeur x= "<< x
|
|
<< " on retourne 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
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_ln_cosh::Valeur_stricte(double x)
|
|
{ Valbool ret; // def de la valeur de retour
|
|
try
|
|
{
|
|
if (x < ax)
|
|
{double seSurax = 0.;
|
|
if (se != 0.) seSurax = se / ax;
|
|
ret.valeur = al * pow((be + ga * ax),n) * log (cosh(de *(he+ ee * ax)))+ ke * (ge+re * ax+seSurax);
|
|
ret.dedans = false;
|
|
}
|
|
else if (x > bx)
|
|
{double seSurbx = 0.;
|
|
if (se != 0.) seSurbx = se / bx;
|
|
ret.valeur = al * pow((be + ga * bx),n) * log (cosh(de *(he+ ee * bx)))+ ke * (ge+re * bx+seSurbx);
|
|
ret.dedans = false;
|
|
}
|
|
else {double seSurx = 0.;
|
|
if (se != 0.) seSurx = se / x;
|
|
ret.valeur = al * pow((be + ga * x),n) * log (cosh(de *(he+ ee * x)))+ ke * (ge+re * x+seSurx);
|
|
ret.dedans = true;
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la fonction ln_cosh pour la valeur x= "<< x
|
|
<< " on retourne 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// 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_ln_cosh::Valeur_Et_derivee_stricte(double x)
|
|
{ ValDerbool ret; // def de la valeur de retour
|
|
|
|
try
|
|
{
|
|
if (x < ax) {double bega = be + ga * ax; double bega_n = pow((be + ga * ax),n);
|
|
double deheee = de *(he+ ee * ax); double cosh_deheee = cosh(deheee);
|
|
double seSurax = 0.; double seSur_ax2 = 0.;
|
|
if (se != 0.) {seSurax = se / ax; seSur_ax2 = seSurax / ax;}
|
|
ret.valeur = al * bega_n * log (cosh_deheee)+ ke * (ge+re * ax+seSurax);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_ax2);
|
|
ret.dedans = false;}
|
|
else if (x > bx)
|
|
{double bega = be + ga * bx; double bega_n = pow((be + ga * bx),n);
|
|
double deheee = de *(he+ ee * bx); double cosh_deheee = cosh(deheee);
|
|
double seSurbx = 0.; double seSur_bx2 = 0.;
|
|
if (se != 0.) {seSurbx = se / bx; seSur_bx2 = seSurbx / bx;}
|
|
ret.valeur = al * bega_n * log (cosh_deheee)+ ke * (ge+re * bx+seSurbx);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_bx2);
|
|
ret.dedans = false;}
|
|
else {double bega = be + ga * x; double bega_n = pow((be + ga * x),n);
|
|
double deheee = de *(he+ ee * x); double cosh_deheee = cosh(deheee);
|
|
double seSurx = 0.; double seSur_x2 = 0.;
|
|
if (se != 0.) {seSurx = se / x; seSur_x2 = seSurx / x;}
|
|
ret.valeur = al * bega_n * log (cosh_deheee)+ ke * (ge+re * x+seSurx);
|
|
ret.derivee = de * ee * al * bega_n * tanh(deheee)
|
|
+ al * n * ga * pow(bega,(n-1)) * log(cosh_deheee)
|
|
+ ke * (re-seSur_x2);
|
|
ret.dedans = true;};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n ** erreur dans le calcul de la fonction ln_cosh et de sa derivee pour la valeur x= "<< x
|
|
<< " on retourne 0 et 0 ce qui peut conduite a des erreurs !! "<<endl ;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
//----- 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_ln_cosh::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_ln_cosh")
|
|
{ cout << "\n erreur dans la vérification du type de courbe lue ";
|
|
cout << "\n Courbe_ln_cosh::Lecture_base_info(... ";
|
|
Sortie(1);
|
|
}
|
|
// lecture des infos
|
|
ent >> nom >> ax >> nom >> bx >> nom >> al >> nom >> be
|
|
>> nom >> ga >> nom >> n >> nom >> de >> nom >> he
|
|
>> nom >> ee >> nom >> ke >> nom >> ge >> nom >> re
|
|
>> nom >> se ;
|
|
}
|
|
};
|
|
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void Courbe_ln_cosh::Ecriture_base_info(ofstream& sort,const int cas)
|
|
{ // on n'a que des grandeurs constantes
|
|
if (cas == 1)
|
|
{ sort << " Courbe_ln_cosh ";
|
|
sort << "\n a=" << ax << " b= " << bx << " " ;
|
|
sort << " al= " << al << " be= " << be << " ga= " << ga
|
|
<< " n= " << n << " de= " << de << " he= " << he
|
|
<< " ee= " << ee << " ke= " << ke << " ge= " << ge << " re= " << re
|
|
<< " se= " << se << " ";
|
|
}
|
|
};
|
|
|
|
// sortie du schemaXML: en fonction de enu
|
|
void Courbe_ln_cosh::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;
|
|
}
|
|
};
|
|
};
|
|
|