2708 lines
111 KiB
C++
Executable file
2708 lines
111 KiB
C++
Executable file
// 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 "TypeQuelconqueParticulier.h"
|
|
|
|
#include "Tenseur1.h"
|
|
#include "Tenseur2.h"
|
|
#include "Tenseur3.h"
|
|
|
|
//--- partie bizarre, ne devrait pas exister, car TypeQuelconque::Grandeur est une classe virtuelle
|
|
// qui est toujours surchargée, donc la fonction d'affectation ne doit jamais servir !!
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & TypeQuelconque::Grandeur::operator=(TypeQuelconque::Grandeur const&)
|
|
{
|
|
cout << "\n erreur: cette fonction ne doit pas etre utilisee ?? "
|
|
<< "\n TypeQuelconque::Grandeur & TypeQuelconque::Grandeur::operator=(TypeQuelconque::Grandeur const&)"
|
|
<< "\n fichier TypeQuelconqueParticulier.cc ";
|
|
Sortie(1);
|
|
return *this;
|
|
};
|
|
|
|
//---- fin de la partie bizarre !!!!
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//| définition des fonctions permettant la création de la grandeur particulière |
|
|
//| en fonction d'un type énuméré |
|
|
//--------------------------------------------------------------------------------
|
|
|
|
TypeQuelconque::Grandeur* NevezGrandeurParticuliereEnLecture(EnuTypeQuelParticulier enu,istream & ent)
|
|
{TypeQuelconque::Grandeur* type_ret;
|
|
switch (enu)
|
|
{ case RIEN_TYPE_QUELCONQUE_PARTICULIER : type_ret=new Grandeur_defaut(); break;
|
|
case PARTICULIER_TENSEURHH : type_ret=new Grandeur_TenseurHH(ent); break;
|
|
case PARTICULIER_TENSEURBB : type_ret=new Grandeur_TenseurBB(ent); break;
|
|
case PARTICULIER_TABLEAU_TENSEURHH : type_ret=new Tab_Grandeur_TenseurHH(ent); break;
|
|
case PARTICULIER_TABLEAU2_TENSEURHH : type_ret=new Tab2_Grandeur_TenseurHH(ent); break;
|
|
case PARTICULIER_TENSEURBH : type_ret=new Grandeur_TenseurBH(ent); break;
|
|
case PARTICULIER_SCALAIRE_ENTIER : type_ret=new Grandeur_scalaire_entier(ent); break;
|
|
case PARTICULIER_TABLEAU_SCALAIRE_ENTIER : type_ret=new Tab_Grandeur_scalaire_entier(ent); break;
|
|
case PARTICULIER_SCALAIRE_DOUBLE : type_ret=new Grandeur_scalaire_double(ent); break;
|
|
case PARTICULIER_TABLEAU_SCALAIRE_DOUBLE : type_ret=new Tab_Grandeur_scalaire_double(ent); break;
|
|
case PARTICULIER_COORDONNEE : type_ret=new Grandeur_coordonnee(ent); break;
|
|
case PARTICULIER_TABLEAU_COORDONNEE : type_ret=new Tab_Grandeur_Coordonnee(ent); break;
|
|
case PARTICULIER_TABLEAU_TENSEURBH : type_ret=new Tab_Grandeur_TenseurBH(ent); break;
|
|
case PARTICULIER_TABLEAU_TENSEURBB : type_ret=new Tab_Grandeur_TenseurBB(ent); break;
|
|
case PARTICULIER_TENSEURHB : type_ret=new Grandeur_TenseurHB(ent); break;
|
|
case PARTICULIER_TABLEAU_TENSEURHB : type_ret=new Tab_Grandeur_TenseurHB(ent); break;
|
|
case PARTICULIER_DDL_ETENDU : type_ret=new Grandeur_Ddl_etendu(ent); break;
|
|
case PARTICULIER_TABLEAU_DDL_ETENDU : type_ret=new Tab_Grandeur_Ddl_etendu(ent); break;
|
|
case PARTICULIER_VECTEUR_NOMMER : type_ret=new Grandeur_Vecteur_Nommer(ent); break;
|
|
case PARTICULIER_VECTEUR : type_ret=new Grandeur_Vecteur(ent); break;
|
|
case PARTICULIER_TABLEAU_VECTEUR : type_ret=new Tab_Grandeur_Vecteur(ent); break;
|
|
case PARTICULIER_BASE_H : type_ret=new Grandeur_BaseH(ent); break;
|
|
case PARTICULIER_TABLEAU_BASE_H : type_ret=new Tab_Grandeur_BaseH(ent); break;
|
|
|
|
// case PARTICULIER_TABLEAU_QUELCONQUE : type_ret=new Tableau_Grandeur_quelconque(ent); break;
|
|
default :
|
|
cout << "\nErreur : valeur incorrecte du type EnuTypeQuelParticulier "
|
|
<< NomTypeQuelParticulier(enu) << " \n" ;
|
|
cout << "NevezGrandeurParticuliere(EnuTypeQuelParticulier enu) \n";
|
|
Sortie(1);
|
|
};
|
|
return type_ret;
|
|
};
|
|
|
|
//----------------------------------------------------------------
|
|
// grandeur par défaut: TypeQuelconque::Grandeur::Grandeur_defaut|
|
|
//----------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_defaut & )
|
|
{ cout << "\n erreur! grandeur par defaut: Grandeur_defaut::TypeQuelconque::Grandeur"
|
|
<< "\n istream & operator >> (..";
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_defaut & )
|
|
{ cout << "\n erreur! grandeur par defaut: TypeQuelconque::Grandeur::Grandeur_defaut"
|
|
<< "\n ostream & operator << (..";
|
|
return sort;
|
|
};
|
|
// ramène une grandeur identique,
|
|
TypeQuelconque::Grandeur* Grandeur_defaut::New_idem_grandeur() const
|
|
{ /*cout << "\n erreur! grandeur par defaut: TypeQuelconque::Grandeur::Grandeur_defaut"
|
|
<< "\n New_idem_grandeur(..";*/
|
|
return new Grandeur_defaut();
|
|
};
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_defaut::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_defaut::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
return *this;
|
|
};
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// ***** ici toutes ces opérations sont illicites !!! ********
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_defaut::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{ cout << "\n operation non permise pour une grandeur par defaut !!! "
|
|
<< "\n Grandeur_defaut::Affectation_numerique(.. ";
|
|
Sortie(1);
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_defaut::operator+= (const Grandeur& )
|
|
{ cout << "\n operation non permise pour une grandeur par defaut !!! "
|
|
<< "\n Grandeur_defaut::operator+= (.. ";
|
|
Sortie(1);
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_defaut::operator-= (const Grandeur& )
|
|
{ cout << "\n operation non permise pour une grandeur par defaut !!! "
|
|
<< "\n Grandeur_defaut::operator-= (.. ";
|
|
Sortie(1);
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Grandeur_defaut::operator*= (double )
|
|
{ cout << "\n operation non permise pour une grandeur par defaut !!! "
|
|
<< "\n Grandeur_defaut::operator*= (.. ";
|
|
Sortie(1);
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Grandeur_defaut::operator/= (double )
|
|
{ cout << "\n operation non permise pour une grandeur par defaut !!! "
|
|
<< "\n Grandeur_defaut::operator/= (.. ";
|
|
Sortie(1);
|
|
};
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Grandeur_defaut::GrandeurNumOrdre(int ) const
|
|
{ cout << "\n erreur! grandeur par defaut: TypeQuelconque::Grandeur::Grandeur_defaut"
|
|
<< "\n GrandeurNumOrdre(..";
|
|
return 0.;
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Grandeur_defaut::NbMaxiNumeroOrdre() const
|
|
{ cout << "\n erreur! grandeur par defaut: TypeQuelconque::Grandeur::Grandeur_defaut"
|
|
<< "\n NbMaxiNumeroOrdre(..";
|
|
return 0;
|
|
};
|
|
// sortie de la grandeur brut sur sort
|
|
void Grandeur_defaut::Grandeur_brut(ostream & ,int ) const
|
|
{ cout << "\n erreur! grandeur par defaut: TypeQuelconque::Grandeur::Grandeur_defaut"
|
|
<< "\n Grandeur_brut(..";
|
|
};
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Grandeur_defaut::InitParDefaut()
|
|
{ cout << "\n erreur! grandeur par defaut: TypeQuelconque::Grandeur::Grandeur_defaut"
|
|
<< "\n InitParDefaut()";
|
|
};
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
// grandeur TenseurHH: TypeQuelconque::Grandeur::Grandeur_TenseurHH|
|
|
//------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_TenseurHH & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_TenseurHH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurHH= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_TenseurHH & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
a.ptTens->Lecture(ent);
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_TenseurHH & a)
|
|
{sort << " Grandeur_TenseurHH= " << " " ;
|
|
a.ptTens->Ecriture(sort);
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Grandeur_TenseurHH::Grandeur_TenseurHH() : ptTens(NevezTenseurHH(1))
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Grandeur_TenseurHH::Grandeur_TenseurHH()";
|
|
};
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Grandeur_TenseurHH::Grandeur_TenseurHH(istream & ent) :
|
|
ptTens(NULL)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_TenseurHH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurHH= "
|
|
<< "\n Grandeur_TenseurHH::Grandeur_TenseurHH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
if (nom != "dim=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: dim= "
|
|
<< "\n Grandeur_TenseurHH::Grandeur_TenseurHH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int dimension; ent >> dimension; // lecture de la dimension
|
|
ptTens = NevezTenseurHH(dimension);
|
|
// lecture du tenseur
|
|
ptTens->Lecture(ent);
|
|
};
|
|
|
|
// destructeur
|
|
Grandeur_TenseurHH::~Grandeur_TenseurHH()
|
|
{if (ptTens != NULL) delete ptTens;};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_TenseurHH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_TenseurHH= " << "dim= " << ptTens->Dimension() << " ";
|
|
ptTens->Ecriture(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurHH::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_TenseurHH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHH& aa= *((Grandeur_TenseurHH*) &a);
|
|
*ptTens = *(aa.ptTens);
|
|
return *this;
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurHH::operator = ( const Grandeur_TenseurHH & aa)
|
|
{
|
|
*ptTens = *(aa.ptTens);
|
|
return *this;
|
|
};
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_TenseurHH::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurHH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHH& aa= *((Grandeur_TenseurHH*) &a);
|
|
(*ptTens) = (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_TenseurHH::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurHH::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHH& aa= *((Grandeur_TenseurHH*) &a);
|
|
(*ptTens) += (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_TenseurHH::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurHH::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHH& aa= *((Grandeur_TenseurHH*) &a);
|
|
(*ptTens) -= (*(aa.ptTens));
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Grandeur_TenseurHH::GrandeurNumOrdre(int n) const
|
|
{ switch (ptTens->Dimension())
|
|
{case -1: case 1: return (*ptTens)(1,1);break;
|
|
case -2:{Tenseur_ns2HH& tens = *((Tenseur_ns2HH*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case 2: {Tenseur2HH& tens = *((Tenseur2HH*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case -3:{Tenseur_ns3HH& tens = *((Tenseur_ns3HH*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case 3: {Tenseur3HH& tens = *((Tenseur3HH*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurHH::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0.; // pour taire le warning
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Grandeur_TenseurHH::NbMaxiNumeroOrdre() const
|
|
{ switch (ptTens->Dimension())
|
|
{case -1: case 1: return 1; break;
|
|
case -2: return 4; break;
|
|
case 2: return 3; break;
|
|
case -3: return 9; break;
|
|
case 3: return 6; break;
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurHH::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0; // pour taire le warning
|
|
};
|
|
|
|
void Grandeur_TenseurHH::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int dim = ptTens->Dimension();
|
|
if (dim > 0)
|
|
{for (int i=1;i<=dim;i++)
|
|
for (int j=1;j<=i;j++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << (*ptTens)(i,j) << " ";
|
|
}
|
|
else
|
|
{for (int i=1;i<=-dim;i++)
|
|
for (int j=1;j<=-dim;j++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << (*ptTens)(i,j) << " ";
|
|
};
|
|
// sort << *this;
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Grandeur_TenseurHH::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ ptTens->ChBase(gamma);};
|
|
|
|
//------------------------------------------------------------------
|
|
// grandeur TenseurBB: TypeQuelconque::Grandeur::Grandeur_TenseurBB|
|
|
//------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_TenseurBB & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_TenseurBB=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurBB= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_TenseurBB & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
a.ptTens->Lecture(ent);
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_TenseurBB & a)
|
|
{sort << " Grandeur_TenseurBB= " << " " ;
|
|
a.ptTens->Ecriture(sort);
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Grandeur_TenseurBB::Grandeur_TenseurBB() : ptTens(NevezTenseurBB(1))
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Grandeur_TenseurBB::Grandeur_TenseurBB()";
|
|
};
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Grandeur_TenseurBB::Grandeur_TenseurBB(istream & ent) :
|
|
ptTens(NULL)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_TenseurBB=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurBB= "
|
|
<< "\n Grandeur_TenseurBB::Grandeur_TenseurBB(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
if (nom != "dim=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: dim= "
|
|
<< "\n Grandeur_TenseurBB::Grandeur_TenseurBB(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int dimension; ent >> dimension; // lecture de la dimension
|
|
ptTens = NevezTenseurBB(dimension);
|
|
// lecture du tenseur
|
|
ptTens->Lecture(ent);
|
|
};
|
|
|
|
// destructeur
|
|
Grandeur_TenseurBB::~Grandeur_TenseurBB()
|
|
{if (ptTens != NULL) delete ptTens;};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_TenseurBB::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_TenseurBB= " << "dim= " << ptTens->Dimension() << " ";
|
|
ptTens->Ecriture(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurBB::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_TenseurBB::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBB& aa= *((Grandeur_TenseurBB*) &a);
|
|
*ptTens = *(aa.ptTens);
|
|
return *this;
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurBB::operator = ( const Grandeur_TenseurBB & aa)
|
|
{
|
|
*ptTens = *(aa.ptTens);
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_TenseurBB::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurBB::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBB& aa= *((Grandeur_TenseurBB*) &a);
|
|
(*ptTens) = (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_TenseurBB::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurBB::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBB& aa= *((Grandeur_TenseurBB*) &a);
|
|
(*ptTens) += (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_TenseurBB::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurBB::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBB& aa= *((Grandeur_TenseurBB*) &a);
|
|
(*ptTens) -= (*(aa.ptTens));
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Grandeur_TenseurBB::GrandeurNumOrdre(int n) const
|
|
{ switch (ptTens->Dimension())
|
|
{case -1: case 1: return (*ptTens)(1,1); break;
|
|
case -2:{Tenseur_ns2BB& tens = *((Tenseur_ns2BB*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case 2: {Tenseur2BB& tens = *((Tenseur2BB*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case -3:{Tenseur_ns3BB& tens = *((Tenseur_ns3BB*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case 3: {Tenseur3BB& tens = *((Tenseur3BB*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurBB::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0.; // pour taire le warning
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Grandeur_TenseurBB::NbMaxiNumeroOrdre() const
|
|
{ switch (ptTens->Dimension())
|
|
{case -1: case 1: return 1; break;
|
|
case -2: return 4; break;
|
|
case 2: return 3; break;
|
|
case -3: return 9; break;
|
|
case 3: return 6; break;
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurBB::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0; // pour taire le warning
|
|
};
|
|
|
|
void Grandeur_TenseurBB::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int dim = ptTens->Dimension();
|
|
if (dim > 0)
|
|
{for (int i=1;i<=dim;i++)
|
|
for (int j=1;j<=i;j++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << (*ptTens)(i,j) << " ";
|
|
}
|
|
else
|
|
{for (int i=1;i<=-dim;i++)
|
|
for (int j=1;j<=-dim;j++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << (*ptTens)(i,j) << " ";
|
|
};
|
|
// sort << *this;
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Grandeur_TenseurBB::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ ptTens->ChBase(beta);};
|
|
|
|
//------------------------------------------------------------------
|
|
// grandeur TenseurBH: TypeQuelconque::Grandeur::Grandeur_TenseurBH|
|
|
//------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_TenseurBH & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_TenseurBH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurBH= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_TenseurBH & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
a.ptTens->Lecture(ent);
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_TenseurBH & a)
|
|
{sort << " Grandeur_TenseurBH= " << " " ;
|
|
a.ptTens->Ecriture(sort);
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Grandeur_TenseurBH::Grandeur_TenseurBH() : ptTens(NevezTenseurBH(1))
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Grandeur_TenseurBH::Grandeur_TenseurBH()";
|
|
};
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Grandeur_TenseurBH::Grandeur_TenseurBH(istream & ent) :
|
|
ptTens(NULL)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_TenseurBH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurBH= "
|
|
<< "\n Grandeur_TenseurBH::Grandeur_TenseurBH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
if (nom != "dim=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: dim= "
|
|
<< "\n Grandeur_TenseurBH::Grandeur_TenseurBH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int dimension; ent >> dimension; // lecture de la dimension
|
|
ptTens = NevezTenseurBH(dimension);
|
|
// lecture du tenseur
|
|
ptTens->Lecture(ent);
|
|
};
|
|
|
|
// destructeur
|
|
Grandeur_TenseurBH::~Grandeur_TenseurBH()
|
|
{if (ptTens != NULL) delete ptTens;};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_TenseurBH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_TenseurHH= " << "dim= " << ptTens->Dimension() << " ";
|
|
ptTens->Ecriture(sort);
|
|
};
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurBH::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_TenseurBH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBH& aa= *((Grandeur_TenseurBH*) &a);
|
|
*ptTens = *aa.ptTens;return *this;
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurBH::operator = ( const Grandeur_TenseurBH & aa)
|
|
{
|
|
*ptTens = *(aa.ptTens);
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_TenseurBH::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurBH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBH& aa= *((Grandeur_TenseurBH*) &a);
|
|
(*ptTens) = (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_TenseurBH::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurBH::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBH& aa= *((Grandeur_TenseurBH*) &a);
|
|
(*ptTens) += (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_TenseurBH::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_TenseurBH::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurBH& aa= *((Grandeur_TenseurBH*) &a);
|
|
(*ptTens) -= (*(aa.ptTens));
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Grandeur_TenseurBH::GrandeurNumOrdre(int n) const
|
|
{ switch (ptTens->Dimension())
|
|
{case 1: return (*ptTens)(1,1); break;
|
|
case 2: {Tenseur2BH& tens = *((Tenseur2BH*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case 3: {Tenseur3BH& tens = *((Tenseur3BH*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurBH::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0.; // pour taire le warning
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Grandeur_TenseurBH::NbMaxiNumeroOrdre() const
|
|
{ switch (ptTens->Dimension())
|
|
{case -1: case 1: return 1; break;
|
|
case -2: return 4; break;
|
|
case 2: return 3; break;
|
|
case -3: return 9; break;
|
|
case 3: return 6; break;
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurBH::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0; // pour taire le warning
|
|
};
|
|
|
|
void Grandeur_TenseurBH::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int dim = ptTens->Dimension();
|
|
if (dim > 0)
|
|
{for (int i=1;i<=dim;i++)
|
|
for (int j=1;j<=i;j++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << (*ptTens)(i,j) << " ";
|
|
}
|
|
else
|
|
{for (int i=1;i<=-dim;i++)
|
|
for (int j=1;j<=-dim;j++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << (*ptTens)(i,j) << " ";
|
|
};
|
|
// sort << *this;
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Grandeur_TenseurBH::Change_repere(const Mat_pleine& beta, const Mat_pleine& gamma)
|
|
{ ptTens->ChBase(beta, gamma);};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de TenseurHH: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurHH|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_TenseurHH & a)
|
|
{ int taille = a.tabTens.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_tenseurHH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_tenseurHH_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_TenseurHH & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int nb;
|
|
ent >> nb;
|
|
if (nb != taille)
|
|
{ cout << "\n erreur en lecteur, la taille actuelle du tableau: " << taille
|
|
<< " est differente de la taille lue: " << nb
|
|
<< "\n operator >> (istream & ent, Tab_Grandeur_TenseurHH & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabTens(i)); // on utilise la lecture de Grandeur_TenseurHH
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurHH & a)
|
|
{ int taille = a.tabTens.Taille();
|
|
sort << " Tableau_de_tenseurHH_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabTens(i)); // on utilise l'écriture de Grandeur_TenseurHH
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Tab_Grandeur_TenseurHH::Tab_Grandeur_TenseurHH() : tabTens()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_TenseurHH::Tab_Grandeur_TenseurHH()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab_Grandeur_TenseurHH::Tab_Grandeur_TenseurHH( TenseurHH& tens,int nb) :
|
|
tabTens(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
tabTens(i) = new Grandeur_TenseurHH(tens);
|
|
};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Tab_Grandeur_TenseurHH::Tab_Grandeur_TenseurHH(istream & ent) :
|
|
tabTens()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_tenseurHH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_tenseurHH_nb= "
|
|
<< "\n Tab_Grandeur_TenseurHH::Tab_Grandeur_TenseurHH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture de la taille
|
|
int taille; ent >> taille ;
|
|
if (taille <= 0)
|
|
// dans le cas où la taille est nulle on définit simplement un tableau nul
|
|
{tabTens.Change_taille(0);}
|
|
else // sinon il nous faut définir les éléments du tableau au fur et à mesure de la lecture
|
|
{ tabTens.Change_taille(taille);
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i) = new Grandeur_TenseurHH(ent); // lecture au moment de la création de chaque tenseur
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_TenseurHH::Tab_Grandeur_TenseurHH(const Tab_Grandeur_TenseurHH& a):
|
|
tabTens(a.tabTens.Taille())
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i) = new Grandeur_TenseurHH(*(a.tabTens(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_TenseurHH::~Tab_Grandeur_TenseurHH()
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
delete tabTens(i);
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tab_Grandeur_TenseurHH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabTens.Taille();
|
|
sort << " Tableau_de_tenseurHH_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_TenseurHH::operator = ( const TypeQuelconque::Grandeur & b)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((b.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (b.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Tab_Grandeur_TenseurHH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHH& a= *((Tab_Grandeur_TenseurHH*) &b);
|
|
// maintenant l'affectation
|
|
int taille = tabTens.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabTens.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabTens.Taille()
|
|
<< "\n Tab_Grandeur_TenseurHH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
*(tabTens(i))= *(a.tabTens(i));
|
|
return *this;
|
|
};
|
|
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_TenseurHH::operator = ( const Tab_Grandeur_TenseurHH & a)
|
|
{
|
|
// maintenant l'affectation
|
|
int taille = tabTens.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabTens.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabTens.Taille()
|
|
<< "\n Tab_Grandeur_TenseurHH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
*(tabTens(i))= *(a.tabTens(i));
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Tab_Grandeur_TenseurHH::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_TenseurHH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHH& aa= *((Tab_Grandeur_TenseurHH*) &a);
|
|
int taille = tabTens.Taille();
|
|
int tailleN = aa.tabTens.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_TenseurHH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
(tabTens(i))->Affectation_numerique(*(aa.tabTens(i)));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_TenseurHH::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_TenseurHH::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHH& aa= *((Tab_Grandeur_TenseurHH*) &a);
|
|
int taille = tabTens.Taille();
|
|
int tailleN = aa.tabTens.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_TenseurHH::operator+= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabTens(i)) += (*(aa.tabTens(i)));
|
|
*(tabTens(i)) += *(aa.tabTens(i));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tab_Grandeur_TenseurHH::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_TenseurHH::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHH& aa= *((Tab_Grandeur_TenseurHH*) &a);
|
|
int taille = tabTens.Taille();
|
|
int tailleN = aa.tabTens.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_TenseurHH::operator-= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabTens(i)) -= (*(aa.tabTens(i)));
|
|
*(tabTens(i)) -= *(aa.tabTens(i));
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Tab_Grandeur_TenseurHH::operator*= (double val)
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabTens(i))*=val;
|
|
*(tabTens(i)) *=val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tab_Grandeur_TenseurHH::operator/= (double val)
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabTens(i))/=val;
|
|
*(tabTens(i)) /=val;
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Tab_Grandeur_TenseurHH::GrandeurNumOrdre(int n) const
|
|
{ int taille = tabTens.Taille();
|
|
if (taille == 0) return 0; // cas d'un tableau vide
|
|
int nbpartenseur=tabTens(1)->NbMaxiNumeroOrdre();
|
|
int indice_tableau = (n-1)/nbpartenseur + 1;
|
|
int r_div = (n-1)%nbpartenseur+1;
|
|
return tabTens(indice_tableau)->GrandeurNumOrdre(r_div);
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Tab_Grandeur_TenseurHH::NbMaxiNumeroOrdre() const
|
|
{ if (tabTens.Taille() == 0) return 0; // cas d'un tableau vide
|
|
int nbpartenseur=tabTens(1)->NbMaxiNumeroOrdre();
|
|
return (tabTens.Taille() * nbpartenseur);
|
|
};
|
|
|
|
void Tab_Grandeur_TenseurHH::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int taille = tabTens.Taille();
|
|
for (int k=1;k<=taille;k++)
|
|
tabTens(k)->Grandeur_brut(sort,nbcar);
|
|
};
|
|
|
|
// changement de taille -> n :
|
|
// si n < taille_actuelle --> les taille_actuelle - n sont supprimé
|
|
// si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois,
|
|
void Tab_Grandeur_TenseurHH::Change_taille(int n)
|
|
{ int taille = tabTens.Taille();
|
|
if (n < taille)
|
|
{ for (int i=n;i<=taille;i++) delete tabTens(i);
|
|
tabTens.Change_taille(n);
|
|
}
|
|
else // sinon on augmente
|
|
{ tabTens.Change_taille(n);
|
|
for (int i=taille;i<=n;i++)
|
|
tabTens(i) = new Grandeur_TenseurHH(*tabTens(taille));
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab_Grandeur_TenseurHH::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->Change_repere(beta,gamma);
|
|
};
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab_Grandeur_TenseurHH::InitParDefaut()
|
|
{int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->InitParDefaut();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
// grandeur un tableau à 2 dim de TenseurHH: TypeQuelconque::Grandeur::Tab2_Grandeur_TenseurHH|
|
|
//------------------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab2_Grandeur_TenseurHH & a)
|
|
{ int taille1 = a.tabTens.Taille1(); int taille2 = a.tabTens.Taille2(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau2_de_tenseurHH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_tenseurHH_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab2_Grandeur_TenseurHH & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int nb1,nb2;
|
|
ent >> nb1 >> nb2;
|
|
if ((nb1 != taille1)&&(nb2!=taille2))
|
|
{ cout << "\n erreur en lecteur, les tailles actuelles du tableau2: " << taille1 << " " << taille2
|
|
<< " sont differentes des tailles lues: " << nb1 << " " << nb2
|
|
<< "\n operator >> (istream & ent, Tab2_Grandeur_TenseurHH & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
ent >> *(a.tabTens(i,j)); // on utilise la lecture de Grandeur_TenseurHH
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab2_Grandeur_TenseurHH & a)
|
|
{ int taille1 = a.tabTens.Taille1(); int taille2 = a.tabTens.Taille2();
|
|
sort << " Tableau2_de_tenseurHH_nb= " << taille1 << " " << taille2 << " " ;
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
sort << *(a.tabTens(i,j)); // on utilise l'écriture de Grandeur_TenseurHH
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Tab2_Grandeur_TenseurHH::Tab2_Grandeur_TenseurHH() : tabTens()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab2_Grandeur_TenseurHH::Tab2_Grandeur_TenseurHH()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab2_Grandeur_TenseurHH::Tab2_Grandeur_TenseurHH( TenseurHH& tens,int nb1,int nb2) :
|
|
tabTens(nb1,nb2)
|
|
{ for (int i=1; i<=nb1;i++)
|
|
for (int j=1;j<=nb2;j++)
|
|
tabTens(i,j) = new Grandeur_TenseurHH(tens);
|
|
};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Tab2_Grandeur_TenseurHH::Tab2_Grandeur_TenseurHH(istream & ent) :
|
|
tabTens()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau2_de_tenseurHH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_tenseurHH_nb= "
|
|
<< "\n Tab2_Grandeur_TenseurHH::Tab2_Grandeur_TenseurHH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int taille1,taille2;
|
|
ent >> taille1 >> taille2; // lecture des dimensions
|
|
|
|
if ((taille1 <= 0) || (taille2 <=0))
|
|
// dans le cas où une des tailles est nulle on définit simplement un tableau nul
|
|
{ tabTens.Change_taille(0,0);}
|
|
else // sinon il nous faut définir les éléments du tableau au fur et à mesure de la lecture
|
|
{ tabTens.Change_taille(taille1,taille2);
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
tabTens(i,j) = new Grandeur_TenseurHH(ent); // lecture au moment de la création de chaque tenseur
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab2_Grandeur_TenseurHH::Tab2_Grandeur_TenseurHH(const Tab2_Grandeur_TenseurHH& a):
|
|
tabTens(a.tabTens.Taille())
|
|
{ int taille1 = tabTens.Taille1(); int taille2 = tabTens.Taille2();
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
tabTens(i,j) = new Grandeur_TenseurHH(*(a.tabTens(i,j)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab2_Grandeur_TenseurHH::~Tab2_Grandeur_TenseurHH()
|
|
{ int taille1 = tabTens.Taille1(); int taille2 = tabTens.Taille2();
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
delete tabTens(i,j);
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tab2_Grandeur_TenseurHH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille1 = tabTens.Taille1(); int taille2 = tabTens.Taille2();
|
|
sort << " Tableau2_de_tenseurHH_nb= " << taille1 << " " << taille2 << " " ;
|
|
// if (taille1==0) {sort << 0 << " ";}
|
|
// else if (taille2==0) {sort << 0 << " ";}
|
|
// else {sort << (tabTens(1,1)->Dimension()) << " ";}
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
(tabTens(i,j))->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab2_Grandeur_TenseurHH::operator = ( const TypeQuelconque::Grandeur & b)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((b.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (b.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Tab2_Grandeur_TenseurHH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab2_Grandeur_TenseurHH& a= *((Tab2_Grandeur_TenseurHH*) &b);
|
|
int taille1 = tabTens.Taille1(); int taille2 = tabTens.Taille2();
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
*(tabTens(i,j))= *(a.tabTens(i,j));
|
|
return *this;
|
|
};
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab2_Grandeur_TenseurHH::operator = ( const Tab2_Grandeur_TenseurHH & a)
|
|
{
|
|
int taille1 = tabTens.Taille1(); int taille2 = tabTens.Taille2();
|
|
#ifdef MISE_AU_POINT
|
|
if ((taille1 != a.tabTens.Taille1()) || (taille2 != a.tabTens.Taille2()))
|
|
{ cout << "\n erreur a l'affectation: les tailles de this " << taille1 << " et " << taille2
|
|
<< " ne sont pas egales a celles de a " << a.tabTens.Taille1() << " et " << a.tabTens.Taille2()
|
|
<< "\n Tab_Grandeur_TenseurHH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1; i<=taille1;i++)
|
|
for (int j=1;j<=taille2;j++)
|
|
*(tabTens(i,j))= *(a.tabTens(i,j));
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Tab2_Grandeur_TenseurHH::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab2_Grandeur_TenseurHH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab2_Grandeur_TenseurHH& aa= *((Tab2_Grandeur_TenseurHH*) &a);
|
|
int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
int tailleN_1 = aa.tabTens.Taille1();int tailleN_2 = aa.tabTens.Taille2();
|
|
if ((taille1 != tailleN_1)||(taille2!=tailleN_2))
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille1 2 de this puis de a "
|
|
<< taille1 << " "<< taille2 << " " << tailleN_1 << " " << tailleN_2 << " "
|
|
<< "\n Tab2_Grandeur_TenseurHH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
(tabTens(i,j))->Affectation_numerique(*(aa.tabTens(i,j)));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab2_Grandeur_TenseurHH::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab2_Grandeur_TenseurHH::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab2_Grandeur_TenseurHH& aa= *((Tab2_Grandeur_TenseurHH*) &a);
|
|
int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
int tailleN_1 = aa.tabTens.Taille1();int tailleN_2 = aa.tabTens.Taille2();
|
|
if ((taille1 != tailleN_1)||(taille2!=tailleN_2))
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille1 2 de this puis de a "
|
|
<< taille1 << " "<< taille2 << " " << tailleN_1 << " " << tailleN_2 << " "
|
|
<< "\n Tab2_Grandeur_TenseurHH::operator+= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
*(tabTens(i,j)) += *(aa.tabTens(i,j));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tab2_Grandeur_TenseurHH::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab2_Grandeur_TenseurHH::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab2_Grandeur_TenseurHH& aa= *((Tab2_Grandeur_TenseurHH*) &a);
|
|
int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
int tailleN_1 = aa.tabTens.Taille1();int tailleN_2 = aa.tabTens.Taille2();
|
|
if ((taille1 != tailleN_1)||(taille2!=tailleN_2))
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille1 2 de this puis de a "
|
|
<< taille1 << " "<< taille2 << " " << tailleN_1 << " " << tailleN_2 << " "
|
|
<< "\n Tab2_Grandeur_TenseurHH::operator-= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
*(tabTens(i,j)) -= *(aa.tabTens(i,j));
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Tab2_Grandeur_TenseurHH::operator*= (double val)
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
*(tabTens(i,j)) *=val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tab2_Grandeur_TenseurHH::operator/= (double val)
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
*(tabTens(i,j)) /=val;
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Tab2_Grandeur_TenseurHH::GrandeurNumOrdre(int n) const
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
if ((taille1 == 0) || (taille2==0)) return 0; // cas d'un tableau vide
|
|
int nbpartenseur=tabTens(1,1)->NbMaxiNumeroOrdre();
|
|
int in_i = (n-1)/(nbpartenseur*taille2) + 1;
|
|
int r_i = (n-1)%(nbpartenseur*taille2)+1; // reste de la première division
|
|
int in_j = (r_i-1)/nbpartenseur + 1;
|
|
int r_div = (r_i-1)%nbpartenseur+1;
|
|
return tabTens(in_i,in_j)->GrandeurNumOrdre(r_div);
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Tab2_Grandeur_TenseurHH::NbMaxiNumeroOrdre() const
|
|
{ if ((tabTens.Taille1() == 0)||(tabTens.Taille2() == 0)) return 0; // cas d'un tableau vide
|
|
int nbpartenseur=tabTens(1,1)->NbMaxiNumeroOrdre();
|
|
return (tabTens.Taille1() * tabTens.Taille2() * nbpartenseur);
|
|
};
|
|
|
|
void Tab2_Grandeur_TenseurHH::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
for (int k1=1;k1<=taille1;k1++)
|
|
for (int k2=1;k2<=taille2;k2++)
|
|
tabTens(k1,k2)->Grandeur_brut(sort,nbcar);
|
|
};
|
|
|
|
// changement de taille -> n :
|
|
// si ni < taille_actuelle --> les taille_actuelle - ni sont supprimé
|
|
// si ni > taille_actuelle --> le dernier élément existant est dupliqué ni-taille_actuelle fois,
|
|
void Tab2_Grandeur_TenseurHH::Change_taille(int n1,int n2)
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
// la gestion des deux dimensions est un peu compliquée, on simplifie en créant un
|
|
// nouveau tableau de sauvegarde
|
|
Tableau2 <Grandeur_TenseurHH* > tabsauve(tabTens);
|
|
tabTens.Change_taille(n1,n2,NULL);
|
|
if ((n1 < taille1) && (n2 < taille2))
|
|
{ for (int i1=1;i1<=n1;i1++) for (int i2=1;i2<=n2;i2++) tabTens(i1,i2) = tabsauve(i1,i2);
|
|
for (int i1=n1+1;i1<=taille1;i1++) for (int i2=1;i2<=taille2;i2++) {delete tabsauve(i1,i2);tabsauve(i1,i2)=NULL;};
|
|
for (int i1=1;i1<=taille1;i1++) for (int i2=n2+1;i2<=taille2;i2++) if (tabsauve(i1,i2) != NULL) delete tabsauve(i1,i2);
|
|
}
|
|
else if ((n1 < taille1) && (n2 > taille2))
|
|
{ for (int i1=1;i1<=n1;i1++) for (int i2=1;i2<=taille2;i2++) tabTens(i1,i2) = tabsauve(i1,i2);
|
|
for (int i1=1;i1<=n1;i1++) for (int i2=taille2+1;i2<=n2;i2++) tabTens(i1,i2) = new Grandeur_TenseurHH(*tabsauve(n1,taille2));
|
|
for (int i1=n1+1;i1<=taille1;i1++) for (int i2=1;i2<=taille2;i2++) delete tabsauve(i1,i2);
|
|
}
|
|
else if ((n1 > taille1) && (n2 < taille2))
|
|
{ for (int i1=1;i1<=taille1;i1++) for (int i2=1;i2<=n2;i2++) tabTens(i1,i2) = tabsauve(i1,i2);
|
|
for (int i1=taille1+1;i1<=n1;i1++) for (int i2=1;i2<=n2;i2++) tabTens(i1,i2) = new Grandeur_TenseurHH(*tabsauve(taille1,n2));
|
|
for (int i1=1;i1<=taille1;i1++) for (int i2=n2+1;i2<=taille2;i2++) delete tabsauve(i1,i2);
|
|
}
|
|
else if ((n1 > taille1) && (n2 > taille2))
|
|
{ for (int i1=1;i1<=taille1;i1++) for (int i2=1;i2<=taille2;i2++) tabTens(i1,i2) = tabsauve(i1,i2);
|
|
for (int i1=taille1+1;i1<=n1;i1++) for (int i2=1;i2<=n2;i2++) tabTens(i1,i2) = new Grandeur_TenseurHH(*tabsauve(taille1,n2));
|
|
for (int i1=1;i1<=n1;i1++) for (int i2=taille2+1;i2<=n2;i2++)
|
|
{ if (tabTens(i1,i2)==NULL) tabTens(i1,i2) = new Grandeur_TenseurHH(*tabsauve(n1,taille2));};
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab2_Grandeur_TenseurHH::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
tabTens(i,j)->Change_repere(beta,gamma);
|
|
};
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab2_Grandeur_TenseurHH::InitParDefaut()
|
|
{ int taille1 = tabTens.Taille1();int taille2 = tabTens.Taille2();
|
|
for (int i=1;i<=taille1;i++) for (int j=1;j<=taille2;j++)
|
|
tabTens(i,j)->InitParDefaut();
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//| grandeur scalaire réel: TypeQuelconque::Grandeur::Grandeur_scalaire_double|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_scalaire_double & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "d=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: d= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_scalaire_double & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
ent >> a.val;
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_scalaire_double & a)
|
|
{sort << " d= " << a.val << " " ;
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Grandeur_scalaire_double::Grandeur_scalaire_double():
|
|
val(0.) {};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Grandeur_scalaire_double::Grandeur_scalaire_double(istream & ent)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "d=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: d= "
|
|
<< "\n Grandeur_scalaire_double::Grandeur_scalaire_double(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> val;
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_scalaire_double::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " d= " << val << " ";};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_scalaire_double::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_scalaire_double::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_double& aa= *((Grandeur_scalaire_double*) &a);
|
|
val=aa.val;return *this;
|
|
};
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_scalaire_double::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_scalaire_double::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_double& aa= *((Grandeur_scalaire_double*) &a);
|
|
val=aa.val;
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_scalaire_double::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_scalaire_double::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_double& aa= *((Grandeur_scalaire_double*) &a);
|
|
val+=aa.val;
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_scalaire_double::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_scalaire_double::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_double& aa= *((Grandeur_scalaire_double*) &a);
|
|
val-=aa.val;
|
|
};
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//| grandeur tableau de scalaires réel: TypeQuelconque::Grandeur::Tab_Grandeur_scalaire_double|
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_scalaire_double & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Tab_G_s_double=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tab_G_s_double= "
|
|
<< "\n operator << (ostream & sort , const Tab_Grandeur_scalaire_double & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
a.tab_val.Entree(ent);
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_scalaire_double & a)
|
|
{sort << " Tab_G_s_double= " ;
|
|
a.tab_val.Sortir_sansRet(sort);
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Tab_Grandeur_scalaire_double::Tab_Grandeur_scalaire_double():
|
|
tab_val() {};
|
|
// constructeur légal
|
|
Tab_Grandeur_scalaire_double::Tab_Grandeur_scalaire_double(const Tableau <double>& tab_va)
|
|
: tab_val(tab_va.Taille())
|
|
{int taille = tab_va.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_val(i).val = tab_va(i);
|
|
};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Tab_Grandeur_scalaire_double::Tab_Grandeur_scalaire_double(istream & ent)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tab_G_s_double=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tab_G_s_double= "
|
|
<< "\n Tab_Grandeur_scalaire_double::Tab_Grandeur_scalaire_double(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
tab_val.Entree(ent);
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tab_Grandeur_scalaire_double::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Tab_G_s_double= " ;
|
|
tab_val.Sortir_sansRet(sort);};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_scalaire_double::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Tab_Grandeur_scalaire_double::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_double& aa= *((Tab_Grandeur_scalaire_double*) &a);
|
|
tab_val=aa.tab_val;return *this;
|
|
};
|
|
|
|
// surcharge d'affectation avec un tableau de réel
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_scalaire_double::operator = ( const Tableau <double>& b)
|
|
{
|
|
int taille = b.Taille();
|
|
tab_val.Change_taille(taille);
|
|
for (int i=1;i<=taille;i++)
|
|
tab_val(i).val = b(i);
|
|
return *this;
|
|
};
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Tab_Grandeur_scalaire_double::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_scalaire_double::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_double& aa= *((Tab_Grandeur_scalaire_double*) &a);
|
|
int taille_ex = aa.tab_val.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille_ex != tab_val.Taille())
|
|
{ cout << "\n erreur sur les tailles, elles sont differentes ! operation impossible "
|
|
<< "\n Tab_Grandeur_scalaire_double::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<= taille_ex;i++)
|
|
tab_val(i) = aa.tab_val(i);
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_scalaire_double::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_scalaire_double::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_double& aa= *((Tab_Grandeur_scalaire_double*) &a);
|
|
int taille_ex = aa.tab_val.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille_ex != tab_val.Taille())
|
|
{ cout << "\n erreur sur les tailles, elles sont differentes ! operation impossible "
|
|
<< "\n Tab_Grandeur_scalaire_double::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<= taille_ex;i++)
|
|
tab_val(i) += aa.tab_val(i);
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tab_Grandeur_scalaire_double::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_scalaire_double::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_double& aa= *((Tab_Grandeur_scalaire_double*) &a);
|
|
int taille_ex = aa.tab_val.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille_ex != tab_val.Taille())
|
|
{ cout << "\n erreur sur les tailles, elles sont differentes ! operation impossible "
|
|
<< "\n Tab_Grandeur_scalaire_double::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<= taille_ex;i++)
|
|
tab_val(i) -= aa.tab_val(i);
|
|
};
|
|
|
|
// Surcharge de l'operateur *=
|
|
void Tab_Grandeur_scalaire_double::operator*= (double x)
|
|
{
|
|
int taille = tab_val.Taille();
|
|
for (int i=1;i<= taille;i++)
|
|
tab_val(i) *= x;
|
|
};
|
|
|
|
// Surcharge de l'operateur /=
|
|
void Tab_Grandeur_scalaire_double::operator/= (double x)
|
|
{
|
|
int taille = tab_val.Taille();
|
|
for (int i=1;i<= taille;i++)
|
|
tab_val(i) /= x;
|
|
};
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Tab_Grandeur_scalaire_double::GrandeurNumOrdre(int num) const
|
|
{int taille = tab_val.Taille();
|
|
if ((num <=0) || (num > taille)) {return 0.;}
|
|
else return tab_val(num).val;
|
|
};
|
|
|
|
void Tab_Grandeur_scalaire_double::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{int taille = tab_val.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_val(i).Grandeur_brut(sort,nbcar);
|
|
// sort << " " << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << tab_val(i) << " ";
|
|
};
|
|
|
|
// changement de taille -> n :
|
|
// si n < taille_actuelle --> les taille_actuelle - n sont supprimé
|
|
// si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois,
|
|
void Tab_Grandeur_scalaire_double::Change_taille(int n)
|
|
{ int taille = tab_val.Taille();
|
|
if (n < taille)
|
|
{ tab_val.Change_taille(n);
|
|
}
|
|
else // sinon on augmente
|
|
{ tab_val.Change_taille(n);
|
|
for (int i=taille;i<=n;i++)
|
|
tab_val(i) = tab_val(taille);
|
|
};
|
|
};
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab_Grandeur_scalaire_double::InitParDefaut()
|
|
{int taille = tab_val.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_val(i).InitParDefaut();
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//| grandeur coordonnée: TypeQuelconque::Grandeur::Grandeur_coordonnee|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_coordonnee & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_coordonnee=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_coordonnee= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_coordonnee & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> a.co;
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_coordonnee & a)
|
|
{sort << " Grandeur_coordonnee= " << a.co << " " ;
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Grandeur_coordonnee::Grandeur_coordonnee():
|
|
co() {};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Grandeur_coordonnee::Grandeur_coordonnee(istream & ent):
|
|
co()
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_coordonnee=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_coordonnee= "
|
|
<< "\n Grandeur_coordonnee::Grandeur_coordonnee(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture de la dimension
|
|
int dim; ent >> dim;
|
|
co.Change_dim(dim);
|
|
// fin de la lecture
|
|
ent >> co;
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_coordonnee::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_coordonnee= " << co.Dimension() << " "<< co << " ";};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_coordonnee::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_coordonnee::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_coordonnee& aa= *((Grandeur_coordonnee*) &a);
|
|
co=aa.co;return *this;
|
|
};
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_coordonnee::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_coordonnee::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_coordonnee& aa= *((Grandeur_coordonnee*) &a);
|
|
co=aa.co;
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_coordonnee::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_coordonnee::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_coordonnee& aa= *((Grandeur_coordonnee*) &a);
|
|
co+=aa.co;
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_coordonnee::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_coordonnee::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_coordonnee& aa= *((Grandeur_coordonnee*) &a);
|
|
co-=aa.co;
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Grandeur_coordonnee::GrandeurNumOrdre(int num) const
|
|
{if((num>0)&&(num<=co.Dimension())) return co(num); else return 0.;};
|
|
|
|
// change de repère de la grandeur
|
|
void Grandeur_coordonnee::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma )
|
|
{cout << "\n **** non implante !!! "
|
|
<< "\n Grandeur_coordonnee::Change_repere(";
|
|
Sortie(1);
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de Coordonnee: TypeQuelconque::Grandeur::Tab_Grandeur_CoordonneeHH|
|
|
// tous les coordonnees doivent avoir la même dimension !! pour la routine GrandeurNumOrdre
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_Coordonnee & a)
|
|
{ int taille = a.tabCoor.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_Coordonnee_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_Coordonnee_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_Coordonnee & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int nb;
|
|
ent >> nb;
|
|
if (nb != taille)
|
|
{ cout << "\n erreur en lecteur, la taille actuelle du tableau: " << taille
|
|
<< " est differente de la taille lue: " << nb
|
|
<< "\n operator >> (istream & ent, Tab_Grandeur_Coordonnee & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabCoor(i)); // on utilise la lecture de Grandeur_coordonnee
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_Coordonnee & a)
|
|
{ int taille = a.tabCoor.Taille();
|
|
sort << " Tableau_de_Coordonnee_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabCoor(i)); // on utilise l'écriture de Grandeur_coordonnee
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Tab_Grandeur_Coordonnee::Tab_Grandeur_Coordonnee() : tabCoor()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_Coordonnee::Tab_Grandeur_Coordonnee()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab_Grandeur_Coordonnee::Tab_Grandeur_Coordonnee( Coordonnee& tens,int nb) :
|
|
tabCoor(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
tabCoor(i) = new Grandeur_coordonnee(tens);
|
|
};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Tab_Grandeur_Coordonnee::Tab_Grandeur_Coordonnee(istream & ent) :
|
|
tabCoor()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_Coordonnee_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_Coordonnee_nb= "
|
|
<< "\n Tab_Grandeur_Coordonnee::Tab_Grandeur_Coordonnee(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture de la taille
|
|
int taille; ent >> taille ;
|
|
if (taille <= 0)
|
|
// dans le cas où la taille est nulle on définit simplement un tableau nul
|
|
{tabCoor.Change_taille(0);}
|
|
else // sinon il nous faut définir les éléments du tableau au fur et à mesure de la lecture
|
|
{ tabCoor.Change_taille(taille);
|
|
for (int i=1;i<=taille;i++)
|
|
tabCoor(i) = new Grandeur_coordonnee(ent); // lecture au moment de la création de chaque Coordonnee
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_Coordonnee::Tab_Grandeur_Coordonnee(const Tab_Grandeur_Coordonnee& a):
|
|
tabCoor(a.tabCoor.Taille())
|
|
{ int taille = tabCoor.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabCoor(i) = new Grandeur_coordonnee(*(a.tabCoor(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_Coordonnee::~Tab_Grandeur_Coordonnee()
|
|
{ int taille = tabCoor.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
delete tabCoor(i);
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tab_Grandeur_Coordonnee::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabCoor.Taille();
|
|
sort << " Tableau_de_Coordonnee_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabCoor(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_Coordonnee::operator = ( const TypeQuelconque::Grandeur & b)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((b.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (b.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Tab_Grandeur_Coordonnee::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Coordonnee& a= *((Tab_Grandeur_Coordonnee*) &b);
|
|
// maintenant l'affectation
|
|
int taille = tabCoor.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabCoor.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabCoor.Taille()
|
|
<< "\n Tab_Grandeur_Coordonnee::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
// ici on fait une grosse manip d'écriture qui revient au même qu'à la ligne suivante
|
|
// mais il y a un pb sur linux que je ne comprend pas
|
|
((Grandeur_coordonnee*) tabCoor(i))->operator = (*((TypeQuelconque::Grandeur*) a.tabCoor(i)));
|
|
// *(tabCoor(i))= *(a.tabCoor(i));
|
|
return *this;
|
|
};
|
|
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_Coordonnee::operator = ( const Tab_Grandeur_Coordonnee & a)
|
|
{
|
|
// maintenant l'affectation
|
|
int taille = tabCoor.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabCoor.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabCoor.Taille()
|
|
<< "\n Tab_Grandeur_Coordonnee::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
*(tabCoor(i))= *(a.tabCoor(i));
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Tab_Grandeur_Coordonnee::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_Coordonnee::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Coordonnee& aa= *((Tab_Grandeur_Coordonnee*) &a);
|
|
int taille = tabCoor.Taille();
|
|
int tailleN = aa.tabCoor.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Coordonnee::Affectation_numerique(..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
(tabCoor(i))->Affectation_numerique(*(aa.tabCoor(i)));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_Coordonnee::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_Coordonnee::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Coordonnee& aa= *((Tab_Grandeur_Coordonnee*) &a);
|
|
int taille = tabCoor.Taille();
|
|
int tailleN = aa.tabCoor.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Coordonnee::operator+= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabCoor(i)) += (*(aa.tabCoor(i)));
|
|
*(tabCoor(i)) += *(aa.tabCoor(i));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tab_Grandeur_Coordonnee::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_Coordonnee::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Coordonnee& aa= *((Tab_Grandeur_Coordonnee*) &a);
|
|
int taille = tabCoor.Taille();
|
|
int tailleN = aa.tabCoor.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Coordonnee::operator-= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabCoor(i)) -= (*(aa.tabCoor(i)));
|
|
*(tabCoor(i)) -= *(aa.tabCoor(i));
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Tab_Grandeur_Coordonnee::operator*= (double val)
|
|
{ int taille = tabCoor.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabCoor(i))*=val;
|
|
*(tabCoor(i)) *=val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tab_Grandeur_Coordonnee::operator/= (double val)
|
|
{ int taille = tabCoor.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabCoor(i))/=val;
|
|
*(tabCoor(i)) /=val;
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Tab_Grandeur_Coordonnee::GrandeurNumOrdre(int n) const
|
|
{ int taille = tabCoor.Taille();
|
|
if (taille == 0) return 0; // cas d'un tableau vide
|
|
int nbparcoor=tabCoor(1)->NbMaxiNumeroOrdre();
|
|
int indice_tableau = (n-1)/nbparcoor + 1;
|
|
int r_div = (n-1)%nbparcoor+1;
|
|
return tabCoor(indice_tableau)->GrandeurNumOrdre(r_div);
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Tab_Grandeur_Coordonnee::NbMaxiNumeroOrdre() const
|
|
{ if (tabCoor.Taille() == 0) return 0; // cas d'un tableau vide
|
|
int nbparcoor=tabCoor(1)->NbMaxiNumeroOrdre();
|
|
return (tabCoor.Taille() * nbparcoor);
|
|
};
|
|
|
|
void Tab_Grandeur_Coordonnee::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int taille = tabCoor.Taille();
|
|
for (int k=1;k<=taille;k++)
|
|
tabCoor(k)->Grandeur_brut(sort,nbcar);
|
|
};
|
|
|
|
// changement de taille -> n :
|
|
// si n < taille_actuelle --> les taille_actuelle - n sont supprimé
|
|
// si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois,
|
|
void Tab_Grandeur_Coordonnee::Change_taille(int n)
|
|
{ int taille = tabCoor.Taille();
|
|
if (n < taille)
|
|
{ for (int i=n;i<=taille;i++) delete tabCoor(i);
|
|
tabCoor.Change_taille(n);
|
|
}
|
|
else // sinon on augmente
|
|
{ tabCoor.Change_taille(n);
|
|
for (int i=taille;i<=n;i++)
|
|
tabCoor(i) = new Grandeur_coordonnee(*tabCoor(taille));
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab_Grandeur_Coordonnee::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ int taille = tabCoor.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabCoor(i)->Change_repere(beta,gamma);
|
|
};
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab_Grandeur_Coordonnee::InitParDefaut()
|
|
{int taille = tabCoor.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabCoor(i)->InitParDefaut();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//| grandeur Grandeur_Ddl_etendu: TypeQuelconque::Grandeur::Grandeur_Ddl_etendu|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_Ddl_etendu & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_Ddl_etendu=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_Ddl_etendu= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_Ddl_etendu & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> a.co >> a.nom_ref;
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_Ddl_etendu & a)
|
|
{sort << " Grandeur_Ddl_etendu= " << a.co << " nom_ref: " << a.nom_ref <<" ";
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Grandeur_Ddl_etendu::Grandeur_Ddl_etendu():
|
|
co(),nom_ref("") {};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Grandeur_Ddl_etendu::Grandeur_Ddl_etendu(istream & ent):
|
|
co()
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_Ddl_etendu=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_Ddl_etendu= "
|
|
<< "\n Grandeur_Ddl_etendu::Grandeur_Ddl_etendu(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// fin de la lecture
|
|
ent >> co >> nom_ref;
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_Ddl_etendu::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_Ddl_etendu= " << co << " nom_ref: " << nom_ref <<" ";};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_Ddl_etendu::operator = ( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Grandeur_Ddl_etendu::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Ddl_etendu& aa= *((Grandeur_Ddl_etendu*) &a);
|
|
co=aa.co;nom_ref = aa.nom_ref; return *this;
|
|
};
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Grandeur_Ddl_etendu::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_Ddl_etendu::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Ddl_etendu& aa= *((Grandeur_Ddl_etendu*) &a);
|
|
co.Valeur() = aa.co.Valeur();
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_Ddl_etendu::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_Ddl_etendu::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Ddl_etendu& aa= *((Grandeur_Ddl_etendu*) &a);
|
|
co+=aa.co;
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_Ddl_etendu::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Grandeur_Ddl_etendu::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Ddl_etendu& aa= *((Grandeur_Ddl_etendu*) &a);
|
|
co-=aa.co;
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// grandeur un tableau de Ddl_etendu: TypeQuelconque::Grandeur::Tab_Grandeur_Ddl_etendu|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_Ddl_etendu & a)
|
|
{ int taille = a.tabDdlEte.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_Ddl_etendu_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_Ddl_etendu_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_Ddl_etendu & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int nb;
|
|
ent >> nb;
|
|
if (nb != taille)
|
|
{ cout << "\n erreur en lecteur, la taille actuelle du tableau: " << taille
|
|
<< " est differente de la taille lue: " << nb
|
|
<< "\n operator >> (istream & ent, Tab_Grandeur_Ddl_etendu & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabDdlEte(i)); // on utilise la lecture de Grandeur_Ddl_etendu
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_Ddl_etendu & a)
|
|
{ int taille = a.tabDdlEte.Taille();
|
|
sort << " Tableau_de_Ddl_etendu_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabDdlEte(i)); // on utilise l'écriture de Grandeur_Ddl_etendu
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, donc -> erreur
|
|
Tab_Grandeur_Ddl_etendu::Tab_Grandeur_Ddl_etendu() : tabDdlEte()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_Ddl_etendu::Tab_Grandeur_Ddl_etendu()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de Ddl_etendu
|
|
Tab_Grandeur_Ddl_etendu::Tab_Grandeur_Ddl_etendu( Grandeur_Ddl_etendu& tens,int nb) :
|
|
tabDdlEte(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
tabDdlEte(i) = new Grandeur_Ddl_etendu(tens);
|
|
};
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Tab_Grandeur_Ddl_etendu::Tab_Grandeur_Ddl_etendu(istream & ent) :
|
|
tabDdlEte()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_Ddl_etendu_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_Ddl_etendu_nb= "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::Tab_Grandeur_Ddl_etendu(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture de la taille
|
|
int taille; ent >> taille ;
|
|
if (taille <= 0)
|
|
// dans le cas où la taille est nulle on définit simplement un tableau nul
|
|
{tabDdlEte.Change_taille(0);}
|
|
else // sinon il nous faut définir les éléments du tableau au fur et à mesure de la lecture
|
|
{ tabDdlEte.Change_taille(taille);
|
|
for (int i=1;i<=taille;i++)
|
|
tabDdlEte(i) = new Grandeur_Ddl_etendu(ent); // lecture au moment de la création de chaque Ddl_etendu
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_Ddl_etendu::Tab_Grandeur_Ddl_etendu(const Tab_Grandeur_Ddl_etendu& a):
|
|
tabDdlEte(a.tabDdlEte.Taille())
|
|
{ int taille = tabDdlEte.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabDdlEte(i) = new Grandeur_Ddl_etendu(*(a.tabDdlEte(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_Ddl_etendu::~Tab_Grandeur_Ddl_etendu()
|
|
{ int taille = tabDdlEte.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
delete tabDdlEte(i);
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tab_Grandeur_Ddl_etendu::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabDdlEte.Taille();
|
|
sort << " Tableau_de_Ddl_etendu_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabDdlEte(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_Ddl_etendu::operator = ( const TypeQuelconque::Grandeur & b)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((b.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (b.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Ddl_etendu& a= *((Tab_Grandeur_Ddl_etendu*) &b);
|
|
// maintenant l'affectation
|
|
int taille = tabDdlEte.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabDdlEte.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabDdlEte.Taille()
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
// ici on fait une grosse manip d'écriture qui revient au même qu'à la ligne suivante
|
|
// mais il y a un pb sur linux que je ne comprend pas
|
|
((Grandeur_coordonnee*) tabDdlEte(i))->operator = (*((TypeQuelconque::Grandeur*) a.tabDdlEte(i)));
|
|
// *(tabDdlEte(i))= *(a.tabDdlEte(i));
|
|
return *this;
|
|
};
|
|
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_Ddl_etendu::operator = ( const Tab_Grandeur_Ddl_etendu & a)
|
|
{
|
|
// maintenant l'affectation
|
|
int taille = tabDdlEte.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabDdlEte.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabDdlEte.Taille()
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
*(tabDdlEte(i))= *(a.tabDdlEte(i));
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Tab_Grandeur_Ddl_etendu::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Ddl_etendu& aa= *((Tab_Grandeur_Ddl_etendu*) &a);
|
|
int taille = tabDdlEte.Taille();
|
|
int tailleN = aa.tabDdlEte.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::Affectation_numerique(..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
(tabDdlEte(i))->Affectation_numerique(*(aa.tabDdlEte(i)));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_Ddl_etendu::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Ddl_etendu& aa= *((Tab_Grandeur_Ddl_etendu*) &a);
|
|
int taille = tabDdlEte.Taille();
|
|
int tailleN = aa.tabDdlEte.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator+= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabDdlEte(i)) += (*(aa.tabDdlEte(i)));
|
|
*(tabDdlEte(i)) += *(aa.tabDdlEte(i));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tab_Grandeur_Ddl_etendu::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Ddl_etendu& aa= *((Tab_Grandeur_Ddl_etendu*) &a);
|
|
int taille = tabDdlEte.Taille();
|
|
int tailleN = aa.tabDdlEte.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Ddl_etendu::operator-= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabDdlEte(i)) -= (*(aa.tabDdlEte(i)));
|
|
*(tabDdlEte(i)) -= *(aa.tabDdlEte(i));
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Tab_Grandeur_Ddl_etendu::operator*= (double val)
|
|
{ int taille = tabDdlEte.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabDdlEte(i))*=val;
|
|
*(tabDdlEte(i)) *=val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tab_Grandeur_Ddl_etendu::operator/= (double val)
|
|
{ int taille = tabDdlEte.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabDdlEte(i))/=val;
|
|
*(tabDdlEte(i)) /=val;
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Tab_Grandeur_Ddl_etendu::GrandeurNumOrdre(int n) const
|
|
{ int taille = tabDdlEte.Taille();
|
|
if (taille == 0) return 0.; // cas d'un tableau vide
|
|
if (n > taille) {return 0.;} // cas où c'est impossible
|
|
else {return tabDdlEte(n)->GrandeurNumOrdre(1);};
|
|
};
|
|
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Tab_Grandeur_Ddl_etendu::NbMaxiNumeroOrdre() const
|
|
{ if (tabDdlEte.Taille() == 0) return 0; // cas d'un tableau vide
|
|
return (tabDdlEte.Taille());
|
|
};
|
|
|
|
void Tab_Grandeur_Ddl_etendu::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int taille = tabDdlEte.Taille();
|
|
for (int k=1;k<=taille;k++)
|
|
tabDdlEte(k)->Grandeur_brut(sort,nbcar);
|
|
};
|
|
|
|
// changement de taille -> n :
|
|
// si n < taille_actuelle --> les taille_actuelle - n sont supprimé
|
|
// si n > taille_actuelle --> le dernier élément existant est dupliqué n-taille_actuelle fois,
|
|
void Tab_Grandeur_Ddl_etendu::Change_taille(int n)
|
|
{ int taille = tabDdlEte.Taille();
|
|
if (n < taille)
|
|
{ for (int i=n;i<=taille;i++) delete tabDdlEte(i);
|
|
tabDdlEte.Change_taille(n);
|
|
}
|
|
else // sinon on augmente
|
|
{ tabDdlEte.Change_taille(n);
|
|
for (int i=taille;i<=n;i++)
|
|
tabDdlEte(i) = new Grandeur_Ddl_etendu(*tabDdlEte(taille));
|
|
};
|
|
};
|
|
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab_Grandeur_Ddl_etendu::InitParDefaut()
|
|
{int taille = tabDdlEte.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabDdlEte(i)->InitParDefaut();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//| un tableau de grandeur quelconque |
|
|
//-----------------------------------------------------------------------------
|
|
/*
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tableau_Grandeur_quelconque & a)
|
|
{ int taille = a.tab_grandeur.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_tenseurHH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_tenseurHH_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tableau_Grandeur_quelconque & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int nb;
|
|
ent >> nb;
|
|
if (nb != taille)
|
|
{ cout << "\n erreur en lecteur, la taille actuelle du tableau: " << taille
|
|
<< " est differente de la taille lue: " << nb
|
|
<< "\n operator >> (istream & ent, Tableau_Grandeur_quelconque & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> (a.tab_grandeur(i));
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tableau_Grandeur_quelconque & a)
|
|
{ int taille = a.tab_grandeur.Taille();
|
|
sort << " Tableau_Grandeur_quelconque= " << taille << " ";
|
|
for (int i=1;i<=taille;i++)
|
|
sort << (a.tab_grandeur(i)) << " ";
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, donc -> erreur
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque() : tab_grandeur()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de grandeur quelconque que contient le tableau
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(const TypeQuelconque::Grandeur& tg,int nb) :
|
|
tab_grandeur(nb,tg)
|
|
{ };
|
|
|
|
// constructeur qui effectue la construction en lisant les informations sur le stream d'entrée
|
|
// nécessite d'utiliser la fonction EcriturePourLectureAvecCreation() pour la fonction
|
|
// inverse c'est-à-dire l'écriture sur le stream, au lieu de la surcharge d'écriture normale
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(istream & ent) :
|
|
tab_grandeur()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_Grandeur_quelconque=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_Grandeur_quelconque= "
|
|
<< "\n Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int taille; ent >> taille ; // lecture de la taille du tableau
|
|
tab_grandeur.Change_taille(taille);
|
|
for (int i=1;i<=taille;i++)
|
|
{ tab_grandeur(i)=NevezTenseurHH(dimension); tab_grandeur(i)->Lecture(ent);};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(const Tableau_Grandeur_quelconque& a):
|
|
tab_grandeur(a.tab_grandeur)
|
|
{ int taille = a.tab_grandeur.Taille();
|
|
for (int i=1; i<=taille;i++)
|
|
tab_grandeur(i) = NevezTenseurHH(*(a.tab_grandeur(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tableau_Grandeur_quelconque::~Tableau_Grandeur_quelconque()
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++) delete tab_grandeur(i);
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tableau_Grandeur_quelconque::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tab_grandeur.Taille();
|
|
sort << " Tableau_Grandeur_quelconque= " << taille << " ";
|
|
if (taille != 0)
|
|
{for (int i=1;i<=taille;i++)
|
|
{
|
|
|
|
}
|
|
};
|
|
|
|
|
|
if (taille == 0) {sort << 0 << " ";}
|
|
else {sort << tab_grandeur(1)->Dimension() << " ";};
|
|
for (int i=1;i<=taille;i++)
|
|
tab_grandeur(i)->Ecriture(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tableau_Grandeur_quelconque::operator = ( const TypeQuelconque::Grandeur & b)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((b.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (b.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur a l'affectation: type de l'objet: "
|
|
<< "\n Tableau_Grandeur_quelconque::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tableau_Grandeur_quelconque& a= *((Tableau_Grandeur_quelconque*) &b);
|
|
int new_taille=a.tab_grandeur.Taille();
|
|
int taille = tab_grandeur.Taille();
|
|
// comme il s'agit d'un tableau de pointeur, on supprime
|
|
// les derniers si besoin, avant le changement de taille
|
|
if (new_taille < taille)
|
|
for (int i=new_taille;i<=taille; i++) delete tab_grandeur(i);
|
|
tab_grandeur.Change_taille(new_taille);
|
|
// affectation
|
|
for (int i=1;i<=new_taille;i++)
|
|
*tab_grandeur(i) =*a.tab_grandeur(i);
|
|
return *this;
|
|
};
|
|
|
|
// ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
|
|
// ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs de même type
|
|
// Surcharge de l'operateur +=
|
|
void Tableau_Grandeur_quelconque::operator+= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tableau_Grandeur_quelconque::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tableau_Grandeur_quelconque& aa= *((Tableau_Grandeur_quelconque*) &a);
|
|
int taille = tab_grandeur.Taille();
|
|
int tailleN = aa.tab_grandeur.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tableau_Grandeur_quelconque::operator+= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) (*tab_grandeur(i)) += (*(aa.tab_grandeur(i)));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tableau_Grandeur_quelconque::operator-= (const Grandeur& a)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if ((a.Type_grandeurAssocie() != this->Type_grandeurAssocie())
|
|
|| (a.Type_structure_grandeurAssocie() != this->Type_structure_grandeurAssocie()))
|
|
{ cout << "\n erreur sur le : type de l'objet: "
|
|
<< "\n Tableau_Grandeur_quelconque::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tableau_Grandeur_quelconque& aa= *((Tableau_Grandeur_quelconque*) &a);
|
|
int taille = tab_grandeur.Taille();
|
|
int tailleN = aa.tab_grandeur.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tableau_Grandeur_quelconque::operator-= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) (*tab_grandeur(i)) -= (*(aa.tab_grandeur(i)));
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Tableau_Grandeur_quelconque::operator*= (double val)
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++) (*tab_grandeur(i))*=val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tableau_Grandeur_quelconque::operator/= (double val)
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++) (*tab_grandeur(i))/=val;
|
|
};
|
|
|
|
// récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
|
|
// si pas possible, ramène 0
|
|
double Tableau_Grandeur_quelconque::GrandeurNumOrdre(int n) const
|
|
{ int taille = tab_grandeur.Taille();
|
|
int indice_tableau = n/taille + 1;
|
|
int r_div = n%taille;
|
|
if (taille == 0) return 0; // cas d'un tableau vide
|
|
|
|
switch (tab_grandeur(indice_tableau)->Dimension())
|
|
{case -1: case 1: return ((*(tab_grandeur(indice_tableau)))(1,1)); break;
|
|
case -2:{Tenseur_ns2HH& tens = *((Tenseur_ns2HH*) tab_grandeur(indice_tableau));
|
|
return tens(tens.idx_i(r_div),tens.idx_j(r_div));break;}
|
|
case 2: {Tenseur2HH& tens = *((Tenseur2HH*) tab_grandeur(indice_tableau));
|
|
return tens(tens.idx_i(r_div),tens.idx_j(r_div));break;}
|
|
case -3:{Tenseur_ns3HH& tens = *((Tenseur_ns3HH*) tab_grandeur(indice_tableau));
|
|
return tens(tens.idx_i(r_div),tens.idx_j(r_div));break;}
|
|
case 3: {Tenseur3HH& tens = *((Tenseur3HH*) tab_grandeur(indice_tableau));
|
|
return tens(tens.idx_i(r_div),tens.idx_j(r_div));break;}
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Tableau_Grandeur_quelconque::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0.; // pour taire le warning
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Tableau_Grandeur_quelconque::NbMaxiNumeroOrdre() const
|
|
{ int nbpartenseur=0;
|
|
if (tab_grandeur.Taille() == 0) return 0; // cas d'un tableau vide
|
|
switch (tab_grandeur(1)->Dimension())
|
|
{case -1: case 1: nbpartenseur= 1; break;
|
|
case -2: nbpartenseur= 4; break;
|
|
case 2: nbpartenseur= 3; break;
|
|
case -3: nbpartenseur= 9; break;
|
|
case 3: nbpartenseur= 6; break;
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Tableau_Grandeur_quelconque::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return (tab_grandeur.Taille() * nbpartenseur);
|
|
};
|
|
|
|
void Tableau_Grandeur_quelconque::Grandeur_brut(ostream & sort) const
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int k=1;k<=taille;k++)
|
|
{ TenseurHH& ptTens = *tab_grandeur(k);
|
|
int dim = ptTens.Dimension();
|
|
if (dim > 0)
|
|
{for (int i=1;i<=dim;i++)
|
|
for (int j=1;j<=i;j++)
|
|
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << ptTens(i,j) << " ";
|
|
}
|
|
else
|
|
{for (int i=1;i<=-dim;i++)
|
|
for (int j=1;j<=-dim;j++)
|
|
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << ptTens(i,j) << " ";
|
|
};
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tableau_Grandeur_quelconque::Change_repere(const Mat_pleine& jB)
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_grandeur(i)->ChBase(jB);
|
|
};
|
|
|
|
*/
|