Thyra  Version of the Day
Thyra_VectorStdOpsTester_def.hpp
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Thyra: Interfaces and Support for Abstract Numerical Algorithms
5 // Copyright (2004) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Roscoe A. Bartlett (bartlettra@ornl.gov)
38 //
39 // ***********************************************************************
40 // @HEADER
41 
42 #ifndef THYRA_VECTOR_STD_OPS_TESTER_HPP
43 #define THYRA_VECTOR_STD_OPS_TESTER_HPP
44 
45 #include "Thyra_VectorStdOpsTester_decl.hpp"
46 #include "Thyra_TestingTools.hpp"
47 #include "RTOpPack_TOpSetAssendingValues.hpp"
48 #include "Teuchos_TestingHelpers.hpp"
49 #include "Teuchos_Assert.hpp"
50 
51 //#define THYRA_VECTOR_STD_OPS_TESTER_DUMP
52 
53 #ifdef THYRA_VECTOR_STD_OPS_TESTER_DUMP
54 # include "RTOpPack_SPMD_apply_op.hpp"
55 #endif // THYRA_VECTOR_STD_OPS_TESTER_DUMP
56 
57 
58 namespace Thyra {
59 
60 
61 // VectorStdOpsTesterComparable (using partial specialization to only do tests in some cases)
62 
63 
64 template <bool isComparable, class Scalar>
65 class VectorStdOpsTesterComparable {
66 public:
67  static bool checkComparableStdOps(
68  const VectorSpaceBase<Scalar> &vecSpc,
69  const Ptr<VectorBase<Scalar> > &z,
70  const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &error_tol,
71  const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &warning_tol,
72  const Ptr<std::ostream> &out,
73  const bool &dumpAll
74  )
75  {
76  return Teuchos::ScalarTraits<Scalar>::ThisShouldNotCompile();
77  }
78 };
79 
80 
81 template <class Scalar>
82 class VectorStdOpsTesterComparable<false,Scalar> {
83 public:
84  static bool checkComparableStdOps(
85  const VectorSpaceBase<Scalar> &vecSpc,
86  const Ptr<VectorBase<Scalar> > &z,
87  const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &error_tol,
88  const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &warning_tol,
89  const Ptr<std::ostream> &out,
90  const bool &dumpAll
91  )
92  {
93  if (nonnull(out)) *out
94  << "\nThis scalar type does not support comparable operations so"
95  << " we can not test min(), max() and other such functions.\n";
96  return true;
97  }
98 };
99 
100 
101 template <class Scalar>
102 class VectorStdOpsTesterComparable<true,Scalar> {
103 public:
104  static bool checkComparableStdOps(
105  const VectorSpaceBase<Scalar> &vecSpc,
106  const Ptr<VectorBase<Scalar> > &z,
107  const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &error_tol,
108  const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &warning_tol,
109  const Ptr<std::ostream> &out,
110  const bool &dumpAll
111  )
112  {
113  typedef Teuchos::ScalarTraits<Scalar> ST;
114  using Teuchos::outArg;
115 
116  bool success = true, result;
117 
118  if (nonnull(out)) *out << "\nTesting comparable operations ...\n";
119 
120  const Scalar scalarSmall(1e-5), scalarMedium(2.0), scalarLarge(100.0);
121  if (nonnull(out)) *out << "\nassign(z.ptr(),"<<scalarMedium<<");\n";
122  assign(z.ptr(),Scalar(scalarMedium));
123  if(nonnull(out) && dumpAll) *out << "\nz =\n" << *z;
124  if (nonnull(out)) *out << "\nset_ele(0,"<<scalarSmall<<",z.ptr());\n";
125  set_ele(0,scalarSmall,z.ptr());
126  if(nonnull(out) && dumpAll) *out << "\nz =\n" << *z;
127  if (nonnull(out)) *out << "\nset_ele(1,"<<scalarLarge<<",z.ptr());\n";
128  set_ele(1,scalarLarge,z.ptr());
129  if(nonnull(out) && dumpAll) *out << "\nz =\n" << *z;
130  if (nonnull(out)) *out << "\nset_ele(vecSpc.dim()-2,"<<scalarSmall<<",z.ptr());\n";
131  set_ele(vecSpc.dim()-2,scalarSmall,z.ptr());
132  if(nonnull(out) && dumpAll) *out << "\nz =\n" << *z;
133  if (nonnull(out)) *out << "\nset_ele(vecSpc.dim()-1,"<<scalarLarge<<",z.ptr());\n";
134  set_ele(vecSpc.dim()-1,scalarLarge,z.ptr());
135  if(nonnull(out) && dumpAll) *out << "\nz =\n" << *z;
136 
137  Scalar minEle; Ordinal minIndex;
138  Scalar maxEle; Ordinal maxIndex;
139 
140  if(!Teuchos::testRelErr<Scalar>(
141  "min(*z)",min(*z),"scalarSmall",scalarSmall
142  ,"error_tol",error_tol,"warning_tol",warning_tol,out
143  )
144  ) success=false;
145 
146  if (nonnull(out)) *out << "\nmin(*z,&minEle,&minIndex);\n";
147  minEle = ST::zero(); minIndex = 0;
148  min(*z, outArg(minEle), outArg(minIndex));
149  if(!Teuchos::testRelErr<Scalar>(
150  "minEle",minEle,"scalarSmall",scalarSmall
151  ,"error_tol",error_tol,"warning_tol",warning_tol, out
152  )
153  ) success=false;
154  result = minIndex == 0;
155  if (nonnull(out)) *out << "\nminIndex = " << minIndex << " == 0 ? " << passfail(result) << std::endl;
156  if(!result) success = false;
157 
158  if (nonnull(out)) *out << "\nminGreaterThanBound(*z,"<<scalarMedium<<",&minEle,&minIndex);\n";
159  minEle = ST::zero(); minIndex = 0;
160  minGreaterThanBound(*z, scalarMedium, outArg(minEle), outArg(minIndex));
161  if(!Teuchos::testRelErr<Scalar>(
162  "minEle",minEle,"scalarLarge",scalarLarge
163  ,"error_tol",error_tol,"warning_tol",warning_tol,out
164  )
165  ) success=false;
166  result = minIndex == 1;
167  if (nonnull(out)) *out << "\nminIndex = " << minIndex << " == 1 ? " << passfail(result) << std::endl;
168  if(!result) success = false;
169 
170  if (nonnull(out)) *out << "\nminGreaterThanBound(*z,"<<scalarLarge<<",&minEle,&minIndex);\n";
171  minEle = ST::zero(); minIndex = 0;
172  minGreaterThanBound(*z,scalarLarge, outArg(minEle), outArg(minIndex));
173  result = minIndex < 0;
174  if (nonnull(out)) *out << "\nminIndex = " << minIndex << " < 0 ? " << passfail(result) << std::endl;
175  if(!result) success = false;
176 
177  if(!Teuchos::testRelErr<Scalar>(
178  "max(*z)",max(*z),"scalarLarge",scalarLarge
179  ,"error_tol",error_tol,"warning_tol",warning_tol,out)
180  ) success=false;
181 
182  if (nonnull(out)) *out << "\nmax(*z,&maxEle,&maxIndex);\n";
183  maxEle = ST::zero(); maxIndex = 0;
184  max(*z, outArg(maxEle), outArg(maxIndex));
185  if(!Teuchos::testRelErr<Scalar>(
186  "maxEle",maxEle,"scalarLarge",scalarLarge
187  ,"error_tol",error_tol,"warning_tol",warning_tol,out)
188  ) success=false;
189  result = maxIndex == 1;
190  if (nonnull(out)) *out << "\nmaxIndex = " << maxIndex << " == 1 ? " << passfail(result) << std::endl;
191  if(!result) success = false;
192 
193  if (nonnull(out)) *out << "\nmaxLessThanBound(*z,"<<scalarMedium<<",&maxEle,&maxIndex);\n";
194  maxEle = ST::zero(); maxIndex = 0;
195  maxLessThanBound(*z, scalarMedium, outArg(maxEle), outArg(maxIndex));
196  if(!Teuchos::testRelErr<Scalar>(
197  "maxEle",maxEle,"scalarSmall",scalarSmall
198  ,"error_tol",error_tol,"warning_tol",warning_tol,out)
199  ) success=false;
200  result = maxIndex == 0;
201  if (nonnull(out)) *out << "\nmaxIndex = " << maxIndex << " == 0 ? " << passfail(result) << std::endl;
202  if(!result) success = false;
203 
204  if (nonnull(out)) *out << "\nmaxLessThanBound(*z,"<<scalarSmall<<",&maxEle,&maxIndex);\n";
205  maxEle = ST::zero(); maxIndex = 0;
206  maxLessThanBound(*z, scalarSmall, outArg(maxEle), outArg(maxIndex));
207  result = ( maxIndex < 0 );
208  if (nonnull(out)) *out << "\nmaxIndex = " << maxIndex << " < 0 ? " << passfail(result) << std::endl;
209  if(!result) success = false;
210 
211  return success;
212  }
213 };
214 
215 
216 // Other helpers
217 
218 
219 template<class Scalar>
220 void setEleTestCase( const Ptr<VectorBase<Scalar> > &z, const Ordinal i, int &tc,
221  std::ostream &out, bool &success)
222 {
223  using Teuchos::as;
224  out << "\n"<<tc<<") set_ele(z, "<<i<<");\n";
225  ++tc;
226  {
227  typedef ScalarTraits<Scalar> ST;
228  const Scalar val_i = as<Scalar>(i+1);
229  assign<Scalar>(z, ST::zero());
230  set_ele(i, val_i, z);
231  TEUCHOS_TEST_EQUALITY_CONST(get_ele(*z, i), val_i, out, success);
232  TEUCHOS_TEST_EQUALITY_CONST(sum(*z), val_i, out, success);
233  }
234 }
235 
236 
237 // VectorStdOpsTester
238 
239 
240 template <class Scalar>
242  const ScalarMag &warning_tol_in,
243  const ScalarMag &error_tol_in
244  )
245  :warning_tol_(warning_tol_in),
246  error_tol_(error_tol_in)
247 {}
248 
249 
250 template <class Scalar>
252  const VectorSpaceBase<Scalar> &vecSpc,
253  std::ostream *out_out,
254  const bool &dumpAll
255  )
256 {
257  using Teuchos::as;
258  using Teuchos::tuple;
259  using Teuchos::null;
260  using Teuchos::outArg;
261  using Teuchos::inOutArg;
262  typedef Teuchos::ScalarTraits<Scalar> ST;
263 
264  TEUCHOS_ASSERT(out_out);
265  std::ostream &out = *out_out;
266 
267  out << "\n*** Entering VectorStdOpsTester<"<<ST::name()<<">::checkStdOps(...) ...\n"
268  << "using a \'" << vecSpc.description() << "\' object ...\n";
269 
270  bool success = true;
271  out << "\nvecSpc.dim() = " << vecSpc.dim() << std::endl;
272 
273  const Ordinal n = vecSpc.dim();
274 
275  TEUCHOS_TEST_FOR_EXCEPTION( n < 4, std::logic_error,
276  "Error: n = "<<n<<" must be least 4 or greater to"
277  " run Thyra::VectorStdOpsTester::checkStdOps(...)!" );
278 
279  const Scalar
280  two = as<Scalar>(2.0),
281  three = as<Scalar>(3.0),
282  four = as<Scalar>(4.0);
283 
284  int tc = 0;
285 
286  out << "\nCreating vectors v1, v2, v3, v4, x and z ...\n";
287  Teuchos::RCP<VectorBase<Scalar> >
288  v1 = createMember(vecSpc),
289  v2 = createMember(vecSpc),
290  v3 = createMember(vecSpc),
291  v4 = createMember(vecSpc),
292  y = createMember(vecSpc),
293  x = createMember(vecSpc),
294  z = createMember(vecSpc);
295 
296  out << "\nassign(v1.ptr(), -2.0);\n";
297  assign<Scalar>(v1.ptr(), -two);
298  out << "\nassign(v2.ptr(), -3.0);\n";
299  assign<Scalar>(v2.ptr(), -three);
300  out << "\nassign(v3.ptr(), -4.0);\n";
301  assign<Scalar>(v3.ptr(), -four);
302  out << "\ny[i] = i+1\n";
303  {
304  RTOpPack::TOpSetAssendingValues<Scalar> setAssendOp(ST::zero());
305  applyOp<Scalar>( setAssendOp,
306  ArrayView<const Ptr<const VectorBase<Scalar> > >(null),
307  tuple<Ptr<VectorBase<Scalar> > >(y.ptr())(),
308  null );
309  }
310 
311  // sum
312  out << "\n"<<tc<<") sum(*y);\n";
313  ++tc;
314  TEUCHOS_TEST_ASSERT(
315  Teuchos::testRelErr<Scalar>(
316  "sum(*y)", sum(*y),
317  "0.5*(n+1)*n", as<Scalar>(0.5*(n+1)*n),
318  "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
319  out, success);
320 
321  // norm_inf
322  out << "\n"<<tc<<") nom_inf(*v1);\n";
323  ++tc;
324  TEUCHOS_TEST_ASSERT(
325  Teuchos::testRelErr<Scalar>(
326  "norm_inf(*v1)", norm_inf(*v1),
327  "2.0", two,
328  "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
329  out, success);
330 
331  // norm_2
332  out << "\n"<<tc<<") norm_2(*v1);\n";
333  ++tc;
334  TEUCHOS_TEST_ASSERT(
335  Teuchos::testRelErr<Scalar>(
336  "norm_2(*v1)", norm_2(*v1),
337  "2.0*sqrt(vecSpc.dim())", as<Scalar>(2.0)*ST::squareroot(vecSpc.dim()),
338  "error_tol", error_tol(), "warning_tol",warning_tol(), inOutArg(out)),
339  out, success);
340 
341  // norm_1
342  out << "\n"<<tc<<") norm_1(*v1);\n";
343  ++tc;
344  TEUCHOS_TEST_ASSERT(
345  Teuchos::testRelErr<Scalar>(
346  "norm_1(*v1)" ,norm_1(*v1),
347  "2.0*vecSpc.dim()", as<Scalar>(2.0)*as<Scalar>(vecSpc.dim()),
348  "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
349  out, success);
350 
351  // abs
352  out << "\n"<<tc<<") abs(z.ptr(),*v1);\n";
353  ++tc;
354  {
355  abs<Scalar>(*v1, z.ptr());
356  if(!Teuchos::testRelErr<Scalar>(
357  "sum(*z)", sum(*z), "2.0*vecSpc.dim()", as<Scalar>(2.0)*as<Scalar>(vecSpc.dim()),
358  "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out))
359  ) success=false;
360  }
361 
362  // get_ele
363 
364  out << "\n"<<tc<<") val = get_ele(y, 0);\n";
365  ++tc;
366  {
367  const Scalar val = get_ele<Scalar>(*y, 0);
368  TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(1), out, success );
369  }
370 
371  out << "\n"<<tc<<") val = get_ele<Scalar>(*y, 1);\n";
372  ++tc;
373  {
374  const Scalar val = get_ele<Scalar>(*y, 1);
375  TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(2), out, success );
376  }
377 
378  out << "\n"<<tc<<") val = get_ele<Scalar>(*y, n-2);\n";
379  ++tc;
380  {
381  const Scalar val = get_ele<Scalar>(*y, n-2);
382  TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(n-1), out, success );
383  }
384 
385  out << "\n"<<tc<<") val = get_ele<Scalar>(*y, n-1);\n";
386  ++tc;
387  {
388  const Scalar val = get_ele<Scalar>(*y, n-1);
389  TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(n), out, success );
390  }
391 
392 #ifdef THYRA_DEBUG
393 
394  out << "\n"<<tc<<") get_ele<Scalar>(*y, -1);\n";
395  ++tc;
396  {
397  TEUCHOS_TEST_THROW(get_ele<Scalar>(*y, -1), std::out_of_range, out, success );
398  }
399 
400  out << "\n"<<tc<<") get_ele<Scalar>(*y, n);\n";
401  ++tc;
402  {
403  TEUCHOS_TEST_THROW(get_ele<Scalar>(*y, n), std::out_of_range, out, success );
404  }
405 
406 #endif // THYRA_DEBUG
407 
408  // set_ele
409 
410  setEleTestCase<Scalar>(z.ptr(), 0, tc, out, success);
411 
412  setEleTestCase<Scalar>(z.ptr(), 1, tc, out, success);
413 
414  setEleTestCase<Scalar>(z.ptr(), n-2, tc, out, success);
415 
416  setEleTestCase<Scalar>(z.ptr(), n-1, tc, out, success);
417 
418 #ifdef THYRA_DEBUG
419 
420  TEUCHOS_TEST_THROW(set_ele(-1, two, z.ptr()),
421  std::out_of_range, out, success);
422 
423  TEUCHOS_TEST_THROW(set_ele(n, two, z.ptr()),
424  std::out_of_range, out, success);
425 
426 #endif // THYRA_DEBUG
427 
428  // reciprocal
429  out << "\n"<<tc<<") reciprocal(z.ptr(),*v1);\n";
430  ++tc;
431  {
432  reciprocal(*v1, z.ptr());
433  if(!Teuchos::testRelErr<Scalar>(
434  "sum(*z)",sum(*z),"-0.5*vecSpc.dim()",as<Scalar>(-0.5)*as<Scalar>(vecSpc.dim())
435  ,"error_tol",error_tol(),"warning_tol",warning_tol(),inOutArg(out))
436  ) success=false;
437  }
438 
439  // linear_combination
440 
441  out << "\n"<<tc<<") linear_combination(2,{0.5,0.25},{v1.ptr(),v2.ptr()},0.0,z.ptr());\n";
442  ++tc;
443  {
444  linear_combination<Scalar>(
445  tuple<Scalar>(0.5, 0.25)(),
446  tuple<Ptr<const VectorBase<Scalar> > >(v1.ptr(), v2.ptr())(),
447  ST::zero(),
448  z.ptr());
449  TEUCHOS_TEST_ASSERT(
450  Teuchos::testRelErr<Scalar>(
451  "sum(*z)", sum(*z),
452  "(-0.5*2.0-0.25*3.0)*vecSpc.dim()", as<Scalar>((-0.5 * 2.0 - 0.25 * 3.0) *vecSpc.dim()),
453  "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
454  out, success);
455  }
456 
457  out << "\nassign(z.ptr(), 2.0);\n";
458  ++tc;
459  assign(z.ptr(), as<Scalar>(2.0));
460 
461  out << "\n"<<tc<<") linear_combination(3,{0.5,0.25,0.125},{v1.ptr(),v2.ptr(),v2.ptr()},0.5,z.ptr());\n";
462  ++tc;
463  {
464  linear_combination<Scalar>(
465  tuple<Scalar>(0.5, 0.25, 0.125)(),
466  tuple<Ptr<const VectorBase<Scalar> > >(v1.ptr(), v2.ptr(), v3.ptr())(),
467  as<Scalar>(0.5),
468  z.ptr());
469  if(!Teuchos::testRelErr<Scalar>(
470  "sum(*z)", sum(*z),
471  "(0.5*2.0-0.5*2.0-0.25*3.0-0.125*4.0)*vecSpc.dim()",
472  as<Scalar>(0.5*2.0-0.5*2.0-0.25*3.0-0.125*4.0)*as<Scalar>(vecSpc.dim()),
473  "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)
474  )
475  ) success=false;
476  }
477 
478  // assgin
479  out << "\n"<<tc<<") assign(z.ptr(),2.0);\n";
480  ++tc;
481  {
482  assign(z.ptr(),as<Scalar>(2.0));
483  if(!Teuchos::testRelErr<Scalar>(
484  "norm_2(*z,*v2)",norm_2(*z,*v2)
485  ,"sqrt(2.0*3.0*3.0*vecSpc.dim())",ST::magnitude(ST::squareroot(as<Scalar>(2.0*3.0*3.0)*as<Scalar>(vecSpc.dim())))
486  ,"error_tol",error_tol(),"warning_tol",warning_tol(),inOutArg(out)
487  )
488  ) success=false;
489 
490  if(!VectorStdOpsTesterComparable<ST::isComparable,Scalar>::checkComparableStdOps(
491  vecSpc,z.ptr(),error_tol(),warning_tol(),inOutArg(out),dumpAll)
492  ) success=false;
493  }
494 
495  // Test Vt_S
496  out << "\n"<<tc<<") Testing Vt_S(z.ptr(),alpha) ...\n";
497  ++tc;
498  {
499 #ifdef THYRA_VECTOR_STD_OPS_TESTER_DUMP
500  RTOpPack::show_spmd_apply_op_dump = true;
501 #endif // THYRA_VECTOR_STD_OPS_TESTER_DUMP
502  v1 = createMember(vecSpc);
503  v2 = createMember(vecSpc);
504  const Scalar alpha = as<Scalar>(1.2345);
505  seed_randomize<Scalar>(12345);
506  randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr());
507  V_V(v2.ptr(),*v1);
508  Vt_S(v1.ptr(), alpha);
509  const Scalar norm_alpha_v1 = norm_2(*v1);
510  //out << "norm_alpha_v1 = " << norm_alpha_v1 << "\n";
511  const Scalar mag_alpha = ST::magnitude(alpha);
512  //out << "mag_alpha = " << mag_alpha << "\n";
513  const Scalar norm_2_v2 = norm_2(*v2);
514  //out << "norm_2_v2 = " << norm_2_v2 << "\n";
515  const Scalar alpha_norm_v1 = mag_alpha * norm_2_v2;
516  //out << "alpha_norm_v1 = " << alpha_norm_v1 << "\n";
517  if(!testMaxErr<Scalar>(
518  "norm_alpha_v1 - alpha_norm_v1",ST::magnitude(norm_alpha_v1-alpha_norm_v1)
519  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
520  )
521  ) success=false;
522 #ifdef THYRA_VECTOR_STD_OPS_TESTER_DUMP
523  RTOpPack::show_spmd_apply_op_dump = false;
524 #endif // THYRA_VECTOR_STD_OPS_TESTER_DUMP
525  }
526 
527  // Test V_StV
528  out << "\n"<<tc<<") Testing V_StV(z.ptr(),alpha,*v) ...\n";
529  ++tc;
530  {
531  v1 = createMember(vecSpc);
532  v2 = createMember(vecSpc);
533  z = createMember(vecSpc);
534  const Scalar alpha = as<Scalar>(-1.2345);
535  seed_randomize<Scalar>(12345);
536  randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr());
537  V_StV(v2.ptr(),alpha,*v1);
538  Vt_S(v1.ptr(),alpha);
539  V_V(z.ptr(),*v1);
540  Vp_V(z.ptr(),*v2,as<Scalar>(-ST::one()));
541  if(!testMaxErr<Scalar>(
542  "norm_2(*z)",norm_2(*z)
543  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
544  )
545  ) success=false;
546  }
547 
548  // Test Vp_StV
549  out << "\n"<<tc<<") Testing Vp_StV(z.ptr(),alpha,*v) ...\n";
550  ++tc;
551  {
552  v1 = createMember(vecSpc);
553  v2 = createMember(vecSpc);
554  v3 = createMember(vecSpc);
555  z = createMember(vecSpc);
556  const Scalar alpha = as<Scalar>(-1.2345);
557  seed_randomize<Scalar>(12345);
558  randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
559  randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
560  V_V(v3.ptr(),*v1); // v3 = v1
561  Vp_StV(v1.ptr(),alpha,*v2); // v1 += alpha*v2
562  V_StV(z.ptr(),alpha,*v2); // z = alpha*v2
563  Vp_V(z.ptr(),*v3); // z += v3
564  V_V(v3.ptr(),*v1); // v3 = v1
565  Vp_V(v3.ptr(),*z,as<Scalar>(-ST::one())); // v3 -= z
566  if(!testMaxErr<Scalar>(
567  "norm_2(*v3)",norm_2(*v3)
568  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
569  )
570  ) success=false;
571  }
572 
573  // Test ele_wise_prod
574  out << "\n"<<tc<<") Testing ele_wise_prod(alpha,*v1, *v2, z.ptr()) ...\n";
575  ++tc;
576  {
577  v1 = createMember(vecSpc);
578  v2 = createMember(vecSpc);
579  v3 = createMember(vecSpc);
580  z = createMember(vecSpc);
581  const Scalar alpha = as<Scalar>(-1.2345);
582  seed_randomize<Scalar>(12345);
583  randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
584  randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
585  randomize(as<Scalar>(-ST::one()),ST::one(),v3.ptr()); // v3 = rand
586  V_V(v4.ptr(), *v1); // v4 = v1
587  V_V(z.ptr(), *v2); // z = v2
588  ele_wise_prod(alpha, *v2, *v3, v1.ptr()); // v1 += alpha * v2 * v3
589  ele_wise_prod_update(alpha, *v3, z.ptr()); // z *= alpha * v3
590  Vp_V(z.ptr(), *v4); // z += v4
591  V_V(v2.ptr(), *v1); // v2 = v1
592  Vp_V(v2.ptr(), *z, as<Scalar>(-ST::one())); // v2 -= z
593  if(!testMaxErr<Scalar>(
594  "norm_2(*v2)",norm_2(*v2)
595  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
596  )
597  ) success=false;
598  }
599 
600  // Test ele_wise_scale
601  out << "\n"<<tc<<") Testing ele_wise_scale(*v1, z.ptr()) ...\n";
602  ++tc;
603  {
604  v1 = createMember(vecSpc);
605  z = createMember(vecSpc);
606  V_S(v1.ptr(), as<Scalar>(2.0));
607  V_S(z.ptr(), as<Scalar>(3.0));
608  ele_wise_scale( *v1, z.ptr() );
609  if (!Teuchos::testRelErr<Scalar>(
610  "norm_2(*z)", norm_2(*z),
611  "ST::squareroot(n*sqr(3.0*2.0))", ST::squareroot(n*36.0),
612  "error_tol", error_tol(),
613  "warning_tol", warning_tol(),
614  inOutArg(out)
615  )
616  ) success=false;
617  }
618 
619  // Test Vt_StV
620  out << "\n"<<tc<<") Testing Vt_StV(z.ptr(), alpha, *v) ...\n";
621  ++tc;
622  {
623  v1 = createMember(vecSpc);
624  v2 = createMember(vecSpc);
625  v3 = createMember(vecSpc);
626  z = createMember(vecSpc);
627  const Scalar alpha = as<Scalar>(-1.2345);
628  seed_randomize<Scalar>(12345);
629  randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
630  randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
631  V_V(v3.ptr(),*v1); // v3 = v1
632  Vt_StV(v1.ptr(),alpha,*v2); // v1 *= alpha*v2
633  V_S(z.ptr(),ST::zero()); // z = 0
634  Vp_StVtV(z.ptr(),alpha,*v3,*v2); // z += alpha*v3*v2
635  V_V(v2.ptr(),*v1); // v2 = v1
636  Vp_V(v2.ptr(),*z,as<Scalar>(-ST::one())); // v2 -= z
637  if(!testMaxErr<Scalar>(
638  "norm_2(*v2)",norm_2(*v2)
639  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
640  )
641  ) success=false;
642  }
643 
644  // Test V_StVpV
645  out << "\n"<<tc<<") Testing V_StVpV(z.ptr(),alpha,*v1,*v2) ...\n";
646  ++tc;
647  {
648  v1 = createMember(vecSpc);
649  v2 = createMember(vecSpc);
650  v3 = createMember(vecSpc);
651  x = createMember(vecSpc);
652  z = createMember(vecSpc);
653  const Scalar alpha = as<Scalar>(1.2345);
654  seed_randomize<Scalar>(12345);
655  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v1.ptr());
656  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
657  V_StVpV(v3.ptr(),alpha,*v1,*v2);
658  V_V(z.ptr(),*v1);
659  Vp_V(z.ptr(),*v2,alpha);
660  V_V(x.ptr(),*v3);
661  Vp_V(x.ptr(),*z,as<Scalar>(-ST::one()));
662  if(!testMaxErr<Scalar>(
663  "norm_2(*x)",norm_2(*x)
664  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
665  )
666  ) success=false;
667  }
668 
669  // Test V_VpStV
670  out << "\n"<<tc<<") Testing V_VpStV(z.ptr(),*v1,alpha,*v2) ...\n";
671  ++tc;
672  {
673  v1 = createMember(vecSpc);
674  v2 = createMember(vecSpc);
675  v3 = createMember(vecSpc);
676  x = createMember(vecSpc);
677  z = createMember(vecSpc);
678  const Scalar alpha = as<Scalar>(1.2345);
679  seed_randomize<Scalar>(12345);
680  randomize<Scalar>(as<Scalar>(as<Scalar>(-10)*ST::one()),
681  as<Scalar>(as<Scalar>(10)*ST::one()), v1.ptr());
682  randomize<Scalar>(as<Scalar>(as<Scalar>(-10)*ST::one()),
683  as<Scalar>(as<Scalar>(10)*ST::one()), v2.ptr());
684  V_VpStV(outArg(*v3), *v1, alpha, *v2);
685  V_V(z.ptr(), *v1);
686  Vp_StV(z.ptr(), alpha, *v2);
687  V_VmV(outArg(*x), *z, *v3);
688  if(!testMaxErr<Scalar>(
689  "norm_2(*x)",norm_2(*x)
690  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
691  )
692  ) success=false;
693  }
694 
695  // Test V_StVpStV
696  out << "\n"<<tc<<") Testing V_StVpStV(z.ptr(),alpha,*v1,beta,*v2) ...\n";
697  ++tc;
698  {
699  v1 = createMember(vecSpc);
700  v2 = createMember(vecSpc);
701  v3 = createMember(vecSpc);
702  x = createMember(vecSpc);
703  z = createMember(vecSpc);
704  const Scalar alpha = as<Scalar>(1.2345);
705  const Scalar beta = as<Scalar>(5.4321);
706  seed_randomize<Scalar>(12345);
707  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v1.ptr());
708  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
709  V_StVpStV(v3.ptr(),alpha,*v1,beta,*v2);
710  V_StV(z.ptr(),alpha,*v1);
711  Vp_StV(z.ptr(),beta,*v2);
712  V_V(x.ptr(),*v3);
713  Vp_V(x.ptr(),*z,as<Scalar>(-ST::one()));
714  if(!testMaxErr<Scalar>(
715  "norm_2(*x)",norm_2(*x)
716  ,"10*error_tol",ScalarMag(ScalarMag(10)*error_tol()),"warning_tol",warning_tol(),&out
717  )
718  ) success=false;
719  }
720 
721  // Test Vp_V
722  out << "\n"<<tc<<") Testing Vp_V(v1.ptr(),*v2,beta) ...\n";
723  ++tc;
724  {
725  v1 = createMember(vecSpc);
726  v2 = createMember(vecSpc);
727  v3 = createMember(vecSpc);
728  x = createMember(vecSpc);
729  z = createMember(vecSpc);
730  const Scalar alpha = as<Scalar>(-2.0);
731  const Scalar beta = as<Scalar>(10.0);
732  V_S(v1.ptr(),alpha);
733  seed_randomize<Scalar>(12345);
734  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
735  Vp_V(v1.ptr(),*v2,beta);
736  V_S(v3.ptr(),alpha);
737  V_StVpV(z.ptr(),beta,*v3,*v2);
738  V_StVpV(x.ptr(),as<Scalar>(-ST::one()),*z,*v1);
739  if(!testMaxErr<Scalar>(
740  "norm_2(*x)",norm_2(*x)
741  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
742  )
743  ) success=false;
744  }
745 
746  // Test Vp_V
747  out << "\n"<<tc<<") Testing Vp_V(v1.ptr(),*v2) ...\n";
748  ++tc;
749  {
750  v1 = createMember(vecSpc);
751  v2 = createMember(vecSpc);
752  v3 = createMember(vecSpc);
753  x = createMember(vecSpc);
754  z = createMember(vecSpc);
755  const Scalar alpha = as<Scalar>(-2.0);
756  V_S(v1.ptr(),alpha);
757  seed_randomize<Scalar>(12345);
758  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
759  Vp_V(v1.ptr(),*v2);
760  V_S(v3.ptr(),alpha);
761  V_StVpV(z.ptr(),ST::one(),*v3,*v2);
762  V_StVpV(x.ptr(),as<Scalar>(-ST::one()),*z,*v1);
763  if(!testMaxErr<Scalar>(
764  "norm_2(*x)",norm_2(*x)
765  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
766  )
767  ) success=false;
768  }
769 
770  // Test V_S
771  out << "\n"<<tc<<") Testing V_S(v1.ptr(),alpha) ...\n";
772  ++tc;
773  {
774  v1 = createMember(vecSpc);
775  v2 = createMember(vecSpc);
776  z = createMember(vecSpc);
777  const Scalar alpha = as<Scalar>(1.2345);
778  assign(v1.ptr(),alpha);
779  V_S(v2.ptr(),alpha);
780  V_StVpV(z.ptr(),as<Scalar>(-ST::one()),*v1,*v2);
781  if(!testMaxErr<Scalar>(
782  "norm_2(*z)",norm_2(*z)
783  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
784  )
785  ) success=false;
786  }
787 
788  // Test V_V
789  out << "\n"<<tc<<") Testing V_V(v1.ptr(),*v2) ...\n";
790  ++tc;
791  {
792  v1 = createMember(vecSpc);
793  v2 = createMember(vecSpc);
794  z = createMember(vecSpc);
795  seed_randomize<Scalar>(12345);
796  randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v1.ptr());
797  V_V(v2.ptr(),*v1);
798  V_StVpV(z.ptr(),as<Scalar>(-ST::one()),*v1,*v2);
799  if(!testMaxErr<Scalar>(
800  "norm_2(*z)",norm_2(*z)
801  ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
802  )
803  ) success=false;
804  }
805 
806  // ToDo: Add tests for *all* standard operators!
807 
808  out << "\n*** Leaving VectorStdOpsTester<"<<ST::name()<<">::checkStdOps(...) ...\n";
809 
810  return success;
811 
812 
813 }
814 
815 
816 } // namespace Thyra
817 
818 
819 #endif // THYRA_VECTOR_STD_OPS_TESTER_HPP
VectorStdOpsTester(const ScalarMag &warning_tol=0, const ScalarMag &error_tol=0)
const std::string passfail(const bool result)
Abstract interface for objects that represent a space for vectors.
Teuchos::Ordinal Ordinal
Type for the dimension of a vector space. `*.
Abstract interface for finite-dimensional dense vectors.
Teuchos::ScalarTraits< Scalar >::magnitudeType ScalarMag
bool checkStdOps(const VectorSpaceBase< Scalar > &vecSpc, std::ostream *out=0, const bool &dumpAll=false)
Run the tests using a vector space.
virtual Ordinal dim() const =0
Return the dimension of the vector space.