Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
Stokhos_PseudoSpectralExpansionUnitTest.hpp
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 namespace PseudoSpectralExpansionUnitTest {
45 
46  template <class Func, typename OrdinalType, typename ValueType>
47  void computePCE1(Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& c,
48  const Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& a,
49  const Stokhos::Quadrature<OrdinalType,ValueType>& quad)
50  {
51  // Basis
52  Teuchos::RCP<const Stokhos::OrthogPolyBasis<OrdinalType,ValueType> > basis
53  = a.basis();
54 
55  // Quadrature data
56  const Teuchos::Array<ValueType>& weights = quad.getQuadWeights();
57  const Teuchos::Array< Teuchos::Array<ValueType> >& points =
58  quad.getQuadPoints();
59  const Teuchos::Array< Teuchos::Array<ValueType> >& values =
60  quad.getBasisAtQuadPoints();
61  OrdinalType nqp = weights.size();
62 
63  // Initialize
64  for (OrdinalType i=0; i<c.size(); i++)
65  c[i] = 0.0;
66 
67  // Compute PCE via quadrature
68  Func func;
69  for (OrdinalType k=0; k<nqp; k++) {
70  ValueType val = a.evaluate(points[k], values[k]);
71  val = func(val);
72  for (int i=0; i<c.size(); i++)
73  c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
74  }
75  }
76 
77  template <class Func, typename OrdinalType, typename ValueType>
78  void computePCE2(Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& c,
79  const Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& a,
80  const Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& b,
81  const Stokhos::Quadrature<OrdinalType,ValueType>& quad)
82  {
83  // Basis
84  Teuchos::RCP<const Stokhos::OrthogPolyBasis<OrdinalType,ValueType> > basis
85  = a.basis();
86 
87  // Quadrature data
88  const Teuchos::Array<ValueType>& weights = quad.getQuadWeights();
89  const Teuchos::Array< Teuchos::Array<ValueType> >& points =
90  quad.getQuadPoints();
91  const Teuchos::Array< Teuchos::Array<ValueType> >& values =
92  quad.getBasisAtQuadPoints();
93  OrdinalType nqp = weights.size();
94 
95  // Initialize
96  for (OrdinalType i=0; i<c.size(); i++)
97  c[i] = 0.0;
98 
99  // Compute PCE via quadrature
100  Func func;
101  for (OrdinalType k=0; k<nqp; k++) {
102  ValueType val1 = a.evaluate(points[k], values[k]);
103  ValueType val2 = b.evaluate(points[k], values[k]);
104  ValueType val = func(val1, val2);
105  for (int i=0; i<c.size(); i++)
106  c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
107  }
108  }
109 
110  template <class Func, typename OrdinalType, typename ValueType>
111  void computePCE2LC(
112  Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& c,
113  ValueType a,
114  const Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& b,
115  const Stokhos::Quadrature<OrdinalType,ValueType>& quad)
116  {
117  // Basis
118  Teuchos::RCP<const Stokhos::OrthogPolyBasis<OrdinalType,ValueType> > basis
119  = b.basis();
120 
121  // Quadrature data
122  const Teuchos::Array<ValueType>& weights = quad.getQuadWeights();
123  const Teuchos::Array< Teuchos::Array<ValueType> >& points =
124  quad.getQuadPoints();
125  const Teuchos::Array< Teuchos::Array<ValueType> >& values =
126  quad.getBasisAtQuadPoints();
127  OrdinalType nqp = weights.size();
128 
129  // Initialize
130  for (OrdinalType i=0; i<c.size(); i++)
131  c[i] = 0.0;
132 
133  // Compute PCE via quadrature
134  Func func;
135  for (OrdinalType k=0; k<nqp; k++) {
136  ValueType val2 = b.evaluate(points[k], values[k]);
137  ValueType val = func(a, val2);
138  for (int i=0; i<c.size(); i++)
139  c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
140  }
141  }
142 
143  template <class Func, typename OrdinalType, typename ValueType>
144  void computePCE2RC(
145  Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& c,
146  const Stokhos::OrthogPolyApprox<OrdinalType,ValueType>& a,
147  ValueType b,
148  const Stokhos::Quadrature<OrdinalType,ValueType>& quad)
149  {
150  // Basis
151  Teuchos::RCP<const Stokhos::OrthogPolyBasis<OrdinalType,ValueType> > basis
152  = a.basis();
153 
154  // Quadrature data
155  const Teuchos::Array<ValueType>& weights = quad.getQuadWeights();
156  const Teuchos::Array< Teuchos::Array<ValueType> >& points =
157  quad.getQuadPoints();
158  const Teuchos::Array< Teuchos::Array<ValueType> >& values =
159  quad.getBasisAtQuadPoints();
160  OrdinalType nqp = weights.size();
161 
162  // Initialize
163  for (OrdinalType i=0; i<c.size(); i++)
164  c[i] = 0.0;
165 
166  // Compute PCE via quadrature
167  Func func;
168  for (OrdinalType k=0; k<nqp; k++) {
169  ValueType val1 = a.evaluate(points[k], values[k]);
170  ValueType val = func(val1, b);
171  for (int i=0; i<c.size(); i++)
172  c[i] += weights[k]*val*values[k][i] / basis->norm_squared(i);
173  }
174  }
175 
176  struct UMinusFunc {
177  double operator() (double a) const { return -a; }
178  };
179  struct ExpFunc {
180  double operator() (double a) const { return std::exp(a); }
181  };
182  struct LogFunc {
183  double operator() (double a) const { return std::log(a); }
184  };
185  struct Log10Func {
186  double operator() (double a) const { return std::log10(a); }
187  };
188  struct SqrtFunc {
189  double operator() (double a) const { return std::sqrt(a); }
190  };
191  struct CbrtFunc {
192  double operator() (double a) const { return std::cbrt(a); }
193  };
194  struct SinFunc {
195  double operator() (double a) const { return std::sin(a); }
196  };
197  struct CosFunc {
198  double operator() (double a) const { return std::cos(a); }
199  };
200  struct TanFunc {
201  double operator() (double a) const { return std::tan(a); }
202  };
203  struct SinhFunc {
204  double operator() (double a) const { return std::sinh(a); }
205  };
206  struct CoshFunc {
207  double operator() (double a) const { return std::cosh(a); }
208  };
209  struct TanhFunc {
210  double operator() (double a) const { return std::tanh(a); }
211  };
212  struct ASinFunc {
213  double operator() (double a) const { return std::asin(a); }
214  };
215  struct ACosFunc {
216  double operator() (double a) const { return std::acos(a); }
217  };
218  struct ATanFunc {
219  double operator() (double a) const { return std::atan(a); }
220  };
221  struct ASinhFunc {
222  double operator() (double a) const {
223  return std::log(a+std::sqrt(a*a+1.0));
224  }
225  };
226  struct ACoshFunc {
227  double operator() (double a) const {
228  return std::log(a+std::sqrt(a*a-1.0));
229  }
230  };
231  struct ATanhFunc {
232  double operator() (double a) const {
233  return 0.5*std::log((1.0+a)/(1.0-a));
234  }
235  };
236 
237  struct PlusFunc {
238  double operator() (double a, double b) const { return a + b; }
239  };
240  struct MinusFunc {
241  double operator() (double a, double b) const { return a - b; }
242  };
243  struct TimesFunc {
244  double operator() (double a, double b) const { return a * b; }
245  };
246  struct DivideFunc {
247  double operator() (double a, double b) const { return a / b; }
248  };
249  struct PowFunc {
250  double operator() (double a, double b) const { return std::pow(a,b); }
251  };
252 
253  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, UMinus ) {
254  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
255  setup.exp->sin(v, setup.x);
256  setup.exp->unaryMinus(setup.u, v);
257  computePCE1<UMinusFunc>(setup.u2, v, *setup.quad);
258  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
259  setup.rtol, setup.atol, out);
260  }
261  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Exp ) {
262  setup.exp->exp(setup.u, setup.x);
263  computePCE1<ExpFunc>(setup.u2, setup.x, *setup.quad);
264  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
265  setup.rtol, setup.atol, out);
266  }
267  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ExpConst ) {
268  setup.exp->exp(setup.cu, setup.cx);
269  setup.cu2[0] = std::exp(setup.cx[0]);
270  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
271  setup.crtol, setup.catol, out);
272  }
273  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ExpResize ) {
274  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
275  setup.exp->exp(ru, setup.x);
276  computePCE1<ExpFunc>(setup.u2, setup.x, *setup.quad);
277  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
278  setup.rtol, setup.atol, out);
279  }
280  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Log ) {
281  setup.exp->log(setup.u, setup.x);
282  computePCE1<LogFunc>(setup.u2, setup.x, *setup.quad);
283  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
284  setup.rtol, setup.atol, out);
285  }
286  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, LogConst ) {
287  setup.exp->log(setup.cu, setup.cx);
288  setup.cu2[0] = std::log(setup.cx[0]);
289  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
290  setup.crtol, setup.catol, out);
291  }
292  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, LogResize ) {
293  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
294  setup.exp->log(ru, setup.x);
295  computePCE1<LogFunc>(setup.u2, setup.x, *setup.quad);
296  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
297  setup.rtol, setup.atol, out);
298  }
299  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Log10 ) {
300  setup.exp->log10(setup.u, setup.x);
301  computePCE1<Log10Func>(setup.u2, setup.x, *setup.quad);
302  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
303  setup.rtol, setup.atol, out);
304  }
305  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Log10Const ) {
306  setup.exp->log10(setup.cu, setup.cx);
307  setup.cu2[0] = std::log10(setup.cx[0]);
308  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
309  setup.crtol, setup.catol, out);
310  }
311  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Log10Resize ) {
312  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
313  setup.exp->log10(ru, setup.x);
314  computePCE1<Log10Func>(setup.u2, setup.x, *setup.quad);
315  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
316  setup.rtol, setup.atol, out);
317  }
318  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Sqrt ) {
319  setup.exp->sqrt(setup.u, setup.x);
320  computePCE1<SqrtFunc>(setup.u2, setup.x, *setup.quad);
321  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
322  setup.rtol, setup.atol, out);
323  }
324  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, SqrtConst ) {
325  setup.exp->sqrt(setup.cu, setup.cx);
326  setup.cu2[0] = std::sqrt(setup.cx[0]);
327  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
328  setup.crtol, setup.catol, out);
329  }
330  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, SqrtResize ) {
331  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
332  setup.exp->sqrt(ru, setup.x);
333  computePCE1<SqrtFunc>(setup.u2, setup.x, *setup.quad);
334  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
335  setup.rtol, setup.atol, out);
336  }
337  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Cbrt ) {
338  setup.exp->cbrt(setup.u, setup.x);
339  computePCE1<CbrtFunc>(setup.u2, setup.x, *setup.quad);
340  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
341  setup.rtol, setup.atol, out);
342  }
343  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, CbrtConst ) {
344  setup.exp->cbrt(setup.cu, setup.cx);
345  setup.cu2[0] = std::cbrt(setup.cx[0]);
346  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
347  setup.crtol, setup.catol, out);
348  }
349  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, CbrtResize ) {
350  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
351  setup.exp->cbrt(ru, setup.x);
352  computePCE1<CbrtFunc>(setup.u2, setup.x, *setup.quad);
353  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
354  setup.rtol, setup.atol, out);
355  }
356  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Sin ) {
357  setup.exp->sin(setup.u, setup.x);
358  computePCE1<SinFunc>(setup.u2, setup.x, *setup.quad);
359  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
360  setup.rtol, setup.atol, out);
361  }
362  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, SinConst ) {
363  setup.exp->sin(setup.cu, setup.cx);
364  setup.cu2[0] = std::sin(setup.cx[0]);
365  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
366  setup.crtol, setup.catol, out);
367  }
368  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, SinResize ) {
369  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
370  setup.exp->sin(ru, setup.x);
371  computePCE1<SinFunc>(setup.u2, setup.x, *setup.quad);
372  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
373  setup.rtol, setup.atol, out);
374  }
375  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Cos ) {
376  setup.exp->cos(setup.u, setup.x);
377  computePCE1<CosFunc>(setup.u2, setup.x, *setup.quad);
378  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
379  setup.rtol, setup.atol, out);
380  }
381  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, CosConst ) {
382  setup.exp->cos(setup.cu, setup.cx);
383  setup.cu2[0] = std::cos(setup.cx[0]);
384  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
385  setup.crtol, setup.catol, out);
386  }
387  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, CosResize ) {
388  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
389  setup.exp->cos(ru, setup.x);
390  computePCE1<CosFunc>(setup.u2, setup.x, *setup.quad);
391  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
392  setup.rtol, setup.atol, out);
393  }
394  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Tan ) {
395  setup.exp->tan(setup.u, setup.x);
396  computePCE1<TanFunc>(setup.u2, setup.x, *setup.quad);
397  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
398  setup.rtol, setup.atol, out);
399  }
400  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TanConst ) {
401  setup.exp->tan(setup.cu, setup.cx);
402  setup.cu2[0] = std::tan(setup.cx[0]);
403  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
404  setup.crtol, setup.catol, out);
405  }
406  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TanResize ) {
407  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
408  setup.exp->tan(ru, setup.x);
409  computePCE1<TanFunc>(setup.u2, setup.x, *setup.quad);
410  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
411  setup.rtol, setup.atol, out);
412  }
413  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Sinh ) {
414  setup.exp->sinh(setup.u, setup.x);
415  computePCE1<SinhFunc>(setup.u2, setup.x, *setup.quad);
416  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
417  setup.rtol, setup.atol, out);
418  }
419  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, SinhConst ) {
420  setup.exp->sinh(setup.cu, setup.cx);
421  setup.cu2[0] = std::sinh(setup.cx[0]);
422  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
423  setup.crtol, setup.catol, out);
424  }
425  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, SinhResize ) {
426  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
427  setup.exp->sinh(ru, setup.x);
428  computePCE1<SinhFunc>(setup.u2, setup.x, *setup.quad);
429  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
430  setup.rtol, setup.atol, out);
431  }
432  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Cosh ) {
433  setup.exp->cosh(setup.u, setup.x);
434  computePCE1<CoshFunc>(setup.u2, setup.x, *setup.quad);
435  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
436  setup.rtol, setup.atol, out);
437  }
438  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, CoshConst ) {
439  setup.exp->cosh(setup.cu, setup.cx);
440  setup.cu2[0] = std::cosh(setup.cx[0]);
441  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
442  setup.crtol, setup.catol, out);
443  }
444  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, CoshResize ) {
445  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
446  setup.exp->cosh(ru, setup.x);
447  computePCE1<CoshFunc>(setup.u2, setup.x, *setup.quad);
448  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
449  setup.rtol, setup.atol, out);
450  }
451  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Tanh ) {
452  setup.exp->tanh(setup.u, setup.x);
453  computePCE1<TanhFunc>(setup.u2, setup.x, *setup.quad);
454  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
455  setup.rtol, setup.atol, out);
456  }
457  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TanhConst ) {
458  setup.exp->tanh(setup.cu, setup.cx);
459  setup.cu2[0] = std::tanh(setup.cx[0]);
460  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
461  setup.crtol, setup.catol, out);
462  }
463  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TanhResize ) {
464  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
465  setup.exp->tanh(ru, setup.x);
466  computePCE1<TanhFunc>(setup.u2, setup.x, *setup.quad);
467  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
468  setup.rtol, setup.atol, out);
469  }
470  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ASin ) {
471  setup.exp->asin(setup.u, setup.x);
472  computePCE1<ASinFunc>(setup.u2, setup.x, *setup.quad);
473  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
474  setup.rtol, setup.atol, out);
475  }
476  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ASinConst ) {
477  setup.exp->asin(setup.cu, setup.cx);
478  setup.cu2[0] = std::asin(setup.cx[0]);
479  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
480  setup.crtol, setup.catol, out);
481  }
482  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ASinResize ) {
483  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
484  setup.exp->asin(ru, setup.x);
485  computePCE1<ASinFunc>(setup.u2, setup.x, *setup.quad);
486  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
487  setup.rtol, setup.atol, out);
488  }
489  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ACos ) {
490  setup.exp->acos(setup.u, setup.x);
491  computePCE1<ACosFunc>(setup.u2, setup.x, *setup.quad);
492  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
493  setup.rtol, setup.atol, out);
494  }
495  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ACosConst ) {
496  setup.exp->acos(setup.cu, setup.cx);
497  setup.cu2[0] = std::acos(setup.cx[0]);
498  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
499  setup.crtol, setup.catol, out);
500  }
501  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ACosResize ) {
502  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
503  setup.exp->acos(ru, setup.x);
504  computePCE1<ACosFunc>(setup.u2, setup.x, *setup.quad);
505  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
506  setup.rtol, setup.atol, out);
507  }
508  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ATan ) {
509  setup.exp->atan(setup.u, setup.x);
510  computePCE1<ATanFunc>(setup.u2, setup.x, *setup.quad);
511  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
512  setup.rtol, setup.atol, out);
513  }
514  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ATanConst ) {
515  setup.exp->atan(setup.cu, setup.cx);
516  setup.cu2[0] = std::atan(setup.cx[0]);
517  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
518  setup.crtol, setup.catol, out);
519  }
520  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ATanResize ) {
521  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
522  setup.exp->atan(ru, setup.x);
523  computePCE1<ATanFunc>(setup.u2, setup.x, *setup.quad);
524  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
525  setup.rtol, setup.atol, out);
526  }
527  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ASinh ) {
528  setup.exp->asinh(setup.u, setup.x);
529  computePCE1<ASinhFunc>(setup.u2, setup.x, *setup.quad);
530  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
531  setup.rtol, setup.atol, out);
532  }
533  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ASinhConst ) {
534  ASinhFunc f;
535  setup.exp->asinh(setup.cu, setup.cx);
536  setup.cu2[0] = f(setup.cx[0]);
537  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
538  setup.crtol, setup.catol, out);
539  }
540  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ASinhResize ) {
541  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
542  setup.exp->asinh(ru, setup.x);
543  computePCE1<ASinhFunc>(setup.u2, setup.x, *setup.quad);
544  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
545  setup.rtol, setup.atol, out);
546  }
547  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ACosh ) {
548  setup.exp->acosh(setup.u, setup.x);
549  computePCE1<ACoshFunc>(setup.u2, setup.x, *setup.quad);
550  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
551  setup.rtol, setup.atol, out);
552  }
553  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ACoshConst ) {
554  ACoshFunc f;
555  setup.exp->acosh(setup.cu, setup.cx);
556  setup.cu2[0] = f(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_PSExpansion, ACoshResize ) {
561  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
562  setup.exp->acosh(ru, setup.x);
563  computePCE1<ACoshFunc>(setup.u2, setup.x, *setup.quad);
564  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
565  setup.rtol, setup.atol, out);
566  }
567  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ATanh ) {
568  setup.exp->atanh(setup.u, setup.x);
569  computePCE1<ATanhFunc>(setup.u2, setup.x, *setup.quad);
570  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
571  setup.rtol, setup.atol, out);
572  }
573  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ATanhConst ) {
574  ATanhFunc f;
575  setup.exp->atanh(setup.cu, setup.cx);
576  setup.cu2[0] = f(setup.cx[0]);
577  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
578  setup.crtol, setup.catol, out);
579  }
580  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, ATanhResize ) {
581  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
582  setup.exp->atanh(ru, setup.x);
583  computePCE1<ATanhFunc>(setup.u2, setup.x, *setup.quad);
584  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
585  setup.rtol, setup.atol, out);
586  }
587 
588  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Plus ) {
589  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
590  setup.exp->sin(v, setup.x);
591  setup.exp->cos(w, setup.y);
592  setup.exp->plus(setup.u, v, w);
593  computePCE2<PlusFunc>(setup.u2, v, w, *setup.quad);
594  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
595  setup.rtol, setup.atol, out);
596  }
597  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusLC ) {
598  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
599  setup.exp->sin(v, setup.x);
600  setup.exp->plus(setup.u, setup.a, v);
601  computePCE2LC<PlusFunc>(setup.u2, setup.a, v, *setup.quad);
602  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
603  setup.rtol, setup.atol, out);
604  }
605  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusRC ) {
606  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
607  setup.exp->sin(v, setup.x);
608  setup.exp->plus(setup.u, v, setup.a);
609  computePCE2RC<PlusFunc>(setup.u2, v, setup.a, *setup.quad);
610  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
611  setup.rtol, setup.atol, out);
612  }
613  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusCC ) {
614  setup.exp->plus(setup.cu, setup.cx, setup.cx);
615  computePCE2<PlusFunc>(setup.cu2, setup.cx, setup.cx, *setup.quad);
616  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
617  setup.rtol, setup.atol, out);
618  }
619  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusLC2 ) {
620  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
621  setup.exp->sin(v, setup.x);
622  setup.exp->plus(setup.u, setup.cx, v);
623  computePCE2LC<PlusFunc>(setup.u2, setup.cx[0], v, *setup.quad);
624  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
625  setup.rtol, setup.atol, out);
626  }
627  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusRC2 ) {
628  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
629  setup.exp->sin(v, setup.x);
630  setup.exp->plus(setup.u, v, setup.cx);
631  computePCE2RC<PlusFunc>(setup.u2, v, setup.cx[0], *setup.quad);
632  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
633  setup.rtol, setup.atol, out);
634  }
635  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusResize ) {
636  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
637  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
638  setup.exp->sin(v, setup.x);
639  setup.exp->cos(w, setup.y);
640  setup.exp->plus(ru, v, w);
641  computePCE2<PlusFunc>(setup.u2, v, w, *setup.quad);
642  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
643  setup.rtol, setup.atol, out);
644  }
645  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusLCResize ) {
646  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
647  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
648  setup.exp->sin(v, setup.x);
649  setup.exp->plus(ru, setup.a, v);
650  computePCE2LC<PlusFunc>(setup.u2, setup.a, v, *setup.quad);
651  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
652  setup.rtol, setup.atol, out);
653  }
654  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusRCResize ) {
655  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
656  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
657  setup.exp->sin(v, setup.x);
658  setup.exp->plus(ru, v, setup.a);
659  computePCE2RC<PlusFunc>(setup.u2, v, setup.a, *setup.quad);
660  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
661  setup.rtol, setup.atol, out);
662  }
663  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusLS ) {
664  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
665  setup.exp->sin(v, setup.x);
666  setup.exp->plus(setup.u, setup.sx, v);
667  computePCE2<PlusFunc>(setup.u2, setup.sx, v, *setup.quad);
668  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
669  setup.rtol, setup.atol, out);
670  }
671  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusRS ) {
672  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
673  setup.exp->sin(v, setup.x);
674  setup.exp->plus(setup.u, v, setup.sx);
675  computePCE2<PlusFunc>(setup.u2, v, setup.sx, *setup.quad);
676  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
677  setup.rtol, setup.atol, out);
678  }
679  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusLSRC ) {
680  setup.exp->plus(setup.su, setup.sx, setup.a);
681  computePCE2RC<PlusFunc>(setup.su2, setup.sx, setup.a, *setup.quad);
682  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
683  setup.rtol, setup.atol, out);
684  }
685  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusRSLC ) {
686  setup.exp->plus(setup.su, setup.a, setup.sx);
687  computePCE2LC<PlusFunc>(setup.su2, setup.a, setup.sx, *setup.quad);
688  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
689  setup.rtol, setup.atol, out);
690  }
691  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusLSRC2 ) {
692  setup.exp->plus(setup.su, setup.sx, setup.cx);
693  computePCE2<PlusFunc>(setup.su2, setup.sx, setup.cx, *setup.quad);
694  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
695  setup.rtol, setup.atol, out);
696  }
697  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusRSLC2 ) {
698  setup.exp->plus(setup.su, setup.cx, setup.sx);
699  computePCE2<PlusFunc>(setup.su2, setup.cx, setup.sx, *setup.quad);
700  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
701  setup.rtol, setup.atol, out);
702  }
703 
704  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Minus ) {
705  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
706  setup.exp->sin(v, setup.x);
707  setup.exp->cos(w, setup.y);
708  setup.exp->minus(setup.u, v, w);
709  computePCE2<MinusFunc>(setup.u2, v, w, *setup.quad);
710  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
711  setup.rtol, setup.atol, out);
712  }
713  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusLC ) {
714  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
715  setup.exp->sin(v, setup.x);
716  setup.exp->minus(setup.u, setup.a, v);
717  computePCE2LC<MinusFunc>(setup.u2, setup.a, v, *setup.quad);
718  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
719  setup.rtol, setup.atol, out);
720  }
721  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusRC ) {
722  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
723  setup.exp->sin(v, setup.x);
724  setup.exp->minus(setup.u, v, setup.a);
725  computePCE2RC<MinusFunc>(setup.u2, v, setup.a, *setup.quad);
726  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
727  setup.rtol, setup.atol, out);
728  }
729  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusCC ) {
730  setup.exp->minus(setup.cu, setup.cx, setup.cx);
731  computePCE2<MinusFunc>(setup.cu2, setup.cx, setup.cx, *setup.quad);
732  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
733  setup.rtol, setup.atol, out);
734  }
735  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusLC2 ) {
736  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
737  setup.exp->sin(v, setup.x);
738  setup.exp->minus(setup.u, setup.cx, v);
739  computePCE2LC<MinusFunc>(setup.u2, setup.cx[0], v, *setup.quad);
740  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
741  setup.rtol, setup.atol, out);
742  }
743  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusRC2 ) {
744  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
745  setup.exp->sin(v, setup.x);
746  setup.exp->minus(setup.u, v, setup.cx);
747  computePCE2RC<MinusFunc>(setup.u2, v, setup.cx[0], *setup.quad);
748  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
749  setup.rtol, setup.atol, out);
750  }
751  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusResize ) {
752  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
753  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
754  setup.exp->sin(v, setup.x);
755  setup.exp->cos(w, setup.y);
756  setup.exp->minus(ru, v, w);
757  computePCE2<MinusFunc>(setup.u2, v, w, *setup.quad);
758  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
759  setup.rtol, setup.atol, out);
760  }
761  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusLCResize ) {
762  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
763  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
764  setup.exp->sin(v, setup.x);
765  setup.exp->minus(ru, setup.a, v);
766  computePCE2LC<MinusFunc>(setup.u2, setup.a, v, *setup.quad);
767  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
768  setup.rtol, setup.atol, out);
769  }
770  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusRCResize ) {
771  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
772  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
773  setup.exp->sin(v, setup.x);
774  setup.exp->minus(ru, v, setup.a);
775  computePCE2RC<MinusFunc>(setup.u2, v, setup.a, *setup.quad);
776  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
777  setup.rtol, setup.atol, out);
778  }
779  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusLS ) {
780  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
781  setup.exp->sin(v, setup.x);
782  setup.exp->minus(setup.u, setup.sx, v);
783  computePCE2<MinusFunc>(setup.u2, setup.sx, v, *setup.quad);
784  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
785  setup.rtol, setup.atol, out);
786  }
787  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusRS ) {
788  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
789  setup.exp->sin(v, setup.x);
790  setup.exp->minus(setup.u, v, setup.sx);
791  computePCE2<MinusFunc>(setup.u2, v, setup.sx, *setup.quad);
792  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
793  setup.rtol, setup.atol, out);
794  }
795  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusLSRC ) {
796  setup.exp->minus(setup.su, setup.sx, setup.a);
797  computePCE2RC<MinusFunc>(setup.su2, setup.sx, setup.a, *setup.quad);
798  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
799  setup.rtol, setup.atol, out);
800  }
801  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusRSLC ) {
802  setup.exp->minus(setup.su, setup.a, setup.sx);
803  computePCE2LC<MinusFunc>(setup.su2, setup.a, setup.sx, *setup.quad);
804  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
805  setup.rtol, setup.atol, out);
806  }
807  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusLSRC2 ) {
808  setup.exp->minus(setup.su, setup.sx, setup.cx);
809  computePCE2<MinusFunc>(setup.su2, setup.sx, setup.cx, *setup.quad);
810  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
811  setup.rtol, setup.atol, out);
812  }
813  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusRSLC2 ) {
814  setup.exp->minus(setup.su, setup.cx, setup.sx);
815  computePCE2<MinusFunc>(setup.su2, setup.cx, setup.sx, *setup.quad);
816  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
817  setup.rtol, setup.atol, out);
818  }
819 
820  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Times ) {
821  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
822  setup.exp->sin(v, setup.x);
823  setup.exp->cos(w, setup.y);
824  setup.exp->times(setup.u, v, w);
825  computePCE2<TimesFunc>(setup.u2, v, w, *setup.quad);
826  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
827  setup.rtol, setup.atol, out);
828  }
829  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLC ) {
830  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
831  setup.exp->sin(v, setup.x);
832  setup.exp->times(setup.u, setup.a, v);
833  computePCE2LC<TimesFunc>(setup.u2, setup.a, v, *setup.quad);
834  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
835  setup.rtol, setup.atol, out);
836  }
837  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRC ) {
838  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
839  setup.exp->sin(v, setup.x);
840  setup.exp->times(setup.u, v, setup.a);
841  computePCE2RC<TimesFunc>(setup.u2, v, setup.a, *setup.quad);
842  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
843  setup.rtol, setup.atol, out);
844  }
845  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesCC ) {
846  setup.exp->times(setup.cu, setup.cx, setup.cx);
847  computePCE2<TimesFunc>(setup.cu2, setup.cx, setup.cx, *setup.quad);
848  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
849  setup.rtol, setup.atol, out);
850  }
851  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLC2 ) {
852  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
853  setup.exp->sin(v, setup.x);
854  setup.exp->times(setup.u, setup.cx, v);
855  computePCE2LC<TimesFunc>(setup.u2, setup.cx[0], v, *setup.quad);
856  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
857  setup.rtol, setup.atol, out);
858  }
859  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRC2 ) {
860  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
861  setup.exp->sin(v, setup.x);
862  setup.exp->times(setup.u, v, setup.cx);
863  computePCE2RC<TimesFunc>(setup.u2, v, setup.cx[0], *setup.quad);
864  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
865  setup.rtol, setup.atol, out);
866  }
867  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesResize ) {
868  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
869  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
870  setup.exp->sin(v, setup.x);
871  setup.exp->cos(w, setup.y);
872  setup.exp->times(ru, v, w);
873  computePCE2<TimesFunc>(setup.u2, v, w, *setup.quad);
874  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
875  setup.rtol, setup.atol, out);
876  }
877  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLCResize ) {
878  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
879  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
880  setup.exp->sin(v, setup.x);
881  setup.exp->times(ru, setup.a, v);
882  computePCE2LC<TimesFunc>(setup.u2, setup.a, v, *setup.quad);
883  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
884  setup.rtol, setup.atol, out);
885  }
886  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRCResize ) {
887  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
888  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
889  setup.exp->sin(v, setup.x);
890  setup.exp->times(ru, v, setup.a);
891  computePCE2RC<TimesFunc>(setup.u2, v, setup.a, *setup.quad);
892  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
893  setup.rtol, setup.atol, out);
894  }
895  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLS ) {
896  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
897  setup.exp->sin(v, setup.x);
898  setup.exp->times(setup.u, setup.sx, v);
899  computePCE2<TimesFunc>(setup.u2, setup.sx, v, *setup.quad);
900  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
901  setup.rtol, setup.atol, out);
902  }
903  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRS ) {
904  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
905  setup.exp->sin(v, setup.x);
906  setup.exp->times(setup.u, v, setup.sx);
907  computePCE2<TimesFunc>(setup.u2, v, setup.sx, *setup.quad);
908  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
909  setup.rtol, setup.atol, out);
910  }
911  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLSLinear ) {
912  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
913  setup.exp->sin(v, setup.x);
914  setup.exp_linear->times(setup.u, setup.sx, v);
915  computePCE2<TimesFunc>(setup.u2, setup.sx, v, *setup.quad);
916  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
917  setup.rtol, setup.atol, out);
918  }
919  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRSLinear ) {
920  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
921  setup.exp->sin(v, setup.x);
922  setup.exp_linear->times(setup.u, v, setup.sx);
923  computePCE2<TimesFunc>(setup.u2, v, setup.sx, *setup.quad);
924  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
925  setup.rtol, setup.atol, out);
926  }
927  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLSRC ) {
928  setup.exp->times(setup.su, setup.sx, setup.a);
929  computePCE2RC<TimesFunc>(setup.su2, setup.sx, setup.a, *setup.quad);
930  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
931  setup.rtol, setup.atol, out);
932  }
933  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRSLC ) {
934  setup.exp->times(setup.su, setup.a, setup.sx);
935  computePCE2LC<TimesFunc>(setup.su2, setup.a, setup.sx, *setup.quad);
936  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
937  setup.rtol, setup.atol, out);
938  }
939  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesLSRC2 ) {
940  setup.exp->times(setup.su, setup.sx, setup.cx);
941  computePCE2<TimesFunc>(setup.su2, setup.sx, setup.cx, *setup.quad);
942  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
943  setup.rtol, setup.atol, out);
944  }
945  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesRSLC2 ) {
946  setup.exp->times(setup.su, setup.cx, setup.sx);
947  computePCE2<TimesFunc>(setup.su2, setup.cx, setup.sx, *setup.quad);
948  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
949  setup.rtol, setup.atol, out);
950  }
951 
952  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Divide ) {
953  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
954  setup.exp->sin(v, setup.x);
955  setup.exp->exp(w, setup.y);
956  setup.exp->divide(setup.u, v, w);
957  computePCE2<DivideFunc>(setup.u2, v, w, *setup.quad);
958  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
959  setup.rtol, setup.atol, out);
960  }
961  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideLC ) {
962  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
963  setup.exp->sin(v, setup.x);
964  setup.exp->divide(setup.u, setup.a, v);
965  computePCE2LC<DivideFunc>(setup.u2, setup.a, v, *setup.quad);
966  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
967  setup.rtol, setup.atol, out);
968  }
969  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideRC ) {
970  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
971  setup.exp->sin(v, setup.x);
972  setup.exp->divide(setup.u, v, setup.a);
973  computePCE2RC<DivideFunc>(setup.u2, v, setup.a, *setup.quad);
974  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
975  setup.rtol, setup.atol, out);
976  }
977  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideCC ) {
978  setup.exp->divide(setup.cu, setup.cx, setup.cx);
979  computePCE2<DivideFunc>(setup.cu2, setup.cx, setup.cx, *setup.quad);
980  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
981  setup.rtol, setup.atol, out);
982  }
983  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideLC2 ) {
984  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
985  setup.exp->sin(v, setup.x);
986  setup.exp->divide(setup.u, setup.cx, v);
987  computePCE2LC<DivideFunc>(setup.u2, setup.cx[0], v, *setup.quad);
988  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
989  setup.rtol, setup.atol, out);
990  }
991  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideRC2 ) {
992  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
993  setup.exp->sin(v, setup.x);
994  setup.exp->divide(setup.u, v, setup.cx);
995  computePCE2RC<DivideFunc>(setup.u2, v, setup.cx[0], *setup.quad);
996  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
997  setup.rtol, setup.atol, out);
998  }
999  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideResize ) {
1000  Stokhos::OrthogPolyApprox<int,double> v(setup.basis), w(setup.basis);
1001  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1002  setup.exp->sin(v, setup.x);
1003  setup.exp->exp(w, setup.y);
1004  setup.exp->divide(ru, v, w);
1005  computePCE2<DivideFunc>(setup.u2, v, w, *setup.quad);
1006  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1007  setup.rtol, setup.atol, out);
1008  }
1009  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideLCResize ) {
1010  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1011  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1012  setup.exp->sin(v, setup.x);
1013  setup.exp->divide(ru, setup.a, v);
1014  computePCE2LC<DivideFunc>(setup.u2, setup.a, v, *setup.quad);
1015  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1016  setup.rtol, setup.atol, out);
1017  }
1018  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideRCResize ) {
1019  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1020  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1021  setup.exp->sin(v, setup.x);
1022  setup.exp->divide(ru, v, setup.a);
1023  computePCE2RC<DivideFunc>(setup.u2, v, setup.a, *setup.quad);
1024  success = Stokhos::comparePCEs(ru, "u", setup.u2, "u2",
1025  setup.rtol, setup.atol, out);
1026  }
1027  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideLS ) {
1028  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1029  setup.exp->sin(v, setup.x);
1030  setup.exp->divide(setup.u, setup.sx, v);
1031  computePCE2<DivideFunc>(setup.u2, setup.sx, v, *setup.quad);
1032  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1033  setup.rtol, setup.atol, out);
1034  }
1035  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideRS ) {
1036  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1037  setup.exp->sin(v, setup.x);
1038  setup.exp->divide(setup.u, v, setup.sx);
1039  computePCE2<DivideFunc>(setup.u2, v, setup.sx, *setup.quad);
1040  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1041  setup.rtol, setup.atol, out);
1042  }
1043  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideLSRC ) {
1044  setup.exp->divide(setup.su, setup.sx, setup.a);
1045  computePCE2RC<DivideFunc>(setup.su2, setup.sx, setup.a, *setup.quad);
1046  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1047  setup.rtol, setup.atol, out);
1048  }
1049  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideRSLC ) {
1050  setup.exp->divide(setup.u, setup.a, setup.sx);
1051  computePCE2LC<DivideFunc>(setup.u2, setup.a, setup.sx, *setup.quad);
1052  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1053  setup.rtol, setup.atol, out);
1054  }
1055  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideLSRC2 ) {
1056  setup.exp->divide(setup.su, setup.sx, setup.cx);
1057  computePCE2<DivideFunc>(setup.su2, setup.sx, setup.cx, *setup.quad);
1058  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1059  setup.rtol, setup.atol, out);
1060  }
1061  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideRSLC2 ) {
1062  setup.exp->divide(setup.u, setup.cx, setup.sx);
1063  computePCE2<DivideFunc>(setup.u2, setup.cx, setup.sx, *setup.quad);
1064  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1065  setup.rtol, setup.atol, out);
1066  }
1067 
1068  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, Pow ) {
1069  setup.exp->pow(setup.u, setup.x, setup.y);
1070  computePCE2<PowFunc>(setup.u2, setup.x, setup.y, *setup.quad);
1071  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1072  setup.rtol, setup.atol, out);
1073  }
1074  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowLC ) {
1075  setup.exp->pow(setup.u, setup.a, setup.y);
1076  computePCE2LC<PowFunc>(setup.u2, setup.a, setup.y, *setup.quad);
1077  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1078  setup.rtol, setup.atol, out);
1079  }
1080  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowRC ) {
1081  setup.exp->pow(setup.u, setup.x, setup.a);
1082  computePCE2RC<PowFunc>(setup.u2, setup.x, setup.a, *setup.quad);
1083  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1084  setup.rtol, setup.atol, out);
1085  }
1086  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowCC ) {
1087  setup.exp->pow(setup.cu, setup.cx, setup.cx);
1088  computePCE2<PowFunc>(setup.cu2, setup.cx, setup.cx, *setup.quad);
1089  success = Stokhos::comparePCEs(setup.cu, "cu", setup.cu2, "cu2",
1090  setup.rtol, setup.atol, out);
1091  }
1092  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowLC2 ) {
1093  setup.exp->pow(setup.u, setup.cx, setup.y);
1094  computePCE2LC<PowFunc>(setup.u2, setup.cx[0], setup.y, *setup.quad);
1095  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1096  setup.rtol, setup.atol, out);
1097  }
1098  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowRC2 ) {
1099  setup.exp->pow(setup.u, setup.x, setup.cx);
1100  computePCE2RC<PowFunc>(setup.u2, setup.x, setup.cx[0], *setup.quad);
1101  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1102  setup.rtol, setup.atol, out);
1103  }
1104  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowResize ) {
1105  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1106  setup.exp->pow(ru, setup.x, setup.y);
1107  computePCE2<PowFunc>(setup.u2, setup.x, setup.y, *setup.quad);
1108  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1109  setup.rtol, setup.atol, out);
1110  }
1111  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowLCResize ) {
1112  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1113  setup.exp->pow(ru, setup.a, setup.y);
1114  computePCE2LC<PowFunc>(setup.u2, setup.a, setup.y, *setup.quad);
1115  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1116  setup.rtol, setup.atol, out);
1117  }
1118  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowRCResize ) {
1119  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1120  setup.exp->pow(ru, setup.x, setup.a);
1121  computePCE2RC<PowFunc>(setup.u2, setup.x, setup.a, *setup.quad);
1122  success = Stokhos::comparePCEs(ru, "ru", setup.u2, "u2",
1123  setup.rtol, setup.atol, out);
1124  }
1125  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowLS ) {
1126  setup.exp->pow(setup.u, setup.sx, setup.y);
1127  computePCE2<PowFunc>(setup.u2, setup.sx, setup.y, *setup.quad);
1128  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1129  setup.rtol, setup.atol, out);
1130  }
1131  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowRS ) {
1132  setup.exp->pow(setup.u, setup.x, setup.sx);
1133  computePCE2<PowFunc>(setup.u2, setup.x, setup.sx, *setup.quad);
1134  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1135  setup.rtol, setup.atol, out);
1136  }
1137  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowLSRC ) {
1138  setup.exp->pow(setup.u, setup.sx, setup.a);
1139  computePCE2RC<PowFunc>(setup.u2, setup.sx, setup.a, *setup.quad);
1140  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1141  setup.rtol, setup.atol, out);
1142  }
1143  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowRSLC ) {
1144  setup.exp->pow(setup.u, setup.a, setup.sx);
1145  computePCE2LC<PowFunc>(setup.u2, setup.a, setup.sx, *setup.quad);
1146  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1147  setup.rtol, setup.atol, out);
1148  }
1149  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowLSRC2 ) {
1150  setup.exp->pow(setup.u, setup.sx, setup.cx);
1151  computePCE2<PowFunc>(setup.u2, setup.sx, setup.cx, *setup.quad);
1152  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1153  setup.rtol, setup.atol, out);
1154  }
1155  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PowRSLC2 ) {
1156  setup.exp->pow(setup.u, setup.cx, setup.sx);
1157  computePCE2<PowFunc>(setup.u2, setup.cx, setup.sx, *setup.quad);
1158  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1159  setup.rtol, setup.atol, out);
1160  }
1161 
1162  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqual ) {
1163  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1164  setup.exp->sin(v, setup.x);
1165  setup.exp->cos(setup.u, setup.x);
1166  computePCE2<PlusFunc>(setup.u2, setup.u, v, *setup.quad);
1167  setup.exp->plusEqual(setup.u, v);
1168  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1169  setup.rtol, setup.atol, out);
1170  }
1171  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqualC ) {
1172  setup.exp->cos(setup.u, setup.x);
1173  computePCE2RC<PlusFunc>(setup.u2, setup.u, setup.a, *setup.quad);
1174  setup.exp->plusEqual(setup.u, setup.a);
1175  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1176  setup.rtol, setup.atol, out);
1177  }
1178  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqualC2 ) {
1179  setup.exp->cos(setup.u, setup.x);
1180  computePCE2RC<PlusFunc>(setup.u2, setup.u, setup.cx[0], *setup.quad);
1181  setup.exp->plusEqual(setup.u, setup.cx);
1182  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1183  setup.rtol, setup.atol, out);
1184  }
1185  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqualResize ) {
1186  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1187  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1188  setup.exp->sin(v, setup.x);
1189  setup.exp->plusEqual(ru, v);
1190  success = Stokhos::comparePCEs(ru, "ru", v, "v",
1191  setup.rtol, setup.atol, out);
1192  }
1193  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqualS ) {
1194  setup.exp->cos(setup.u, setup.x);
1195  computePCE2<PlusFunc>(setup.u2, setup.u, setup.sx, *setup.quad);
1196  setup.exp->plusEqual(setup.u, setup.sx);
1197  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1198  setup.rtol, setup.atol, out);
1199  }
1200  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqualSC ) {
1201  setup.su = setup.sx;
1202  computePCE2RC<PlusFunc>(setup.su2, setup.su, setup.a, *setup.quad);
1203  setup.exp->plusEqual(setup.su, setup.a);
1204  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1205  setup.rtol, setup.atol, out);
1206  }
1207  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, PlusEqualSC2 ) {
1208  setup.su = setup.sx;
1209  computePCE2<PlusFunc>(setup.su2, setup.su, setup.cx, *setup.quad);
1210  setup.exp->plusEqual(setup.su, setup.cx);
1211  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1212  setup.rtol, setup.atol, out);
1213  }
1214 
1215  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqual ) {
1216  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1217  setup.exp->sin(v, setup.x);
1218  setup.exp->cos(setup.u, setup.x);
1219  computePCE2<MinusFunc>(setup.u2, setup.u, v, *setup.quad);
1220  setup.exp->minusEqual(setup.u, v);
1221  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1222  setup.rtol, setup.atol, out);
1223  }
1224  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqualC ) {
1225  setup.exp->cos(setup.u, setup.x);
1226  computePCE2RC<MinusFunc>(setup.u2, setup.u, setup.a, *setup.quad);
1227  setup.exp->minusEqual(setup.u, setup.a);
1228  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1229  setup.rtol, setup.atol, out);
1230  }
1231  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqualC2 ) {
1232  setup.exp->cos(setup.u, setup.x);
1233  computePCE2RC<MinusFunc>(setup.u2, setup.u, setup.cx[0], *setup.quad);
1234  setup.exp->minusEqual(setup.u, setup.cx);
1235  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1236  setup.rtol, setup.atol, out);
1237  }
1238  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqualResize ) {
1239  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1240  Stokhos::OrthogPolyApprox<int, double> ru(setup.basis, 0);
1241  setup.exp->sin(v, setup.x);
1242  setup.exp->minusEqual(ru, v);
1243  setup.exp->unaryMinus(v, v);
1244  success = Stokhos::comparePCEs(ru, "ru", v, "v",
1245  setup.rtol, setup.atol, out);
1246  }
1247  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqualS ) {
1248  setup.exp->cos(setup.u, setup.x);
1249  computePCE2<MinusFunc>(setup.u2, setup.u, setup.sx, *setup.quad);
1250  setup.exp->minusEqual(setup.u, setup.sx);
1251  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1252  setup.rtol, setup.atol, out);
1253  }
1254  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqualSC ) {
1255  setup.su = setup.sx;
1256  computePCE2RC<MinusFunc>(setup.su2, setup.su, setup.a, *setup.quad);
1257  setup.exp->minusEqual(setup.su, setup.a);
1258  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1259  setup.rtol, setup.atol, out);
1260  }
1261  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, MinusEqualSC2 ) {
1262  setup.su = setup.sx;
1263  computePCE2<MinusFunc>(setup.su2, setup.su, setup.cx, *setup.quad);
1264  setup.exp->minusEqual(setup.su, setup.cx);
1265  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1266  setup.rtol, setup.atol, out);
1267  }
1268 
1269  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqual ) {
1270  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1271  setup.exp->sin(v, setup.x);
1272  setup.exp->cos(setup.u, setup.x);
1273  computePCE2<TimesFunc>(setup.u2, setup.u, v, *setup.quad);
1274  setup.exp->timesEqual(setup.u, v);
1275  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1276  setup.rtol, setup.atol, out);
1277  }
1278  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualC ) {
1279  setup.exp->cos(setup.u, setup.x);
1280  computePCE2RC<TimesFunc>(setup.u2, setup.u, setup.a, *setup.quad);
1281  setup.exp->timesEqual(setup.u, setup.a);
1282  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1283  setup.rtol, setup.atol, out);
1284  }
1285  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualC2 ) {
1286  setup.exp->cos(setup.u, setup.x);
1287  computePCE2RC<TimesFunc>(setup.u2, setup.u, setup.cx[0], *setup.quad);
1288  setup.exp->timesEqual(setup.u, setup.cx);
1289  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1290  setup.rtol, setup.atol, out);
1291  }
1292  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualResize ) {
1293  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1294  setup.exp->sin(v, setup.x);
1295  setup.su = setup.sx;
1296  computePCE2<TimesFunc>(setup.u2, setup.su, v, *setup.quad);
1297  setup.exp->timesEqual(setup.su, v);
1298  success = Stokhos::comparePCEs(setup.su, "su", setup.u2, "u2",
1299  setup.rtol, setup.atol, out);
1300  }
1301  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualS ) {
1302  setup.exp->cos(setup.u, setup.x);
1303  computePCE2<TimesFunc>(setup.u2, setup.u, setup.sx, *setup.quad);
1304  setup.exp->timesEqual(setup.u, setup.sx);
1305  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1306  setup.rtol, setup.atol, out);
1307  }
1308  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualSLinear ) {
1309  setup.exp->cos(setup.u, setup.x);
1310  computePCE2<TimesFunc>(setup.u2, setup.u, setup.sx, *setup.quad);
1311  setup.exp_linear->timesEqual(setup.u, setup.sx);
1312  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1313  setup.rtol, setup.atol, out);
1314  }
1315  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualSC ) {
1316  setup.su = setup.sx;
1317  computePCE2RC<TimesFunc>(setup.su2, setup.su, setup.a, *setup.quad);
1318  setup.exp->timesEqual(setup.su, setup.a);
1319  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1320  setup.rtol, setup.atol, out);
1321  }
1322  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, TimesEqualSC2 ) {
1323  setup.su = setup.sx;
1324  computePCE2<TimesFunc>(setup.su2, setup.su, setup.cx, *setup.quad);
1325  setup.exp->timesEqual(setup.su, setup.cx);
1326  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1327  setup.rtol, setup.atol, out);
1328  }
1329 
1330  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqual ) {
1331  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1332  setup.exp->sin(v, setup.x);
1333  setup.exp->cos(setup.u, setup.x);
1334  computePCE2<DivideFunc>(setup.u2, setup.u, v, *setup.quad);
1335  setup.exp->divideEqual(setup.u, v);
1336  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1337  setup.rtol, setup.atol, out);
1338  }
1339  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqualC ) {
1340  setup.exp->cos(setup.u, setup.x);
1341  computePCE2RC<DivideFunc>(setup.u2, setup.u, setup.a, *setup.quad);
1342  setup.exp->divideEqual(setup.u, setup.a);
1343  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1344  setup.rtol, setup.atol, out);
1345  }
1346  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqualC2 ) {
1347  setup.exp->cos(setup.u, setup.x);
1348  computePCE2RC<DivideFunc>(setup.u2, setup.u, setup.cx[0], *setup.quad);
1349  setup.exp->divideEqual(setup.u, setup.cx);
1350  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1351  setup.rtol, setup.atol, out);
1352  }
1353  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqualResize ) {
1354  Stokhos::OrthogPolyApprox<int,double> v(setup.basis);
1355  setup.exp->sin(v, setup.x);
1356  setup.su = setup.sx;
1357  computePCE2<DivideFunc>(setup.u2, setup.su, v, *setup.quad);
1358  setup.exp->divideEqual(setup.su, v);
1359  success = Stokhos::comparePCEs(setup.su, "su", setup.u2, "u2",
1360  setup.rtol, setup.atol, out);
1361  }
1362  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqualS ) {
1363  setup.exp->cos(setup.u, setup.x);
1364  computePCE2<DivideFunc>(setup.u2, setup.u, setup.sx, *setup.quad);
1365  setup.exp->divideEqual(setup.u, setup.sx);
1366  success = Stokhos::comparePCEs(setup.u, "u", setup.u2, "u2",
1367  setup.rtol, setup.atol, out);
1368  }
1369  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqualSC ) {
1370  setup.su = setup.sx;
1371  computePCE2RC<DivideFunc>(setup.su2, setup.su, setup.a, *setup.quad);
1372  setup.exp->divideEqual(setup.su, setup.a);
1373  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1374  setup.rtol, setup.atol, out);
1375  }
1376  TEUCHOS_UNIT_TEST( Stokhos_PSExpansion, DivideEqualSC2 ) {
1377  setup.su = setup.sx;
1378  computePCE2<DivideFunc>(setup.su2, setup.su, setup.cx, *setup.quad);
1379  setup.exp->divideEqual(setup.su, setup.cx);
1380  success = Stokhos::comparePCEs(setup.su, "su", setup.su2, "su2",
1381  setup.rtol, setup.atol, out);
1382  }
1383 
1384  // Not testing atan2(), max(), min(), abs(), fabs() since these are
1385  // not smooth functions
1386 
1387 }
PseudoSpectralExpansionUnitTest::MinusFunc::operator()
double operator()(double a, double b) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:241
PseudoSpectralExpansionUnitTest::Log10Func
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:185
Cos
Cos
Definition: Stokhos_LanczosUnitTest.cpp:267
PseudoSpectralExpansionUnitTest::CbrtFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:192
PseudoSpectralExpansionUnitTest::PowFunc::operator()
double operator()(double a, double b) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:250
Stokhos::comparePCEs
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)
Definition: Stokhos_SacadoUQPCEUnitTest.cpp:58
Teuchos::Array::size
size_type size() const
PseudoSpectralExpansionUnitTest::Log10Func::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:186
Sacado::UQ::cosh
KOKKOS_INLINE_FUNCTION PCE< Storage > cosh(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:1033
PseudoSpectralExpansionUnitTest::CosFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:197
Stokhos::OrthogPolyApprox::size
ordinal_type size() const
Return size.
Definition: Stokhos_OrthogPolyApproxImp.hpp:160
Stokhos::Quadrature::getQuadWeights
virtual const Teuchos::Array< value_type > & getQuadWeights() const =0
Get quadrature weights.
PseudoSpectralExpansionUnitTest::TanFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:200
PseudoSpectralExpansionUnitTest::SqrtFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:189
PseudoSpectralExpansionUnitTest::TimesFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:243
PseudoSpectralExpansionUnitTest::CoshFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:207
PseudoSpectralExpansionUnitTest::DivideFunc::operator()
double operator()(double a, double b) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:247
PseudoSpectralExpansionUnitTest::ATanFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:219
PseudoSpectralExpansionUnitTest::ExpFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:179
PseudoSpectralExpansionUnitTest::setup
UnitTestSetup< int, double > setup
Definition: Stokhos_QuadraturePseudoSpectralExpansionUnitTest.cpp:135
Sacado::UQ::atan
KOKKOS_INLINE_FUNCTION PCE< Storage > atan(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:1101
Sacado::UQ::exp
KOKKOS_INLINE_FUNCTION PCE< Storage > exp(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:827
PseudoSpectralExpansionUnitTest
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:44
PseudoSpectralExpansionUnitTest::PlusFunc::operator()
double operator()(double a, double b) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:238
Stokhos::OrthogPolyApprox::basis
Teuchos::RCP< const Stokhos::OrthogPolyBasis< ordinal_type, value_type > > basis() const
Return basis.
Definition: Stokhos_OrthogPolyApproxImp.hpp:130
PseudoSpectralExpansionUnitTest::ACoshFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:226
PseudoSpectralExpansionUnitTest::computePCE1
void computePCE1(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a, const Stokhos::Quadrature< OrdinalType, ValueType > &quad)
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:47
Stokhos::Quadrature< OrdinalType, ValueType >
PseudoSpectralExpansionUnitTest::SinhFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:203
PseudoSpectralExpansionUnitTest::ATanhFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:231
Sacado::UQ::log10
KOKKOS_INLINE_FUNCTION PCE< Storage > log10(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:861
Sacado::UQ::sin
KOKKOS_INLINE_FUNCTION PCE< Storage > sin(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:965
Sacado::UQ::asin
KOKKOS_INLINE_FUNCTION PCE< Storage > asin(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:1084
Teuchos::RCP
PseudoSpectralExpansionUnitTest::ACosFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:215
PseudoSpectralExpansionUnitTest::computePCE2RC
void computePCE2RC(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a, ValueType b, const Stokhos::Quadrature< OrdinalType, ValueType > &quad)
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:144
Teuchos::Array< ValueType >
Sacado::UQ::log
KOKKOS_INLINE_FUNCTION PCE< Storage > log(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:844
PseudoSpectralExpansionUnitTest::DivideFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:246
PseudoSpectralExpansionUnitTest::CbrtFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:191
PseudoSpectralExpansionUnitTest::ACosFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:216
val
expr val()
PseudoSpectralExpansionUnitTest::CosFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:198
PseudoSpectralExpansionUnitTest::PowFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:249
PseudoSpectralExpansionUnitTest::ATanFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:218
Sacado::UQ::cos
KOKKOS_INLINE_FUNCTION PCE< Storage > cos(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:982
Stokhos::OrthogPolyApprox::evaluate
value_type evaluate(const Teuchos::Array< value_type > &point) const
Evaluate polynomial approximation at a point.
Definition: Stokhos_OrthogPolyApproxImp.hpp:248
PseudoSpectralExpansionUnitTest::TanhFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:209
PseudoSpectralExpansionUnitTest::ASinFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:213
Stokhos::Quadrature::getBasisAtQuadPoints
virtual const Teuchos::Array< Teuchos::Array< value_type > > & getBasisAtQuadPoints() const =0
Get values of basis at quadrature points.
Sacado::UQ::sinh
KOKKOS_INLINE_FUNCTION PCE< Storage > sinh(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:1016
PseudoSpectralExpansionUnitTest::SinFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:194
PseudoSpectralExpansionUnitTest::UMinusFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:177
Sacado::UQ::sqrt
KOKKOS_INLINE_FUNCTION PCE< Storage > sqrt(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:878
Sacado::UQ::tan
KOKKOS_INLINE_FUNCTION PCE< Storage > tan(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:999
PseudoSpectralExpansionUnitTest::CoshFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:206
PseudoSpectralExpansionUnitTest::PlusFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:237
PseudoSpectralExpansionUnitTest::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(Stokhos_PSExpansion, UMinus)
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:253
PseudoSpectralExpansionUnitTest::MinusFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:240
PseudoSpectralExpansionUnitTest::TimesFunc::operator()
double operator()(double a, double b) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:244
PseudoSpectralExpansionUnitTest::SqrtFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:188
PseudoSpectralExpansionUnitTest::LogFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:182
f
ScalarType f(const Teuchos::Array< ScalarType > &x, double a, double b)
Definition: gram_schmidt_example3.cpp:98
PseudoSpectralExpansionUnitTest::computePCE2
void computePCE2(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &a, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &b, const Stokhos::Quadrature< OrdinalType, ValueType > &quad)
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:78
Sacado::UQ::pow
KOKKOS_INLINE_FUNCTION PCE< Storage > pow(const PCE< Storage > &a, const PCE< Storage > &b)
Definition: Sacado_UQ_PCE_Imp.hpp:912
PseudoSpectralExpansionUnitTest::ASinFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:212
PseudoSpectralExpansionUnitTest::LogFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:183
PseudoSpectralExpansionUnitTest::ExpFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:180
Stokhos::Quadrature::getQuadPoints
virtual const Teuchos::Array< Teuchos::Array< value_type > > & getQuadPoints() const =0
Get quadrature points.
Stokhos::OrthogPolyApprox< OrdinalType, ValueType >
PseudoSpectralExpansionUnitTest::SinhFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:204
PseudoSpectralExpansionUnitTest::TanFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:201
Sacado::UQ::tanh
KOKKOS_INLINE_FUNCTION PCE< Storage > tanh(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:1050
PseudoSpectralExpansionUnitTest::computePCE2LC
void computePCE2LC(Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &c, ValueType a, const Stokhos::OrthogPolyApprox< OrdinalType, ValueType > &b, const Stokhos::Quadrature< OrdinalType, ValueType > &quad)
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:111
PseudoSpectralExpansionUnitTest::ASinhFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:222
Sacado::UQ::cbrt
KOKKOS_INLINE_FUNCTION PCE< Storage > cbrt(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:895
PseudoSpectralExpansionUnitTest::TanhFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:210
PseudoSpectralExpansionUnitTest::ATanhFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:232
PseudoSpectralExpansionUnitTest::ACoshFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:227
PseudoSpectralExpansionUnitTest::UMinusFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:176
PseudoSpectralExpansionUnitTest::SinFunc::operator()
double operator()(double a) const
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:195
Sacado::UQ::acos
KOKKOS_INLINE_FUNCTION PCE< Storage > acos(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:1067
Exp
Exp
Definition: Stokhos_LanczosUnitTest.cpp:318
PseudoSpectralExpansionUnitTest::ASinhFunc
Definition: Stokhos_PseudoSpectralExpansionUnitTest.hpp:221
Sin
Sin
Definition: Stokhos_LanczosUnitTest.cpp:292
Generated by   doxygen 1.8.16