// 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-2022 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"




// =========    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) :
  memoire(vec.memoire)
{
  // --- cas d'un vecteur lié
  if(!memoire) // cas où le vecteur ne gère pas sa mémoire
     // on décide que le nouveau vecteur sera du même type
     // donc positionné au même endroit, les grandeurs sont donc
     // déjà identiques
     {taille = vec.taille;
      v = vec.v;
     }
  // --- fin cas d'un vecteur lié
  else 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 normale
	  //  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;
};