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


Main Page   Class Hierarchy   Compound List   File List  

Vector18.h

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


Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download



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