de même que pour vector3d.cpp

/*****************************************************************************

 * class LrVector3d (specification)                                          *

 *                                                                           *

 * author : Gilles Subrenat                                                  *

 * creation : Sunday, March 2 2008 (3/2/2008)                                *

 * note :                                                                    *

 *****************************************************************************/

#ifndef VECTEURS_H

#define VECTEURS_H

#ifndef LRVECTOR3D_H

#define LRVECTOR3D_H

#include <math.h>

class LrPoint3d;

#define X 0;

#define Y 1;

#define Z 2;

class LrVector3d

class Vecteur

{

public:

    // constants

    // *********

    static const LrVector3d ZERO;

    static const LrVector3d I;

    static const LrVector3d J;

    static const LrVector3d K;

    // constructors and destructor

    // ***************************

    LrVector3d();

    LrVector3d(const LrVector3d &source);

    LrVector3d(Real x, Real y, Real z);

    LrVector3d(const LrPoint3d &p1, const LrPoint3d &p2);

    explicit LrVector3d(const LrPoint3d &p);

    virtual ~LrVector3d();

    // assignement operator(s)

    // ***********************

    LrVector3d & operator = (const LrVector3d &source);

    LrVector3d & operator += (const LrVector3d &source);

    LrVector3d & operator -= (const LrVector3d &source);

    LrVector3d & operator *= (Real source);

    LrVector3d & operator /= (Real source);

    private :

    // comparison operator(s)

    // **********************

        float composantes[3];

        float norme;

    friend bool operator == (const LrVector3d &lhs, const LrVector3d &rhs);

    friend bool operator != (const LrVector3d &lhs, const LrVector3d &rhs);

        //calculer la norme

        void calculNorme();

    // unary and binary operator(s)

    // ****************************

    public :

    friend LrVector3d operator + (const LrVector3d &rhs);

    friend LrVector3d operator - (const LrVector3d &rhs);

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

    friend LrVector3d operator + (const LrVector3d &lhs,

                                  const LrVector3d &rhs);

    friend LrVector3d operator - (const LrVector3d &lhs,

                                  const LrVector3d &rhs);

    friend Real operator * (const LrVector3d &lhs, const LrVector3d &rhs);

    friend LrVector3d operator * (Real lhs, const LrVector3d &rhs);

    friend LrVector3d operator * (const LrVector3d &lhs, Real rhs);

    friend LrVector3d operator / (const LrVector3d &lhs, Real rhs);

    friend LrVector3d operator ^ (const LrVector3d &lhs,

                                  const LrVector3d &rhs);

        //Constructeur par defaut

        Vecteur ();

    // accessors

    // *********

        //constructeur par copie

        Vecteur (const Vecteur &);

        //Constructeur personnel

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

	virtual ~Vecteur();

    Real getX() const;

    void setX(Real x);

        // calcul de l'angle form� par 2 vecteurs

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

        // ACCESSEURS //////////////////////////////////////////////////////////////////////////////

    Real getY() const;

    void setY(Real y);

        //renvoie la norme du vecteur

        float getNorme() const;

        //renvoie la valeur d'une composante du vecteur suivant le param int compo qui peut valoir X, Y ou Z

        float getCompo(int compo) const;

        //renvoie une copie de l'ensemble des composantes

        float* getComposantes() const;

    Real getZ() const;

    void setZ(Real z);

    void setXYZ(Real x, Real y, Real z);

        //modifier une composante du vecteur

        void setComposante(int compo, float valeur);

        //appliquer plusieur fois un vecteur au vecteur courant

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

    // miscellaneous functions

    // ***********************

        // CALCUL SUR LES VECTEURS /////////////////////////////////////////////////////////////////

    Real length() const;

    Real lengthSquare() const;

    void normalize();

        //somme

        Vecteur somm(const Vecteur &) const;

        //soustraction

        Vecteur sous(const Vecteur &) const;

        //produit vectoriel

        Vecteur prodVectoriel(const Vecteur &) const;

        //produit scalaire

        Vecteur prodScalaire(const Vecteur &) const;

        //multiplication par un scalaire

        Vecteur multScalaire(float scalaire);

    // data

    // ****

    // public members EXCEPTIONNALY : to simplify use of this class

    Real x, y, z;

        //normaliser le vecteur

        void normaliser();

        Vecteur & operator = (const Vecteur &);

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

        Vecteur & operator -= (const Vecteur &);

private:

    // data

    // ****

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

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

        //produit scalaire

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

        //multiplication par un scalaire

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

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

         //produit vectoriel

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

    // see public part

};

#endif