Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Stokhos_QuadOrthogPolyExpansionImp.hpp
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_Assert.hpp"
11 #include "Stokhos_DynamicArrayTraits.hpp"
12 #include "Teuchos_TimeMonitor.hpp"
13 #include "Teuchos_Tuple.hpp"
14 
15 template <typename ordinal_type, typename value_type, typename node_type>
16 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
17 QuadOrthogPolyExpansion(
18  const Teuchos::RCP<const Stokhos::OrthogPolyBasis<ordinal_type, value_type> >& basis_,
19  const Teuchos::RCP<const Stokhos::Sparse3Tensor<ordinal_type, value_type> >& Cijk_,
20  const Teuchos::RCP<const Quadrature<ordinal_type, value_type> >& quad_,
21  const Teuchos::RCP<Teuchos::ParameterList>& params_) :
22  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>(basis_, Cijk_, params_),
23  quad(quad_),
24  sz(this->basis->size()),
25  blas(),
26  quad_points(quad->getQuadPoints()),
27  quad_weights(quad->getQuadWeights()),
28  quad_values(quad->getBasisAtQuadPoints()),
29  norms(this->basis->norm_squared()),
30  nqp(quad_points.size()),
31  avals(nqp),
32  bvals(nqp),
33  fvals(nqp),
34  qv(nqp*sz),
35  sqv(nqp*sz)
36 {
37  for (ordinal_type qp=0; qp<nqp; qp++)
38  for (ordinal_type i=0; i<sz; i++) {
39  qv[qp*sz+i] = quad_values[qp][i];
40  sqv[qp*sz+i] = quad_values[qp][i]/norms[i];
41  }
42 
43  Teuchos::RCP<Teuchos::ParameterList> params = params_;
44  if (params == Teuchos::null)
45  params = Teuchos::rcp(new Teuchos::ParameterList);
46  use_quad_for_times = params->get("Use Quadrature for Times", false);
47  use_quad_for_division = params->get("Use Quadrature for Division", true);
48 }
49 
50 template <typename ordinal_type, typename value_type, typename node_type>
51 template <typename FuncT>
52 void
53 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
54 unary_op(const FuncT& func,
55  OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
56  const OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
57 {
58  ordinal_type pa = a.size();
59  ordinal_type pc;
60  if (a.size() == 1)
61  pc = 1;
62  else
63  pc = sz;
64  if (c.size() != pc)
65  c.resize(pc);
66 
67  if (pc == 1) {
68  c[0] = func(a[0]);
69  return;
70  }
71 
72  {
73 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
74  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- Unary Polynomial Evaluation");
75 #endif
76 
77  // Evaluate input
78  blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, a.coeff(), 1, 0.0,
79  &avals[0], 1);
80 
81  }
82 
83  {
84 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
85  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- Unary Function Evaluation");
86 #endif
87 
88  // Evaluate function
89  for (ordinal_type qp=0; qp<nqp; qp++) {
90  if (quad_weights[qp] != value_type(0))
91  fvals[qp] = func(avals[qp])*quad_weights[qp];
92  else
93  fvals[qp] = value_type(0);
94  }
95 
96  }
97 
98  {
99 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
100  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- Unary Polynomial Integration");
101 #endif
102 
103  // Integrate
104  blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
105  c.coeff(), 1);
106 
107  }
108 }
109 
110 template <typename ordinal_type, typename value_type, typename node_type>
111 template <typename FuncT>
112 void
113 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
114 binary_op(const FuncT& func,
115  OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
116  const OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
117  const OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
118 {
119  ordinal_type pa = a.size();
120  ordinal_type pb = b.size();
121  ordinal_type pc;
122  if (pa == 1 && pb == 1)
123  pc = 1;
124  else
125  pc = sz;
126  if (c.size() != pc)
127  c.resize(pc);
128 
129  if (pc == 1) {
130  c[0] = func(a[0], b[0]);
131  return;
132  }
133 
134  {
135 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
136  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PP Binary Polynomial Evaluation");
137 #endif
138 
139  // Evaluate input
140  blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, a.coeff(), 1, 0.0,
141  &avals[0], 1);
142  blas.GEMV(Teuchos::TRANS, pb, nqp, 1.0, &qv[0], sz, b.coeff(), 1, 0.0,
143  &bvals[0], 1);
144 
145  }
146 
147  {
148 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
149  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PP Binary Function Evaluation");
150 #endif
151 
152  // Evaluate function
153  for (ordinal_type qp=0; qp<nqp; qp++)
154  if (quad_weights[qp] != value_type(0))
155  fvals[qp] = func(avals[qp], bvals[qp])*quad_weights[qp];
156  else
157  fvals[qp] = value_type(0);
158 
159  }
160 
161  {
162 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
163  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PP Binary Polynomial Integration");
164 #endif
165 
166  // Integrate
167  blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
168  c.coeff(), 1);
169 
170  }
171 }
172 
173 template <typename ordinal_type, typename value_type, typename node_type>
174 template <typename FuncT>
175 void
176 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
177 binary_op(const FuncT& func,
178  OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
179  const value_type& a,
180  const OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
181 {
182  ordinal_type pb = b.size();
183  ordinal_type pc;
184  if (pb == 1)
185  pc = 1;
186  else
187  pc = sz;
188  if (c.size() != pc)
189  c.resize(pc);
190 
191  if (pc == 1) {
192  c[0] = func(a, b[0]);
193  return;
194  }
195 
196  {
197 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
198  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- CP Binary Polynomial Evaluation");
199 #endif
200 
201  // Evaluate input
202  blas.GEMV(Teuchos::TRANS, pb, nqp, 1.0, &qv[0], sz, b.coeff(), 1, 0.0,
203  &bvals[0], 1);
204 
205  }
206 
207  {
208 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
209  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- CP Binary Function Evaluation");
210 #endif
211 
212  // Evaluate function
213  for (ordinal_type qp=0; qp<nqp; qp++)
214  if (quad_weights[qp] != value_type(0))
215  fvals[qp] = func(a, bvals[qp])*quad_weights[qp];
216  else
217  fvals[qp] = value_type(0);
218 
219  }
220 
221  {
222 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
223  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- CP Binary Polynomial Integration");
224 #endif
225 
226  // Integrate
227  blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
228  c.coeff(), 1);
229 
230  }
231 }
232 
233 template <typename ordinal_type, typename value_type, typename node_type>
234 template <typename FuncT>
235 void
236 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
237 binary_op(const FuncT& func,
238  OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
239  const OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
240  const value_type& b)
241 {
242  ordinal_type pa = a.size();
243  ordinal_type pc;
244  if (pa == 1)
245  pc = 1;
246  else
247  pc = sz;
248  if (c.size() != pc)
249  c.resize(pc);
250 
251  if (pc == 1) {
252  c[0] = func(a[0], b);
253  return;
254  }
255 
256  {
257 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
258  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PC Binary Polynomial Evaluation");
259 #endif
260 
261  // Evaluate input
262  blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, a.coeff(), 1, 0.0,
263  &avals[0], 1);
264 
265  }
266 
267  {
268 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
269  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PC Binary Function Evaluation");
270 #endif
271 
272  // Evaluate function
273  for (ordinal_type qp=0; qp<nqp; qp++)
274  if (quad_weights[qp] != value_type(0))
275  fvals[qp] = func(avals[qp], b)*quad_weights[qp];
276  else
277  fvals[qp] = value_type(0);
278 
279  }
280 
281  {
282 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
283  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PC Binary Polynomial Integration");
284 #endif
285 
286  // Integrate
287  blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
288  c.coeff(), 1);
289 
290  }
291 }
292 
293 template <typename ordinal_type, typename value_type, typename node_type>
294 template <typename FuncT>
295 void
296 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
297 nary_op(const FuncT& func,
298  OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
299  const OrthogPolyApprox<ordinal_type, value_type, node_type>** na)
300 {
301  const int N = FuncT::N;
302  bool is_constant = true;
303  for (int i=0; i<N; i++) {
304  if (na[i]->size() > 1) {
305  is_constant = false;
306  break;
307  }
308  }
309  ordinal_type pc;
310  if (is_constant)
311  pc = 1;
312  else
313  pc = sz;
314  if (c.size() != pc)
315  c.resize(pc);
316 
317  if (pc == 1) {
318  value_type val[N];
319  for (int i=0; i<N; i++)
320  val[i] = (*na[i])[0];
321  c[0] = func(val);
322  return;
323  }
324 
325  if (N >= navals.size())
326  navals.resize(N+1);
327  if (navals[N].size() != N) {
328  navals[N].resize(N);
329  for (int i=0; i<N; i++)
330  navals[N][i].resize(nqp);
331  }
332 
333  {
334 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
335  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- N(" << N << ")-ary Polynomial Evaluation");
336 #endif
337 
338  // Evaluate input
339  for (int i=0; i<N; i++) {
340  //navals[i].resize(nqp);
341  ordinal_type pa = na[i]->size();
342  blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, na[i]->coeff(), 1, 0.0,
343  &navals[N][i][0], 1);
344  }
345 
346  }
347 
348  {
349 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
350  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- N(" << N << ")-ary Function Evaluation");
351 #endif
352 
353  // Evaluate function
354  value_type val[N];
355  for (ordinal_type qp=0; qp<nqp; qp++) {
356  if (quad_weights[qp] != value_type(0)) {
357  for (int i=0; i<N; i++)
358  val[i] = navals[N][i][qp];
359  fvals[qp] = func(val)*quad_weights[qp];
360  }
361  else
362  fvals[qp] = value_type(0);
363  }
364 
365  }
366 
367  {
368 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
369  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- N(" << N << ")-ary Polynomial Integration");
370 #endif
371 
372  // Integrate
373  blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
374  c.coeff(), 1);
375 
376  }
377 }
378 
379 template <typename ordinal_type, typename value_type, typename node_type>
380 void
381 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
382 timesEqual(
383  Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
384  const value_type& x)
385 {
386  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::timesEqual(c,x);
387 }
388 
389 template <typename ordinal_type, typename value_type, typename node_type>
390 void
391 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
392 divideEqual(
393  Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
394  const value_type& x)
395 {
396  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divideEqual(c,x);
397 }
398 
399 template <typename ordinal_type, typename value_type, typename node_type>
400 void
401 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
402 timesEqual(
403  Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
404  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& x)
405 {
406  if (use_quad_for_times)
407  binary_op(times_quad_func(), c, c, x);
408  else
409  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::timesEqual(c, x);
410 }
411 
412 template <typename ordinal_type, typename value_type, typename node_type>
413 void
414 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
415 divideEqual(
416  Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
417  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& x)
418 {
419 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
420  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::OrthogPolyExpansionBase::divideEqual(OPA)");
421 #endif
422  if (x.size() == 1) {
423  ordinal_type p = c.size();
424  value_type* cc = c.coeff();
425  const value_type* xc = x.coeff();
426  for (ordinal_type i=0; i<p; i++)
427  cc[i] /= xc[0];
428  }
429  else {
430  if (use_quad_for_division)
431  binary_op(div_quad_func(), c, c, x);
432  else
433  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divideEqual(c, x);
434  }
435 }
436 
437 template <typename ordinal_type, typename value_type, typename node_type>
438 void
439 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
440 times(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
441  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
442  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
443 {
444  if (use_quad_for_times)
445  binary_op(times_quad_func(), c, a, b);
446  else
447  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::times(c, a, b);
448 }
449 
450 template <typename ordinal_type, typename value_type, typename node_type>
451 void
452 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
453 times(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
454  const value_type& a,
455  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
456 {
457  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::times(c, a, b);
458 }
459 
460 template <typename ordinal_type, typename value_type, typename node_type>
461 void
462 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
463 times(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
464  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
465  const value_type& b)
466 {
467  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::times(c, a, b);
468 }
469 
470 template <typename ordinal_type, typename value_type, typename node_type>
471 void
472 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
473 divide(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
474  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
475  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
476 {
477 #ifdef STOKHOS_TEUCHOS_TIME_MONITOR
478  TEUCHOS_FUNC_TIME_MONITOR("Stokhos::OrthogPolyExpansionBase::divide(OPA,OPA)");
479 #endif
480  if (b.size() == 1) {
481  ordinal_type pc = a.size();
482  if (c.size() != pc)
483  c.resize(pc);
484 
485  const value_type* ca = a.coeff();
486  const value_type* cb = b.coeff();
487  value_type* cc = c.coeff();
488 
489  for (ordinal_type i=0; i<pc; i++)
490  cc[i] = ca[i]/cb[0];
491  }
492  else {
493  if (use_quad_for_division)
494  binary_op(div_quad_func(), c, a, b);
495  else
496  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divide(c, a, b);
497  }
498 }
499 
500 template <typename ordinal_type, typename value_type, typename node_type>
501 void
502 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
503 divide(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
504  const value_type& a,
505  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
506 {
507  if (use_quad_for_division)
508  binary_op(div_quad_func(), c, a, b);
509  else
510  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divide(c, a, b);
511 }
512 
513 template <typename ordinal_type, typename value_type, typename node_type>
514 void
515 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
516 divide(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
517  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
518  const value_type& b)
519 {
520  OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divide(c, a, b);
521 }
522 
523 template <typename ordinal_type, typename value_type, typename node_type>
524 void
525 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
526 exp(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
527  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
528 {
529  unary_op(exp_quad_func(), c, a);
530 }
531 
532 template <typename ordinal_type, typename value_type, typename node_type>
533 void
534 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
535 log(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
536  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
537 {
538  unary_op(log_quad_func(), c, a);
539 }
540 
541 template <typename ordinal_type, typename value_type, typename node_type>
542 void
543 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
544 log10(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
545  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
546 {
547  unary_op(log10_quad_func(), c, a);
548 }
549 
550 template <typename ordinal_type, typename value_type, typename node_type>
551 void
552 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
553 sqrt(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
554  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
555 {
556  unary_op(sqrt_quad_func(), c, a);
557 }
558 
559 template <typename ordinal_type, typename value_type, typename node_type>
560 void
561 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
562 cbrt(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
563  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
564 {
565  unary_op(cbrt_quad_func(), c, a);
566 }
567 
568 template <typename ordinal_type, typename value_type, typename node_type>
569 void
570 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
571 pow(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
572  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
573  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
574 {
575  binary_op(pow_quad_func(), c, a, b);
576 }
577 
578 template <typename ordinal_type, typename value_type, typename node_type>
579 void
580 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
581 pow(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
582  const value_type& a,
583  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
584 {
585  binary_op(pow_quad_func(), c, a, b);
586 }
587 
588 template <typename ordinal_type, typename value_type, typename node_type>
589 void
590 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
591 pow(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
592  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
593  const value_type& b)
594 {
595  binary_op(pow_quad_func(), c, a, b);
596 }
597 
598 template <typename ordinal_type, typename value_type, typename node_type>
599 void
600 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
601 sin(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& s,
602  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
603 {
604  unary_op(sin_quad_func(), s, a);
605 }
606 
607 template <typename ordinal_type, typename value_type, typename node_type>
608 void
609 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
610 cos(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
611  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
612 {
613  unary_op(cos_quad_func(), c, a);
614 }
615 
616 template <typename ordinal_type, typename value_type, typename node_type>
617 void
618 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
619 tan(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& t,
620  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
621 {
622  unary_op(tan_quad_func(), t, a);
623 }
624 
625 template <typename ordinal_type, typename value_type, typename node_type>
626 void
627 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
628 sinh(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& s,
629  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
630 {
631  unary_op(sinh_quad_func(), s, a);
632 }
633 
634 template <typename ordinal_type, typename value_type, typename node_type>
635 void
636 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
637 cosh(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
638  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
639 {
640  unary_op(cosh_quad_func(), c, a);
641 }
642 
643 template <typename ordinal_type, typename value_type, typename node_type>
644 void
645 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
646 tanh(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& t,
647  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
648 {
649  unary_op(tanh_quad_func(), t, a);
650 }
651 
652 template <typename ordinal_type, typename value_type, typename node_type>
653 void
654 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
655 acos(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
656  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
657 {
658  unary_op(acos_quad_func(), c, a);
659 }
660 
661 template <typename ordinal_type, typename value_type, typename node_type>
662 void
663 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
664 asin(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
665  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
666 {
667  unary_op(asin_quad_func(), c, a);
668 }
669 
670 template <typename ordinal_type, typename value_type, typename node_type>
671 void
672 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
673 atan(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
674  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
675 {
676  unary_op(atan_quad_func(), c, a);
677 }
678 
679 template <typename ordinal_type, typename value_type, typename node_type>
680 void
681 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
682 atan2(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
683  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
684  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
685 {
686  binary_op(atan2_quad_func(), c, a, b);
687 }
688 
689 template <typename ordinal_type, typename value_type, typename node_type>
690 void
691 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
692 atan2(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
693  const value_type& a,
694  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
695 {
696  binary_op(atan2_quad_func(), c, a, b);
697 }
698 
699 template <typename ordinal_type, typename value_type, typename node_type>
700 void
701 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
702 atan2(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
703  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
704  const value_type& b)
705 {
706  binary_op(atan2_quad_func(), c, a, b);
707 }
708 
709 template <typename ordinal_type, typename value_type, typename node_type>
710 void
711 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
712 acosh(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
713  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
714 {
715  unary_op(acosh_quad_func(), c, a);
716 }
717 
718 template <typename ordinal_type, typename value_type, typename node_type>
719 void
720 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
721 asinh(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
722  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
723 {
724  unary_op(asinh_quad_func(), c, a);
725 }
726 
727 template <typename ordinal_type, typename value_type, typename node_type>
728 void
729 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
730 atanh(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
731  const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
732 {
733  unary_op(atanh_quad_func(), c, a);
734 }
735 
736 template <typename ordinal_type, typename value_type, typename node_type>
737 template <typename ExprT1, typename ExprT2>
738 value_type
739 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
740 compute_times_coeff(ordinal_type i, const ExprT1& a, const ExprT2& b) const
741 {
742  ordinal_type pa = a.size();
743  ordinal_type pb = b.size();
744 
745  if (pa > 1 && pb > 1) {
746  ordinal_type k_lim = pa;
747  ordinal_type j_lim = pb;
748  if (pb < pa) {
749  k_lim = pb;
750  j_lim = pa;
751  }
752  typename Cijk_type::i_iterator i_it = this->Cijk->find_i(i);
753 #ifdef STOKHOS_DEBUG
754  TEUCHOS_TEST_FOR_EXCEPTION(i_it == this->Cijk->i_end(), std::logic_error,
755  "Stokhos::QuadOrthogPolyExpansion::compute_times_coeff()"
756  << ": Index " << i << " is out of range [0,"
757  << this->Cijk->num_i() << ")!");
758 #endif
759  value_type cc = value_type(0);
760  value_type aa, bb, cijk;
761  ordinal_type j, k;
762  for (typename Cijk_type::ik_iterator k_it = this->Cijk->k_begin(i_it);
763  k_it != this->Cijk->k_end(i_it); ++k_it) {
764  k = index(k_it);
765  if (k < k_lim) {
766  if (pa < pb) {
767  if (k == 0)
768  aa = a.val();
769  else
770  aa = a.higher_order_coeff(k);
771  }
772  else {
773  if (k == 0)
774  aa = b.val();
775  else
776  aa = b.higher_order_coeff(k);
777  }
778  for (typename Cijk_type::ikj_iterator j_it = this->Cijk->j_begin(k_it);
779  j_it != this->Cijk->j_end(k_it); ++j_it) {
780  j = index(j_it);
781  cijk = value(j_it);
782  if (j < j_lim) {
783  if (pa < pb) {
784  if (j == 0)
785  bb = b.val();
786  else
787  bb = b.higher_order_coeff(j);
788  }
789  else {
790  if (j == 0)
791  bb = a.val();
792  else
793  bb = a.higher_order_coeff(j);
794  }
795  cc += cijk*aa*bb;
796  }
797  }
798  }
799  }
800  return cc / norms[i];
801  }
802  else if (i == 0)
803  return a.val() * b.val();
804  else if (pa > 1) {
805  return a.higher_order_coeff(i)*b.val();
806  }
807  else {
808  return a.val()*b.higher_order_coeff(i);
809  }
810 }
811 
812 template <typename ordinal_type, typename value_type, typename node_type>
813 template <typename ExprT1, typename ExprT2>
814 value_type
815 Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
816 fast_compute_times_coeff(ordinal_type i, const ExprT1& a, const ExprT2& b) const
817 {
818  typename Cijk_type::i_iterator i_it = this->Cijk->find_i(i);
819 #ifdef STOKHOS_DEBUG
820  TEUCHOS_TEST_FOR_EXCEPTION(i_it == this->Cijk->i_end(), std::logic_error,
821  "Stokhos::QuadOrthogPolyExpansion::fast_ompute_times_coeff()"
822  << ": Index " << i << " is out of range [0,"
823  << this->Cijk->num_i() << ")!");
824 #endif
825  value_type cc = value_type(0);
826  value_type aa, bb, cijk;
827  ordinal_type j, k;
828  for (typename Cijk_type::ik_iterator k_it = this->Cijk->k_begin(i_it);
829  k_it != this->Cijk->k_end(i_it); ++k_it) {
830  k = index(k_it);
831  if (k == 0)
832  aa = a.val();
833  else
834  aa = a.higher_order_coeff(k);
835  for (typename Cijk_type::ikj_iterator j_it = this->Cijk->j_begin(k_it);
836  j_it != this->Cijk->j_end(k_it); ++j_it) {
837  j = index(j_it);
838  cijk = value(j_it);
839  if (j == 0)
840  bb = b.val();
841  else
842  bb = b.higher_order_coeff(j);
843  cc += cijk*aa*bb;
844  }
845  }
846 
847  return cc / norms[i];
848 }
Stokhos::OrthogPolyExpansionBase::divideEqual
void divideEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition: Stokhos_OrthogPolyExpansionBaseImp.hpp:144
Stokhos::QuadOrthogPolyExpansion::norms
const Teuchos::Array< value_type > & norms
Norms of basis vectors.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:180
Teuchos_Tuple.hpp
Stokhos::QuadOrthogPolyExpansion::binary_op
void binary_op(const FuncT &func, OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Nonlinear binary function.
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:114
Stokhos::QuadOrthogPolyExpansion::log_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:256
TEUCHOS_FUNC_TIME_MONITOR
#define TEUCHOS_FUNC_TIME_MONITOR(FUNCNAME)
Stokhos::OrthogPolyExpansionBase::params
Teuchos::RCP< Teuchos::ParameterList > params
Parameter list.
Definition: Stokhos_OrthogPolyExpansionBase.hpp:163
Stokhos::QuadOrthogPolyExpansion::sin
void sin(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:601
Stokhos::QuadOrthogPolyExpansion::times
void times(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:440
Stokhos::QuadOrthogPolyExpansion::sqrt
void sqrt(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:553
Stokhos::OrthogPolyApprox::resize
void resize(ordinal_type sz)
Resize coefficient array (coefficients are preserved)
Definition: Stokhos_OrthogPolyApproxImp.hpp:118
Stokhos::QuadOrthogPolyExpansion::nqp
ordinal_type nqp
Number of Quad points.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:183
Stokhos::QuadOrthogPolyExpansion::atan_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:334
Stokhos::QuadOrthogPolyExpansion::sin_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:292
Stokhos::Sparse3Tensor
Data structure storing a sparse 3-tensor C(i,j,k) in a a compressed format.
Definition: Stokhos_Sparse3Tensor.hpp:24
Stokhos::QuadOrthogPolyExpansion::acos
void acos(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:655
Stokhos::QuadOrthogPolyExpansion::quad_values
const Teuchos::Array< Teuchos::Array< value_type > > & quad_values
Values of basis at Quad points.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:177
Stokhos::QuadOrthogPolyExpansion::QuadOrthogPolyExpansion
QuadOrthogPolyExpansion(const Teuchos::RCP< const OrthogPolyBasis< ordinal_type, value_type > > &basis, const Teuchos::RCP< const Stokhos::Sparse3Tensor< ordinal_type, value_type > > &Cijk, const Teuchos::RCP< const Quadrature< ordinal_type, value_type > > &quad, const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null)
Constructor.
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:17
Stokhos::QuadOrthogPolyExpansion::exp
void exp(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:526
Teuchos::ParameterList::get
T & get(ParameterList &l, const std::string &name)
Stokhos::QuadOrthogPolyExpansion::tan_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:298
Stokhos::QuadOrthogPolyExpansion::log10_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:262
Stokhos::QuadOrthogPolyExpansion::atanh
void atanh(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:730
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Stokhos::QuadOrthogPolyExpansion::log10
void log10(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:544
Stokhos::QuadOrthogPolyExpansion::cos
void cos(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:610
Stokhos::QuadOrthogPolyExpansion::times_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:238
Stokhos::OrthogPolyExpansionBase::divide
void divide(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Definition: Stokhos_OrthogPolyExpansionBaseImp.hpp:567
Stokhos::QuadOrthogPolyExpansion::tanh_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:316
Stokhos::OrthogPolyExpansionBase
Base class for consolidating common expansion implementations.
Definition: Stokhos_OrthogPolyExpansionBase.hpp:27
Stokhos::QuadOrthogPolyExpansion::asin
void asin(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:664
Stokhos::OrthogPolyExpansionBase::timesEqual
void timesEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition: Stokhos_OrthogPolyExpansionBaseImp.hpp:129
Stokhos::QuadOrthogPolyExpansion::sinh_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:310
Stokhos::QuadOrthogPolyExpansion::cbrt_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:274
Stokhos::QuadOrthogPolyExpansion::atan
void atan(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:673
Stokhos::OrthogPolyApprox::coeff
pointer coeff()
Return coefficient array.
Definition: Stokhos_OrthogPolyApproxImp.hpp:134
Stokhos::QuadOrthogPolyExpansion::exp_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:250
Stokhos::SparseArrayIterator
Bi-directional iterator for traversing a sparse array.
Definition: Stokhos_SparseArray.hpp:24
node_type
Kokkos::Serial node_type
Definition: Stokhos_SacadoTraitsUnitTest.cpp:29
j
j
Definition: Sacado_Fad_Exp_MP_Vector.hpp:495
Stokhos::QuadOrthogPolyExpansion::cosh_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:304
Stokhos::QuadOrthogPolyExpansion::pow_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:280
Stokhos::QuadOrthogPolyExpansion::cos_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:286
Stokhos::QuadOrthogPolyExpansion::divide
void divide(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:473
Stokhos::QuadOrthogPolyExpansion::compute_times_coeff
value_type compute_times_coeff(ordinal_type k, const ExprT1 &a, const ExprT2 &b) const
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:740
Stokhos::OrthogPolyBasis
Abstract base class for multivariate orthogonal polynomials.
Definition: Stokhos_OrthogPolyBasis.hpp:40
Stokhos::QuadOrthogPolyExpansion::sinh
void sinh(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:628
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Stokhos::QuadOrthogPolyExpansion::fast_compute_times_coeff
value_type fast_compute_times_coeff(ordinal_type k, const ExprT1 &a, const ExprT2 &b) const
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:816
Stokhos::Quadrature
Abstract base class for quadrature methods.
Definition: Stokhos_Quadrature.hpp:20
Stokhos::QuadOrthogPolyExpansion::atan2
void atan2(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:682
Stokhos::QuadOrthogPolyExpansion::nary_op
void nary_op(const FuncT &func, OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > **a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:297
Stokhos::QuadOrthogPolyExpansion::atanh_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:358
Stokhos::QuadOrthogPolyExpansion::use_quad_for_times
bool use_quad_for_times
Use quadrature for times functions.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:159
Stokhos::QuadOrthogPolyExpansion::asinh_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:352
Stokhos::QuadOrthogPolyExpansion::sqv
Teuchos::Array< value_type > sqv
Quad values scaled by norms.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:201
Sacado::is_constant
KOKKOS_INLINE_FUNCTION bool is_constant(const T &x)
Definition: Stokhos_Is_Constant.hpp:21
Stokhos::QuadOrthogPolyExpansion::atan2_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:340
Stokhos::OrthogPolyExpansionBase::times
void times(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Definition: Stokhos_OrthogPolyExpansionBaseImp.hpp:448
Stokhos::QuadOrthogPolyExpansion::log
void log(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:535
Kokkos::cijk
KOKKOS_INLINE_FUNCTION constexpr std::enable_if< is_view_uq_pce< view_type >::value, typename CijkType< view_type >::type >::type cijk(const view_type &view)
Definition: KokkosExp_View_UQ_PCE_Contiguous.hpp:88
Stokhos::QuadOrthogPolyExpansion::use_quad_for_division
bool use_quad_for_division
Use quadrature for division functions.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:162
Stokhos::OrthogPolyApprox
Class to store coefficients of a projection onto an orthogonal polynomial basis.
Definition: Stokhos_OrthogPolyApprox.hpp:29
Stokhos::QuadOrthogPolyExpansion::timesEqual
void timesEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:382
val
expr val()
Stokhos::QuadOrthogPolyExpansion::divideEqual
void divideEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:392
Stokhos::QuadOrthogPolyExpansion::asin_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:328
Stokhos::QuadOrthogPolyExpansion::cbrt
void cbrt(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:562
Stokhos_DynamicArrayTraits.hpp
Stokhos::QuadOrthogPolyExpansion::pow
void pow(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a, const OrthogPolyApprox< ordinal_type, value_type, node_type > &b)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:571
Stokhos::QuadOrthogPolyExpansion::tanh
void tanh(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:646
Stokhos::QuadOrthogPolyExpansion::tan
void tan(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:619
Stokhos::OrthogPolyApprox::size
ordinal_type size() const
Return size.
Definition: Stokhos_OrthogPolyApproxImp.hpp:126
Stokhos::QuadOrthogPolyExpansion::acosh_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:346
Stokhos::QuadOrthogPolyExpansion::cosh
void cosh(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:637
Teuchos_TimeMonitor.hpp
Stokhos::QuadOrthogPolyExpansion::asinh
void asinh(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:721
Stokhos::QuadOrthogPolyExpansion::div_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:244
Teuchos_Assert.hpp
Stokhos::QuadOrthogPolyExpansion::qv
Teuchos::Array< value_type > qv
Reshaped quad values into 1D array.
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:198
Stokhos::QuadOrthogPolyExpansion::unary_op
void unary_op(const FuncT &func, OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Nonlinear unary function.
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:54
Stokhos::QuadOrthogPolyExpansion::acosh
void acosh(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const OrthogPolyApprox< ordinal_type, value_type, node_type > &a)
Definition: Stokhos_QuadOrthogPolyExpansionImp.hpp:712
Stokhos::QuadOrthogPolyExpansion::acos_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:322
Stokhos::QuadOrthogPolyExpansion::sqrt_quad_func
Definition: Stokhos_QuadOrthogPolyExpansion.hpp:268
Generated on Fri Nov 22 2024 09:18:14 for Stokhos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5