// 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) . // // 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 . // // For more information, please consult: . /************************************************************************ * DATE: 30/05/2004 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: classes qui permettent de définir des identificateurs de * * grandeurs particulières héritants du TypeQuelconque. * * Ces idendificateurs sont prévue en particulier pour gérer * * les sorties de résultats. * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * $ * ************************************************************************/ #ifndef TYPE_QUELCONQUE_PARTICULIER_H #define TYPE_QUELCONQUE_PARTICULIER_H #include #include "EnumTypeGrandeur.h" #include "List_io.h" #include #include #include "TypeQuelconque.h" #include "Tenseur.h" #include "NevezTenseur.h" #include "Tableau_T.h" #include "Tableau2_T.h" #include "Ddl_etendu.h" #include "Fonction_nD.h" #include "Base.h" /** @defgroup Les_grandeurs_particulieres Les_grandeurs_particulieres * * BUT: classes qui permettent de définir des identificateurs de * grandeurs particulières héritants du TypeQuelconque. * Ces idendificateurs sont prévue en particulier pour gérer * les sorties de résultats. * * * \author Gérard Rio * \version 1.0 * \date 30/05/2004 * \brief Définition des grandeurs particulières. * */ //-------------------------------------------------------------------------------- //| définition des fonctions permettant la création de la grandeur particulière | //| en lecture après la lecture d'un énuméré de type particulier | //-------------------------------------------------------------------------------- TypeQuelconque::Grandeur* NevezGrandeurParticuliereEnLecture(EnuTypeQuelParticulier enu,istream & ent); /// @addtogroup Les_grandeurs_particulieres /// @{ /// ///---------------------------------------------------------------- /// grandeur par défaut: TypeQuelconque::Grandeur::Grandeur_defaut| ///---------------------------------------------------------------- class Grandeur_defaut : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_defaut & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_defaut & a) ; public: // constructeur par défaut Grandeur_defaut() {}; ~Grandeur_defaut() {}; TypeQuelconque::Grandeur* New_idem_grandeur() const; // ramène une grandeur identique, créée Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // ***** ici toutes ces opérations sont illicites !!! ******** // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val); // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // sortie de la grandeur brut sur sort // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return RIEN_TYPEGRANDEUR;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return RIEN_TYPE_QUELCONQUE_PARTICULIER;}; // change de repère de la grandeur si nécessaire void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) {}; // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------ /// grandeur TenseurHH: TypeQuelconque::Grandeur::Grandeur_TenseurHH| //------------------------------------------------------------------ class Grandeur_TenseurHH : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_TenseurHH;friend class Tab2_Grandeur_TenseurHH; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_TenseurHH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_TenseurHH & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Grandeur_TenseurHH(); // constructeur légal Grandeur_TenseurHH(const TenseurHH& tens): ptTens(NevezTenseurHH(tens)) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_TenseurHH(istream & ent); // constructeur de copie Grandeur_TenseurHH(const Grandeur_TenseurHH& a): ptTens(NevezTenseurHH(*a.ptTens)) {}; // destructeur ~Grandeur_TenseurHH(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_TenseurHH(*ptTens);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_TenseurHH & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; void operator+= (const Grandeur_TenseurHH& aa) {(*ptTens) += (*(aa.ptTens));}; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; void operator-= (const Grandeur_TenseurHH& aa) {(*ptTens) -= (*(aa.ptTens));}; // Surcharge de l'operateur *= void operator*= (double val) {*ptTens *= val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {*ptTens /= val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURHH;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TENSEURHH;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {ptTens->Inita(0.);}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode TenseurHH* ConteneurTenseur() const {return ptTens;}; // la référence est un peu plus sur (il est toujours possible de faire un delete sur un pointeur de ref // mais c'est plus difficile de le faire en se trompant ! enfin j'espère) TenseurHH& RefConteneurTenseur() const {return *ptTens;}; protected: TenseurHH* ptTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------ /// grandeur TenseurBB: TypeQuelconque::Grandeur::Grandeur_TenseurBB| //------------------------------------------------------------------ class Grandeur_TenseurBB : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_TenseurBB; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_TenseurBB & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_TenseurBB & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Grandeur_TenseurBB(); // constructeur légal Grandeur_TenseurBB(const TenseurBB& tens): ptTens(NevezTenseurBB(tens)) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_TenseurBB(istream & ent); // constructeur de copie Grandeur_TenseurBB(const Grandeur_TenseurBB& a): ptTens(NevezTenseurBB(*a.ptTens)) {}; // destructeur ~Grandeur_TenseurBB(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_TenseurBB(*ptTens);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_TenseurBB & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; void operator+= (const Grandeur_TenseurBB& aa) {(*ptTens) += (*(aa.ptTens));}; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; void operator-= (const Grandeur_TenseurBB& aa) {(*ptTens) -= (*(aa.ptTens));}; // Surcharge de l'operateur *= void operator*= (double val) {*ptTens *= val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {*ptTens /= val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURBB;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TENSEURBB;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {ptTens->Inita(0.);}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode TenseurBB* ConteneurTenseur() const {return ptTens;}; // la référence est un peu plus sur (il est toujours possible de faire un delete sur un pointeur de ref // mais c'est plus difficile de le faire en se trompant ! enfin j'espère) TenseurBB& RefConteneurTenseur() const {return *ptTens;}; protected: TenseurBB* ptTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------ /// grandeur TenseurBH: TypeQuelconque::Grandeur::Grandeur_TenseurBH| //------------------------------------------------------------------ class Grandeur_TenseurBH : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_TenseurBH; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_TenseurBH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_TenseurBH & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Grandeur_TenseurBH(); // constructeur légal Grandeur_TenseurBH(const TenseurBH& tens): ptTens(NevezTenseurBH(tens)) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_TenseurBH(istream & ent); // constructeur de copie Grandeur_TenseurBH(const Grandeur_TenseurBH& a): ptTens(NevezTenseurBH(*a.ptTens)) {}; // destructeur ~Grandeur_TenseurBH(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_TenseurBH(*ptTens);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_TenseurBH & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; void operator+= (const Grandeur_TenseurBH& aa) {(*ptTens) += (*(aa.ptTens));}; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; void operator-= (const Grandeur_TenseurBH& aa) {(*ptTens) -= (*(aa.ptTens));}; // Surcharge de l'operateur *= void operator*= (double val) {*ptTens *= val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {*ptTens /= val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURBH;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TENSEURBH;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta, const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {ptTens->Inita(0.);}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode // le pb avec le pointeur c'est que l'on peut faire un delete en erreur TenseurBH* ConteneurTenseur() const {return ptTens;}; // la référence est un peu plus sur (il est toujours possible de faire un delete sur un pointeur de ref // mais c'est plus difficile de le faire en se trompant ! enfin j'espère) TenseurBH& RefConteneurTenseur() const {return *ptTens;}; protected: TenseurBH* ptTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------ /// grandeur TenseurHB: TypeQuelconque::Grandeur::Grandeur_TenseurHB| //------------------------------------------------------------------ class Grandeur_TenseurHB : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_TenseurHB; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_TenseurHB & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_TenseurHB & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Grandeur_TenseurHB(); // constructeur légal Grandeur_TenseurHB(const TenseurHB& tens): ptTens(NevezTenseurHB(tens)) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_TenseurHB(istream & ent); // constructeur de copie Grandeur_TenseurHB(const Grandeur_TenseurHB& a): ptTens(NevezTenseurHB(*a.ptTens)) {}; // destructeur ~Grandeur_TenseurHB(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_TenseurHB(*ptTens);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_TenseurHB & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; void operator+= (const Grandeur_TenseurHB& aa) {(*ptTens) += (*(aa.ptTens));}; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; void operator-= (const Grandeur_TenseurHB& aa) {(*ptTens) -= (*(aa.ptTens));}; // Surcharge de l'operateur *= void operator*= (double val) {*ptTens *= val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {*ptTens /= val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURHB;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TENSEURHB;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {ptTens->Inita(0.);}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode // le pb avec le pointeur c'est que l'on peut faire un delete en erreur TenseurHB* ConteneurTenseur() const {return ptTens;}; // la référence est un peu plus sur (il est toujours possible de faire un delete sur un pointeur de ref // mais c'est plus difficile de le faire en se trompant ! enfin j'espère) TenseurHB& RefConteneurTenseur() const {return *ptTens;}; protected: TenseurHB* ptTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de TenseurHH: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurHH| /// tous les tenseurs doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_TenseurHH : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_TenseurHH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurHH & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Tab_Grandeur_TenseurHH(); // constructeur légal // nb indique le nombre de tenseur Tab_Grandeur_TenseurHH( TenseurHH& tens,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_TenseurHH(istream & ent); // constructeur de copie Tab_Grandeur_TenseurHH(const Tab_Grandeur_TenseurHH& a) ; // destructeur ~Tab_Grandeur_TenseurHH(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_TenseurHH(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_TenseurHH & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURHH;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_TENSEURHH;}; // acces au tenseur de numéro i en lecture écriture TenseurHH& operator () ( int i)const {return (*(tabTens(i)->ptTens));}; // ramène la grandeur_Tenseur associée const Grandeur_TenseurHH& Grandeur_TenseurHH_associee(int i) const {return *(tabTens(i));}; // ramène la dimension du tableau de tenseur int Taille() const {return tabTens.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_TenseurHH, d'où la nécessité d'une construction // en deux temps !! Tableau tabTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de TenseurBH: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurBH| /// tous les tenseurs doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_TenseurBH : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_TenseurBH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurBH & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Tab_Grandeur_TenseurBH(); // constructeur légal // nb indique le nombre de tenseur Tab_Grandeur_TenseurBH( TenseurBH& tens,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_TenseurBH(istream & ent); // constructeur de copie Tab_Grandeur_TenseurBH(const Tab_Grandeur_TenseurBH& a) ; // destructeur ~Tab_Grandeur_TenseurBH(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_TenseurBH(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_TenseurBH & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURBH;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_TENSEURBH;}; // acces au tenseur de numéro i en lecture écriture TenseurBH& operator () ( int i)const {return (*(tabTens(i)->ptTens));}; // ramène la grandeur_Tenseur associée const Grandeur_TenseurBH& Grandeur_TenseurBH_associee(int i) const {return *(tabTens(i));}; // ramène la dimension du tableau de tenseur int Taille() const {return tabTens.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_TenseurBH, d'où la nécessité d'une construction // en deux temps !! Tableau tabTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de TenseurBB: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurBB| /// tous les tenseurs doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_TenseurBB : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_TenseurBB & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurBB & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Tab_Grandeur_TenseurBB(); // constructeur légal // nb indique le nombre de tenseur Tab_Grandeur_TenseurBB( TenseurBB& tens,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_TenseurBB(istream & ent); // constructeur de copie Tab_Grandeur_TenseurBB(const Tab_Grandeur_TenseurBB& a) ; // destructeur ~Tab_Grandeur_TenseurBB(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_TenseurBB(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_TenseurBB & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURBB;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_TENSEURBB;}; // acces au tenseur de numéro i en lecture écriture TenseurBB& operator () ( int i)const {return (*(tabTens(i)->ptTens));}; // ramène la grandeur_Tenseur associée const Grandeur_TenseurBB& Grandeur_TenseurBB_associee(int i) const {return *(tabTens(i));}; // ramène la dimension du tableau de tenseur int Taille() const {return tabTens.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_TenseurBB, d'où la nécessité d'une construction // en deux temps !! Tableau tabTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de TenseurHB: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurHB /// tous les tenseurs doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_TenseurHB : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_TenseurHB & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurHB & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Tab_Grandeur_TenseurHB(); // constructeur légal // nb indique le nombre de tenseur Tab_Grandeur_TenseurHB( TenseurHB& tens,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_TenseurHB(istream & ent); // constructeur de copie Tab_Grandeur_TenseurHB(const Tab_Grandeur_TenseurHB& a) ; // destructeur ~Tab_Grandeur_TenseurHB(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_TenseurHB(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_TenseurHB & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURHB;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_TENSEURHB;}; // acces au tenseur de numéro i en lecture écriture TenseurHB& operator () ( int i)const {return (*(tabTens(i)->ptTens));}; // ramène la grandeur_Tenseur associée const Grandeur_TenseurHB& Grandeur_TenseurHB_associee(int i) const {return *(tabTens(i));}; // ramène la dimension du tableau de tenseur int Taille() const {return tabTens.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_TenseurHB, d'où la nécessité d'une construction // en deux temps !! Tableau tabTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------------------ /// grandeur un tableau à 2 dim de TenseurHH: TypeQuelconque::Grandeur::Tab2_Grandeur_TenseurHH //------------------------------------------------------------------------------------------------ class Tab2_Grandeur_TenseurHH : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab2_Grandeur_TenseurHH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab2_Grandeur_TenseurHH & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // ptTens défini, donc -> erreur Tab2_Grandeur_TenseurHH(); // constructeur légal // nb1,nb2 indique la dimension du tableau(nb1,nb2) de tenseur Tab2_Grandeur_TenseurHH( TenseurHH& tens,int nb1, int nb2); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab2_Grandeur_TenseurHH(istream & ent); // constructeur de copie Tab2_Grandeur_TenseurHH(const Tab2_Grandeur_TenseurHH& a) ; // destructeur ~Tab2_Grandeur_TenseurHH(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab2_Grandeur_TenseurHH(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab2_Grandeur_TenseurHH & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val); // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return TENSEURHH;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU2_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU2_TENSEURHH;}; // acces au tenseur de numéro i,j en lecture écriture TenseurHH& operator () ( int i,int j) const {return (*(tabTens(i,j)->ptTens));}; // ramène la grandeur_Tenseur associée const Grandeur_TenseurHH& Grandeur_TenseurHH_associee(int i, int j) const {return *(tabTens(i,j));}; // changement de taille -> n : // si ni < taille_actuelle --> les taille_actuelle - ni sont supprimé // si ni > taille_actuelle --> le dernier élément existant est dupliqué ni-taille_actuelle fois, void Change_taille(int n1, int n2); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_TenseurHH, d'où la nécessité d'une construction // en deux temps !! Tableau2 tabTens; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //----------------------------------------------------------------------------- /// grandeur scalaire réel: TypeQuelconque::Grandeur::Grandeur_scalaire_double //----------------------------------------------------------------------------- class Grandeur_scalaire_entier : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_scalaire_entier; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_scalaire_entier & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_scalaire_entier & a); public: // constructeur par défaut: Grandeur_scalaire_entier(); // constructeur légal Grandeur_scalaire_entier(const double& va): val(va) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_scalaire_entier(istream & ent); // constructeur de copie Grandeur_scalaire_entier(const Grandeur_scalaire_entier& a): val(a.val) {}; // destructeur ~Grandeur_scalaire_entier(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_scalaire_entier(val);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_scalaire_entier & a) {val=a.val;return *this;}; // surcharge d'affectation Grandeur & operator = ( const double& b) {val=b;return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double x) {val*=x;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double x) {val/=x;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {if(num==1) return val; else return 0.;}; int NbMaxiNumeroOrdre() const {return 1;}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const {sort <<" "<< setw(nbcar)<< setprecision(nbcar) << val << " ";}; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_SCALAIRE_ENTIER;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& ,const Mat_pleine& ){}; // lecture istream & Lecture_grandeur(istream & ent) { ent >> val ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort) const { sort <<" "<< val << " "; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(){val = 0.;}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode int* ConteneurEntier() {return &val;}; protected: int val; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //--------------------------------------------------------------------------------------------- /// grandeur tableau de scalaires entière: TypeQuelconque::Grandeur::Tab_Grandeur_scalaire_entière //--------------------------------------------------------------------------------------------- class Tab_Grandeur_scalaire_entier : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_scalaire_entier & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_scalaire_entier & a); public: // constructeur par défaut: Tab_Grandeur_scalaire_entier(); // constructeur légal Tab_Grandeur_scalaire_entier(const Tableau & tab_va); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_scalaire_entier(istream & ent); // constructeur de copie Tab_Grandeur_scalaire_entier(const Tab_Grandeur_scalaire_entier& a): tab_val(a.tab_val) {}; // destructeur ~Tab_Grandeur_scalaire_entier(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_scalaire_entier(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tableau & b) ; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double x); // Surcharge de l'operateur /= : division par un scalaire void operator/= (double x); // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const; int NbMaxiNumeroOrdre() const {return tab_val.Taille();}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_SCALAIRE_DOUBLE;}; // ramène un Grandeur_scalaire_entier associé Grandeur_scalaire_entier& Grandeur_scalaire_associee(int i) {return tab_val(i);}; // ramène la dimension du tableau int Taille() const {return tab_val.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& ,const Mat_pleine& ){}; // lecture istream & Lecture_grandeur(istream & ent) { tab_val.Entree(ent);return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { tab_val.Sortir_sansRet(sort); return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode Tableau & ConteneurTabEntier() {return tab_val;}; // acces au double de numéro i en lecture écriture int& operator () ( const int i) {return tab_val(i).val;}; protected: Tableau tab_val; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //----------------------------------------------------------------------------- /// grandeur scalaire réel: TypeQuelconque::Grandeur::Grandeur_scalaire_double //----------------------------------------------------------------------------- class Grandeur_scalaire_double : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_scalaire_double; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_scalaire_double & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_scalaire_double & a); public: // constructeur par défaut: Grandeur_scalaire_double(); // constructeur légal Grandeur_scalaire_double(const double& va): val(va) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_scalaire_double(istream & ent); // constructeur de copie Grandeur_scalaire_double(const Grandeur_scalaire_double& a): val(a.val) {}; // destructeur ~Grandeur_scalaire_double(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_scalaire_double(val);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_scalaire_double & a) {val=a.val;return *this;}; // surcharge d'affectation Grandeur & operator = ( const double& b) {val=b;return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double x) {val*=x;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double x) {val/=x;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {if(num==1) return val; else return 0.;}; int NbMaxiNumeroOrdre() const {return 1;}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const {sort <<" "<< setw(nbcar)<< setprecision(nbcar) << val << " ";}; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_SCALAIRE_DOUBLE;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma){}; // lecture istream & Lecture_grandeur(istream & ent) { ent >> val ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort) const { sort <<" "<< val << " "; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(){val = 0.;}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode double* ConteneurDouble() {return &val;}; // idem en const double ContDouble() const {return val;}; protected: double val; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //--------------------------------------------------------------------------------------------- /// grandeur tableau de scalaires réel: TypeQuelconque::Grandeur::Tab_Grandeur_scalaire_double //--------------------------------------------------------------------------------------------- class Tab_Grandeur_scalaire_double : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_scalaire_double & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_scalaire_double & a); public: // constructeur par défaut: Tab_Grandeur_scalaire_double(); // constructeur légal Tab_Grandeur_scalaire_double(const Tableau & tab_va); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_scalaire_double(istream & ent); // constructeur de copie Tab_Grandeur_scalaire_double(const Tab_Grandeur_scalaire_double& a): tab_val(a.tab_val) {}; // destructeur ~Tab_Grandeur_scalaire_double(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_scalaire_double(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tableau & b) ; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double x); // Surcharge de l'operateur /= : division par un scalaire void operator/= (double x); // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const; int NbMaxiNumeroOrdre() const {return tab_val.Taille();}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_SCALAIRE_DOUBLE;}; // ramène un Grandeur_scalaire_double associé Grandeur_scalaire_double& Grandeur_scalaire_associee(int i) {return tab_val(i);}; // ramène la dimension du tableau int Taille() const {return tab_val.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma){}; // lecture istream & Lecture_grandeur(istream & ent) { tab_val.Entree(ent);return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { tab_val.Sortir_sansRet(sort); return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode Tableau & ConteneurTabDouble() {return tab_val;}; // acces au double de numéro i en lecture écriture double& operator () ( const int i) {return tab_val(i).val;}; protected: Tableau tab_val; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //----------------------------------------------------------------------------- /// grandeur vecteur: TypeQuelconque::Grandeur::Grandeur_vecteur //----------------------------------------------------------------------------- class Grandeur_Vecteur : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_Vecteur; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_Vecteur & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_Vecteur & a); public: // constructeur par défaut: Grandeur_Vecteur(); // constructeur légal Grandeur_Vecteur(const Vecteur& v): ve(v) {}; // à partir d'un vecteur Grandeur_Vecteur(int n): ve(n) {}; // à partir d'une dimension // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_Vecteur(istream & ent); // constructeur de copie Grandeur_Vecteur(const Grandeur_Vecteur& a): ve(a.ve) {}; // destructeur ~Grandeur_Vecteur(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_Vecteur(ve);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Vecteur& b) {ve=b;return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double val) {ve*=val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {ve/=val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const; int NbMaxiNumeroOrdre() const {return ve.Taille();}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const {int tailp1 = ve.Taille()+1; for (int i=1;i> ve ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort <<" " << ve << " "; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {ve.Zero();}; // ----------- méthodes spécifiques d'acces à la grandeur ------------- // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode Vecteur* ConteneurVecteur() {return &ve;}; // idem en const const Vecteur& ConteneurVecteur_const() const {return ve;}; protected: Vecteur ve; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de Vecteur: TypeQuelconque::Grandeur::Tab_Grandeur_Vecteur| /// tous les Vecteurs doivent avoir la même dimension !! pour la routine GrandeurNumOrdre ?? à voir //------------------------------------------------------------------------------------ class Tab_Grandeur_Vecteur : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_Vecteur & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_Vecteur & a); public: // constructeur par défaut: ne doit pas être utilisé Tab_Grandeur_Vecteur(); // constructeur légal // nb indique le nombre de Vecteur Tab_Grandeur_Vecteur( Vecteur & vect,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_Vecteur(istream & ent); // constructeur de copie Tab_Grandeur_Vecteur(const Tab_Grandeur_Vecteur& a) ; // destructeur ~Tab_Grandeur_Vecteur(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_Vecteur(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_Vecteur & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return VECTEUR;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_VECTEUR;}; // acces au Vecteur de numéro i en lecture écriture Vecteur& operator () ( int i)const {return (tabVe(i)->ve);}; // ramène la grandeur_Vecteur associée const Grandeur_Vecteur& Grandeur_Vecteur_associee(int i) const {return *(tabVe(i));}; // ramène la dimension du tableau de Vecteur int Taille() const {return tabVe.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_Vecteur, d'où la nécessité d'une construction // en deux temps !! Tableau tabVe; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //----------------------------------------------------------------------------- /// grandeur coordonnée: TypeQuelconque::Grandeur::Grandeur_coordonnee //----------------------------------------------------------------------------- class Grandeur_coordonnee : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_Coordonnee; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_coordonnee & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_coordonnee & a); public: // constructeur par défaut: Grandeur_coordonnee(); // constructeur légal Grandeur_coordonnee(const Coordonnee& v): co(v) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_coordonnee(istream & ent); // constructeur de copie Grandeur_coordonnee(const Grandeur_coordonnee& a): co(a.co) {}; // destructeur ~Grandeur_coordonnee(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_coordonnee(co);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Coordonnee& b) {co=b;return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double val) {co*=val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {co/=val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const; int NbMaxiNumeroOrdre() const {return co.Dimension();}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const {sort <<" "<< setprecision(nbcar) ; co.Affiche(sort,nbcar) ;}; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return COORDONNEE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_COORDONNEE;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> co ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort <<" " << co << " "; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {co.Zero();}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode Coordonnee* ConteneurCoordonnee() {return &co;}; // idem en const const Coordonnee& ConteneurCoordonnee_const() const {return co;}; protected: Coordonnee co; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de Coordonnee: TypeQuelconque::Grandeur::Tab_Grandeur_CoordonneeHH /// tous les coordonnees doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_Coordonnee : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_Coordonnee & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_Coordonnee & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // co défini, donc -> erreur (en fait ce n'est sûr, mais on fait comme pour les tenseurs) Tab_Grandeur_Coordonnee(); // constructeur légal // nb indique le nombre de Coordonnee Tab_Grandeur_Coordonnee( Coordonnee & coor,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_Coordonnee(istream & ent); // constructeur de copie Tab_Grandeur_Coordonnee(const Tab_Grandeur_Coordonnee& a) ; // destructeur ~Tab_Grandeur_Coordonnee(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_Coordonnee(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_Coordonnee & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return COORDONNEE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_COORDONNEE;}; // acces au Coordonnee de numéro i en lecture écriture Coordonnee& operator () ( int i)const {return (tabCoor(i)->co);}; // ramène la grandeur_Coordonnee associée const Grandeur_coordonnee& Grandeur_Coordonnee_associee(int i) const {return *(tabCoor(i));}; // ramène la dimension du tableau de Coordonnee int Taille() const {return tabCoor.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut de Grandeur_coordonnee, d'où la nécessité d'une construction // en deux temps !! Tableau tabCoor; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------- /// grandeur Ddl_etendu: TypeQuelconque::Grandeur::Grandeur_Ddl_etendu //------------------------------------------------------------------------------- class Grandeur_Ddl_etendu : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_Ddl_etendu; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_Ddl_etendu & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_Ddl_etendu & a); public: // constructeur par défaut: Grandeur_Ddl_etendu(); // constructeur légal Grandeur_Ddl_etendu(const Ddl_etendu& v,const string& nom): co(v) ,nom_ref(nom){}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_Ddl_etendu(istream & ent); // constructeur de copie Grandeur_Ddl_etendu(const Grandeur_Ddl_etendu& a): co(a.co),nom_ref(a.nom_ref) {}; // destructeur ~Grandeur_Ddl_etendu(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_Ddl_etendu(co,nom_ref);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_Ddl_etendu& b) {co=b.co;nom_ref=b.nom_ref; return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double val) {co*=val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {co/=val;}; // récup du nom de référence virtual const string* Nom_ref() const {return &nom_ref;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {if (num == 1) {return co.ConstValeur();} else {return 0.;}}; int NbMaxiNumeroOrdre() const {return 1;}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const {sort <<" "<< setprecision(nbcar) << co.ConstValeur()<<" " ;}; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE_DOUBLE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_DDL_ETENDU;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) // a priori on ne fait rien sur la grandeur scalaire {}; // lecture istream & Lecture_grandeur(istream & ent) { ent >> nom_ref >> co ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort <<" " << nom_ref <<" " << co << " "; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {co.Valeur()=0.;}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode Ddl_etendu* ConteneurDdl_etendu() {return &co;}; void Change_nom_ref(const string& nom) {nom_ref = nom;}; protected: Ddl_etendu co; string nom_ref; // un nom de référence qui permet ensuite de discriminer les différents conteneurs }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de Coordonnee: TypeQuelconque::Grandeur::Tab_Grandeur_CoordonneeHH /// tous les coordonnees doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_Ddl_etendu : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_Ddl_etendu & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_Ddl_etendu & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // co défini, donc -> erreur (en fait ce n'est sûr, mais on fait comme pour les tenseurs) Tab_Grandeur_Ddl_etendu(); // constructeur légal // nb indique le nombre de Ddl_etendu Tab_Grandeur_Ddl_etendu( Grandeur_Ddl_etendu & coor,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_Ddl_etendu(istream & ent); // constructeur de copie Tab_Grandeur_Ddl_etendu(const Tab_Grandeur_Ddl_etendu& a) ; // destructeur ~Tab_Grandeur_Ddl_etendu(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_Ddl_etendu(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_Ddl_etendu & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE_DOUBLE;}; // vecteur à 1 élément // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_DDL_ETENDU;}; // acces au Coordonnee de numéro i en lecture écriture Ddl_etendu& operator () ( int i)const {return (tabDdlEte(i)->co);}; // ramène la Grandeur_Ddl_etendu associée const Grandeur_Ddl_etendu& Grandeur_Ddl_etendu_associee(int i) const {return *(tabDdlEte(i));}; // ramène la dimension du tableau int Taille() const {return tabDdlEte.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) {}; // ne fait rien ici car ce sont des scalaires uniques // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut , d'où la nécessité d'une construction // en deux temps !! Tableau tabDdlEte; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------- /// grandeur vecteur nommé : TypeQuelconque::Grandeur::Grandeur_Vecteur_Nommer /// contient un nom d'identificateur (utilisé par exemple pour un nom de fonc //------------------------------------------------------------------------------- class Grandeur_Vecteur_Nommer : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_Vecteur_Nommer & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_Vecteur_Nommer & a); public: // constructeur par défaut: Grandeur_Vecteur_Nommer(); // constructeur légal Grandeur_Vecteur_Nommer(const string & nom_ref_, const int taille,Fonction_nD * fct_ =NULL) : nom_ref(nom_ref_),fct(fct_) {v.Change_taille(taille);}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_Vecteur_Nommer(istream & ent); // constructeur de copie Grandeur_Vecteur_Nommer(const Grandeur_Vecteur_Nommer& a): nom_ref(a.nom_ref),v(a.v),fct(a.fct) {}; // destructeur ~Grandeur_Vecteur_Nommer(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_Vecteur_Nommer(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_Vecteur_Nommer& b) {v=b.v;nom_ref = b.nom_ref; fct=b.fct; return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double val) {v *=val;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) {v /=val;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {if ((num <= v.Taille())&&(num>0)) {return v(num);} else {return 0.;}}; // récup du nom de référence virtual const string* Nom_ref() const {return &nom_ref;}; int NbMaxiNumeroOrdre() const {return v.Taille();}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return VECTEUR;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_VECTEUR_NOMMER;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) // a priori on ne fait rien sur la grandeur vectoriel {}; // lecture istream & Lecture_grandeur(istream & ent) { ent >> nom_ref >> v ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort <<" " << nom_ref << " "<< v ; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut() {v.Zero();}; // ----------- méthodes spécifiques d'acces à la grandeur ------------- // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode Vecteur& ConteneurVecteur() {return v;}; Fonction_nD * Fct() const {return fct;}; // const string& Nom_vec() const {return nom_ref;}; void Change_fonction_nD(Fonction_nD * fct_) {fct = fct_;}; protected: Fonction_nD * fct; // la fonction nD qui permet le calcul du résultat stocké dans v // n'est pas forcément définit string nom_ref ; // un nom de référence qui permet de discriminer une même intégrale de fonction nD, ou une statistique par exemple // mais sur des volumes ou des ref différents Vecteur v; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //---------------------------------------------------------------------------------------------------------------- /// grandeur un tableau de Grandeur_Vecteur_Nommer: TypeQuelconque::Grandeur::Tab_Grandeur_Grandeur_Vecteur_Nommer //---------------------------------------------------------------------------------------------------------------- class Tab_Grandeur_Vecteur_Nommer : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_Vecteur_Nommer & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_Vecteur_Nommer & a); public: // constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable // co défini, donc -> erreur (en fait ce n'est sûr, mais on fait comme pour les tenseurs) Tab_Grandeur_Vecteur_Nommer(); // constructeur légal // nb indique le nombre de Grandeur_Vecteur_Nommer Tab_Grandeur_Vecteur_Nommer( Grandeur_Vecteur_Nommer & grno,int nb); // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_Vecteur_Nommer(istream & ent); // constructeur de copie Tab_Grandeur_Vecteur_Nommer(const Tab_Grandeur_Vecteur_Nommer& a) ; // destructeur ~Tab_Grandeur_Vecteur_Nommer(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_Vecteur_Nommer(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_Vecteur_Nommer & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {return 0;}; // ici c'est le maxi des vecteurs nommés * le nombre int NbMaxiNumeroOrdre() const {return 0;}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return VECTEUR;}; // vecteur à 1 élément // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_VECTEUR_NOMMER;}; // acces au Grandeur_Vecteur_Nommer de numéro i en lecture écriture Grandeur_Vecteur_Nommer& operator () ( int i)const {return (*(tabVN(i)));}; // ramène la Grandeur_Vecteur_Nommer associée const Grandeur_Vecteur_Nommer& Grandeur_Vecteur_Nommer_associee(int i) const {return *(tabVN(i));}; // ramène la dimension du tableau int Taille() const {return tabVN.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) {}; // ne fait rien ici car ce sont des scalaires uniques // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau de pointeur et non de valeur car pour la construction il ne faut pas // utiliser le constructeur par défaut , d'où la nécessité d'une construction // en deux temps !! Tableau tabVN; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------ /// grandeur BaseH: TypeQuelconque::Grandeur::Grandeur_BaseH //------------------------------------------------------------------ class Grandeur_BaseH : public TypeQuelconque::Grandeur { friend class Tab_Grandeur_BaseH; // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_BaseH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_BaseH & a); public: // constructeur par défaut: Grandeur_BaseH(): baseH() {}; // constructeur fonction du nombre de vecteur et de la dimension des vecteurs de base Grandeur_BaseH(int dim, int nb_vec ): baseH(dim,nb_vec) {}; // constructeur légal Grandeur_BaseH(const BaseH& basH): baseH(basH) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_BaseH(istream & ent); // constructeur de copie Grandeur_BaseH(const Grandeur_BaseH& a): baseH(a.baseH) {}; // destructeur ~Grandeur_BaseH() {}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_BaseH(baseH);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_BaseH & a) // surcharge d'affectation {baseH = a.baseH; return *this; } Grandeur & operator = ( const BaseH & a) // surcharge d'affectation {baseH = a; return *this; } // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; void operator+= (const Grandeur_BaseH& aa); // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; void operator-= (const Grandeur_BaseH& aa); // Surcharge de l'operateur *= void operator*= (double val); // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val); // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const ; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return BASE__H;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_BASE_H;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode BaseH* ConteneurBaseH() {return &baseH;}; // la référence est un peu plus sur (il est toujours possible de faire un delete sur un pointeur de ref // mais c'est plus difficile de le faire en se trompant ! enfin j'espère) const BaseH& RefConteneurBaseH() const {return baseH;}; protected: BaseH baseH; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------ /// grandeur un tableau de Grandeur_BaseH: TypeQuelconque::Grandeur::Tab_Grandeur_BaseH /// tous les coordonnees doivent avoir la même dimension !! pour la routine GrandeurNumOrdre //------------------------------------------------------------------------------------ class Tab_Grandeur_BaseH : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tab_Grandeur_BaseH & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tab_Grandeur_BaseH & a); public: // constructeur par défaut: Tab_Grandeur_BaseH(): tabBaseH() {}; // constructeur légal // nb indique le nombre de Grandeur_BaseH Tab_Grandeur_BaseH( Grandeur_BaseH & baseH,int nb): tabBaseH(nb,baseH) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Tab_Grandeur_BaseH(istream & ent); // constructeur de copie Tab_Grandeur_BaseH(const Tab_Grandeur_BaseH& a) : tabBaseH(a.tabBaseH) {}; // destructeur ~Tab_Grandeur_BaseH() {}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tab_Grandeur_BaseH(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Tab_Grandeur_BaseH & a) // surcharge d'affectation {tabBaseH = a.tabBaseH; return *this;}; // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c) ; // Surcharge de l'operateur -= void operator-= (const Grandeur& c) ; // Surcharge de l'operateur *= void operator*= (double val) ; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val) ; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const ; int NbMaxiNumeroOrdre() const; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return BASE__H;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_BASE_H;}; // acces au Grandeur_BaseH de numéro i en lecture écriture Grandeur_BaseH& operator () ( int i)const {return tabBaseH(i);}; // ramène la grandeur_Grandeur_BaseH associée const Grandeur_BaseH& Grandeur_Grandeur_BaseH_associee(int i) const {return tabBaseH(i);}; // ramène la dimension du tableau de Grandeur_BaseH int Taille() const {return tabBaseH.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: // on utilise un tableau Tableau tabBaseH; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //------------------------------------------------------------------------------------------------------ /// grandeur scalaire double nommé + indice: TypeQuelconque::Grandeur::Grandeur_Double_Nommer_indicer /// contient un nom d'identificateur et un indice qui est sensé resté fixe pendant les opérations /// la seule grandeur qui varie c'est le double: c'est donc équivalent à un scalaire double /// l'indice et le nom_ref, servent pour la gestion //------------------------------------------------------------------------------------------------------ class Grandeur_Double_Nommer_indicer : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Grandeur_Double_Nommer_indicer & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Grandeur_Double_Nommer_indicer & a); public: // constructeur par défaut: Grandeur_Double_Nommer_indicer(); // constructeur légal Grandeur_Double_Nommer_indicer(const string & nom_ref_,const double& va,int indice_ = 1) : nom_ref(nom_ref_),val(va),indice(indice_) {}; // constructeur qui effectue la construction en lisant les informations sur le stream d'entrée // nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction // inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale Grandeur_Double_Nommer_indicer(istream & ent); // constructeur de copie Grandeur_Double_Nommer_indicer(const Grandeur_Double_Nommer_indicer& a): nom_ref(a.nom_ref),val(a.val),indice(a.indice) {}; // destructeur ~Grandeur_Double_Nommer_indicer(){}; // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Grandeur_Double_Nommer_indicer(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); // la surcharge d'affectation concerne toutes les grandeurs Grandeur & operator = ( const Grandeur & a); // surcharge d'affectation Grandeur & operator = ( const Grandeur_Double_Nommer_indicer& b) {val=b.val;nom_ref = b.nom_ref; indice=b.indice; return *this;}; // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) // >>>>> ici seul le double val est concerné !! <<<<<<<<<<<<< void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double x) {val *=x;}; // Surcharge de l'operateur /= : division par un scalaire void operator/= (double x) {val /=x;}; // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {if(num==1) return val; else return 0.;}; // récup du nom de référence virtual const string* Nom_ref() const {return &nom_ref;}; int NbMaxiNumeroOrdre() const {return 1;}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const {sort <<" "<< setw(nbcar)<< setprecision(nbcar) << val << " ";}; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return SCALAIRE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TYPE_SIMPLE;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER;}; // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) // a priori on ne fait rien sur la grandeur scalaire {}; // lecture istream & Lecture_grandeur(istream & ent) { ent >> nom_ref >> val >> indice ;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort <<" " << nom_ref << " "<< val << " " << indice ; return sort;}; // ----------- méthodes spécifiques d'acces à la grandeur ------------- // initialise la grandeur à une valeur par défaut: = 0 pour la grandeur double void InitParDefaut(){val = 0.;}; // méthode spécifique d'acces à la grandeur // le fait d'utiliser une méthode permet de savoir qui passe par cette méthode double* ConteneurDouble() {return &val;}; // idem en const double ContDouble() const {return val;}; // l'indice int Indice_const() const {return indice;}; int& Indice() {return indice;}; protected: string nom_ref ; // un nom de référence double val; // valeur int indice; }; /// @} // end of group /// @addtogroup Les_grandeurs_particulieres /// @{ /// //----------------------------------------------------------------------------- /// un tableau de grandeur quelconque //----------------------------------------------------------------------------- // on arrête le développement car c'est pas sûr que c'est utile en fait !! class Tableau_Grandeur_quelconque : public TypeQuelconque::Grandeur { // surcharge de l'operator de lecture friend istream & operator >> (istream & ent, Tableau_Grandeur_quelconque & a); // surcharge de l'operator d'ecriture friend ostream & operator << (ostream & sort , const Tableau_Grandeur_quelconque & a); public: // constructeur par défaut: Tableau_Grandeur_quelconque(); // constructeur légal: on recopie nfois // nb indique le nombre de grandeur quelconque que contient le tableau Tableau_Grandeur_quelconque(const TypeQuelconque::Grandeur& tg,int nb); // cas d'un tableau déjà connu // Tableau_Grandeur_quelconque(const Tableau & tab); // idem pour des pointeurs Tableau_Grandeur_quelconque(const Tableau & tab); // idem pour des grandeurs quelconques Tableau_Grandeur_quelconque(const Tableau & tab); // constructeur de copie Tableau_Grandeur_quelconque(const Tableau_Grandeur_quelconque& a); // destructeur ~Tableau_Grandeur_quelconque(); // ramène une grandeur identique, créée TypeQuelconque::Grandeur* New_idem_grandeur() const {return new Tableau_Grandeur_quelconque(*this);}; // sauvegarde sur le stream des informations permetant ensuite en lecture de créer via // le constructeur adoc l'objet correcte et valide void EcriturePourLectureAvecCreation(ostream & sort); TypeQuelconque::Grandeur & operator = ( const TypeQuelconque::Grandeur & a); // surcharge d'affectation // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type // affectation uniquement des données numériques (pas les pointeurs, pas les string) void Affectation_numerique( const TypeQuelconque::Grandeur & a); // Surcharge de l'operateur += void operator+= (const Grandeur& c); // Surcharge de l'operateur -= void operator-= (const Grandeur& c); // Surcharge de l'operateur *= void operator*= (double val); // Surcharge de l'operateur /= : division par un scalaire void operator/= (double val); // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre // si pas possible, ramène 0 double GrandeurNumOrdre(int num) const {return 0;}; int NbMaxiNumeroOrdre() const {return 0;}; // récup du nb maxi de numéros d'ordres void Grandeur_brut(ostream & sort,int nbcar) const; // ramène le type de grandeur associée de la grandeur de base, car // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base EnumTypeGrandeur Type_grandeurAssocie() const {return GRANDEUR_QUELCONQUE;}; // ramène le type de la structure: tableau, liste ext.. EnumType2Niveau Type_structure_grandeurAssocie() const {return TABLEAU_T;}; // ramène le type de la grandeur particulière EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const{return PARTICULIER_TABLEAU_QUELCONQUE;}; // acces au Grandeur_Vecteur_Nommer de numéro i en lecture écriture TypeQuelconque::Grandeur& operator () ( int i)const {return (*(tab_grandeur(i)));}; // ramène la Grandeur_Vecteur_Nommer associée const TypeQuelconque::Grandeur& ConteneurGrandeurQuelconque(int i) const {return *(tab_grandeur(i));}; // ramène la dimension du tableau int Taille() const {return tab_grandeur.Taille();}; // changement de taille -> n : // si n < taille_actuelle --> les taille_actuelle - n sont supprimé // si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois, void Change_taille(int n); // change de repère de la grandeur void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma ); // lecture istream & Lecture_grandeur(istream & ent) { ent >> *this;return ent;}; // ecriture virtual ostream & Ecriture_grandeur(ostream & sort ) const { sort << *this; return sort;}; // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques void InitParDefaut(); protected: Tableau tab_grandeur; }; /// @} // end of group #endif