Stokhos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Stokhos_QuadExpansionUnitTest.cpp
Go to the documentation of this file.
1// $Id$
2// $Source$
3// @HEADER
4// ***********************************************************************
5//
6// Stokhos Package
7// Copyright (2009) Sandia Corporation
8//
9// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
10// license for use of this work by or on behalf of the U.S. Government.
11//
12// Redistribution and use in source and binary forms, with or without
13// modification, are permitted provided that the following conditions are
14// met:
15//
16// 1. Redistributions of source code must retain the above copyright
17// notice, this list of conditions and the following disclaimer.
18//
19// 2. Redistributions in binary form must reproduce the above copyright
20// notice, this list of conditions and the following disclaimer in the
21// documentation and/or other materials provided with the distribution.
22//
23// 3. Neither the name of the Corporation nor the names of the
24// contributors may be used to endorse or promote products derived from
25// this software without specific prior written permission.
26//
27// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
28// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
31// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38//
39// Questions? Contact Eric T. Phipps (etphipp@sandia.gov).
40//
41// ***********************************************************************
42// @HEADER
43
44#include "Teuchos_UnitTestHarness.hpp"
45#include "Teuchos_TestingHelpers.hpp"
46#include "Teuchos_UnitTestRepository.hpp"
47#include "Teuchos_GlobalMPISession.hpp"
48
49#include "Stokhos.hpp"
51
53
54 // Common setup for unit tests
55 template <typename OrdinalType, typename ValueType>
57 ValueType rtol, atol;
58 ValueType crtol, catol;
59 OrdinalType sz;
60 Teuchos::RCP<const Stokhos::CompletePolynomialBasis<OrdinalType,ValueType> > basis;
61 Teuchos::RCP<const Stokhos::Quadrature<OrdinalType,ValueType> > quad;
62 Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk, Cijk_linear;
63 Teuchos::RCP< Stokhos::QuadOrthogPolyExpansion<OrdinalType,ValueType> > exp, exp_linear;
65 ValueType a;
66
68 rtol = 1e-4;
69 atol = 1e-5;
70 crtol = 1e-12;
71 catol = 1e-12;
72 a = 3.1;
73 const OrdinalType d = 2;
74 const OrdinalType p = 7;
75
76 // Create product basis
77 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<OrdinalType,ValueType> > > bases(d);
78 for (OrdinalType i=0; i<d; i++)
79 bases[i] =
81 basis =
83
84 // Tensor product quadrature
85 quad =
87
88 // Triple product tensor
89 Cijk = basis->computeTripleProductTensor();
90 Cijk_linear = basis->computeLinearTripleProductTensor();
91
92 // Quadrature expansion
93 exp =
95 exp_linear =
97
98 // Create approximation
99 sz = basis->size();
100 x.reset(basis);
101 y.reset(basis);
102 u.reset(basis);
103 u2.reset(basis);
104 cx.reset(basis, 1);
105 x.term(0, 0) = 1.0;
106 cx.term(0, 0) = a;
107 cu.reset(basis);
108 cu2.reset(basis, 1);
109 sx.reset(basis, d+1);
110 su.reset(basis, d+1);
111 su2.reset(basis, d+1);
112 for (OrdinalType i=0; i<d; i++) {
113 x.term(i, 1) = 0.1;
114 sx.term(i, 1) = 0.0;
115 }
116 y.term(0, 0) = 2.0;
117 for (OrdinalType i=0; i<d; i++)
118 y.term(i, 1) = 0.25;
119 }
120
121 template <class Func>
124 {
125 // Quadrature data
126 const Teuchos::Array<ValueType>& weights = quad->getQuadWeights();
127 const Teuchos::Array< Teuchos::Array<ValueType> >& points =
128 quad->getQuadPoints();
129 const Teuchos::Array< Teuchos::Array<ValueType> >& values =
130 quad->getBasisAtQuadPoints();
131 OrdinalType nqp = weights.size();
132
133 // Initialize
134 for (OrdinalType i=0; i<c.size(); i++)
135 c[i] = 0.0;
136
137 // Compute PCE via quadrature
138 Func func;
139 for (OrdinalType k=0; k<nqp; k++) {
140 ValueType val = a.evaluate(points[k], values[k]);
141 val = func(val);
142 for (int i=0; i<c.size(); i++)
143 c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
144 }
145 }
146
147 template <class Func>
151 {
152 // Quadrature data
153 const Teuchos::Array<ValueType>& weights = quad->getQuadWeights();
154 const Teuchos::Array< Teuchos::Array<ValueType> >& points =
155 quad->getQuadPoints();
156 const Teuchos::Array< Teuchos::Array<ValueType> >& values =
157 quad->getBasisAtQuadPoints();
158 OrdinalType nqp = weights.size();
159
160 // Initialize
161 for (OrdinalType i=0; i<c.size(); i++)
162 c[i] = 0.0;
163
164 // Compute PCE via quadrature
165 Func func;
166 for (OrdinalType k=0; k<nqp; k++) {
167 ValueType val1 = a.evaluate(points[k], values[k]);
168 ValueType val2 = b.evaluate(points[k], values[k]);
169 ValueType val = func(val1, val2);
170 for (int i=0; i<c.size(); i++)
171 c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
172 }
173 }
174
175 template <class Func>
178 ValueType a,
180 {
181 // Quadrature data
182 const Teuchos::Array<ValueType>& weights = quad->getQuadWeights();
183 const Teuchos::Array< Teuchos::Array<ValueType> >& points =
184 quad->getQuadPoints();
185 const Teuchos::Array< Teuchos::Array<ValueType> >& values =
186 quad->getBasisAtQuadPoints();
187 OrdinalType nqp = weights.size();
188
189 // Initialize
190 for (OrdinalType i=0; i<c.size(); i++)
191 c[i] = 0.0;
192
193 // Compute PCE via quadrature
194 Func func;
195 for (OrdinalType k=0; k<nqp; k++) {
196 ValueType val2 = b.evaluate(points[k], values[k]);
197 ValueType val = func(a, val2);
198 for (int i=0; i<c.size(); i++)
199 c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
200 }
201 }
202
203 template <class Func>
207 ValueType b)
208 {
209 // Quadrature data
210 const Teuchos::Array<ValueType>& weights = quad->getQuadWeights();
211 const Teuchos::Array< Teuchos::Array<ValueType> >& points =
212 quad->getQuadPoints();
213 const Teuchos::Array< Teuchos::Array<ValueType> >& values =
214 quad->getBasisAtQuadPoints();
215 OrdinalType nqp = weights.size();
216
217 // Initialize
218 for (OrdinalType i=0; i<c.size(); i++)
219 c[i] = 0.0;
220
221 // Compute PCE via quadrature
222 Func func;
223 for (OrdinalType k=0; k<nqp; k++) {
224 ValueType val1 = a.evaluate(points[k], values[k]);
225 ValueType val = func(val1, b);
226 for (int i=0; i<c.size(); i++)
227 c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
228 }
229 }
230
231 };
232
234
235 struct UMinusFunc {
236 double operator() (double a) const { return -a; }
237 };
238 struct ExpFunc {
239 double operator() (double a) const { return std::exp(a); }
240 };
241 struct LogFunc {
242 double operator() (double a) const { return std::log(a); }
243 };
244 struct Log10Func {
245 double operator() (double a) const { return std::log10(a); }
246 };
247 struct SqrtFunc {
248 double operator() (double a) const { return std::sqrt(a); }
249 };
250 struct CbrtFunc {
251 double operator() (double a) const { return std::cbrt(a); }
252 };
253 struct SinFunc {
254 double operator() (double a) const { return std::sin(a); }
255 };
256 struct CosFunc {
257 double operator() (double a) const { return std::cos(a); }
258 };
259 struct TanFunc {
260 double operator() (double a) const { return std::tan(a); }
261 };
262 struct SinhFunc {
263 double operator() (double a) const { return std::sinh(a); }
264 };
265 struct CoshFunc {
266 double operator() (double a) const { return std::cosh(a); }
267 };
268 struct TanhFunc {
269 double operator() (double a) const { return std::tanh(a); }
270 };
271 struct ASinFunc {
272 double operator() (double a) const { return std::asin(a); }
273 };
274 struct ACosFunc {
275 double operator() (double a) const { return std::acos(a); }
276 };
277 struct ATanFunc {
278 double operator() (double a) const { return std::atan(a); }
279 };
280 struct ASinhFunc {
281 double operator() (double a) const {
282 return std::log(a+std::sqrt(a*a+1.0));
283 }
284 };
285 struct ACoshFunc {
286 double operator() (double a) const {
287 return std::log(a+std::sqrt(a*a-1.0));
288 }
289 };
290 struct ATanhFunc {
291 double operator() (double a) const {
292 return 0.5*std::log((1.0+a)/(1.0-a));
293 }
294 };
295
296 struct PlusFunc {
297 double operator() (double a, double b) const { return a + b; }
298 };
299 struct MinusFunc {
300 double operator() (double a, double b) const { return a - b; }
301 };
302 struct TimesFunc {
303 double operator() (double a, double b) const { return a * b; }
304 };
305 struct DivideFunc {
306 double operator() (double a, double b) const { return a / b; }
307 };
308 struct PowFunc {
309 double operator() (double a, double b) const { return std::pow(a,b); }
310 };
311
312 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, UMinus ) {
314 setup.exp->sin(v, setup.x);
315 setup.exp->unaryMinus(setup.u, v);
316 setup.computePCE1<UMinusFunc>(setup.u2, v);
317 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
318 setup.rtol, setup.atol, out);
319 }
320 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Exp ) {
321 setup.exp->exp(setup.u, setup.x);
322 setup.computePCE1<ExpFunc>(setup.u2, setup.x);
323 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
324 setup.rtol, setup.atol, out);
325 }
326 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ExpConst ) {
327 setup.exp->exp(setup.cu, setup.cx);
328 setup.cu2[0] = std::exp(setup.cx[0]);
329 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
330 setup.crtol, setup.catol, out);
331 }
332 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ExpResize ) {
334 setup.exp->exp(ru, setup.x);
335 setup.computePCE1<ExpFunc>(setup.u2, setup.x);
336 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
337 setup.rtol, setup.atol, out);
338 }
339 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Log ) {
340 setup.exp->log(setup.u, setup.x);
341 setup.computePCE1<LogFunc>(setup.u2, setup.x);
342 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
343 setup.rtol, setup.atol, out);
344 }
345 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, LogConst ) {
346 setup.exp->log(setup.cu, setup.cx);
347 setup.cu2[0] = std::log(setup.cx[0]);
348 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
349 setup.crtol, setup.catol, out);
350 }
351 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, LogResize ) {
353 setup.exp->log(ru, setup.x);
354 setup.computePCE1<LogFunc>(setup.u2, setup.x);
355 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
356 setup.rtol, setup.atol, out);
357 }
358 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Log10 ) {
359 setup.exp->log10(setup.u, setup.x);
360 setup.computePCE1<Log10Func>(setup.u2, setup.x);
361 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
362 setup.rtol, setup.atol, out);
363 }
364 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Log10Const ) {
365 setup.exp->log10(setup.cu, setup.cx);
366 setup.cu2[0] = std::log10(setup.cx[0]);
367 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
368 setup.crtol, setup.catol, out);
369 }
370 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Log10Resize ) {
372 setup.exp->log10(ru, setup.x);
373 setup.computePCE1<Log10Func>(setup.u2, setup.x);
374 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
375 setup.rtol, setup.atol, out);
376 }
377 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Sqrt ) {
378 setup.exp->sqrt(setup.u, setup.x);
379 setup.computePCE1<SqrtFunc>(setup.u2, setup.x);
380 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
381 setup.rtol, setup.atol, out);
382 }
383 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, SqrtConst ) {
384 setup.exp->sqrt(setup.cu, setup.cx);
385 setup.cu2[0] = std::sqrt(setup.cx[0]);
386 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
387 setup.crtol, setup.catol, out);
388 }
389 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, SqrtResize ) {
391 setup.exp->sqrt(ru, setup.x);
392 setup.computePCE1<SqrtFunc>(setup.u2, setup.x);
393 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
394 setup.rtol, setup.atol, out);
395 }
396 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Cbrt ) {
397 setup.exp->cbrt(setup.u, setup.x);
398 setup.computePCE1<CbrtFunc>(setup.u2, setup.x);
399 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
400 setup.rtol, setup.atol, out);
401 }
402 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, CbrtConst ) {
403 setup.exp->cbrt(setup.cu, setup.cx);
404 setup.cu2[0] = std::cbrt(setup.cx[0]);
405 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
406 setup.crtol, setup.catol, out);
407 }
408 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, CbrtResize ) {
410 setup.exp->cbrt(ru, setup.x);
411 setup.computePCE1<CbrtFunc>(setup.u2, setup.x);
412 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
413 setup.rtol, setup.atol, out);
414 }
415 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Sin ) {
416 setup.exp->sin(setup.u, setup.x);
417 setup.computePCE1<SinFunc>(setup.u2, setup.x);
418 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
419 setup.rtol, setup.atol, out);
420 }
421 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, SinConst ) {
422 setup.exp->sin(setup.cu, setup.cx);
423 setup.cu2[0] = std::sin(setup.cx[0]);
424 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
425 setup.crtol, setup.catol, out);
426 }
427 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, SinResize ) {
429 setup.exp->sin(ru, setup.x);
430 setup.computePCE1<SinFunc>(setup.u2, setup.x);
431 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
432 setup.rtol, setup.atol, out);
433 }
434 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Cos ) {
435 setup.exp->cos(setup.u, setup.x);
436 setup.computePCE1<CosFunc>(setup.u2, setup.x);
437 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
438 setup.rtol, setup.atol, out);
439 }
440 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, CosConst ) {
441 setup.exp->cos(setup.cu, setup.cx);
442 setup.cu2[0] = std::cos(setup.cx[0]);
443 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
444 setup.crtol, setup.catol, out);
445 }
446 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, CosResize ) {
448 setup.exp->cos(ru, setup.x);
449 setup.computePCE1<CosFunc>(setup.u2, setup.x);
450 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
451 setup.rtol, setup.atol, out);
452 }
453 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Tan ) {
454 setup.exp->tan(setup.u, setup.x);
455 setup.computePCE1<TanFunc>(setup.u2, setup.x);
456 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
457 setup.rtol, setup.atol, out);
458 }
459 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TanConst ) {
460 setup.exp->tan(setup.cu, setup.cx);
461 setup.cu2[0] = std::tan(setup.cx[0]);
462 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
463 setup.crtol, setup.catol, out);
464 }
465 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TanResize ) {
467 setup.exp->tan(ru, setup.x);
468 setup.computePCE1<TanFunc>(setup.u2, setup.x);
469 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
470 setup.rtol, setup.atol, out);
471 }
472 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Sinh ) {
473 setup.exp->sinh(setup.u, setup.x);
474 setup.computePCE1<SinhFunc>(setup.u2, setup.x);
475 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
476 setup.rtol, setup.atol, out);
477 }
478 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, SinhConst ) {
479 setup.exp->sinh(setup.cu, setup.cx);
480 setup.cu2[0] = std::sinh(setup.cx[0]);
481 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
482 setup.crtol, setup.catol, out);
483 }
484 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, SinhResize ) {
486 setup.exp->sinh(ru, setup.x);
487 setup.computePCE1<SinhFunc>(setup.u2, setup.x);
488 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
489 setup.rtol, setup.atol, out);
490 }
491 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Cosh ) {
492 setup.exp->cosh(setup.u, setup.x);
493 setup.computePCE1<CoshFunc>(setup.u2, setup.x);
494 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
495 setup.rtol, setup.atol, out);
496 }
497 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, CoshConst ) {
498 setup.exp->cosh(setup.cu, setup.cx);
499 setup.cu2[0] = std::cosh(setup.cx[0]);
500 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
501 setup.crtol, setup.catol, out);
502 }
503 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, CoshResize ) {
505 setup.exp->cosh(ru, setup.x);
506 setup.computePCE1<CoshFunc>(setup.u2, setup.x);
507 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
508 setup.rtol, setup.atol, out);
509 }
510 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Tanh ) {
511 setup.exp->tanh(setup.u, setup.x);
512 setup.computePCE1<TanhFunc>(setup.u2, setup.x);
513 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
514 setup.rtol, setup.atol, out);
515 }
516 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TanhConst ) {
517 setup.exp->tanh(setup.cu, setup.cx);
518 setup.cu2[0] = std::tanh(setup.cx[0]);
519 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
520 setup.crtol, setup.catol, out);
521 }
522 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TanhResize ) {
524 setup.exp->tanh(ru, setup.x);
525 setup.computePCE1<TanhFunc>(setup.u2, setup.x);
526 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
527 setup.rtol, setup.atol, out);
528 }
529 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ASin ) {
530 setup.exp->asin(setup.u, setup.x);
531 setup.computePCE1<ASinFunc>(setup.u2, setup.x);
532 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
533 setup.rtol, setup.atol, out);
534 }
535 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ASinConst ) {
536 setup.exp->asin(setup.cu, setup.cx);
537 setup.cu2[0] = std::asin(setup.cx[0]);
538 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
539 setup.crtol, setup.catol, out);
540 }
541 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ASinResize ) {
543 setup.exp->asin(ru, setup.x);
544 setup.computePCE1<ASinFunc>(setup.u2, setup.x);
545 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
546 setup.rtol, setup.atol, out);
547 }
548 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ACos ) {
549 setup.exp->acos(setup.u, setup.x);
550 setup.computePCE1<ACosFunc>(setup.u2, setup.x);
551 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
552 setup.rtol, setup.atol, out);
553 }
554 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ACosConst ) {
555 setup.exp->acos(setup.cu, setup.cx);
556 setup.cu2[0] = std::acos(setup.cx[0]);
557 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
558 setup.crtol, setup.catol, out);
559 }
560 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ACosResize ) {
562 setup.exp->acos(ru, setup.x);
563 setup.computePCE1<ACosFunc>(setup.u2, setup.x);
564 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
565 setup.rtol, setup.atol, out);
566 }
567 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ATan ) {
568 setup.exp->atan(setup.u, setup.x);
569 setup.computePCE1<ATanFunc>(setup.u2, setup.x);
570 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
571 setup.rtol, setup.atol, out);
572 }
573 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ATanConst ) {
574 setup.exp->atan(setup.cu, setup.cx);
575 setup.cu2[0] = std::atan(setup.cx[0]);
576 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
577 setup.crtol, setup.catol, out);
578 }
579 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ATanResize ) {
581 setup.exp->atan(ru, setup.x);
582 setup.computePCE1<ATanFunc>(setup.u2, setup.x);
583 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
584 setup.rtol, setup.atol, out);
585 }
586 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ASinh ) {
587 setup.exp->asinh(setup.u, setup.x);
588 setup.computePCE1<ASinhFunc>(setup.u2, setup.x);
589 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
590 setup.rtol, setup.atol, out);
591 }
592 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ASinhConst ) {
593 ASinhFunc f;
594 setup.exp->asinh(setup.cu, setup.cx);
595 setup.cu2[0] = f(setup.cx[0]);
596 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
597 setup.crtol, setup.catol, out);
598 }
599 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ASinhResize ) {
601 setup.exp->asinh(ru, setup.x);
602 setup.computePCE1<ASinhFunc>(setup.u2, setup.x);
603 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
604 setup.rtol, setup.atol, out);
605 }
606 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ACosh ) {
607 setup.exp->acosh(setup.u, setup.x);
608 setup.computePCE1<ACoshFunc>(setup.u2, setup.x);
609 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
610 setup.rtol, setup.atol, out);
611 }
612 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ACoshConst ) {
613 ACoshFunc f;
614 setup.exp->acosh(setup.cu, setup.cx);
615 setup.cu2[0] = f(setup.cx[0]);
616 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
617 setup.crtol, setup.catol, out);
618 }
619 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ACoshResize ) {
621 setup.exp->acosh(ru, setup.x);
622 setup.computePCE1<ACoshFunc>(setup.u2, setup.x);
623 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
624 setup.rtol, setup.atol, out);
625 }
626 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ATanh ) {
627 setup.exp->atanh(setup.u, setup.x);
628 setup.computePCE1<ATanhFunc>(setup.u2, setup.x);
629 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
630 setup.rtol, setup.atol, out);
631 }
632 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ATanhConst ) {
633 ATanhFunc f;
634 setup.exp->atanh(setup.cu, setup.cx);
635 setup.cu2[0] = f(setup.cx[0]);
636 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
637 setup.crtol, setup.catol, out);
638 }
639 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, ATanhResize ) {
641 setup.exp->atanh(ru, setup.x);
642 setup.computePCE1<ATanhFunc>(setup.u2, setup.x);
643 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
644 setup.rtol, setup.atol, out);
645 }
646
647 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Plus ) {
649 setup.exp->sin(v, setup.x);
650 setup.exp->cos(w, setup.y);
651 setup.exp->plus(setup.u, v, w);
652 setup.computePCE2<PlusFunc>(setup.u2, v, w);
653 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
654 setup.rtol, setup.atol, out);
655 }
656 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusLC ) {
658 setup.exp->sin(v, setup.x);
659 setup.exp->plus(setup.u, setup.a, v);
660 setup.computePCE2LC<PlusFunc>(setup.u2, setup.a, v);
661 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
662 setup.rtol, setup.atol, out);
663 }
664 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusRC ) {
666 setup.exp->sin(v, setup.x);
667 setup.exp->plus(setup.u, v, setup.a);
668 setup.computePCE2RC<PlusFunc>(setup.u2, v, setup.a);
669 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
670 setup.rtol, setup.atol, out);
671 }
672 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusCC ) {
673 setup.exp->plus(setup.cu, setup.cx, setup.cx);
674 setup.computePCE2<PlusFunc>(setup.cu2, setup.cx, setup.cx);
675 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
676 setup.rtol, setup.atol, out);
677 }
678 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusLC2 ) {
680 setup.exp->sin(v, setup.x);
681 setup.exp->plus(setup.u, setup.cx, v);
682 setup.computePCE2LC<PlusFunc>(setup.u2, setup.cx[0], v);
683 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
684 setup.rtol, setup.atol, out);
685 }
686 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusRC2 ) {
688 setup.exp->sin(v, setup.x);
689 setup.exp->plus(setup.u, v, setup.cx);
690 setup.computePCE2RC<PlusFunc>(setup.u2, v, setup.cx[0]);
691 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
692 setup.rtol, setup.atol, out);
693 }
694 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusResize ) {
697 setup.exp->sin(v, setup.x);
698 setup.exp->cos(w, setup.y);
699 setup.exp->plus(ru, v, w);
700 setup.computePCE2<PlusFunc>(setup.u2, v, w);
701 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
702 setup.rtol, setup.atol, out);
703 }
704 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusLCResize ) {
707 setup.exp->sin(v, setup.x);
708 setup.exp->plus(ru, setup.a, v);
709 setup.computePCE2LC<PlusFunc>(setup.u2, setup.a, v);
710 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
711 setup.rtol, setup.atol, out);
712 }
713 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusRCResize ) {
716 setup.exp->sin(v, setup.x);
717 setup.exp->plus(ru, v, setup.a);
718 setup.computePCE2RC<PlusFunc>(setup.u2, v, setup.a);
719 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
720 setup.rtol, setup.atol, out);
721 }
722 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusLS ) {
724 setup.exp->sin(v, setup.x);
725 setup.exp->plus(setup.u, setup.sx, v);
726 setup.computePCE2<PlusFunc>(setup.u2, setup.sx, v);
727 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
728 setup.rtol, setup.atol, out);
729 }
730 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusRS ) {
732 setup.exp->sin(v, setup.x);
733 setup.exp->plus(setup.u, v, setup.sx);
734 setup.computePCE2<PlusFunc>(setup.u2, v, setup.sx);
735 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
736 setup.rtol, setup.atol, out);
737 }
738 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusLSRC ) {
739 setup.exp->plus(setup.su, setup.sx, setup.a);
740 setup.computePCE2RC<PlusFunc>(setup.su2, setup.sx, setup.a);
741 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
742 setup.rtol, setup.atol, out);
743 }
744 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusRSLC ) {
745 setup.exp->plus(setup.su, setup.a, setup.sx);
746 setup.computePCE2LC<PlusFunc>(setup.su2, setup.a, setup.sx);
747 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
748 setup.rtol, setup.atol, out);
749 }
750 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusLSRC2 ) {
751 setup.exp->plus(setup.su, setup.sx, setup.cx);
752 setup.computePCE2<PlusFunc>(setup.su2, setup.sx, setup.cx);
753 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
754 setup.rtol, setup.atol, out);
755 }
756 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusRSLC2 ) {
757 setup.exp->plus(setup.su, setup.cx, setup.sx);
758 setup.computePCE2<PlusFunc>(setup.su2, setup.cx, setup.sx);
759 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
760 setup.rtol, setup.atol, out);
761 }
762
763 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Minus ) {
765 setup.exp->sin(v, setup.x);
766 setup.exp->cos(w, setup.y);
767 setup.exp->minus(setup.u, v, w);
768 setup.computePCE2<MinusFunc>(setup.u2, v, w);
769 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
770 setup.rtol, setup.atol, out);
771 }
772 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusLC ) {
774 setup.exp->sin(v, setup.x);
775 setup.exp->minus(setup.u, setup.a, v);
776 setup.computePCE2LC<MinusFunc>(setup.u2, setup.a, v);
777 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
778 setup.rtol, setup.atol, out);
779 }
780 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusRC ) {
782 setup.exp->sin(v, setup.x);
783 setup.exp->minus(setup.u, v, setup.a);
784 setup.computePCE2RC<MinusFunc>(setup.u2, v, setup.a);
785 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
786 setup.rtol, setup.atol, out);
787 }
788 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusCC ) {
789 setup.exp->minus(setup.cu, setup.cx, setup.cx);
790 setup.computePCE2<MinusFunc>(setup.cu2, setup.cx, setup.cx);
791 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
792 setup.rtol, setup.atol, out);
793 }
794 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusLC2 ) {
796 setup.exp->sin(v, setup.x);
797 setup.exp->minus(setup.u, setup.cx, v);
798 setup.computePCE2LC<MinusFunc>(setup.u2, setup.cx[0], v);
799 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
800 setup.rtol, setup.atol, out);
801 }
802 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusRC2 ) {
804 setup.exp->sin(v, setup.x);
805 setup.exp->minus(setup.u, v, setup.cx);
806 setup.computePCE2RC<MinusFunc>(setup.u2, v, setup.cx[0]);
807 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
808 setup.rtol, setup.atol, out);
809 }
810 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusResize ) {
813 setup.exp->sin(v, setup.x);
814 setup.exp->cos(w, setup.y);
815 setup.exp->minus(ru, v, w);
816 setup.computePCE2<MinusFunc>(setup.u2, v, w);
817 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
818 setup.rtol, setup.atol, out);
819 }
820 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusLCResize ) {
823 setup.exp->sin(v, setup.x);
824 setup.exp->minus(ru, setup.a, v);
825 setup.computePCE2LC<MinusFunc>(setup.u2, setup.a, v);
826 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
827 setup.rtol, setup.atol, out);
828 }
829 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusRCResize ) {
832 setup.exp->sin(v, setup.x);
833 setup.exp->minus(ru, v, setup.a);
834 setup.computePCE2RC<MinusFunc>(setup.u2, v, setup.a);
835 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
836 setup.rtol, setup.atol, out);
837 }
838 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusLS ) {
840 setup.exp->sin(v, setup.x);
841 setup.exp->minus(setup.u, setup.sx, v);
842 setup.computePCE2<MinusFunc>(setup.u2, setup.sx, v);
843 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
844 setup.rtol, setup.atol, out);
845 }
846 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusRS ) {
848 setup.exp->sin(v, setup.x);
849 setup.exp->minus(setup.u, v, setup.sx);
850 setup.computePCE2<MinusFunc>(setup.u2, v, setup.sx);
851 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
852 setup.rtol, setup.atol, out);
853 }
854 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusLSRC ) {
855 setup.exp->minus(setup.su, setup.sx, setup.a);
856 setup.computePCE2RC<MinusFunc>(setup.su2, setup.sx, setup.a);
857 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
858 setup.rtol, setup.atol, out);
859 }
860 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusRSLC ) {
861 setup.exp->minus(setup.su, setup.a, setup.sx);
862 setup.computePCE2LC<MinusFunc>(setup.su2, setup.a, setup.sx);
863 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
864 setup.rtol, setup.atol, out);
865 }
866 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusLSRC2 ) {
867 setup.exp->minus(setup.su, setup.sx, setup.cx);
868 setup.computePCE2<MinusFunc>(setup.su2, setup.sx, setup.cx);
869 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
870 setup.rtol, setup.atol, out);
871 }
872 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusRSLC2 ) {
873 setup.exp->minus(setup.su, setup.cx, setup.sx);
874 setup.computePCE2<MinusFunc>(setup.su2, setup.cx, setup.sx);
875 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
876 setup.rtol, setup.atol, out);
877 }
878
879 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Times ) {
881 setup.exp->sin(v, setup.x);
882 setup.exp->cos(w, setup.y);
883 setup.exp->times(setup.u, v, w);
884 setup.computePCE2<TimesFunc>(setup.u2, v, w);
885 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
886 setup.rtol, setup.atol, out);
887 }
888 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLC ) {
890 setup.exp->sin(v, setup.x);
891 setup.exp->times(setup.u, setup.a, v);
892 setup.computePCE2LC<TimesFunc>(setup.u2, setup.a, v);
893 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
894 setup.rtol, setup.atol, out);
895 }
896 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRC ) {
898 setup.exp->sin(v, setup.x);
899 setup.exp->times(setup.u, v, setup.a);
900 setup.computePCE2RC<TimesFunc>(setup.u2, v, setup.a);
901 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
902 setup.rtol, setup.atol, out);
903 }
904 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesCC ) {
905 setup.exp->times(setup.cu, setup.cx, setup.cx);
906 setup.computePCE2<TimesFunc>(setup.cu2, setup.cx, setup.cx);
907 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
908 setup.rtol, setup.atol, out);
909 }
910 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLC2 ) {
912 setup.exp->sin(v, setup.x);
913 setup.exp->times(setup.u, setup.cx, v);
914 setup.computePCE2LC<TimesFunc>(setup.u2, setup.cx[0], v);
915 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
916 setup.rtol, setup.atol, out);
917 }
918 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRC2 ) {
920 setup.exp->sin(v, setup.x);
921 setup.exp->times(setup.u, v, setup.cx);
922 setup.computePCE2RC<TimesFunc>(setup.u2, v, setup.cx[0]);
923 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
924 setup.rtol, setup.atol, out);
925 }
926 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesResize ) {
929 setup.exp->sin(v, setup.x);
930 setup.exp->cos(w, setup.y);
931 setup.exp->times(ru, v, w);
932 setup.computePCE2<TimesFunc>(setup.u2, v, w);
933 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
934 setup.rtol, setup.atol, out);
935 }
936 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLCResize ) {
939 setup.exp->sin(v, setup.x);
940 setup.exp->times(ru, setup.a, v);
941 setup.computePCE2LC<TimesFunc>(setup.u2, setup.a, v);
942 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
943 setup.rtol, setup.atol, out);
944 }
945 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRCResize ) {
948 setup.exp->sin(v, setup.x);
949 setup.exp->times(ru, v, setup.a);
950 setup.computePCE2RC<TimesFunc>(setup.u2, v, setup.a);
951 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
952 setup.rtol, setup.atol, out);
953 }
954 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLS ) {
956 setup.exp->sin(v, setup.x);
957 setup.exp->times(setup.u, setup.sx, v);
958 setup.computePCE2<TimesFunc>(setup.u2, setup.sx, v);
959 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
960 setup.rtol, setup.atol, out);
961 }
962 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRS ) {
964 setup.exp->sin(v, setup.x);
965 setup.exp->times(setup.u, v, setup.sx);
966 setup.computePCE2<TimesFunc>(setup.u2, v, setup.sx);
967 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
968 setup.rtol, setup.atol, out);
969 }
970 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLSLinear ) {
972 setup.exp->sin(v, setup.x);
973 setup.exp_linear->times(setup.u, setup.sx, v);
974 setup.computePCE2<TimesFunc>(setup.u2, setup.sx, v);
975 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
976 setup.rtol, setup.atol, out);
977 }
978 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRSLinear ) {
980 setup.exp->sin(v, setup.x);
981 setup.exp_linear->times(setup.u, v, setup.sx);
982 setup.computePCE2<TimesFunc>(setup.u2, v, setup.sx);
983 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
984 setup.rtol, setup.atol, out);
985 }
986 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLSRC ) {
987 setup.exp->times(setup.su, setup.sx, setup.a);
988 setup.computePCE2RC<TimesFunc>(setup.su2, setup.sx, setup.a);
989 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
990 setup.rtol, setup.atol, out);
991 }
992 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRSLC ) {
993 setup.exp->times(setup.su, setup.a, setup.sx);
994 setup.computePCE2LC<TimesFunc>(setup.su2, setup.a, setup.sx);
995 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
996 setup.rtol, setup.atol, out);
997 }
998 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesLSRC2 ) {
999 setup.exp->times(setup.su, setup.sx, setup.cx);
1000 setup.computePCE2<TimesFunc>(setup.su2, setup.sx, setup.cx);
1001 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1002 setup.rtol, setup.atol, out);
1003 }
1004 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesRSLC2 ) {
1005 setup.exp->times(setup.su, setup.cx, setup.sx);
1006 setup.computePCE2<TimesFunc>(setup.su2, setup.cx, setup.sx);
1007 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1008 setup.rtol, setup.atol, out);
1009 }
1010
1011 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Divide ) {
1013 setup.exp->sin(v, setup.x);
1014 setup.exp->exp(w, setup.y);
1015 setup.exp->divide(setup.u, v, w);
1016 setup.computePCE2<DivideFunc>(setup.u2, v, w);
1017 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1018 setup.rtol, setup.atol, out);
1019 }
1020 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideLC ) {
1022 setup.exp->sin(v, setup.x);
1023 setup.exp->divide(setup.u, setup.a, v);
1024 setup.computePCE2LC<DivideFunc>(setup.u2, setup.a, v);
1025 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1026 setup.rtol, setup.atol, out);
1027 }
1028 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideRC ) {
1030 setup.exp->sin(v, setup.x);
1031 setup.exp->divide(setup.u, v, setup.a);
1032 setup.computePCE2RC<DivideFunc>(setup.u2, v, setup.a);
1033 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1034 setup.rtol, setup.atol, out);
1035 }
1036 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideCC ) {
1037 setup.exp->divide(setup.cu, setup.cx, setup.cx);
1038 setup.computePCE2<DivideFunc>(setup.cu2, setup.cx, setup.cx);
1039 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
1040 setup.rtol, setup.atol, out);
1041 }
1042 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideLC2 ) {
1044 setup.exp->sin(v, setup.x);
1045 setup.exp->divide(setup.u, setup.cx, v);
1046 setup.computePCE2LC<DivideFunc>(setup.u2, setup.cx[0], v);
1047 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1048 setup.rtol, setup.atol, out);
1049 }
1050 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideRC2 ) {
1052 setup.exp->sin(v, setup.x);
1053 setup.exp->divide(setup.u, v, setup.cx);
1054 setup.computePCE2RC<DivideFunc>(setup.u2, v, setup.cx[0]);
1055 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1056 setup.rtol, setup.atol, out);
1057 }
1058 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideResize ) {
1061 setup.exp->sin(v, setup.x);
1062 setup.exp->exp(w, setup.y);
1063 setup.exp->divide(ru, v, w);
1064 setup.computePCE2<DivideFunc>(setup.u2, v, w);
1065 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1066 setup.rtol, setup.atol, out);
1067 }
1068 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideLCResize ) {
1071 setup.exp->sin(v, setup.x);
1072 setup.exp->divide(ru, setup.a, v);
1073 setup.computePCE2LC<DivideFunc>(setup.u2, setup.a, v);
1074 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1075 setup.rtol, setup.atol, out);
1076 }
1077 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideRCResize ) {
1080 setup.exp->sin(v, setup.x);
1081 setup.exp->divide(ru, v, setup.a);
1082 setup.computePCE2RC<DivideFunc>(setup.u2, v, setup.a);
1083 success = Stokhos::comparePCEs(ru, "u", setup.u2, "u2",
1084 setup.rtol, setup.atol, out);
1085 }
1086 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideLS ) {
1088 setup.exp->sin(v, setup.x);
1089 setup.exp->divide(setup.u, setup.sx, v);
1090 setup.computePCE2<DivideFunc>(setup.u2, setup.sx, v);
1091 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1092 setup.rtol, setup.atol, out);
1093 }
1094 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideRS ) {
1096 setup.exp->sin(v, setup.x);
1097 setup.exp->divide(setup.u, v, setup.sx);
1098 setup.computePCE2<DivideFunc>(setup.u2, v, setup.sx);
1099 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1100 setup.rtol, setup.atol, out);
1101 }
1102 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideLSRC ) {
1103 setup.exp->divide(setup.su, setup.sx, setup.a);
1104 setup.computePCE2RC<DivideFunc>(setup.su2, setup.sx, setup.a);
1105 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1106 setup.rtol, setup.atol, out);
1107 }
1108 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideRSLC ) {
1109 setup.exp->divide(setup.u, setup.a, setup.sx);
1110 setup.computePCE2LC<DivideFunc>(setup.u2, setup.a, setup.sx);
1111 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1112 setup.rtol, setup.atol, out);
1113 }
1114 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideLSRC2 ) {
1115 setup.exp->divide(setup.su, setup.sx, setup.cx);
1116 setup.computePCE2<DivideFunc>(setup.su2, setup.sx, setup.cx);
1117 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1118 setup.rtol, setup.atol, out);
1119 }
1120 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideRSLC2 ) {
1121 setup.exp->divide(setup.u, setup.cx, setup.sx);
1122 setup.computePCE2<DivideFunc>(setup.u2, setup.cx, setup.sx);
1123 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1124 setup.rtol, setup.atol, out);
1125 }
1126
1127 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, Pow ) {
1128 setup.exp->pow(setup.u, setup.x, setup.y);
1129 setup.computePCE2<PowFunc>(setup.u2, setup.x, setup.y);
1130 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1131 setup.rtol, setup.atol, out);
1132 }
1133 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowLC ) {
1134 setup.exp->pow(setup.u, setup.a, setup.y);
1135 setup.computePCE2LC<PowFunc>(setup.u2, setup.a, setup.y);
1136 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1137 setup.rtol, setup.atol, out);
1138 }
1139 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowRC ) {
1140 setup.exp->pow(setup.u, setup.x, setup.a);
1141 setup.computePCE2RC<PowFunc>(setup.u2, setup.x, setup.a);
1142 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1143 setup.rtol, setup.atol, out);
1144 }
1145 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowCC ) {
1146 setup.exp->pow(setup.cu, setup.cx, setup.cx);
1147 setup.computePCE2<PowFunc>(setup.cu2, setup.cx, setup.cx);
1148 success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
1149 setup.rtol, setup.atol, out);
1150 }
1151 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowLC2 ) {
1152 setup.exp->pow(setup.u, setup.cx, setup.y);
1153 setup.computePCE2LC<PowFunc>(setup.u2, setup.cx[0], setup.y);
1154 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1155 setup.rtol, setup.atol, out);
1156 }
1157 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowRC2 ) {
1158 setup.exp->pow(setup.u, setup.x, setup.cx);
1159 setup.computePCE2RC<PowFunc>(setup.u2, setup.x, setup.cx[0]);
1160 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1161 setup.rtol, setup.atol, out);
1162 }
1163 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowResize ) {
1165 setup.exp->pow(ru, setup.x, setup.y);
1166 setup.computePCE2<PowFunc>(setup.u2, setup.x, setup.y);
1167 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1168 setup.rtol, setup.atol, out);
1169 }
1170 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowLCResize ) {
1172 setup.exp->pow(ru, setup.a, setup.y);
1173 setup.computePCE2LC<PowFunc>(setup.u2, setup.a, setup.y);
1174 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1175 setup.rtol, setup.atol, out);
1176 }
1177 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowRCResize ) {
1179 setup.exp->pow(ru, setup.x, setup.a);
1180 setup.computePCE2RC<PowFunc>(setup.u2, setup.x, setup.a);
1181 success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1182 setup.rtol, setup.atol, out);
1183 }
1184 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowLS ) {
1185 setup.exp->pow(setup.u, setup.sx, setup.y);
1186 setup.computePCE2<PowFunc>(setup.u2, setup.sx, setup.y);
1187 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1188 setup.rtol, setup.atol, out);
1189 }
1190 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowRS ) {
1191 setup.exp->pow(setup.u, setup.x, setup.sx);
1192 setup.computePCE2<PowFunc>(setup.u2, setup.x, setup.sx);
1193 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1194 setup.rtol, setup.atol, out);
1195 }
1196 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowLSRC ) {
1197 setup.exp->pow(setup.u, setup.sx, setup.a);
1198 setup.computePCE2RC<PowFunc>(setup.u2, setup.sx, setup.a);
1199 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1200 setup.rtol, setup.atol, out);
1201 }
1202 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowRSLC ) {
1203 setup.exp->pow(setup.u, setup.a, setup.sx);
1204 setup.computePCE2LC<PowFunc>(setup.u2, setup.a, setup.sx);
1205 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1206 setup.rtol, setup.atol, out);
1207 }
1208 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowLSRC2 ) {
1209 setup.exp->pow(setup.u, setup.sx, setup.cx);
1210 setup.computePCE2<PowFunc>(setup.u2, setup.sx, setup.cx);
1211 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1212 setup.rtol, setup.atol, out);
1213 }
1214 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PowRSLC2 ) {
1215 setup.exp->pow(setup.u, setup.cx, setup.sx);
1216 setup.computePCE2<PowFunc>(setup.u2, setup.cx, setup.sx);
1217 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1218 setup.rtol, setup.atol, out);
1219 }
1220
1221 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqual ) {
1223 setup.exp->sin(v, setup.x);
1224 setup.exp->cos(setup.u, setup.x);
1225 setup.computePCE2<PlusFunc>(setup.u2, setup.u, v);
1226 setup.exp->plusEqual(setup.u, v);
1227 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1228 setup.rtol, setup.atol, out);
1229 }
1230 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqualC ) {
1231 setup.exp->cos(setup.u, setup.x);
1232 setup.computePCE2RC<PlusFunc>(setup.u2, setup.u, setup.a);
1233 setup.exp->plusEqual(setup.u, setup.a);
1234 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1235 setup.rtol, setup.atol, out);
1236 }
1237 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqualC2 ) {
1238 setup.exp->cos(setup.u, setup.x);
1239 setup.computePCE2RC<PlusFunc>(setup.u2, setup.u, setup.cx[0]);
1240 setup.exp->plusEqual(setup.u, setup.cx);
1241 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1242 setup.rtol, setup.atol, out);
1243 }
1244 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqualResize ) {
1247 setup.exp->sin(v, setup.x);
1248 setup.exp->plusEqual(ru, v);
1249 success = Stokhos::comparePCEs(ru, "ru", v, "v",
1250 setup.rtol, setup.atol, out);
1251 }
1252 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqualS ) {
1253 setup.exp->cos(setup.u, setup.x);
1254 setup.computePCE2<PlusFunc>(setup.u2, setup.u, setup.sx);
1255 setup.exp->plusEqual(setup.u, setup.sx);
1256 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1257 setup.rtol, setup.atol, out);
1258 }
1259 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqualSC ) {
1260 setup.su = setup.sx;
1261 setup.computePCE2RC<PlusFunc>(setup.su2, setup.su, setup.a);
1262 setup.exp->plusEqual(setup.su, setup.a);
1263 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1264 setup.rtol, setup.atol, out);
1265 }
1266 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, PlusEqualSC2 ) {
1267 setup.su = setup.sx;
1268 setup.computePCE2<PlusFunc>(setup.su2, setup.su, setup.cx);
1269 setup.exp->plusEqual(setup.su, setup.cx);
1270 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1271 setup.rtol, setup.atol, out);
1272 }
1273
1274 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqual ) {
1276 setup.exp->sin(v, setup.x);
1277 setup.exp->cos(setup.u, setup.x);
1278 setup.computePCE2<MinusFunc>(setup.u2, setup.u, v);
1279 setup.exp->minusEqual(setup.u, v);
1280 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1281 setup.rtol, setup.atol, out);
1282 }
1283 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqualC ) {
1284 setup.exp->cos(setup.u, setup.x);
1285 setup.computePCE2RC<MinusFunc>(setup.u2, setup.u, setup.a);
1286 setup.exp->minusEqual(setup.u, setup.a);
1287 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1288 setup.rtol, setup.atol, out);
1289 }
1290 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqualC2 ) {
1291 setup.exp->cos(setup.u, setup.x);
1292 setup.computePCE2RC<MinusFunc>(setup.u2, setup.u, setup.cx[0]);
1293 setup.exp->minusEqual(setup.u, setup.cx);
1294 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1295 setup.rtol, setup.atol, out);
1296 }
1297 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqualResize ) {
1300 setup.exp->sin(v, setup.x);
1301 setup.exp->minusEqual(ru, v);
1302 setup.exp->unaryMinus(v, v);
1303 success = Stokhos::comparePCEs(ru, "ru", v, "v",
1304 setup.rtol, setup.atol, out);
1305 }
1306 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqualS ) {
1307 setup.exp->cos(setup.u, setup.x);
1308 setup.computePCE2<MinusFunc>(setup.u2, setup.u, setup.sx);
1309 setup.exp->minusEqual(setup.u, setup.sx);
1310 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1311 setup.rtol, setup.atol, out);
1312 }
1313 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqualSC ) {
1314 setup.su = setup.sx;
1315 setup.computePCE2RC<MinusFunc>(setup.su2, setup.su, setup.a);
1316 setup.exp->minusEqual(setup.su, setup.a);
1317 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1318 setup.rtol, setup.atol, out);
1319 }
1320 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, MinusEqualSC2 ) {
1321 setup.su = setup.sx;
1322 setup.computePCE2<MinusFunc>(setup.su2, setup.su, setup.cx);
1323 setup.exp->minusEqual(setup.su, setup.cx);
1324 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1325 setup.rtol, setup.atol, out);
1326 }
1327
1328 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqual ) {
1330 setup.exp->sin(v, setup.x);
1331 setup.exp->cos(setup.u, setup.x);
1332 setup.computePCE2<TimesFunc>(setup.u2, setup.u, v);
1333 setup.exp->timesEqual(setup.u, v);
1334 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1335 setup.rtol, setup.atol, out);
1336 }
1337 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualC ) {
1338 setup.exp->cos(setup.u, setup.x);
1339 setup.computePCE2RC<TimesFunc>(setup.u2, setup.u, setup.a);
1340 setup.exp->timesEqual(setup.u, setup.a);
1341 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1342 setup.rtol, setup.atol, out);
1343 }
1344 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualC2 ) {
1345 setup.exp->cos(setup.u, setup.x);
1346 setup.computePCE2RC<TimesFunc>(setup.u2, setup.u, setup.cx[0]);
1347 setup.exp->timesEqual(setup.u, setup.cx);
1348 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1349 setup.rtol, setup.atol, out);
1350 }
1351 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualResize ) {
1353 setup.exp->sin(v, setup.x);
1354 setup.su = setup.sx;
1355 setup.computePCE2<TimesFunc>(setup.u2, setup.su, v);
1356 setup.exp->timesEqual(setup.su, v);
1357 success = Stokhos::comparePCEs(setup.su, "su", setup.u2, "u2",
1358 setup.rtol, setup.atol, out);
1359 }
1360 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualS ) {
1361 setup.exp->cos(setup.u, setup.x);
1362 setup.computePCE2<TimesFunc>(setup.u2, setup.u, setup.sx);
1363 setup.exp->timesEqual(setup.u, setup.sx);
1364 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1365 setup.rtol, setup.atol, out);
1366 }
1367 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualSLinear ) {
1368 setup.exp->cos(setup.u, setup.x);
1369 setup.computePCE2<TimesFunc>(setup.u2, setup.u, setup.sx);
1370 setup.exp_linear->timesEqual(setup.u, setup.sx);
1371 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1372 setup.rtol, setup.atol, out);
1373 }
1374 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualSC ) {
1375 setup.su = setup.sx;
1376 setup.computePCE2RC<TimesFunc>(setup.su2, setup.su, setup.a);
1377 setup.exp->timesEqual(setup.su, setup.a);
1378 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1379 setup.rtol, setup.atol, out);
1380 }
1381 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, TimesEqualSC2 ) {
1382 setup.su = setup.sx;
1383 setup.computePCE2<TimesFunc>(setup.su2, setup.su, setup.cx);
1384 setup.exp->timesEqual(setup.su, setup.cx);
1385 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1386 setup.rtol, setup.atol, out);
1387 }
1388
1389 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqual ) {
1391 setup.exp->sin(v, setup.x);
1392 setup.exp->cos(setup.u, setup.x);
1393 setup.computePCE2<DivideFunc>(setup.u2, setup.u, v);
1394 setup.exp->divideEqual(setup.u, v);
1395 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1396 setup.rtol, setup.atol, out);
1397 }
1398 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqualC ) {
1399 setup.exp->cos(setup.u, setup.x);
1400 setup.computePCE2RC<DivideFunc>(setup.u2, setup.u, setup.a);
1401 setup.exp->divideEqual(setup.u, setup.a);
1402 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1403 setup.rtol, setup.atol, out);
1404 }
1405 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqualC2 ) {
1406 setup.exp->cos(setup.u, setup.x);
1407 setup.computePCE2RC<DivideFunc>(setup.u2, setup.u, setup.cx[0]);
1408 setup.exp->divideEqual(setup.u, setup.cx);
1409 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1410 setup.rtol, setup.atol, out);
1411 }
1412 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqualResize ) {
1414 setup.exp->sin(v, setup.x);
1415 setup.su = setup.sx;
1416 setup.computePCE2<DivideFunc>(setup.u2, setup.su, v);
1417 setup.exp->divideEqual(setup.su, v);
1418 success = Stokhos::comparePCEs(setup.su, "su", setup.u2, "u2",
1419 setup.rtol, setup.atol, out);
1420 }
1421 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqualS ) {
1422 setup.exp->cos(setup.u, setup.x);
1423 setup.computePCE2<DivideFunc>(setup.u2, setup.u, setup.sx);
1424 setup.exp->divideEqual(setup.u, setup.sx);
1425 success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1426 setup.rtol, setup.atol, out);
1427 }
1428 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqualSC ) {
1429 setup.su = setup.sx;
1430 setup.computePCE2RC<DivideFunc>(setup.su2, setup.su, setup.a);
1431 setup.exp->divideEqual(setup.su, setup.a);
1432 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1433 setup.rtol, setup.atol, out);
1434 }
1435 TEUCHOS_UNIT_TEST( Stokhos_QuadExpansion, DivideEqualSC2 ) {
1436 setup.su = setup.sx;
1437 setup.computePCE2<DivideFunc>(setup.su2, setup.su, setup.cx);
1438 setup.exp->divideEqual(setup.su, setup.cx);
1439 success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1440 setup.rtol, setup.atol, out);
1441 }
1442
1443 // Not testing atan2(), max(), min(), abs(), fabs() since these are
1444 // not smooth functions
1445
1446}
1447
1448int main( int argc, char* argv[] ) {
1449 Teuchos::GlobalMPISession mpiSession(&argc, &argv);
1450 return Teuchos::UnitTestRepository::runUnitTestsFromMain(argc, argv);
1451}
expr val()
int main(int argc, char *argv[])
Multivariate orthogonal polynomial basis generated from a total-order complete-polynomial tensor prod...
Legendre polynomial basis.
Class to store coefficients of a projection onto an orthogonal polynomial basis.
void reset(const Teuchos::RCP< const Stokhos::OrthogPolyBasis< ordinal_type, value_type > > &new_basis, ordinal_type sz=0)
Reset to a new basis.
reference term(ordinal_type dimension, ordinal_type order)
Get coefficient term for given dimension and order.
ordinal_type size() const
Return size.
value_type evaluate(const Teuchos::Array< value_type > &point) const
Evaluate polynomial approximation at a point.
Orthogonal polynomial expansions based on numerical quadrature.
Defines quadrature for a tensor product basis by tensor products of 1-D quadrature rules.
ScalarType f(const Teuchos::Array< ScalarType > &x, double a, double b)
TEUCHOS_UNIT_TEST(Stokhos_QuadExpansion, UMinus)
UnitTestSetup< int, double > setup
bool comparePCEs(const PCEType &a1, const std::string &a1_name, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a2, const std::string &a2_name, const ValueType &rel_tol, const ValueType &abs_tol, Teuchos::FancyOStream &out)
double operator()(double a, double b) const
double operator()(double a, double b) const
double operator()(double a, double b) const
double operator()(double a, double b) const
double operator()(double a, double b) const
void computePCE2LC(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, ValueType a, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &b)
void computePCE2RC(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a, ValueType b)
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > x
void computePCE2(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &b)
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > cx
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > sx
Teuchos::RCP< Stokhos::QuadOrthogPolyExpansion< OrdinalType, ValueType > > exp
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > su
Teuchos::RCP< const Stokhos::Quadrature< OrdinalType, ValueType > > quad
Teuchos::RCP< Stokhos::QuadOrthogPolyExpansion< OrdinalType, ValueType > > exp_linear
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > cu2
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > y
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > su2
Teuchos::RCP< Stokhos::Sparse3Tensor< int, double > > Cijk
void computePCE1(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a)
Teuchos::RCP< Stokhos::Sparse3Tensor< int, double > > Cijk_linear
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > u2
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > u
Stokhos::OrthogPolyApprox< OrdinalType, ValueType > cu
Teuchos::RCP< const Stokhos::CompletePolynomialBasis< OrdinalType, ValueType > > basis