diff --git a/Tableaux/TabOper_T.h b/Tableaux/TabOper_T.h new file mode 100644 index 0000000..9859446 --- /dev/null +++ b/Tableaux/TabOper_T.h @@ -0,0 +1,321 @@ + +// 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-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + +/************************************************************************ + * * + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: une spécialisation du tableau en incluant une * + * surchage d'opérateurs courants. Le template n'est pas utilisable * + * par tous les objets: ces derniers doivent posséder également * + * les surcharges correspondantes. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * * + * $ * + * * + ************************************************************************/ + + +#ifndef TABOPER_T_H +#define TABOPER_T_H + + +#include "Tableau_T.h" + + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +template +class TabOper : public Tableau +{ + + + public : + + + // CONSTRUCTEURS : + + // Constructeur par defaut + TabOper () : Tableau() {}; + + // Constructeur fonction de la taille du tableau + TabOper (int nb) : Tableau(nb) {}; + + // Constructeur fonction de la taille du tableau et d'une + // valeur d'initialisation pour les composantes + TabOper (int nb,T val) : Tableau(nb,val) {}; + + // Constructeur fonction d'un tableau de composantes de type T + TabOper (int nb,T* tab) : Tableau(nb,tab) {} ; + + // Constructeur de copie + TabOper (const TabOper & tab) : Tableau(tab) {} ; + + + // DESTRUCTEUR : + + ~TabOper (){}; + + // METHODES : + // Surcharge de l'operateur + : addition entre deux tableaux + TabOper operator+ (const TabOper& vec); + + // Surcharge de l'operateur - : soustraction entre deux tableaux + TabOper operator- (const TabOper& vec); + + // Surcharge de l'operateur - : oppose d'un tableau + //TabOper operator- (); + TabOper operator- (); + + // Surcharge de l'operateur += + void operator+= (const TabOper& vec); + + // Surcharge de l'operateur -= + void operator-= (const TabOper& vec); + + // Surcharge de l'operateur *= : multiplication d'un scalaire par un tableau + void operator*= (double val); + + // Surcharge de l'operateur * : multiplication d'un vecteur par un scalaire + //TabOper operator* (double val); + inline TabOper operator* (double val); + + // Surcharge de l'operateur / : division des composantes d'un vecteur par un scalaire + TabOper operator/ (double val); + + // Surcharge de l'operateur /= : division des composantes d'un vecteur par un scalaire + void operator/= (double val); + + // mise a zero d'un vecteur + void Zero(); + +}; +/// @} // end of group + +template + TabOper operator* (double val,TabOper& vec) +// Surcharge de l'operateur * : multiplication entre un scalaire et un tableau +{ return (vec*val); }; + + +template TabOper +TabOper::operator+ (const TabOper& vec) +// Surcharge de l'operateur + : addition entre deux tableaux +// N.B.: Les tableaux doivent etre de meme taille +{ + #ifdef MISE_AU_POINT + if ( this->taille!=vec.taille ) + { cout << "\nErreur : tailles non egales !\n"; + cout << "TabOper::OPERATOR+ (TabOper ) \n"; + Sortie(1); + }; + #endif + TabOper result(this->taille); + T* ptr1=this->t; + T* ptr2=vec.t; + T* ptr3=result.t; + for (int i=0;itaille;i++) + // somme des composantes des deux tableaux vec et v, puis stockage + // dans le tableau result + (*ptr3++)=(*ptr1++)+(*ptr2++); + return result; +} + +template TabOper +TabOper::operator- (const TabOper& vec) +// Surcharge de l'operateur - : soustraction entre deux tableaux +// N.B.: Les tableaux doivent etre de meme taille +{ + #ifdef MISE_AU_POINT + if ( this->taille!=vec.taille ) + { cout << "\nErreur : tailles non egales !\n"; + cout << "TabOper::OPERATOR- (TabOper ) \n"; + Sortie(1); + }; + #endif + TabOper result(this->taille); + T* ptr1=this->t; + T* ptr2=vec.t; + T* ptr3=result.t; + for (int i=0;itaille;i++) + // soustraction des composantes des tableaux vec et v, puis stockage + // dans le tableau result + (*ptr3++)=(*ptr1++)-(*ptr2++); + return result; +} + +template TabOper +TabOper::operator- () +// Surcharge de l'operateur - : oppose d'un tableau +{ TabOper result(this->taille); + T* ptr1=this->t; + T* ptr2=result.t; + for (int i=0;itaille;i++) + (*ptr2++)=-(*ptr1++); + return result; +} + +template void +TabOper::operator+= (const TabOper& vec) +// Surcharge de l'operateur += : additionne au tableau courant le tableau vec +// N.B.: Les tableaux doivent etre de meme taille +{ + #ifdef MISE_AU_POINT + if ( this->taille!=vec.taille ) + { cout << "\nErreur : tailles non egales !\n"; + cout << "TabOper::OPERATOR+= (TabOper ) \n"; + Sortie(1); + }; + #endif + T* ptr1=this->t; + T* ptr2=vec.t; + for (int i=0;itaille;i++) + (*ptr1++)+=(*ptr2++); +} + +template void +TabOper::operator-= (const TabOper& vec) +// Surcharge de l'operateur -= : soustrait au tableau courant le tableau vec +// N.B.: Les tableaux doivent etre de meme taille +{ + #ifdef MISE_AU_POINT + if ( this->taille!=vec.taille ) + { cout << "\nErreur : tailles non egales !\n"; + cout << "TabOper::OPERATOR-= (TabOper ) \n"; + Sortie(1); + }; + #endif + T* ptr1=this->t; + T* ptr2=vec.t; + for (int i=0;itaille;i++) + (*ptr1++)-=(*ptr2++); +} + +template void +TabOper::operator*= (double val) +// Surcharge de l'operateur *= : multiplie les composantes du tableau courant par +// le scalaire val +// N.B.: Les tableaux doivent etre de meme taille +{ T* ptr=this->t; + for (int i=0;itaille;i++) + (*ptr++)*=val; +} + + + +template TabOper +TabOper::operator* (double val) +// Surcharge de l'operateur * : multiplication d'un tableau par un scalaire +{ + #ifdef MISE_AU_POINT + if ( this->taille==0 ) + { cout << "\nErreur : taille nulle !\n"; + cout << "TabOper::OPERATOR* (T ) \n"; + Sortie(1); + }; + #endif + TabOper result(this->taille); + T* ptr1=this->t; + T* ptr2=result.t; + for (int i=1;i<=this->taille;i++) + // stockage dans le tableau result du produit des composantes du tableau courant + // avec val + (*ptr2++)=val*(*ptr1++); + return result; +} + +template TabOper +TabOper::operator/ (double val) +// Surcharge de l'operateur / : division des composantes d'un tableau par un scalaire +{ + #ifdef MISE_AU_POINT + if ( (this->taille==0) || (val==0) ) + { cout << "\nErreur : taille nulle ou division par zero !\n"; + cout << "TabOper::OPERATOR/ (T ) \n"; + Sortie(1); + }; + #endif + TabOper result(this->taille); + T* ptr1=this->t; + T* ptr2=result.t; + for (int i=1;i<=this->taille;i++) + // stockage dans le tableau result de la division des composantes du tableau courant + // avec val + (*ptr2++)=(*ptr1++)/val; + return result; +} + +template void +TabOper::operator/= (double val) +// Surcharge de l'operateur / : division des composantes d'un tableau par un scalaire +{ + #ifdef MISE_AU_POINT + if ( (this->taille==0) || (val==0) ) + { cout << "\nErreur : taille nulle ou division par zero !\n"; + cout << "TabOper::OPERATOR/ (T ) \n"; + Sortie(1); + }; + #endif + T* ptr=this->t; + for (int i=0;itaille;i++) + (*ptr++) /= val; +} + +template +// mise a zero d'un tableau +void TabOper::Zero() + { T* ptr=this->t; + for (int i=0;itaille;i++) + // affectation des composantes du tableau a 0 + (*ptr++)=0.0; + } + + +#endif diff --git a/Tableaux/Tableau2_T.h b/Tableaux/Tableau2_T.h new file mode 100644 index 0000000..311e00e --- /dev/null +++ b/Tableaux/Tableau2_T.h @@ -0,0 +1,325 @@ + +// 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-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + +/************************************************************************ + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: définir un tableau template de dimension 2. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +#ifndef TABLEAU2_T_H +#define TABLEAU2_T_H + +#include "Tableau_T.h" + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +template +class Tableau2 : public Tableau +{ + public : + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau2 (); + + // Constructeur fonction de la taille du tableau + // dans le cas d'une taille il s'agit d'un tableau carré + Tableau2 (const int nb); + // cas de deux dimensions différentes + Tableau2 (const int nb1,const int nb2); + // Constructeur fonction de la taille du tableau et d'une + // valeur d'initialisation pour les composantes + //1) tableau carré + Tableau2 (const int nb,const T& val); + //2) tableau rectangulaire + Tableau2 (const int nb1,const int nb2,const T& val); + // Constructeur de copie + Tableau2 (const Tableau2 & tab); + + + // DESTRUCTEUR : + ~Tableau2 (); + + + // METHODES : + inline int Taille1 () const + // Retourne la première taille du tableau + { return taille1; }; + inline int Taille2 () const + // Retourne la seconde taille du tableau + { return taille2; }; + // gestion d'erreur + // cette fonction n'est plus valable d'où la surcharge pour filtrer les + // appels éventuels + inline int Taille () const + { + cout << "\nErreur : fonction non disponible \n" ; + cout << "TABLEAU2_T::Taille () \n"; + Sortie(1); + return 0; // pour éviter le warning + }; + + inline T& operator() (int i, int j) + // Retourne la (ieme,jeme) composante du tableau : acces en lecture et ecriture + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille1) || (j<1) || (j>taille2) ) + { cout << "\nErreur : composante inexistante !, (i,j) demandé = (" << i + << ',' << j << ")" << '\n'; + cout << "TABLEAU2_T::OPERATOR() (int, int ) \n"; + Sortie(1); + }; + #endif + return this->t[(i-1)*taille2 + j-1]; + }; + inline T operator() (int i, int j) const + // Retourne la (ieme,jeme) composante du tableau : acces en lecture uniquement + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille1) || (j<1) || (j>taille2) ) + { cout << "\nErreur : composante inexistante !, (i,j) demandé = (" << i + << ',' << j << ")" << '\n'; + cout << "TABLEAU2_T::OPERATOR() (int, int ) \n"; + Sortie(1); + }; + #endif + return this->t[(i-1)*taille2 + j-1]; + }; + + inline int operator!= (const Tableau2& tab) const + // Surcharge de l'operateur != + // Renvoie 1 si les deux tableaux ne sont pas egaux + // Renvoie 0 sinon + { if ( (*this)==tab ) // test de l'egalite des deux tableaux a l'aide + // de l'operateur surcharge == + return 0; + else + return 1; + }; + + // Surcharge de l'operateur == + int operator== (const Tableau2& tab) const ; + // const {return ((*this)==tab); }; + + // Surcharge de l'operateur d'affectation = + Tableau2& operator= (const Tableau2& tab); + + // Change la taille du tableau (la nouvelle taille est n) + // uniquement valable pour les tableaux carrés + // N.B. : Si la nouvelle taille est superieure a l'ancienne alors le tableau est + // complete par defaut + void Change_taille (int n); + // idem et initialisation de toutes les valeurs, anciennes et nouvelles à tb + void Change_taille (int n,const T& tb); + // Change la taille du tableau (les nouvelles tailles sont n1 et n2) + void Change_taille (int n1, int n2); + // Change la taille du tableau (les nouvelles tailles sont n1 et n2) + // et initialisation de toutes les valeurs, anciennes et nouvelles à tb + void Change_taille (int n1, int n2,const T& tb); + // Permet de desallouer l'ensemble des elements du tableau + void Libere (); + + + protected : + int taille1; // la première taille du tableau + int taille2; // seconde taille du tableau + + }; +/// @} // end of group + +//================================= def des differents elements ================== + +// Constructeur par defaut +template +inline Tableau2::Tableau2 () : + Tableau () +{ taille1=0;taille2=0; +} + +// Constructeur fonction de la taille du tableau +// dans le cas d'une taille il s'agit d'un tableau carré +template +inline Tableau2::Tableau2 (const int nb) : + Tableau (nb*nb) + { taille1=nb;taille2=nb; + } +// cas de deux dimensions différentes +template +inline Tableau2::Tableau2 (const int nb1,const int nb2) : + Tableau (nb1*nb2) + { taille1=nb1;taille2=nb2; + } +// Constructeur fonction de la taille du tableau et d'une +// valeur d'initialisation pour les composantes + //1) tableau carré +template +inline Tableau2::Tableau2 (const int nb,const T& val) : + Tableau (nb*nb,val) + { taille1=nb;taille2=nb; + } + //2) tableau rectangulaire +template +inline Tableau2::Tableau2 (const int nb1,const int nb2,const T& val) : + Tableau (nb1*nb2,val) + { taille1=nb1;taille2=nb2; + } +// Constructeur de copie +template +inline Tableau2::Tableau2 (const Tableau2 & tab) : + Tableau (tab) + { taille1 = tab.taille1; + taille2 = tab.taille2; + } +// DESTRUCTEUR : +template +inline Tableau2::~Tableau2 () +{ Libere(); } + +// METHODES : +template +inline Tableau2 & Tableau2::operator= (const Tableau2 & tab) +// Surcharge de l'operateur = : realise l'egalite entre deux tableaux de pointeurs +{ Tableau & T1 = *this; + //this->Tableau::operator= (T1,T2); + T1 = (Tableau) tab; + taille1 = tab.taille1; + taille2 = tab.taille2; + return (*this); +} + +// Change la taille du tableau (la nouvelle taille est n) +// uniquement valable pour les tableaux carrés +// N.B. : Si la nouvelle taille est superieure a l'ancienne alors le tableau est +// complete par defaut +template +inline void Tableau2::Change_taille (int n) + { + #ifdef MISE_AU_POINT + if (taille1 != taille2) + { cout << "\nErreur : le changement de taille demandé n'est valide que pour des tableaux carrés," + << " ici taille 1= " << taille1 << " et taille2 = " << taille2 << '\n'; + cout << "Tableau2::Change_taille (int n) \n"; + Sortie(1); + }; + if ( n < 0) + { cout << "\nErreur : la nouvelle taille demandée est négative , n= " << n << '\n'; + cout << "Tableau2::Change_taille (int n) \n"; + Sortie(1); + }; + #endif + this->Tableau::Change_taille (n*n); + taille1 = n; taille2 = n; + } +// idem et initialisation de toutes les valeurs, anciennes et nouvelles à tb +template +inline void Tableau2::Change_taille (int n,const T& tb) + { + #ifdef MISE_AU_POINT + if (taille1 != taille2) + { cout << "\nErreur : le changement de taille demandé n'est valide que pour des tableaux carrés," + << " ici taille 1= " << taille1 << " et taille2 = " << taille2 << '\n'; + cout << "Tableau2::Change_taille (int n) \n"; + Sortie(1); + }; + if ( n < 0) + { cout << "\nErreur : la nouvelle taille demandée est négative , n= " << n << '\n'; + cout << "Tableau2::Change_taille (int n) \n"; + Sortie(1); + }; + #endif + this->Tableau::Change_taille (n*n,tb); + taille1 = n; taille2 = n; + } + +// Change la taille du tableau (les nouvelles tailles sont n1 et n2) +template +inline void Tableau2::Change_taille (int n1, int n2) + { + #ifdef MISE_AU_POINT + if (( n1 < 0) || (n2 < 0)) + { cout << "\nErreur : une des nouvelles tailles demandée est négative , n1= " << n1 << " n2 = " << n2 <<'\n'; + cout << "Tableau2::Change_taille (int n1,int n2) \n"; + Sortie(1); + }; + #endif + this->Tableau::Change_taille (n1*n2); + taille1 = n1; taille2 = n2; + } +// Permet de desallouer l'ensemble des elements du tableau +template +inline void Tableau2::Libere () + { this->Tableau::Libere (); + taille1 = 0; taille2 = 0; + } +// Surcharge de l'operateur == +template +inline int Tableau2::operator== (const Tableau2& tab) const + { if ((tab.taille1 != taille1) || (tab.taille2 != taille2)) + return 0; + else + return this->Tableau::operator== (tab); + } +// Change la taille du tableau (les nouvelles tailles sont n1 et n2) +// et initialisation de toutes les valeurs, anciennes et nouvelles à tb +template +inline void Tableau2::Change_taille (int n1, int n2,const T& tb) + { + #ifdef MISE_AU_POINT + if (( n1 < 0) || (n2 < 0)) + { cout << "\nErreur : une des nouvelles tailles demandée est négative , n1= " << n1 << " n2 = " << n2 <<'\n'; + cout << "Tableau2::Change_taille (int n1,int n2) \n"; + Sortie(1); + }; + #endif + this->Tableau::Change_taille (n1*n2,tb); + taille1 = n1; taille2 = n2; + } + +#endif diff --git a/Tableaux/Tableau4_T.h b/Tableaux/Tableau4_T.h new file mode 100644 index 0000000..d2a0352 --- /dev/null +++ b/Tableaux/Tableau4_T.h @@ -0,0 +1,307 @@ + +// 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-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + +/************************************************************************ + * DATE: 8/6/2003 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: définir un tableau template de dimension 4. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +#ifndef TABLEAU4_T_H +#define TABLEAU4_T_H + +#include "Tableau_T.h" + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +template +class Tableau4 : public Tableau +{ + public : + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau4 (); + + // Constructeur fonction de la taille du tableau + // dans le cas d'une taille il s'agit d'un tableau 4 fois la même dim + Tableau4 (const int nb); + // cas de 4 dimensions différentes + Tableau4 (const int nb1,const int nb2,const int nb3,const int nb4); + // Constructeur fonction de la taille du tableau et d'une + // valeur d'initialisation pour les composantes + //1) tableau 4 dim identique + Tableau4 (const int nb,const T& val); + //2) tableau avec des dimensions différentes + Tableau4 (const int nb1,const int nb2,const int nb3,const int nb4,const T& val); + // Constructeur de copie + Tableau4 (const Tableau4 & tab); + + + // DESTRUCTEUR : + ~Tableau4 (); + + + // METHODES : + // Retourne la première taille du tableau + inline int Taille1 () const { return taille1; }; + // Retourne la deuxième taille du tableau + inline int Taille2 () const{ return taille2; }; + // Retourne la troisième taille du tableau + inline int Taille3 () const{ return taille3; }; + // Retourne la quatrième taille du tableau + inline int Taille4 () const{ return taille4; }; + // gestion d'erreur + // cette fonction n'est plus valable d'où la surcharge pour filtrer les + // appels éventuels + inline int Taille () const + { + cout << "\nErreur : fonction non disponible \n" ; + cout << "Tableau4_T::Taille () \n"; + Sortie(1); + return 0; // pour éviter le warning + }; + + inline T& operator() (int i, int j, int k, int l) + // Retourne la (ieme,jeme) composante du tableau : acces en lecture et ecriture + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille1) || (j<1) || (j>taille2) + || (k<1) || (k>taille3) || (l<1) || (l>taille4)) + { cout << "\nErreur : composante inexistante !, (i,j) demandé = (" << i + << ',' << j << ","<t[taille4*((k-1) + taille3*((j-1)+taille2*(i-1))) + l-1]; + }; + inline T operator() (int i, int j, int k, int l) const + // Retourne la (ieme,jeme) composante du tableau : acces en lecture uniquement + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille1) || (j<1) || (j>taille2) + || (k<1) || (k>taille3) || (l<1) || (l>taille4)) + { cout << "\nErreur : composante inexistante !, (i,j) demandé = (" << i + << ',' << j << ","<t[taille4*((k-1) + taille3*((j-1)+taille2*(i-1))) + l-1]; + }; + + inline int operator!= (const Tableau4& tab) const + // Surcharge de l'operateur != + // Renvoie 1 si les deux tableaux ne sont pas egaux + // Renvoie 0 sinon + { if ( (*this)==tab ) // test de l'egalite des deux tableaux a l'aide + // de l'operateur surcharge == + return 0; + else + return 1; + }; + + // Surcharge de l'operateur == + int operator== (const Tableau4& tab) const ; + // const {return ((*this)==tab); }; + + // Surcharge de l'operateur d'affectation = + Tableau4& operator= (const Tableau4& tab); + + // Change la taille du tableau (la nouvelle taille est n) + // uniquement valable pour les tableaux de dimension identique + // N.B. : Si la nouvelle taille est superieure a l'ancienne alors le tableau est + // complete par defaut, mais les valeurs anciennes et nouvelles sont mises à la valeur par défaut de T + // contrairement au Tableau_T + void Change_taille (int n); + // Change la taille du tableau (les nouvelles tailles sont n1 et n2,n3,n4) + // et toutes les valeurs sont initialisées à la valeur par défaut de T + void Change_taille (int n1, int n2,int n3, int n4); + // Change la taille du tableau (la nouvelle taille est n) + // et initialisation de toutes les valeurs, anciennes et nouvelles à tb + void Change_taille (int n,T& tb) + { cout << "\n fonction non disponible pour des tableaux a quatre dim" + << "\n Tableau4::Change_taille (int n,T& tb)"; Sortie(1); }; + // Permet de desallouer l'ensemble des elements du tableau + void Libere (); + + + protected : + int taille1; // la première taille du tableau + int taille2; // seconde taille du tableau + int taille3; // troisième taille du tableau + int taille4; // quatrième taille du tableau + + }; +/// @} // end of group + +//================================= def des differents elements ================== + +// Constructeur par defaut +template +inline Tableau4::Tableau4 () : + Tableau (),taille1(0),taille2(0),taille3(0),taille4(0) +{ } + +// Constructeur fonction de la taille du tableau +// dans le cas d'une taille identique +template +inline Tableau4::Tableau4 (const int nb) : + Tableau (nb*nb*nb*nb),taille1(nb),taille2(nb),taille3(nb),taille4(nb) + { } +// cas de deux dimensions différentes +template +inline Tableau4::Tableau4 (const int nb1,const int nb2,const int nb3,const int nb4) : + Tableau (nb1*nb2*nb3*nb4),taille1(nb1),taille2(nb2),taille3(nb3),taille4(nb4) + { } +// Constructeur fonction de la taille du tableau et d'une +// valeur d'initialisation pour les composantes + //1) tableau de dim identique +template +inline Tableau4::Tableau4 (const int nb,const T& val) : + Tableau (nb*nb*nb*nb,val),taille1(nb),taille2(nb),taille3(nb),taille4(nb) + { } + //2) tableau rectangulaire +template +inline Tableau4::Tableau4 (const int nb1,const int nb2,const int nb3,const int nb4,const T& val) : + Tableau (nb1*nb2*nb3*nb4,val),taille1(nb1),taille2(nb2),taille3(nb3),taille4(nb4) + { } +// Constructeur de copie +template +inline Tableau4::Tableau4 (const Tableau4 & tab) : + Tableau (tab),taille1(tab.taille1),taille2(tab.taille2) + ,taille3(tab.taille3),taille4(tab.taille4) + { } +// DESTRUCTEUR : +template +inline Tableau4::~Tableau4 () +{ Libere(); } + +// METHODES : +template +inline Tableau4 & Tableau4::operator= (const Tableau4 & tab) +// Surcharge de l'operateur = : realise l'egalite entre deux tableaux de pointeurs +{ Tableau & T1 = *this; + //this->Tableau::operator= (T1,T2); + T1 = (Tableau) tab; + taille1 = tab.taille1;taille2 = tab.taille2; + taille3 = tab.taille3;taille4 = tab.taille4; + return (*this); +} + +// Change la taille du tableau (la nouvelle taille est n) +// uniquement valable pour les tableaux carrés +// N.B. : Si la nouvelle taille est superieure a l'ancienne alors le tableau est +// complete par defaut +template +inline void Tableau4::Change_taille (int n) + { + #ifdef MISE_AU_POINT + if ((taille1 != taille2) || (taille1 != taille3) || (taille1 != taille4) + || (taille2 != taille3) || (taille2 != taille4)) + { cout << "\nErreur : le changement de taille demande n'est valide que pour des tableaux de meme 4 dimensions," + << " ici taille 1= " << taille1 << " et taille2 = " << taille2 + << " et taille3 = " << taille3 << " et taille4 = " << taille4<< '\n'; + cout << "Tableau4::Change_taille (int n) \n"; + Sortie(1); + }; + if ( n < 0) + { cout << "\nErreur : la nouvelle taille demandée est négative , n= " << n << '\n'; + cout << "Tableau4::Change_taille (int n) \n"; + Sortie(1); + }; + #endif + if (n != taille1) + { // on intervient que si la nouvelle dimension est différente + T tb; // def d'une valeur par défaut + // déf du tableau avec initialisation à tb + this->Tableau::Change_taille (n*n*n*n,tb); + taille1 = n; taille2 = n;taille3 = n;taille4 = n; + } + } +// Change la taille du tableau (les nouvelles tailles sont n1 et n2) +template +inline void Tableau4::Change_taille (int n1, int n2,int n3, int n4) + { + #ifdef MISE_AU_POINT + if (( n1 < 0) || (n2 < 0) || (n3<0) || (n4<0)) + { cout << "\nErreur : une des nouvelles tailles demandée est négative , n1= " << n1 << " n2 = " << n2 + << " n3 = " << n3 << " n4 = " << n4 <<'\n'; + cout << "Tableau4::Change_taille (int n1,int n2,int n3, int n4) \n"; + Sortie(1); + }; + #endif + if ( (n1 != taille1) || (n2 != taille2) || (n3 != taille3) || (n4 != taille4)) + // dans le cas où il y a un changement de taille on répercute + { // dimensionnement du nouveau tableau + T tb; // def d'une valeur par défaut + // déf du tableau avec initialisation à tb + this->Tableau::Change_taille (n1*n2*n3*n4,tb); + taille1 = n1; taille2 = n2;taille3 = n3;taille4 = n4; + } + } + +// Permet de desallouer l'ensemble des elements du tableau +template +inline void Tableau4::Libere () + { this->Tableau::Libere (); + taille1 = 0; taille2 = 0; taille3 = 0;taille4 = 0; + } +// Surcharge de l'operateur == +template +inline int Tableau4::operator== (const Tableau4& tab) const + { if ((tab.taille1 != taille1) || (tab.taille2 != taille2) + || (tab.taille3 != taille3) || (tab.taille4 != taille4)) + return 0; + else + return this->Tableau::operator== (tab); + } + +#endif diff --git a/Tableaux/Tableau_3D.cc b/Tableaux/Tableau_3D.cc new file mode 100644 index 0000000..d53a650 --- /dev/null +++ b/Tableaux/Tableau_3D.cc @@ -0,0 +1 @@ +// FICHIER : Tableau_3D.cc // CLASSE : Tableau_3D // 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-2021 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . #include using namespace std; #include #include "Sortie.h" #include "Tableau_3D.h" Tableau_3D::Tableau_3D () // Constructeur par defaut { dim1=0; dim2=0; dim3=0; t=NULL; }; Tableau_3D::Tableau_3D (int d1,int d2,int d3,double val) // Constructeur utile quand les trois dimensions ainsi qu'une // eventuelle valeur d'initialisation sont connues { if ( ( d1<0 ) || ( d2<0 ) || ( d3<0 ) ) { cout << "\nErreur : taille(s) invalide(s) !\n"; cout << "TABLEAU_3D::TABLEAU_3D(int ,int ,int ,double ) \n"; Sortie(1); }; if ( ( d1==0 ) || ( d2==0 ) || ( d3==0 ) ) // cas ou une des dimensions est nulle : initialisation identique // a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; t=NULL; } else // autres cas { dim1=d1; dim2=d2; dim3=d3; t=new double [d1*d2*d3]; // allocation dynamique de la memoire Initialise(val); // initialisation des composantes a val }; }; Tableau_3D::Tableau_3D (const Tableau_3D& tab) // Constructeur de copie { if ( tab.dim1==0 ) // cas ou le tableau copie est vide : initialisation // identique a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; t=NULL; } else { dim1=tab.dim1; dim2=tab.dim2; dim3=tab.dim3; t=new double [dim1*dim2*dim3]; // allocation dynamique de la memoire double* ptr1=t; double* ptr2=tab.t; for (int i=0;i0 ) delete [] t; // desallocation de la place memoire else { if ( t!=NULL ) { cout << "\nErreur de liberation de la place memoire\n"; cout << "TABLEAU_3D::LIBERE() \n"; Sortie(1); } }; t=NULL; dim1=0; dim2=0; dim3=0; }; Tableau_3D& Tableau_3D::operator= (const Tableau_3D& tab) // Surcharge de l'operateur = : egalite entre deux tableaux a trois dimensions { if ( t!=NULL ) Libere(); // cas ou le tableau se trouvant a gauche du signe = // n'est pas vide : desallocation de ce tableau if ( tab.dim1==0 ) // cas ou le tableau se trouvant a droite du signe = est vide : initialisation // identique a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; t=NULL; } else // autres cas { dim1=tab.dim1; dim2=tab.dim2; dim3=tab.dim3; t=new double [dim1*dim2*dim3]; // allocation de la place memoire double* ptr1=t; double* ptr2=tab.t; // copie des elements du tableau se trouvant a droite dans le tableau se trouvant // a gauche du signe d'affectation for (int i=0;i. +// +// Herezh++ is distributed under GPL 3 license ou ultérieure. +// +// Copyright (C) 1997-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + + +/************************************************************************ + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * La classe Tableau_3D permet de declarer des tableaux a trois dimensions dont + * les composantes sont de type double. + * Les composantes d'une instance de cette classe sont stockees en ligne et la memoire + * est allouee dynamiquement. + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +// La classe Tableau_3D permet de declarer des tableaux a trois dimensions dont +// les composantes sont de type double. +// Les composantes d'une instance de cette classe sont stockees en ligne et la memoire +// est allouee dynamiquement. + + +#ifndef TABLEAU_3D_H +#define TABLEAU_3D_H + + +#include +#include +#include "Sortie.h" + + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +class Tableau_3D +{ + + + public : + + + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau_3D (); + + // Constructeur utile quand les trois dimensions ainsi qu'une + // eventuelle valeur d'initialisation sont connues + Tableau_3D (int d1,int d2,int d3,double val=0.0); + + // Constructeur de copie + Tableau_3D (const Tableau_3D& tab); + + + // DESTRUCTEUR : + + ~Tableau_3D (); + + + // METHODES : + + inline void Affiche () const + // Affiche les donnees du tableau a trois dimensions + { + + cout << "Tableau 3D\n"; + cout << "Dimension 1 : " << Taille1() << " .\n"; + cout << "Dimension 2 : " << Taille2() << " .\n"; + cout << "Dimension 3 : " << Taille3() << " .\n"; + cout << "Composante(s) :\n{\n"; + for (int i=0;idim1) || (j<1) || (j>dim2) || (k<1) || (k>dim3) ) + { + cout << "\nErreur : composante inexistante !\n"; + cout << "TABLEAU_3D::OPERATOR[](int ,int ,int ) \n"; + Sortie(1); + }; + return *(t+dim3*dim2*(i-1)+dim3*(j-1)+(k-1)); + + }; + + // Initialisation des composantes du tableau + void Initialise (double val=0.0); + + // Desallocation des composantes du tableau + void Libere (); + + // Surcharge de l'operateur = : egalite entre deux tableaux a trois dimensions + Tableau_3D& operator= (const Tableau_3D& tab); + + + protected : + + + int dim1; // dimension dans la premiere direction + int dim2; // dimension dans la seconde direction + int dim3; // dimension dans la troisieme direction + double* t; // tableau des composantes + + +}; +/// @} // end of group + + +#endif diff --git a/Tableaux/Tableau_4D.cc b/Tableaux/Tableau_4D.cc new file mode 100644 index 0000000..925eb04 --- /dev/null +++ b/Tableaux/Tableau_4D.cc @@ -0,0 +1 @@ +// FICHIER : Tableau_4D.cc // CLASSE : Tableau_4D // 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-2021 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . #include using namespace std; #include #include "Tableau_4D.h" Tableau_4D::Tableau_4D () // Constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; t=NULL; }; Tableau_4D::Tableau_4D (int d1,int d2,int d3,int d4,double val) // Constructeur utile quand les quatre dimensions ainsi qu'une // eventuelle valeur d'initialisation sont connues { if ( ( d1<0 ) || ( d2<0 ) || ( d3<0 ) || ( d4<0 ) ) { cout << "\nErreur : taille(s) invalide(s) !\n"; cout << "TABLEAU_4D::TABLEAU_4D(int ,int ,int ,int ,double ) \n"; exit(1); }; if ( ( d1==0 ) || ( d2==0 ) || ( d3==0 ) || ( d4==0 ) ) // cas ou une des dimensions est nulle : initialisation identique // a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; t=NULL; } else // autres cas { dim1=d1; dim2=d2; dim3=d3; dim4=d4; t=new double [d1*d2*d3*d4]; // allocation dynamique de la memoire Initialise(val); // initialisation des composantes a val }; }; Tableau_4D::Tableau_4D (const Tableau_4D& tab) // Constructeur de copie { if ( tab.dim1==0 ) // cas ou le tableau copie est vide : initialisation // identique a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; t=NULL; } else { dim1=tab.dim1; dim2=tab.dim2; dim3=tab.dim3; dim4=tab.dim4; t=new double [dim1*dim2*dim3*dim4]; // allocation dynamique de la memoire double* ptr1=t; double* ptr2=tab.t; for (int i=0;i0 ) delete [] t; // desallocation de la place memoire else { if ( t!=NULL ) { cout << "\nErreur de liberation de la place memoire\n"; cout << "TABLEAU_4D::LIBERE() \n"; exit(1); } }; t=NULL; dim1=0; dim2=0; dim3=0; dim4=0; }; Tableau_4D& Tableau_4D::operator= (const Tableau_4D& tab) // Surcharge de l'operateur = : egalite entre deux tableaux a quatre dimensions { if ( t!=NULL ) Libere(); // cas ou le tableau se trouvant a gauche du signe = // n'est pas vide : desallocation de ce tableau if ( tab.dim1==0 ) // cas ou le tableau se trouvant a droite du signe = est vide : initialisation // identique a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; t=NULL; } else // autres cas { dim1=tab.dim1; dim2=tab.dim2; dim3=tab.dim3; dim4=tab.dim4; t=new double [dim1*dim2*dim3*dim4]; // allocation de la place memoire double* ptr1=t; double* ptr2=tab.t; // copie des elements du tableau se trouvant a droite dans le tableau se trouvant // a gauche du signe d'affectation for (int i=0;i. +// +// Herezh++ is distributed under GPL 3 license ou ultérieure. +// +// Copyright (C) 1997-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + + +/************************************************************************ + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * La classe Tableau_4D permet de declarer des tableaux a quatre dimensions dont + * les composantes sont de type double. + * Les composantes d'une instance de cette classe sont stockees en ligne et la memoire + * est allouee dynamiquement. + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +// La classe Tableau_4D permet de declarer des tableaux a quatre dimensions dont +// les composantes sont de type double. +// Les composantes d'une instance de cette classe sont stockees en ligne et la memoire +// est allouee dynamiquement. + + +#ifndef TABLEAU_4D_H +#define TABLEAU_4D_H + + +#include +#include +#include "Sortie.h" + + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +class Tableau_4D +{ + + + public : + + + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau_4D (); + + // Constructeur utile quand les quatre dimensions ainsi qu'une + // eventuelle valeur d'initialisation sont connues + Tableau_4D (int d1,int d2,int d3,int d4,double val=0.0); + + // Constructeur de copie + Tableau_4D (const Tableau_4D& tab); + + + // DESTRUCTEUR : + + ~Tableau_4D (); + + + // METHODES : + + inline void Affiche () + // Affiche les donnees du tableau a trois dimensions + { + + cout << "Tableau 4D\n"; + cout << "Dimension 1 : " << Taille1() << " .\n"; + cout << "Dimension 2 : " << Taille2() << " .\n"; + cout << "Dimension 3 : " << Taille3() << " .\n"; + cout << "Dimension 4 : " << Taille4() << " .\n"; + cout << "Composante(s) :\n{\n"; + for (int i=0;idim1) || (j<1) || (j>dim2) + || (k<1) || (k>dim3) || (l<1) || (l>dim4) ) + { + cout << "\nErreur : composante inexistante !\n"; + cout << "TABLEAU_4D::OPERATOR[](int ,int ,int ,int ) \n"; + Sortie(1); + }; + return *(t+dim4*dim3*dim2*(i-1)+dim4*dim3*(j-1)+dim4*(k-1)+(l-1)); + + }; + + // Initialisation des composantes du tableau + void Initialise (double val=0.0); + + // Desallocation des composantes du tableau + void Libere (); + + // Surcharge de l'operateur = : egalite entre deux tableaux a quatre dimensions + Tableau_4D& operator= (const Tableau_4D& tab); + + + protected : + + + int dim1; // dimension dans la premiere direction + int dim2; // dimension dans la seconde direction + int dim3; // dimension dans la troisieme direction + int dim4; // dimension dans la quatrieme direction + double* t; // tableau des composantes + + +}; +/// @} // end of group + + +#endif diff --git a/Tableaux/Tableau_5D.cc b/Tableaux/Tableau_5D.cc new file mode 100644 index 0000000..d98e636 --- /dev/null +++ b/Tableaux/Tableau_5D.cc @@ -0,0 +1 @@ + // 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-2021 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . // FICHIER : Tableau_5D.cp // CLASSE : Tableau_5D #include using namespace std; #include #include "Tableau_5D.h" Tableau_5D::Tableau_5D () // Constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; dim5=0; t=NULL; }; Tableau_5D::Tableau_5D (int d1,int d2,int d3,int d4,int d5,double val) // Constructeur utile quand les cinq dimensions ainsi qu'une // eventuelle valeur d'initialisation sont connues { if ( ( d1<0 ) || ( d2<0 ) || ( d3<0 ) || ( d4<0 ) || ( d5<0 ) ) { cout << "\nErreur : taille(s) invalide(s) !\n"; cout << "TABLEAU_5D::TABLEAU_5D(int ,int ,int ,int ,int ,double ) \n"; exit(1); }; if ( ( d1==0 ) || ( d2==0 ) || ( d3==0 ) || ( d4==0 ) || ( d5==0 ) ) // cas ou une des dimensions est nulle : initialisation identique // a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; dim5=0; t=NULL; } else // autres cas { dim1=d1; dim2=d2; dim3=d3; dim4=d4; dim5=d5; t=new double [d1*d2*d3*d4*d5]; // allocation dynamique de la memoire Initialise(val); // initialisation des composantes a val }; }; Tableau_5D::Tableau_5D (const Tableau_5D& tab) // Constructeur de copie { if ( tab.dim1==0 ) // cas ou le tableau copie est vide : initialisation // identique a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; dim5=0; t=NULL; } else { dim1=tab.dim1; dim2=tab.dim2; dim3=tab.dim3; dim4=tab.dim4; dim5=tab.dim5; t=new double [dim1*dim2*dim3*dim4*dim5]; // allocation dynamique de la memoire double* ptr1=t; double* ptr2=tab.t; for (int i=0;i0 ) delete [] t; // desallocation de la place memoire else { if ( t!=NULL ) { cout << "\nErreur de liberation de la place memoire\n"; cout << "TABLEAU_5D::LIBERE() \n"; exit(1); } }; t=NULL; dim1=0; dim2=0; dim3=0; dim4=0; dim5=0; }; Tableau_5D& Tableau_5D::operator= (const Tableau_5D& tab) // Surcharge de l'operateur = : egalite entre deux tableaux a cinq dimensions { if ( t!=NULL ) Libere(); // cas ou le tableau se trouvant a gauche du signe = // n'est pas vide : desallocation de ce tableau if ( tab.dim1==0 ) // cas ou le tableau se trouvant a droite du signe = est vide : initialisation // identique a l'appel du constructeur par defaut { dim1=0; dim2=0; dim3=0; dim4=0; dim5=0; t=NULL; } else // autres cas { dim1=tab.dim1; dim2=tab.dim2; dim3=tab.dim3; dim4=tab.dim4; dim5=tab.dim5; t=new double [dim1*dim2*dim3*dim4*dim5]; // allocation de la place memoire double* ptr1=t; double* ptr2=tab.t; // copie des elements du tableau se trouvant a droite dans le tableau se trouvant // a gauche du signe d'affectation for (int i=0;i. +// +// Herezh++ is distributed under GPL 3 license ou ultérieure. +// +// Copyright (C) 1997-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + + +/************************************************************************ + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * La classe Tableau_5D permet de declarer des tableaux a cinq dimensions dont + * les composantes sont de type double. + * Les composantes d'une instance de cette classe sont stockees en ligne et la memoire + * est allouee dynamiquement. + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +// La classe Tableau_5D permet de declarer des tableaux a cinq dimensions dont +// les composantes sont de type double. +// Les composantes d'une instance de cette classe sont stockees en ligne et la memoire +// est allouee dynamiquement. + + +#ifndef TABLEAU_5D_H +#define TABLEAU_5D_H + + +#include +#include +#include "Sortie.h" + + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +class Tableau_5D +{ + + + public : + + + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau_5D (); + + // Constructeur utile quand les cinq dimensions ainsi qu'une + // eventuelle valeur d'initialisation sont connues + Tableau_5D (int d1,int d2,int d3,int d4,int d5,double val=0.0); + + // Constructeur de copie + Tableau_5D (const Tableau_5D& tab); + + + // DESTRUCTEUR : + + ~Tableau_5D (); + + + // METHODES : + + inline void Affiche () + // Affiche les donnees du tableau a cinq dimensions + { + + cout << "Tableau 5D\n"; + cout << "Dimension 1 : " << Taille1() << " .\n"; + cout << "Dimension 2 : " << Taille2() << " .\n"; + cout << "Dimension 3 : " << Taille3() << " .\n"; + cout << "Dimension 4 : " << Taille4() << " .\n"; + cout << "Dimension 5 : " << Taille5() << " .\n"; + cout << "Composante(s) :\n{\n"; + for (int i=0;idim1) || (j<1) || (j>dim2) + || (k<1) || (k>dim3) || (l<1) || (l>dim4) || (m<1) || (m>dim5) ) + { + cout << "\nErreur : composante inexistante !\n"; + cout << "TABLEAU_3D::OPERATOR[](int ,int ,int ) \n"; + Sortie(1); + }; + return *(t+dim5*dim4*dim3*dim2*(i-1)+dim5*dim4*dim3*(j-1)+dim5*dim4*(k-1) + +dim5*(l-1)+(m-1)); + + }; + + // Initialisation des composantes du tableau + void Initialise (double val=0.0); + + // Desallocation des composantes du tableau + void Libere (); + + // Surcharge de l'operateur = : egalite entre deux tableaux a cinq dimensions + Tableau_5D& operator= (const Tableau_5D& tab); + + + protected : + + + int dim1; // dimension dans la premiere direction + int dim2; // dimension dans la seconde direction + int dim3; // dimension dans la troisieme direction + int dim4; // dimension dans la quatrieme direction + int dim5; // dimension dans la cinquieme direction + double* t; // tableau des composantes + + +}; +/// @} // end of group + + +#endif diff --git a/Tableaux/Tableau_T.h b/Tableaux/Tableau_T.h new file mode 100644 index 0000000..5556633 --- /dev/null +++ b/Tableaux/Tableau_T.h @@ -0,0 +1,889 @@ +// FICHIER : Tableau_T.h +// CLASSE : Tableau_T + +// 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-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + + +/************************************************************************ + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: La classe Tableau_T permet de declarer des tableaux de * + * longueur determinee et dont les composantes sont du type T fixe * + * a la declaration d'un objet de cette classe. L'operateur = doit * + * etre surcharge pour les objets de la classe T. * + * L'allocation memoire est dynamique et permet de declarer des * + * tableaux de tailles indifferentes. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef TABLEAU_T_H +#define TABLEAU_T_H + + +//#include "Debug.h" +#include +#include + +using namespace std; //introduces namespace std + +#include "Sortie.h" +#include +#include +#include "ParaGlob.h" + +/** @defgroup Les_Tableaux_generiques +* +* BUT: groupe des tableaux génériques: typiquement des templates, mais pas seulement +* +* +* \author Gérard Rio +* \version 1.0 +* \date 23/01/97 +* \brief groupe des tableaux génériques: typiquement des templates, mais pas seulement +* +*/ + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +template +class Tableau +{ + + // surcharge de l'operator d'ecriture + friend ostream & operator << (ostream & sort, const Tableau & tab) + { // tout d'abord un indicateur donnant le type + sort << "Tableau :taille= " << tab.taille << " "; + for (int i=0;i & tab ) + { if (tab.taille > 0) + {sort << "\n le premier element du tableau pour info: "; + sort << tab.t[0] ; + sort << endl;}; + } + + + public : + + + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau (); + + // Constructeur fonction de la taille du tableau + Tableau (int nb); + + // Constructeur fonction de la taille du tableau et d'une + // valeur d'initialisation pour les composantes + Tableau (int nb,T val); + + // Constructeur fonction de la taille du tableau et d'une + // référence: pas facile à faire car ensuite on manipule des pointeurs de références !! + // bref on ne sait pas ce que l'on fait , dans ce cas il vaut mieux utiliser + // un tableau de pointeur de la grandeur en question + + // Constructeur fonction d'un tableau de composantes de type T + Tableau (int nb,T* tab); + + // Constructeur de copie + Tableau (const Tableau & tab); + + + // DESTRUCTEUR : + + ~Tableau (); + + + // METHODES : + + inline int Taille () const + // Retourne la taille du tableau + { return taille; }; + + // Retourne la ieme composante du tableau : acces en lecture et ecriture + T& operator() (int i) const; + + // cas particulier ou l'on ne veut pas modifier les valeurs + const T val_const(int i) const; + const T& ref_const(int i) const; + + // Surcharge de l'operateur != + // Renvoie 1 si les deux tableaux ne sont pas egaux + // Renvoie 0 sinon + int operator!= (const Tableau& tab) const; + + // Surcharge de l'operateur == + int operator== (const Tableau& tab) const ; + + // Surcharge de l'operateur d'affectation = + Tableau& operator= (const Tableau& tab); + + // Change la taille du tableau (la nouvelle taille est n) + void Change_taille (int n); + // Change la taille du tableau (la nouvelle taille est n) + // et initialisation de toutes les valeurs, anciennes et nouvelles à tb + void Change_taille (int n,const T& tb); + + // Enleve la ieme composante du tableau + void Enleve (int i); + + // Enleve toutes les composantes du tableau dont la valeur est val + void Enleve_val (T val); + + // Permet de desallouer l'ensemble des elements du tableau + void Libere (); + + // initialisation d'un tableau à partir d'une liste + // premier du tableau == premier de la liste + void Init_from_list(const list & liste ); + + // opération inverse: remplissage d'une liste à partir du tableau + // premier de la liste == premier du tableau + void Init_list(list & liste ); + + // opération de lecture sur un flot d'entrée + // les données sont le type puis la dimension puis les datas + istream & Entree(istream &); + + // les données sont le type puis la dimension puis les datas + // ici il n'y a pas redimentionnement du tableau si la taille est suffisante + istream & Entree_sans_redim(istream &); + + // lectures sur le flot si la taille du tableau est identique ou supérieure à celle lue + // retour d'un pointeur nulle + // sinon, si la taille lue est supérieure à la taille du tableau actuellement existant + // il y a création d'un nouveau tableau de même type avec la taille adéquate + // et retour d'un pointeur sur le nouveau tableau + Tableau * New_en_lecture_si_taille_superieur_a_lire(istream &); + + // opération d'écriture non formatée + // les données sont le type la dimension puis les datas, chacun + // séparé par un espace + ostream & Sortir(ostream &) const ; + // idem mais sans retour chariot à la fin + ostream & Sortir_sansRet(ostream &) const; + + // test si la valeur passée en argument apartient au tableau + // ramène 0 si ne contient pas + // ramène l'indice dans le tableau de la grandeur si appartenance + int Contient(const T& e) const; + + // initialisation avec la valeur passée en argument + bool Inita(const T& e) ; + + + protected : + + int taille; // taille du tableau + T* t; // pointeur sur les composantes du tableau + + +}; +/// @} // end of group + +// cas de la surcharge de la lecture : il y a deux cas a considérer +// 1) cas d'élément constant : dans ce cas la lecture est une erreur +// 2) cas d'élément non constant : lecture permise +// les deux fonctions sont en dehors de la classe car sinon dans la classe il y a pris en compte +// du fait d'avoir des éléments constants ou non ce qui n'a pas l'air évident à traité sinon par +// deux classes différentes + + +template +// surcharge de l'operator de lecture d'élément non constant + istream & operator >> (istream & entree, Tableau & tab) + { // vérification du type + string type; + entree >> type; + if (type != "Tableau") + {Sortie (1); + return entree; + }; + int dim; entree >> type >> dim; + int tabtaille = tab.Taille(); + if (dim != tabtaille) + tab.Change_taille(dim); + for (int i=1;i<=dim;i++) + entree >> tab(i); + return entree; + } + +//================================= def des differents elements ================== + + +template +inline Tableau::Tableau () +// Constructeur par defaut +{ taille=0; + t=NULL; +} + + +template +inline Tableau::Tableau (int nb) +// Constructeur devant etre utilise quand la dimension nb du tableau est connu +{ + #ifdef MISE_AU_POINT + if ( nb<0 ) + // cas ou la taille selectionnee est negative + { cout << "\nErreur : taille invalide !\n"; + cout << "TABLEAU_T::TABLEAU_T(int ) \n"; + Sortie(1); + }; + #endif + if ( nb==0 ) + // cas ou la taille selectionnee est nulle : initialisation identique a + // l'appel du constructeur par defaut + { taille=0; + t=NULL; + } + else + // autres cas + { taille=nb; + t=new T [taille]; // allocation de la place memoire + T* ptr=t; + for (int i=0;i +inline Tableau::Tableau (int nb, T val) +// Constructeur permettant de creer un tableau dont toutes les composantes +// sont egales a val +// N.B: La valeur de l'attribut defaut est fixee a val +{ // initialisation de l'element defaut + #ifdef MISE_AU_POINT + if ( nb<0 ) + // cas ou la taille selectionnee est negative + { cout << "\nErreur : taille invalide !\n"; + cout << "TABLEAU_T::TABLEAU_T(int ,T ) \n"; + Sortie(1); + }; + #endif + if ( nb==0 ) + // cas ou la taille selectionnee est nulle : initialisation identique a + // l'appel du constructeur par defaut + { taille=0; + t=NULL; + } + else + // autres cas + { taille=nb; + t=new T [taille]; // allocation de la place memoire + T* ptr=t; + for (int i=0;i +inline Tableau::Tableau (int nb,T* tab) +// Constructeur permettant de creer un tableau de taille nb dont les composantes +// sont initialisees a l'aide des valeurs de tab +// N.B.: tab doit avoir au moins nb composantes (aucun test n'est realise pour le +// verifier !!!) +{ + #ifdef MISE_AU_POINT + if ( nb<0 ) + // cas ou la taille selectionnee est negative + { cout << "\nErreur : taille invalide !\n"; + cout << "TABLEAU_T::TABLEAU_T(int ,T* ) \n"; + Sortie(1); + }; + #endif + if ( nb==0 ) + // cas ou la taille selectionnee est nulle : initialisation identique a + // l'appel du constructeur par defaut + { + taille=0; + t=NULL; + } + else + // autres cas + { + taille=nb; + t=new T [taille]; // allocation de la place memoire + T* ptr1=t; + T* ptr2=tab; + for (int i=0;i +inline Tableau::Tableau (const Tableau& tab) +// Constructeur de copie +{ if ( tab.taille==0 ) + // cas ou le tableau copie est vide : initialisation identique a l'appel + // du constructeur par defaut + { t=NULL; + taille=0; + } + else + // autres cas + { t=new T [tab.taille]; // allocation de la place memoire + T* ptr1=t; + T* ptr2=tab.t; + for (int i=0;i +inline Tableau::~Tableau () +// Destructeur (N.B. : Apres l'appel de ce destructeur le tableau est identique +// a ce qu'il aurait ete a la suite d'un appel du constructeur par defaut) +{ Libere(); } + +template void +inline Tableau::Change_taille (int n) +// Permet de modifier la taille du tableau +// N.B. : Si la nouvelle taille est superieure a l'ancienne alors le tableau est +// complete par defaut +{ + #ifdef MISE_AU_POINT + if ( n<0 ) + // cas ou la taille selectionnee est negative + { cout << "\nErreur : taille invalide !\n"; + cout << "TABLEAU_T::CHANGE_TAILLE(int ) \n"; + cout << " NB: taille actuelle = " << taille << " "; + Sortie(1); + } + #endif + if ( n == taille ) // taille identique , on ne fait rien + return; + if ( n==0 ) + // cas ou la taille selectionnee est nulle : initialisation identique a + // l'appel du constructeur par defaut + { + taille=0; + if ( t!= NULL) delete [] t; + t=NULL; + return ; + }; + T* tempo; + tempo=new T [n]; + T* ptr1=t; + T* ptr2=tempo; + if ( n<=taille ) + // cas ou la taille selectionnee est inferieure a la taille d'origine + { + for (int i=0;itaille ) + // cas ou la taille selectionnee est superieure a la taille d'origine + { + for (int i=0;i void +inline Tableau::Change_taille (int n,const T& tb) +// Change la taille du tableau (la nouvelle taille est n) +// et initialisation de toutes les valeurs, anciennes et nouvelles à tb +{ + #ifdef MISE_AU_POINT + if ( n<0 ) + // cas ou la taille selectionnee est negative + { cout << "\nErreur : taille invalide !\n"; + cout << "TABLEAU_T::CHANGE_TAILLE(int ) \n"; + cout << " NB: taille actuelle = " << taille << " "; + Sortie(1); + } + #endif + if ( n == taille ) // taille identique , on ne fait que l'initialisation + { T* ptr2= t; + for (int i=0;itaille ) + // cas ou la taille selectionnee est superieure a la taille d'origine + { + for (int i=0;i +#ifndef MISE_AU_POINT + inline +#endif +T& Tableau::operator() (int i) const + // Retourne la ieme composante du tableau : acces en lecture et ecriture + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille) ) + { cout << "\nErreur : composante inexistante !, nb demande = " << i << '\n'; + cout << "T& TABLEAU_T::OPERATOR() (int ) \n"; + cout << "\n pour info: taille actuelle du tableau = " << taille << " "; + Sortie(1); + }; + #endif + return t[i-1]; + } + + // cas particulier ou l'on ne veut pas modifier les valeurs +template +#ifndef MISE_AU_POINT + inline +#endif +const T Tableau::val_const(int i) const +//const T& Tableau::operator() (int i) const + // Retourne la ieme composante du tableau : acces en lecture seulement + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille) ) + { cout << "\nErreur : composante inexistante !, nb demande = " << i << '\n'; + cout << "T TABLEAU_T::OPERATOR() (int ) const \n"; + cout << "\n pour info: taille actuelle du tableau = " << taille << " "; + Sortie(1); + }; + #endif + T retour = t[i-1]; + return retour; + } + +// Retourne la référence constante à la ieme composante du tableau : acces en lecture seulement +template +#ifndef MISE_AU_POINT + inline +#endif +const T& Tableau::ref_const(int i) const +//const T& Tableau::operator() (int i) const + // Retourne la ieme composante du tableau : acces en lecture seulement + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille) ) + { cout << "\nErreur : composante inexistante !, nb demande = " << i << '\n'; + cout << "T TABLEAU_T::OPERATOR() (int ) const \n"; + cout << "\n pour info: taille actuelle du tableau = " << taille << " "; + Sortie(1); + }; + #endif + return t[i-1]; + } + +template +#ifndef MISE_AU_POINT + inline +#endif +int Tableau::operator!= (const Tableau& tab) const + // Surcharge de l'operateur != + // Renvoie 1 si les deux tableaux ne sont pas egaux + // Renvoie 0 sinon + { if ( (*this)==tab ) // test de l'egalite des deux tableaux a l'aide + // de l'operateur surcharge == + return 0; + else + return 1; + } + +template void +inline Tableau::Enleve (int i) +// Enleve la ieme composante du tableau en decrementant la taille +{ + #ifdef MISE_AU_POINT + if ( (i<1) || (i>taille) ) + { + cout << "\nErreur : composante inexistante "< void +inline Tableau::Enleve_val (T val) +// Enleve les composantes du tableau egales a val en decrementant la taille +{ + + T* tempo; + tempo=new T [taille]; + T* ptr1=t; + T* ptr2=tempo; + int nouvel_taille=taille; + for (int j=0;j void +inline Tableau::Libere () +// Apres l'appel de cette methode, le tableau est identique a ce qu'il aurait +// ete a la suite d'un appel du constructeur par defaut +{ + if ( taille>0 ) + delete [] t; // desallocation du tableau pointe par t + else + { + #ifdef MISE_AU_POINT + if ( t!=NULL ) + { cout << "\nErreur de liberation de la place memoire\n"; + cout << "TABLEAU_T::LIBERE() \n"; +// Affiche_premier_elem( cout); + Sortie(1); + } + #endif + }; + t=NULL; + taille=0; +} + +template void +inline Tableau::Init_from_list(const list & liste ) +// initialisation d'un tableau à partir d'une liste +{ int tail_liste = liste.size(); // récup de la tail de la liste + typename list::const_iterator ili,ilifin=liste.end(); + Change_taille(tail_liste); + int i=0; + for (ili=liste.begin();ili!=ilifin;ili++,i++) + t[i] = (*ili); +} + +template void +inline Tableau::Init_list(list & liste ) +// initialisation d'une liste à partir du tableau +// premier de la liste == premier du tableau +{ liste.clear(); // on initialise la liste + // on balaie le tableau et on remplit la liste + T* ptr1=t; + for (int i=0;i +inline Tableau & Tableau::operator= (const Tableau & tab) +// Surcharge de l'operateur = : realise l'egalite entre deux tableaux de pointeurs +{ + // on essaie d'optimiser un peu + // -- si les tableaux sont identiques en taille, on ne réaffecte pas + // on ne fait que la recopie + if (taille == tab.taille) + { // on n'examine que si la taille est non nulle + if (taille != 0) + { T* ptr1=t; + T* ptr2=tab.t; + for (int i=0;i +inline int Tableau::operator ==(const Tableau & tab) const +// Surcharge de l'operateur == +// Renvoie 1 si les deux tableaux sont egaux +// Renvoie 0 sinon +{ + + if ( tab.taille!=taille ) + return 0; + else + { + T* ptr1=t; + T* ptr2=tab.t; + for (int i=0;i +inline istream & Tableau::Entree(istream & entree) + { // vérification du type + string type; + entree >> type; + if (type != "Tableau") + {Sortie (1); + return entree; + } + int dime; entree >> type >> dime; + if (dime != taille) + Change_taille(dime); + for (int i=0;i> t[i]; + return entree; + } + +// opération de lecture sur un flot d'entrée sans redimentionnement +// les données sont le type puis la dimension puis les datas +// ici il n'y a pas redimentionnement du tableau si la taille est suffisente +template +inline istream & Tableau::Entree_sans_redim(istream & entree) + { // vérification du type + string type; + entree >> type; + if (type != "Tableau") + {Sortie (1); + return entree; + } + int dime; entree >> type >> dime; + if (dime > taille) // redimensionnement que si la taille est insuffisente + Change_taille(dime); + for (int i=0;i> t[i]; + return entree; + } + +// lectures sur le flot si la taille du tableau est identique ou supérieure à celle lue +// retour d'un pointeur nulle +// sinon, si la taille lue est supérieure à la taille du tableau actuellement existant +// il y a création d'un nouveau tableau de même type avec la taille adéquate +// et retour d'un pointeur sur le nouveau tableau +template +inline Tableau * Tableau::New_en_lecture_si_taille_superieur_a_lire(istream& entree) + { Tableau * pt_tableau = NULL; // init au cas courant + // vérification du type + string type; + entree >> type; + if (type != "Tableau") + {Sortie (1); + return pt_tableau; + } + int dime; entree >> type >> dime; + if (dime > taille) + { // on crée un nouveau tableau + pt_tableau = new Tableau(dime); + for (int i=0;i> pt_tableau->t[i]; + } + else + { // cas d'une dimension suffisante + for (int i=0;i> t[i]; + }; + return pt_tableau; + } + +// opération d'écriture non formatée +// les données sont le type la dimension puis les datas, chacun +// séparé par un espace +template +inline ostream & Tableau::Sortir( ostream & sort) const + { // tout d'abord un indicateur donnant le type + sort << "Tableau :taille= " << taille << " "; + for (int i=0;i +inline ostream & Tableau::Sortir_sansRet( ostream & sort) const + { // tout d'abord un indicateur donnant le type + sort << "Tableau :taille= " << taille << " "; + for (int i=0;i +inline int Tableau::Contient(const T& e) const + { for (int i=0;i +inline bool Tableau::Inita(const T& e) + { for (int i=0;i +//inline void Tableau::Affiche_premier_elem( ostream & sort) const +// { // on indique quelque infos sup pour la compréhension +// sort << "Tableau :taille= " << taille << " "; +// if (taille >0) +// {sort << "\n le premier element du tableau pour info: "; +// sort << t[0] ; +// sort << endl;}; +// } + + +//#include "ParaGlob.h" + +#endif diff --git a/Tableaux/Tableau_double.cc b/Tableaux/Tableau_double.cc new file mode 100644 index 0000000..1515276 --- /dev/null +++ b/Tableaux/Tableau_double.cc @@ -0,0 +1 @@ + // 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-2021 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . // définition d'un tableau de réel de dimension quelconque. Dans le cas ou la dimension est comprise // entre 1 et 20, on utilise des listes de réels pour allouer de la mémoire et pour la désallouer, ce qui // permet d'être beaucoup plus rapide que l'opérateur classique new. // la construstion de la classe s'appuit sur une spécialisation d'une classe template. #include "Tableau_double.h" // Constructeur fonction de la taille du tableau Tableau_double::Tableau_double (int nb) { #ifdef MISE_AU_POINT if ( nb<0 ) // cas ou la taille selectionnee est negative { cout << "\nErreur : taille invalide !\n"; cout << "Tableau_double::Tableau_double(int ) \n"; Sortie(1); }; #endif if ( nb!=0 ) { taille=nb; switch (nb) {/* case 1 : iapointe = new Reel1Pointe(); t = & (*(((Reel1Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; // initialisation break; case 2 : iapointe = new Reel2Pointe(); t = (*(((Reel2Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[2] = defaut; // initialisation break; case 3 : iapointe = new Reel3Pointe(); t = (*(((Reel3Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; // initialisation break;*/ case 4 : iapointe = new Reel4Pointe(); Reel4Pointe* toto = (Reel4Pointe*)iapointe; t = (*(((Reel4Pointe*)iapointe)->ipointe)).donnees; t[0] = 1; t[1] = 2; t[2] = 3; t[3] = 4;// initialisation break; /* case 5 : iapointe = new Reel5Pointe(); t = (*(((Reel5Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;// initialisation break; case 6 : iapointe = new Reel6Pointe(); t = (*(((Reel6Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;// initialisation break; case 7 : iapointe = new Reel7Pointe(); t = (*(((Reel7Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;// initialisation break; case 8 : iapointe = new Reel8Pointe(); t = (*(((Reel8Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut; // initialisation break; case 9 : iapointe = new Reel9Pointe(); t = (*(((Reel9Pointe*)iapointe)->ipointe)).donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; // initialisation break; /* case 10 : iapointe = new Reel10Pointe(); t = (*(((Reel10Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;// initialisation break; case 11 : iapointe = new Reel11Pointe(); t = (*(((Reel11Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;// initialisation break; case 12 : iapointe = new Reel12Pointe(); t = (*(((Reel12Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;// initialisation break; case 13 : iapointe = new Reel13Pointe(); t = (*(((Reel13Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut; // initialisation break; case 14 : iapointe = new Reel14Pointe(); t = (*(((Reel14Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; // initialisation break; case 15 : iapointe = new Reel15Pointe(); t = (*(((Reel15Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; t[14] = defaut;// initialisation break; case 16 : iapointe = new Reel16Pointe(); t = (*(((Reel16Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; t[14] = defaut;t[15] = defaut;// initialisation break; case 17 : iapointe = new Reel17Pointe(); t = (*(((Reel17Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; t[14] = defaut;t[15] = defaut;t[16] = defaut;// initialisation break; case 18 : iapointe = new Reel18Pointe(); t = (*(((Reel18Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; t[14] = defaut;t[15] = defaut;t[16] = defaut;t[17] = defaut; // initialisation break; case 19 : iapointe = new Reel19Pointe(); t = (*(((Reel19Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; t[14] = defaut;t[15] = defaut;t[16] = defaut;t[17] = defaut;t[18] = defaut; // initialisation break; case 20 : iapointe = new Reel20Pointe(); t = (*(((Reel20Pointe*)iapointe)->ipointe))->donnees; t[0] = defaut; t[1] = defaut; t[2] = defaut; t[3] = defaut; t[4] = defaut;t[5] = defaut;t[6] = defaut;t[7] = defaut;t[8] = defaut; t[9] = defaut;t[10] = defaut;t[11] = defaut;t[12] = defaut;t[13] = defaut; t[14] = defaut;t[15] = defaut;t[16] = defaut;t[17] = defaut;t[18] = defaut; t[19] = defaut; // initialisation break; */ default : // allocation classique t=new double [taille]; // allocation de la place memoire double* ptr=t; for (int i=0;iipointe)) ; // suppression de l'élément de la liste break; case 3 : delete ((Reel3Pointe*)iapointe); break; case 4 : Reel4Pointe* toto = (Reel4Pointe*)iapointe; delete toto; // delete ((Reel4Pointe*)iapointe); break; case 5 : delete ((Reel5Pointe*)iapointe); break; case 6 : delete ((Reel6Pointe*)iapointe); break; case 7 : delete ((Reel7Pointe*)iapointe); break; case 8 : delete ((Reel8Pointe*)iapointe); break; case 9 : delete ((Reel9Pointe*)iapointe); break; /* case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; case 3 : listdouble3.erase(*(((Reel3Pointe*)iapointe)->ipointe)) ; // suppression de l'élément de la liste break; /* default : // desallocation classique delete t=new double [taille]; // allocation de la place memoire double* ptr=t; for (int i=0;i. +// +// Herezh++ is distributed under GPL 3 license ou ultérieure. +// +// Copyright (C) 1997-2021 Université Bretagne Sud (France) +// AUTHOR : Gérard Rio +// E-MAIL : gerardrio56@free.fr +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// For more information, please consult: . + +/************************************************************************ + * * + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * définition d'un tableau de réel de dimension quelconque. Dans le cas ou la dimension est comprise + * entre 1 et 20, on utilise des listes de réels pour allouer de la mémoire et pour la désallouer, ce qui + * permet d'être beaucoup plus rapide que l'opérateur classique new. + * la construstion de la classe s'appuit sur une spécialisation d'une classe template. + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * * + * $ * + * * + ************************************************************************/ + + +// définition d'un tableau de réel de dimension quelconque. Dans le cas ou la dimension est comprise +// entre 1 et 20, on utilise des listes de réels pour allouer de la mémoire et pour la désallouer, ce qui +// permet d'être beaucoup plus rapide que l'opérateur classique new. + +// la construstion de la classe s'appuit sur une spécialisation d'une classe template. + +#ifndef TABLEAU_DOUBLE_H +#define TABLEAU_DOUBLE_H + +#include "Tableau_T.h" +#include "PtTabRel.h" + +/// @addtogroup Les_Tableaux_generiques +/// @{ +/// + + +class Tableau_double : public Tableau +{ + public : + // VARIABLES PUBLIQUES : + + // CONSTRUCTEURS : + // CONSTRUCTEURS : + + // Constructeur par defaut + Tableau_double () : + Tableau() + {}; + + // Constructeur fonction de la taille du tableau + Tableau_double (int nb); + + // Constructeur fonction de la taille du tableau et d'une + // valeur d'initialisation pour les composantes + Tableau_double (int nb,double val); + + // Constructeur fonction d'un tableau de double + Tableau_double (int nb,double* tab); + + // Constructeur de copie + Tableau_double (const Tableau_double & tab); + + // DESTRUCTEUR : + + ~Tableau_double (); + + + // METHODES : + + + // Surcharge de l'operateur d'affectation = + Tableau_double& operator= (const Tableau_double& tab); + + // Change la taille du tableau (la nouvelle taille est n) + void Change_taille (int n); + + // Enleve la ieme composante du tableau + void Enleve (int i); + + // Enleve toutes les composantes du tableau dont la valeur est val + void Enleve_val (double val); + + // Permet de desallouer l'ensemble des elements du tableau + void Libere (); + + protected : + // allocator dans la liste de data + // a priori on utilise un pointeur sur une liste de 3 réels, mais dans + // le constructeur et dans le destructeur, on effectue un cast vers le + // bon allocator qui normalement à la même dimension + ReelsPointe* iapointe; // pointeur générique + + + + }; + /// @} // end of group + +#endif diff --git a/Tableaux/utilDebug.h b/Tableaux/utilDebug.h new file mode 100644 index 0000000..1b881fc --- /dev/null +++ b/Tableaux/utilDebug.h @@ -0,0 +1 @@ + // 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-2021 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . /************************************************************************ * * * DATE: 23/01/97 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: outils pour la visualisation avec le debugger * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * * * $ * * * ************************************************************************/ #ifndef TABLE_H #define TABLE_H class Table33 { public : double A[3][3]; }; #endif \ No newline at end of file