Thyra Version of the Day
Loading...
Searching...
No Matches
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
58namespace Thyra {
59
60
61// VectorStdOpsTesterComparable (using partial specialization to only do tests in some cases)
62
63
64template <bool isComparable, class Scalar>
65class VectorStdOpsTesterComparable {
66public:
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
81template <class Scalar>
82class VectorStdOpsTesterComparable<false,Scalar> {
83public:
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
101template <class Scalar>
102class VectorStdOpsTesterComparable<true,Scalar> {
103public:
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
212 // Test pair_wise_max
213 if (nonnull(out)) *out << "\nTesting pair_wise_max(*v1, *v2, z0.ptr()) ...\n";
214 {
215 using Teuchos::as;
216 using Teuchos::tuple;
217 using Teuchos::null;
218 using Teuchos::outArg;
219 using Teuchos::inOutArg;
220 Teuchos::RCP<VectorBase<Scalar> > v1 = createMember(vecSpc);
221 Teuchos::RCP<VectorBase<Scalar> > v2 = createMember(vecSpc);
222 Teuchos::RCP<VectorBase<Scalar> > v3 = createMember(vecSpc);
223 Teuchos::RCP<VectorBase<Scalar> > z0 = createMember(vecSpc);
224 const Scalar alpha = as<Scalar>(2.0);
225 seed_randomize<Scalar>(12345);
226 randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
227 randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
228
229 // z0 = alpha*max(v1_i, v2_i)
230 pair_wise_max(alpha, *v1, *v2, z0.ptr());
231
232 V_VpV(v3.ptr(), *v1, *v2); // v3 = v1 + v2
233 Vp_V(v1.ptr(), *v2, as<Scalar>(-ST::one())); // v1 -= v2
234 abs(*v1, v2.ptr()); // v2 = abs(v1)
235 Vp_V(v3.ptr(), *v2); // v3 += v2
236
237 // v1 + v2 + | v1 - v2 | = 2 max (v1, v2)
238 Vp_V(z0.ptr(), *v3, as<Scalar>(-ST::one())); // z0 -= v3
239 if(!testMaxErr<Scalar>(
240 "norm_2(*z0)",norm_2(*z0)
241 ,"error_tol",error_tol,"warning_tol",warning_tol,out.get()
242 )
243 ) success=false;
244 }
245
246 return success;
247 }
248};
249
250
251// Other helpers
252
253
254template<class Scalar>
255void setEleTestCase( const Ptr<VectorBase<Scalar> > &z, const Ordinal i, int &tc,
256 std::ostream &out, bool &success)
257{
258 using Teuchos::as;
259 out << "\n"<<tc<<") set_ele(z, "<<i<<");\n";
260 ++tc;
261 {
262 typedef ScalarTraits<Scalar> ST;
263 const Scalar val_i = as<Scalar>(i+1);
264 assign<Scalar>(z, ST::zero());
265 set_ele(i, val_i, z);
266 TEUCHOS_TEST_EQUALITY_CONST(get_ele(*z, i), val_i, out, success);
267 TEUCHOS_TEST_EQUALITY_CONST(sum(*z), val_i, out, success);
268 }
269}
270
271
272// VectorStdOpsTester
273
274
275template <class Scalar>
276VectorStdOpsTester<Scalar>::VectorStdOpsTester(
277 const ScalarMag &warning_tol_in,
278 const ScalarMag &error_tol_in
279 )
280 :warning_tol_(warning_tol_in),
281 error_tol_(error_tol_in)
282{}
283
284
285template <class Scalar>
286bool VectorStdOpsTester<Scalar>::checkStdOps(
287 const VectorSpaceBase<Scalar> &vecSpc,
288 std::ostream *out_out,
289 const bool &dumpAll
290 )
291{
292 using Teuchos::as;
293 using Teuchos::tuple;
294 using Teuchos::null;
295 using Teuchos::outArg;
296 using Teuchos::inOutArg;
297 typedef Teuchos::ScalarTraits<Scalar> ST;
298
299 TEUCHOS_ASSERT(out_out);
300 std::ostream &out = *out_out;
301
302 out << "\n*** Entering VectorStdOpsTester<"<<ST::name()<<">::checkStdOps(...) ...\n"
303 << "using a \'" << vecSpc.description() << "\' object ...\n";
304
305 bool success = true;
306 out << "\nvecSpc.dim() = " << vecSpc.dim() << std::endl;
307
308 const Ordinal n = vecSpc.dim();
309
310 TEUCHOS_TEST_FOR_EXCEPTION( n < 4, std::logic_error,
311 "Error: n = "<<n<<" must be least 4 or greater to"
312 " run Thyra::VectorStdOpsTester::checkStdOps(...)!" );
313
314 const Scalar
315 two = as<Scalar>(2.0),
316 three = as<Scalar>(3.0),
317 four = as<Scalar>(4.0);
318
319 int tc = 0;
320
321 out << "\nCreating vectors v1, v2, v3, v4, x and z ...\n";
322 Teuchos::RCP<VectorBase<Scalar> >
323 v1 = createMember(vecSpc),
324 v2 = createMember(vecSpc),
325 v3 = createMember(vecSpc),
326 v4 = createMember(vecSpc),
327 y = createMember(vecSpc),
328 x = createMember(vecSpc),
329 z = createMember(vecSpc);
330
331 out << "\nassign(v1.ptr(), -2.0);\n";
332 assign<Scalar>(v1.ptr(), -two);
333 out << "\nassign(v2.ptr(), -3.0);\n";
334 assign<Scalar>(v2.ptr(), -three);
335 out << "\nassign(v3.ptr(), -4.0);\n";
336 assign<Scalar>(v3.ptr(), -four);
337 out << "\ny[i] = i+1\n";
338 {
339 RTOpPack::TOpSetAssendingValues<Scalar> setAssendOp(ST::zero());
340 applyOp<Scalar>( setAssendOp,
341 ArrayView<const Ptr<const VectorBase<Scalar> > >(null),
342 tuple<Ptr<VectorBase<Scalar> > >(y.ptr())(),
343 null );
344 }
345
346 // sum
347 out << "\n"<<tc<<") sum(*y);\n";
348 ++tc;
349 TEUCHOS_TEST_ASSERT(
350 Teuchos::testRelErr<Scalar>(
351 "sum(*y)", sum(*y),
352 "0.5*(n+1)*n", as<Scalar>(0.5*(n+1)*n),
353 "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
354 out, success);
355
356 // norm_inf
357 out << "\n"<<tc<<") nom_inf(*v1);\n";
358 ++tc;
359 TEUCHOS_TEST_ASSERT(
360 Teuchos::testRelErr<Scalar>(
361 "norm_inf(*v1)", norm_inf(*v1),
362 "2.0", two,
363 "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
364 out, success);
365
366 // norm_2
367 out << "\n"<<tc<<") norm_2(*v1);\n";
368 ++tc;
369 TEUCHOS_TEST_ASSERT(
370 Teuchos::testRelErr<Scalar>(
371 "norm_2(*v1)", norm_2(*v1),
372 "2.0*sqrt(vecSpc.dim())", as<Scalar>(2.0)*ST::squareroot(vecSpc.dim()),
373 "error_tol", error_tol(), "warning_tol",warning_tol(), inOutArg(out)),
374 out, success);
375
376 // norm_1
377 out << "\n"<<tc<<") norm_1(*v1);\n";
378 ++tc;
379 TEUCHOS_TEST_ASSERT(
380 Teuchos::testRelErr<Scalar>(
381 "norm_1(*v1)" ,norm_1(*v1),
382 "2.0*vecSpc.dim()", as<Scalar>(2.0)*as<Scalar>(vecSpc.dim()),
383 "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
384 out, success);
385
386 // abs
387 out << "\n"<<tc<<") abs(z.ptr(),*v1);\n";
388 ++tc;
389 {
390 abs<Scalar>(*v1, z.ptr());
391 if(!Teuchos::testRelErr<Scalar>(
392 "sum(*z)", sum(*z), "2.0*vecSpc.dim()", as<Scalar>(2.0)*as<Scalar>(vecSpc.dim()),
393 "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out))
394 ) success=false;
395 }
396
397 // get_ele
398
399 out << "\n"<<tc<<") val = get_ele(y, 0);\n";
400 ++tc;
401 {
402 const Scalar val = get_ele<Scalar>(*y, 0);
403 TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(1), out, success );
404 }
405
406 out << "\n"<<tc<<") val = get_ele<Scalar>(*y, 1);\n";
407 ++tc;
408 {
409 const Scalar val = get_ele<Scalar>(*y, 1);
410 TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(2), out, success );
411 }
412
413 out << "\n"<<tc<<") val = get_ele<Scalar>(*y, n-2);\n";
414 ++tc;
415 {
416 const Scalar val = get_ele<Scalar>(*y, n-2);
417 TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(n-1), out, success );
418 }
419
420 out << "\n"<<tc<<") val = get_ele<Scalar>(*y, n-1);\n";
421 ++tc;
422 {
423 const Scalar val = get_ele<Scalar>(*y, n-1);
424 TEUCHOS_TEST_EQUALITY_CONST( val, as<Scalar>(n), out, success );
425 }
426
427#ifdef THYRA_DEBUG
428
429 out << "\n"<<tc<<") get_ele<Scalar>(*y, -1);\n";
430 ++tc;
431 {
432 TEUCHOS_TEST_THROW(get_ele<Scalar>(*y, -1), std::out_of_range, out, success );
433 }
434
435 out << "\n"<<tc<<") get_ele<Scalar>(*y, n);\n";
436 ++tc;
437 {
438 TEUCHOS_TEST_THROW(get_ele<Scalar>(*y, n), std::out_of_range, out, success );
439 }
440
441#endif // THYRA_DEBUG
442
443 // set_ele
444
445 setEleTestCase<Scalar>(z.ptr(), 0, tc, out, success);
446
447 setEleTestCase<Scalar>(z.ptr(), 1, tc, out, success);
448
449 setEleTestCase<Scalar>(z.ptr(), n-2, tc, out, success);
450
451 setEleTestCase<Scalar>(z.ptr(), n-1, tc, out, success);
452
453#ifdef THYRA_DEBUG
454
455 TEUCHOS_TEST_THROW(set_ele(-1, two, z.ptr()),
456 std::out_of_range, out, success);
457
458 TEUCHOS_TEST_THROW(set_ele(n, two, z.ptr()),
459 std::out_of_range, out, success);
460
461#endif // THYRA_DEBUG
462
463 // reciprocal
464 out << "\n"<<tc<<") reciprocal(z.ptr(),*v1);\n";
465 ++tc;
466 {
467 reciprocal(*v1, z.ptr());
468 if(!Teuchos::testRelErr<Scalar>(
469 "sum(*z)",sum(*z),"-0.5*vecSpc.dim()",as<Scalar>(-0.5)*as<Scalar>(vecSpc.dim())
470 ,"error_tol",error_tol(),"warning_tol",warning_tol(),inOutArg(out))
471 ) success=false;
472 }
473
474 // linear_combination
475
476 out << "\n"<<tc<<") linear_combination(2,{0.5,0.25},{v1.ptr(),v2.ptr()},0.0,z.ptr());\n";
477 ++tc;
478 {
479 linear_combination<Scalar>(
480 tuple<Scalar>(0.5, 0.25)(),
481 tuple<Ptr<const VectorBase<Scalar> > >(v1.ptr(), v2.ptr())(),
482 ST::zero(),
483 z.ptr());
484 TEUCHOS_TEST_ASSERT(
485 Teuchos::testRelErr<Scalar>(
486 "sum(*z)", sum(*z),
487 "(-0.5*2.0-0.25*3.0)*vecSpc.dim()", as<Scalar>((-0.5 * 2.0 - 0.25 * 3.0) *vecSpc.dim()),
488 "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)),
489 out, success);
490 }
491
492 out << "\nassign(z.ptr(), 2.0);\n";
493 ++tc;
494 assign(z.ptr(), as<Scalar>(2.0));
495
496 out << "\n"<<tc<<") linear_combination(3,{0.5,0.25,0.125},{v1.ptr(),v2.ptr(),v2.ptr()},0.5,z.ptr());\n";
497 ++tc;
498 {
499 linear_combination<Scalar>(
500 tuple<Scalar>(0.5, 0.25, 0.125)(),
501 tuple<Ptr<const VectorBase<Scalar> > >(v1.ptr(), v2.ptr(), v3.ptr())(),
502 as<Scalar>(0.5),
503 z.ptr());
504 if(!Teuchos::testRelErr<Scalar>(
505 "sum(*z)", sum(*z),
506 "(0.5*2.0-0.5*2.0-0.25*3.0-0.125*4.0)*vecSpc.dim()",
507 as<Scalar>(0.5*2.0-0.5*2.0-0.25*3.0-0.125*4.0)*as<Scalar>(vecSpc.dim()),
508 "error_tol", error_tol(), "warning_tol", warning_tol(), inOutArg(out)
509 )
510 ) success=false;
511 }
512
513 // assgin
514 out << "\n"<<tc<<") assign(z.ptr(),2.0);\n";
515 ++tc;
516 {
517 assign(z.ptr(),as<Scalar>(2.0));
518 if(!Teuchos::testRelErr<Scalar>(
519 "norm_2(*z,*v2)",norm_2(*z,*v2)
520 ,"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())))
521 ,"error_tol",error_tol(),"warning_tol",warning_tol(),inOutArg(out)
522 )
523 ) success=false;
524
525 if(!VectorStdOpsTesterComparable<ST::isComparable,Scalar>::checkComparableStdOps(
526 vecSpc,z.ptr(),error_tol(),warning_tol(),inOutArg(out),dumpAll)
527 ) success=false;
528 }
529
530 // Test Vt_S
531 out << "\n"<<tc<<") Testing Vt_S(z.ptr(),alpha) ...\n";
532 ++tc;
533 {
534#ifdef THYRA_VECTOR_STD_OPS_TESTER_DUMP
535 RTOpPack::show_spmd_apply_op_dump = true;
536#endif // THYRA_VECTOR_STD_OPS_TESTER_DUMP
537 v1 = createMember(vecSpc);
538 v2 = createMember(vecSpc);
539 const Scalar alpha = as<Scalar>(1.2345);
540 seed_randomize<Scalar>(12345);
541 randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr());
542 V_V(v2.ptr(),*v1);
543 Vt_S(v1.ptr(), alpha);
544 const Scalar norm_alpha_v1 = norm_2(*v1);
545 //out << "norm_alpha_v1 = " << norm_alpha_v1 << "\n";
546 const Scalar mag_alpha = ST::magnitude(alpha);
547 //out << "mag_alpha = " << mag_alpha << "\n";
548 const Scalar norm_2_v2 = norm_2(*v2);
549 //out << "norm_2_v2 = " << norm_2_v2 << "\n";
550 const Scalar alpha_norm_v1 = mag_alpha * norm_2_v2;
551 //out << "alpha_norm_v1 = " << alpha_norm_v1 << "\n";
552 if(!testMaxErr<Scalar>(
553 "norm_alpha_v1 - alpha_norm_v1",ST::magnitude(norm_alpha_v1-alpha_norm_v1)
554 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
555 )
556 ) success=false;
557#ifdef THYRA_VECTOR_STD_OPS_TESTER_DUMP
558 RTOpPack::show_spmd_apply_op_dump = false;
559#endif // THYRA_VECTOR_STD_OPS_TESTER_DUMP
560 }
561
562 // Test V_StV
563 out << "\n"<<tc<<") Testing V_StV(z.ptr(),alpha,*v) ...\n";
564 ++tc;
565 {
566 v1 = createMember(vecSpc);
567 v2 = createMember(vecSpc);
568 z = createMember(vecSpc);
569 const Scalar alpha = as<Scalar>(-1.2345);
570 seed_randomize<Scalar>(12345);
571 randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr());
572 V_StV(v2.ptr(),alpha,*v1);
573 Vt_S(v1.ptr(),alpha);
574 V_V(z.ptr(),*v1);
575 Vp_V(z.ptr(),*v2,as<Scalar>(-ST::one()));
576 if(!testMaxErr<Scalar>(
577 "norm_2(*z)",norm_2(*z)
578 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
579 )
580 ) success=false;
581 }
582
583 // Test Vp_StV
584 out << "\n"<<tc<<") Testing Vp_StV(z.ptr(),alpha,*v) ...\n";
585 ++tc;
586 {
587 v1 = createMember(vecSpc);
588 v2 = createMember(vecSpc);
589 v3 = createMember(vecSpc);
590 z = createMember(vecSpc);
591 const Scalar alpha = as<Scalar>(-1.2345);
592 seed_randomize<Scalar>(12345);
593 randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
594 randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
595 V_V(v3.ptr(),*v1); // v3 = v1
596 Vp_StV(v1.ptr(),alpha,*v2); // v1 += alpha*v2
597 V_StV(z.ptr(),alpha,*v2); // z = alpha*v2
598 Vp_V(z.ptr(),*v3); // z += v3
599 V_V(v3.ptr(),*v1); // v3 = v1
600 Vp_V(v3.ptr(),*z,as<Scalar>(-ST::one())); // v3 -= z
601 if(!testMaxErr<Scalar>(
602 "norm_2(*v3)",norm_2(*v3)
603 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
604 )
605 ) success=false;
606 }
607
608 // Test ele_wise_prod
609 out << "\n"<<tc<<") Testing ele_wise_prod(alpha,*v1, *v2, z.ptr()) ...\n";
610 ++tc;
611 {
612 v1 = createMember(vecSpc);
613 v2 = createMember(vecSpc);
614 v3 = createMember(vecSpc);
615 z = createMember(vecSpc);
616 const Scalar alpha = as<Scalar>(-1.2345);
617 seed_randomize<Scalar>(12345);
618 randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
619 randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
620 randomize(as<Scalar>(-ST::one()),ST::one(),v3.ptr()); // v3 = rand
621 V_V(v4.ptr(), *v1); // v4 = v1
622 V_V(z.ptr(), *v2); // z = v2
623 ele_wise_prod(alpha, *v2, *v3, v1.ptr()); // v1 += alpha * v2 * v3
624 ele_wise_prod_update(alpha, *v3, z.ptr()); // z *= alpha * v3
625 Vp_V(z.ptr(), *v4); // z += v4
626 V_V(v2.ptr(), *v1); // v2 = v1
627 Vp_V(v2.ptr(), *z, as<Scalar>(-ST::one())); // v2 -= z
628 if(!testMaxErr<Scalar>(
629 "norm_2(*v2)",norm_2(*v2)
630 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
631 )
632 ) success=false;
633 }
634
635
636 // Test ele_wise_scale
637 out << "\n"<<tc<<") Testing ele_wise_scale(*v1, z.ptr()) ...\n";
638 ++tc;
639 {
640 v1 = createMember(vecSpc);
641 z = createMember(vecSpc);
642 V_S(v1.ptr(), as<Scalar>(2.0));
643 V_S(z.ptr(), as<Scalar>(3.0));
644 ele_wise_scale( *v1, z.ptr() );
645 if (!Teuchos::testRelErr<Scalar>(
646 "norm_2(*z)", norm_2(*z),
647 "ST::squareroot(n*sqr(3.0*2.0))", ST::squareroot(n*36.0),
648 "error_tol", error_tol(),
649 "warning_tol", warning_tol(),
650 inOutArg(out)
651 )
652 ) success=false;
653 }
654
655 // Test Vt_StV
656 out << "\n"<<tc<<") Testing Vt_StV(z.ptr(), alpha, *v) ...\n";
657 ++tc;
658 {
659 v1 = createMember(vecSpc);
660 v2 = createMember(vecSpc);
661 v3 = createMember(vecSpc);
662 z = createMember(vecSpc);
663 const Scalar alpha = as<Scalar>(-1.2345);
664 seed_randomize<Scalar>(12345);
665 randomize(as<Scalar>(-ST::one()),ST::one(),v1.ptr()); // v1 = rand
666 randomize(as<Scalar>(-ST::one()),ST::one(),v2.ptr()); // v2 = rand
667 V_V(v3.ptr(),*v1); // v3 = v1
668 Vt_StV(v1.ptr(),alpha,*v2); // v1 *= alpha*v2
669 V_S(z.ptr(),ST::zero()); // z = 0
670 Vp_StVtV(z.ptr(),alpha,*v3,*v2); // z += alpha*v3*v2
671 V_V(v2.ptr(),*v1); // v2 = v1
672 Vp_V(v2.ptr(),*z,as<Scalar>(-ST::one())); // v2 -= z
673 if(!testMaxErr<Scalar>(
674 "norm_2(*v2)",norm_2(*v2)
675 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
676 )
677 ) success=false;
678 }
679
680 // Test V_StVpV
681 out << "\n"<<tc<<") Testing V_StVpV(z.ptr(),alpha,*v1,*v2) ...\n";
682 ++tc;
683 {
684 v1 = createMember(vecSpc);
685 v2 = createMember(vecSpc);
686 v3 = createMember(vecSpc);
687 x = createMember(vecSpc);
688 z = createMember(vecSpc);
689 const Scalar alpha = as<Scalar>(1.2345);
690 seed_randomize<Scalar>(12345);
691 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v1.ptr());
692 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
693 V_StVpV(v3.ptr(),alpha,*v1,*v2);
694 V_V(z.ptr(),*v1);
695 Vp_V(z.ptr(),*v2,alpha);
696 V_V(x.ptr(),*v3);
697 Vp_V(x.ptr(),*z,as<Scalar>(-ST::one()));
698 if(!testMaxErr<Scalar>(
699 "norm_2(*x)",norm_2(*x)
700 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
701 )
702 ) success=false;
703 }
704
705 // Test V_VpStV
706 out << "\n"<<tc<<") Testing V_VpStV(z.ptr(),*v1,alpha,*v2) ...\n";
707 ++tc;
708 {
709 v1 = createMember(vecSpc);
710 v2 = createMember(vecSpc);
711 v3 = createMember(vecSpc);
712 x = createMember(vecSpc);
713 z = createMember(vecSpc);
714 const Scalar alpha = as<Scalar>(1.2345);
715 seed_randomize<Scalar>(12345);
716 randomize<Scalar>(as<Scalar>(as<Scalar>(-10)*ST::one()),
717 as<Scalar>(as<Scalar>(10)*ST::one()), v1.ptr());
718 randomize<Scalar>(as<Scalar>(as<Scalar>(-10)*ST::one()),
719 as<Scalar>(as<Scalar>(10)*ST::one()), v2.ptr());
720 V_VpStV(outArg(*v3), *v1, alpha, *v2);
721 V_V(z.ptr(), *v1);
722 Vp_StV(z.ptr(), alpha, *v2);
723 V_VmV(outArg(*x), *z, *v3);
724 if(!testMaxErr<Scalar>(
725 "norm_2(*x)",norm_2(*x)
726 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
727 )
728 ) success=false;
729 }
730
731 // Test V_StVpStV
732 out << "\n"<<tc<<") Testing V_StVpStV(z.ptr(),alpha,*v1,beta,*v2) ...\n";
733 ++tc;
734 {
735 v1 = createMember(vecSpc);
736 v2 = createMember(vecSpc);
737 v3 = createMember(vecSpc);
738 x = createMember(vecSpc);
739 z = createMember(vecSpc);
740 const Scalar alpha = as<Scalar>(1.2345);
741 const Scalar beta = as<Scalar>(5.4321);
742 seed_randomize<Scalar>(12345);
743 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v1.ptr());
744 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
745 V_StVpStV(v3.ptr(),alpha,*v1,beta,*v2);
746 V_StV(z.ptr(),alpha,*v1);
747 Vp_StV(z.ptr(),beta,*v2);
748 V_V(x.ptr(),*v3);
749 Vp_V(x.ptr(),*z,as<Scalar>(-ST::one()));
750 if(!testMaxErr<Scalar>(
751 "norm_2(*x)",norm_2(*x)
752 ,"10*error_tol",ScalarMag(ScalarMag(10)*error_tol()),"warning_tol",warning_tol(),&out
753 )
754 ) success=false;
755 }
756
757 // Test Vp_V
758 out << "\n"<<tc<<") Testing Vp_V(v1.ptr(),*v2,beta) ...\n";
759 ++tc;
760 {
761 v1 = createMember(vecSpc);
762 v2 = createMember(vecSpc);
763 v3 = createMember(vecSpc);
764 x = createMember(vecSpc);
765 z = createMember(vecSpc);
766 const Scalar alpha = as<Scalar>(-2.0);
767 const Scalar beta = as<Scalar>(10.0);
768 V_S(v1.ptr(),alpha);
769 seed_randomize<Scalar>(12345);
770 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
771 Vp_V(v1.ptr(),*v2,beta);
772 V_S(v3.ptr(),alpha);
773 V_StVpV(z.ptr(),beta,*v3,*v2);
774 V_StVpV(x.ptr(),as<Scalar>(-ST::one()),*z,*v1);
775 if(!testMaxErr<Scalar>(
776 "norm_2(*x)",norm_2(*x)
777 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
778 )
779 ) success=false;
780 }
781
782 // Test Vp_V
783 out << "\n"<<tc<<") Testing Vp_V(v1.ptr(),*v2) ...\n";
784 ++tc;
785 {
786 v1 = createMember(vecSpc);
787 v2 = createMember(vecSpc);
788 v3 = createMember(vecSpc);
789 x = createMember(vecSpc);
790 z = createMember(vecSpc);
791 const Scalar alpha = as<Scalar>(-2.0);
792 V_S(v1.ptr(),alpha);
793 seed_randomize<Scalar>(12345);
794 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v2.ptr());
795 Vp_V(v1.ptr(),*v2);
796 V_S(v3.ptr(),alpha);
797 V_StVpV(z.ptr(),ST::one(),*v3,*v2);
798 V_StVpV(x.ptr(),as<Scalar>(-ST::one()),*z,*v1);
799 if(!testMaxErr<Scalar>(
800 "norm_2(*x)",norm_2(*x)
801 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
802 )
803 ) success=false;
804 }
805
806 // Test V_S
807 out << "\n"<<tc<<") Testing V_S(v1.ptr(),alpha) ...\n";
808 ++tc;
809 {
810 v1 = createMember(vecSpc);
811 v2 = createMember(vecSpc);
812 z = createMember(vecSpc);
813 const Scalar alpha = as<Scalar>(1.2345);
814 assign(v1.ptr(),alpha);
815 V_S(v2.ptr(),alpha);
816 V_StVpV(z.ptr(),as<Scalar>(-ST::one()),*v1,*v2);
817 if(!testMaxErr<Scalar>(
818 "norm_2(*z)",norm_2(*z)
819 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
820 )
821 ) success=false;
822 }
823
824 // Test V_V
825 out << "\n"<<tc<<") Testing V_V(v1.ptr(),*v2) ...\n";
826 ++tc;
827 {
828 v1 = createMember(vecSpc);
829 v2 = createMember(vecSpc);
830 z = createMember(vecSpc);
831 seed_randomize<Scalar>(12345);
832 randomize(as<Scalar>(as<Scalar>(-10)*ST::one()),as<Scalar>(as<Scalar>(10)*ST::one()),v1.ptr());
833 V_V(v2.ptr(),*v1);
834 V_StVpV(z.ptr(),as<Scalar>(-ST::one()),*v1,*v2);
835 if(!testMaxErr<Scalar>(
836 "norm_2(*z)",norm_2(*z)
837 ,"error_tol",error_tol(),"warning_tol",warning_tol(),&out
838 )
839 ) success=false;
840 }
841
842 // ToDo: Add tests for *all* standard operators!
843
844 out << "\n*** Leaving VectorStdOpsTester<"<<ST::name()<<">::checkStdOps(...) ...\n";
845
846 return success;
847
848
849}
850
851
852} // namespace Thyra
853
854
855#endif // THYRA_VECTOR_STD_OPS_TESTER_HPP
Teuchos_TestingHelpers.hpp
Teuchos::Describable::description
virtual std::string description() const
Teuchos::RCP::ptr
Ptr< T > ptr() const
Thyra::MultiVectorBase::assign
void assign(const Ptr< MultiVectorBase< Scalar > > &V, Scalar alpha)
V = alpha.
Definition Thyra_MultiVectorStdOps_def.hpp:154
Thyra::MultiVectorBase::randomize
void randomize(Scalar l, Scalar u, const Ptr< MultiVectorBase< Scalar > > &V)
Generate a random multi-vector with elements uniformly distributed elements.
Definition Thyra_MultiVectorStdOps_def.hpp:232
Thyra::MultiVectorBase::V_VpV
void V_VpV(const Ptr< MultiVectorBase< Scalar > > &Z, const MultiVectorBase< Scalar > &X, const MultiVectorBase< Scalar > &Y)
Z(i,j) = X(i,j) + Y(i,j), i = 0...Z->range()->dim()-1, j = 0...Z->domain()->dim()-1.
Definition Thyra_MultiVectorStdOps_def.hpp:273
Thyra::MultiVectorBase::applyOp
void applyOp(const RTOpPack::RTOpT< Scalar > &primary_op, const ArrayView< const Ptr< const MultiVectorBase< Scalar > > > &multi_vecs, const ArrayView< const Ptr< MultiVectorBase< Scalar > > > &targ_multi_vecs, const ArrayView< const Ptr< RTOpPack::ReductTarget > > &reduct_objs, const Ordinal primary_global_offset=0)
Apply a reduction/transformation operator column by column and return an array of the reduction objec...
Definition Thyra_MultiVectorBase_decl.hpp:1341
Thyra::MultiVectorBase::Vt_S
void Vt_S(const Ptr< MultiVectorBase< Scalar > > &Z, const Scalar &alpha)
Z(i,j) *= alpha, i = 0...Z->range()->dim()-1, j = 0...Z->domain()->dim()-1.
Definition Thyra_MultiVectorStdOps_def.hpp:243
Thyra::MultiVectorBase::norm_1
ScalarTraits< Scalar >::magnitudeType norm_1(const MultiVectorBase< Scalar > &V)
Take the induced matrix one norm of a multi-vector.
Thyra::MultiVectorBase::V_VmV
void V_VmV(const Ptr< MultiVectorBase< Scalar > > &Z, const MultiVectorBase< Scalar > &X, const MultiVectorBase< Scalar > &Y)
Z(i,j) = X(i,j) - Y(i,j), i = 0...Z->range()->dim()-1, j = 0...Z->domain()->dim()-1.
Definition Thyra_MultiVectorStdOps_def.hpp:286
Thyra::MultiVectorBase::linear_combination
void linear_combination(const ArrayView< const Scalar > &alpha, const ArrayView< const Ptr< const MultiVectorBase< Scalar > > > &X, const Scalar &beta, const Ptr< MultiVectorBase< Scalar > > &Y)
Y.col(j)(i) = beta*Y.col(j)(i) + sum( alpha[k]*X[k].col(j)(i), k=0...m-1 ), for i = 0....
Definition Thyra_MultiVectorStdOps_def.hpp:220
Thyra::MultiVectorBase::V_StVpV
void V_StVpV(const Ptr< MultiVectorBase< Scalar > > &Z, const Scalar &alpha, const MultiVectorBase< Scalar > &X, const MultiVectorBase< Scalar > &Y)
Z(i,j) = alpha*X(i,j) + Y(i), i = 0...z->space()->dim()-1, , j = 0...Z->domain()->dim()-1.
Definition Thyra_MultiVectorStdOps_def.hpp:299
Thyra::MultiVectorBase::Vp_V
void Vp_V(const Ptr< MultiVectorBase< Scalar > > &Z, const MultiVectorBase< Scalar > &X)
Z(i,j) += X(i,j), i = 0...Z->range()->dim()-1, j = 0...Z->domain()->dim()-1.
Definition Thyra_MultiVectorStdOps_def.hpp:262
Thyra::VectorBase
Abstract interface for finite-dimensional dense vectors.
Definition Thyra_VectorBase.hpp:147
Thyra::VectorBase::maxLessThanBound
void maxLessThanBound(const VectorBase< Scalar > &x, const Scalar &bound, const Ptr< Scalar > &maxEle, const Ptr< Ordinal > &maxIndex)
Max element less than bound and its index: Returns maxEle = x(k) and maxIndex = k such that x(k) >= x...
Definition Thyra_VectorStdOps_def.hpp:584
Thyra::VectorBase::abs
void abs(const VectorBase< Scalar > &x, const Ptr< VectorBase< Scalar > > &y)
Element-wise absolute value: y(i) = abs(x(i)), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:201
Thyra::VectorBase::Vp_StV
void Vp_StV(const Ptr< VectorBase< Scalar > > &y, const Scalar &alpha, const VectorBase< Scalar > &x)
AXPY: y(i) = alpha * x(i) + y(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:395
Thyra::VectorBase::V_VpStV
void V_VpStV(const Ptr< VectorBase< Scalar > > &z, const VectorBase< Scalar > &x, const Scalar &alpha, const VectorBase< Scalar > &y)
z(i) = x(i) + alpha*y(i), i = 0...z->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:475
Thyra::VectorBase::set_ele
void set_ele(Ordinal i, Scalar alpha, const Ptr< VectorBase< Scalar > > &v)
Set single element: v(i) = alpha.
Definition Thyra_VectorStdOps_def.hpp:153
Thyra::VectorBase::norm_2
Teuchos::ScalarTraits< Scalar >::magnitudeType norm_2(const VectorBase< Scalar > &v)
Euclidean (2) norm: result = ||v||2.
Definition Thyra_VectorStdOps_def.hpp:104
Thyra::VectorBase::ele_wise_scale
void ele_wise_scale(const VectorBase< Scalar > &x, const Ptr< VectorBase< Scalar > > &y)
Element-wise scaling: y(i) *= x(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:253
Thyra::VectorBase::Vt_StV
void Vt_StV(const Ptr< VectorBase< Scalar > > &y, const Scalar &alpha, const VectorBase< Scalar > &x)
Element-wise product update: y(i) *= alpha * x(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:299
Thyra::VectorBase::norm_inf
Teuchos::ScalarTraits< Scalar >::magnitudeType norm_inf(const VectorBase< Scalar > &v_rhs)
Infinity norm: result = ||v||inf.
Definition Thyra_VectorStdOps_def.hpp:120
Thyra::VectorBase::V_StV
void V_StV(const Ptr< VectorBase< Scalar > > &y, const Scalar &alpha, const VectorBase< Scalar > &x)
Assign scaled vector: y(i) = alpha * x(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:384
Thyra::VectorBase::min
Scalar min(const VectorBase< Scalar > &x)
Min element: result = min{ x(i), i = 0...x.space()->dim()-1 } .
Definition Thyra_VectorStdOps_def.hpp:508
Thyra::VectorBase::sum
Scalar sum(const VectorBase< Scalar > &v)
Sum of vector elements: result = sum( v(i), i = 0...v.space()->dim()-1 ).
Definition Thyra_VectorStdOps_def.hpp:81
Thyra::VectorBase::ele_wise_prod_update
void ele_wise_prod_update(const Scalar &alpha, const VectorBase< Scalar > &x, const Ptr< VectorBase< Scalar > > &y)
Element-wise product update: y(i) *= alpha * x(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:272
Thyra::VectorBase::get_ele
Scalar get_ele(const VectorBase< Scalar > &v, Ordinal i)
Get single element: result = v(i).
Definition Thyra_VectorStdOps_def.hpp:134
Thyra::VectorBase::seed_randomize
void seed_randomize(unsigned int s)
Seed the random number generator used in randomize().
Definition Thyra_VectorStdOps_def.hpp:334
Thyra::VectorBase::V_S
void V_S(const Ptr< VectorBase< Scalar > > &y, const Scalar &alpha)
y(i) = alpha, i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:424
Thyra::VectorBase::pair_wise_max
void pair_wise_max(const Scalar &alpha, const VectorBase< Scalar > &x, const VectorBase< Scalar > &v, const Ptr< VectorBase< Scalar > > &y)
Element-wise maximum: y(i) = alpha * max(x(i), v(i)), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:227
Thyra::VectorBase::minGreaterThanBound
void minGreaterThanBound(const VectorBase< Scalar > &x, const Scalar &bound, const Ptr< Scalar > &minEle, const Ptr< Ordinal > &minIndex)
Minimum element greater than some bound and its index: Returns minEle = x(k) and minIndex = k such th...
Definition Thyra_VectorStdOps_def.hpp:537
Thyra::VectorBase::V_V
void V_V(const Ptr< VectorBase< Scalar > > &y, const VectorBase< Scalar > &x)
y(i) = x(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:417
Thyra::VectorBase::reciprocal
void reciprocal(const VectorBase< Scalar > &x, const Ptr< VectorBase< Scalar > > &y)
Element-wise reciprocal: y(i) = 1/x(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:208
Thyra::VectorBase::ele_wise_prod
void ele_wise_prod(const Scalar &alpha, const VectorBase< Scalar > &x, const VectorBase< Scalar > &v, const Ptr< VectorBase< Scalar > > &y)
Element-wise product update: y(i) += alpha * x(i) * v(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:215
Thyra::VectorBase::Vp_StVtV
void Vp_StVtV(const Ptr< VectorBase< Scalar > > &y, const Scalar &alpha, const VectorBase< Scalar > &x, const VectorBase< Scalar > &v)
Element-wise product update: y(i) += alpha * x(i) * v(i), i = 0...y->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:261
Thyra::VectorBase::V_StVpStV
void V_StVpStV(const Ptr< VectorBase< Scalar > > &z, const Scalar &alpha, const VectorBase< Scalar > &x, const Scalar &beta, const VectorBase< Scalar > &y)
z(i) = alpha*x(i) + beta*y(i), i = 0...z->space()->dim()-1.
Definition Thyra_VectorStdOps_def.hpp:489
Thyra::VectorBase::max
Scalar max(const VectorBase< Scalar > &x)
Max element: result = max{ x(i), i = 1...n } .
Definition Thyra_VectorStdOps_def.hpp:554
Thyra::VectorSpaceBase
Abstract interface for objects that represent a space for vectors.
Definition Thyra_VectorSpaceBase_decl.hpp:299
Thyra::VectorSpaceBase::dim
virtual Ordinal dim() const =0
Return the dimension of the vector space.
Thyra::VectorSpaceBase::createMember
RCP< VectorBase< Scalar > > createMember(const RCP< const VectorSpaceBase< Scalar > > &vs, const std::string &label="")
Create a vector member from the vector space.
Thyra::VectorStdOpsTester::checkStdOps
bool checkStdOps(const VectorSpaceBase< Scalar > &vecSpc, std::ostream *out=0, const bool &dumpAll=false)
Run the tests using a vector space.
Definition Thyra_VectorStdOpsTester_def.hpp:286
Thyra::VectorStdOpsTester::VectorStdOpsTester
VectorStdOpsTester(const ScalarMag &warning_tol=0, const ScalarMag &error_tol=0)
Definition Thyra_VectorStdOpsTester_def.hpp:276
Thyra::VectorStdOpsTester::ScalarMag
Teuchos::ScalarTraits< Scalar >::magnitudeType ScalarMag
Definition Thyra_VectorStdOpsTester_decl.hpp:61
TEUCHOS_ASSERT
#define TEUCHOS_ASSERT(assertion_test)
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Teuchos::nonnull
bool nonnull(const std::shared_ptr< T > &p)
Thyra::passfail
const std::string passfail(const bool result)
Definition Thyra_TestingToolsDecl.hpp:56
Thyra::testMaxErr
bool testMaxErr(const std::string &error_name, const Scalar &error, const std::string &max_error_name, const typename Teuchos::ScalarTraits< Scalar >::magnitudeType &max_error, const std::string &max_warning_name, const typename Teuchos::ScalarTraits< Scalar >::magnitudeType &max_warning, std::ostream *out, const std::string &leadingIndent=std::string(""))
Check that an error is less than some error tolerence.
Definition Thyra_TestingTools.hpp:203
Thyra::Ordinal
Teuchos::Ordinal Ordinal
Type for the dimension of a vector space. `*.
Definition Thyra_OperatorVectorTypes.hpp:127
Teuchos::as
TypeTo as(const TypeFrom &t)
TEUCHOS_TEST_ASSERT
#define TEUCHOS_TEST_ASSERT(v1, out, success)
TEUCHOS_TEST_THROW
#define TEUCHOS_TEST_THROW(code, ExceptType, out, success)
TEUCHOS_TEST_EQUALITY_CONST
#define TEUCHOS_TEST_EQUALITY_CONST(v1, v2, out, success)
Generated by doxygen 1.13.2