outil/src/ot_mathematique.h

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       ot_mathematique.h
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H23
//------------------------------------------------------------
//------------------------------------------------------------
#ifndef _OTMATHEMATIQUE_
#define _OTMATHEMATIQUE_

#ifdef WINDOWS_VERSION
        #ifdef BUILT_DLL_OUTIL
        #define DLLPORTOUTIL __declspec(dllexport)
        #else
        #define DLLPORTOUTIL __declspec(dllimport)
        #endif
#else
        #define DLLPORTOUTIL
#endif

#include "ot_doubleprecision.h"
#include <iostream>
#include <vector>


class DLLPORTOUTIL OT_VECTEUR_3D
{
public :                     
    // construction
OT_VECTEUR_3D(double x,double y,double z);
OT_VECTEUR_3D(double *xyz);
OT_VECTEUR_3D(double *xyz1,double *xyz2);
OT_VECTEUR_3D(void);
OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd);
OT_VECTEUR_3D unite(int i);
        // stream string output
friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_3D& mdd) const;
    bool operator!= (const OT_VECTEUR_3D& mdd) const;
    bool operator<  (const OT_VECTEUR_3D& mdd) const;
    bool operator<= (const OT_VECTEUR_3D& mdd) const;
    bool operator>  (const OT_VECTEUR_3D& mdd) const;
    bool operator>= (const OT_VECTEUR_3D& mdd) const;
    int compare_valeur (const OT_VECTEUR_3D& mdd) const;

    // coordinate access
virtual double get_x(void) const ;
virtual double get_y(void) const ;
virtual double get_z(void) const ;
virtual void change_x(double x);
virtual void change_y(double y);
virtual void change_z(double z);    
virtual double* get_xyz(void);

    operator const double* () const;
    operator double* ();
    double operator[] (int i) const;
    double& operator[] (int i);     
    double operator() (int i) const;
    double & operator() (int i);

// arithmetic operations
    friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
    friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
friend OT_VECTEUR_3D operator*(const class OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
friend OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
friend OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);

    // arithmetic updates
    OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
    OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
    OT_VECTEUR_3D& operator*= (double fScalar);
    OT_VECTEUR_3D& operator/= (double fScalar);

    // vector operations
virtual double get_longueur(void) const ;
virtual double get_longueur2(void) const ;
virtual void norme(void);
OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
virtual double diff(void);


private:
double valeur[3];
};

class DLLPORTOUTIL OT_MATRICE_3D
{
public:
OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
OT_MATRICE_3D(void);
OT_MATRICE_3D(double* t);
OT_MATRICE_3D(const OT_MATRICE_3D& mdd);
                                        
        // stream string output
friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);

        // access to matrix elements 
    double operator() (int iLigne, int iCol) const;
    double & operator() (int iLigne, int iCol);
    double valeur(int iLigne, int iCol) const;
    double & valeur(int iLigne, int iCol);
OT_VECTEUR_3D& get_vecteur1(void);
OT_VECTEUR_3D& get_vecteur2(void);
OT_VECTEUR_3D& get_vecteur3(void);
void change_vecteur1(OT_VECTEUR_3D v);
void change_vecteur2(OT_VECTEUR_3D v);
void change_vecteur3(OT_VECTEUR_3D v);
OT_VECTEUR_3D & operator [](int i);
    // return inverse matrix
OT_MATRICE_3D inverse() const;
        // assignements methods
void identite(void);
double get_determinant();
void transpose(OT_MATRICE_3D& res) const;
OT_MATRICE_3D transpose() const;
friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);

private:
OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
};
                                                                  
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);


#define ot_vecteur_4d
#ifdef ot_vecteur_4d
class DLLPORTOUTIL OT_VECTEUR_4D
{
public :                     
    //construction
OT_VECTEUR_4D(double x,double y,double z,double w);
OT_VECTEUR_4D(double *xyzw);
OT_VECTEUR_4D(void){};
OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd); 
OT_VECTEUR_4D & operator= (double);

        // stream string output
friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_4D& mdd) const;
    bool operator!= (const OT_VECTEUR_4D& mdd) const;
    bool operator<  (const OT_VECTEUR_4D& mdd) const;
    bool operator<= (const OT_VECTEUR_4D& mdd) const;
    bool operator>  (const OT_VECTEUR_4D& mdd) const;
    bool operator>= (const OT_VECTEUR_4D& mdd) const;
    int compare_valeur (const OT_VECTEUR_4D& mdd) const;

    // coordinate access
virtual double get_x(void) const ;
virtual double get_y(void) const ;
virtual double get_z(void) const ;  
virtual double get_w(void) const ; 
virtual double & x(void);
virtual double & y(void);
virtual double & z(void);
virtual double & w(void);
virtual void change_x(double x);
virtual void change_y(double y);
virtual void change_z(double z);   
virtual void change_w(double w);
virtual double* get_xyzw(void);
    operator const double* () const;
    operator double* ();
    double operator[] (int i) const;
    double& operator[] (int i);     
    double operator() (int i) const;
    double & operator() (int i);

// arithmetic operations                   
    OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
    OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
    double operator* (const OT_VECTEUR_4D & a);

    // arithmetic updates
    OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
    OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
    OT_VECTEUR_4D& operator*= (double fScalar);
    OT_VECTEUR_4D& operator/= (double fScalar);

private:
double valeur[4];
};

DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
#endif // ot_vecteur_4d


class DLLPORTOUTIL OT_VECTEUR_4DD
{
public :
    //construction
OT_VECTEUR_4DD(double2 x,double2 y,double2 z,double2 w);
OT_VECTEUR_4DD(double2 *xyzw);
OT_VECTEUR_4DD(){};
OT_VECTEUR_4DD(const OT_VECTEUR_4DD& mdd);
//OT_VECTEUR_4DD & operator= (double2);
OT_VECTEUR_4DD & operator= (const OT_VECTEUR_4DD&);

        // stream string output
friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_4DD& mdd) const;
    bool operator!= (const OT_VECTEUR_4DD& mdd) const;
    bool operator<  (const OT_VECTEUR_4DD& mdd) const;
    bool operator<= (const OT_VECTEUR_4DD& mdd) const;
    bool operator>  (const OT_VECTEUR_4DD& mdd) const;
    bool operator>= (const OT_VECTEUR_4DD& mdd) const;
    int compare_valeur (const OT_VECTEUR_4DD& mdd) const;

    // coordinate access
virtual double2 get_x(void) const ;
virtual double2 get_y(void) const ;
virtual double2 get_z(void) const ;  
virtual double2 get_w(void) const ; 
virtual double2 & x(void);
virtual double2 & y(void);
virtual double2 & z(void);
virtual double2 & w(void);
virtual void change_x(double2 x);
virtual void change_y(double2 y);
virtual void change_z(double2 z);   
virtual void change_w(double2 w);
virtual double2* get_xyzw(void);
double2 norme();
OT_VECTEUR_4DD vecteur_norme() ;
    operator const double2* () const;
    operator double2* ();
    double2 operator[] (int i) const;
    double2& operator[] (int i);     
    double2 operator() (int i) const;
    double2 & operator() (int i);

// arithmetic operations                   
    OT_VECTEUR_4DD operator+ (const OT_VECTEUR_4DD& rkV);
    OT_VECTEUR_4DD operator- (const OT_VECTEUR_4DD& rkV);
    double2 operator* (const OT_VECTEUR_4DD & a);

    // arithmetic updates
    OT_VECTEUR_4DD& operator+= (const OT_VECTEUR_4DD& rkV);
    OT_VECTEUR_4DD& operator-= (const OT_VECTEUR_4DD& rkV);
    OT_VECTEUR_4DD& operator*= (double2 fScalar);
    OT_VECTEUR_4DD& operator/= (double2 fScalar);
    OT_VECTEUR_4DD  operator^(const OT_VECTEUR_4DD& v2);


private:
double2 valeur[4];
};


class DLLPORTOUTIL OT_VECTEUR_3DD
{
public :
    //construction
OT_VECTEUR_3DD(double2 x,double2 y,double2 z);
OT_VECTEUR_3DD(double2 *xyzw);
OT_VECTEUR_3DD(){};
OT_VECTEUR_3DD(const OT_VECTEUR_3DD& mdd);
OT_VECTEUR_3DD & operator= (const OT_VECTEUR_3DD&);

        // stream string output
friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_3DD& mdd) const;
    bool operator!= (const OT_VECTEUR_3DD& mdd) const;
    bool operator<  (const OT_VECTEUR_3DD& mdd) const;
    bool operator<= (const OT_VECTEUR_3DD& mdd) const;
    bool operator>  (const OT_VECTEUR_3DD& mdd) const;
    bool operator>= (const OT_VECTEUR_3DD& mdd) const;
    int compare_valeur (const OT_VECTEUR_3DD& mdd) const;

    // coordinate access
virtual double2 get_x(void) const ;
virtual double2 get_y(void) const ;
virtual double2 get_z(void) const ;  
virtual double2 & x(void);
virtual double2 & y(void);
virtual double2 & z(void);
virtual void change_x(double2 x);
virtual void change_y(double2 y);
virtual void change_z(double2 z);   
virtual double2* get_xyz(void);
double2 norme();
OT_VECTEUR_3DD vecteur_norme() ;
    operator const double2* () const;
    operator double2* ();
    double2 operator[] (int i) const;
    double2& operator[] (int i);     
    double2 operator() (int i) const;
    double2 & operator() (int i);

// arithmetic operations                   
    OT_VECTEUR_3DD operator+ (const OT_VECTEUR_3DD& rkV);
    OT_VECTEUR_3DD operator- (const OT_VECTEUR_3DD& rkV);
    double2 operator* (const OT_VECTEUR_3DD & a);

    // arithmetic updates
    OT_VECTEUR_3DD& operator+= (const OT_VECTEUR_3DD& rkV);
    OT_VECTEUR_3DD& operator-= (const OT_VECTEUR_3DD& rkV);
    OT_VECTEUR_3DD& operator*= (double2 fScalar);
    OT_VECTEUR_3DD& operator/= (double2 fScalar);
    OT_VECTEUR_3DD  operator&(const OT_VECTEUR_3DD& v2);


private:
double2 valeur[3];
};


DLLPORTOUTIL OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV);
DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
DLLPORTOUTIL OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV);
DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);


class DLLPORTOUTIL OPERATEUR
{
public:
static int egal(double a,double b,double eps);
static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
static double  qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
static void doubleto2int(double val,int& val1,int& val2);
};


template <int N=4>
class DLLPORTOUTIL DOUBLEN
{
public:
DOUBLEN();
DOUBLEN(double *v);
DOUBLEN(DOUBLEN& mdd);
DOUBLEN(const DOUBLEN& mdd);
~DOUBLEN();
double get_valeur(int num);
void change_valeur(int num,double val);
DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
private:
double tab[N];
};

struct lessOT_VECTEUR_4DD : binary_function<OT_VECTEUR_4DD, OT_VECTEUR_4DD, bool>
{
  bool operator() ( OT_VECTEUR_4DD v1, OT_VECTEUR_4DD v2)
  {
  if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
  if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
  if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
  if (v1[3]!=v2[3]) return v1[3]<v2[3] ;
  return 0;

  }
  ;
};

struct lessOT_VECTEUR_3DD : binary_function<OT_VECTEUR_3DD, OT_VECTEUR_3DD, bool>
{
  bool operator() ( OT_VECTEUR_3DD v1, OT_VECTEUR_3DD v2)
  {
  if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
  if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
  if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
  return 0;

  }
  ;
};


#endif
Revision:	258
Committed:	Thu Aug 12 19:10:34 2010 UTC (15 years ago) by francois
Content type:	text/plain
File size:	15284 byte(s)
Log Message:	Mise a jour toxfem + parametrisation compilation toxfem + bug comparaison
#	Content
1	//------------------------------------------------------------
2	//------------------------------------------------------------
3	// MAGiC
4	// Jean Christophe Cuilli�re et Vincent FRANCOIS
5	// D�partement de G�nie M�canique - UQTR
6	//------------------------------------------------------------
7	// Le projet MAGIC est un projet de recherche du d�partement
8	// de g�nie m�canique de l'Universit� du Qu�bec �
9	// Trois Rivi�res
10	// Les librairies ne peuvent �tre utilis�es sans l'accord
11	// des auteurs (contact : francois@uqtr.ca)
12	//------------------------------------------------------------
13	//------------------------------------------------------------
14	//
15	// ot_mathematique.h
16	//
17	//------------------------------------------------------------
18	//------------------------------------------------------------
19	// COPYRIGHT 2000
20	// Version du 02/03/2006 � 11H23
21	//------------------------------------------------------------
22	//------------------------------------------------------------
23	#ifndef _OTMATHEMATIQUE_
24	#define _OTMATHEMATIQUE_
25
26	#ifdef WINDOWS_VERSION
27	#ifdef BUILT_DLL_OUTIL
28	#define DLLPORTOUTIL __declspec(dllexport)
29	#else
30	#define DLLPORTOUTIL __declspec(dllimport)
31	#endif
32	#else
33	#define DLLPORTOUTIL
34	#endif
35
36	#include "ot_doubleprecision.h"
37	#include <iostream>
38	#include <vector>
39
40
41
42
43
44
45	class DLLPORTOUTIL OT_VECTEUR_3D
46	{
47	public :
48	// construction
49	OT_VECTEUR_3D(double x,double y,double z);
50	OT_VECTEUR_3D(double *xyz);
51	OT_VECTEUR_3D(double xyz1,double xyz2);
52	OT_VECTEUR_3D(void);
53	OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd);
54	OT_VECTEUR_3D unite(int i);
55	// stream string output
56	friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
57
58	// comparison
59	bool operator== (const OT_VECTEUR_3D& mdd) const;
60	bool operator!= (const OT_VECTEUR_3D& mdd) const;
61	bool operator< (const OT_VECTEUR_3D& mdd) const;
62	bool operator<= (const OT_VECTEUR_3D& mdd) const;
63	bool operator> (const OT_VECTEUR_3D& mdd) const;
64	bool operator>= (const OT_VECTEUR_3D& mdd) const;
65	int compare_valeur (const OT_VECTEUR_3D& mdd) const;
66
67	// coordinate access
68	virtual double get_x(void) const ;
69	virtual double get_y(void) const ;
70	virtual double get_z(void) const ;
71	virtual void change_x(double x);
72	virtual void change_y(double y);
73	virtual void change_z(double z);
74	virtual double* get_xyz(void);
75
76	operator const double* () const;
77	operator double* ();
78	double operator[] (int i) const;
79	double& operator[] (int i);
80	double operator() (int i) const;
81	double & operator() (int i);
82
83	// arithmetic operations
84	friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
85	friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
86	friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
87	friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
88	friend OT_VECTEUR_3D operator*(const class OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
89	friend OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
90	friend OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
91	friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
92
93	// arithmetic updates
94	OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
95	OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
96	OT_VECTEUR_3D& operator*= (double fScalar);
97	OT_VECTEUR_3D& operator/= (double fScalar);
98
99	// vector operations
100	virtual double get_longueur(void) const ;
101	virtual double get_longueur2(void) const ;
102	virtual void norme(void);
103	OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
104	virtual double diff(void);
105
106
107	private:
108	double valeur[3];
109	};
110
111	class DLLPORTOUTIL OT_MATRICE_3D
112	{
113	public:
114	OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
115	OT_MATRICE_3D(void);
116	OT_MATRICE_3D(double* t);
117	OT_MATRICE_3D(const OT_MATRICE_3D& mdd);
118
119	// stream string output
120	friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
121
122	// access to matrix elements
123	double operator() (int iLigne, int iCol) const;
124	double & operator() (int iLigne, int iCol);
125	double valeur(int iLigne, int iCol) const;
126	double & valeur(int iLigne, int iCol);
127	OT_VECTEUR_3D& get_vecteur1(void);
128	OT_VECTEUR_3D& get_vecteur2(void);
129	OT_VECTEUR_3D& get_vecteur3(void);
130	void change_vecteur1(OT_VECTEUR_3D v);
131	void change_vecteur2(OT_VECTEUR_3D v);
132	void change_vecteur3(OT_VECTEUR_3D v);
133	OT_VECTEUR_3D & operator [](int i);
134	// return inverse matrix
135	OT_MATRICE_3D inverse() const;
136	// assignements methods
137	void identite(void);
138	double get_determinant();
139	void transpose(OT_MATRICE_3D& res) const;
140	OT_MATRICE_3D transpose() const;
141	friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
142
143	private:
144	OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
145	friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
146	};
147
148	DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
149	DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
150	DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
151	DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
152	DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
153	DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
154	DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
155	DLLPORTOUTIL OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
156	DLLPORTOUTIL OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
157	DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
158	DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
159	DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
160
161
162
163	#define ot_vecteur_4d
164	#ifdef ot_vecteur_4d
165	class DLLPORTOUTIL OT_VECTEUR_4D
166	{
167	public :
168	//construction
169	OT_VECTEUR_4D(double x,double y,double z,double w);
170	OT_VECTEUR_4D(double *xyzw);
171	OT_VECTEUR_4D(void){};
172	OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd);
173	OT_VECTEUR_4D & operator= (double);
174
175	// stream string output
176	friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
177
178	// comparison
179	bool operator== (const OT_VECTEUR_4D& mdd) const;
180	bool operator!= (const OT_VECTEUR_4D& mdd) const;
181	bool operator< (const OT_VECTEUR_4D& mdd) const;
182	bool operator<= (const OT_VECTEUR_4D& mdd) const;
183	bool operator> (const OT_VECTEUR_4D& mdd) const;
184	bool operator>= (const OT_VECTEUR_4D& mdd) const;
185	int compare_valeur (const OT_VECTEUR_4D& mdd) const;
186
187	// coordinate access
188	virtual double get_x(void) const ;
189	virtual double get_y(void) const ;
190	virtual double get_z(void) const ;
191	virtual double get_w(void) const ;
192	virtual double & x(void);
193	virtual double & y(void);
194	virtual double & z(void);
195	virtual double & w(void);
196	virtual void change_x(double x);
197	virtual void change_y(double y);
198	virtual void change_z(double z);
199	virtual void change_w(double w);
200	virtual double* get_xyzw(void);
201	operator const double* () const;
202	operator double* ();
203	double operator[] (int i) const;
204	double& operator[] (int i);
205	double operator() (int i) const;
206	double & operator() (int i);
207
208	// arithmetic operations
209	OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
210	OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
211	double operator* (const OT_VECTEUR_4D & a);
212
213	// arithmetic updates
214	OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
215	OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
216	OT_VECTEUR_4D& operator*= (double fScalar);
217	OT_VECTEUR_4D& operator/= (double fScalar);
218
219	private:
220	double valeur[4];
221	};
222
223	DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
224	DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
225	DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
226	DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
227	DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
228	#endif // ot_vecteur_4d
229
230
231
232	class DLLPORTOUTIL OT_VECTEUR_4DD
233	{
234	public :
235	//construction
236	OT_VECTEUR_4DD(double2 x,double2 y,double2 z,double2 w);
237	OT_VECTEUR_4DD(double2 *xyzw);
238	OT_VECTEUR_4DD(){};
239	OT_VECTEUR_4DD(const OT_VECTEUR_4DD& mdd);
240	//OT_VECTEUR_4DD & operator= (double2);
241	OT_VECTEUR_4DD & operator= (const OT_VECTEUR_4DD&);
242
243	// stream string output
244	friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
245
246	// comparison
247	bool operator== (const OT_VECTEUR_4DD& mdd) const;
248	bool operator!= (const OT_VECTEUR_4DD& mdd) const;
249	bool operator< (const OT_VECTEUR_4DD& mdd) const;
250	bool operator<= (const OT_VECTEUR_4DD& mdd) const;
251	bool operator> (const OT_VECTEUR_4DD& mdd) const;
252	bool operator>= (const OT_VECTEUR_4DD& mdd) const;
253	int compare_valeur (const OT_VECTEUR_4DD& mdd) const;
254
255	// coordinate access
256	virtual double2 get_x(void) const ;
257	virtual double2 get_y(void) const ;
258	virtual double2 get_z(void) const ;
259	virtual double2 get_w(void) const ;
260	virtual double2 & x(void);
261	virtual double2 & y(void);
262	virtual double2 & z(void);
263	virtual double2 & w(void);
264	virtual void change_x(double2 x);
265	virtual void change_y(double2 y);
266	virtual void change_z(double2 z);
267	virtual void change_w(double2 w);
268	virtual double2* get_xyzw(void);
269	double2 norme();
270	OT_VECTEUR_4DD vecteur_norme() ;
271	operator const double2* () const;
272	operator double2* ();
273	double2 operator[] (int i) const;
274	double2& operator[] (int i);
275	double2 operator() (int i) const;
276	double2 & operator() (int i);
277
278	// arithmetic operations
279	OT_VECTEUR_4DD operator+ (const OT_VECTEUR_4DD& rkV);
280	OT_VECTEUR_4DD operator- (const OT_VECTEUR_4DD& rkV);
281	double2 operator* (const OT_VECTEUR_4DD & a);
282
283	// arithmetic updates
284	OT_VECTEUR_4DD& operator+= (const OT_VECTEUR_4DD& rkV);
285	OT_VECTEUR_4DD& operator-= (const OT_VECTEUR_4DD& rkV);
286	OT_VECTEUR_4DD& operator*= (double2 fScalar);
287	OT_VECTEUR_4DD& operator/= (double2 fScalar);
288	OT_VECTEUR_4DD operator^(const OT_VECTEUR_4DD& v2);
289
290
291	private:
292	double2 valeur[4];
293	};
294
295
296
297	class DLLPORTOUTIL OT_VECTEUR_3DD
298	{
299	public :
300	//construction
301	OT_VECTEUR_3DD(double2 x,double2 y,double2 z);
302	OT_VECTEUR_3DD(double2 *xyzw);
303	OT_VECTEUR_3DD(){};
304	OT_VECTEUR_3DD(const OT_VECTEUR_3DD& mdd);
305	OT_VECTEUR_3DD & operator= (const OT_VECTEUR_3DD&);
306
307	// stream string output
308	friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec);
309
310	// comparison
311	bool operator== (const OT_VECTEUR_3DD& mdd) const;
312	bool operator!= (const OT_VECTEUR_3DD& mdd) const;
313	bool operator< (const OT_VECTEUR_3DD& mdd) const;
314	bool operator<= (const OT_VECTEUR_3DD& mdd) const;
315	bool operator> (const OT_VECTEUR_3DD& mdd) const;
316	bool operator>= (const OT_VECTEUR_3DD& mdd) const;
317	int compare_valeur (const OT_VECTEUR_3DD& mdd) const;
318
319	// coordinate access
320	virtual double2 get_x(void) const ;
321	virtual double2 get_y(void) const ;
322	virtual double2 get_z(void) const ;
323	virtual double2 & x(void);
324	virtual double2 & y(void);
325	virtual double2 & z(void);
326	virtual void change_x(double2 x);
327	virtual void change_y(double2 y);
328	virtual void change_z(double2 z);
329	virtual double2* get_xyz(void);
330	double2 norme();
331	OT_VECTEUR_3DD vecteur_norme() ;
332	operator const double2* () const;
333	operator double2* ();
334	double2 operator[] (int i) const;
335	double2& operator[] (int i);
336	double2 operator() (int i) const;
337	double2 & operator() (int i);
338
339	// arithmetic operations
340	OT_VECTEUR_3DD operator+ (const OT_VECTEUR_3DD& rkV);
341	OT_VECTEUR_3DD operator- (const OT_VECTEUR_3DD& rkV);
342	double2 operator* (const OT_VECTEUR_3DD & a);
343
344	// arithmetic updates
345	OT_VECTEUR_3DD& operator+= (const OT_VECTEUR_3DD& rkV);
346	OT_VECTEUR_3DD& operator-= (const OT_VECTEUR_3DD& rkV);
347	OT_VECTEUR_3DD& operator*= (double2 fScalar);
348	OT_VECTEUR_3DD& operator/= (double2 fScalar);
349	OT_VECTEUR_3DD operator&(const OT_VECTEUR_3DD& v2);
350
351
352	private:
353	double2 valeur[3];
354	};
355
356
357
358
359
360
361	DLLPORTOUTIL OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a);
362	DLLPORTOUTIL OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV);
363	DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a);
364	DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV);
365	DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
366	DLLPORTOUTIL OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a);
367	DLLPORTOUTIL OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV);
368	DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a);
369	DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV);
370	DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
371
372
373
374
375
376
377	class DLLPORTOUTIL OPERATEUR
378	{
379	public:
380	static int egal(double a,double b,double eps);
381	static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
382	static double qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
383	static void doubleto2int(double val,int& val1,int& val2);
384	};
385
386
387	template <int N=4>
388	class DLLPORTOUTIL DOUBLEN
389	{
390	public:
391	DOUBLEN();
392	DOUBLEN(double *v);
393	DOUBLEN(DOUBLEN& mdd);
394	DOUBLEN(const DOUBLEN& mdd);
395	~DOUBLEN();
396	double get_valeur(int num);
397	void change_valeur(int num,double val);
398	DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
399	DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
400	private:
401	double tab[N];
402	};
403
404	struct lessOT_VECTEUR_4DD : binary_function<OT_VECTEUR_4DD, OT_VECTEUR_4DD, bool>
405	{
406	bool operator() ( OT_VECTEUR_4DD v1, OT_VECTEUR_4DD v2)
407	{
408	if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
409	if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
410	if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
411	if (v1[3]!=v2[3]) return v1[3]<v2[3] ;
412	return 0;
413
414	}
415	;
416	};
417
418	struct lessOT_VECTEUR_3DD : binary_function<OT_VECTEUR_3DD, OT_VECTEUR_3DD, bool>
419	{
420	bool operator() ( OT_VECTEUR_3DD v1, OT_VECTEUR_3DD v2)
421	{
422	if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
423	if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
424	if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
425	return 0;
426
427	}
428	;
429	};
430
431
432	#endif