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];
};


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