00001
00002
00003
00004
00005
00006 #ifndef PLAYA_VECTORTESTER_HPP
00007 #define PLAYA_VECTORTESTER_HPP
00008
00009 #include "PlayaVectorDecl.hpp"
00010 #include "PlayaLinearCombinationImpl.hpp"
00011 #include "Thyra_TestSpecifier.hpp"
00012 #include "Teuchos_ScalarTraits.hpp"
00013
00014 using namespace Playa;
00015 using namespace PlayaExprTemplates;
00016 using namespace Teuchos;
00017
00018
00019
00020 namespace Playa
00021 {
00022
00023
00024
00025
00026
00027 template <class Scalar>
00028 class VectorTester
00029 {
00030 public:
00031
00032 typedef typename Teuchos::ScalarTraits<Scalar>::magnitudeType ScalarMag;
00033
00034
00035 VectorTester(const VectorSpace<Scalar>& space,
00036 const TestSpecifier<Scalar>& spec,
00037 const Playa::MPIComm& comm = Playa::MPIComm::world());
00038
00039
00040 bool runAllTests() const ;
00041
00042
00043 bool sumTest() const ;
00044
00045
00046 bool dotStarTest() const ;
00047
00048
00049 bool dotSlashTest() const ;
00050
00051
00052 bool scalarMultTest() const ;
00053
00054
00055 bool overloadedUpdateTest() const ;
00056
00057
00058 private:
00059
00060
00061 void randomizeVec(Vector<Scalar>& x) const ;
00062
00063 TestSpecifier<Scalar> spec_;
00064
00065 VectorSpace<Scalar> space_;
00066
00067 Playa::MPIComm comm_;
00068
00069 };
00070
00071 template <class Scalar>
00072 inline VectorTester<Scalar>
00073 ::VectorTester(const VectorSpace<Scalar>& space,
00074 const TestSpecifier<Scalar>& spec,
00075 const Playa::MPIComm& comm)
00076 : spec_(spec), space_(space), comm_(comm)
00077 {;}
00078
00079 template <class Scalar>
00080 inline bool VectorTester<Scalar>
00081 ::runAllTests() const
00082 {
00083 bool pass = true;
00084
00085 pass = sumTest() && pass;
00086 pass = dotStarTest() && pass;
00087 pass = dotSlashTest() && pass;
00088 pass = scalarMultTest() && pass;
00089 pass = overloadedUpdateTest() && pass;
00090
00091 return pass;
00092 }
00093
00094 template <class Scalar>
00095 inline void VectorTester<Scalar>
00096 ::randomizeVec(Vector<Scalar>& x) const
00097 {
00098 typedef Teuchos::ScalarTraits<Scalar> ST;
00099
00100
00101 SequentialIterator<Scalar> i;
00102 for (i=space_.begin(); i != space_.end(); i++)
00103 {
00104 x[i] = 2.0*(drand48()-0.5);
00105 }
00106 }
00107
00108 template <class Scalar>
00109 inline bool VectorTester<Scalar>
00110 ::sumTest() const
00111 {
00112 if (spec_.doTest())
00113 {
00114 std::cerr << "running vector addition test..." << std::endl;
00115
00116 Vector<Scalar> a = space_.createMember();
00117 Vector<Scalar> b = space_.createMember();
00118 Vector<Scalar> x = space_.createMember();
00119 Vector<Scalar> y = space_.createMember();
00120 x.zero();
00121 y.zero();
00122 cout << "x = " << x << std::endl;
00123 cout << "y = " << y << std::endl;
00124 randomizeVec(a);
00125 randomizeVec(b);
00126 cout << "a = " << a << std::endl;
00127 cout << "b = " << b << std::endl;
00128
00129
00130 for (SequentialIterator<Scalar> i=space_.begin(); i!=space_.end(); i++)
00131 {
00132 y[i] = a[i] + b[i];
00133 }
00134
00135
00136 x = a + b ;
00137
00138 cout << "op (a+b)=" << std::endl << x << std::endl;
00139 cout << "loop (a+b)=" << std::endl << y << std::endl;
00140
00141 double err = (x-y).normInf();
00142
00143 std::cerr << "|sum error|=" << err << std::endl;
00144 if (err > spec_.errorTol())
00145 {
00146 std::cerr << "vector sum test FAILED: tol = "
00147 << spec_.errorTol() << std::endl;
00148 return false;
00149 }
00150 else if (err > spec_.warningTol())
00151 {
00152 std::cerr << "WARNING: vector sum test could not beat tol = "
00153 << spec_.warningTol() << std::endl;
00154 }
00155
00156 }
00157 else
00158 {
00159 std::cerr << "skipping vector addition test..." << std::endl;
00160 }
00161 std::cerr << "vector addition test PASSED: tol = "
00162 << spec_.errorTol() << std::endl;
00163 return true;
00164 }
00165
00166
00167
00168
00169
00170 template <class Scalar>
00171 inline bool VectorTester<Scalar>
00172 ::dotStarTest() const
00173 {
00174 if (spec_.doTest())
00175 {
00176 std::cerr << "running vector dotStar test..." << std::endl;
00177
00178 Vector<Scalar> a = space_.createMember();
00179 Vector<Scalar> b = space_.createMember();
00180 Vector<Scalar> x = space_.createMember();
00181 Vector<Scalar> y = space_.createMember();
00182 randomizeVec(a);
00183 randomizeVec(b);
00184
00185
00186
00187 x = a.dotStar(b);
00188
00189
00190 for (SequentialIterator<Scalar> i=space_.begin(); i!=space_.end(); i++)
00191 {
00192 y[i] = a[i] * b[i];
00193 }
00194
00195 double err = (x-y).normInf();
00196
00197 std::cerr << "|dotStar error|=" << err << std::endl;
00198 if (err > spec_.errorTol())
00199 {
00200 std::cerr << "vector dotStar test FAILED: tol = "
00201 << spec_.errorTol() << std::endl;
00202 return false;
00203 }
00204 else if (err > spec_.warningTol())
00205 {
00206 std::cerr << "WARNING: vector dotStar test could not beat tol = "
00207 << spec_.warningTol() << std::endl;
00208 }
00209
00210 }
00211 else
00212 {
00213 std::cerr << "skipping vector dotStar test..." << std::endl;
00214 }
00215 std::cerr << "vector dotStar test PASSED: tol = "
00216 << spec_.errorTol() << std::endl;
00217 return true;
00218 }
00219
00220
00221 template <class Scalar>
00222 inline bool VectorTester<Scalar>
00223 ::dotSlashTest() const
00224 {
00225 if (spec_.doTest())
00226 {
00227 std::cerr << "running vector dotSlash test..." << std::endl;
00228
00229 Vector<Scalar> a = space_.createMember();
00230 Vector<Scalar> b = space_.createMember();
00231 Vector<Scalar> x = space_.createMember();
00232 Vector<Scalar> y = space_.createMember();
00233 randomizeVec(a);
00234 randomizeVec(b);
00235
00236
00237
00238 x = a.dotSlash(b);
00239
00240
00241
00242 for (SequentialIterator<Scalar> i=space_.begin(); i!=space_.end(); i++)
00243 {
00244 y[i] = a[i] / b[i];
00245 }
00246
00247 double err = (x-y).normInf();
00248
00249 std::cerr << "|dotSlash error|=" << err << std::endl;
00250 if (err > spec_.errorTol())
00251 {
00252 std::cerr << "vector dotSlash test FAILED: tol = "
00253 << spec_.errorTol() << std::endl;
00254 return false;
00255 }
00256 else if (err > spec_.warningTol())
00257 {
00258 std::cerr << "WARNING: vector dotSlash test could not beat tol = "
00259 << spec_.warningTol() << std::endl;
00260 }
00261
00262 }
00263 else
00264 {
00265 std::cerr << "skipping vector dotSlash test..." << std::endl;
00266 }
00267 std::cerr << "vector dotSlash test PASSED: tol = "
00268 << spec_.errorTol() << std::endl;
00269 return true;
00270 }
00271
00272
00273 template <class Scalar>
00274 inline bool VectorTester<Scalar>
00275 ::scalarMultTest() const
00276 {
00277 if (spec_.doTest())
00278 {
00279 std::cerr << "running vector scalarMult test..." << std::endl;
00280
00281 Vector<Scalar> a = space_.createMember();
00282 Vector<Scalar> x = space_.createMember();
00283 Vector<Scalar> y = space_.createMember();
00284 randomizeVec(a);
00285
00286
00287
00288 x = 3.14*a;
00289
00290
00291 for (SequentialIterator<Scalar> i=space_.begin(); i!=space_.end(); i++)
00292 {
00293 y[i] = 3.14 * a[i];
00294 }
00295
00296 double err = (x-y).normInf();
00297
00298 std::cerr << "|scalarMult error|=" << err << std::endl;
00299 if (err > spec_.errorTol())
00300 {
00301 std::cerr << "vector scalarMult test FAILED: tol = "
00302 << spec_.errorTol() << std::endl;
00303 return false;
00304 }
00305 else if (err > spec_.warningTol())
00306 {
00307 std::cerr << "WARNING: vector scalarMult test could not beat tol = "
00308 << spec_.warningTol() << std::endl;
00309 }
00310
00311 }
00312 else
00313 {
00314 std::cerr << "skipping vector scalarMult test..." << std::endl;
00315 }
00316 std::cerr << "vector scalarMult test PASSED: tol = "
00317 << spec_.errorTol() << std::endl;
00318 return true;
00319 }
00320
00321 template <class Scalar>
00322 inline bool VectorTester<Scalar>
00323 ::overloadedUpdateTest() const
00324 {
00325 if (spec_.doTest())
00326 {
00327 std::cerr << "running vector overloadedUpdate test..." << std::endl;
00328
00329 Vector<Scalar> a = space_.createMember();
00330 Vector<Scalar> b = space_.createMember();
00331 Vector<Scalar> x = space_.createMember();
00332 Vector<Scalar> y = space_.createMember();
00333 randomizeVec(a);
00334 randomizeVec(b);
00335
00336
00337
00338 x = 3.14*a + 1.4*b;
00339
00340
00341 for (SequentialIterator<Scalar> i=space_.begin(); i!=space_.end(); i++)
00342 {
00343 y[i] = 3.14*a[i] + 1.4*b[i];
00344 }
00345
00346 double err = (x-y).normInf();
00347
00348 std::cerr << "|overloadedUpdate error|=" << err << std::endl;
00349 if (err > spec_.errorTol())
00350 {
00351 std::cerr << "vector overloadedUpdate test FAILED: tol = "
00352 << spec_.errorTol() << std::endl;
00353 return false;
00354 }
00355 else if (err > spec_.warningTol())
00356 {
00357 std::cerr << "WARNING: vector overloadedUpdate test could not beat tol = "
00358 << spec_.warningTol() << std::endl;
00359 }
00360
00361 }
00362 else
00363 {
00364 std::cerr << "skipping vector overloadedUpdate test..." << std::endl;
00365 }
00366 std::cerr << "vector overloadedUpdate test PASSED: tol = "
00367 << spec_.errorTol() << std::endl;
00368 return true;
00369 }
00370
00371
00372
00373 }
00374 #endif