// 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 "CourbePolynomiale.h"
#include "Sortie.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "CharUtil.h"
#include "ParaGlob.h"


    // CONSTRUCTEURS :
CourbePolynomiale::CourbePolynomiale(string nom) :
 Courbe1D(nom,COURBEPOLYNOMIALE),coef()
  {};
    
    // de copie
CourbePolynomiale::CourbePolynomiale(const CourbePolynomiale& Co) :
 Courbe1D(Co),coef(Co.coef)
  {};
    // de copie à partir d'une instance générale
CourbePolynomiale::CourbePolynomiale(const Courbe1D& Coo) :
 Courbe1D(Coo)
  { if (Coo.Type_courbe() != COURBEPOLYNOMIALE)
      { cout << "\n erreur dans le constructeur de copie pour une courbe COURBEPOLYNOMIALE "
             << " à partir d'une instance générale ";
        cout << "\n CourbePolynomiale::CourbePolynomiale(const Courbe1D& Co) ";
           Sortie(1);          
          };
    // définition des données
    CourbePolynomiale & Co = (CourbePolynomiale&) Coo;
    coef = Co.coef;       
  };

    // DESTRUCTEUR :
CourbePolynomiale::~CourbePolynomiale() 
  {};
    
    // METHODES PUBLIQUES :
    
    // --------- virtuelles ---------
    
    // affichage de la courbe
void CourbePolynomiale::Affiche() const 
  { cout << "\n CourbePolynomiale : nom_ref= " << nom_ref;
    cout << "\n coef=" << coef << " ";
   };

    // vérification que tout est ok, pres à l'emploi
    // ramène true si ok, false sinon
bool CourbePolynomiale::Complet_courbe()const
 { bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
   // puis les variables propres
   if (coef.Taille() == 0) ret = false;
   if (!ret && (ParaGlob::NiveauImpression() >0))
      { cout << "\n ***** la courbe n'est pas complete ";
        this->Affiche();
        };
   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 CourbePolynomiale::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 l'entête
     string ncoe; 
     // tout d'abord on passe le mot clé
     *(entreePrinc->entree) >> ncoe;
//     if(strstr(entreePrinc->tablcar,"debut_coef=")==0)
     if(ncoe != "debut_coef=")
         { cout << "\n erreur en lecture de l'entete des coefficients "
                << " on attendait la chaine: debut_coef= et on a lue "<< ncoe;
           entreePrinc->MessageBuffer("**erreur1 CourbePolynomiale::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          }
     // lecture des coeffs
     list <double> list_coef; // pour la lecture  
     try
      { *(entreePrinc->entree) >> ncoe; 
        while (ncoe != "fin_coef")
         { double co = ChangeReel(ncoe);
           list_coef.push_back(co);
            *(entreePrinc->entree) >> ncoe;
           }
        }
     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 en lecture des coefficients du polynome "
                << " a la suite du mot cle debut_coef= on attendait n coefficient suivi du mot cle"
                << " fin_coef et on lue "<< ncoe;
           entreePrinc->MessageBuffer("**erreur1 CourbePolynomiale::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          }
     // définition du tableau 
     int taille = list_coef.size();
     coef.Change_taille(taille);
     list <double>::iterator il = list_coef.begin();
     for (int i=1;i<= taille;i++,il++)
       coef(i)=(*il);   
   };
    
// def info fichier de commande
void CourbePolynomiale::Info_commande_Courbes1D(UtilLecture & entreePrinc) 
  {  
     ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
     sort << "\n#............................................"
          << "\n# exemple de definition d'une courbe COURBEPOLYNOMIALE" 
          << "\n#"
          << "\n courbe_exemple    COURBEPOLYNOMIALE  # nom de la courbe puis le type de la courbe"
          << "\n      # def des coefficients  d'un polynome du troisieme degre 1+3x+6x^2+8x^3"
          << "\n      debut_coef=  1.   3.   6.  8.  fin_coef "
          << endl;
   };
        
    // ramène la valeur 
double CourbePolynomiale::Valeur(double x)  
  { double taille = coef.Taille();
    double vale = coef(taille);
    for (int i=taille-1;i> 0;i--)
      { vale = vale*x + coef(i);};
    return vale;
  };

    // ramène la valeur et la dérivée en paramètre
Courbe1D::ValDer CourbePolynomiale::Valeur_Et_derivee(double x)  
  {  ValDer ret; // def de la valeur de retour
     double taille = coef.Taille();
     // valeur
     ret.valeur = coef(taille);
     for (int i=taille-1;i> 0;i--)
      { ret.valeur = ret.valeur*x + coef(i);};
     // dérivée  
     ret.derivee = coef(taille) * (taille-1.);
     for (int i=taille-1;i> 1;i--)
        { ret.derivee = ret.derivee*x + coef(i) * (i-1.);};
    return ret;
   };
    
    // ramène la dérivée 
double CourbePolynomiale::Derivee(double x)  
  {  double taille = coef.Taille();
     double der = coef(taille) * (taille-1.);
     for (int i=taille-1;i> 1;i--)
        { der = der*x + coef(i) * (i-1.);};
     return der;
   };
        
    // ramène la valeur et les dérivées première et seconde en paramètre
Courbe1D::ValDer2 CourbePolynomiale::Valeur_Et_der12(double x)
  {  ValDer2 ret; // def de la valeur de retour
     double taille = coef.Taille();
     // valeur
     ret.valeur = coef(taille);
     for (int i=taille-1;i> 0;i--)
      { ret.valeur = ret.valeur*x + coef(i);};
     // dérivée  
     ret.derivee = coef(taille) * (taille-1.);
     for (int i=taille-1;i> 1;i--)
        { ret.derivee = ret.derivee*x + coef(i) * (i-1.);};
     // dérivée seconde
     ret.der_sec = coef(taille) * (taille-1.) * (taille-2.);
     for (int i=taille-1;i> 2;i--)
      { ret.der_sec = ret.der_sec*x + coef(i) * (i-1.) * (i-2.);
      };
    return ret;
   };
        
    // ramène la dérivée seconde
double CourbePolynomiale::Der_sec(double x)
  {  double taille = coef.Taille();
     double der2 = coef(taille) * (taille-1.) * (taille-2.);
     for (int i=taille-1;i> 2;i--)
        { der2 = der2*x + coef(i) * (i-1.) * (i-2.);};
     return der2;
   };
    
    // 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  CourbePolynomiale::Valeur_stricte(double x)  
  { Valbool ret; // def de la valeur de retour
    double taille = coef.Taille();
    // valeur
    ret.valeur = coef(taille);
    for (int i=taille-1;i> 0;i--)
      { ret.valeur = ret.valeur*x + coef(i);};
    // intervale de définition R    
    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  CourbePolynomiale::Valeur_Et_derivee_stricte(double x)  
  { ValDerbool ret; // def de la valeur de retour
    double taille = coef.Taille();
    // valeur
    ret.valeur = coef(taille);
    for (int i=taille-1;i> 0;i--)
      { ret.valeur = ret.valeur*x + coef(i);};
    // dérivée  
    ret.derivee = coef(taille) * (taille-1.);
    for (int i=taille-1;i> 1;i--)
        { ret.derivee = ret.derivee*x + coef(i) * (i-1.);};
    // intervale de définition R    
    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 CourbePolynomiale::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 != "COURBEPOLYNOMIALE")
         { cout << "\n erreur dans la vérification du type de courbe lue ";    
           cout << "\n CourbePolynomiale::Lecture_base_info(... ";
           Sortie(1); 
           } 
        // lecture des infos
        coef.Entree(ent);
       }
   };

    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void CourbePolynomiale::Ecriture_base_info(ofstream& sort,const int cas)
  { // on n'a que des grandeurs constantes
    if (cas == 1)
      { sort << " COURBEPOLYNOMIALE  ";
        coef.Sortir(sort);
       }
   };
         
// sortie du schemaXML: en fonction de enu 
void CourbePolynomiale::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;
		}
	};		
  };