2021-09-28 17:59:27 +02:00
|
|
|
|
|
|
|
// 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.
|
|
|
|
//
|
2023-05-03 17:23:49 +02:00
|
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
2021-09-28 17:59:27 +02:00
|
|
|
// 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
|