Herezh_dev/tenseurs_mai99/Vecteurs/Vecteur2.cc

284 lines
7.8 KiB
C++

// FICHIER : Vecteur.cc
// CLASSE : Vecteur
// 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/>.
// concerne les méthodes qui ne sont pas en include
# include <iostream>
using namespace std; //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include <iomanip>
#include "ParaGlob.h"
#include "Vecteur.h"
#include "Coordonnee.h"
#include "MathUtil.h"
#include "ConstMath.h"
//// Constructeur fonction d'un Point
//Vecteur::Vecteur ( const Coordonnee& a)
//{ int n = a.Dimension();
// #ifdef MISE_AU_POINT
// if ( n < 0)
// {
// cout << "\nErreur : taille invalide ! n= " << n << '\n';
// cout << "Vecteur::Vecteur ( const Coordonnee& a) \n";
// Sortie(1);
// };
// #endif
// if ( n==0 )
// // cas ou la taille selectionnee est nulle : initialisation identique a l'appel
// // du constructeur par defaut
// { taille=0;
// v=NULL;
// }
// else
// { v=new double [n]; // allocation de la place memoire
// taille=n;
// for (int i=0;i<n;i++)
// // affectation des composantes du vecteur a a[i]
// v[i]=a(i+1);
// };
//};
//
//// cas d'un covariant
//Vecteur::Vecteur ( const CoordonneeB& a)
//{ int n = a.Dimension();
// #ifdef MISE_AU_POINT
// if ( n < 0)
// {
// cout << "\nErreur : taille invalide ! n= " << n << '\n';
// cout << "Vecteur::Vecteur ( const Coordonnee& a) \n";
// Sortie(1);
// };
// #endif
// if ( n==0 )
// // cas ou la taille selectionnee est nulle : initialisation identique a l'appel
// // du constructeur par defaut
// { taille=0;
// v=NULL;
// }
// else
// { v=new double [n]; // allocation de la place memoire
// taille=n;
// for (int i=0;i<n;i++)
// // affectation des composantes du vecteur a a[i]
// v[i]=a(i+1);
// };
//};
//
//// cas d'un contravariant
//Vecteur::Vecteur ( const CoordonneeH& a)
//{ int n = a.Dimension();
// #ifdef MISE_AU_POINT
// if ( n < 0)
// {
// cout << "\nErreur : taille invalide ! n= " << n << '\n';
// cout << "Vecteur::Vecteur ( const Coordonnee& a) \n";
// Sortie(1);
// };
// #endif
// if ( n==0 )
// // cas ou la taille selectionnee est nulle : initialisation identique a l'appel
// // du constructeur par defaut
// { taille=0;
// v=NULL;
// }
// else
// { v=new double [n]; // allocation de la place memoire
// taille=n;
// for (int i=0;i<n;i++)
// // affectation des composantes du vecteur a a[i]
// v[i]=a(i+1);
// };
//};
//
//
//// Surcharge de l'operateur = : affectation a partir d'un point
//Vecteur& Vecteur::operator= ( const Coordonnee& point)
////Vecteur& Vecteur::Egale_Coordonnee( const Coordonnee& point)
//{ if ((v!=NULL) && (point.Dimension() != taille))
// Libere(); // cas ou le vecteur se trouvant a gauche du signe =
// // n'est pas vide et est de taille differente
// // du point : desallocation de ce vecteur
// if ( point.Dimension() == 0 )
// // cas ou le point se trouvant a droite du signe = est vide : initialisation
// // identique a l'appel du constructeur par defaut
// { taille=0;
// v=NULL;
// }
// else if (point.Dimension() == taille)
// { for (int i=0;i<taille;i++)
// // copie des elements du point dans le vecteur se trouvant
// // a gauche du signe d'affectation
// v[i] = point(i+1);
// }
// else
// // autres cas
// { taille=point.Dimension();
// v=new double [taille];
// for (int i=0;i<taille;i++)
// // copie des elements du point dans le vecteur se trouvant
// // a gauche du signe d'affectation
// v[i] = point(i+1);
// };
// return (*this);
//};
//
// ========= insertion de vecteur.cc ==========
// Constructeur par defaut
Vecteur::Vecteur ()
{taille=0;
v=NULL;
};
// constructeur fonction d'un MV_Vector <double>
Vecteur::Vecteur (const MV_Vector <double>& a):
taille(a.size())
{ if ( taille==0 )
// cas ou le vecteur a est vide : initialisation identique a l'appel
// du constructeur par defaut
v=NULL;
else
// cas ou le vecteur a est de taille non nulle
{ v=new double [taille];
for (int i=0;i< taille;i++)
// copie des composantes du vecteur vec dans le vecteur declare
v[i] = a[i];
}
};
// Constructeur de copie
Vecteur::Vecteur (const Vecteur& vec)
{ if ( vec.taille==0 )
// cas ou le vecteur copie est vide : initialisation identique a l'appel
// du constructeur par defaut
{ v=NULL;
taille=0;
}
else
// cas ou le vecteur resultat est non affecte
{ v=new double [vec.taille];
taille=vec.taille;
for (int i=0;i< taille;i++)
// copie des composantes du vecteur vec dans le vecteur declare
v[i] = vec.v[i];
}
};
// -- création explicite de coordonnees équivalentes
Coordonnee Vecteur::Coordo() const
{ Coordonnee A(taille);
// c'est forcément une dimension <= 3
switch (taille)
{ case 3: A(3) = v[2];
case 2: A(2) = v[1];
case 1: A(1) = v[0];
case 0: ; // on ne fait rien
};
return A;
};
// -- création explicite de coordonnees équivalentes
CoordonneeH Vecteur::CoordoH() const
{ CoordonneeH A(taille);
// c'est forcément une dimension <= 3
switch (taille)
{ case 3: A(3) = v[2];
case 2: A(2) = v[1];
case 1: A(1) = v[0];
case 0: ; // on ne fait rien
};
return A;
};
// -- création explicite de coordonnees équivalentes
CoordonneeB Vecteur::CoordoB() const
{ CoordonneeB A(taille);
// c'est forcément une dimension <= 3
switch (taille)
{ case 3: A(3) = v[2];
case 2: A(2) = v[1];
case 1: A(1) = v[0];
case 0: ; // on ne fait rien
};
return A;
};
// calcul, récupération et affichage éventuelle
// des mini, maxi, et en valeur absolue la moyenne des composantes du vecteur
// en retour: le min, le max et la moyenne en valeur absolue
Coordonnee Vecteur::MinMaxMoy(bool affiche) const
{ Coordonnee retour(3);
if (taille > 0)
{ // calcul des grandeurs
double min=ConstMath::tresgrand,max=-ConstMath::tresgrand,moy=0.;
if (affiche)
{for (int i=1;i<taille;i++)
{double dia = v[i];
min = MiN(min, dia);
max = MaX(max, dia);
moy += Dabs(dia);
};
moy /= taille;
// affichage
cout << "\n vecteur a "<<taille<<" composantes: min= "<<min <<", max= "<<max<<", moy des |(i)| "<<moy<<flush;
}
else
{for (int i=1;i<taille;i++)
{double dia = v[i];
min = MiN(min, dia);
max = MaX(max, dia);
moy += Dabs(dia);
};
moy /= taille;
};
retour(1) = min; retour(2) = max; retour(3)=moy;
}
else
{double min=0.,max=0.,moy=0.;
retour(1) = min; retour(2) = max; retour(3)=moy;
if (affiche)
cout << "\n vecteur a "<<taille<<" composante: min= "<<min <<", max= "<<max<<", moy des |(i)| "<<moy<<flush;
}
return retour;
};