2375 lines
93 KiB
C++
2375 lines
93 KiB
C++
// 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"
|
|
#include "MathUtil2.h"
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
// grandeur TenseurHB: TypeQuelconque::Grandeur::Grandeur_TenseurHB|
|
|
//------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_TenseurHB & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_TenseurHB=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurHB= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_TenseurHB & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
a.ptTens->Lecture(ent);
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_TenseurHB & a)
|
|
{sort << " Grandeur_TenseurHB= " << " " ;
|
|
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_TenseurHB::Grandeur_TenseurHB() : ptTens(NevezTenseurHB(1))
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Grandeur_TenseurHB::Grandeur_TenseurHB()";
|
|
};
|
|
// 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_TenseurHB::Grandeur_TenseurHB(istream & ent) :
|
|
ptTens(NULL)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_TenseurHB=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_TenseurHB= "
|
|
<< "\n Grandeur_TenseurHB::Grandeur_TenseurHB(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
if (nom != "dim=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: dim= "
|
|
<< "\n Grandeur_TenseurHB::Grandeur_TenseurHB(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
int dimension; ent >> dimension; // lecture de la dimension
|
|
ptTens = NevezTenseurHB(dimension);
|
|
// lecture du tenseur
|
|
ptTens->Lecture(ent);
|
|
};
|
|
|
|
// destructeur
|
|
Grandeur_TenseurHB::~Grandeur_TenseurHB()
|
|
{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_TenseurHB::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_TenseurHB= " << "dim= " << ptTens->Dimension() << " ";
|
|
ptTens->Ecriture(sort);
|
|
};
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurHB::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_TenseurHB::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHB& aa= *((Grandeur_TenseurHB*) &a);
|
|
*ptTens = *aa.ptTens;return *this;
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_TenseurHB::operator = ( const Grandeur_TenseurHB & 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_TenseurHB::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_TenseurHB::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHB& aa= *((Grandeur_TenseurHB*) &a);
|
|
(*ptTens) = (*(aa.ptTens));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_TenseurHB::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_TenseurHB::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHB& aa= *((Grandeur_TenseurHB*) &a);
|
|
(*ptTens) += (*(aa.ptTens));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_TenseurHB::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_TenseurHB::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_TenseurHB& aa= *((Grandeur_TenseurHB*) &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_TenseurHB::GrandeurNumOrdre(int n) const
|
|
{ switch (ptTens->Dimension())
|
|
{case 1: return (*ptTens)(1,1); break;
|
|
case 2: {Tenseur2HB& tens = *((Tenseur2HB*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
case 3: {Tenseur3HB& tens = *((Tenseur3HB*) ptTens);
|
|
return tens(tens.idx_i(n),tens.idx_j(n));break;}
|
|
default:
|
|
cout << "\n erreur dimension du tenseur non defini !"
|
|
<< "\n Grandeur_TenseurHB::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0.; // pour taire le warning
|
|
};
|
|
// récup du nb maxi de numéros d'ordres
|
|
int Grandeur_TenseurHB::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_TenseurHB::NbMaxiNumeroOrdre()";
|
|
Sortie(1);
|
|
};
|
|
return 0; // pour taire le warning
|
|
};
|
|
|
|
void Grandeur_TenseurHB::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_TenseurHB::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ ptTens->ChBase(beta,gamma);};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de TenseurBH: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurBH|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_TenseurBH & a)
|
|
{ int taille = a.tabTens.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_TenseurBH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_TenseurBH_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_TenseurBH & 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_TenseurBH & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabTens(i)); // on utilise la lecture de Grandeur_TenseurBH
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurBH & a)
|
|
{ int taille = a.tabTens.Taille();
|
|
sort << " Tableau_de_TenseurBH_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabTens(i)); // on utilise l'écriture de Grandeur_TenseurBH
|
|
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_TenseurBH::Tab_Grandeur_TenseurBH() : tabTens()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_TenseurBH::Tab_Grandeur_TenseurBH()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab_Grandeur_TenseurBH::Tab_Grandeur_TenseurBH( TenseurBH& tens,int nb) :
|
|
tabTens(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
tabTens(i) = new Grandeur_TenseurBH(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_TenseurBH::Tab_Grandeur_TenseurBH(istream & ent) :
|
|
tabTens()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_TenseurBH_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_TenseurBH_nb= "
|
|
<< "\n Tab_Grandeur_TenseurBH::Tab_Grandeur_TenseurBH(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_TenseurBH(ent); // lecture au moment de la création de chaque tenseur
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_TenseurBH::Tab_Grandeur_TenseurBH(const Tab_Grandeur_TenseurBH& a):
|
|
tabTens(a.tabTens.Taille())
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i) = new Grandeur_TenseurBH(*(a.tabTens(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_TenseurBH::~Tab_Grandeur_TenseurBH()
|
|
{ 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_TenseurBH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabTens.Taille();
|
|
sort << " Tableau_de_TenseurBH_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_TenseurBH::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_TenseurBH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBH& a= *((Tab_Grandeur_TenseurBH*) &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_TenseurBH::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_TenseurBH::operator = ( const Tab_Grandeur_TenseurBH & 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_TenseurBH::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_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 Tab_Grandeur_TenseurBH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBH& aa= *((Tab_Grandeur_TenseurBH*) &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_TenseurBH::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_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 Tab_Grandeur_TenseurBH::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBH& aa= *((Tab_Grandeur_TenseurBH*) &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_TenseurBH::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_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 Tab_Grandeur_TenseurBH::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBH& aa= *((Tab_Grandeur_TenseurBH*) &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_TenseurBH::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_TenseurBH::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_TenseurBH::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_TenseurBH::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_TenseurBH::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_TenseurBH::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_TenseurBH::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_TenseurBH(*tabTens(taille));
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab_Grandeur_TenseurBH::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_TenseurBH::InitParDefaut()
|
|
{int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->InitParDefaut();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de TenseurBB: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurBB|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_TenseurBB & a)
|
|
{ int taille = a.tabTens.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_TenseurBB_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_TenseurBB_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_TenseurBB & 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_TenseurBB & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabTens(i)); // on utilise la lecture de Grandeur_TenseurBB
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurBB & a)
|
|
{ int taille = a.tabTens.Taille();
|
|
sort << " Tableau_de_TenseurBB_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabTens(i)); // on utilise l'écriture de Grandeur_TenseurBB
|
|
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_TenseurBB::Tab_Grandeur_TenseurBB() : tabTens()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_TenseurBB::Tab_Grandeur_TenseurBB()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab_Grandeur_TenseurBB::Tab_Grandeur_TenseurBB( TenseurBB& tens,int nb) :
|
|
tabTens(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
tabTens(i) = new Grandeur_TenseurBB(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_TenseurBB::Tab_Grandeur_TenseurBB(istream & ent) :
|
|
tabTens()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_TenseurBB_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_TenseurBB_nb= "
|
|
<< "\n Tab_Grandeur_TenseurBB::Tab_Grandeur_TenseurBB(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_TenseurBB(ent); // lecture au moment de la création de chaque tenseur
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_TenseurBB::Tab_Grandeur_TenseurBB(const Tab_Grandeur_TenseurBB& a):
|
|
tabTens(a.tabTens.Taille())
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i) = new Grandeur_TenseurBB(*(a.tabTens(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_TenseurBB::~Tab_Grandeur_TenseurBB()
|
|
{ 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_TenseurBB::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabTens.Taille();
|
|
sort << " Tableau_de_TenseurBB_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_TenseurBB::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_TenseurBB::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBB& a= *((Tab_Grandeur_TenseurBB*) &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_TenseurBB::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_TenseurBB::operator = ( const Tab_Grandeur_TenseurBB & 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_TenseurBB::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_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 Tab_Grandeur_TenseurBB::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBB& aa= *((Tab_Grandeur_TenseurBB*) &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_TenseurBB::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_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 Tab_Grandeur_TenseurBB::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBB& aa= *((Tab_Grandeur_TenseurBB*) &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_TenseurBB::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_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 Tab_Grandeur_TenseurBB::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurBB& aa= *((Tab_Grandeur_TenseurBB*) &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_TenseurBB::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_TenseurBB::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_TenseurBB::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_TenseurBB::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_TenseurBB::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_TenseurBB::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_TenseurBB::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_TenseurBB(*tabTens(taille));
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab_Grandeur_TenseurBB::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_TenseurBB::InitParDefaut()
|
|
{int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->InitParDefaut();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de TenseurHB: TypeQuelconque::Grandeur::Tab_Grandeur_TenseurHB|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_TenseurHB & a)
|
|
{ int taille = a.tabTens.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_TenseurHB_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_TenseurHB_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_TenseurHB & 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_TenseurHB & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabTens(i)); // on utilise la lecture de Grandeur_TenseurHB
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_TenseurHB & a)
|
|
{ int taille = a.tabTens.Taille();
|
|
sort << " Tableau_de_TenseurHB_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabTens(i)); // on utilise l'écriture de Grandeur_TenseurHB
|
|
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_TenseurHB::Tab_Grandeur_TenseurHB() : tabTens()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_TenseurHB::Tab_Grandeur_TenseurHB()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab_Grandeur_TenseurHB::Tab_Grandeur_TenseurHB( TenseurHB& tens,int nb) :
|
|
tabTens(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
tabTens(i) = new Grandeur_TenseurHB(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_TenseurHB::Tab_Grandeur_TenseurHB(istream & ent) :
|
|
tabTens()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_TenseurHB_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_TenseurHB_nb= "
|
|
<< "\n Tab_Grandeur_TenseurHB::Tab_Grandeur_TenseurHB(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_TenseurHB(ent); // lecture au moment de la création de chaque tenseur
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_TenseurHB::Tab_Grandeur_TenseurHB(const Tab_Grandeur_TenseurHB& a):
|
|
tabTens(a.tabTens.Taille())
|
|
{ int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i) = new Grandeur_TenseurHB(*(a.tabTens(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_TenseurHB::~Tab_Grandeur_TenseurHB()
|
|
{ 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_TenseurHB::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabTens.Taille();
|
|
sort << " Tableau_de_TenseurHB_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_TenseurHB::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_TenseurHB::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHB& a= *((Tab_Grandeur_TenseurHB*) &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_TenseurHB::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_TenseurHB::operator = ( const Tab_Grandeur_TenseurHB & 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_TenseurHB::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_TenseurHB::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_TenseurHB::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHB& aa= *((Tab_Grandeur_TenseurHB*) &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_TenseurHB::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_TenseurHB::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_TenseurHB::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHB& aa= *((Tab_Grandeur_TenseurHB*) &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_TenseurHB::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_TenseurHB::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_TenseurHB::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_TenseurHB& aa= *((Tab_Grandeur_TenseurHB*) &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_TenseurHB::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_TenseurHB::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_TenseurHB::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_TenseurHB::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_TenseurHB::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_TenseurHB::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_TenseurHB::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_TenseurHB(*tabTens(taille));
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab_Grandeur_TenseurHB::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_TenseurHB::InitParDefaut()
|
|
{int taille = tabTens.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabTens(i)->InitParDefaut();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//| grandeur scalaire entier: TypeQuelconque::Grandeur::Grandeur_scalaire_entier|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_scalaire_entier & 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_entier & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// lecture
|
|
ent >> a.val;
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_scalaire_entier & a)
|
|
{sort << " d= " << a.val << " " ;
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Grandeur_scalaire_entier::Grandeur_scalaire_entier():
|
|
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_entier::Grandeur_scalaire_entier(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_entier::Grandeur_scalaire_entier(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_entier::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " d= " << val << " ";};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_scalaire_entier::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_entier::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_entier& aa= *((Grandeur_scalaire_entier*) &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_entier::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_entier::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_entier& aa= *((Grandeur_scalaire_entier*) &a);
|
|
val = aa.val;
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_scalaire_entier::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_entier::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_entier& aa= *((Grandeur_scalaire_entier*) &a);
|
|
val+=aa.val;
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_scalaire_entier::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_entier::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_scalaire_entier& aa= *((Grandeur_scalaire_entier*) &a);
|
|
val-=aa.val;
|
|
};
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//| grandeur tableau de scalaires entier: TypeQuelconque::Grandeur::Tab_Grandeur_scalaire_entier|
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_scalaire_entier & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Tab_G_s_entier=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tab_G_s_entier= "
|
|
<< "\n operator << (ostream & sort , const Tab_Grandeur_scalaire_entier & 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_entier & a)
|
|
{sort << " Tab_G_s_entier= " ;
|
|
a.tab_val.Sortir_sansRet(sort);
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Tab_Grandeur_scalaire_entier::Tab_Grandeur_scalaire_entier():
|
|
tab_val() {};
|
|
// constructeur légal
|
|
Tab_Grandeur_scalaire_entier::Tab_Grandeur_scalaire_entier(const Tableau <int>& 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_entier::Tab_Grandeur_scalaire_entier(istream & ent)
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tab_G_s_entier=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tab_G_s_entier= "
|
|
<< "\n Tab_Grandeur_scalaire_entier::Tab_Grandeur_scalaire_entier(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_entier::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Tab_G_s_entier= " ;
|
|
tab_val.Sortir_sansRet(sort);};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_scalaire_entier::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_entier::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_entier& aa= *((Tab_Grandeur_scalaire_entier*) &a);
|
|
tab_val=aa.tab_val;return *this;
|
|
};
|
|
|
|
// surcharge d'affectation avec un tableau d'entiers
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_scalaire_entier::operator = ( const Tableau <int>& 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_entier::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_entier::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_entier& aa= *((Tab_Grandeur_scalaire_entier*) &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_entier::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<= taille_ex;i++)
|
|
tab_val(i).Affectation_numerique(aa.tab_val(i));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_scalaire_entier::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_entier::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_entier& aa= *((Tab_Grandeur_scalaire_entier*) &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_entier::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_entier::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_entier::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_scalaire_entier& aa= *((Tab_Grandeur_scalaire_entier*) &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_entier::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_entier::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_entier::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_entier::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_entier::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_entier::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_entier::InitParDefaut()
|
|
{int taille = tab_val.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_val(i).InitParDefaut();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//| grandeur Grandeur_Vecteur_Nommer: TypeQuelconque::Grandeur::Grandeur_Vecteur_Nommer|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_Vecteur_Nommer & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_Vecteur_Nommer=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_Vecteur_Nommer= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_Vecteur_Nommer & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> a.nom_ref >> a.v;
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_Vecteur_Nommer & a)
|
|
{sort << " Grandeur_Vecteur_Nommer= " << a.nom_ref << " " << a.v << " " ;
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut:
|
|
Grandeur_Vecteur_Nommer::Grandeur_Vecteur_Nommer():
|
|
nom_ref(""),v(),fct(NULL) {};
|
|
|
|
// 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_Vecteur_Nommer::Grandeur_Vecteur_Nommer(istream & ent):
|
|
v()
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_Vecteur_Nommer=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_Vecteur_Nommer= "
|
|
<< "\n Grandeur_Vecteur_Nommer::Grandeur_Vecteur_Nommer(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// fin de la lecture
|
|
ent >> nom_ref >> v;
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_Vecteur_Nommer::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_Vecteur_Nommer= " << nom_ref << " " << v << " ";};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_Vecteur_Nommer::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_Vecteur_Nommer::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Vecteur_Nommer& aa= *((Grandeur_Vecteur_Nommer*) &a);
|
|
v=aa.v;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_Vecteur_Nommer::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_Vecteur_Nommer::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Vecteur_Nommer& aa= *((Grandeur_Vecteur_Nommer*) &a);
|
|
v = aa.v;
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_Vecteur_Nommer::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_Vecteur_Nommer::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Vecteur_Nommer& aa= *((Grandeur_Vecteur_Nommer*) &a);
|
|
v +=aa.v;
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_Vecteur_Nommer::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_Vecteur_Nommer::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_Vecteur_Nommer& aa= *((Grandeur_Vecteur_Nommer*) &a);
|
|
v -=aa.v;
|
|
};
|
|
|
|
void Grandeur_Vecteur_Nommer::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{int taille = v.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
sort << setw(nbcar) << setprecision(nbcar) << v(i) << " ";
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de Grandeur_Vecteur_Nommer: TypeQuelconque::Grandeur::Tab_Grandeur_Vecteur_Nommer|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Tab_Grandeur_Vecteur_Nommer & a)
|
|
{ int taille = a.tabVN.Taille(); string entete;
|
|
ent >> entete; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_Vecteur_Nommer_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_Vecteur_Nommer_nb= "
|
|
<< "\n istream & operator >> (istream & ent, Tab_Grandeur_Vecteur_Nommer & 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_Vecteur_Nommer & a)";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
ent >> *(a.tabVN(i)); // on utilise la lecture de Grandeur_Vecteur_Nommer
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_Vecteur_Nommer & a)
|
|
{ int taille = a.tabVN.Taille();
|
|
sort << " Tableau_de_Vecteur_Nommer_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tabVN(i)); // on utilise l'écriture de Grandeur_Vecteur_Nommer
|
|
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_Vecteur_Nommer::Tab_Grandeur_Vecteur_Nommer() : tabVN()
|
|
{ cout << "\n erreur! ce constructeur ne doit pas etre utilise !!"
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::Tab_Grandeur_Vecteur_Nommer()";
|
|
};
|
|
|
|
// constructeur légal
|
|
// nb indique le nombre de tenseur
|
|
Tab_Grandeur_Vecteur_Nommer::Tab_Grandeur_Vecteur_Nommer( Grandeur_Vecteur_Nommer& tens,int nb) :
|
|
tabVN(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
{Grandeur_Vecteur_Nommer * pt = new Grandeur_Vecteur_Nommer(tens);
|
|
tabVN(i) = pt;
|
|
};
|
|
// this->Ecriture_grandeur(cout); // débug
|
|
// cout << endl;
|
|
};
|
|
|
|
// 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_Vecteur_Nommer::Tab_Grandeur_Vecteur_Nommer(istream & ent) :
|
|
tabVN()
|
|
{ string entete,nom; ent >> entete ; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tableau_de_Vecteur_Nommer_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_de_Vecteur_Nommer_nb= "
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::Tab_Grandeur_Vecteur_Nommer(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
|
|
{tabVN.Change_taille(0);}
|
|
else // sinon il nous faut définir les éléments du tableau au fur et à mesure de la lecture
|
|
{ tabVN.Change_taille(taille);
|
|
for (int i=1;i<=taille;i++)
|
|
tabVN(i) = new Grandeur_Vecteur_Nommer(ent); // lecture au moment de la création de chaque tenseur
|
|
};
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tab_Grandeur_Vecteur_Nommer::Tab_Grandeur_Vecteur_Nommer(const Tab_Grandeur_Vecteur_Nommer& a):
|
|
tabVN(a.tabVN.Taille())
|
|
{ int taille = tabVN.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabVN(i) = new Grandeur_Vecteur_Nommer(*(a.tabVN(i)));
|
|
};
|
|
|
|
// destructeur
|
|
Tab_Grandeur_Vecteur_Nommer::~Tab_Grandeur_Vecteur_Nommer()
|
|
{ int taille = tabVN.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
delete tabVN(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_Vecteur_Nommer::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{ int taille = tabVN.Taille();
|
|
sort << " Tableau_de_Vecteur_Nommer_nb= " << taille << " "; //<< " dim= ";
|
|
for (int i=1;i<=taille;i++)
|
|
tabVN(i)->EcriturePourLectureAvecCreation(sort);
|
|
};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_Vecteur_Nommer::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_Vecteur_Nommer::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Vecteur_Nommer& a= *((Tab_Grandeur_Vecteur_Nommer*) &b);
|
|
// maintenant l'affectation
|
|
int taille = tabVN.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabVN.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabVN.Taille()
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
*(tabVN(i))= *(a.tabVN(i));
|
|
return *this;
|
|
};
|
|
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_Vecteur_Nommer::operator = ( const Tab_Grandeur_Vecteur_Nommer & a)
|
|
{
|
|
// maintenant l'affectation
|
|
int taille = tabVN.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tabVN.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tabVN.Taille()
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=taille;i++)
|
|
*(tabVN(i))= *(a.tabVN(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_Vecteur_Nommer::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_Vecteur_Nommer::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Vecteur_Nommer& aa= *((Tab_Grandeur_Vecteur_Nommer*) &a);
|
|
int taille = tabVN.Taille();
|
|
int tailleN = aa.tabVN.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::Affectation_numerique(..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
(tabVN(i))->Affectation_numerique(*(aa.tabVN(i)));
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_Vecteur_Nommer::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_Vecteur_Nommer::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Vecteur_Nommer& aa= *((Tab_Grandeur_Vecteur_Nommer*) &a);
|
|
int taille = tabVN.Taille();
|
|
int tailleN = aa.tabVN.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::operator+= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabVN(i)) += (*(aa.tabVN(i)));
|
|
*(tabVN(i)) += *(aa.tabVN(i));
|
|
};
|
|
// Surcharge de l'operateur -=
|
|
void Tab_Grandeur_Vecteur_Nommer::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_Vecteur_Nommer::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_Vecteur_Nommer& aa= *((Tab_Grandeur_Vecteur_Nommer*) &a);
|
|
int taille = tabVN.Taille();
|
|
int tailleN = aa.tabVN.Taille();
|
|
if (taille != tailleN)
|
|
{ cout << "\n erreur sur les dimensions des tableaux taille de this puis de a "
|
|
<< taille << " " << tailleN << " "
|
|
<< "\n Tab_Grandeur_Vecteur_Nommer::operator-= (..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++) //(*tabVN(i)) -= (*(aa.tabVN(i)));
|
|
*(tabVN(i)) -= *(aa.tabVN(i));
|
|
};
|
|
// Surcharge de l'operateur *=
|
|
void Tab_Grandeur_Vecteur_Nommer::operator*= (double val)
|
|
{ int taille = tabVN.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabVN(i))*=val;
|
|
*(tabVN(i)) *=val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tab_Grandeur_Vecteur_Nommer::operator/= (double val)
|
|
{ int taille = tabVN.Taille();
|
|
for (int i=1;i<=taille;i++) //(*tabVN(i))/=val;
|
|
*(tabVN(i)) /=val;
|
|
};
|
|
|
|
void Tab_Grandeur_Vecteur_Nommer::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int taille = tabVN.Taille();
|
|
for (int k=1;k<=taille;k++)
|
|
tabVN(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_Vecteur_Nommer::Change_taille(int n)
|
|
{ int taille = tabVN.Taille();
|
|
if (n < taille)
|
|
{ for (int i=n;i<=taille;i++) delete tabVN(i);
|
|
tabVN.Change_taille(n);
|
|
}
|
|
else // sinon on augmente
|
|
{ tabVN.Change_taille(n);
|
|
for (int i=taille;i<=n;i++)
|
|
tabVN(i) = new Grandeur_Vecteur_Nommer(*tabVN(taille));
|
|
};
|
|
};
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab_Grandeur_Vecteur_Nommer::InitParDefaut()
|
|
{int taille = tabVN.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tabVN(i)->InitParDefaut();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur une base H |
|
|
//------------------------------------------------------------------------------------
|
|
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & ent, Grandeur_BaseH & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Grandeur_BaseH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_BaseH= "
|
|
<< "\n operator << (ostream & sort , const Grandeur_BaseH & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> a.baseH;
|
|
return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Grandeur_BaseH & a)
|
|
{sort << " Grandeur_BaseH= " << a.baseH << " " ;
|
|
return sort;
|
|
};
|
|
|
|
// 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_BaseH::Grandeur_BaseH(istream & ent):
|
|
baseH()
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Grandeur_BaseH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Grandeur_BaseH= "
|
|
<< "\n Grandeur_BaseH::Grandeur_BaseH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
BaseH inter; // une base de travail
|
|
ent >> inter; // il y a un redimensionnement à la lecture
|
|
baseH = inter; // redimensionnement à l'affectation
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permettant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Grandeur_BaseH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Grandeur_BaseH= " << baseH << " ";};
|
|
|
|
// surcharge d'affectation
|
|
TypeQuelconque::Grandeur & Grandeur_BaseH::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_BaseH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_BaseH& aa= *((Grandeur_BaseH*) &a);
|
|
baseH=aa.baseH;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_BaseH::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_BaseH::Affectation_numerique(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_BaseH& aa= *((Grandeur_BaseH*) &a);
|
|
int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) = aa.baseH(i);
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Grandeur_BaseH::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_BaseH::operator+= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_BaseH& aa= *((Grandeur_BaseH*) &a);
|
|
int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) += aa.baseH(i);
|
|
};
|
|
|
|
void Grandeur_BaseH::operator+= (const Grandeur_BaseH& aa)
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) += aa.baseH(i);
|
|
};
|
|
|
|
// Surcharge de l'operateur -=
|
|
void Grandeur_BaseH::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_BaseH::operator-= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Grandeur_BaseH& aa= *((Grandeur_BaseH*) &a);
|
|
int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) -= aa.baseH(i);
|
|
};
|
|
void Grandeur_BaseH::operator-= (const Grandeur_BaseH& aa)
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) -= aa.baseH(i);
|
|
};
|
|
|
|
// Surcharge de l'operateur *=
|
|
void Grandeur_BaseH::operator*= (double val)
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) *= val;
|
|
};
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Grandeur_BaseH::operator/= (double val)
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i) /= val;
|
|
};
|
|
|
|
int Grandeur_BaseH::NbMaxiNumeroOrdre() const // récup du nb maxi de numéros d'ordres
|
|
{// on va suivre les coordonnées de chaque vecteur
|
|
int nb_vec = baseH.NbVecteur();
|
|
int dim = baseH.Dimension();
|
|
int max = nb_vec * dim;
|
|
return max;
|
|
};
|
|
|
|
// 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_BaseH::GrandeurNumOrdre(int num) const
|
|
{// on va suivre les coordonnées de chaque vecteur
|
|
int nb_vec = baseH.NbVecteur();
|
|
int dim = baseH.Dimension();
|
|
int a = (num-1) / dim ; // le numéro du vecteur
|
|
int i = num - a * dim; // l'indice de la coordonnée
|
|
#ifdef MISE_AU_POINT
|
|
int max = nb_vec * dim;
|
|
if ((num > max) || (num < 1))
|
|
{ cout << "\n erreur d'acces a la grandeur de numero d'ordre " << num
|
|
<< " seules sont accessibles les grandeurs de numeros entre 1 et "<< max
|
|
<< "\n Grandeur_BaseH::GrandeurNumOrdre(int num)";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
return baseH(a)(i);
|
|
};
|
|
|
|
void Grandeur_BaseH::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH(i).Affiche(sort,nbcar);
|
|
};
|
|
// change de repère de la grandeur
|
|
void Grandeur_BaseH::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
{//CoordonneeH inter(ParaGlob::Dimension());
|
|
MathUtil2::ChBase(baseH(i),gamma,baseH.CoordoH(i));
|
|
//baseH.CoordoH(i) = inter;
|
|
};
|
|
};
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Grandeur_BaseH::InitParDefaut()
|
|
{ int nb_vec = baseH.NbVecteur();
|
|
for (int i=1;i<=nb_vec;i++)
|
|
baseH.CoordoH(i).Zero();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de Grandeur_BaseH: TypeQuelconque::Grandeur::Tab_Grandeur_BaseH|
|
|
// 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_BaseH & a)
|
|
{ string toto; ent >> toto; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "Tab_Grandeur_BaseH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tab_Grandeur_BaseH= "
|
|
<< "\n operator << (ostream & sort , const Tab_Grandeur_BaseH & a)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> a.tabBaseH;
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'ecriture
|
|
ostream & operator << (ostream & sort , const Tab_Grandeur_BaseH & a)
|
|
{sort << " Tab_Grandeur_BaseH= " << a.tabBaseH << " " ;
|
|
return sort;
|
|
};
|
|
|
|
// 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_BaseH::Tab_Grandeur_BaseH(istream & ent) :
|
|
tabBaseH()
|
|
{ string entete,nom; ent >> entete >> nom; // passage de l'entête
|
|
#ifdef MISE_AU_POINT
|
|
if (entete != "Tab_Grandeur_BaseH=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tab_Grandeur_BaseH= "
|
|
<< "\n Tab_Grandeur_BaseH::Tab_Grandeur_BaseH(istream & ent)";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
ent >> tabBaseH; // il y a un redimensionnement à la lecture
|
|
};
|
|
|
|
// sauvegarde sur le stream des informations permetant ensuite en lecture de créer via
|
|
// le constructeur adoc l'objet correcte et valide
|
|
void Tab_Grandeur_BaseH::EcriturePourLectureAvecCreation(ostream & sort)
|
|
{sort << " Tab_Grandeur_BaseH= " << tabBaseH << " ";};
|
|
|
|
TypeQuelconque::Grandeur & Tab_Grandeur_BaseH::operator = ( const Grandeur & a) // surcharge d'affectation
|
|
{
|
|
#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_BaseH::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_BaseH& aa= *((Tab_Grandeur_BaseH*) &a);
|
|
tabBaseH=aa.tabBaseH; 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_BaseH::Affectation_numerique( const TypeQuelconque::Grandeur & a)
|
|
{*this = a;
|
|
};
|
|
|
|
// Surcharge de l'operateur +=
|
|
void Tab_Grandeur_BaseH::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 a l'affectation: type de l'objet: "
|
|
<< "\n Tab_Grandeur_BaseH::operator += (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_BaseH& aa= *((Tab_Grandeur_BaseH*) &a);
|
|
int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(i) += aa.tabBaseH(i);
|
|
} ;
|
|
|
|
// Surcharge de l'operateur -=
|
|
void Tab_Grandeur_BaseH::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 a l'affectation: type de l'objet: "
|
|
<< "\n Tab_Grandeur_BaseH::operator -= (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
Tab_Grandeur_BaseH& aa= *((Tab_Grandeur_BaseH*) &a);
|
|
int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(i) -= aa.tabBaseH(i);
|
|
} ;
|
|
// Surcharge de l'operateur *=
|
|
void Tab_Grandeur_BaseH::operator*= (double val)
|
|
{ int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(i) *= val;
|
|
} ;
|
|
// Surcharge de l'operateur /= : division par un scalaire
|
|
void Tab_Grandeur_BaseH::operator/= (double val)
|
|
{ int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(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_BaseH::GrandeurNumOrdre(int num) const
|
|
{ int num_dans_tableau = 0;
|
|
int taille_et_1 = tabBaseH.Taille() + 1;
|
|
int indic = 0;int i=0;
|
|
for (i=1;i<taille_et_1;i++)
|
|
{num_dans_tableau = indic; // on garde le précédent
|
|
indic += tabBaseH(i).NbMaxiNumeroOrdre();
|
|
if (indic > num)
|
|
break;
|
|
};
|
|
return tabBaseH(i).GrandeurNumOrdre(num-num_dans_tableau);
|
|
};
|
|
int Tab_Grandeur_BaseH::NbMaxiNumeroOrdre() const // récup du nb maxi de numéros d'ordres
|
|
{ int retour = 0;
|
|
int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
retour += tabBaseH(i).NbMaxiNumeroOrdre();
|
|
return retour;
|
|
};
|
|
void Tab_Grandeur_BaseH::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(i).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_BaseH::Change_taille(int n)
|
|
{tabBaseH.Change_taille(n);
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tab_Grandeur_BaseH::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(i).Change_repere(beta,gamma);
|
|
};
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tab_Grandeur_BaseH::InitParDefaut()
|
|
{ int taille_et_1 = tabBaseH.Taille() + 1;
|
|
for (int i=1;i<taille_et_1;i++)
|
|
tabBaseH(i).InitParDefaut();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// grandeur un tableau de Tableau_Grandeur_quelconque: TypeQuelconque::Grandeur::Tableau_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_Grandeur_quelconque_nb=")
|
|
{cout << "\n erreur en lecteur, on attendait le mot cle: Tableau_Grandeur_quelconque_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)); // on utilise la lecture de la grandeur quelconque
|
|
return ent;
|
|
};
|
|
|
|
// surcharge de l'operator d'écriture
|
|
ostream & operator << (ostream & sort , const Tableau_Grandeur_quelconque & a)
|
|
{ int taille = a.tab_grandeur.Taille();
|
|
sort << " Tableau_Grandeur_quelconque_nb= " << taille ;
|
|
for (int i=1;i<=taille;i++)
|
|
sort << *(a.tab_grandeur(i)); // on utilise l'écriture de la grandeur quelconque
|
|
return sort;
|
|
};
|
|
|
|
// constructeur par défaut: ne doit pas être utilisé, car on doit toujours avoir la variable
|
|
// ptTens défini, 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 grandeurs quelconques
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque( const TypeQuelconque::Grandeur& tens,int nb) :
|
|
tab_grandeur(nb)
|
|
{ for (int i=1;i<=nb;i++)
|
|
{TypeQuelconque::Grandeur * pt = tens.New_idem_grandeur();
|
|
tab_grandeur(i) = pt;
|
|
};
|
|
// this->Ecriture_grandeur(cout); // débug
|
|
// cout << endl;
|
|
};
|
|
//// cas d'un tableau déjà connu
|
|
//Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(const Tableau <TypeQuelconque::Grandeur> & tab) :
|
|
// tab_grandeur(tab.Taille())
|
|
// { int nb = tab.Taille();
|
|
// for (int i=1;i<=nb;i++)
|
|
// {TypeQuelconque::Grandeur * pt = tab(i).New_idem_grandeur();
|
|
// tab_grandeur(i) = pt;
|
|
// };
|
|
//// this->Ecriture_grandeur(cout); // débug
|
|
//// cout << endl;
|
|
// };
|
|
|
|
// cas d'un tableau de pointeurs déjà connu
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(const Tableau <TypeQuelconque::Grandeur*> & tab) :
|
|
tab_grandeur(tab.Taille())
|
|
{ int nb = tab.Taille();
|
|
for (int i=1;i<=nb;i++)
|
|
{TypeQuelconque::Grandeur * pt = tab(i)->New_idem_grandeur();
|
|
tab_grandeur(i) = pt;
|
|
};
|
|
// this->Ecriture_grandeur(cout); // débug
|
|
// cout << endl;
|
|
};
|
|
|
|
// cas d'un tableau de grandeurs quelconques déjà connu
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(const Tableau <TypeQuelconque> & tab) :
|
|
tab_grandeur(tab.Taille())
|
|
{ int nb = tab.Taille();
|
|
for (int i=1;i<=nb;i++)
|
|
{TypeQuelconque::Grandeur * pt = tab(i).Grandeur_pointee()->New_idem_grandeur();
|
|
tab_grandeur(i) = pt;
|
|
};
|
|
// this->Ecriture_grandeur(cout); // débug
|
|
// cout << endl;
|
|
};
|
|
|
|
// constructeur de copie
|
|
Tableau_Grandeur_quelconque::Tableau_Grandeur_quelconque(const Tableau_Grandeur_quelconque& a):
|
|
tab_grandeur(a.tab_grandeur.Taille())
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_grandeur(i) = a.tab_grandeur(i)->New_idem_grandeur();
|
|
};
|
|
|
|
// destructeur
|
|
Tableau_Grandeur_quelconque::~Tableau_Grandeur_quelconque()
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
delete tab_grandeur(i);
|
|
};
|
|
|
|
// 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);
|
|
// maintenant l'affectation
|
|
int taille = tab_grandeur.Taille();
|
|
#ifdef MISE_AU_POINT
|
|
if (taille != a.tab_grandeur.Taille())
|
|
{ cout << "\n erreur a l'affectation: la taille de this " << taille << " n'est pas egale a celle "
|
|
<< " du parametre " << a.tab_grandeur.Taille()
|
|
<< "\n Tableau_Grandeur_quelconque::operator = (..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
for (int i=1;i<=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
|
|
// affectation uniquement des données numériques (pas les pointeurs, pas les string)
|
|
void Tableau_Grandeur_quelconque::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 Tableau_Grandeur_quelconque::Affectation_numerique(..";
|
|
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::Affectation_numerique(..";
|
|
Sortie(1);
|
|
};
|
|
for (int i=1;i<=taille;i++)
|
|
(tab_grandeur(i))->Affectation_numerique(*(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)));
|
|
*(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)));
|
|
*(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;
|
|
*(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;
|
|
*(tab_grandeur(i)) /=val;
|
|
};
|
|
|
|
void Tableau_Grandeur_quelconque::Grandeur_brut(ostream & sort,int nbcar) const
|
|
{ // la méthode n'est pas adaptée
|
|
cout << "\n *** erreur la methode n'est pas adaptee !! "
|
|
<< " \n Tableau_Grandeur_quelconque::Grandeur_brut(...";
|
|
Sortie(1);
|
|
// int taille = tab_grandeur.Taille();
|
|
// for (int k=1;k<=taille;k++)
|
|
// tab_grandeur(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 Tableau_Grandeur_quelconque::Change_taille(int n)
|
|
{ int taille = tab_grandeur.Taille();
|
|
if (n < taille)
|
|
{ for (int i=n;i<=taille;i++) delete tab_grandeur(i);
|
|
tab_grandeur.Change_taille(n);
|
|
}
|
|
else // sinon on augmente
|
|
{ tab_grandeur.Change_taille(n);
|
|
for (int i=taille;i<=n;i++)
|
|
tab_grandeur(i) = tab_grandeur(taille)->New_idem_grandeur();
|
|
};
|
|
};
|
|
|
|
// change de repère de la grandeur
|
|
void Tableau_Grandeur_quelconque::Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_grandeur(i)->Change_repere(beta,gamma);
|
|
};
|
|
|
|
|
|
// initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
|
|
void Tableau_Grandeur_quelconque::InitParDefaut()
|
|
{int taille = tab_grandeur.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
tab_grandeur(i)->InitParDefaut();
|
|
};
|
|
|
|
|
|
|
|
|