285 lines
7.8 KiB
C++
285 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;
|
||
|
|
};
|
||
|
|
|
||
|
|
|