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


Main Page   Class Hierarchy   Compound List   File List  

Vector19.h

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


Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download



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