introduction du répertoire Tableaux : correspond aux tableaux génériques et template
This commit is contained in:
parent
f43e5da7ec
commit
0e0f950eef
13 changed files with 2628 additions and 0 deletions
321
Tableaux/TabOper_T.h
Normal file
321
Tableaux/TabOper_T.h
Normal file
|
|
@ -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) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* 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 T>
|
||||
class TabOper : public Tableau<T>
|
||||
{
|
||||
|
||||
|
||||
public :
|
||||
|
||||
|
||||
// CONSTRUCTEURS :
|
||||
|
||||
// Constructeur par defaut
|
||||
TabOper () : Tableau<T>() {};
|
||||
|
||||
// Constructeur fonction de la taille du tableau
|
||||
TabOper (int nb) : Tableau<T>(nb) {};
|
||||
|
||||
// Constructeur fonction de la taille du tableau et d'une
|
||||
// valeur d'initialisation pour les composantes
|
||||
TabOper (int nb,T val) : Tableau<T>(nb,val) {};
|
||||
|
||||
// Constructeur fonction d'un tableau de composantes de type T
|
||||
TabOper (int nb,T* tab) : Tableau<T>(nb,tab) {} ;
|
||||
|
||||
// Constructeur de copie
|
||||
TabOper (const TabOper<T> & tab) : Tableau<T>(tab) {} ;
|
||||
|
||||
|
||||
// DESTRUCTEUR :
|
||||
|
||||
~TabOper (){};
|
||||
|
||||
// METHODES :
|
||||
// Surcharge de l'operateur + : addition entre deux tableaux
|
||||
TabOper<T> operator+ (const TabOper<T>& vec);
|
||||
|
||||
// Surcharge de l'operateur - : soustraction entre deux tableaux
|
||||
TabOper<T> operator- (const TabOper<T>& vec);
|
||||
|
||||
// Surcharge de l'operateur - : oppose d'un tableau
|
||||
//TabOper operator- ();
|
||||
TabOper<T> operator- ();
|
||||
|
||||
// Surcharge de l'operateur +=
|
||||
void operator+= (const TabOper<T>& vec);
|
||||
|
||||
// Surcharge de l'operateur -=
|
||||
void operator-= (const TabOper<T>& 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<T> operator* (double val);
|
||||
inline TabOper<T> operator* (double val);
|
||||
|
||||
// Surcharge de l'operateur / : division des composantes d'un vecteur par un scalaire
|
||||
TabOper<T> 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 <class T>
|
||||
TabOper<T> operator* (double val,TabOper<T>& vec)
|
||||
// Surcharge de l'operateur * : multiplication entre un scalaire et un tableau
|
||||
{ return (vec*val); };
|
||||
|
||||
|
||||
template <class T> TabOper<T>
|
||||
TabOper<T>::operator+ (const TabOper<T>& 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;i<this->taille;i++)
|
||||
// somme des composantes des deux tableaux vec et v, puis stockage
|
||||
// dans le tableau result
|
||||
(*ptr3++)=(*ptr1++)+(*ptr2++);
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T> TabOper<T>
|
||||
TabOper<T>::operator- (const TabOper<T>& 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;i<this->taille;i++)
|
||||
// soustraction des composantes des tableaux vec et v, puis stockage
|
||||
// dans le tableau result
|
||||
(*ptr3++)=(*ptr1++)-(*ptr2++);
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T> TabOper<T>
|
||||
TabOper<T>::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;i<this->taille;i++)
|
||||
(*ptr2++)=-(*ptr1++);
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T> void
|
||||
TabOper<T>::operator+= (const TabOper<T>& 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;i<this->taille;i++)
|
||||
(*ptr1++)+=(*ptr2++);
|
||||
}
|
||||
|
||||
template <class T> void
|
||||
TabOper<T>::operator-= (const TabOper<T>& 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;i<this->taille;i++)
|
||||
(*ptr1++)-=(*ptr2++);
|
||||
}
|
||||
|
||||
template <class T> void
|
||||
TabOper<T>::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;i<this->taille;i++)
|
||||
(*ptr++)*=val;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template <class T> TabOper <T>
|
||||
TabOper<T>::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 <class T> TabOper<T>
|
||||
TabOper<T>::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 <class T> void
|
||||
TabOper<T>::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;i<this->taille;i++)
|
||||
(*ptr++) /= val;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
// mise a zero d'un tableau
|
||||
void TabOper<T>::Zero()
|
||||
{ T* ptr=this->t;
|
||||
for (int i=0;i<this->taille;i++)
|
||||
// affectation des composantes du tableau a 0
|
||||
(*ptr++)=0.0;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
325
Tableaux/Tableau2_T.h
Normal file
325
Tableaux/Tableau2_T.h
Normal file
|
|
@ -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) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
/************************************************************************
|
||||
* 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 T>
|
||||
class Tableau2 : public Tableau <T>
|
||||
{
|
||||
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<T> & 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<T>& 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<T>& tab) const ;
|
||||
// const {return ((*this)==tab); };
|
||||
|
||||
// Surcharge de l'operateur d'affectation =
|
||||
Tableau2<T>& operator= (const Tableau2<T>& 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 <class T>
|
||||
inline Tableau2<T>::Tableau2 () :
|
||||
Tableau<T> ()
|
||||
{ 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 <class T>
|
||||
inline Tableau2<T>::Tableau2 (const int nb) :
|
||||
Tableau<T> (nb*nb)
|
||||
{ taille1=nb;taille2=nb;
|
||||
}
|
||||
// cas de deux dimensions différentes
|
||||
template <class T>
|
||||
inline Tableau2<T>::Tableau2 (const int nb1,const int nb2) :
|
||||
Tableau<T> (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 <class T>
|
||||
inline Tableau2<T>::Tableau2 (const int nb,const T& val) :
|
||||
Tableau<T> (nb*nb,val)
|
||||
{ taille1=nb;taille2=nb;
|
||||
}
|
||||
//2) tableau rectangulaire
|
||||
template <class T>
|
||||
inline Tableau2<T>::Tableau2 (const int nb1,const int nb2,const T& val) :
|
||||
Tableau<T> (nb1*nb2,val)
|
||||
{ taille1=nb1;taille2=nb2;
|
||||
}
|
||||
// Constructeur de copie
|
||||
template <class T>
|
||||
inline Tableau2<T>::Tableau2 (const Tableau2<T> & tab) :
|
||||
Tableau<T> (tab)
|
||||
{ taille1 = tab.taille1;
|
||||
taille2 = tab.taille2;
|
||||
}
|
||||
// DESTRUCTEUR :
|
||||
template <class T>
|
||||
inline Tableau2<T>::~Tableau2 ()
|
||||
{ Libere(); }
|
||||
|
||||
// METHODES :
|
||||
template <class T>
|
||||
inline Tableau2<T> & Tableau2<T>::operator= (const Tableau2<T> & tab)
|
||||
// Surcharge de l'operateur = : realise l'egalite entre deux tableaux de pointeurs
|
||||
{ Tableau<T> & T1 = *this;
|
||||
//this->Tableau<T>::operator= (T1,T2);
|
||||
T1 = (Tableau<T>) 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 <class T>
|
||||
inline void Tableau2<T>::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<T>::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<T>::Change_taille (int n) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
this->Tableau<T>::Change_taille (n*n);
|
||||
taille1 = n; taille2 = n;
|
||||
}
|
||||
// idem et initialisation de toutes les valeurs, anciennes et nouvelles à tb
|
||||
template <class T>
|
||||
inline void Tableau2<T>::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<T>::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<T>::Change_taille (int n) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
this->Tableau<T>::Change_taille (n*n,tb);
|
||||
taille1 = n; taille2 = n;
|
||||
}
|
||||
|
||||
// Change la taille du tableau (les nouvelles tailles sont n1 et n2)
|
||||
template <class T>
|
||||
inline void Tableau2<T>::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<T>::Change_taille (int n1,int n2) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
this->Tableau<T>::Change_taille (n1*n2);
|
||||
taille1 = n1; taille2 = n2;
|
||||
}
|
||||
// Permet de desallouer l'ensemble des elements du tableau
|
||||
template <class T>
|
||||
inline void Tableau2<T>::Libere ()
|
||||
{ this->Tableau<T>::Libere ();
|
||||
taille1 = 0; taille2 = 0;
|
||||
}
|
||||
// Surcharge de l'operateur ==
|
||||
template <class T>
|
||||
inline int Tableau2<T>::operator== (const Tableau2<T>& tab) const
|
||||
{ if ((tab.taille1 != taille1) || (tab.taille2 != taille2))
|
||||
return 0;
|
||||
else
|
||||
return this->Tableau<T>::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 <class T>
|
||||
inline void Tableau2<T>::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<T>::Change_taille (int n1,int n2) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
this->Tableau<T>::Change_taille (n1*n2,tb);
|
||||
taille1 = n1; taille2 = n2;
|
||||
}
|
||||
|
||||
#endif
|
||||
307
Tableaux/Tableau4_T.h
Normal file
307
Tableaux/Tableau4_T.h
Normal file
|
|
@ -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) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
/************************************************************************
|
||||
* 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 T>
|
||||
class Tableau4 : public Tableau <T>
|
||||
{
|
||||
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<T> & 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 << ","<<k <<","<<l<<")" << '\n';
|
||||
cout << "Tableau4_T::OPERATOR() (int, int, int, int ) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
return this->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 << ","<<k <<","<<l<<")" << '\n';
|
||||
cout << "Tableau4_T::OPERATOR() (int, int ) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
return this->t[taille4*((k-1) + taille3*((j-1)+taille2*(i-1))) + l-1];
|
||||
};
|
||||
|
||||
inline int operator!= (const Tableau4<T>& 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<T>& tab) const ;
|
||||
// const {return ((*this)==tab); };
|
||||
|
||||
// Surcharge de l'operateur d'affectation =
|
||||
Tableau4<T>& operator= (const Tableau4<T>& 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<T>::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 <class T>
|
||||
inline Tableau4<T>::Tableau4 () :
|
||||
Tableau<T> (),taille1(0),taille2(0),taille3(0),taille4(0)
|
||||
{ }
|
||||
|
||||
// Constructeur fonction de la taille du tableau
|
||||
// dans le cas d'une taille identique
|
||||
template <class T>
|
||||
inline Tableau4<T>::Tableau4 (const int nb) :
|
||||
Tableau<T> (nb*nb*nb*nb),taille1(nb),taille2(nb),taille3(nb),taille4(nb)
|
||||
{ }
|
||||
// cas de deux dimensions différentes
|
||||
template <class T>
|
||||
inline Tableau4<T>::Tableau4 (const int nb1,const int nb2,const int nb3,const int nb4) :
|
||||
Tableau<T> (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 <class T>
|
||||
inline Tableau4<T>::Tableau4 (const int nb,const T& val) :
|
||||
Tableau<T> (nb*nb*nb*nb,val),taille1(nb),taille2(nb),taille3(nb),taille4(nb)
|
||||
{ }
|
||||
//2) tableau rectangulaire
|
||||
template <class T>
|
||||
inline Tableau4<T>::Tableau4 (const int nb1,const int nb2,const int nb3,const int nb4,const T& val) :
|
||||
Tableau<T> (nb1*nb2*nb3*nb4,val),taille1(nb1),taille2(nb2),taille3(nb3),taille4(nb4)
|
||||
{ }
|
||||
// Constructeur de copie
|
||||
template <class T>
|
||||
inline Tableau4<T>::Tableau4 (const Tableau4<T> & tab) :
|
||||
Tableau<T> (tab),taille1(tab.taille1),taille2(tab.taille2)
|
||||
,taille3(tab.taille3),taille4(tab.taille4)
|
||||
{ }
|
||||
// DESTRUCTEUR :
|
||||
template <class T>
|
||||
inline Tableau4<T>::~Tableau4 ()
|
||||
{ Libere(); }
|
||||
|
||||
// METHODES :
|
||||
template <class T>
|
||||
inline Tableau4<T> & Tableau4<T>::operator= (const Tableau4<T> & tab)
|
||||
// Surcharge de l'operateur = : realise l'egalite entre deux tableaux de pointeurs
|
||||
{ Tableau<T> & T1 = *this;
|
||||
//this->Tableau<T>::operator= (T1,T2);
|
||||
T1 = (Tableau<T>) 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 <class T>
|
||||
inline void Tableau4<T>::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<T>::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<T>::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<T>::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 <class T>
|
||||
inline void Tableau4<T>::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<T>::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<T>::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 <class T>
|
||||
inline void Tableau4<T>::Libere ()
|
||||
{ this->Tableau<T>::Libere ();
|
||||
taille1 = 0; taille2 = 0; taille3 = 0;taille4 = 0;
|
||||
}
|
||||
// Surcharge de l'operateur ==
|
||||
template <class T>
|
||||
inline int Tableau4<T>::operator== (const Tableau4<T>& tab) const
|
||||
{ if ((tab.taille1 != taille1) || (tab.taille2 != taille2)
|
||||
|| (tab.taille3 != taille3) || (tab.taille4 != taille4))
|
||||
return 0;
|
||||
else
|
||||
return this->Tableau<T>::operator== (tab);
|
||||
}
|
||||
|
||||
#endif
|
||||
1
Tableaux/Tableau_3D.cc
Normal file
1
Tableaux/Tableau_3D.cc
Normal file
|
|
@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include <iostream>
using namespace std;
#include <stdlib.h>
#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;i<dim1;i++)
{
for (int j=0;j<dim2;j++)
{
for (int k=0;k<dim3;k++)
{
(*ptr1++)=(*ptr2++); // copie des composantes du tableau tab
};
};
};
};
};
Tableau_3D::~Tableau_3D ()
// 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();
};
void
Tableau_3D::Initialise (double val)
// Initialisation des composantes du tableau a trois dimensions
{
double* ptr=t;
for (int i=0;i<dim1;i++)
{
for (int j=0;j<dim2;j++)
{
for (int k=0;k<dim3;k++)
{
(*ptr++)=val; // initialisation des composantes a val
};
};
};
};
void
Tableau_3D::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 ( dim1>0 )
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<dim1;i++)
{
for (int j=0;j<dim2;j++)
{
for (int k=0;k<dim3;k++)
{
(*ptr1++)=(*ptr2++);
};
};
};
};
return (*this);
};
|
||||
197
Tableaux/Tableau_3D.h
Normal file
197
Tableaux/Tableau_3D.h
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
// FICHIER : Tableau_3D.h
|
||||
// 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) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* 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 <iostream>
|
||||
#include <stdlib.h>
|
||||
#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;i<dim1;i++)
|
||||
{
|
||||
cout << "\t[ ";
|
||||
for (int j=0;j<dim2;j++)
|
||||
{
|
||||
cout << "[ ";
|
||||
for (int k=0;k<dim3;k++)
|
||||
{
|
||||
cout << *(t+dim3*dim2*i+dim3*j+k) << " ";
|
||||
};
|
||||
cout << "] ";
|
||||
};
|
||||
cout << "] \n";
|
||||
};
|
||||
cout << "}\n\n";
|
||||
|
||||
};
|
||||
|
||||
inline int Taille1 () const
|
||||
// Retourne la taille de la premiere dimension
|
||||
{
|
||||
|
||||
return dim1;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille2 () const
|
||||
// Retourne la taille de la deuxieme dimension
|
||||
{
|
||||
|
||||
return dim2;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille3 () const
|
||||
// Retourne la taille de la troisieme dimension
|
||||
{
|
||||
|
||||
return dim3;
|
||||
|
||||
};
|
||||
|
||||
inline double& operator() (int i,int j,int k)
|
||||
// Retourne la ieme jieme kieme composante
|
||||
{
|
||||
|
||||
if ( (i<1) || (i>dim1) || (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
|
||||
1
Tableaux/Tableau_4D.cc
Normal file
1
Tableaux/Tableau_4D.cc
Normal file
File diff suppressed because one or more lines are too long
213
Tableaux/Tableau_4D.h
Normal file
213
Tableaux/Tableau_4D.h
Normal file
|
|
@ -0,0 +1,213 @@
|
|||
// FICHIER : Tableau_4D.h
|
||||
// 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) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* 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 <iostream>
|
||||
#include <stdlib.h>
|
||||
#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;i<dim1;i++)
|
||||
{
|
||||
cout << "( ";
|
||||
for (int j=0;j<dim2;j++)
|
||||
{
|
||||
cout << "\t[ ";
|
||||
for (int k=0;k<dim3;k++)
|
||||
{
|
||||
cout << "[ ";
|
||||
for (int l=0;l<dim4;l++)
|
||||
{
|
||||
cout << *(t+dim4*dim3*dim2*i+dim4*dim3*j+dim4*k+l) << " ";
|
||||
};
|
||||
cout << " ]";
|
||||
};
|
||||
cout << "] \n";
|
||||
};
|
||||
cout << ") \n";
|
||||
};
|
||||
cout << "}\n\n";
|
||||
|
||||
};
|
||||
|
||||
inline int Taille1 ()
|
||||
// Retourne la taille de la premiere dimension
|
||||
{
|
||||
|
||||
return dim1;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille2 ()
|
||||
// Retourne la taille de la deuxieme dimension
|
||||
{
|
||||
|
||||
return dim2;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille3 ()
|
||||
// Retourne la taille de la troisieme dimension
|
||||
{
|
||||
|
||||
return dim3;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille4 ()
|
||||
// Retourne la taille de la quatrieme dimension
|
||||
{
|
||||
|
||||
return dim4;
|
||||
|
||||
};
|
||||
|
||||
inline double& operator() (int i,int j,int k,int l)
|
||||
// Retourne la ieme jieme kieme lieme composante
|
||||
{
|
||||
|
||||
if ( (i<1) || (i>dim1) || (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
|
||||
1
Tableaux/Tableau_5D.cc
Normal file
1
Tableaux/Tableau_5D.cc
Normal file
File diff suppressed because one or more lines are too long
230
Tableaux/Tableau_5D.h
Normal file
230
Tableaux/Tableau_5D.h
Normal file
|
|
@ -0,0 +1,230 @@
|
|||
// FICHIER : Tableau_5D.h
|
||||
// CLASSE : Tableau_5D
|
||||
|
||||
// This file is part of the Herezh++ application.
|
||||
//
|
||||
// The finite element software Herezh++ is dedicated to the field
|
||||
// of mechanics for large transformations of solid structures.
|
||||
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
||||
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* 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 <iostream>
|
||||
#include <stdlib.h>
|
||||
#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;i<dim1;i++)
|
||||
{
|
||||
cout << "( ";
|
||||
for (int j=0;j<dim2;j++)
|
||||
{
|
||||
cout << "\t[ ";
|
||||
for (int k=0;k<dim3;k++)
|
||||
{
|
||||
cout << "[ ";
|
||||
for (int l=0;l<dim4;l++)
|
||||
{
|
||||
cout << "[ ";
|
||||
for (int m=0;m<dim5;m++)
|
||||
{
|
||||
cout << *(t+dim5*dim4*dim3*dim2*i+dim5*dim4*dim3*j
|
||||
+dim5*dim4*k+dim5*l+m) << " ";
|
||||
};
|
||||
cout << " ]";
|
||||
};
|
||||
cout << " ]";
|
||||
};
|
||||
cout << "] \n";
|
||||
};
|
||||
cout << ") \n";
|
||||
};
|
||||
cout << "}\n\n";
|
||||
|
||||
};
|
||||
|
||||
inline int Taille1 ()
|
||||
// Retourne la taille de la premiere dimension
|
||||
{
|
||||
|
||||
return dim1;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille2 ()
|
||||
// Retourne la taille de la deuxieme dimension
|
||||
{
|
||||
|
||||
return dim2;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille3 ()
|
||||
// Retourne la taille de la troisieme dimension
|
||||
{
|
||||
|
||||
return dim3;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille4 ()
|
||||
// Retourne la taille de la quatrieme dimension
|
||||
{
|
||||
|
||||
return dim4;
|
||||
|
||||
};
|
||||
|
||||
inline int Taille5 ()
|
||||
// Retourne la taille de la cinquieme dimension
|
||||
{
|
||||
|
||||
return dim5;
|
||||
|
||||
};
|
||||
|
||||
inline double& operator() (int i,int j,int k,int l,int m)
|
||||
// Retourne la ieme jieme kieme lieme mieme composante
|
||||
{
|
||||
|
||||
if ( (i<1) || (i>dim1) || (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
|
||||
889
Tableaux/Tableau_T.h
Normal file
889
Tableaux/Tableau_T.h
Normal file
|
|
@ -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) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* 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 <iostream>
|
||||
#include <stdlib.h>
|
||||
|
||||
using namespace std; //introduces namespace std
|
||||
|
||||
#include "Sortie.h"
|
||||
#include <iomanip>
|
||||
#include <string>
|
||||
#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 T>
|
||||
class Tableau
|
||||
{
|
||||
|
||||
// surcharge de l'operator d'ecriture
|
||||
friend ostream & operator << (ostream & sort, const Tableau<T> & tab)
|
||||
{ // tout d'abord un indicateur donnant le type
|
||||
sort << "Tableau :taille= " << tab.taille << " ";
|
||||
for (int i=0;i<tab.taille;i++)
|
||||
{ sort << setprecision(ParaGlob::NbdigdoCA()) << tab.t[i] ; sort << " "; }
|
||||
// sort << "\n";
|
||||
return sort;
|
||||
}
|
||||
|
||||
// affichage du premier élément pour les messages d'erreur
|
||||
friend void Affiche_premier_elem(ostream &sort , const Tableau<T> & 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<T> & 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<T>& tab) const;
|
||||
|
||||
// Surcharge de l'operateur ==
|
||||
int operator== (const Tableau<T>& tab) const ;
|
||||
|
||||
// Surcharge de l'operateur d'affectation =
|
||||
Tableau<T>& operator= (const Tableau<T>& 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<T> & liste );
|
||||
|
||||
// opération inverse: remplissage d'une liste à partir du tableau
|
||||
// premier de la liste == premier du tableau
|
||||
void Init_list(list<T> & 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<T> * 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 <class T>
|
||||
// surcharge de l'operator de lecture d'élément non constant
|
||||
istream & operator >> (istream & entree, Tableau<T> & 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 <class T>
|
||||
inline Tableau<T>::Tableau ()
|
||||
// Constructeur par defaut
|
||||
{ taille=0;
|
||||
t=NULL;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline Tableau<T>::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<taille;i++)
|
||||
// initialisation des composantes a l'aide de l'attribut statique defaut
|
||||
// (*ptr++)=defaut;
|
||||
(*ptr++)= T();
|
||||
};
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline Tableau<T>::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<taille;i++)
|
||||
// initialisation des composantes a val
|
||||
(*ptr++)=val;
|
||||
};
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline Tableau<T>::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<taille;i++)
|
||||
// copie des composantes du tableau tab dans le tableau declare
|
||||
(*ptr1++)=(*ptr2++);
|
||||
};
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline Tableau<T>::Tableau (const Tableau<T>& 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<tab.taille;i++)
|
||||
// copie des composantes du tableau tab dans le tableau declare
|
||||
(*ptr1++)=(*ptr2++);
|
||||
taille=tab.taille;
|
||||
};
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline Tableau<T>::~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 <class T> void
|
||||
inline Tableau<T>::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;i<n;i++)
|
||||
// copie des composantes du tableau d'origine dans le tableau pointe par tempo
|
||||
(*ptr2++)=(*ptr1++);
|
||||
}
|
||||
else if ( n>taille )
|
||||
// cas ou la taille selectionnee est superieure a la taille d'origine
|
||||
{
|
||||
for (int i=0;i<taille;i++)
|
||||
// copie des composantes du tableau d'origine dans le tableau pointe par tempo
|
||||
(*ptr2++)=(*ptr1++);
|
||||
for (int i=taille;i<n;i++)
|
||||
// initialisation des composantes supplementaires a l'aide de l'element par defaut
|
||||
///(*ptr2++)=defaut;
|
||||
(*ptr2++)=T();
|
||||
};
|
||||
delete [] t; // desallocation du tableau pointe par t
|
||||
t=tempo; // affectation du pointeur t au pointeur tempo
|
||||
taille=n;
|
||||
|
||||
}
|
||||
|
||||
template <class T> void
|
||||
inline Tableau<T>::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;i<n;i++)
|
||||
// copie des composantes à tb
|
||||
(*ptr2++)=tb;
|
||||
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* ptr2=tempo;
|
||||
if ( n<=taille )
|
||||
// cas ou la taille selectionnee est inferieure a la taille d'origine
|
||||
{
|
||||
for (int i=0;i<n;i++)
|
||||
// copie des composantes du tableau d'origine dans le tableau pointe par tempo
|
||||
(*ptr2++)=tb;
|
||||
}
|
||||
else if ( n>taille )
|
||||
// cas ou la taille selectionnee est superieure a la taille d'origine
|
||||
{
|
||||
for (int i=0;i<n;i++)
|
||||
// copie des composantes à tb
|
||||
(*ptr2++)=tb;
|
||||
};
|
||||
delete [] t; // desallocation du tableau pointe par t
|
||||
t=tempo; // affectation du pointeur t au pointeur tempo
|
||||
taille=n;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
#ifndef MISE_AU_POINT
|
||||
inline
|
||||
#endif
|
||||
T& Tableau<T>::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 <class T>
|
||||
#ifndef MISE_AU_POINT
|
||||
inline
|
||||
#endif
|
||||
const T Tableau<T>::val_const(int i) const
|
||||
//const T& Tableau<T>::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 <class T>
|
||||
#ifndef MISE_AU_POINT
|
||||
inline
|
||||
#endif
|
||||
const T& Tableau<T>::ref_const(int i) const
|
||||
//const T& Tableau<T>::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 <class T>
|
||||
#ifndef MISE_AU_POINT
|
||||
inline
|
||||
#endif
|
||||
int Tableau<T>::operator!= (const Tableau<T>& 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 <class T> void
|
||||
inline Tableau<T>::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 "<<i<< " !\n";
|
||||
cout << "TABLEAU_T::ENLEVE(int ) \n";
|
||||
cout << "\n pour info: taille actuelle du tableau = " << taille << " ";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
T* tempo;
|
||||
tempo=new T [taille-1];
|
||||
T* ptr1=t;
|
||||
T* ptr2=tempo;
|
||||
for (int j=0;j<i-1;j++)
|
||||
// copie des elements du tableau pointe par t dans le tableau pointe par tempo
|
||||
// du 1er au (i-1)eme element
|
||||
(*ptr2++)=(*ptr1++);
|
||||
ptr1++; // saut du ieme element du tableau pointe par t
|
||||
for (int j=i;j<taille;j++)
|
||||
// copie des elements du tableau pointe par t dans le tableau pointe par tempo
|
||||
// du (i+1)eme au dernier element
|
||||
(*ptr2++)=(*ptr1++);
|
||||
delete [] t; // desallocation du tableau pointe par t
|
||||
t=tempo; // affectation du pointeur t au pointeur tempo
|
||||
taille=taille-1;
|
||||
}
|
||||
|
||||
template <class T> void
|
||||
inline Tableau<T>::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<taille;j++)
|
||||
// boucle sur les composantes du tableau
|
||||
{
|
||||
if ( (*ptr1)!=val )
|
||||
// l'objet pointe n'est pas egal a val
|
||||
(*ptr2++)=(*ptr1++);
|
||||
else
|
||||
// l'objet pointe est egal a val, saut de celui-ci
|
||||
{
|
||||
ptr1++;
|
||||
nouvel_taille=nouvel_taille-1;
|
||||
};
|
||||
};
|
||||
|
||||
#ifdef MISE_AU_POINT
|
||||
if ( nouvel_taille==taille )
|
||||
{
|
||||
cout << "\nErreur : absence de la composante cherchee !\n";
|
||||
cout << "TABLEAU_T::ENLEVE_VAL(T ) \n";
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
delete [] t; // desallocation du tableau pointe par t
|
||||
t=tempo; // affectation du pointeur t au pointeur tempo
|
||||
taille=nouvel_taille;
|
||||
|
||||
}
|
||||
|
||||
template <class T> void
|
||||
inline Tableau<T>::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 <class T> void
|
||||
inline Tableau<T>::Init_from_list(const list<T> & liste )
|
||||
// initialisation d'un tableau à partir d'une liste
|
||||
{ int tail_liste = liste.size(); // récup de la tail de la liste
|
||||
typename list<T>::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 <class T> void
|
||||
inline Tableau<T>::Init_list(list<T> & 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<taille;i++)
|
||||
liste.push_back(*ptr1++);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline Tableau<T> & Tableau<T>::operator= (const Tableau<T> & 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<taille;i++)
|
||||
// copie des elements du tableau se trouvant a droite dans le tableau se trouvant
|
||||
// a gauche du signe d'affectation
|
||||
(*ptr1++)=(*ptr2++);
|
||||
};
|
||||
// et retour
|
||||
return (*this);
|
||||
};
|
||||
// sinon on réajuste les tailles
|
||||
if ( t!=NULL ) Libere(); // cas ou le tableau se trouvant a gauche du signe =
|
||||
// n'est pas vide : desallocation de ce tableau
|
||||
if ( tab.taille==0 )
|
||||
// cas ou le tableau se trouvant a droite du signe = est vide : initialisation
|
||||
// identique a l'appel du constructeur par defaut
|
||||
{
|
||||
taille=0;
|
||||
t=NULL;
|
||||
}
|
||||
else
|
||||
// autres cas
|
||||
{
|
||||
taille=tab.taille;
|
||||
t=new T [taille];
|
||||
T* ptr1=t;
|
||||
T* ptr2=tab.t;
|
||||
for (int i=0;i<taille;i++)
|
||||
// copie des elements du tableau se trouvant a droite dans le tableau se trouvant
|
||||
// a gauche du signe d'affectation
|
||||
(*ptr1++)=(*ptr2++);
|
||||
};
|
||||
return (*this);
|
||||
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline int Tableau<T>::operator ==(const Tableau<T> & 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<taille;i++)
|
||||
{
|
||||
if ( (*ptr2++)!=(*ptr1++) )
|
||||
return 0;
|
||||
};
|
||||
return 1;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// opération de lecture sur un flot d'entrée
|
||||
// les données sont le type puis la dimension puis les datas
|
||||
template <class T>
|
||||
inline istream & Tableau<T>::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<taille;i++)
|
||||
entree >> 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 <class T>
|
||||
inline istream & Tableau<T>::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<taille;i++)
|
||||
entree >> 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 <class T>
|
||||
inline Tableau<T> * Tableau<T>::New_en_lecture_si_taille_superieur_a_lire(istream& entree)
|
||||
{ Tableau<T> * 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<T>(dime);
|
||||
for (int i=0;i<dime;i++)
|
||||
entree >> pt_tableau->t[i];
|
||||
}
|
||||
else
|
||||
{ // cas d'une dimension suffisante
|
||||
for (int i=0;i<dime;i++)
|
||||
entree >> 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 <class T>
|
||||
inline ostream & Tableau<T>::Sortir( ostream & sort) const
|
||||
{ // tout d'abord un indicateur donnant le type
|
||||
sort << "Tableau :taille= " << taille << " ";
|
||||
for (int i=0;i<taille;i++)
|
||||
sort << t[i] << " ";
|
||||
sort << "\n";
|
||||
return sort;
|
||||
}
|
||||
|
||||
// opération d'écriture non formatée, idem précédent mais sans retour chariot à la fin
|
||||
// les données sont le type la dimension puis les datas, chacun
|
||||
// séparé par un espace
|
||||
template <class T>
|
||||
inline ostream & Tableau<T>::Sortir_sansRet( ostream & sort) const
|
||||
{ // tout d'abord un indicateur donnant le type
|
||||
sort << "Tableau :taille= " << taille << " ";
|
||||
for (int i=0;i<taille;i++)
|
||||
sort << t[i] << " ";
|
||||
return sort;
|
||||
}
|
||||
|
||||
// test si la valeur passée en argument apartient au tableau
|
||||
// ramène 0 si n'appartient pas sinon ramène l'indice dans le tableau
|
||||
// t(i) = t[i+1]
|
||||
template <class T>
|
||||
inline int Tableau<T>::Contient(const T& e) const
|
||||
{ for (int i=0;i<taille;i++)
|
||||
if (t[i] == e) {return (i+1);}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// initialisation avec la valeur passée en argument
|
||||
template <class T>
|
||||
inline bool Tableau<T>::Inita(const T& e)
|
||||
{ for (int i=0;i<taille;i++)
|
||||
t[i] = e;
|
||||
return true; // par défaut
|
||||
};
|
||||
|
||||
//// affichage du premier élément pour les messages d'erreur
|
||||
//template <class T>
|
||||
//inline void Tableau<T>::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
|
||||
1
Tableaux/Tableau_double.cc
Normal file
1
Tableaux/Tableau_double.cc
Normal file
File diff suppressed because one or more lines are too long
141
Tableaux/Tableau_double.h
Normal file
141
Tableaux/Tableau_double.h
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
|
||||
// This file is part of the Herezh++ application.
|
||||
//
|
||||
// The finite element software Herezh++ is dedicated to the field
|
||||
// of mechanics for large transformations of solid structures.
|
||||
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
||||
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
||||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
//
|
||||
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* 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<double>
|
||||
{
|
||||
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
|
||||
1
Tableaux/utilDebug.h
Normal file
1
Tableaux/utilDebug.h
Normal file
|
|
@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* *
* 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
|
||||
Loading…
Reference in a new issue