rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Tableaux/TabOper_T.h
Gérard Rio 0460624e94 mise à jour 7.010
2023-05-03 17:23:49 +02:00

321 lines
9.9 KiB
C++
Raw Blame History

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <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
Reference in a new issue View git blame Copy permalink