// This file is part of the Herezh++ application. // // The finite element software Herezh++ is dedicated to the field // of mechanics for large transformations of solid structures. // It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600) // INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) . // // Herezh++ is distributed under GPL 3 license ou ultérieure. // // Copyright (C) 1997-2021 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . /************************************************************************ * * * DATE: 23/01/97 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: une spécialisation du tableau en incluant une * * surchage d'opérateurs courants. Le template n'est pas utilisable * * par tous les objets: ces derniers doivent posséder également * * les surcharges correspondantes. * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * * * $ * * * ************************************************************************/ #ifndef TABOPER_T_H #define TABOPER_T_H #include "Tableau_T.h" /// @addtogroup Les_Tableaux_generiques /// @{ /// template class TabOper : public Tableau { public : // CONSTRUCTEURS : // Constructeur par defaut TabOper () : Tableau() {}; // Constructeur fonction de la taille du tableau TabOper (int nb) : Tableau(nb) {}; // Constructeur fonction de la taille du tableau et d'une // valeur d'initialisation pour les composantes TabOper (int nb,T val) : Tableau(nb,val) {}; // Constructeur fonction d'un tableau de composantes de type T TabOper (int nb,T* tab) : Tableau(nb,tab) {} ; // Constructeur de copie TabOper (const TabOper & tab) : Tableau(tab) {} ; // DESTRUCTEUR : ~TabOper (){}; // METHODES : // Surcharge de l'operateur + : addition entre deux tableaux TabOper operator+ (const TabOper& vec); // Surcharge de l'operateur - : soustraction entre deux tableaux TabOper operator- (const TabOper& vec); // Surcharge de l'operateur - : oppose d'un tableau //TabOper operator- (); TabOper operator- (); // Surcharge de l'operateur += void operator+= (const TabOper& vec); // Surcharge de l'operateur -= void operator-= (const TabOper& vec); // Surcharge de l'operateur *= : multiplication d'un scalaire par un tableau void operator*= (double val); // Surcharge de l'operateur * : multiplication d'un vecteur par un scalaire //TabOper operator* (double val); inline TabOper operator* (double val); // Surcharge de l'operateur / : division des composantes d'un vecteur par un scalaire TabOper operator/ (double val); // Surcharge de l'operateur /= : division des composantes d'un vecteur par un scalaire void operator/= (double val); // mise a zero d'un vecteur void Zero(); }; /// @} // end of group template TabOper operator* (double val,TabOper& vec) // Surcharge de l'operateur * : multiplication entre un scalaire et un tableau { return (vec*val); }; template TabOper TabOper::operator+ (const TabOper& vec) // Surcharge de l'operateur + : addition entre deux tableaux // N.B.: Les tableaux doivent etre de meme taille { #ifdef MISE_AU_POINT if ( this->taille!=vec.taille ) { cout << "\nErreur : tailles non egales !\n"; cout << "TabOper::OPERATOR+ (TabOper ) \n"; Sortie(1); }; #endif TabOper result(this->taille); T* ptr1=this->t; T* ptr2=vec.t; T* ptr3=result.t; for (int i=0;itaille;i++) // somme des composantes des deux tableaux vec et v, puis stockage // dans le tableau result (*ptr3++)=(*ptr1++)+(*ptr2++); return result; } template TabOper TabOper::operator- (const TabOper& vec) // Surcharge de l'operateur - : soustraction entre deux tableaux // N.B.: Les tableaux doivent etre de meme taille { #ifdef MISE_AU_POINT if ( this->taille!=vec.taille ) { cout << "\nErreur : tailles non egales !\n"; cout << "TabOper::OPERATOR- (TabOper ) \n"; Sortie(1); }; #endif TabOper result(this->taille); T* ptr1=this->t; T* ptr2=vec.t; T* ptr3=result.t; for (int i=0;itaille;i++) // soustraction des composantes des tableaux vec et v, puis stockage // dans le tableau result (*ptr3++)=(*ptr1++)-(*ptr2++); return result; } template TabOper TabOper::operator- () // Surcharge de l'operateur - : oppose d'un tableau { TabOper result(this->taille); T* ptr1=this->t; T* ptr2=result.t; for (int i=0;itaille;i++) (*ptr2++)=-(*ptr1++); return result; } template void TabOper::operator+= (const TabOper& vec) // Surcharge de l'operateur += : additionne au tableau courant le tableau vec // N.B.: Les tableaux doivent etre de meme taille { #ifdef MISE_AU_POINT if ( this->taille!=vec.taille ) { cout << "\nErreur : tailles non egales !\n"; cout << "TabOper::OPERATOR+= (TabOper ) \n"; Sortie(1); }; #endif T* ptr1=this->t; T* ptr2=vec.t; for (int i=0;itaille;i++) (*ptr1++)+=(*ptr2++); } template void TabOper::operator-= (const TabOper& vec) // Surcharge de l'operateur -= : soustrait au tableau courant le tableau vec // N.B.: Les tableaux doivent etre de meme taille { #ifdef MISE_AU_POINT if ( this->taille!=vec.taille ) { cout << "\nErreur : tailles non egales !\n"; cout << "TabOper::OPERATOR-= (TabOper ) \n"; Sortie(1); }; #endif T* ptr1=this->t; T* ptr2=vec.t; for (int i=0;itaille;i++) (*ptr1++)-=(*ptr2++); } template void TabOper::operator*= (double val) // Surcharge de l'operateur *= : multiplie les composantes du tableau courant par // le scalaire val // N.B.: Les tableaux doivent etre de meme taille { T* ptr=this->t; for (int i=0;itaille;i++) (*ptr++)*=val; } template TabOper TabOper::operator* (double val) // Surcharge de l'operateur * : multiplication d'un tableau par un scalaire { #ifdef MISE_AU_POINT if ( this->taille==0 ) { cout << "\nErreur : taille nulle !\n"; cout << "TabOper::OPERATOR* (T ) \n"; Sortie(1); }; #endif TabOper result(this->taille); T* ptr1=this->t; T* ptr2=result.t; for (int i=1;i<=this->taille;i++) // stockage dans le tableau result du produit des composantes du tableau courant // avec val (*ptr2++)=val*(*ptr1++); return result; } template TabOper TabOper::operator/ (double val) // Surcharge de l'operateur / : division des composantes d'un tableau par un scalaire { #ifdef MISE_AU_POINT if ( (this->taille==0) || (val==0) ) { cout << "\nErreur : taille nulle ou division par zero !\n"; cout << "TabOper::OPERATOR/ (T ) \n"; Sortie(1); }; #endif TabOper result(this->taille); T* ptr1=this->t; T* ptr2=result.t; for (int i=1;i<=this->taille;i++) // stockage dans le tableau result de la division des composantes du tableau courant // avec val (*ptr2++)=(*ptr1++)/val; return result; } template void TabOper::operator/= (double val) // Surcharge de l'operateur / : division des composantes d'un tableau par un scalaire { #ifdef MISE_AU_POINT if ( (this->taille==0) || (val==0) ) { cout << "\nErreur : taille nulle ou division par zero !\n"; cout << "TabOper::OPERATOR/ (T ) \n"; Sortie(1); }; #endif T* ptr=this->t; for (int i=0;itaille;i++) (*ptr++) /= val; } template // mise a zero d'un tableau void TabOper::Zero() { T* ptr=this->t; for (int i=0;itaille;i++) // affectation des composantes du tableau a 0 (*ptr++)=0.0; } #endif