src/MEDMEM/INTERPOLATION/MEDMEM_WrapperField.hxx

   1 #ifndef MEDMEM_WRAPPER_FIELD_HXX
   2 #define MEDMEM_WRAPPER_FIELD_HXX
   3
   4 #include "MEDMEM_Field.hxx"
   5
   6 #include <vector>
   7
   8 //////////////////////////////////////////////////////////////////
   9 ///                                                            ///
  10 ///                 DECLARATIONS ET CODE                       ///
  11 ///                                                            ///
  12 //////////////////////////////////////////////////////////////////
  13
  14 /*********************************************************/
  15 /*                                                       */
  16 /*        Template Arithmétiques de Valdhuizen           */
  17 /*                                                       */
  18 /*********************************************************/
  19
  20 template <class TYPE> class Valeur;
  21
  22 struct Plus
  23 {
  24 public :
  25         static double apply(double a,double b) {return a+b;}
  26 };
  27
  28 struct Multiply
  29 {
  30 public :
  31         static double apply(double a,double b) {return a*b;}
  32 };
  33
  34
  35 template <typename Left,typename Op, typename Right> struct X
  36 {
  37         Left left;
  38         Right right;
  39         X(Left l,Right r):left(l),right(r){}
  40         double operator[](int i)
  41                 {
  42                 return Op::apply(left[i],right[i]);
  43                 }
  44 };
  45
  46 template <typename Right> struct X<double,Multiply,Right>
  47 {
  48         double left;
  49         Right right;
  50         X(double l,Right r):left(l),right(r){}
  51         double operator[](int i)
  52                 {
  53                 return Multiply::apply(left,right[i]);
  54                 }
  55 };
  56
  57 template <typename TYPE> X< Valeur<TYPE>,Plus,Valeur<TYPE> > operator+(Valeur<TYPE> v1,Valeur<TYPE> v2)
  58 {
  59 return X< Valeur<TYPE>,Plus,Valeur<TYPE> >(v1,v2);
  60 }
  61
  62 template <typename TYPE> X< double,Multiply,Valeur<double> > operator*(TYPE sca,Valeur<TYPE> v)
  63 {
  64 return X< TYPE,Multiply,Valeur<TYPE> >(sca,v);
  65 }
  66
  67 template <typename TYPE,typename  L, typename O, typename R> X< Valeur<TYPE>,Plus,X<L,O,R> > operator+(Valeur<TYPE> v,X<L,O,R> expression)
  68 {
  69 return X< Valeur<TYPE>,Plus,X<L,O,R> >(v,expression);
  70 }
  71
  72 template <typename TYPE,typename  L, typename O, typename R> X< X<L,O,R>,Plus,Valeur<TYPE> > operator+(X<L,O,R> expression,Valeur<TYPE> v)
  73 {
  74 return X< X<L,O,R>,Plus,Valeur<TYPE> >(expression,v);
  75 }
  76
  77 template <typename  Ll, typename  Ol, typename  Rl,typename  Lr, typename  Or, typename  Rr> X< X<Ll,Ol,Rl>,Plus, X<Lr,Or,Rr> > operator+(X<Ll,Ol,Rl> el, X<Lr,Or,Rr> er )
  78 {
  79 return X< X<Ll,Ol,Rl>,Plus,X<Lr,Or,Rr> >(el,er);
  80 }
  81
  82 template <typename  L, typename O, typename R> X< double,Multiply,X<L,O,R> > operator*(double sca,X<L,O,R> expression)
  83 {
  84 return X< double,Multiply,X<L,O,R> >(sca,expression);
  85 }
  86
  87 template <typename Left,typename Op,typename Right> X< double,Multiply,X<Left,Op,Right> > operator/(X<Left,Op,Right> l,double x)
  88 {
  89 return X< double,Multiply,X<Left,Op,Right> >(((double) 1/x),l);
  90 }
  91
  92 /*********************************************************/
  93 /*                                                       */
  94 /*                    Classe Valeur                      */
  95 /*                                                       */
  96 /*********************************************************/
  97
  98 // Problèmes : les constructeurs par copie ne sont pas satisfaisants
  99
 100 template <class TYPE> class Valeur
 101 {
 102 protected :
 103         TYPE * valeurs;
 104         int nbr_valeurs;
 105         int a_detruire;
 106 public :
 107         Valeur():valeurs(NULL),a_detruire(0){}
 108         Valeur(TYPE * val,int nv):valeurs(val),nbr_valeurs(nv),a_detruire(0){} // A VERIFIER
 109         Valeur(int n):nbr_valeurs(n),a_detruire(1)
 110                 {
 111                 valeurs=new TYPE[nbr_valeurs];
 112                 }
 113         template <typename Left,typename Op,typename Right> Valeur(X<Left,Op,Right> expression)
 114                 {
 115                 for (int i=0;i<nbr_valeurs;i++) valeurs[i]=expression[i];
 116                 }
 117         template <typename Left,typename Op,typename Right> void operator=(X<Left,Op,Right> expression)
 118                 {
 119                 for (int i=0;i<nbr_valeurs;i++) valeurs[i]=expression[i];
 120                 }
 121         void operator=(Valeur v)
 122                 {
 123                 for (int i=0;i<nbr_valeurs;i++) valeurs[i]=v[i];
 124                 }
 125         Valeur(const Valeur &v):nbr_valeurs(v.nbr_valeurs)
 126                 {
 127                 if (v.a_detruire)
 128                         {
 129                         a_detruire=1;
 130                         valeurs=new TYPE[nbr_valeurs];
 131                         for (int i=0;i<nbr_valeurs;i++) valeurs[i]=v.valeurs[i];
 132                         }
 133                 else
 134                         {
 135                         a_detruire=0;
 136                         valeurs=v.valeurs;
 137                         }
 138                 }
 139         ~Valeur(){if (a_detruire) delete [] valeurs;}
 140         TYPE operator[](int i){return valeurs[i];}
 141         int SIZE() const {return nbr_valeurs;}
 142 };
 143
 144 template <class TYPE> ostream &operator<<(ostream &os,Valeur<TYPE> v)
 145 {
 146 os<<"("<<flush;
 147 for (int i=0;i<v.SIZE();i++) os<<" "<<v[i]<<flush;
 148 os<<" ) "<<flush;
 149 return os;
 150 }
 151
 152 /*********************************************************/
 153 /*                                                       */
 154 /*               Classe Wrapper_MED_Field                */
 155 /*                                                       */
 156 /*********************************************************/
 157
 158 class Wrapper_MED_Field
 159 {
 160 protected :
 161         int nbr_valeurs;
 162         int nbr_composantes;
 163         double * valeurs;
 164 public :
 165         Wrapper_MED_Field():valeurs(NULL){}
 166         Wrapper_MED_Field(int nv, int nc, double * v):nbr_valeurs(nv),nbr_composantes(nc),valeurs(v)
 167                 {
 168                 }
 169         Wrapper_MED_Field(const FIELD<double> * medfield)
 170                 {
 171                 nbr_valeurs=medfield->getNumberOfValues();
 172                 nbr_composantes=medfield->getNumberOfComponents();
 173                 valeurs=const_cast<double *>(medfield->getValue(MED_FULL_INTERLACE));
 174                 }
 175         ~Wrapper_MED_Field(){}
 176         inline Valeur<double> operator[](int i)
 177                 {
 178                 if ((i<0)||(i>=nbr_valeurs))
 179                         {
 180                         cerr<<endl;
 181                         cerr<<"Outbound call dans Wrapper MED Field"<<endl;
 182                         cerr<<"Inférior Bound = "<<0<<endl;
 183                         cerr<<"Supérior Bound = "<<nbr_valeurs-1<<endl;
 184                         cerr<<"Call = "<<i<<endl;
 185                         exit(-1);
 186                         }
 187                 return Valeur<double>(&valeurs[nbr_composantes*i],nbr_composantes);
 188                 }
 189         double * Get_Valeurs() {return valeurs;}
 190         inline int Get_Nbr_Valeurs() const {return nbr_valeurs;}
 191         inline int Get_Nbr_Composantes() const {return nbr_composantes;}
 192         friend ostream & operator<<(ostream &os, Wrapper_MED_Field);
 193 };
 194
 195 ostream & operator<<(ostream &os, Wrapper_MED_Field wmf)
 196 {
 197 for (int i=0;i<wmf.nbr_valeurs;i++) os<<"Wrapper_MED_Field["<<i<<"] = "<<wmf[i]<<endl;
 198 return os;
 199 }
 200
 201 #endif