Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Stokhos_SmolyakPseudoSpectralOperatorUnitTest.cpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Stokhos Package
4 //
5 // Copyright 2009 NTESS and the Stokhos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #include "Teuchos_UnitTestHarness.hpp"
11 #include "Teuchos_TestingHelpers.hpp"
12 #include "Teuchos_UnitTestRepository.hpp"
13 #include "Teuchos_GlobalMPISession.hpp"
14 #include "Teuchos_ArrayView.hpp"
15 
16 #include "Stokhos.hpp"
17 #include "Stokhos_UnitTestHelpers.hpp"
18 
19 namespace SmolyakBasisUtilsUnitTest {
20 
21  // Common setup for unit tests
22  template <typename ordinal_type, typename value_type>
23  struct UnitTestSetup {
24  value_type rtol, atol;
25  value_type apply_rtol, apply_atol;
26  ordinal_type p,d;
27 
28  UnitTestSetup() {
29  rtol = 1e-12;
30  atol = 1e-12;
31  apply_rtol = 1e-2;
32  apply_atol = 1e-3;
33  p = 4;
34  d = 2;
35  }
36 
37  };
38 
39  typedef int ordinal_type;
40  typedef double value_type;
41  typedef UnitTestSetup<ordinal_type,value_type> setup_type;
42  setup_type setup;
43 
44  // Function for testing quadratures
45  value_type quad_func1(const Teuchos::ArrayView<const value_type>& x) {
46  value_type val = 0.0;
47  for (int i=0; i<x.size(); i++)
48  val += x[i];
49  return std::exp(val);
50  }
51 
52  // Function for testing quadratures
53  value_type quad_func2(const Teuchos::ArrayView<const value_type>& x) {
54  value_type val = 0.0;
55  for (int i=0; i<x.size(); i++)
56  val += x[i];
57  return std::sin(val);
58  }
59 
60  TEUCHOS_UNIT_TEST( Direct, Linear ) {
61  // Build isotropic Smolyak basis of dimension d and order p with
62  // linear growth
63  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
64  for (ordinal_type i=0; i<setup.d; i++)
65  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
66  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
67  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
68 
69  // Build corresponding pseudospectral operator
70  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
71  *smolyak_basis, false);
72 
73  // Generate sparse grids using original approach
74  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
75  smolyak_basis, setup.p, 1e-12, Pecos::SLOW_RESTRICTED_GROWTH);
76  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
77  *smolyak_basis, quad);
78 
79  // Test grid
80  success = Stokhos::testPseudoSpectralPoints(
81  sm_op, quad_op, setup.rtol, setup.atol, out);
82 
83  // Test apply
84  success = success &&
85  Stokhos::testPseudoSpectralApply(
86  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
87 
88  // Test transpose apply
89  success = success &&
90  Stokhos::testPseudoSpectralApplyTrans(
91  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
92 
93  // Test discrete orthogonality
94  success = success &&
95  Stokhos::testPseudoSpectralDiscreteOrthogonality(
96  *smolyak_basis, sm_op, setup.rtol, setup.atol, out);
97  }
98 
99  TEUCHOS_UNIT_TEST( Direct, ModerateLinear ) {
100  // Build isotropic Smolyak basis of dimension d and order p with
101  // moderate linear growth
102  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
103  for (ordinal_type i=0; i<setup.d; i++)
104  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true, Stokhos::MODERATE_GROWTH));
105  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
106  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
107 
108  // Build corresponding pseudospectral operator
109  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
110  *smolyak_basis, false);
111 
112  // Generate sparse grids using original approach
113  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
114  smolyak_basis, setup.p, 1e-12, Pecos::MODERATE_RESTRICTED_GROWTH);
115  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
116  *smolyak_basis, quad);
117 
118  // Test grid
119  success = Stokhos::testPseudoSpectralPoints(
120  sm_op, quad_op, setup.rtol, setup.atol, out);
121 
122  // Test apply
123  success = success &&
124  Stokhos::testPseudoSpectralApply(
125  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
126 
127  // Test transpose apply
128  success = success &&
129  Stokhos::testPseudoSpectralApplyTrans(
130  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
131 
132  // Direct apply will not satisfy discrete orthogonality
133  }
134 
135  TEUCHOS_UNIT_TEST( Smolyak, Linear ) {
136  // Build isotropic Smolyak basis of dimension d and order p with
137  // linear growth
138  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
139  for (ordinal_type i=0; i<setup.d; i++)
140  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
141  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
142  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
143 
144  // Build corresponding pseudospectral operator
145  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
146  *smolyak_basis, true);
147 
148  // Generate sparse grids using original approach
149  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
150  smolyak_basis, setup.p, 1e-12, Pecos::SLOW_RESTRICTED_GROWTH);
151  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
152  *smolyak_basis, quad);
153 
154  Stokhos::TensorProductQuadrature<ordinal_type,value_type> tp_quad(
155  smolyak_basis);
156  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> tp_quad_op(*smolyak_basis, tp_quad);
157 
158  // Test grid
159  success = Stokhos::testPseudoSpectralPoints(
160  sm_op, quad_op, setup.rtol, setup.atol, out);
161 
162  // Test apply
163  success = success &&
164  Stokhos::testPseudoSpectralApply(
165  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
166 
167  // Test transpose apply
168  success = success &&
169  Stokhos::testPseudoSpectralApplyTrans(
170  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
171 
172  // Test discrete orthogonality
173  success = success &&
174  Stokhos::testPseudoSpectralDiscreteOrthogonality(
175  *smolyak_basis, sm_op, setup.rtol, setup.atol, out);
176  }
177 
178  TEUCHOS_UNIT_TEST( Smolyak, ModerateLinear ) {
179  // Build isotropic Smolyak basis of dimension d and order p with
180  // moderate linear growth
181  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
182  for (ordinal_type i=0; i<setup.d; i++)
183  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true, Stokhos::MODERATE_GROWTH));
184  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
185  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
186 
187  // Build corresponding pseudospectral operator
188  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
189  *smolyak_basis, true);
190 
191  // Generate sparse grids using original approach
192  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
193  smolyak_basis, setup.p, 1e-12, Pecos::MODERATE_RESTRICTED_GROWTH);
194  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
195  *smolyak_basis, quad);
196 
197  Stokhos::TensorProductQuadrature<ordinal_type,value_type> tp_quad(
198  smolyak_basis);
199  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> tp_quad_op(*smolyak_basis, tp_quad);
200 
201  // Test grid
202  success = Stokhos::testPseudoSpectralPoints(
203  sm_op, quad_op, setup.rtol, setup.atol, out);
204 
205  // Test apply
206  success = success &&
207  Stokhos::testPseudoSpectralApply(
208  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
209 
210  // Test transpose apply
211  success = success &&
212  Stokhos::testPseudoSpectralApplyTrans(
213  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
214 
215  // Test discrete orthogonality
216  success = success &&
217  Stokhos::testPseudoSpectralDiscreteOrthogonality(
218  *smolyak_basis, sm_op, setup.rtol, setup.atol, out);
219  }
220 
221 #ifdef HAVE_STOKHOS_DAKOTA
222 
223  TEUCHOS_UNIT_TEST( Direct, ClenshawCurtis ) {
224  // Build isotropic Smolyak basis of dimension d and order p with
225  // exponential growth
226  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
227  for (ordinal_type i=0; i<setup.d; i++)
228  bases[i] = Teuchos::rcp(new Stokhos::ClenshawCurtisLegendreBasis<ordinal_type,value_type>(setup.p, true));
229  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
230  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
231 
232  // Build corresponding pseudospectral operator
233  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
234  *smolyak_basis, false);
235 
236  // Generate sparse grids using original approach
237  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
238  smolyak_basis, setup.p, 1e-12, Pecos::UNRESTRICTED_GROWTH);
239  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
240  *smolyak_basis, quad);
241 
242  // Test grid
243  success = Stokhos::testPseudoSpectralPoints(
244  sm_op, quad_op, setup.rtol, setup.atol, out);
245 
246  // Test apply
247  success = success &&
248  Stokhos::testPseudoSpectralApply(
249  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
250 
251  // Test transpose apply
252  success = success &&
253  Stokhos::testPseudoSpectralApplyTrans(
254  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
255 
256  // Direct apply will not satisfy discrete orthogonality
257  }
258 
259  TEUCHOS_UNIT_TEST( Direct, GaussPatterson ) {
260  // Build isotropic Smolyak basis of dimension d and order p with
261  // exponential Gauss-Patterson growth
262  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
263  for (ordinal_type i=0; i<setup.d; i++)
264  bases[i] = Teuchos::rcp(new Stokhos::GaussPattersonLegendreBasis<ordinal_type,value_type>(setup.p, true));
265  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
266  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
267 
268  // Build corresponding pseudospectral operator
269  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
270  *smolyak_basis, false);
271 
272  // Generate sparse grids using original approach
273  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
274  smolyak_basis, setup.p, 1e-12, Pecos::UNRESTRICTED_GROWTH);
275  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
276  *smolyak_basis, quad);
277 
278  // Test grid
279  success = Stokhos::testPseudoSpectralPoints(
280  sm_op, quad_op, setup.rtol, setup.atol, out);
281 
282  // Test apply
283  success = success &&
284  Stokhos::testPseudoSpectralApply(
285  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
286 
287  // Test transpose apply
288  success = success &&
289  Stokhos::testPseudoSpectralApplyTrans(
290  sm_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
291 
292  // Direct apply will not satisfy discrete orthogonality
293  }
294 
295  TEUCHOS_UNIT_TEST( Smolyak, ClenshawCurtis ) {
296  // Build isotropic Smolyak basis of dimension d and order p with
297  // exponential growth
298  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
299  for (ordinal_type i=0; i<setup.d; i++)
300  bases[i] = Teuchos::rcp(new Stokhos::ClenshawCurtisLegendreBasis<ordinal_type,value_type>(setup.p, true));
301  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
302  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
303 
304  // Build corresponding pseudospectral operator
305  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
306  *smolyak_basis, true);
307 
308  // Generate sparse grids using original approach
309  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
310  smolyak_basis, setup.p, 1e-12, Pecos::UNRESTRICTED_GROWTH);
311  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
312  *smolyak_basis, quad);
313 
314  Stokhos::TensorProductQuadrature<ordinal_type,value_type> tp_quad(
315  smolyak_basis);
316  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> tp_quad_op(*smolyak_basis, tp_quad);
317 
318  // Test grid
319  success = Stokhos::testPseudoSpectralPoints(
320  sm_op, quad_op, setup.rtol, setup.atol, out);
321 
322  // Test apply
323  success = success &&
324  Stokhos::testPseudoSpectralApply(
325  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
326 
327  // Test transpose apply
328  success = success &&
329  Stokhos::testPseudoSpectralApplyTrans(
330  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
331 
332  // Test discrete orthogonality
333  success = success &&
334  Stokhos::testPseudoSpectralDiscreteOrthogonality(
335  *smolyak_basis, sm_op, setup.rtol, setup.atol, out);
336  }
337 
338  TEUCHOS_UNIT_TEST( Smolyak, GaussPatterson ) {
339  // Build isotropic Smolyak basis of dimension d and order p with
340  // exponential Gauss-Patterson growth
341  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
342  for (ordinal_type i=0; i<setup.d; i++)
343  bases[i] = Teuchos::rcp(new Stokhos::GaussPattersonLegendreBasis<ordinal_type,value_type>(setup.p, true));
344  Stokhos::TotalOrderIndexSet<ordinal_type> coeff_index_set(setup.d, setup.p);
345  Teuchos::RCP< Stokhos::SmolyakBasis<ordinal_type,value_type> > smolyak_basis = Teuchos::rcp(new Stokhos::SmolyakBasis<ordinal_type,value_type>(bases, coeff_index_set));
346 
347  // Build corresponding pseudospectral operator
348  Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type> sm_op(
349  *smolyak_basis, true);
350 
351  // Generate sparse grids using original approach
352  Stokhos::SparseGridQuadrature<ordinal_type,value_type> quad(
353  smolyak_basis, setup.p, 1e-12, Pecos::UNRESTRICTED_GROWTH);
354  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
355  *smolyak_basis, quad);
356 
357  Stokhos::TensorProductQuadrature<ordinal_type,value_type> tp_quad(
358  smolyak_basis);
359  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> tp_quad_op(*smolyak_basis, tp_quad);
360 
361  // Test grid
362  success = Stokhos::testPseudoSpectralPoints(
363  sm_op, quad_op, setup.rtol, setup.atol, out);
364 
365  // Test apply
366  success = success &&
367  Stokhos::testPseudoSpectralApply(
368  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
369 
370  // Test transpose apply
371  success = success &&
372  Stokhos::testPseudoSpectralApplyTrans(
373  sm_op, tp_quad_op, quad_func1, quad_func2, setup.apply_rtol, setup.apply_atol, out);
374 
375  // Test discrete orthogonality
376  success = success &&
377  Stokhos::testPseudoSpectralDiscreteOrthogonality(
378  *smolyak_basis, sm_op, setup.rtol, setup.atol, out);
379  }
380 
381 #endif
382 
383 }
384 
385 int main( int argc, char* argv[] ) {
386  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
387  return Teuchos::UnitTestRepository::runUnitTestsFromMain(argc, argv);
388 }
argv
char * argv[]
Definition: Stokhos_HouseTriDiagUnitTest.cpp:252
Teuchos_ArrayView.hpp
Teuchos::ArrayView::size
size_type size() const
SmolyakBasisUtilsUnitTest::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(Coefficients, IsotropicLinear)
Definition: Stokhos_SmolyakBasisUnitTest.cpp:70
Teuchos_UnitTestRepository.hpp
Stokhos::GaussPattersonLegendreBasis
Legendre polynomial basis using Gauss-Patterson quadrature points.
Definition: Stokhos_GaussPattersonLegendreBasis.hpp:23
Teuchos::UnitTestRepository::runUnitTestsFromMain
static int runUnitTestsFromMain(int argc, char *argv[])
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Teuchos_UnitTestHarness.hpp
Stokhos::SmolyakPseudoSpectralOperator
An operator for building pseudo-spectral coefficients using a sparse Smolyak construction.
Definition: Stokhos_SmolyakPseudoSpectralOperator.hpp:29
SmolyakBasisUtilsUnitTest::quad_func2
value_type quad_func2(const Teuchos::ArrayView< const value_type > &x)
Definition: Stokhos_SmolyakPseudoSpectralOperatorUnitTest.cpp:53
Stokhos_UnitTestHelpers.hpp
Stokhos::SmolyakBasis
Multivariate orthogonal polynomial basis generated from a Smolyak sparse grid.
Definition: Stokhos_SmolyakBasis.hpp:30
Sacado::UQ::exp
KOKKOS_INLINE_FUNCTION PCE< Storage > exp(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:796
Stokhos::LegendreBasis
Legendre polynomial basis.
Definition: Stokhos_LegendreBasis.hpp:33
main
int main(int argc, char **argv)
Definition: cijk_ltb_partition.cpp:25
Teuchos_TestingHelpers.hpp
val
expr val()
Stokhos::TotalOrderIndexSet
An isotropic total order index set.
Definition: Stokhos_ProductBasisUtils.hpp:183
SmolyakBasisUtilsUnitTest::setup_type
UnitTestSetup< ordinal_type, value_type > setup_type
Definition: Stokhos_SmolyakBasisUnitTest.cpp:38
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:496
Teuchos_GlobalMPISession.hpp
Stokhos::ClenshawCurtisLegendreBasis
Legendre polynomial basis using Clenshaw-Curtis quadrature points.
Definition: Stokhos_ClenshawCurtisLegendreBasis.hpp:23
Sacado::UQ::sin
KOKKOS_INLINE_FUNCTION PCE< Storage > sin(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:934
Stokhos::QuadraturePseudoSpectralOperator
An operator for building pseudo-spectral coefficients using an arbitrary quadrature rule...
Definition: Stokhos_QuadraturePseudoSpectralOperator.hpp:28
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:334
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:376
Stokhos::TensorProductQuadrature
Defines quadrature for a tensor product basis by tensor products of 1-D quadrature rules...
Definition: Stokhos_TensorProductQuadrature.hpp:24
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:437
SmolyakBasisUtilsUnitTest::quad_func1
value_type quad_func1(const Teuchos::ArrayView< const value_type > &x)
Definition: Stokhos_SmolyakPseudoSpectralOperatorUnitTest.cpp:45
Generated on Fri Nov 22 2024 09:18:14 for Stokhos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5