00001
00002
00003
00004
00005 #ifndef PLAYA_VECTORFUNCTORSIMPL_HPP
00006 #define PLAYA_VECTORFUNCTORSIMPL_HPP
00007
00008
00009 #include "PlayaDefs.hpp"
00010 #include "PlayaVectorFunctorsDecl.hpp"
00011 #include "PlayaMPIComm.hpp"
00012 #include "PlayaRand.hpp"
00013
00014 namespace PlayaFunctors
00015 {
00016
00017
00018 template <class Scalar>
00019 class Abs
00020 {
00021 public:
00022
00023 Abs() {}
00024
00025
00026 Scalar operator()(const Scalar& x) const
00027 {return ::fabs(x);}
00028
00029
00030 std::string description() const {return "Abs()";}
00031 };
00032
00033
00034 template <class Scalar>
00035 class Reciprocal
00036 {
00037 public:
00038
00039 Reciprocal() {}
00040
00041
00042 Scalar operator()(const Scalar& x) const
00043 {return 1.0/x;}
00044
00045
00046 std::string description() const {return "Reciprocal()";}
00047 };
00048
00049
00050 template <class Scalar>
00051 class Random
00052 {
00053 public:
00054
00055 Random() {}
00056
00057
00058 Scalar operator()(const Scalar& x) const
00059 {return Playa::Rand::val();}
00060
00061
00062 std::string description() const {return "Random()";}
00063 };
00064
00065
00066 template <class Scalar>
00067 class ScalarMult
00068 {
00069 public:
00070
00071 ScalarMult(const Scalar& alpha) : alpha_(alpha) {}
00072
00073
00074 Scalar operator()(const Scalar& x) const
00075 {return alpha_*x;}
00076
00077
00078 std::string description() const
00079 {
00080 std::ostringstream oss;
00081 oss << "ScalarMult(alpha=" << alpha_ << ")";
00082 return oss.str();
00083 }
00084 private:
00085 Scalar alpha_;
00086 };
00087
00088
00089 template <class Scalar>
00090 class Identity
00091 {
00092 public:
00093
00094 Identity() {}
00095
00096
00097 Scalar operator()(const Scalar& x) const
00098 {return x;}
00099
00100
00101 std::string description() const {return "Identity()";}
00102 };
00103
00104
00105 template <class Scalar>
00106 class SetConstant
00107 {
00108 public:
00109
00110 SetConstant(const Scalar& alpha) : alpha_(alpha) {}
00111
00112
00113 Scalar operator()(const Scalar& x) const
00114 {return alpha_;}
00115
00116
00117 std::string description() const
00118 {
00119 std::ostringstream oss;
00120 oss << "SetConstant(alpha=" << alpha_ << ")";
00121 return oss.str();
00122 }
00123 private:
00124 Scalar alpha_;
00125 };
00126
00127
00128
00129 template <class Scalar>
00130 class DotStar
00131 {
00132 public:
00133
00134 DotStar() {}
00135
00136
00137 Scalar operator()(const Scalar& x, const Scalar& y) const
00138 {return x*y;}
00139
00140
00141 std::string description() const {return "dotStar()";}
00142 };
00143
00144
00145
00146 template <class Scalar>
00147 class DotSlash
00148 {
00149 public:
00150
00151 DotSlash() {}
00152
00153
00154 Scalar operator()(const Scalar& x, const Scalar& y) const
00155 {return x/y;}
00156
00157
00158 std::string description() const {return "dotSlash()";}
00159 };
00160
00161
00162 template <class Scalar>
00163 class XPlusBetaY
00164 {
00165 public:
00166
00167 XPlusBetaY(const Scalar& b) : b_(b) {}
00168
00169
00170 Scalar operator()(const Scalar& x, const Scalar& y) const
00171 {return x + b_*y;}
00172
00173
00174 std::string description() const
00175 {
00176 std::ostringstream oss;
00177 oss << "XPlusBetaY(b=" << b_ << ")";
00178 return oss.str();
00179 }
00180 private:
00181 Scalar b_;
00182 };
00183
00184
00185 template <class Scalar>
00186 class LC2
00187 {
00188 public:
00189
00190 LC2(const Scalar& a, const Scalar& b) : a_(a), b_(b) {}
00191
00192
00193 Scalar operator()(const Scalar& x, const Scalar& y) const
00194 {return a_*x + b_*y;}
00195
00196
00197 std::string description() const
00198 {
00199 std::ostringstream oss;
00200 oss << "LC2(a=" << a_ << ", b=" << b_ << ")";
00201 return oss.str();
00202 }
00203 private:
00204 Scalar a_;
00205 Scalar b_;
00206 };
00207
00208
00209
00210 template <class Scalar>
00211 class LC3
00212 {
00213 public:
00214
00215 LC3(const Scalar& a, const Scalar& b, const Scalar& c)
00216 : a_(a), b_(b), c_(c) {}
00217
00218
00219 Scalar operator()(const Scalar& x, const Scalar& y, const Scalar& z) const
00220 {return a_*x + b_*y + c_*z;}
00221
00222
00223
00224 std::string description() const
00225 {
00226 std::ostringstream oss;
00227 oss << "LC3(a=" << a_ << ", b=" << b_ << ", c=" << c_ << ")";
00228 return oss.str();
00229 }
00230 private:
00231 Scalar a_;
00232 Scalar b_;
00233 Scalar c_;
00234 };
00235
00236
00237
00238 template <class Scalar>
00239 class Norm2 : public ReductionFunctorBase<Scalar>
00240 {
00241 public:
00242 Norm2(const MPIComm& comm)
00243 : ReductionFunctorBase<Scalar>(comm), val_(0.0) {}
00244
00245 void step(int i, const Scalar& x) const
00246 {
00247 val_ += x*x;
00248 }
00249
00250 void postProc() const
00251 {
00252 Scalar final = val_;
00253 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::sumOp());
00254 val_ = final;
00255 }
00256
00257 Scalar result() const
00258 {
00259 return ::sqrt(val_);
00260 }
00261
00262
00263 std::string description() const {return "Norm2()";}
00264
00265 private:
00266 mutable Scalar val_;
00267 };
00268
00269
00270 template <class Scalar>
00271 class WeightedNorm2 : public ReductionFunctorBase<Scalar>
00272 {
00273 public:
00274 WeightedNorm2(const MPIComm& comm)
00275 : ReductionFunctorBase<Scalar>(comm), val_(0.0) {}
00276
00277 void step(int i, const Scalar& x, const Scalar& y) const
00278 {
00279 val_ += y*x*x;
00280 }
00281
00282 void postProc() const
00283 {
00284 Scalar final = val_;
00285 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::sumOp());
00286 val_ = final;
00287 }
00288
00289 Scalar result() const
00290 {
00291 return ::sqrt(val_);
00292 }
00293
00294
00295 std::string description() const {return "WeightedNorm2()";}
00296
00297 private:
00298 MPIComm comm_;
00299 mutable Scalar val_;
00300 };
00301
00302
00303 template <class Scalar>
00304 class Norm1 : public ReductionFunctorBase<Scalar>
00305 {
00306 public:
00307 Norm1(const MPIComm& comm)
00308 : ReductionFunctorBase<Scalar>(comm), val_(0.0) {}
00309
00310 void step(int i, const Scalar& x) const
00311 {
00312 val_ += ::fabs(x);
00313 }
00314
00315 void postProc() const
00316 {
00317 Scalar final = val_;
00318 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::sumOp());
00319 val_ = final;
00320 }
00321
00322 Scalar result() const
00323 {
00324 return val_;
00325 }
00326
00327
00328 std::string description() const {return "Norm1()";}
00329
00330 private:
00331 mutable Scalar val_;
00332 };
00333
00334
00335 template <class Scalar>
00336 class NormInf : public ReductionFunctorBase<Scalar>
00337 {
00338 public:
00339 NormInf(const MPIComm& comm)
00340 : ReductionFunctorBase<Scalar>(comm), val_(-1.0) {}
00341
00342 void step(int i, const Scalar& x) const
00343 {
00344 Scalar z = ::fabs(x);
00345 if (z > val_) val_ = z;
00346 }
00347
00348 void postProc() const
00349 {
00350 Scalar final = val_;
00351 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::maxOp());
00352 val_ = final;
00353 }
00354
00355 Scalar result() const
00356 {
00357 return val_;
00358 }
00359
00360
00361 std::string description() const {return "NormInf()";}
00362
00363 private:
00364 mutable Scalar val_;
00365 };
00366
00367
00368 template <class Scalar>
00369 class DotProduct : public ReductionFunctorBase<Scalar>
00370 {
00371 public:
00372 DotProduct(const MPIComm& comm)
00373 : ReductionFunctorBase<Scalar>(comm), val_(0.0) {}
00374
00375 void step(int i, const Scalar& x, const Scalar& y) const
00376 {
00377 val_ += x*y;
00378 }
00379
00380 void postProc() const
00381 {
00382 Scalar final = val_;
00383 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::sumOp());
00384 val_ = final;
00385 }
00386
00387 Scalar result() const
00388 {
00389 return val_;
00390 }
00391
00392
00393 std::string description() const {return "DotProduct()";}
00394
00395 private:
00396 mutable Scalar val_;
00397 };
00398
00399
00400
00401 template <class Scalar>
00402 class Min : public ReductionFunctorBase<Scalar>
00403 {
00404 public:
00405 Min(const MPIComm& comm)
00406 : ReductionFunctorBase<Scalar>(comm), val_(HUGE_VAL) {}
00407
00408 void step(int i, const Scalar& x) const
00409 {
00410 if (x < val_) val_ = x;
00411 }
00412
00413 void postProc() const
00414 {
00415 Scalar final = val_;
00416 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::minOp());
00417 val_ = final;
00418 }
00419
00420 Scalar result() const
00421 {
00422 return val_;
00423 }
00424
00425
00426 std::string description() const {return "Min()";}
00427
00428 private:
00429 mutable Scalar val_;
00430 };
00431
00432
00433
00434 template <class Scalar>
00435 class Max : public ReductionFunctorBase<Scalar>
00436 {
00437 public:
00438 Max(const MPIComm& comm)
00439 : ReductionFunctorBase<Scalar>(comm), val_(-HUGE_VAL) {}
00440
00441 void step(int i, const Scalar& x) const
00442 {
00443 if (x > val_) val_ = x;
00444 }
00445
00446 void postProc() const
00447 {
00448 Scalar final = val_;
00449 this->comm().allReduce(&val_, &final, 1, MPIDataType::doubleType(), MPIOp::maxOp());
00450 val_ = final;
00451 }
00452
00453 Scalar result() const
00454 {
00455 return val_;
00456 }
00457
00458
00459 std::string description() const {return "Max()";}
00460
00461 private:
00462 mutable Scalar val_;
00463 };
00464
00465
00466
00467
00468 }
00469
00470
00471 #endif
00472
00473
00474