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 <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(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;
void jacobi(double*a,double*d,double*v,int n,int&nrot);
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 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:	58
Committed:	Fri Sep 28 21:00:16 2007 UTC (17 years, 7 months ago) by souaissa
Content type:	text/plain
Original Path:	*magic/lib/outil/outil/src/ot_mathematique.h*
File size:	9547 byte(s)
Log Message:	vectorisation de geometrie pour comparaison
#	User	Rev	Content
1	souaissa	58	//------------------------------------------------------------
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
37			#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(OT_VECTEUR_3D& mdd);
50			OT_VECTEUR_3D unite(int i);
51			// stream string output
52			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
53
54			// comparison
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			bool operator>= (const OT_VECTEUR_3D& mdd) const;
61			int compare_valeur (const OT_VECTEUR_3D& mdd) const;
62
63			// coordinate access
64			virtual double get_x(void) const ;
65			virtual double get_y(void) const ;
66			virtual double get_z(void) const ;
67			virtual void change_x(double x);
68			virtual void change_y(double y);
69			virtual void change_z(double z);
70			virtual double* get_xyz(void);
71
72			operator const double* () const;
73			operator double* ();
74			double operator[] (int i) const;
75			double& operator[] (int i);
76			double operator() (int i) const;
77			double & operator() (int i);
78
79			// arithmetic operations
80			friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
81			friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
82			friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
83			friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
84			friend OT_VECTEUR_3D operator*(const class OT_MATRICE_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-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
87			friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
88
89			// arithmetic updates
90			OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
91			OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
92			OT_VECTEUR_3D& operator*= (double fScalar);
93			OT_VECTEUR_3D& operator/= (double fScalar);
94
95			// vector operations
96			virtual double get_longueur(void) const ;
97			virtual double get_longueur2(void) const ;
98			virtual void norme(void);
99			OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
100			virtual double diff(void);
101
102
103			private:
104			double valeur[3];
105			};
106
107			class DLLPORTOUTIL OT_MATRICE_3D
108			{
109			public:
110			OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
111			OT_MATRICE_3D(void){};
112			OT_MATRICE_3D(double* t);
113			OT_MATRICE_3D(const OT_MATRICE_3D& mdd);
114
115			// stream string output
116			friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
117
118			// access to matrix elements
119			double operator() (int iLigne, int iCol) const;
120			double & operator() (int iLigne, int iCol);
121			double valeur(int iLigne, int iCol) const;
122			double & valeur(int iLigne, int iCol);
123			OT_VECTEUR_3D& get_vecteur1(void);
124			OT_VECTEUR_3D& get_vecteur2(void);
125			OT_VECTEUR_3D& get_vecteur3(void);
126			void change_vecteur1(OT_VECTEUR_3D v);
127			void change_vecteur2(OT_VECTEUR_3D v);
128			void change_vecteur3(OT_VECTEUR_3D v);
129			OT_VECTEUR_3D & operator [](int i);
130			// return inverse matrix
131			OT_MATRICE_3D inverse() const;
132			// assignements methods
133			void identite(void);
134			double get_determinant();
135			void transpose(OT_MATRICE_3D& res) const;
136			void jacobi(doublea,doubled,double*v,int n,int&nrot);
137			friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
138
139			private:
140			OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
141			friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
142			};
143
144			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
145			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
146			DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
147			DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
148			DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
149			DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
150			DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_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_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
153			DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
154			DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
155			DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
156
157
158
159			#define ot_vecteur_4d
160			#ifdef ot_vecteur_4d
161			class DLLPORTOUTIL OT_VECTEUR_4D
162			{
163			public :
164			//construction
165			OT_VECTEUR_4D(double x,double y,double z,double w);
166			OT_VECTEUR_4D(double *xyzw);
167			OT_VECTEUR_4D(void){};
168			OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd);
169			OT_VECTEUR_4D & operator= (double);
170
171			// stream string output
172			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
173
174			// comparison
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			bool operator>= (const OT_VECTEUR_4D& mdd) const;
181			int compare_valeur (const OT_VECTEUR_4D& mdd) const;
182
183			// coordinate access
184			virtual double get_x(void) const ;
185			virtual double get_y(void) const ;
186			virtual double get_z(void) const ;
187			virtual double get_w(void) const ;
188			virtual double & x(void);
189			virtual double & y(void);
190			virtual double & z(void);
191			virtual double & w(void);
192			virtual void change_x(double x);
193			virtual void change_y(double y);
194			virtual void change_z(double z);
195			virtual void change_w(double w);
196			virtual double* get_xyzw(void);
197			operator const double* () const;
198			operator double* ();
199			double operator[] (int i) const;
200			double& operator[] (int i);
201			double operator() (int i) const;
202			double & operator() (int i);
203
204			// arithmetic operations
205			OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
206			OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
207			double operator* (const OT_VECTEUR_4D & a);
208
209			// arithmetic updates
210			OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
211			OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
212			OT_VECTEUR_4D& operator*= (double fScalar);
213			OT_VECTEUR_4D& operator/= (double fScalar);
214
215			private:
216			double valeur[4];
217			};
218
219			DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
220			DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
221			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
222			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
223			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
224			#endif // ot_vecteur_4d
225
226
227			class DLLPORTOUTIL OPERATEUR
228			{
229			public:
230			static int egal(double a,double b,double eps);
231			static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
232			static double qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
233			static void doubleto2int(double val,int& val1,int& val2);
234			};
235
236
237			template <int N=4>
238			class DLLPORTOUTIL DOUBLEN
239			{
240			public:
241			DOUBLEN();
242			DOUBLEN(double *v);
243			DOUBLEN(DOUBLEN& mdd);
244			DOUBLEN(const DOUBLEN& mdd);
245			~DOUBLEN();
246			double get_valeur(int num);
247			void change_valeur(int num,double val);
248			DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
249			DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
250			private:
251			double tab[N];
252			};
253
254
255
256
257			#endif