Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Stokhos_TensorProductPseudoSpectralOperatorUnitTest.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 TensorProductUnitTest {
20 
21  // Common setup for unit tests
22  template <typename OrdinalType, typename ValueType>
23  struct UnitTestSetup {
24  ValueType rtol, atol;
25  OrdinalType p,d;
26 
27  UnitTestSetup() {
28  rtol = 1e-12;
29  atol = 1e-12;
30  d = 3;
31  p = 5;
32  }
33 
34  };
35 
36  typedef int ordinal_type;
37  typedef double value_type;
38  UnitTestSetup<ordinal_type,value_type> setup;
39 
40  // Function for testing quadratures
41  value_type quad_func1(const Teuchos::ArrayView<const value_type>& x) {
42  value_type val = 0.0;
43  for (int i=0; i<x.size(); i++)
44  val += x[i];
45  return std::exp(val);
46  }
47 
48  // Function for testing quadratures
49  value_type quad_func2(const Teuchos::ArrayView<const value_type>& x) {
50  value_type val = 0.0;
51  for (int i=0; i<x.size(); i++)
52  val += x[i];
53  return std::sin(val);
54  }
55 
56  TEUCHOS_UNIT_TEST( TensorProduct, IsotropicPoints ) {
57  success = true;
58 
59  // Build tensor product basis of dimension d and order p
60  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
61  for (ordinal_type i=0; i<setup.d; i++)
62  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
63  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
64  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
65  *basis);
66  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
67  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
68  *basis, quad);
69 
70  success = Stokhos::testPseudoSpectralPoints(
71  tp_op, quad_op, setup.rtol, setup.atol, out);
72  }
73 
74  TEUCHOS_UNIT_TEST( TensorProduct, AnisotropicPoints ) {
75  success = true;
76 
77  // Build aniostropic tensor product basis of dimension d
78  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
79  for (ordinal_type i=0; i<setup.d; i++)
80  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
81  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
82  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
83  *basis);
84  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
85  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
86  *basis, quad);
87 
88  success = Stokhos::testPseudoSpectralPoints(
89  tp_op, quad_op, setup.rtol, setup.atol, out);
90  }
91 
92  TEUCHOS_UNIT_TEST( TensorProduct, Apply ) {
93  success = true;
94 
95  // Build anisotropic tensor product basis of dimension d
96  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
97  for (ordinal_type i=0; i<setup.d; i++)
98  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
99  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
100  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
101  *basis);
102  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
103  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
104  *basis, quad);
105 
106  success = Stokhos::testPseudoSpectralApply(
107  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
108  }
109 
110  TEUCHOS_UNIT_TEST( TensorProduct, Apply_Trans ) {
111  success = true;
112 
113  // Build anisotropic tensor product basis of dimension d
114  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
115  for (ordinal_type i=0; i<setup.d; i++)
116  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
117  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
118  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
119  *basis);
120  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
121  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
122  *basis, quad);
123 
124  success = Stokhos::testPseudoSpectralApplyTrans(
125  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
126  }
127 
128  TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Lexo ) {
129  success = true;
130 
131  // Build anisotropic tensor product basis of dimension d
132  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
133  for (ordinal_type i=0; i<setup.d; i++)
134  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
135  typedef Stokhos::LexographicLess<Stokhos::MultiIndex<ordinal_type> > coeff_compare;
136  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type,coeff_compare>(bases));
137  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
138  *basis, true);
139  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
140  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
141  *basis, quad);
142 
143  success = Stokhos::testPseudoSpectralApply(
144  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
145  }
146 
147  TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_TotalOrder ) {
148  success = true;
149 
150  // Build anisotropic tensor product basis of dimension d
151  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
152  for (ordinal_type i=0; i<setup.d; i++)
153  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
154  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
155  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
156  *basis, true);
157  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
158  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
159  *basis, quad);
160 
161  success = Stokhos::testPseudoSpectralApply(
162  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
163  }
164 
165  TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Trans_Lexo ) {
166  success = true;
167 
168  // Build anisotropic tensor product basis of dimension d
169  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
170  for (ordinal_type i=0; i<setup.d; i++)
171  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
172  typedef Stokhos::LexographicLess<Stokhos::MultiIndex<ordinal_type> > coeff_compare;
173  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type,coeff_compare>(bases));
174  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
175  *basis, true);
176  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
177  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
178  *basis, quad);
179 
180  success = Stokhos::testPseudoSpectralApplyTrans(
181  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
182  }
183 
184  TEUCHOS_UNIT_TEST( TensorProduct, Apply_PST_Trans_TotalOrder ) {
185  success = true;
186 
187  // Build anisotropic tensor product basis of dimension d
188  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
189  for (ordinal_type i=0; i<setup.d; i++)
190  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
191  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
192  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
193  *basis, true);
194  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
195  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
196  *basis, quad);
197 
198  success = Stokhos::testPseudoSpectralApplyTrans(
199  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
200  }
201 
202  TEUCHOS_UNIT_TEST( TensorProduct, IsotropicDiscreteOrthogonality ) {
203  success = true;
204 
205  // Build tensor product basis of dimension d and order p
206  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
207  for (ordinal_type i=0; i<setup.d; i++)
208  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
209  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
210  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
211  *basis, true);
212 
213  success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
214  *basis, tp_op, setup.rtol, setup.atol, out);
215  }
216 
217  TEUCHOS_UNIT_TEST( TensorProduct, AnisotropicDiscreteOrthogonality ) {
218  success = true;
219 
220  // Build tensor product basis of dimension d and order p
221  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
222  for (ordinal_type i=0; i<setup.d; i++)
223  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
224  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TensorProductBasis<ordinal_type,value_type>(bases));
225  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
226  *basis, true);
227 
228  success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
229  *basis, tp_op, setup.rtol, setup.atol, out);
230  }
231 
232  TEUCHOS_UNIT_TEST( TotalOrder, IsotropicPoints ) {
233  success = true;
234 
235  // Build total order basis of dimension d and order p
236  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
237  for (ordinal_type i=0; i<setup.d; i++)
238  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
239  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
240  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
241  *basis);
242  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
243  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
244  *basis, quad);
245 
246  success = Stokhos::testPseudoSpectralPoints(
247  tp_op, quad_op, setup.rtol, setup.atol, out);
248  }
249 
250  TEUCHOS_UNIT_TEST( TotalOrder, AnisotropicPoints ) {
251  success = true;
252 
253  // Build aniostropic tensor product basis of dimension d
254  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
255  for (ordinal_type i=0; i<setup.d; i++)
256  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
257  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
258  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
259  *basis);
260  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
261  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
262  *basis, quad);
263 
264  success = Stokhos::testPseudoSpectralPoints(
265  tp_op, quad_op, setup.rtol, setup.atol, out);
266  }
267 
268  TEUCHOS_UNIT_TEST( TotalOrder, Apply ) {
269  success = true;
270 
271  // Build anisotropic tensor product basis of dimension d
272  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
273  for (ordinal_type i=0; i<setup.d; i++)
274  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
275  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
276  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
277  *basis);
278  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
279  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
280  *basis, quad);
281 
282  success = Stokhos::testPseudoSpectralApply(
283  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
284  }
285 
286  TEUCHOS_UNIT_TEST( TotalOrder, ApplyTrans ) {
287  success = true;
288 
289  // Build anisotropic tensor product basis of dimension d
290  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
291  for (ordinal_type i=0; i<setup.d; i++)
292  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
293  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
294  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
295  *basis);
296  Stokhos::TensorProductQuadrature<ordinal_type,value_type> quad(basis);
297  Stokhos::QuadraturePseudoSpectralOperator<ordinal_type,value_type> quad_op(
298  *basis, quad);
299 
300  success = Stokhos::testPseudoSpectralApplyTrans(
301  tp_op, quad_op, quad_func1, quad_func2, setup.rtol, setup.atol, out);
302  }
303 
304  TEUCHOS_UNIT_TEST( TotalOrder, IsotropicDiscreteOrthogonality ) {
305  success = true;
306 
307  // Build tensor product basis of dimension d and order p
308  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
309  for (ordinal_type i=0; i<setup.d; i++)
310  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(setup.p, true));
311  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
312  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
313  *basis);
314 
315  success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
316  *basis, tp_op, setup.rtol, setup.atol, out);
317  }
318 
319  TEUCHOS_UNIT_TEST( TotalOrder, AnisotropicDiscreteOrthogonality ) {
320  success = true;
321 
322  // Build tensor product basis of dimension d and order p
323  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
324  for (ordinal_type i=0; i<setup.d; i++)
325  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
326  Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
327  Stokhos::TensorProductPseudoSpectralOperator<ordinal_type,value_type> tp_op(
328  *basis);
329 
330  success = Stokhos::testPseudoSpectralDiscreteOrthogonality(
331  *basis, tp_op, setup.rtol, setup.atol, out);
332  }
333 
334 }
335 
336 int main( int argc, char* argv[] ) {
337  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
338  int res = Teuchos::UnitTestRepository::runUnitTestsFromMain(argc, argv);
339  Teuchos::TimeMonitor::summarize(std::cout);
340  return res;
341 }
argv
char * argv[]
Definition: Stokhos_HouseTriDiagUnitTest.cpp:252
Stokhos::TotalOrderBasis
Multivariate orthogonal polynomial basis generated from a total order tensor product of univariate po...
Definition: Stokhos_TotalOrderBasis.hpp:36
Teuchos_ArrayView.hpp
Teuchos::ArrayView::size
size_type size() const
TensorProductUnitTest::quad_func2
value_type quad_func2(const Teuchos::ArrayView< const value_type > &x)
Definition: Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:49
Teuchos_UnitTestRepository.hpp
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::TimeMonitor::summarize
static void summarize(Ptr< const Comm< int > > comm, std::ostream &out=std::cout, const bool alwaysWriteLocal=false, const bool writeGlobalStats=true, const bool writeZeroTimers=true, const ECounterSetOp setOp=Intersection, const std::string &filter="", const bool ignoreZeroTimers=false)
Teuchos_UnitTestHarness.hpp
TensorProductUnitTest::quad_func1
value_type quad_func1(const Teuchos::ArrayView< const value_type > &x)
Definition: Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:41
Stokhos_UnitTestHelpers.hpp
Sacado::UQ::exp
KOKKOS_INLINE_FUNCTION PCE< Storage > exp(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:796
Stokhos::TensorProductBasis
Multivariate orthogonal polynomial basis generated from a tensor product of univariate polynomials...
Definition: Stokhos_TensorProductBasis.hpp:37
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::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
TensorProductUnitTest::setup
UnitTestSetup< ordinal_type, value_type > setup
Definition: Stokhos_TensorProductPseudoSpectralOperatorUnitTest.cpp:38
Stokhos::LexographicLess
A comparison functor implementing a strict weak ordering based lexographic ordering.
Definition: Stokhos_ProductBasisUtils.hpp:767
Sacado::UQ::sin
KOKKOS_INLINE_FUNCTION PCE< Storage > sin(const PCE< Storage > &a)
Definition: Sacado_UQ_PCE_Imp.hpp:934
Stokhos::TensorProductPseudoSpectralOperator
An operator for building pseudo-spectral coefficients using tensor-product quadrature.
Definition: Stokhos_TensorProductPseudoSpectralOperator.hpp:29
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
Generated on Fri Nov 22 2024 09:18:15 for Stokhos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5