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 <map>
#include <vector>


class DLLPORTOUTIL OT_HISTOGRAMME
{
public:
  OT_HISTOGRAMME(void);
  OT_HISTOGRAMME(double largeur_colonne);
  OT_HISTOGRAMME(OT_HISTOGRAMME &mdd);
  ~OT_HISTOGRAMME(void);
  void fixe_largeur_colonne(double largeur_colonne);
  double get_largeur_colonne(void);
  void ajouter_valeur(double x,double val);
  void ajouter_valeur(long i,double val);  
  int get_valeur(double x,double &val);
  int get_valeur(long i,double &val);
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur);
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min,double &borne_max);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min,double &borne_max);
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,long &i);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,long &i);
  long get_nb_colonne(void);
  double get_x_min(void);
  double get_x_max(void);
  OT_HISTOGRAMME& operator=(OT_HISTOGRAMME& mdd);
  OT_HISTOGRAMME& operator=(const OT_HISTOGRAMME& mdd);
  void enregistrer_bin(std::ofstream& ofstr);
  void ouvrir_bin(std::ifstream& ifstr);
  void exporter(std::ofstream& ofstrm);
protected:
  bool m_init;
  long m_i_min;
  long m_i_max;
  double m_largeur_colonne;
  std::map<long,double,std::less<long>> m_map_colonne;
};

class DLLPORTOUTIL OT_QUATERNION
{
public:
  OT_QUATERNION(void);
  OT_QUATERNION(double x,double y,double z,double w);
  OT_QUATERNION(OT_QUATERNION &mdd);
  double get_x(void);
  void change_x(double x);
  double get_y(void);
  void change_y(double y);
  double get_z(void);
  void change_z(double z);
  double get_w(void);
  void change_w(double w);
  
  OT_QUATERNION& operator=(OT_QUATERNION& mdd);
  
protected:
  double valeur[4];
};


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() ;
    OT_VECTEUR_4DD vecteur_norme_3d() ;
    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);
    bool est_nul(void);
    bool est_nul_3d(void);


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(double2 *xyz1,double2 *xyz2);
    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() ;
    virtual double2 get_longueur(void)  ;
    virtual double2 get_longueur2(void) ;
    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:
      enum ETAT {EXTERIEUR=0,INTERIEUR=4,STRICTINTERIEUR=3,SUR_FACE=1,SUR_ARETE=5,FACE1=10,FACE2=11,FACE3=12,FACE4=13,ARETE1=20,ARETE2=21,ARETE3=22,ARETE4=23,ARETE5=24,ARETE6=25,SOMMET1=30,SOMMET2=31,SOMMET3=32,SOMMET4=33};

    static int egal(double a,double b,double eps);
    static int egal(double *xyz1,double *xyz2,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);
    static int estdansletetra(double *xyz1,double *xyz2,double *xyz3,double *xyz4,double x,double y, double z);
    static int estdansletriangle(double *xyz1,double *xyz2,double *xyz3,double x,double y, double z);
    static int projeteestdansletriangle(double *xyz1,double *xyz2,double *xyz3,double x,double y, double z);

    static int compare_etat_tetra(int etat,int valeur);
    static int compare_etat_triangle(int etat,int valeur);
    
    static double taille_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
    static double taille_triangle(double* noeud1,double* noeud2,double* noeud3);
};


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 : std::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 : std::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:	968
Committed:	Sun Sep 16 15:27:49 2018 UTC (6 years, 8 months ago) by couturad
Content type:	text/plain
File size:	18108 byte(s)
Log Message:	Ajout d'une condition de sortie et d'un renvoi d'erreur pour le mailleur FEM. Subdivision des fichiers mstruct_analyse.h/.cpp en sous fichiers pour une meilleure lisibilite. Ajout d'une analyse des modules d'elasticite. Ajout d'une analyse de l'energie. Reconfiguration du main de microstructure.exe (suppression d'actions obsolètes). Reconfiguration des fichiers generer_nb_ves, post_process.
#	User	Rev	Content
1	francois	283	//------------------------------------------------------------
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	couturad	919	#include <map>
39	francois	283	#include <vector>
40
41
42	couturad	919	class DLLPORTOUTIL OT_HISTOGRAMME
43			{
44			public:
45	couturad	926	OT_HISTOGRAMME(void);
46	couturad	919	OT_HISTOGRAMME(double largeur_colonne);
47	couturad	968	OT_HISTOGRAMME(OT_HISTOGRAMME &mdd);
48	couturad	919	~OT_HISTOGRAMME(void);
49	couturad	926	void fixe_largeur_colonne(double largeur_colonne);
50			double get_largeur_colonne(void);
51	couturad	919	void ajouter_valeur(double x,double val);
52			void ajouter_valeur(long i,double val);
53	couturad	968	int get_valeur(double x,double &val);
54			int get_valeur(long i,double &val);
55	couturad	926	int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur);
56			int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur);
57			int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min,double &borne_max);
58			int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min,double &borne_max);
59			int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,long &i);
60			int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,long &i);
61	couturad	919	long get_nb_colonne(void);
62			double get_x_min(void);
63			double get_x_max(void);
64	couturad	926	OT_HISTOGRAMME& operator=(OT_HISTOGRAMME& mdd);
65	couturad	966	OT_HISTOGRAMME& operator=(const OT_HISTOGRAMME& mdd);
66	couturad	926	void enregistrer_bin(std::ofstream& ofstr);
67			void ouvrir_bin(std::ifstream& ifstr);
68			void exporter(std::ofstream& ofstrm);
69	couturad	919	protected:
70			bool m_init;
71			long m_i_min;
72			long m_i_max;
73			double m_largeur_colonne;
74	couturad	926	std::map<long,double,std::less<long>> m_map_colonne;
75	couturad	919	};
76
77	couturad	906	class DLLPORTOUTIL OT_QUATERNION
78			{
79			public:
80			OT_QUATERNION(void);
81			OT_QUATERNION(double x,double y,double z,double w);
82			OT_QUATERNION(OT_QUATERNION &mdd);
83			double get_x(void);
84			void change_x(double x);
85			double get_y(void);
86			void change_y(double y);
87			double get_z(void);
88			void change_z(double z);
89			double get_w(void);
90			void change_w(double w);
91
92			OT_QUATERNION& operator=(OT_QUATERNION& mdd);
93
94			protected:
95			double valeur[4];
96			};
97	francois	283
98
99
100			class DLLPORTOUTIL OT_VECTEUR_3D
101			{
102			public :
103			// construction
104			OT_VECTEUR_3D(double x,double y,double z);
105			OT_VECTEUR_3D(double *xyz);
106			OT_VECTEUR_3D(double xyz1,double xyz2);
107			OT_VECTEUR_3D(void);
108			OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd);
109			OT_VECTEUR_3D unite(int i);
110			// stream string output
111			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
112
113			// comparison
114			bool operator== (const OT_VECTEUR_3D& mdd) const;
115			bool operator!= (const OT_VECTEUR_3D& mdd) const;
116			bool operator< (const OT_VECTEUR_3D& mdd) const;
117			bool operator<= (const OT_VECTEUR_3D& mdd) const;
118			bool operator> (const OT_VECTEUR_3D& mdd) const;
119			bool operator>= (const OT_VECTEUR_3D& mdd) const;
120			int compare_valeur (const OT_VECTEUR_3D& mdd) const;
121
122			// coordinate access
123			virtual double get_x(void) const ;
124			virtual double get_y(void) const ;
125			virtual double get_z(void) const ;
126			virtual void change_x(double x);
127			virtual void change_y(double y);
128			virtual void change_z(double z);
129			virtual double* get_xyz(void);
130
131			operator const double* () const;
132			operator double* ();
133			double operator[] (int i) const;
134			double& operator[] (int i);
135			double operator() (int i) const;
136			double & operator() (int i);
137
138			// arithmetic operations
139			friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
140			friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
141			friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
142			friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
143			friend OT_VECTEUR_3D operator*(const class OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
144			friend OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
145			friend OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
146			friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
147
148			// arithmetic updates
149			OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
150			OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
151			OT_VECTEUR_3D& operator*= (double fScalar);
152			OT_VECTEUR_3D& operator/= (double fScalar);
153
154			// vector operations
155			virtual double get_longueur(void) const ;
156			virtual double get_longueur2(void) const ;
157			virtual void norme(void);
158			OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
159			virtual double diff(void);
160
161
162			private:
163			double valeur[3];
164			};
165
166			class DLLPORTOUTIL OT_MATRICE_3D
167			{
168			public:
169			OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
170			OT_MATRICE_3D(void);
171			OT_MATRICE_3D(double* t);
172			OT_MATRICE_3D(const OT_MATRICE_3D& mdd);
173
174			// stream string output
175			friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
176
177			// access to matrix elements
178			double operator() (int iLigne, int iCol) const;
179			double & operator() (int iLigne, int iCol);
180			double valeur(int iLigne, int iCol) const;
181			double & valeur(int iLigne, int iCol);
182			OT_VECTEUR_3D& get_vecteur1(void);
183			OT_VECTEUR_3D& get_vecteur2(void);
184			OT_VECTEUR_3D& get_vecteur3(void);
185			void change_vecteur1(OT_VECTEUR_3D v);
186			void change_vecteur2(OT_VECTEUR_3D v);
187			void change_vecteur3(OT_VECTEUR_3D v);
188			OT_VECTEUR_3D & operator [](int i);
189			// return inverse matrix
190			OT_MATRICE_3D inverse() const;
191			// assignements methods
192			void identite(void);
193			double get_determinant();
194			void transpose(OT_MATRICE_3D& res) const;
195			OT_MATRICE_3D transpose() const;
196			friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
197
198			private:
199			OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
200			friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
201			};
202
203			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
204			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
205			DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
206			DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
207			DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
208			DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
209			DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
210			DLLPORTOUTIL OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
211			DLLPORTOUTIL OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
212			DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
213			DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
214			DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
215
216
217
218			#define ot_vecteur_4d
219			#ifdef ot_vecteur_4d
220			class DLLPORTOUTIL OT_VECTEUR_4D
221			{
222			public :
223			//construction
224			OT_VECTEUR_4D(double x,double y,double z,double w);
225			OT_VECTEUR_4D(double *xyzw);
226			OT_VECTEUR_4D(void) {};
227			OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd);
228			OT_VECTEUR_4D & operator= (double);
229
230			// stream string output
231			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
232
233			// comparison
234			bool operator== (const OT_VECTEUR_4D& mdd) const;
235			bool operator!= (const OT_VECTEUR_4D& mdd) const;
236			bool operator< (const OT_VECTEUR_4D& mdd) const;
237			bool operator<= (const OT_VECTEUR_4D& mdd) const;
238			bool operator> (const OT_VECTEUR_4D& mdd) const;
239			bool operator>= (const OT_VECTEUR_4D& mdd) const;
240	francois	743	// int compare_valeur (const OT_VECTEUR_4D& mdd) const;
241	francois	283
242			// coordinate access
243			virtual double get_x(void) const ;
244			virtual double get_y(void) const ;
245			virtual double get_z(void) const ;
246			virtual double get_w(void) const ;
247			virtual double & x(void);
248			virtual double & y(void);
249			virtual double & z(void);
250			virtual double & w(void);
251			virtual void change_x(double x);
252			virtual void change_y(double y);
253			virtual void change_z(double z);
254			virtual void change_w(double w);
255			virtual double* get_xyzw(void);
256			operator const double* () const;
257			operator double* ();
258			double operator[] (int i) const;
259			double& operator[] (int i);
260			double operator() (int i) const;
261			double & operator() (int i);
262
263			// arithmetic operations
264			OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
265			OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
266			double operator* (const OT_VECTEUR_4D & a);
267
268			// arithmetic updates
269			OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
270			OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
271			OT_VECTEUR_4D& operator*= (double fScalar);
272			OT_VECTEUR_4D& operator/= (double fScalar);
273
274			private:
275			double valeur[4];
276			};
277
278			DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
279			DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
280			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
281			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
282			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
283			#endif // ot_vecteur_4d
284
285
286
287			class DLLPORTOUTIL OT_VECTEUR_4DD
288			{
289			public :
290			//construction
291			OT_VECTEUR_4DD(double2 x,double2 y,double2 z,double2 w);
292			OT_VECTEUR_4DD(double2 *xyzw);
293			OT_VECTEUR_4DD() {};
294			OT_VECTEUR_4DD(const OT_VECTEUR_4DD& mdd);
295			//OT_VECTEUR_4DD & operator= (double2);
296			OT_VECTEUR_4DD & operator= (const OT_VECTEUR_4DD&);
297
298			// stream string output
299			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
300
301			// comparison
302			bool operator== (const OT_VECTEUR_4DD& mdd) const;
303			bool operator!= (const OT_VECTEUR_4DD& mdd) const;
304			bool operator< (const OT_VECTEUR_4DD& mdd) const;
305			bool operator<= (const OT_VECTEUR_4DD& mdd) const;
306			bool operator> (const OT_VECTEUR_4DD& mdd) const;
307			bool operator>= (const OT_VECTEUR_4DD& mdd) const;
308			int compare_valeur (const OT_VECTEUR_4DD& mdd) const;
309
310			// coordinate access
311			virtual double2 get_x(void) const ;
312			virtual double2 get_y(void) const ;
313			virtual double2 get_z(void) const ;
314			virtual double2 get_w(void) const ;
315			virtual double2 & x(void);
316			virtual double2 & y(void);
317			virtual double2 & z(void);
318			virtual double2 & w(void);
319			virtual void change_x(double2 x);
320			virtual void change_y(double2 y);
321			virtual void change_z(double2 z);
322			virtual void change_w(double2 w);
323			virtual double2* get_xyzw(void);
324			double2 norme();
325			OT_VECTEUR_4DD vecteur_norme() ;
326	francois	363	OT_VECTEUR_4DD vecteur_norme_3d() ;
327	francois	283	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_4DD operator+ (const OT_VECTEUR_4DD& rkV);
336			OT_VECTEUR_4DD operator- (const OT_VECTEUR_4DD& rkV);
337			double2 operator* (const OT_VECTEUR_4DD & a);
338
339			// arithmetic updates
340			OT_VECTEUR_4DD& operator+= (const OT_VECTEUR_4DD& rkV);
341			OT_VECTEUR_4DD& operator-= (const OT_VECTEUR_4DD& rkV);
342			OT_VECTEUR_4DD& operator*= (double2 fScalar);
343			OT_VECTEUR_4DD& operator/= (double2 fScalar);
344			OT_VECTEUR_4DD operator^(const OT_VECTEUR_4DD& v2);
345	francois	743	bool est_nul(void);
346			bool est_nul_3d(void);
347	francois	283
348
349			private:
350			double2 valeur[4];
351			};
352
353
354
355			class DLLPORTOUTIL OT_VECTEUR_3DD
356			{
357			public :
358			//construction
359			OT_VECTEUR_3DD(double2 x,double2 y,double2 z);
360	francois	550	OT_VECTEUR_3DD(double2 *xyzw);
361			OT_VECTEUR_3DD(double2 xyz1,double2 xyz2);
362	francois	283	OT_VECTEUR_3DD() {};
363			OT_VECTEUR_3DD(const OT_VECTEUR_3DD& mdd);
364			OT_VECTEUR_3DD & operator= (const OT_VECTEUR_3DD&);
365
366			// stream string output
367			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec);
368
369			// comparison
370			bool operator== (const OT_VECTEUR_3DD& mdd) const;
371			bool operator!= (const OT_VECTEUR_3DD& mdd) const;
372			bool operator< (const OT_VECTEUR_3DD& mdd) const;
373			bool operator<= (const OT_VECTEUR_3DD& mdd) const;
374			bool operator> (const OT_VECTEUR_3DD& mdd) const;
375			bool operator>= (const OT_VECTEUR_3DD& mdd) const;
376			int compare_valeur (const OT_VECTEUR_3DD& mdd) const;
377
378			// coordinate access
379			virtual double2 get_x(void) const ;
380			virtual double2 get_y(void) const ;
381			virtual double2 get_z(void) const ;
382			virtual double2 & x(void);
383			virtual double2 & y(void);
384			virtual double2 & z(void);
385			virtual void change_x(double2 x);
386			virtual void change_y(double2 y);
387			virtual void change_z(double2 z);
388			virtual double2* get_xyz(void);
389			double2 norme();
390			OT_VECTEUR_3DD vecteur_norme() ;
391	francois	550	virtual double2 get_longueur(void) ;
392			virtual double2 get_longueur2(void) ;
393	francois	283	operator const double2* () const;
394			operator double2* ();
395			double2 operator[] (int i) const;
396			double2& operator[] (int i);
397			double2 operator() (int i) const;
398			double2 & operator() (int i);
399
400			// arithmetic operations
401			OT_VECTEUR_3DD operator+ (const OT_VECTEUR_3DD& rkV);
402			OT_VECTEUR_3DD operator- (const OT_VECTEUR_3DD& rkV);
403			double2 operator* (const OT_VECTEUR_3DD & a);
404
405			// arithmetic updates
406			OT_VECTEUR_3DD& operator+= (const OT_VECTEUR_3DD& rkV);
407			OT_VECTEUR_3DD& operator-= (const OT_VECTEUR_3DD& rkV);
408			OT_VECTEUR_3DD& operator*= (double2 fScalar);
409			OT_VECTEUR_3DD& operator/= (double2 fScalar);
410			OT_VECTEUR_3DD operator&(const OT_VECTEUR_3DD& v2);
411
412
413			private:
414			double2 valeur[3];
415			};
416
417
418
419
420
421
422			DLLPORTOUTIL OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a);
423			DLLPORTOUTIL OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV);
424			DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a);
425			DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV);
426			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
427			DLLPORTOUTIL OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a);
428			DLLPORTOUTIL OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV);
429			DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a);
430			DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV);
431			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
432
433
434
435
436
437
438			class DLLPORTOUTIL OPERATEUR
439			{
440			public:
441	francois	418	enum ETAT {EXTERIEUR=0,INTERIEUR=4,STRICTINTERIEUR=3,SUR_FACE=1,SUR_ARETE=5,FACE1=10,FACE2=11,FACE3=12,FACE4=13,ARETE1=20,ARETE2=21,ARETE3=22,ARETE4=23,ARETE5=24,ARETE6=25,SOMMET1=30,SOMMET2=31,SOMMET3=32,SOMMET4=33};
442
443	francois	283	static int egal(double a,double b,double eps);
444	couturad	906	static int egal(double xyz1,double xyz2,double eps);
445	francois	283	static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
446			static double qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
447			static void doubleto2int(double val,int& val1,int& val2);
448	francois	418	static int estdansletetra(double xyz1,double xyz2,double xyz3,double xyz4,double x,double y, double z);
449			static int estdansletriangle(double xyz1,double xyz2,double *xyz3,double x,double y, double z);
450			static int projeteestdansletriangle(double xyz1,double xyz2,double *xyz3,double x,double y, double z);
451
452			static int compare_etat_tetra(int etat,int valeur);
453			static int compare_etat_triangle(int etat,int valeur);
454	couturad	926
455			static double taille_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
456			static double taille_triangle(double* noeud1,double* noeud2,double* noeud3);
457	francois	283	};
458
459
460			template <int N=4>
461			class DLLPORTOUTIL DOUBLEN
462			{
463			public:
464			DOUBLEN();
465			DOUBLEN(double *v);
466			DOUBLEN(DOUBLEN& mdd);
467			DOUBLEN(const DOUBLEN& mdd);
468			~DOUBLEN();
469			double get_valeur(int num);
470			void change_valeur(int num,double val);
471			DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
472			DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
473			private:
474			double tab[N];
475			};
476
477	couturad	951	struct lessOT_VECTEUR_4DD : std::binary_function<OT_VECTEUR_4DD, OT_VECTEUR_4DD, bool>
478	francois	283	{
479			bool operator() ( OT_VECTEUR_4DD v1, OT_VECTEUR_4DD v2)
480			{
481			if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
482			if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
483			if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
484			if (v1[3]!=v2[3]) return v1[3]<v2[3] ;
485			return 0;
486
487			}
488			;
489			};
490
491	couturad	951	struct lessOT_VECTEUR_3DD : std::binary_function<OT_VECTEUR_3DD, OT_VECTEUR_3DD, bool>
492	francois	283	{
493			bool operator() ( OT_VECTEUR_3DD v1, OT_VECTEUR_3DD v2)
494			{
495			if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
496			if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
497			if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
498			return 0;
499
500			}
501			;
502			};
503
504
505			#endif