// 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;
};


