Herezh_dev/herezh_pp/Util/Courbes/F_union_1D.cc

800 lines
34 KiB
C++
Raw Normal View History

// 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 "F_union_1D.h"
#include "Sortie.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "CharUtil.h"
// CONSTRUCTEURS :
F_union_1D::F_union_1D(string nom) :
Courbe1D(nom,F_UNION_1D),Fi(),Xi(),nom_courbei(),indice_precedant(1)
{};
// de copie
F_union_1D::F_union_1D(const F_union_1D& Co) :
Courbe1D(Co),indice_precedant(Co.indice_precedant)
,Fi(Co.Fi),Xi(Co.Xi),nom_courbei(Co.nom_courbei)
{ // création des courbes locales que si elles étaient déjà locales
int tai = Fi.Taille();
for (int i=1;i<= tai; i++)
if (Co.Fi(i)->NomCourbe() == "_")
{Fi(i)=Courbe1D::New_Courbe1D(*(Co.Fi(i)));};
};
// de copie à partir d'une instance générale
F_union_1D::F_union_1D(const Courbe1D& Coo) :
Courbe1D(Coo)
{ if (Coo.Type_courbe() != F_UNION_1D)
{ cout << "\n erreur dans le constructeur de copie pour une courbe F_UNION_1D "
<< " a partir d'une instance générale ";
cout << "\n F_union_1D::F_union_1D(const Courbe1D& Co) ";
Sortie(1);
};
// définition des données
F_union_1D & Co = (F_union_1D&) Coo;
indice_precedant=Co.indice_precedant;
Fi=Co.Fi;
Xi=Co.Xi;
nom_courbei = Co.nom_courbei;
int tai = Fi.Taille();
// création des courbes locales que si elles étaient déjà locales
for (int i=1;i<= tai; i++)
if (Co.Fi(i)->NomCourbe() == "_")
{Fi(i)=Courbe1D::New_Courbe1D(*(Co.Fi(i)));};
};
// DESTRUCTEUR :
F_union_1D::~F_union_1D()
{ // on efface les courbes que si c'est des courbes locales
int tai = Fi.Taille();
for (int i=1;i<= tai; i++)
if ((Fi(i) != NULL)&&(nom_courbei(i)=="i_interne_i")) delete Fi(i);
};
// METHODES PUBLIQUES :
// --------- virtuelles ---------
// affichage de la courbe
void F_union_1D::Affiche() const
{ cout << "\n courbe composee : F_union_1D : nom_ref= " << nom_ref;
int tai = Fi.Taille();
// on parcours toutes les courbes
for (int i=1;i<= tai; i++)
{ cout << "\n intervalle: [" << Xi(i) <<","<<Xi(i+1)<<"] ";
// si c'est une courbe interne on l'affiche globalement
// si c'est une courbe globale, on n'affiche que son nom
cout << ", fonction de base: " << i << " ";
if (Fi(i)->NomCourbe() == "_") {Fi(i)->Affiche();}
else {cout << Fi(i)->NomCourbe() << " ";};
};
cout << "\n permet_affichage: " << permet_affichage;
cout << "\n ----- fin fonction F_union_1D ----- ";
};
// vérification que tout est ok, pres à l'emploi
// ramène true si ok, false sinon
bool F_union_1D::Complet_courbe()const
{ bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
// puis les variables propres, il faut au moins une courbe
if (Fi.Taille() == 0)
ret = false;
if (!ret && (ParaGlob::NiveauImpression() >0))
{ cout << "\n ***** la courbe n'est pas complete (aucune courbe de base n'existe) ";
this->Affiche();
};
return ret;
} ;
// dans le cas où les courbes membres sont des courbes externes
// fonction pour les définir
// les courbes sont défini en interne que si les courbes argument sont elles même
// des courbes locales. c'est-à-dire si FFi(i)->NomCourbe() ="_" alors on recrée une courbe
// interne avec new pour Fi(i), sinon Fi(i)=FFi(i) et pas de création;
// dans le cas où FFi(i) est NULL on passe, pas de traitement pour ce pointeur
void F_union_1D::DefCourbesMembres(Tableau <Courbe1D* >& FFi)
{ // l'objectif est
// 1) d'adapter le nombre de courbe à celui de FFi
// 2) de ne changer que celle qui sont non nul dans FFi
int tai = Fi.Taille(); // taille existante
int taii = FFi.Taille(); // taille du nouveau tableau
// on commence par effacer les courbes existantes supérieur à taii
if (taii < tai)
for (int i=taii;i<= tai; i++)
if ((Fi(i) != NULL)&&(nom_courbei(i)=="i_interne_i"))
{ delete Fi(i);Fi(i)=NULL;};
// on change de taille
Fi.Change_taille(taii);
tai = taii;
for (int i=1;i<= tai; i++)
{ // création d'une courbe locale que si elle était déjà locales
if (FFi(i) != NULL)
{if (FFi(i)->NomCourbe() == "_") // cas où FFi(i) est une courbe non globale
{ if (Fi(i)==NULL)
// cas où la courbe locale n'est pas défini mais on veut une courbe interne
{ Fi(i)=Courbe1D::New_Courbe1D(*(FFi(i)));nom_courbei(i)="i_interne_i";}
else if (Fi(i)->NomCourbe() == "_")
// cas où la courbe F1 est local et on veut la remplacer par une nouvelle locale
{ delete Fi(i);
Fi(i)=Courbe1D::New_Courbe1D(*(FFi(i)));nom_courbei(i)="i_interne_i";
}
else
// cas où la courbe Fi(i est global et on veut la remplacer par une locale
{ Fi(i)=Courbe1D::New_Courbe1D(*(FFi(i)));nom_courbei(i)="i_interne_i";};
}
else // cas ou FFi(i) est une courbe globale
{ if (Fi(i)==NULL)
// cas où la courbe locale n'est pas défini
{ Fi(i)=FFi(i);nom_courbei(i)="e_externe_e";}
else if (Fi(i)->NomCourbe() == "_")
// cas où la courbe Fi(i) est local et on veut la remplacer par une globale
{ delete Fi(i);
Fi(i)=FFi(i);nom_courbei(i)="e_externe_e";
}
else
// cas où la courbe Fi(i) est global et on veut la remplacer par une globale
{ Fi(i)=FFi(i);nom_courbei(i)="e_externe_e";};
};
};
};
};
// 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 F_union_1D::LectDonnParticulieres_courbes(const string& nom,UtilLecture * entreePrinc)
{ // entête de la courbe
if (nom == "") { *(entreePrinc->entree) >> nom_ref;}
else {nom_ref=nom;};
// lecture de la courbe interne
entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne
// on lit les courbes et les intervalles à suivre jusqu'au mot de fin de courbe
list < Courbe1D* > li_Fi; // un liste intermédiaire pour faciliter la lecture
list <double > li_Xi;
list <string > li_nom_courbei;
// on commence par lire éventuellement la borne inférieure du domaine de définition
string toto;
double xmin=-ConstMath::tresgrand; // par défaut
if(strstr(entreePrinc->tablcar,"Xmin=")!=0)
{ *(entreePrinc->entree) >> toto >> xmin;
if (toto != "Xmin=")
{ cout << "\n erreur en lecture de la borne inferieure "
<< " on attendait la chaine: Xmin= et on a lue: " << toto;
entreePrinc->MessageBuffer("**erreur F_union_1D::LectureDonneesParticulieres**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
li_Xi.push_back(xmin); // enregistrement
// maintenant lecture courante
string nom_indicateur;
do
{ // tout d'abord lecture de la courbe
string toto,nom_lu,nom_courbe;
Courbe1D* F=NULL;
*(entreePrinc->entree) >> nom_indicateur >> nom_lu;
// vérif
if (nom_indicateur != "courbe=" )
{ cout << "\n erreur en lecture du nom de courbe "
<< " on attendait la chaine: courbe= et on a lue: " << nom_indicateur;
entreePrinc->MessageBuffer("**erreur F_union_1D::LectureDonneesParticulieres**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// on regarde si la courbe1 existe, si oui on récupère la référence
if (Type_EnumCourbe1D_existe(nom_lu))
// cas ou c'est un nom de type de courbe -> lecture directe
{ nom_courbe = "_"; // on signale que c'est une courbe interne
F = Courbe1D::New_Courbe1D(nom_courbe,Id_Nom_Courbe1D (nom_lu.c_str()));
// lecture de la courbe
F->LectDonnParticulieres_courbes (nom_courbe,entreePrinc);
nom_courbe="i_interne_i";
entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne
}
else
// sinon on retiend le nom pour une complétion future
{nom_courbe = nom_lu;};
// stockage
li_Fi.push_back(F); li_nom_courbei.push_back(nom_courbe);
// lecture maintenant de la fin de l'intervalle
double xmax=ConstMath::tresgrand; // par défaut
bool fin_lecture=false;
if (strstr(entreePrinc->tablcar,"Xmax=")!=0)
{*(entreePrinc->entree) >> nom_indicateur >> xmax;
// vérif
if (nom_indicateur != "Xmax=" )
{ cout << "\n erreur en lecture de la borne maxi de l'intervalle "
<< " on attendait la chaine: Xmax= et on a lue: " << nom_indicateur;
entreePrinc->MessageBuffer("**erreur F_union_1D::LectureDonneesParticulieres**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
}
else // sinon ça doit-être la dernière lecture
{fin_lecture = true;};
li_Xi.push_back(xmax); // enregistrement
// on passe une ligne si on n'est pas déjà à la fin et on vérifie que ce n'est pas finie
if (strstr(entreePrinc->tablcar,"fin_courbe_union")==0)
entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne
// on regarde s'il n'y a pas un niveau d'affichage particulier
if (strstr(entreePrinc->tablcar,"permet_affichage_")!=0)
{ int val_defaut = 0;int min=10;int max=0; // min > max -> pas pris en compte
string nom_class_methode("F_union_1D::LectureDonneesParticulieres");
string mot_cle("permet_affichage_");
if (entreePrinc->Lecture_un_parametre_int(val_defaut,nom_class_methode
,min,max,mot_cle,permet_affichage))
entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne
};
if (fin_lecture && (strstr(entreePrinc->tablcar,"fin_courbe_union")==0))
{ cout << "\n erreur en lecture de la borne maxi de l'intervalle "
<< " le mot cle Xmax= est obligatoire sauf pour la derniere fonction ";
entreePrinc->MessageBuffer("**erreur F_union_1D::LectureDonneesParticulieres**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
} while (strstr(entreePrinc->tablcar,"fin_courbe_union")==0);
// on met en tableau
int tai = li_Fi.size();
Fi.Change_taille(tai);
Xi.Change_taille(tai+1);
nom_courbei.Change_taille(tai);
list < Courbe1D* >::iterator ili,ilifin= li_Fi.end();
list <double >::iterator xli= li_Xi.begin();
Xi(1)=*xli;xli++; //la borne inférieure
list <string >::iterator sli= li_nom_courbei.begin();
int ia=1;
for (ili=li_Fi.begin();ili!=ilifin;ili++,xli++,sli++,ia++)
{Fi(ia)=*ili;Xi(ia+1)=*xli;nom_courbei(ia)=*sli;}
};
// 1) renseigne si la courbe dépend d'autre courbe ou non
bool F_union_1D::DependAutreCourbes() const
{ bool ret=false;
int tai = Fi.Taille();
for (int i=1;i<=tai;i++)
if(Fi(i) == NULL) {ret=true;}
else if (nom_courbei(i)!="i_interne_i") {ret=true;};
return ret;
};
// 2) retourne une liste de nom correspondant aux noms de courbes dont dépend *this
list <string>& F_union_1D::ListDependanceCourbes(list <string>& lico) const
{ // tout d'abord on vide la liste passée en paramètres
if (lico.size() != 0) lico.erase(lico.begin(),lico.end());
// on remplit en fonction de l'état
int tai = Fi.Taille();
for (int i=1;i<=tai;i++)
if(Fi(i) == NULL) lico.push_back(nom_courbei(i));
return lico;
};
// 3) établit la connection entre la demande de *this et les courbes passées en paramètres
void F_union_1D::Lien_entre_courbe (list <Courbe1D *>& liptco)
{ int tai = Fi.Taille();
Tableau <Courbe1D *> tab_Fi(tai); // def à null par défaut
for (int i=1;i<=tai;i++)
if(Fi(i) == NULL)
{list <Courbe1D *>::iterator ili,ilifin=liptco.end();
for (ili=liptco.begin();ili!=ilifin;ili++)
if ((*ili)->NomCourbe() == nom_courbei(i))
{tab_Fi(i)=(*ili);break;};
}
else // sinon la courbe existe déjà, on met le pointeur à Null
tab_Fi(i)=NULL;
// et on définit les courbes
this->DefCourbesMembres(tab_Fi);
};
// def info fichier de commande
void F_union_1D::Info_commande_Courbes1D(UtilLecture & entreePrinc)
{
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
sort << "\n#............................................"
<< "\n# il s'agit d'une fonction qui agglomere plusieurs fonctions deja existantes"
<< "\n# chaque fonction est defini sur un intervalle disjoint des autres "
<< "\n# Les intervalles doivent se suivre "
<< "\n# Xmin= precise la borne inferieur de definition de la fonction"
<< "\n# c'est un parametre facultatif, s'il manque, la borne inf est - l'infini"
<< "\n# ensuite il y a une liste de courbes: "
<< "\n# suivi chacune de la fin de l'intervalle correspondant"
<< "\n# ici cf1 est pour x appartenant a [-10,0[, cf2 est pour x appartenant a [0,10["
<< "\n# cf3 est pour x appartenant a [10,20["
<< "\n courbe_exemple F_UNION_1D "
<< "\n# Xmin= -10 courbe= cf1 Xmax= 0"
<< "\n# courbe= cf2 Xmax= 10"
<< "\n# courbe= cf3 Xmax= 20"
<< "\n# fin_courbe_union"
<< "\n# "
<< "\n# pour la dernier courbe il est possible de ne pas faire figurer Xmax=, dans"
<< "\n# ce cas, cela signifie que la borne finale est l'infini"
<< "\n# enfin, si la valeur de x est en dehors de l'intervalle, on applique la premiere"
<< "\n (x<Xmin) ou la derniere fonction (x>Xmax) "
<< endl;
};
// ramène la valeur
double F_union_1D::Valeur(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
return Fi(1)->Valeur(x);
};
int tai = Fi.Taille();
int taiPlusUn = tai + 1;
if (x > Xi(taiPlusUn))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
return Fi(tai)->Valeur(x);
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
{for (int indic=indice_precedant;indic < taiPlusUn;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
}
else // sinon il est inférieur
{for (int indic = 1; indic <indice_precedant;indic++)
if (x < Xi(indic+1)) {trouve=true;indice = indic; break;};
};
//
//
// // sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// // on repart à partir de 0 !! ***** a optimiser par dichotomie *****
// if (!trouve)
// { // cas où on n'a pas trouver après l'indice
// for (int indic = 1; indic <indice_precedant;indic++)
// if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
// };
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n double F_union_1D::Valeur(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du y
indice_precedant = indice;
return Fi(indice)->Valeur(x);
};
// ramène la valeur et la dérivée en paramètre
Courbe1D::ValDer F_union_1D::Valeur_Et_derivee(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
return Fi(1)->Valeur_Et_derivee(x);
};
int tai = Fi.Taille();
if (x > Xi(tai+1))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
return Fi(tai)->Valeur_Et_derivee(x);
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
for (int indic=indice_precedant;indic<=tai;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
// sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// on repart à partir de 0 !! ***** a optimiser par dichotomie *****
if (!trouve)
{ // cas où on n'a pas trouver après l'indice
for (int indic = 1; indic <indice_precedant;indic++)
if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
};
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n Courbe1D::ValDer F_union_1D::Valeur_Et_derivee(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du retour
indice_precedant = indice;
return Fi(indice)->Valeur_Et_derivee(x);
};
// ramène la dérivée
double F_union_1D::Derivee(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
return Fi(1)->Derivee(x);
};
int tai = Fi.Taille();
if (x > Xi(tai+1))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
return Fi(tai)->Derivee(x);
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
for (int indic=indice_precedant;indic<=tai;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
// sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// on repart à partir de 0 !! ***** a optimiser par dichotomie *****
if (!trouve)
{ // cas où on n'a pas trouver après l'indice
for (int indic = 1; indic <indice_precedant;indic++)
if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
};
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n double F_union_1D::Derivee(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du retour
indice_precedant = indice;
return Fi(indice)->Derivee(x);
};
// ramène la valeur et les dérivées première et seconde en paramètre
Courbe1D::ValDer2 F_union_1D::Valeur_Et_der12(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
return Fi(1)->Valeur_Et_der12(x);
};
int tai = Fi.Taille();
if (x > Xi(tai+1))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
return Fi(tai)->Valeur_Et_der12(x);
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
for (int indic=indice_precedant;indic<=tai;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
// sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// on repart à partir de 0 !! ***** a optimiser par dichotomie *****
if (!trouve)
{ // cas où on n'a pas trouver après l'indice
for (int indic = 1; indic <indice_precedant;indic++)
if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
};
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n Courbe1D::ValDer F_union_1D::Valeur_Et_derivee(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du retour
indice_precedant = indice;
return Fi(indice)->Valeur_Et_der12(x);
};
// ramène la dérivée seconde
double F_union_1D::Der_sec(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
return Fi(1)->Der_sec(x);
};
int tai = Fi.Taille();
if (x > Xi(tai+1))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
return Fi(tai)->Der_sec(x);
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
for (int indic=indice_precedant;indic<=tai;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
// sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// on repart à partir de 0 !! ***** a optimiser par dichotomie *****
if (!trouve)
{ // cas où on n'a pas trouver après l'indice
for (int indic = 1; indic <indice_precedant;indic++)
if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
};
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n double F_union_1D::Derivee(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du retour
indice_precedant = indice;
return Fi(indice)->Der_sec(x);
};
// 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 F_union_1D::Valeur_stricte(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
Valbool ret = Fi(1)->Valeur_stricte(x);
ret.dedans = false;
return ret;
};
int tai = Fi.Taille();
if (x > Xi(tai+1))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
Valbool ret = Fi(tai)->Valeur_stricte(x);
ret.dedans = false;
return ret;
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
for (int indic=indice_precedant;indic<=tai;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
// sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// on repart à partir de 0 !! ***** a optimiser par dichotomie *****
if (!trouve)
{ // cas où on n'a pas trouver après l'indice
for (int indic = 1; indic <indice_precedant;indic++)
if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
};
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n double F_union_1D::Derivee(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du retour
indice_precedant = indice;
Valbool ret = Fi(indice)->Valeur_stricte(x);
ret.dedans = true;
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 F_union_1D::Valeur_Et_derivee_stricte(double x)
{ // on commence par chercher l'intervalle qui contient x
//tout d'abord on regarde s'il est en dehors des bornes
// si oui on lui donne
if (x < Xi(1))
{indice_precedant=1;
ValDerbool ret = Fi(1)->Valeur_Et_derivee_stricte(x);
ret.dedans = false;
return ret;
};
int tai = Fi.Taille();
if (x > Xi(tai+1))
{indice_precedant=1; // comme c'est le dernier intervalle on met à 1 car
// de toute manière cela ne sert à rien de continuer
ValDerbool ret = Fi(tai)->Valeur_Et_derivee_stricte(x);
ret.dedans = false;
return ret;
};
// maintenant on cherche le couple de xi qui encadre le x
int indice=0;bool trouve=false;
// on commence tout d'abord à chercher à partir du précédent indice
// s'il est supérieur au xi de l'indice existant, l'algo qui suit est ok
if (x >= Xi(indice_precedant))
for (int indic=indice_precedant;indic<=tai;indic++)
if (x < Xi(indic+1)) {trouve=true;indice=indic; break;};
// sinon cela veut dire qu'il se trouve dans les xi plus bas que l'indice
// on repart à partir de 0 !! ***** a optimiser par dichotomie *****
if (!trouve)
{ // cas où on n'a pas trouver après l'indice
for (int indic = 1; indic <indice_precedant;indic++)
if (x <= Xi(indic+1)) {trouve=true;indice = indic; break;};
};
// gestion d'erreur
if (!trouve)
{ cout << "\n erreur : on ne trouve pas la valeur demandee a l'aide de la courbe F_union_1D "
<< "\n x demandee: " << x
<< "\n F_union_1D::Valeur_Et_derivee_stricte(double x) ";
cout << "\n" << Nom_Courbe1D(this->Type_courbe()) << " : nom_ref= " << nom_ref;
Sortie(1);
};
// calcul du retour
indice_precedant = indice;
ValDerbool ret = Fi(indice)->Valeur_Et_derivee_stricte(x);
ret.dedans = true;
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 F_union_1D::Lecture_base_info(ifstream& ent,const int cas)
{ // on n'a que des grandeurs constantes
if (cas == 1)
{ string nom;
ent >> nom; // "\n <F_UNION_1D> "
// string nom1=nom.substr(nom.find(<)+1,nom.find(>)-1);
// lecture et vérification de l'entête
string type_courbe_a_lire('<'+Nom_Courbe1D(this->Type_courbe())+'>');
if (nom != type_courbe_a_lire) //"F_union_1D")
{ cout << "\n erreur dans la verification du type de courbe lue ";
cout << "\n courbe en lecture: " << type_courbe_a_lire;
cout << "\n F_union_1D::Lecture_base_info(... ";
Sortie(1);
}
// lecture du nombre de courbe
int tai=0;
ent >> nom >> tai;
Fi.Change_taille(tai);
Xi.Change_taille(tai+1);
nom_courbei.Change_taille(tai);
// lecture de la borne inf
ent >> nom >> Xi(1);
// lecture des courbes et des bornes
string nom1,nom2,nom3;
for (int i=1;i<=tai;i++)
{ // lecture de la courbe
ent >> nom1 >> nom2 >> nom3;
if (nom1 != "courbe=")
{ cout << "\n erreur dans la verification du type, on attendait le mot cle courbe= "
<< " et on a lu " << nom1 << " ";
cout << "\n F1_rond_F2::Lecture_base_info(... ";
Sortie(1);
}
else
{ if (nom2 == "COURBE_INTERNE")
{// cas d'une courbe en interne
// 1) on commence par effacer la courbe existante si nécessaire
if (Fi(i) != NULL) {if (Fi(i)->NomCourbe() == "_") delete Fi(i);};
// 2) on crée la courbe adoc
nom2="_";
Fi(i) = Courbe1D::New_Courbe1D(nom2,Id_Nom_Courbe1D (nom3.c_str()));
// 3) on lit les données particulières
Fi(i)->Lecture_base_info(ent,cas);
nom_courbei(i)="i_interne_i";
}
else
{// cas d'une courbe externe on lit le nom
nom_courbei(i) = nom2;
};
};
// lecture de la borne max pour la fonction i
ent >> nom1 >> Xi(i+1);
};
// lecture du niveau d'affichage
ent >> nom >> permet_affichage;
// on lit le tag de fin de définition
ent >> nom; // <F_UNION_1D>
}
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void F_union_1D::Ecriture_base_info(ofstream& sort,const int cas)
{ // on n'a que des grandeurs constantes
if (cas == 1)
{ sort << "\n <F_UNION_1D> ";
int tai = Fi.Taille();
sort << " nbcourbe= " << tai << " "; // le nombre de courbes
// la borne mini
sort << " Xmin= " << Xi(1)<< " ";
// on balaie les courbes
for (int i=1;i<=tai;i++)
{if (Fi(i)->NomCourbe() == "_")
{// cas d'une courbe interne
sort << "\n courbe= COURBE_INTERNE " << Fi(i)->Type_courbe();
Fi(i)->Ecriture_base_info(sort,cas);
}
else
// cas d'une courbe externe
{sort << "\n courbe= " << Fi(i)->NomCourbe() << " " << Fi(i)->Type_courbe();};
// la borne max pour la fonction i
sort << " Xmax= " << Xi(i+1) << " ";
};
sort << "\n permet_affichage: " << permet_affichage;
sort << "\n </F_UNION_1D> ";
}
};
// sortie du schemaXML: en fonction de enu
void F_union_1D::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{/*sort << "\n <!-- *************************** F_UNION_1D *************************** -->"
<< "\n <!-- def d'un type contenant une valeur et un boolean -->"
<< "\n <xs:complexType name=\"valeurPlusBooleen\">"
<< "\n <xs:simpleContent>"
<< "\n <xs:extension base=\"xs:double\">"
<< "\n <xs:attribute name=\"present\" type=\"xs:boolean\" />"
<< "\n </xs:extension>"
<< "\n </xs:simpleContent> "
<< "\n </xs:complexType>"
<< "\n <!-- maintenant le type de la courbe -->"
<< "\n<xs:complexType name=\"F_UNION_1D\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> courbe F_UNION_1D constituee de N points </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"derivee_initiale_\" type=\"valeurPlusBooleen\" />"
<< "\n <xs:element name=\"derivee_finale_\" type=\"valeurPlusBooleen\" />"
<< "\n <xs:element name=\"les_points\" type=\"COORDONNEE_2\" minOccurs='0' maxOccurs=\"unbounded\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";*/
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
};
};