Commit 8d4e821b authored by paps's avatar paps

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

parent 23cfa30d
#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;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment