version hervé, la version gilles est dans /trunk/old

#include "vecteur.h"

////////////////////////////// CONSTRUCTEURS ///////////////////////////////////////////////////////

//Par defaut

Vecteur::Vecteur()

{

    composantes[0]= 0;

    composantes[1]= 0;

    composantes[2]= 0;

    norme = 0;

}

//Par copie ////////////////////////////////////////////////////////////////////////////////////////

Vecteur::Vecteur(const Vecteur & source)

{

    composantes[0]= source.getCompo(0);

    composantes[1]= source.getCompo(1);

    composantes[2]= source.getCompo(2);

    norme =source.getNorme();

}

//Personel ////////////////////////////////////////////////////////////////////////////////////////

Vecteur::Vecteur (float x, float y, float z)

{

    composantes[0]= x;

    composantes[1]= y;

    composantes[2]= z;

    calculNorme();

}

///////////////////////////////////////////////////////////////////////////////////////////////////

Vecteur::~Vecteur()

{

}

////////////////////////////////////////////////////////////////////////////////////////////////////

float Vecteur::getCompo(int compo) const

{

    return composantes[compo];

}

////////////////////////////////////////////////////////////////////////////////////////

float Vecteur::getNorme() const

{

    return norme;

}

////////////////////////////////////////////////////////////////////////////////////////

void Vecteur::calculNorme()

{

    norme = sqrt(pow(composantes[0],2)+ pow(composantes[1],2)+ pow(composantes[2],2));

}

////////////////////////////////////////////////////////////////////////////////////////

void Vecteur::setComposante(int compo, float valeur)

{

    composantes[compo] = valeur;

    calculNorme();

}

////////////////////////////////////////////////////////////////////////////////////////

void Vecteur::addXfois(const Vecteur & vs, float nbFois)

{

  for(int i=0;i<nbFois;i++)

  {

    (*this)+= vs;

  }

}

////////////////////////////////////////////////////////////////////////////////////////

Vecteur & Vecteur::operator = (const Vecteur & source)

{

    if(this == &source) return (*this);

    composantes[0]= source.getCompo(0);

    composantes[1]= source.getCompo(1);

    composantes[2]= source.getCompo(2);

    norme =source.getNorme();

    return (*this);

}

////////////////////////////////////////////////////////////////////////////////////////

Vecteur & Vecteur::operator += (const Vecteur & source)

{

    composantes[0] += source.getCompo(0);

    composantes[1] += source.getCompo(1);

    composantes[2] += source.getCompo(2);

    norme =source.getNorme();

    return (*this);

}

////////////////////////////////////////////////////////////////////////////////////////

Vecteur & Vecteur::operator -= (const Vecteur & source)

{

    composantes[0] -= source.getCompo(0);

    composantes[1] -= source.getCompo(1);

    composantes[2] -= source.getCompo(2);

    norme =source.getNorme();

    return (*this);

}

////////////////////////////////////////////////////////////////////////////////////////

Vecteur operator + (const Vecteur & v_1, const Vecteur & v_2)

{

    Vecteur tmp(v_1);

    tmp += v_2;

    return tmp;

}

Vecteur operator - (const Vecteur & v_1, const Vecteur & v_2)

{

    Vecteur tmp(v_1);

    tmp -= v_2;

    return tmp;

}

//produit scalaire ////////////////////////////////////////////////////////////////////////////////////////

float operator * (const Vecteur & v_1, const Vecteur & v_2)

{

    return ((v_1.composantes[0] * v_2.composantes[0]) +

            (v_1.composantes[1] * v_2.composantes[1]) +

            (v_1.composantes[2] * v_2.composantes[2]));

}

//multiplication par un scalaire ////////////////////////////////////////////////////////////////////////////////////////

Vecteur operator * (const Vecteur & v_1, float scalaire)

{

    Vecteur tmp(v_1);

    tmp.composantes[0] = tmp.composantes[0]*scalaire;

    tmp.composantes[1] = tmp.composantes[1]*scalaire;

    tmp.composantes[2] = tmp.composantes[2]*scalaire;

    return tmp;

}

////////////////////////////////////////////////////////////////////////////////////////

Vecteur operator * (float scalaire, const Vecteur & v)

{

    return v*scalaire;

}

//produit vectoriel ////////////////////////////////////////////////////////////////////////////////////////

Vecteur operator ^ (const Vecteur & v_1, const Vecteur & v_2)

{

    Vecteur tmp;

    tmp.composantes[0] = (v_1.composantes[1]*v_2.composantes[2]) - (v_1.composantes[2]*v_2.composantes[1]);

    tmp.composantes[1] = (v_1.composantes[2]*v_2.composantes[0]) - (v_1.composantes[0]*v_2.composantes[2]);

    tmp.composantes[2] = (v_1.composantes[0]*v_2.composantes[1]) - (v_1.composantes[1]*v_2.composantes[0]);

    return tmp;

}

////////////////////////////////////////////////////////////////////////////////////////

float calculAngle(const Vecteur & v_1, const Vecteur & v_2)

{

    float scalaire = v_1*v_2;

    return acos(scalaire/(v_1.getNorme()*v_2.getNorme()));

}

/*

//somme

Vecteur Vecteur::somm(const Vecteur &) const

{

}

//soustraction

Vecteur Vecteur::sous(const Vecteur &) const

{

}

//produit vectoriel

Vecteur Vecteur::prodVectoriel(const Vecteur &) const

{

}

//produit scalaire

Vecteur Vecteur::prodScalaire(const Vecteur &) const

{

}

//multiplication par un scalaire

Vecteur Vecteur::multScalaire(float scalaire)

{

}

*/

//normaliser le vecteur ////////////////////////////////////////////////////////////////////////////////////////

void Vecteur::normaliser()

{

    composantes[0] /= norme;

    composantes[1] /= norme;

    composantes[2] /= norme;

    norme=1;

}