Stokhos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Stokhos_TensorProductPseudoSpectralOperatorUnitTest.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#include "Teuchos_ArrayView.hpp"
49
50#include "Stokhos.hpp"
51#include "Stokhos_UnitTestHelpers.hpp"
52
53namespace TensorProductUnitTest {
54
55 // Common setup for unit tests
56 template <typename OrdinalType, typename ValueType>
57 struct UnitTestSetup {
58 ValueType rtol, atol;
59 OrdinalType p,d;
60
61 UnitTestSetup() {
62 rtol = 1e-12;
63 atol = 1e-12;
64 d = 3;
65 p = 5;
66 }
67
68 };
69
70 typedef int ordinal_type;
71 typedef double value_type;
72 UnitTestSetup<ordinal_type,value_type> setup;
73
74 // Function for testing quadratures
75 value_type quad_func1(const Teuchos::ArrayView<const value_type>& x) {
76 value_type val = 0.0;
77 for (int i=0; i<x.size(); i++)
78 val += x[i];
79 return std::exp(val);
80 }
81
82 // Function for testing quadratures
83 value_type quad_func2(const Teuchos::ArrayView<const value_type>& x) {
84 value_type val = 0.0;
85 for (int i=0; i<x.size(); i++)
86 val += x[i];
87 return std::sin(val);
88 }
89
90 TEUCHOS_UNIT_TEST( TensorProduct, IsotropicPoints ) {
91 success = true;
92
93 // Build tensor product basis of dimension d and order p
94 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
95 for (ordinal_type i=0; i<setup.d; i++)
96 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
97 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
98 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
99 *basis);
100 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
101 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
102 *basis, quad);
103
104 success = Stokhos::testPseudoSpectralPoints(
105 tp_op, quad_op, setup.rtol, setup.atol, out);
106 }
107
108 TEUCHOS_UNIT_TEST( TensorProduct, AnisotropicPoints ) {
109 success = true;
110
111 // Build aniostropic tensor product basis of dimension d
112 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
113 for (ordinal_type i=0; i<setup.d; i++)
114 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
115 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
116 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
117 *basis);
118 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
119 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
120 *basis, quad);
121
122 success = Stokhos::testPseudoSpectralPoints(
123 tp_op, quad_op, setup.rtol, setup.atol, out);
124 }
125
126 TEUCHOS_UNIT_TEST( TensorProduct, Apply ) {
127 success = true;
128
129 // Build anisotropic tensor product basis of dimension d
130 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
131 for (ordinal_type i=0; i<setup.d; i++)
132 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
133 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
134 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
135 *basis);
136 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
137 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
138 *basis, quad);
139
140 success = Stokhos::testPseudoSpectralApply(
141 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
142 }
143
144 TEUCHOS_UNIT_TEST( TensorProduct, Apply_Trans ) {
145 success = true;
146
147 // Build anisotropic tensor product basis of dimension d
148 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
149 for (ordinal_type i=0; i<setup.d; i++)
150 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
151 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
152 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
153 *basis);
154 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
155 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
156 *basis, quad);
157
158 success = Stokhos::testPseudoSpectralApplyTrans(
159 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
160 }
161
162 TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Lexo ) {
163 success = true;
164
165 // Build anisotropic tensor product basis of dimension d
166 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
167 for (ordinal_type i=0; i<setup.d; i++)
168 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
169 typedef Stokhos::LexographicLess<Stokhos::MultiIndex<ordinal_type> > coeff_compare;
170 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type,coeff_compare>(bases));
171 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
172 *basis, true);
173 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
174 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
175 *basis, quad);
176
177 success = Stokhos::testPseudoSpectralApply(
178 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
179 }
180
181 TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_TotalOrder ) {
182 success = true;
183
184 // Build anisotropic tensor product basis of dimension d
185 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
186 for (ordinal_type i=0; i<setup.d; i++)
187 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
188 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
189 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
190 *basis, true);
191 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
192 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
193 *basis, quad);
194
195 success = Stokhos::testPseudoSpectralApply(
196 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
197 }
198
199 TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Trans_Lexo ) {
200 success = true;
201
202 // Build anisotropic tensor product basis of dimension d
203 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
204 for (ordinal_type i=0; i<setup.d; i++)
205 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
206 typedef Stokhos::LexographicLess<Stokhos::MultiIndex<ordinal_type> > coeff_compare;
207 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type,coeff_compare>(bases));
208 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
209 *basis, true);
210 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
211 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
212 *basis, quad);
213
214 success = Stokhos::testPseudoSpectralApplyTrans(
215 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
216 }
217
218 TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Trans_TotalOrder ) {
219 success = true;
220
221 // Build anisotropic tensor product basis of dimension d
222 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
223 for (ordinal_type i=0; i<setup.d; i++)
224 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
225 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
226 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
227 *basis, true);
228 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
229 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
230 *basis, quad);
231
232 success = Stokhos::testPseudoSpectralApplyTrans(
233 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
234 }
235
236 TEUCHOS_UNIT_TEST( TensorProduct, IsotropicDiscreteOrthogonality ) {
237 success = true;
238
239 // Build tensor product basis of dimension d and order p
240 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
241 for (ordinal_type i=0; i<setup.d; i++)
242 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
243 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
244 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
245 *basis, true);
246
247 success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
248 *basis, tp_op, setup.rtol, setup.atol, out);
249 }
250
251 TEUCHOS_UNIT_TEST( TensorProduct, AnisotropicDiscreteOrthogonality ) {
252 success = true;
253
254 // Build tensor product basis of dimension d and order p
255 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
256 for (ordinal_type i=0; i<setup.d; i++)
257 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
258 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
259 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
260 *basis, true);
261
262 success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
263 *basis, tp_op, setup.rtol, setup.atol, out);
264 }
265
266 TEUCHOS_UNIT_TEST( TotalOrder, IsotropicPoints ) {
267 success = true;
268
269 // Build total order basis of dimension d and order p
270 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
271 for (ordinal_type i=0; i<setup.d; i++)
272 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
273 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
274 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
275 *basis);
276 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
277 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
278 *basis, quad);
279
280 success = Stokhos::testPseudoSpectralPoints(
281 tp_op, quad_op, setup.rtol, setup.atol, out);
282 }
283
284 TEUCHOS_UNIT_TEST( TotalOrder, AnisotropicPoints ) {
285 success = true;
286
287 // Build aniostropic tensor product basis of dimension d
288 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
289 for (ordinal_type i=0; i<setup.d; i++)
290 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
291 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
292 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
293 *basis);
294 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
295 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
296 *basis, quad);
297
298 success = Stokhos::testPseudoSpectralPoints(
299 tp_op, quad_op, setup.rtol, setup.atol, out);
300 }
301
302 TEUCHOS_UNIT_TEST( TotalOrder, Apply ) {
303 success = true;
304
305 // Build anisotropic tensor product basis of dimension d
306 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
307 for (ordinal_type i=0; i<setup.d; i++)
308 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
309 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
310 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
311 *basis);
312 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
313 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
314 *basis, quad);
315
316 success = Stokhos::testPseudoSpectralApply(
317 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
318 }
319
320 TEUCHOS_UNIT_TEST( TotalOrder, ApplyTrans ) {
321 success = true;
322
323 // Build anisotropic tensor product basis of dimension d
324 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
325 for (ordinal_type i=0; i<setup.d; i++)
326 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
327 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
328 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
329 *basis);
330 Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
331 Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
332 *basis, quad);
333
334 success = Stokhos::testPseudoSpectralApplyTrans(
335 tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
336 }
337
338 TEUCHOS_UNIT_TEST( TotalOrder, IsotropicDiscreteOrthogonality ) {
339 success = true;
340
341 // Build tensor product basis of dimension d and order p
342 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
343 for (ordinal_type i=0; i<setup.d; i++)
344 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
345 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
346 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
347 *basis);
348
349 success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
350 *basis, tp_op, setup.rtol, setup.atol, out);
351 }
352
353 TEUCHOS_UNIT_TEST( TotalOrder, AnisotropicDiscreteOrthogonality ) {
354 success = true;
355
356 // Build tensor product basis of dimension d and order p
357 Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
358 for (ordinal_type i=0; i<setup.d; i++)
359 bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
360 Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
361 Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
362 *basis);
363
364 success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
365 *basis, tp_op, setup.rtol, setup.atol, out);
366 }
367
368}
369
370int main( int argc, char* argv[] ) {
371 Teuchos::GlobalMPISession mpiSession(&argc, &argv);
372 int res = Teuchos::UnitTestRepository::runUnitTestsFromMain(argc, argv);
373 Teuchos::TimeMonitor::summarize(std::cout);
374 return res;
375}
val
expr val()
argv
char * argv[]
Definition Stokhos_HouseTriDiagUnitTest.cpp:286
main
int main(int argc, char *argv[])
Definition Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:370
Stokhos_UnitTestHelpers.hpp
Stokhos::LegendreBasis
Legendre polynomial basis.
Definition Stokhos_LegendreBasis.hpp:68
Stokhos::LexographicLess
A comparison functor implementing a strict weak ordering based lexographic ordering.
Definition Stokhos_ProductBasisUtils.hpp:799
Stokhos::QuadraturePseudoSpectralOperator
An operator for building pseudo-spectral coefficients using an arbitrary quadrature rule.
Definition Stokhos_QuadraturePseudoSpectralOperator.hpp:61
Stokhos::TensorProductBasis
Multivariate orthogonal polynomial basis generated from a tensor product of univariate polynomials.
Definition Stokhos_TensorProductBasis.hpp:70
Stokhos::TensorProductPseudoSpectralOperator
An operator for building pseudo-spectral coefficients using tensor-product quadrature.
Definition Stokhos_TensorProductPseudoSpectralOperator.hpp:62
Stokhos::TensorProductQuadrature
Defines quadrature for a tensor product basis by tensor products of 1-D quadrature rules.
Definition Stokhos_TensorProductQuadrature.hpp:58
Stokhos::TotalOrderBasis
Multivariate orthogonal polynomial basis generated from a total order tensor product of univariate po...
Definition Stokhos_TotalOrderBasis.hpp:69
Stokhos::testPseudoSpectralDiscreteOrthogonality
bool testPseudoSpectralDiscreteOrthogonality(const basis_type &basis, const operator_type &op, const scalar_type &rel_tol, const scalar_type &abs_tol, Teuchos::FancyOStream &out)
Definition Stokhos_UnitTestHelpers.hpp:528
Stokhos::testPseudoSpectralApplyTrans
bool testPseudoSpectralApplyTrans(const operator_type1 &op1, const operator_type2 &op2, const func_type1 &func1, const func_type2 &func2, const scalar_type &rel_tol, const scalar_type &abs_tol, Teuchos::FancyOStream &out)
Definition Stokhos_UnitTestHelpers.hpp:469
Stokhos::testPseudoSpectralPoints
bool testPseudoSpectralPoints(const operator_type1 &op1, const operator_type2 &op2, const scalar_type &rel_tol, const scalar_type &abs_tol, Teuchos::FancyOStream &out)
Definition Stokhos_UnitTestHelpers.hpp:366
Stokhos::testPseudoSpectralApply
bool testPseudoSpectralApply(const operator_type1 &op1, const operator_type2 &op2, const func_type1 &func1, const func_type2 &func2, const scalar_type &rel_tol, const scalar_type &abs_tol, Teuchos::FancyOStream &out)
Definition Stokhos_UnitTestHelpers.hpp:408
TensorProductUnitTest::quad_func2
value_type quad_func2(const Teuchos::ArrayView< const value_type > &x)
Definition Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:83
TensorProductUnitTest::setup
UnitTestSetup< ordinal_type, value_type > setup
Definition Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:72
TensorProductUnitTest::quad_func1
value_type quad_func1(const Teuchos::ArrayView< const value_type > &x)
Definition Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:75
Generated by doxygen 1.17.0