// 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/>.


////#include "Debug.h"

# include <iostream>
using namespace std;  //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include <iomanip>
#include "ParaGlob.h"
#include "CharUtil.h"

#include "Vecteur.h"

#ifndef  VECTEUR_H_deja_inclus
 

#ifndef MISE_AU_POINT
  inline 
#endif
// Constructeur permettant de definir un vecteur de taille n initialise a 0
Vecteur::Vecteur (int n):
   memoire(true)
{  
 #ifdef MISE_AU_POINT
 if ( n<0 )
   {	cout << "\nErreur : taille invalide !\n";
    cout << "VECTEUR::VECTEUR (int ) \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 0
     v[i]=0.0; 				    		
   };
};
 
#ifndef MISE_AU_POINT
  inline 
#endif
// Constructeur permettant de definir un vecteur de taille n initialise a val
Vecteur::Vecteur (int n,double val) :
    memoire(true)
{
 #ifdef MISE_AU_POINT
	if ( n<0 )
   {	cout << "\nErreur : taille invalide !\n";
    cout << "VECTEUR::VECTEUR (int ,double ) \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 val
     v[i]=val; 			
   };	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Constructeur permettant de definir un vecteur de taille n dont les premieres valeurs
// sont celles de vec
// aucun test n'est fait concernant la taille disponible de vec
Vecteur::Vecteur (int n,double* vec) : // routine dangereuse !!!!!
   memoire(true)
{	
 #ifdef MISE_AU_POINT
  if ( n < 0)
    {
     cout << "\nErreur : taille invalide ! n= " << n << '\n';
     cout << "VECTEUR::VECTEUR (int ,double* ) \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 au tableau vec
     v[i]=vec[i]; 			
   };	
};

/// --------- cas très particulier d'un vecteur lié
/// --------- utilisé uniquement par des classes friend
#ifndef MISE_AU_POINT
  inline
#endif
/// c-a-d qui ne gère pas sa mémoire -> memoire = false par défaut
/// le booléen sert pour différencier le constructeur avec
/// Vecteur::Vecteur (int n,double* vec)
/// Constructeur fonction d'un tableau de composantes déjà existant
/// il s'agit d'un tuillage, le vecteur ne gère pas sa mémoire
/// aucun test n'est fait concernant la taille disponible de vec
/// routine dangereuse !!!!!
/// il n'y a pas d'initialisation des composantes !!
Vecteur::Vecteur (int n,double* vec,bool memoi) :
    memoire(false)
     {
      #ifdef MISE_AU_POINT
       if ( n < 0)
         {
          cout << "\nErreur : taille invalide ! n= " << n << '\n';
          cout << "VECTEUR::VECTEUR (int n,double* vec,bool memoi) \n";
          Sortie(1);
         };
      #endif
      v = vec;
      taille = n;
     };

		
#ifndef MISE_AU_POINT
  inline 
#endif
// Destructeur
Vecteur::~Vecteur ()
{ // on libère la mémoire que s'il s'agit d'un vecteur libre
  if (memoire)
    Libere();
};

// Retourne la taille du vecteur
#ifndef MISE_AU_POINT
  inline 
#endif
int Vecteur::Taille () const 
		{ return taille; };

#ifndef MISE_AU_POINT
  inline 
#endif
// Affiche les donnees concernant le vecteur
void Vecteur::Affiche ()  const 
{double* ptr=v;
	cout << "\nTaille du vecteur : " << taille << " .\n";
	cout << "Composante(s) :\n\t{  ";
	for (int i=0;i<taille;i++)
		cout << (*ptr++) << "  ";
	cout << "}\n" << endl;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Affichage des composantes du vecteur avec paramètres de contrôle
void Vecteur::Affiche (int min_i,int max_i,int pas_i, int nbd)  const 
{cout << "\nTaille du vecteur : " << taille << " .\n";
	cout << "Composante(s) :\n\t{  ";
    for (int i=min_i;i<=max_i;i+=pas_i)
       cout << setw(nbd) << setprecision(nbd) << (*this)(i) << " ";
	cout << "}\n" << endl;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Affiche les donnees concernant le vecteur
void Vecteur::Affichage_ecran(string entete)  const 
 {// affichage éventuelle du vecteur       
  cout << "\n --- " << entete << " -----";
  string rep;
  cout << "\n voulez-vous afficher le vecteur ? (o ou n(defaut)) ";
  rep = lect_return_defaut(false,"n");
  if (rep == "o") 
    {cout << "\n parametre d'affichage par defaut (tout le vecteur) ? (o ou n(defaut))  " ;
     rep = lect_return_defaut(false,"n");
     int min_i,max_i,pas_i,nd;
     if (rep =="o")
         { min_i=1; max_i=taille; pas_i=1; nd=14;}
     else
        {try 
           { cout << "\n a partir de quel numero de composante ? (1) "; min_i=(int)lect_double();
             cout << " jusqu'a quel numero de composante ? ("<<taille<<")  "; max_i=(int)lect_double();
             cout << " par pas de ? (1) "; pas_i=(int)lect_double();
             cout << "\n nombre de diggit ? (14) "; nd=(int)lect_double();
            }   
         catch (ErrSortieFinale)
              // cas d'une direction voulue vers la sortie
              // on relance l'interuption pour le niveau supérieur
            { ErrSortieFinale toto;
              throw (toto);
            }
         catch (...)
           { cout << "\n Erreur sur l'entree des donnee !!, on prend les valeurs par defaut ";
             min_i=1; max_i=taille; pas_i=1; nd=14;
            }
         }
     this->Affiche(min_i,max_i,pas_i,nd);
     cout << "\n entrez une lettre pour continuer ? "; 
     rep = lect_chaine();
  }   
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Permet de modifier la taille du vecteur 
// N.B. : Si la nouvelle taille est superieure a l'ancienne alors le vecteur
// est complete par des 0
void Vecteur::Change_taille (int n)
{ // si la taille est identique, on ne fait rien
  if (n == taille)
    return;
  // sinon, s'il s'agit d'un vecteur lié -> pas possible
  if (!memoire)
    { cout << "\n*** Erreur de changement de taille \n"
           << " il s'agit d'un vecteur particulier qui ne gere pas sa propre memoire "
           << " on ne peut pas modifier la place memoire !! ";
      cout << "Vecteur::Change_taille (... \n";
      Sortie(1);
    };
  // la suite concerne le cas où il faut vraiment faire quelque chose
  if ( n<0 )
   	// cas ou la taille selectionnee est negative
   	{	cout << "\nErreur : taille invalide !\n";
   	 	cout << "VECTEUR::CHANGE_TAILLE (int ) \n";
   			Sortie(1);
    };
	 if ( n==0 )
   	// cas ou la taille selectionnee est nulle : initialisation identique a
   	// l'appel du constructeur par defaut
   	{	taille=0;
   		 v=NULL;
   		 return ;
   	};
	 double* tempo;
	 tempo=new double [n];
	 if ( n<=taille )
	   // cas ou la taille selectionnee est inferieure a la taille d'origine
	   {	for (int i=0;i<n;i++)
		      // copie des composantes du vecteur d'origine dans le vecteur pointe par tempo
		      tempo[i] = v[i];
	   }
	 else if ( n>taille )
   	// cas ou la taille selectionnee est superieure a la taille d'origine
   	{	for (int i=0;i<taille;i++)
   		   // copie des composantes du vecteur d'origine dans le vecteur pointe par tempo
   		   tempo[i] = v[i];
   		 for (int i=taille;i<n;i++)
   		   // initialisation des composantes supplementaires a 0
   		   tempo[i] = 0.0;
   	};
	 delete [] v; // desallocation du vecteur pointe par v
	 v=tempo; // affectation du pointeur v au pointeur tempo
	 taille=n;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Change la taille du vecteur avec initialisation de tous le nouveau vecteur
void Vecteur::Change_taille (int n,const double& val_init)		
{ // si la taille est identique, on ne fait que l'initialisation
  if (n == taille)
    {	for (int i=0;i<taille;i++)
			       v[i] = val_init; // affectation des composantes du vecteur
      return;
    };
  // sinon, s'il s'agit d'un vecteur lié -> pas possible
  if (!memoire)
    { cout << "\n*** Erreur de changement de taille \n"
           << " il s'agit d'un vecteur particulier qui ne gere pas sa propre memoire "
           << " on ne peut pas modifier la place memoire !! ";
      cout << "Vecteur::Change_taille (... \n";
      Sortie(1);
    };
  // la suite concerne le cas où il faut vraiment faire quelque chose
 	if ( n<0 )
    // cas ou la taille selectionnee est negative
    {	cout << "\nErreur : taille demandee="<<n<<" invalide !\n";
    	 cout << "VECTEUR::CHANGE_TAILLE (int,const double& val_init ) \n";
    	 Sortie(1);
    };
	 if ( n==0 )
    // cas ou la taille selectionnee est nulle : initialisation identique a
    // l'appel du constructeur par defaut
    {	taille=0;
    	 v=NULL;
    	 return ;
    };
  double* tempo;
	 tempo=new double [n];
	 double * pt=tempo;
	 for (int i=0; i< n; i++)
	   (*pt++) = val_init;
	 delete [] v; // desallocation du vecteur pointe par v
	 v=tempo; // affectation du pointeur v au pointeur tempo pointant au début !!
	 taille=n;
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Apres l'appel de cette methode, le vecteur est identique a ce qu'il aurait
// ete a la suite de l'appel du contructeur par defaut
// Dans le cas très particulier où le vecteur ne gère pas sa propre mémoire
// l'opération n'est pas possible -> message d'erreur et arrêt
void Vecteur::Libere ()
{if (!memoire)
   { cout << "\n*** Erreur de liberation de la place memoire\n"
          << " il s'agit d'un vecteur particulier qui ne gere pas sa propre memoire "
          << " on ne peut pas modifier la place memoire !! ";
     cout << "VECTEUR::LIBERE () \n";
     Sortie(1);
   };
 // sinon c'est ok
 if ( taille>0 )
		{delete [] v;} // desallocation du vecteur pointe par v
	else
  {	if ( v!=NULL )
     {	cout << "\nErreur de liberation de la place memoire\n";
       cout << "VECTEUR::LIBERE () \n";
       Sortie(1);
     };
  };
	v=NULL;
	taille=0; 	
};

#ifndef MISE_AU_POINT 
  inline 
#endif
// Retourne le maximum en valeur absolue des composantes du vecteur
double Vecteur::Max_val_abs () const 
{	double max;
	 max=fabs(v[0]); // affectation de max a la premiere composante du vecteur
	 for (int i=1;i<taille;i++)
	  {	if ( max<fabs(v[i]) ) 
		    // cas ou la composante pointee excede max
			   max=fabs(v[i]);
   };
	 return max;
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Retourne le maximum en valeur absolue des composantes du vecteur
double Vecteur::Max_val_abs (int& in) const 
{double max;
	in = 1;
	max=fabs(v[0]); // affectation de max a la premiere composante du vecteur
	for (int i=1;i<taille;i++)
	 {	if ( max<fabs(v[i]) ) 
		   // cas ou la composante pointee excede max
      { max=fabs(v[i]);
        in = i+1;
      };
	  };
	return max;	
};
#ifndef MISE_AU_POINT
  inline 
#endif
// Retourne le maximum en valeur absolue des composantes du vecteur
// mais ramène la grandeur signée (avec son signe)
double Vecteur::Max_val_abs_signe () const 
{double max;
	int in = 1;
	max=fabs(v[0]); // affectation de max a la premiere composante du vecteur
	for (int i=1;i<taille;i++)
	 {	if ( max<fabs(v[i]) ) 
		   // cas ou la composante pointee excede max
     { max=fabs(v[i]);
       in = i+1;
     };
	  };
	// affectation à la grandeur signée
	max = v[in-1];  
	return max;	
};


#ifndef MISE_AU_POINT
  inline 
#endif
// Retourne le maximum en valeur absolue des composantes du vecteur
// mais ramène la grandeur signée (avec son signe)
double Vecteur::Max_val_abs_signe (int& in) const 
{double max;
	in = 1;
	max=fabs(v[0]); // affectation de max a la premiere composante du vecteur
	for (int i=1;i<taille;i++)
	 {	if ( max<fabs(v[i]) ) 
		   // cas ou la composante pointee excede max
		   { max=fabs(v[i]);
		     in = i+1;
		   };
  };
	// affectation à la grandeur signée
	max = v[in-1];  
	return max;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Retourne la norme euclidienne du vecteur
double Vecteur::Norme ()  const 
{double norme=0.0;
	for (int i=0;i<taille;i++)
	// somme du carre des composantes du vecteur
		norme += v[i] * v[i];
	// calcul de la norme et retour
	return sqrt(norme);	
};

// norme le vecteur
#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur& Vecteur::Normer () 
  { *this /=  this->Norme();
    return *this;};

#ifndef MISE_AU_POINT
  inline 
#endif
// Realise le produit scalaire entre le vecteur courant et le vecteur
// vec et retourne le resultat obtenu
// N.B.: Les vecteurs doivent etre de meme taille
double Vecteur::Prod_scal (const Vecteur& vec) const 
{
 #ifdef MISE_AU_POINT
  if ( taille!=vec.taille )
   {	cout << "\nErreur : tailles non egales !\n";
    cout << "VECTEUR::PROD_SCAL (Vecteur ) \n";
    Sortie(1);
   };
 #endif
	double prod_scal=0.0;
	for (int i=0;i<taille;i++)
	  // somme du produit des composantes des deux vecteurs
		 prod_scal+=(v[i] * vec.v[i]);
	return prod_scal;	
};

// somme de tous les composantes du vecteur
#ifndef MISE_AU_POINT
  inline 
#endif
double Vecteur::Somme() const 
  { double somme=0;
	   for (int i=0;i<taille;i++)
      somme += v[i];	 
    return somme;
  };          

// somme de tous les valeurs absolues des composantes du vecteur
#ifndef MISE_AU_POINT
  inline
#endif
double Vecteur::SommeAbs() const
  { double somme=0;
    for (int i=0;i<taille;i++)
      somme += fabs(v[i]);
    return somme;
  };


// Moyenne de tous les composantes du vecteur
#ifndef MISE_AU_POINT
  inline 
#endif
double Vecteur::Moyenne() const 
  { double moyenne=0;
    if (taille != 0)
	    { for (int i=0;i<taille;i++)
         moyenne += v[i];
		     moyenne /= taille;
		   };
    return moyenne;
  };          

#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur Vecteur::operator+ (const Vecteur& vec) const 
// Surcharge de l'operateur + : addition entre deux vecteurs
// N.B.: Les vecteurs doivent etre de meme taille
{	
 #ifdef MISE_AU_POINT
  if ( taille!=vec.taille )
   {	cout << "\nErreur : tailles non egales !\n";
    cout << "VECTEUR::OPERATOR+ (Vecteur ) \n";
    Sortie(1);
   };
 #endif
	Vecteur result(taille);
	for (int i=0;i<taille;i++)
  // somme des composantes des deux vecteurs vec et v, puis stockage
  // dans le vecteur result
		result.v[i]=v[i]+vec.v[i];		
	return result;	
};

// Surcharge de l'operateur - : oppose d'un vecteur 
#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur Vecteur::operator- () const 
{Vecteur result(taille);
	for (int i=0;i<taille;i++)
	    result.v[i]=-v[i];
	return result;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur - : soustraction entre deux vecteurs
// N.B.: Les vecteurs doivent etre de meme taille
Vecteur Vecteur::operator- (const Vecteur& vec) const 
{	
 #ifdef MISE_AU_POINT
  if ( taille!=vec.taille )
   {	cout << "\nErreur : tailles non egales !\n";
    cout << "VECTEUR::OPERATOR- (Vecteur ) \n";
    Sortie(1);
   };
 #endif
	Vecteur result(taille);
	for (int i=0;i<taille;i++)
   // soustraction des composantes des vecteurs vec et v, puis stockage
   // dans le vecteur result
		 result.v[i]=v[i]-vec.v[i];
	return result;
};


#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur += : additionne au vecteur courant le vecteur vec
// N.B.: Les vecteurs doivent etre de meme taille
void Vecteur::operator+= (const Vecteur& vec)
{
 #ifdef MISE_AU_POINT
  if ( taille!=vec.taille )
   {	cout << "\nErreur : tailles non egales !\n";
    cout << "VECTEUR::OPERATOR+= (Vecteur ) \n";
    Sortie(1);
   };
 #endif
	for (int i=0;i<taille;i++)
		 v[i]+=vec.v[i];
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur -= : soustrait au vecteur courant le vecteur vec
// N.B.: Les vecteurs doivent etre de meme taille
void Vecteur::operator-= (const Vecteur& vec)
{
 #ifdef MISE_AU_POINT
  if ( taille!=vec.taille )
  {	cout << "\nErreur : tailles non egales !\n";
   cout << "VECTEUR::OPERATOR-= (Vecteur ) \n";
   Sortie(1);
  };
 #endif
	for (int i=0;i<taille;i++)
		 v[i]-=vec.v[i];
};		

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur *= : multiplie les composantes du vecteur courant par
// le scalaire val
// N.B.: Les vecteurs doivent etre de meme taille
void Vecteur::operator*= (double val)
{	for (int i=0;i<taille;i++)
		  v[i]*=val;
};	

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur == : test d'egalite entre deux vecteurs
// Renvoie 1 si les deux vecteurs sont egaux
// Renvoie 0 sinon
int Vecteur::operator== (const Vecteur& vec) const 
{if ( vec.taille!=taille )
		{return 0;}
	else
	 {for (int i=0;i<taille;i++)
		  {	if ( v[i] !=vec.v[i] )
				   return 0;
    };
		 return 1;
	 };
};	

// Surcharge de l'operateur !=
// Renvoie 1 si les deux vecteurs ne sont pas egaux
// Renvoie 0 sinon
#ifndef MISE_AU_POINT
  inline 
#endif
int Vecteur::operator!= (const Vecteur& vec) const 
		{	if ( (*this)==vec )
				  return 0;
			  else
				  return 1;
		};
	
#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur = : realise l'egalite de deux vecteurs
// (Affecte le vecteur courant au vecteur vec)
Vecteur& Vecteur::operator= (const Vecteur& vec)
{	// cas ou l'adresse des vecteurs a gauche et a droite sont identiques
  if (&vec == this) return (*this);
  // cas où les deux tailles sont égales 
  if ( vec.taille==taille )
     {  for (int i=0;i<taille;i++)
         // copie des elements du vecteur se trouvant a droite dans le vecteur se trouvant
         // a gauche du signe d'affectation
         v[i] = vec.v[i];
      }
  else
     { if (v!=NULL)
		       Libere();	// cas ou le vecteur se trouvant a gauche du signe =
       // n'est pas vide mais est different en taille
       // de celui de droite : desallocation de ce vecteur
	      if ( vec.taille==0 )
        // cas ou le vecteur se trouvant a droite du signe = est vide : initialisation
        // identique a l'appel du constructeur par defaut
        {	taille=0;
          v=NULL;
        }
       else
         // autres cas
        {	taille=vec.taille;
          v=new double [taille];
          for (int i=0;i<taille;i++)
          // copie des elements du vecteur se trouvant a droite dans le vecteur se trouvant
          // a gauche du signe d'affectation
          v[i] = vec.v[i];
        };
     };
	 return (*this);
};
		

// définition d'une surcharge basique d'affectation avec un MV_Vector
#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur& Vecteur::operator= (const MV_Vector<double> & A)
{	// cas où les deux tailles sont égales
  if ( taille==A.size() )
     {  for (int i=0;i<taille;i++)
          // copie des elements du vecteur se trouvant a droite dans le vecteur se trouvant
          // a gauche du signe d'affectation
		        v[i] = A[i];
     }
  else
     { if (v!=NULL)
		       Libere();	// cas ou le vecteur se trouvant a gauche du signe =
       // n'est pas vide mais est different en taille
       // de celui de droite : desallocation de ce vecteur
	      if ( A.size()==0 )
        // cas ou le vecteur se trouvant a droite du signe = est vide : initialisation
        // identique a l'appel du constructeur par defaut
        {	taille=0;
          v=NULL;
         }
       else
         // autres cas
        {	taille=A.size();
          v=new double [taille];
          for (int i=0;i<taille;i++)
            // copie des elements du vecteur se trouvant a droite dans le vecteur se trouvant
            // a gauche du signe d'affectation
            v[i] = A[i];
        };
	    };
	 return (*this);
};

// Surcharge de l'operateur * : multiplication d'un vecteur par un scalaire
#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur Vecteur::operator* (double val)  const 
{	
 #ifdef MISE_AU_POINT
 if ( taille==0 )
    {	cout << "\nErreur : taille nulle !\n";
     cout << "VECTEUR::OPERATOR* (double ) \n";
     Sortie(1);
    };
 #endif
	Vecteur result(taille);
	for (int i=0;i<taille;i++)
  // stockage dans le vecteur result du produit des composantes du vecteur courant
  // avec val
		result.v[i]=val*v[i];
	return result;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur / : division des composantes d'un vecteur par un scalaire
Vecteur  Vecteur::operator/ (double val) const 
{
 #ifdef MISE_AU_POINT
	if ( (taille==0) || (val==0) )
   {	cout << "\nErreur : taille nulle ou division par zero !\n";
    cout << "VECTEUR::OPERATOR/ (double ) \n";
    Sortie(1);
   };
 #endif
	Vecteur result(taille);
	for (int i=0;i<taille;i++)
  // stockage dans le vecteur result de la division des composantes du vecteur courant
  // avec val
		result.v[i] = v[i]/val;
	return result;	
};

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur / : division des composantes d'un vecteur par un scalaire
void Vecteur::operator/= (double val)
{
 #ifdef MISE_AU_POINT
	if ( (taille==0) || (val==0) )
   {	cout << "\nErreur : taille nulle ou division par zero !\n";
    cout << "VECTEUR::OPERATOR/ (double ) \n";
    Sortie(1);
   };
 #endif
 //	double* ptr=v;
	for (int i=0;i<taille;i++)
		 v[i] /= val;
};	

// Surcharge de l'operateur * : multiplication entre deux vecteurs
// Permet de realiser le produit scalaire entre deux vecteurs
#ifndef MISE_AU_POINT
  inline 
#endif
double Vecteur::operator* (const Vecteur& vec) const 
		{	return Prod_scal(vec);	};
		
#ifndef MISE_AU_POINT
  inline 
#endif
// Retourne la ieme composante du vecteur : acces en lecture uniquement
double Vecteur::operator() (int i) const 
		{
   #ifdef MISE_AU_POINT
    if ( (i<1) || (i>taille) )
      {	cout << "\nErreur : composante inexistante !\n";
       cout << "VECTEUR::OPERATOR() (int ) \n";
       Sortie(1);
      };
   #endif
			return v[i-1];	
		};

#ifndef MISE_AU_POINT
  inline 
#endif
// Retourne la ieme composante du vecteur : acces en lecture et en ecriture
double& Vecteur::operator() (int i)
		{
   #ifdef MISE_AU_POINT
    if ( (i<1) || (i>taille) )
      {	cout << "\nErreur : composante inexistante !\n";
       cout << "VECTEUR::OPERATOR() (int ) \n";
       Sortie(1);
      };
   #endif
			return v[i-1];	
		};

#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur ! : renvoie la norme d'un vecteur
double Vecteur::operator! () const 
		{	return Norme();	};

// mise a zero d'un vecteur
#ifndef MISE_AU_POINT
  inline 
#endif
void Vecteur::Zero()
 {for (int i=0;i<taille;i++)
		 // affectation des composantes du vecteur a 0
			v[i] = 0.0;
 };  
  
// méthode explicite d'écriture dans un flux: identique à la surcharge de <<
#ifndef MISE_AU_POINT
  inline
#endif
void Vecteur::Ecrit(ostream & ostr) const
  {ostr << *this; };
// méthode explicite de lecture  dans un flux: identique à la surcharge de >>
#ifndef MISE_AU_POINT
  inline
#endif
void Vecteur::Lecture(istream & istr)
 {istr >> *this; };


#ifndef MISE_AU_POINT
  inline 
#endif
// calcul le produit P(i) = (*this)(i) * A(i); ramène P qui est passé en paramètre
Vecteur& Vecteur::Prod_ii(const Vecteur& A, Vecteur& P) const
 {	
  #ifdef MISE_AU_POINT
   if ( taille != A.Taille() )
     {cout << "\nErreur : la taille de this ("<<taille<<") est differente"
           << " de celle de A ("<<A.Taille()<<" la methode Prod_ii ne peut s'effectuer !\n";
      cout << "Vecteur::Prod_ii(const Vecteur& A, Vecteur& P) \n";
      Sortie(1);
     };
  #endif
	 if (P.Taille() != taille )
	  P.Change_taille(taille); 
  for (int i=0;i<taille;i++)
    // affectation des composantes du vecteur de retour
    P.v[i] = v[i] * A.v[i];
	 return P;
 };  

#ifndef MISE_AU_POINT
  inline 
#endif
// initialise toutes les composantes à val
void Vecteur::Inita(double val)   
 {	for (int i=0;i<taille;i++)
		   // affectation des composantes du vecteur a 0
     v[i] = val;
 };  

// affectation à une partie d'un vecteur qui doit avoir une taille donc plus grande
// (*this)(i) = vec(i+indice-1); i= 1 à la taille de (*this)
// ramène *this
#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur& Vecteur::Egale_une_partie_de(const Vecteur& vec,int indice) 
 { 
   #ifdef MISE_AU_POINT
    if ( (indice<1) || (indice-1+taille > vec.taille) )
      {	cout << "\nErreur, affectation impossible: indice= " << indice << " vec.Taille()= " << vec.taille
               << " (*this).Taille()= " << taille << " !\n";
       cout << "Vecteur::Egale_une_partie_de(const Vecteur& vec,int indice)\n";
       Sortie(1);
      };
   #endif
   int j=indice-1;
   for (int i=0;i<taille;i++,j++)
		    v[i] = vec.v[j];
	  return *this;
 }; 
  
// affectation d'une partie de (*this) au vecteur passé en paramètre
// (*this)(i+indice-1) = vec(i); i= 1 à la taille de vec
// ramène *this
#ifndef MISE_AU_POINT
  inline 
#endif
Vecteur& Vecteur::Une_partie_egale(int indice, const Vecteur& vec) 
 { 
   #ifdef MISE_AU_POINT
    if ( (indice<1) || (indice-1+vec.taille > taille) )
      {cout << "\nErreur, affectation impossible: indice= " << indice << " vec.Taille()= " << vec.taille
               << " (*this).Taille()= " << taille << " !\n";
       cout << "Vecteur::Une_partie_egale(int indice, const Vecteur& vec)\n";
       Sortie(1);
      };
   #endif
   int j=indice-1;
   for (int i=0;i<vec.taille;i++,j++)
		    v[j] = vec.v[i];
	  return *this;
 }; 

#ifndef MISE_AU_POINT
  inline 
#endif
// methode pour la compatibilite avec des classes derivees
Vecteur & Vecteur::Vect() 
  { return *this;};
  
#ifndef MISE_AU_POINT
  inline 
#endif
// Surcharge de l'operateur * : multiplication entre un scalaire et un vecteur
Vecteur operator* (double val,const Vecteur& vec)
{	return (vec*val);   };

// surcharge de l'operateur de lecture
// les informations sont le type puis la taille puis les datas 
#ifndef MISE_AU_POINT
  inline 
#endif
istream & operator >> (istream & entree, Vecteur & vec)
  { // vérification du type
    string type;
    entree >> type;
    if (type != "Vecteur")
      {Sortie (1);
       return entree;
      };
    // passage de la chaine donnant la taille puis lecture de la taille
    int taille;
    entree >> type >> taille; 
    // vérification de la taille sinon changement
    if (vec.Taille() != taille) vec.Change_taille(taille);  
    // lecture des données
    for (int i = 0; i< vec.taille; i++)
        entree >> vec.v[i];
    return entree;      
  };

// surcharge de l'operateur d'ecriture non formatée
// les informations sont le type puis la taille puis les datas séparées par
// un espace
#ifndef MISE_AU_POINT
  inline 
#endif
ostream & operator << ( ostream & sort,const  Vecteur & vec)
  { // tout d'abord un indicateur donnant le type
    sort << "Vecteur  taille= "  << vec.taille << " "; 
    for (int i = 0; i< vec.taille; i++)
        sort  << setprecision(ParaGlob::NbdigdoCA()) <<  vec.v[i] << " ";
//    sort << "\n";
    return sort;      
  };


       // spécifiquement à la classe MV_Vector<double>
#ifndef MISE_AU_POINT
  inline 
#endif
MV_Vector<double> * Vecteur::Nouveau_MV_Vector_double()
 { MV_Vector <double>* pt = 
            new MV_Vector <double> (v,taille,MV_Vector_::ref_type(1));
   return pt;
  };
#ifndef MISE_AU_POINT
  inline 
#endif
const MV_Vector<double> * Vecteur::Nouveau_MV_Vector_double_const() const 
 { const MV_Vector <double>* pt = 
            new const MV_Vector <double> (v,taille,MV_Vector_::ref_type(1));
   return pt;
  };



// ramène un vecteur MV_Vector <double> qui utilise la même place
// mémoire que this ce qui pemet d'utiliser le type MV_Vector
#ifndef MISE_AU_POINT
  inline 
#endif
MV_Vector <double> Vecteur::MV_vecteur_double()
 { return (MV_Vector <double> (v,taille,MV_Vector_::ref_type(1)));
  };
// ramène un vecteur constant MV_Vector <double> qui utilise la même place
// mémoire que this ce qui pemet d'utiliser le type MV_Vector
#ifndef MISE_AU_POINT
  inline 
#endif
const MV_Vector <double> Vecteur::MV_vecteur_double() const 
 { return (MV_Vector <double> (v,taille,MV_Vector_::ref_type(1)));
  };

#endif