#ifndef MATR9D_H
#define MATR9D_H

#include "patrons.h"

class Matr9d;

#define float_to_Vect3d(x)  (*(Vect3d*)&(x))
#define QUAT    ((double*)this)
#define PTR_MATR    ((double*)this)

class Vect3d{
    public:

    inline Vect3d(){x=y=z=0;}
    inline Vect3d(double a,double b, double c){x=a;y=b;z=c;}
    inline double operator[](int i)const{return ((double*)this)[i];}
    inline double& operator[](int i){return ((double*)this)[i];}


    Matr9d v() const;//renvoie la matrice du produit vectoriel correspondant
    void print (const char* nom) const;

    inline void operator+=(Vect3d const&a){x+=a.x;y+=a.y;z+=a.z;}
    inline void operator-=(Vect3d const&a){x-=a.x;y-=a.y;z-=a.z;}
    inline void operator*=(double a){x*=a;y*=a;z*=a;}

    double x;
    double y;
    double z;
};
inline Vect3d operator+( Vect3d const&a,Vect3d const&b){Vect3d c(a);c+=b;return c;}
inline Vect3d operator-( Vect3d const&a,Vect3d const&b){Vect3d c(a);c-=b;return c;}

inline Vect3d operator-(Vect3d const& a){return Vect3d(-a.x,-a.y,-a.z);}

inline Vect3d operator*(double a,Vect3d const& b){Vect3d v(b);v*=a;return v;}
inline double operator*(Vect3d const& a,Vect3d const& b){return a.x*b.x+a.y*b.y+a.z*b.z;}

Vect3d operator^(Vect3d const&a,Vect3d const&b);
Vect3d vectorielle(Vect3d const& a,Vect3d const& b);
Vect3d doubleproduit(Vect3d const& a,Vect3d const& b,Vect3d const& c);


class Matr9d{
    public:
    Matr9d();
    Matr9d(double d);
    Matr9d(Vect3d const& diagj);
    Matr9d(double a,double b, double c);
    inline Matr9d(Vect3d const&l1, Vect3d const&l2, Vect3d const&l3){Lx=l1;Ly=l2;Lz=l3;}
    inline double operator[](int i)const{return ((double*)this)[i];}
    inline double& operator[](int i){return ((double*)this)[i];}

    void print (const char* nom) const;

    void transpo();
    void operator+=(Matr9d const&a);
    void operator-=(Matr9d const&a);
    void operator*=(double a);

    Vect3d Lx;
    Vect3d Ly;
    Vect3d Lz;
};
inline Matr9d operator+( Matr9d const&a,Matr9d const&b){Matr9d c(a);c+=b;return c;}
inline Matr9d operator-( Matr9d const&a,Matr9d const&b){Matr9d c(a);c-=b;return c;}

Matr9d transpo(Matr9d const& m);
inline Matr9d operator-(Matr9d const& a){return Matr9d(-a.Lx,-a.Ly,-a.Lz);}

Vect3d operator*(Matr9d const& m, Vect3d const& a);
Matr9d operator*(Matr9d const& a, Matr9d const& b);
Matr9d operator*(double a, Matr9d const& b);
Matr9d operator!(Matr9d const& a);//fonction inverse
Matr9d pivotaxeangle(Vect3d const& axe, double angle);
Matr9d dpivotaxe(Vect3d const&);
Matr9d dpivotaxe2(Vect3d const&);
Matr9d getprojection(Matr9d const&base, const bool *tab3);

inline Matr9d operator^(Vect3d const&a,Matr9d const&b){return a.v()*b;}

//void multglmatrix(Matr9d const& m);
//void multgltmatrix(Matr9d const& m);

class Quaternion{
    public:

    inline Quaternion():v(){s=1;}//quaternion unitaire
    inline Quaternion(double a,Vect3d const&u){s=a;v=u;}
    Matr9d matr()const;//matrice de rotation correspondant au quaternion

    inline void operator+=(Quaternion const& b){s+=b.s;v+=b.v;}
    void renorme();
    void renorme2();

    double s;
    Vect3d v;
};
inline Quaternion renorme(Quaternion const& a){Quaternion b(a); b.renorme();return b;}
Quaternion dquat2(Vect3d const&a);
Quaternion operator*(Quaternion const& a, Quaternion const& b);//multiplication
Quaternion operator/(Quaternion const& a, Quaternion const& b);//division entre quaternions unitaires
Quaternion operator*(Vect3d const&a, Quaternion const&b);
inline Quaternion operator*(double a, Quaternion const& b){return Quaternion(a*b.s,a*b.v);}

/*
class TermeInconnu{
    public:
    inline TermeInconnu(Matr9d const&matr,const int *indice):m(matr){i=indice;}

    Matr9d m;
    const int* i;
};
inline TermeInconnu operator*(Matr9d const&m, TermeInconnu const&t){
    TermeInconnu t2(t);
    t2.m=m*t.m;
    return t2;
}
inline TermeInconnu operator*(Matr9d const&m,const int *indice){
    return TermeInconnu(m,indice);
}
//*/


#endif