AMROC Main     Blockstructured Adaptive Mesh Refinement in object-oriented C++


Main Page   Class Hierarchy   Compound List   File List  

Vector14.h

Go to the documentation of this file.
00001 #ifndef AMROC_VECTOR14_H
00002 #define AMROC_VECTOR14_H
00003 
00011 #include "CompConf.h"
00012 #include "generic.h"
00013 #include <iostream.h>
00014 #include <assert.h>
00015  
00016 #ifndef VectorName
00017 #define Vector(dim)      name2(Vector,dim)
00018 #define VectorName
00019 #endif
00020 
00028 template <class DataType>
00029 class Vector(14) {
00030   typedef Vector(14)<DataType> TVector;
00031 
00032 public:
00033   typedef DataType InternalDataType;
00034 
00035   Vector(14)() {}
00036   Vector(14)(const TVector& x) { 
00037     memcpy((void *) data_, (void *) x.data_, sizeof(TVector));
00038   }
00039   Vector(14)(const DataType& v) { 
00040     data_[0] = v; 
00041     data_[1] = v; 
00042     data_[2] = v; 
00043     data_[3] = v; 
00044     data_[4] = v; 
00045     data_[5] = v; 
00046     data_[6] = v; 
00047     data_[7] = v; 
00048     data_[8] = v; 
00049     data_[9] = v; 
00050     data_[10] = v; 
00051     data_[11] = v; 
00052     data_[12] = v; 
00053     data_[13] = v; 
00054   }
00055 
00056   ~Vector(14)() {}
00057   
00058   DataType * data() { return data_; }
00059   const DataType * data() const { return data_; }
00060   int length() const { return 14; }
00061   static int Length() { return 14; }
00062 
00063   inline DataType operator()(int i) const {
00064 #ifdef DEBUG_PRINT
00065     assert((i >= 0) && (i < 14)); 
00066 #endif
00067     return data_[i];
00068   }
00069   inline DataType& operator()(int i) { 
00070 #ifdef DEBUG_PRINT
00071     assert((i >= 0) && (i < 14)); 
00072 #endif
00073     return data_[i];
00074   }
00075 
00076   inline DataType operator[](int i) const {
00077 #ifdef DEBUG_PRINT
00078     assert((i >= 0) && (i < 14)); 
00079 #endif
00080     return data_[i];
00081   }
00082   inline DataType& operator[](int i) { 
00083 #ifdef DEBUG_PRINT
00084     assert((i >= 0) && (i < 14)); 
00085 #endif
00086     return data_[i];
00087   }
00088 
00089   inline TVector& operator=(const TVector& x) { 
00090     memcpy((void *) data_, (void *) x.data_, sizeof(TVector));
00091     return *this; 
00092   }
00093   inline TVector& operator=(const DataType& v) { 
00094     data_[0] = v; 
00095     data_[1] = v; 
00096     data_[2] = v; 
00097     data_[3] = v; 
00098     data_[4] = v; 
00099     data_[5] = v; 
00100     data_[6] = v; 
00101     data_[7] = v; 
00102     data_[8] = v; 
00103     data_[9] = v; 
00104     data_[10] = v; 
00105     data_[11] = v; 
00106     data_[12] = v; 
00107     data_[13] = v; 
00108     return *this; 
00109   }
00110 
00111 #define Vector_Vector_Operator(ope,op)                          \
00112    inline TVector& operator ope (const TVector &x)              \
00113      {                                                          \
00114       data_[0] ope x.data_[0];                                  \
00115       data_[1] ope x.data_[1];                                  \
00116       data_[2] ope x.data_[2];                                  \
00117       data_[3] ope x.data_[3];                                  \
00118       data_[4] ope x.data_[4];                                  \
00119       data_[5] ope x.data_[5];                                  \
00120       data_[6] ope x.data_[6];                                  \
00121       data_[7] ope x.data_[7];                                  \
00122       data_[8] ope x.data_[8];                                  \
00123       data_[9] ope x.data_[9];                                  \
00124       data_[10] ope x.data_[10];                                \
00125       data_[11] ope x.data_[11];                                \
00126       data_[12] ope x.data_[12];                                \
00127       data_[13] ope x.data_[13];                                \
00128       return(*this);                                            \
00129      }                                                          \
00130    inline TVector operator op (const TVector &x) const          \
00131      {                                                          \
00132       TVector ret(*this);                                       \
00133       ret.data_[0] ope x.data_[0];                              \
00134       ret.data_[1] ope x.data_[1];                              \
00135       ret.data_[2] ope x.data_[2];                              \
00136       ret.data_[3] ope x.data_[3];                              \
00137       ret.data_[4] ope x.data_[4];                              \
00138       ret.data_[5] ope x.data_[5];                              \
00139       ret.data_[6] ope x.data_[6];                              \
00140       ret.data_[7] ope x.data_[7];                              \
00141       ret.data_[8] ope x.data_[8];                              \
00142       ret.data_[9] ope x.data_[9];                              \
00143       ret.data_[10] ope x.data_[10];                            \
00144       ret.data_[11] ope x.data_[11];                            \
00145       ret.data_[12] ope x.data_[12];                            \
00146       ret.data_[13] ope x.data_[13];                            \
00147       return(ret);                                              \
00148      }
00149    Vector_Vector_Operator(+=,+)
00150    Vector_Vector_Operator(-=,-)
00151    Vector_Vector_Operator(*=,*)
00152    Vector_Vector_Operator(/=,/)
00153 #undef Vector_Vector_Operator
00154 
00155 #define Vector_Scalar_Operator(ope,op)                          \
00156    inline TVector& operator ope (const DataType &v)             \
00157      {                                                          \
00158       data_[0] ope v;                                           \
00159       data_[1] ope v;                                           \
00160       data_[2] ope v;                                           \
00161       data_[3] ope v;                                           \
00162       data_[4] ope v;                                           \
00163       data_[5] ope v;                                           \
00164       data_[6] ope v;                                           \
00165       data_[7] ope v;                                           \
00166       data_[8] ope v;                                           \
00167       data_[9] ope v;                                           \
00168       data_[10] ope v;                                          \
00169       data_[11] ope v;                                          \
00170       data_[12] ope v;                                          \
00171       data_[13] ope v;                                          \
00172       return(*this);                                            \
00173      }                                                          \
00174    inline TVector operator op (const DataType &v) const         \
00175      {                                                          \
00176       TVector ret(*this);                                       \
00177       ret.data_[0] ope v;                                       \
00178       ret.data_[1] ope v;                                       \
00179       ret.data_[2] ope v;                                       \
00180       ret.data_[3] ope v;                                       \
00181       ret.data_[4] ope v;                                       \
00182       ret.data_[5] ope v;                                       \
00183       ret.data_[6] ope v;                                       \
00184       ret.data_[7] ope v;                                       \
00185       ret.data_[8] ope v;                                       \
00186       ret.data_[9] ope v;                                       \
00187       ret.data_[10] ope v;                                      \
00188       ret.data_[11] ope v;                                      \
00189       ret.data_[12] ope v;                                      \
00190       ret.data_[13] ope v;                                      \
00191      return(ret);                                               \
00192      }
00193    Vector_Scalar_Operator(+=,+)
00194    Vector_Scalar_Operator(-=,-)
00195    Vector_Scalar_Operator(*=,*)
00196    Vector_Scalar_Operator(/=,/)
00197 #undef Vector_Scalar_Operator
00198 
00199    /* Define the negation operator */
00200    inline TVector operator - () const
00201      { 
00202        TVector ret;
00203        ret.data_[0] = -data_[0];
00204        ret.data_[1] = -data_[1];
00205        ret.data_[2] = -data_[2];
00206        ret.data_[3] = -data_[3];
00207        ret.data_[4] = -data_[4];
00208        ret.data_[5] = -data_[5];
00209        ret.data_[6] = -data_[6];
00210        ret.data_[7] = -data_[7];
00211        ret.data_[8] = -data_[8];
00212        ret.data_[9] = -data_[9];
00213        ret.data_[10] = -data_[10];
00214        ret.data_[11] = -data_[11];
00215        ret.data_[12] = -data_[12];
00216        ret.data_[13] = -data_[13];
00217        return(ret);
00218      }
00219 
00220 #define Vector_Vector_RelOperator(op)                           \
00221    inline int operator op (const TVector &x) const              \
00222      { return(                                                  \
00223                (data_[0] op x.data_[0])                         \
00224             && (data_[1] op x.data_[1])                         \
00225             && (data_[2] op x.data_[2])                         \
00226             && (data_[3] op x.data_[3])                         \
00227             && (data_[4] op x.data_[4])                         \
00228             && (data_[5] op x.data_[5])                         \
00229             && (data_[6] op x.data_[6])                         \
00230             && (data_[7] op x.data_[7])                         \
00231             && (data_[8] op x.data_[8])                         \
00232             && (data_[9] op x.data_[9])                         \
00233             && (data_[10] op x.data_[10])                       \
00234             && (data_[11] op x.data_[11])                       \
00235             && (data_[12] op x.data_[12])                       \
00236             && (data_[13] op x.data_[13])                       \
00237              ) ; }                     
00238 
00239    Vector_Vector_RelOperator(==)
00240    Vector_Vector_RelOperator(!=)
00241 #undef Vector_Vector_RelOperator
00242 
00243 #define Vector_Vector_RelOperator(op)                           \
00244    inline int operator op (const TVector &x) const              \
00245      { return(                                                  \
00246                (data_[0] op x.data_[0])                         \
00247             || (data_[1] op x.data_[1])                         \
00248             || (data_[2] op x.data_[2])                         \
00249             || (data_[3] op x.data_[3])                         \
00250             || (data_[4] op x.data_[4])                         \
00251             || (data_[5] op x.data_[5])                         \
00252             || (data_[6] op x.data_[6])                         \
00253             || (data_[7] op x.data_[7])                         \
00254             || (data_[8] op x.data_[8])                         \
00255             || (data_[9] op x.data_[9])                         \
00256             || (data_[10] op x.data_[10])                       \
00257             || (data_[11] op x.data_[11])                       \
00258             || (data_[12] op x.data_[12])                       \
00259             || (data_[13] op x.data_[13])                       \
00260              ) ; }                     
00261 
00262    Vector_Vector_RelOperator(>)
00263    Vector_Vector_RelOperator(<)
00264    Vector_Vector_RelOperator(>=)
00265    Vector_Vector_RelOperator(<=)
00266 #undef Vector_Vector_RelOperator
00267 
00268 #define Vector_Scalar_RelOperator(op)                           \
00269    inline int operator op (const DataType &v) const             \
00270      { return(                                                  \
00271                (data_[0] op v)                                  \
00272             && (data_[1] op v)                                  \
00273             && (data_[2] op v)                                  \
00274             && (data_[3] op v)                                  \
00275             && (data_[4] op v)                                  \
00276             && (data_[5] op v)                                  \
00277             && (data_[6] op v)                                  \
00278             && (data_[7] op v)                                  \
00279             && (data_[8] op v)                                  \
00280             && (data_[9] op v)                                  \
00281             && (data_[10] op v)                                 \
00282             && (data_[11] op v)                                 \
00283             && (data_[12] op v)                                 \
00284             && (data_[13] op v)                                 \
00285              ); }                     
00286 
00287    Vector_Scalar_RelOperator(==)
00288    Vector_Scalar_RelOperator(!=)
00289 #undef Vector_Scalar_RelOperator
00290 
00291 #define Vector_Scalar_RelOperator(op)                           \
00292    inline int operator op (const DataType &v) const             \
00293      { return(                                                  \
00294                (data_[0] op v)                                  \
00295             || (data_[1] op v)                                  \
00296             || (data_[2] op v)                                  \
00297             || (data_[3] op v)                                  \
00298             || (data_[4] op v)                                  \
00299             || (data_[5] op v)                                  \
00300             || (data_[6] op v)                                  \
00301             || (data_[7] op v)                                  \
00302             || (data_[8] op v)                                  \
00303             || (data_[9] op v)                                  \
00304             || (data_[10] op v)                                 \
00305             || (data_[11] op v)                                 \
00306             || (data_[12] op v)                                 \
00307             || (data_[13] op v)                                 \
00308               ); }                     
00309 
00310    Vector_Scalar_RelOperator(>)
00311    Vector_Scalar_RelOperator(<)
00312    Vector_Scalar_RelOperator(>=)
00313    Vector_Scalar_RelOperator(<=)
00314 #undef Vector_Scalar_RelOperator
00315 
00316    /* Define elementwise minimum and maximum functions for Vectors */
00317    inline void min(const TVector &x) { 
00318      data_[0] = (data_[0] < x.data_[0]) ? data_[0] : x.data_[0]; 
00319      data_[1] = (data_[1] < x.data_[1]) ? data_[1] : x.data_[1]; 
00320      data_[2] = (data_[2] < x.data_[2]) ? data_[2] : x.data_[2]; 
00321      data_[3] = (data_[3] < x.data_[3]) ? data_[3] : x.data_[3]; 
00322      data_[4] = (data_[4] < x.data_[4]) ? data_[4] : x.data_[4]; 
00323      data_[5] = (data_[5] < x.data_[5]) ? data_[5] : x.data_[5]; 
00324      data_[6] = (data_[6] < x.data_[6]) ? data_[6] : x.data_[6]; 
00325      data_[7] = (data_[7] < x.data_[7]) ? data_[7] : x.data_[7]; 
00326      data_[8] = (data_[8] < x.data_[8]) ? data_[8] : x.data_[8]; 
00327      data_[9] = (data_[9] < x.data_[9]) ? data_[9] : x.data_[9]; 
00328      data_[10] = (data_[10] < x.data_[10]) ? data_[10] : x.data_[10]; 
00329      data_[11] = (data_[11] < x.data_[11]) ? data_[11] : x.data_[11]; 
00330      data_[12] = (data_[12] < x.data_[12]) ? data_[12] : x.data_[12]; 
00331      data_[13] = (data_[13] < x.data_[13]) ? data_[13] : x.data_[13]; 
00332    }
00333    inline void max(const TVector &x) {
00334      data_[0] = (data_[0] > x.data_[0]) ? data_[0] : x.data_[0]; 
00335      data_[1] = (data_[1] > x.data_[1]) ? data_[1] : x.data_[1]; 
00336      data_[2] = (data_[2] > x.data_[2]) ? data_[2] : x.data_[2]; 
00337      data_[3] = (data_[3] > x.data_[3]) ? data_[3] : x.data_[3]; 
00338      data_[4] = (data_[4] > x.data_[4]) ? data_[4] : x.data_[4]; 
00339      data_[5] = (data_[5] > x.data_[5]) ? data_[5] : x.data_[5]; 
00340      data_[6] = (data_[6] > x.data_[6]) ? data_[6] : x.data_[6]; 
00341      data_[7] = (data_[7] > x.data_[7]) ? data_[7] : x.data_[7]; 
00342      data_[8] = (data_[8] > x.data_[8]) ? data_[8] : x.data_[8]; 
00343      data_[9] = (data_[9] > x.data_[9]) ? data_[9] : x.data_[9]; 
00344      data_[10] = (data_[10] > x.data_[10]) ? data_[10] : x.data_[10]; 
00345      data_[11] = (data_[11] > x.data_[11]) ? data_[11] : x.data_[11]; 
00346      data_[12] = (data_[12] > x.data_[12]) ? data_[12] : x.data_[12]; 
00347      data_[13] = (data_[13] > x.data_[13]) ? data_[13] : x.data_[13]; 
00348    }
00349 
00350    /* Define minimum and maximum of components */
00351    inline DataType mincomp() const { 
00352      DataType min;
00353      min = data_[0];
00354      if (data_[1] < min) min = data_[1]; 
00355      if (data_[2] < min) min = data_[2]; 
00356      if (data_[3] < min) min = data_[3]; 
00357      if (data_[4] < min) min = data_[4]; 
00358      if (data_[5] < min) min = data_[5]; 
00359      if (data_[6] < min) min = data_[6]; 
00360      if (data_[7] < min) min = data_[7]; 
00361      if (data_[8] < min) min = data_[8]; 
00362      if (data_[9] < min) min = data_[9]; 
00363      if (data_[10] < min) min = data_[10]; 
00364      if (data_[11] < min) min = data_[11]; 
00365      if (data_[12] < min) min = data_[12]; 
00366      if (data_[13] < min) min = data_[13]; 
00367      return min;
00368    }
00369    inline DataType maxcomp() const { 
00370      DataType max;
00371      max = data_[0];
00372      if (data_[1] > max) max = data_[1]; 
00373      if (data_[2] > max) max = data_[2]; 
00374      if (data_[3] > max) max = data_[3]; 
00375      if (data_[4] > max) max = data_[4]; 
00376      if (data_[5] > max) max = data_[5]; 
00377      if (data_[6] > max) max = data_[6]; 
00378      if (data_[7] > max) max = data_[7]; 
00379      if (data_[8] > max) max = data_[8]; 
00380      if (data_[9] > max) max = data_[9]; 
00381      if (data_[10] > max) max = data_[10]; 
00382      if (data_[11] > max) max = data_[11]; 
00383      if (data_[12] > max) max = data_[12]; 
00384      if (data_[13] > max) max = data_[13]; 
00385      return max;
00386    }
00387 
00388    inline double abs() const {
00389      DataType s = data_[0]*data_[0];
00390      s += data_[1]*data_[1]; 
00391      s += data_[2]*data_[2]; 
00392      s += data_[3]*data_[3]; 
00393      s += data_[4]*data_[4]; 
00394      s += data_[5]*data_[5]; 
00395      s += data_[6]*data_[6]; 
00396      s += data_[7]*data_[7]; 
00397      s += data_[8]*data_[8]; 
00398      s += data_[9]*data_[9];
00399      s += data_[10]*data_[10];
00400      s += data_[11]*data_[11];
00401      s += data_[12]*data_[12];
00402      s += data_[13]*data_[13];
00403      return (sqrt(double(s)));
00404    }
00405 
00406    inline TVector getmin(const TVector &x) const
00407      { TVector ret(*this); ret.min(x); return(ret); }
00408    inline TVector getmax(const TVector &x) const
00409      { TVector ret(*this); ret.max(x); return(ret); }
00410 
00411 public:
00412    DataType data_[14];
00413 };
00414 
00415 
00416 template <class DataType>
00417 inline ostream&  operator << (ostream& os, const Vector(14)<DataType> &v) {
00418   os << "(" 
00419      << v.data_[0] 
00420      << "," << v.data_[1] 
00421      << "," << v.data_[2] 
00422      << "," << v.data_[3] 
00423      << "," << v.data_[4] 
00424      << "," << v.data_[5] 
00425      << "," << v.data_[6] 
00426      << "," << v.data_[7] 
00427      << "," << v.data_[8] 
00428      << "," << v.data_[9] 
00429      << "," << v.data_[10] 
00430      << "," << v.data_[11] 
00431      << "," << v.data_[12] 
00432      << "," << v.data_[13] 
00433      << ")";
00434   return os;
00435 }
00436 
00437 template <class DataType>
00438 inline Vector(14)<DataType> Min(const Vector(14)<DataType> &x, 
00439                                    const Vector(14)<DataType> &y) 
00440   { Vector(14)<DataType> ret(x); ret.min(y); return(ret); }
00441 
00442 template <class DataType>
00443 inline Vector(14)<DataType> Max(const Vector(14)<DataType> &x, 
00444                                    const Vector(14)<DataType> &y) 
00445   { Vector(14)<DataType> ret(x); ret.max(y); return(ret); }
00446 
00447 template <class DataType>
00448 inline double abs(const Vector(14)<DataType> &x) 
00449   { return (x.abs()); }
00450 
00451 template <class DataType>
00452 inline DataType mincomp(const Vector(14)<DataType> &x) 
00453   { return(x.mincomp()); }
00454 
00455 template <class DataType>
00456 inline DataType maxcomp(const Vector(14)<DataType> &x) 
00457   { return(x.maxcomp()); }
00458 
00459 
00460 #define Global_Vector_Scalar_Operator(op)                                  \
00461 template <class DataType>                                                  \
00462 inline Vector(14)<DataType> operator op (const DataType &v,                 \
00463    const Vector(14)<DataType> &x)                                           \
00464    { return(x op v); }
00465 
00466 Global_Vector_Scalar_Operator(+)
00467 Global_Vector_Scalar_Operator(-)
00468 Global_Vector_Scalar_Operator(*)
00469 Global_Vector_Scalar_Operator(/)
00470 #undef Global_Vector_Scalar_Operator
00471 
00472 
00473 #define Global_Vector_Function(fct)                                       \
00474 template <class DataType>                                                 \
00475 inline Vector(14)<DataType> fct(const Vector(14)<DataType> &x)              \
00476    {                                                                      \
00477       Vector(14)<DataType> ret;                                            \
00478       ret[0] = fct(x[0]);                                                 \
00479       ret[1] = fct(x[1]);                                                 \
00480       ret[2] = fct(x[2]);                                                 \
00481       ret[3] = fct(x[3]);                                                 \
00482       ret[4] = fct(x[4]);                                                 \
00483       ret[5] = fct(x[5]);                                                 \
00484       ret[6] = fct(x[6]);                                                 \
00485       ret[7] = fct(x[7]);                                                 \
00486       ret[8] = fct(x[8]);                                                 \
00487       ret[9] = fct(x[9]);                                                 \
00488       ret[10] = fct(x[10]);                                               \
00489       ret[11] = fct(x[11]);                                               \
00490       ret[12] = fct(x[12]);                                               \
00491       ret[13] = fct(x[13]);                                               \
00492       return(ret);                                                        \
00493      }
00494 
00495 Global_Vector_Function(fabs)
00496 Global_Vector_Function(sqrt)
00497 #undef Global_Vector_Function
00498 
00499 
00500 #define Vector_Vector_Functions(NameTo,NameFrom,ope)                      \
00501   template <class DataType, class VectorType>                             \
00502   inline void NameTo (Vector(14)<DataType> &x, const VectorType &y)        \
00503     {                                                                     \
00504       x(0) ope y(0);                                                      \
00505       x(1) ope y(1);                                                      \
00506       x(2) ope y(2);                                                      \
00507       x(3) ope y(3);                                                      \
00508       x(4) ope y(4);                                                      \
00509       x(5) ope y(5);                                                      \
00510       x(6) ope y(6);                                                      \
00511       x(7) ope y(7);                                                      \
00512       x(8) ope y(8);                                                      \
00513       x(9) ope y(9);                                                      \
00514       x(10) ope y(10);                                                    \
00515       x(11) ope y(11);                                                    \
00516       x(12) ope y(12);                                                    \
00517       x(13) ope y(13);                                                    \
00518     }                                                                     \
00519   template <class DataType, class VectorType>                             \
00520   inline void NameFrom (VectorType &x, const Vector(14)<DataType> &y)      \
00521     {                                                                     \
00522       x(0) ope y(0);                                                      \
00523       x(1) ope y(1);                                                      \
00524       x(2) ope y(2);                                                      \
00525       x(3) ope y(3);                                                      \
00526       x(4) ope y(4);                                                      \
00527       x(5) ope y(5);                                                      \
00528       x(6) ope y(6);                                                      \
00529       x(7) ope y(7);                                                      \
00530       x(8) ope y(8);                                                      \
00531       x(9) ope y(9);                                                      \
00532       x(10) ope y(10);                                                    \
00533       x(11) ope y(11);                                                    \
00534       x(12) ope y(12);                                                    \
00535       x(13) ope y(13);                                                    \
00536     }
00537 
00538    Vector_Vector_Functions(equals_to,equals_from,=)
00539    Vector_Vector_Functions(plus_to,plus_from,+=)
00540    Vector_Vector_Functions(minus_to,minus_from,-=)
00541    Vector_Vector_Functions(multiply_to,multiply_from,*=)
00542    Vector_Vector_Functions(divide_to,divide_from,/=)
00543 #undef Vector_Vector_Functions
00544 
00545 
00546 #endif


Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download



AMROC Main      Home      Contact
last update: 06/01/04