Stokhos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Stokhos_QuadOrthogPolyExpansionImp.hpp
Go to the documentation of this file.
1// $Id$
2// $Source$
3// @HEADER
4// ***********************************************************************
5//
6// Stokhos Package
7// Copyright (2009) Sandia Corporation
8//
9// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
10// license for use of this work by or on behalf of the U.S. Government.
11//
12// Redistribution and use in source and binary forms, with or without
13// modification, are permitted provided that the following conditions are
14// met:
15//
16// 1. Redistributions of source code must retain the above copyright
17// notice, this list of conditions and the following disclaimer.
18//
19// 2. Redistributions in binary form must reproduce the above copyright
20// notice, this list of conditions and the following disclaimer in the
21// documentation and/or other materials provided with the distribution.
22//
23// 3. Neither the name of the Corporation nor the names of the
24// contributors may be used to endorse or promote products derived from
25// this software without specific prior written permission.
26//
27// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
28// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
31// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38//
39// Questions? Contact Eric T. Phipps (etphipp@sandia.gov).
40//
41// ***********************************************************************
42// @HEADER
43
44#include "Teuchos_Assert.hpp"
45#include "Stokhos_DynamicArrayTraits.hpp"
46#include "Teuchos_TimeMonitor.hpp"
47#include "Teuchos_Tuple.hpp"
48
49template <typename ordinal_type, typename value_type, typename node_type>
50Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
51QuadOrthogPolyExpansion(
52 const Teuchos::RCP<const Stokhos::OrthogPolyBasis<ordinal_type, value_type> >& basis_,
53 const Teuchos::RCP<const Stokhos::Sparse3Tensor<ordinal_type, value_type> >& Cijk_,
54 const Teuchos::RCP<const Quadrature<ordinal_type, value_type> >& quad_,
55 const Teuchos::RCP<Teuchos::ParameterList>& params_) :
56 OrthogPolyExpansionBase<ordinal_type, value_type, node_type>(basis_, Cijk_, params_),
57 quad(quad_),
58 sz(this->basis->size()),
59 blas(),
60 quad_points(quad->getQuadPoints()),
61 quad_weights(quad->getQuadWeights()),
62 quad_values(quad->getBasisAtQuadPoints()),
63 norms(this->basis->norm_squared()),
64 nqp(quad_points.size()),
65 avals(nqp),
66 bvals(nqp),
67 fvals(nqp),
68 qv(nqp*sz),
69 sqv(nqp*sz)
70{
71 for (ordinal_type qp=0; qp<nqp; qp++)
72 for (ordinal_type i=0; i<sz; i++) {
73 qv[qp*sz+i] = quad_values[qp][i];
74 sqv[qp*sz+i] = quad_values[qp][i]/norms[i];
75 }
76
77 Teuchos::RCP<Teuchos::ParameterList> params = params_;
78 if (params == Teuchos::null)
79 params = Teuchos::rcp(new Teuchos::ParameterList);
80 use_quad_for_times = params->get("Use Quadrature for Times", false);
81 use_quad_for_division = params->get("Use Quadrature for Division", true);
82}
83
84template <typename ordinal_type, typename value_type, typename node_type>
85template <typename FuncT>
86void
87Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
88unary_op(const FuncT& func,
89 OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
90 const OrthogPolyApprox<ordinal_type, value_type, node_type>& a)
91{
92 ordinal_type pa = a.size();
93 ordinal_type pc;
94 if (a.size() == 1)
95 pc = 1;
96 else
97 pc = sz;
98 if (c.size() != pc)
99 c.resize(pc);
100
101 if (pc == 1) {
102 c[0] = func(a[0]);
103 return;
104 }
105
106 {
107#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
108 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- Unary Polynomial Evaluation");
109#endif
110
111 // Evaluate input
112 blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, a.coeff(), 1, 0.0,
113 &avals[0], 1);
114
115 }
116
117 {
118#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
119 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- Unary Function Evaluation");
120#endif
121
122 // Evaluate function
123 for (ordinal_type qp=0; qp<nqp; qp++) {
124 if (quad_weights[qp] != value_type(0))
125 fvals[qp] = func(avals[qp])*quad_weights[qp];
126 else
127 fvals[qp] = value_type(0);
128 }
129
130 }
131
132 {
133#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
134 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- Unary Polynomial Integration");
135#endif
136
137 // Integrate
138 blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
139 c.coeff(), 1);
140
141 }
142}
143
144template <typename ordinal_type, typename value_type, typename node_type>
145template <typename FuncT>
146void
147Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
148binary_op(const FuncT& func,
149 OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
150 const OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
151 const OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
152{
153 ordinal_type pa = a.size();
154 ordinal_type pb = b.size();
155 ordinal_type pc;
156 if (pa == 1 && pb == 1)
157 pc = 1;
158 else
159 pc = sz;
160 if (c.size() != pc)
161 c.resize(pc);
162
163 if (pc == 1) {
164 c[0] = func(a[0], b[0]);
165 return;
166 }
167
168 {
169#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
170 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PP Binary Polynomial Evaluation");
171#endif
172
173 // Evaluate input
174 blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, a.coeff(), 1, 0.0,
175 &avals[0], 1);
176 blas.GEMV(Teuchos::TRANS, pb, nqp, 1.0, &qv[0], sz, b.coeff(), 1, 0.0,
177 &bvals[0], 1);
178
179 }
180
181 {
182#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
183 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PP Binary Function Evaluation");
184#endif
185
186 // Evaluate function
187 for (ordinal_type qp=0; qp<nqp; qp++)
188 if (quad_weights[qp] != value_type(0))
189 fvals[qp] = func(avals[qp], bvals[qp])*quad_weights[qp];
190 else
191 fvals[qp] = value_type(0);
192
193 }
194
195 {
196#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
197 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PP Binary Polynomial Integration");
198#endif
199
200 // Integrate
201 blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
202 c.coeff(), 1);
203
204 }
205}
206
207template <typename ordinal_type, typename value_type, typename node_type>
208template <typename FuncT>
209void
210Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
211binary_op(const FuncT& func,
212 OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
213 const value_type& a,
214 const OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
215{
216 ordinal_type pb = b.size();
217 ordinal_type pc;
218 if (pb == 1)
219 pc = 1;
220 else
221 pc = sz;
222 if (c.size() != pc)
223 c.resize(pc);
224
225 if (pc == 1) {
226 c[0] = func(a, b[0]);
227 return;
228 }
229
230 {
231#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
232 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- CP Binary Polynomial Evaluation");
233#endif
234
235 // Evaluate input
236 blas.GEMV(Teuchos::TRANS, pb, nqp, 1.0, &qv[0], sz, b.coeff(), 1, 0.0,
237 &bvals[0], 1);
238
239 }
240
241 {
242#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
243 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- CP Binary Function Evaluation");
244#endif
245
246 // Evaluate function
247 for (ordinal_type qp=0; qp<nqp; qp++)
248 if (quad_weights[qp] != value_type(0))
249 fvals[qp] = func(a, bvals[qp])*quad_weights[qp];
250 else
251 fvals[qp] = value_type(0);
252
253 }
254
255 {
256#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
257 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- CP Binary Polynomial Integration");
258#endif
259
260 // Integrate
261 blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
262 c.coeff(), 1);
263
264 }
265}
266
267template <typename ordinal_type, typename value_type, typename node_type>
268template <typename FuncT>
269void
270Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
271binary_op(const FuncT& func,
272 OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
273 const OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
274 const value_type& b)
275{
276 ordinal_type pa = a.size();
277 ordinal_type pc;
278 if (pa == 1)
279 pc = 1;
280 else
281 pc = sz;
282 if (c.size() != pc)
283 c.resize(pc);
284
285 if (pc == 1) {
286 c[0] = func(a[0], b);
287 return;
288 }
289
290 {
291#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
292 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PC Binary Polynomial Evaluation");
293#endif
294
295 // Evaluate input
296 blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, a.coeff(), 1, 0.0,
297 &avals[0], 1);
298
299 }
300
301 {
302#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
303 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PC Binary Function Evaluation");
304#endif
305
306 // Evaluate function
307 for (ordinal_type qp=0; qp<nqp; qp++)
308 if (quad_weights[qp] != value_type(0))
309 fvals[qp] = func(avals[qp], b)*quad_weights[qp];
310 else
311 fvals[qp] = value_type(0);
312
313 }
314
315 {
316#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
317 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- PC Binary Polynomial Integration");
318#endif
319
320 // Integrate
321 blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
322 c.coeff(), 1);
323
324 }
325}
326
327template <typename ordinal_type, typename value_type, typename node_type>
328template <typename FuncT>
329void
330Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
331nary_op(const FuncT& func,
332 OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
333 const OrthogPolyApprox<ordinal_type, value_type, node_type>** na)
334{
335 const int N = FuncT::N;
336 bool is_constant = true;
337 for (int i=0; i<N; i++) {
338 if (na[i]->size() > 1) {
339 is_constant = false;
340 break;
341 }
342 }
343 ordinal_type pc;
344 if (is_constant)
345 pc = 1;
346 else
347 pc = sz;
348 if (c.size() != pc)
349 c.resize(pc);
350
351 if (pc == 1) {
352 value_type val[N];
353 for (int i=0; i<N; i++)
354 val[i] = (*na[i])[0];
355 c[0] = func(val);
356 return;
357 }
358
359 if (N >= navals.size())
360 navals.resize(N+1);
361 if (navals[N].size() != N) {
362 navals[N].resize(N);
363 for (int i=0; i<N; i++)
364 navals[N][i].resize(nqp);
365 }
366
367 {
368#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
369 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- N(" << N << ")-ary Polynomial Evaluation");
370#endif
371
372 // Evaluate input
373 for (int i=0; i<N; i++) {
374 //navals[i].resize(nqp);
375 ordinal_type pa = na[i]->size();
376 blas.GEMV(Teuchos::TRANS, pa, nqp, 1.0, &qv[0], sz, na[i]->coeff(), 1, 0.0,
377 &navals[N][i][0], 1);
378 }
379
380 }
381
382 {
383#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
384 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- N(" << N << ")-ary Function Evaluation");
385#endif
386
387 // Evaluate function
388 value_type val[N];
389 for (ordinal_type qp=0; qp<nqp; qp++) {
390 if (quad_weights[qp] != value_type(0)) {
391 for (int i=0; i<N; i++)
392 val[i] = navals[N][i][qp];
393 fvals[qp] = func(val)*quad_weights[qp];
394 }
395 else
396 fvals[qp] = value_type(0);
397 }
398
399 }
400
401 {
402#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
403 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::QuadExp -- N(" << N << ")-ary Polynomial Integration");
404#endif
405
406 // Integrate
407 blas.GEMV(Teuchos::NO_TRANS, pc, nqp, 1.0, &sqv[0], sz, &fvals[0], 1, 0.0,
408 c.coeff(), 1);
409
410 }
411}
412
413template <typename ordinal_type, typename value_type, typename node_type>
414void
422
423template <typename ordinal_type, typename value_type, typename node_type>
424void
432
433template <typename ordinal_type, typename value_type, typename node_type>
434void
445
446template <typename ordinal_type, typename value_type, typename node_type>
447void
448Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
449divideEqual(
450 Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
451 const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& x)
452{
453#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
454 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::OrthogPolyExpansionBase::divideEqual(OPA)");
455#endif
456 if (x.size() == 1) {
457 ordinal_type p = c.size();
458 value_type* cc = c.coeff();
459 const value_type* xc = x.coeff();
460 for (ordinal_type i=0; i<p; i++)
461 cc[i] /= xc[0];
462 }
463 else {
464 if (use_quad_for_division)
465 binary_op(div_quad_func(), c, c, x);
466 else
467 OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divideEqual(c, x);
468 }
469}
470
471template <typename ordinal_type, typename value_type, typename node_type>
472void
483
484template <typename ordinal_type, typename value_type, typename node_type>
485void
493
494template <typename ordinal_type, typename value_type, typename node_type>
495void
503
504template <typename ordinal_type, typename value_type, typename node_type>
505void
506Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
507divide(Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& c,
508 const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& a,
509 const Stokhos::OrthogPolyApprox<ordinal_type, value_type, node_type>& b)
510{
511#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
512 TEUCHOS_FUNC_TIME_MONITOR("Stokhos::OrthogPolyExpansionBase::divide(OPA,OPA)");
513#endif
514 if (b.size() == 1) {
515 ordinal_type pc = a.size();
516 if (c.size() != pc)
517 c.resize(pc);
518
519 const value_type* ca = a.coeff();
520 const value_type* cb = b.coeff();
521 value_type* cc = c.coeff();
522
523 for (ordinal_type i=0; i<pc; i++)
524 cc[i] = ca[i]/cb[0];
525 }
526 else {
527 if (use_quad_for_division)
528 binary_op(div_quad_func(), c, a, b);
529 else
530 OrthogPolyExpansionBase<ordinal_type, value_type, node_type>::divide(c, a, b);
531 }
532}
533
534template <typename ordinal_type, typename value_type, typename node_type>
535void
546
547template <typename ordinal_type, typename value_type, typename node_type>
548void
556
557template <typename ordinal_type, typename value_type, typename node_type>
558void
565
566template <typename ordinal_type, typename value_type, typename node_type>
567void
574
575template <typename ordinal_type, typename value_type, typename node_type>
576void
583
584template <typename ordinal_type, typename value_type, typename node_type>
585void
592
593template <typename ordinal_type, typename value_type, typename node_type>
594void
601
602template <typename ordinal_type, typename value_type, typename node_type>
603void
611
612template <typename ordinal_type, typename value_type, typename node_type>
613void
621
622template <typename ordinal_type, typename value_type, typename node_type>
623void
631
632template <typename ordinal_type, typename value_type, typename node_type>
633void
640
641template <typename ordinal_type, typename value_type, typename node_type>
642void
649
650template <typename ordinal_type, typename value_type, typename node_type>
651void
658
659template <typename ordinal_type, typename value_type, typename node_type>
660void
667
668template <typename ordinal_type, typename value_type, typename node_type>
669void
676
677template <typename ordinal_type, typename value_type, typename node_type>
678void
685
686template <typename ordinal_type, typename value_type, typename node_type>
687void
694
695template <typename ordinal_type, typename value_type, typename node_type>
696void
703
704template <typename ordinal_type, typename value_type, typename node_type>
705void
712
713template <typename ordinal_type, typename value_type, typename node_type>
714void
722
723template <typename ordinal_type, typename value_type, typename node_type>
724void
732
733template <typename ordinal_type, typename value_type, typename node_type>
734void
742
743template <typename ordinal_type, typename value_type, typename node_type>
744void
751
752template <typename ordinal_type, typename value_type, typename node_type>
753void
760
761template <typename ordinal_type, typename value_type, typename node_type>
762void
769
770template <typename ordinal_type, typename value_type, typename node_type>
771template <typename ExprT1, typename ExprT2>
772value_type
773Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
774compute_times_coeff(ordinal_type i, const ExprT1& a, const ExprT2& b) const
775{
776 ordinal_type pa = a.size();
777 ordinal_type pb = b.size();
778
779 if (pa > 1 && pb > 1) {
780 ordinal_type k_lim = pa;
781 ordinal_type j_lim = pb;
782 if (pb < pa) {
783 k_lim = pb;
784 j_lim = pa;
785 }
786 typename Cijk_type::i_iterator i_it = this->Cijk->find_i(i);
787#ifdef STOKHOS_DEBUG
788 TEUCHOS_TEST_FOR_EXCEPTION(i_it == this->Cijk->i_end(), std::logic_error,
789 "Stokhos::QuadOrthogPolyExpansion::compute_times_coeff()"
790 << ": Index " << i << " is out of range [0,"
791 << this->Cijk->num_i() << ")!");
792#endif
793 value_type cc = value_type(0);
794 value_type aa, bb, cijk;
795 ordinal_type j, k;
796 for (typename Cijk_type::ik_iterator k_it = this->Cijk->k_begin(i_it);
797 k_it != this->Cijk->k_end(i_it); ++k_it) {
798 k = index(k_it);
799 if (k < k_lim) {
800 if (pa < pb) {
801 if (k == 0)
802 aa = a.val();
803 else
804 aa = a.higher_order_coeff(k);
805 }
806 else {
807 if (k == 0)
808 aa = b.val();
809 else
810 aa = b.higher_order_coeff(k);
811 }
812 for (typename Cijk_type::ikj_iterator j_it = this->Cijk->j_begin(k_it);
813 j_it != this->Cijk->j_end(k_it); ++j_it) {
814 j = index(j_it);
815 cijk = value(j_it);
816 if (j < j_lim) {
817 if (pa < pb) {
818 if (j == 0)
819 bb = b.val();
820 else
821 bb = b.higher_order_coeff(j);
822 }
823 else {
824 if (j == 0)
825 bb = a.val();
826 else
827 bb = a.higher_order_coeff(j);
828 }
829 cc += cijk*aa*bb;
830 }
831 }
832 }
833 }
834 return cc / norms[i];
835 }
836 else if (i == 0)
837 return a.val() * b.val();
838 else if (pa > 1) {
839 return a.higher_order_coeff(i)*b.val();
840 }
841 else {
842 return a.val()*b.higher_order_coeff(i);
843 }
844}
845
846template <typename ordinal_type, typename value_type, typename node_type>
847template <typename ExprT1, typename ExprT2>
848value_type
849Stokhos::QuadOrthogPolyExpansion<ordinal_type, value_type, node_type>::
850fast_compute_times_coeff(ordinal_type i, const ExprT1& a, const ExprT2& b) const
851{
852 typename Cijk_type::i_iterator i_it = this->Cijk->find_i(i);
853#ifdef STOKHOS_DEBUG
854 TEUCHOS_TEST_FOR_EXCEPTION(i_it == this->Cijk->i_end(), std::logic_error,
855 "Stokhos::QuadOrthogPolyExpansion::fast_ompute_times_coeff()"
856 << ": Index " << i << " is out of range [0,"
857 << this->Cijk->num_i() << ")!");
858#endif
859 value_type cc = value_type(0);
860 value_type aa, bb, cijk;
861 ordinal_type j, k;
862 for (typename Cijk_type::ik_iterator k_it = this->Cijk->k_begin(i_it);
863 k_it != this->Cijk->k_end(i_it); ++k_it) {
864 k = index(k_it);
865 if (k == 0)
866 aa = a.val();
867 else
868 aa = a.higher_order_coeff(k);
869 for (typename Cijk_type::ikj_iterator j_it = this->Cijk->j_begin(k_it);
870 j_it != this->Cijk->j_end(k_it); ++j_it) {
871 j = index(j_it);
872 cijk = value(j_it);
873 if (j == 0)
874 bb = b.val();
875 else
876 bb = b.higher_order_coeff(j);
877 cc += cijk*aa*bb;
878 }
879 }
880
881 return cc / norms[i];
882}
j
j
Definition Sacado_Fad_Exp_MP_Vector.hpp:527
val
expr val()
Stokhos_DynamicArrayTraits.hpp
node_type
Kokkos::Serial node_type
Definition Stokhos_SacadoTraitsUnitTest.cpp:59
Stokhos::OrthogPolyApprox
Class to store coefficients of a projection onto an orthogonal polynomial basis.
Definition Stokhos_OrthogPolyApprox.hpp:63
Stokhos::OrthogPolyApprox::resize
void resize(ordinal_type sz)
Resize coefficient array (coefficients are preserved)
Definition Stokhos_OrthogPolyApproxImp.hpp:152
Stokhos::OrthogPolyApprox::coeff
pointer coeff()
Return coefficient array.
Definition Stokhos_OrthogPolyApproxImp.hpp:168
Stokhos::OrthogPolyApprox::size
ordinal_type size() const
Return size.
Definition Stokhos_OrthogPolyApproxImp.hpp:160
Stokhos::OrthogPolyBasis
Abstract base class for multivariate orthogonal polynomials.
Definition Stokhos_OrthogPolyBasis.hpp:74
Stokhos::OrthogPolyExpansionBase::Cijk
Teuchos::RCP< const Stokhos::Sparse3Tensor< ordinal_type, value_type > > Cijk
Triple-product tensor.
Definition Stokhos_OrthogPolyExpansionBase.hpp:192
Stokhos::OrthogPolyExpansionBase::timesEqual
void timesEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition Stokhos_OrthogPolyExpansionBaseImp.hpp:161
Stokhos::OrthogPolyExpansionBase::divideEqual
void divideEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition Stokhos_OrthogPolyExpansionBaseImp.hpp:176
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:599
Stokhos::OrthogPolyExpansionBase::size
ordinal_type size() const
Get expansion size.
Definition Stokhos_OrthogPolyExpansionBase.hpp:73
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:480
Stokhos::ProductContainer::size
ordinal_type size() const
Return size.
Definition Stokhos_ProductContainerImp.hpp:139
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:560
Stokhos::QuadOrthogPolyExpansion::sqv
Teuchos::Array< value_type > sqv
Quad values scaled by norms.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:235
Stokhos::QuadOrthogPolyExpansion::navals
Teuchos::Array< Teuchos::Array< Teuchos::Array< value_type > > > navals
Temporary array for values of n-ary arguments at quad points.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:226
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:578
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:653
Stokhos::QuadOrthogPolyExpansion::qv
Teuchos::Array< value_type > qv
Reshaped quad values into 1D array.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:232
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:474
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:716
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:680
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:587
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:746
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.
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:507
Stokhos::QuadOrthogPolyExpansion::blas
Teuchos::BLAS< ordinal_type, value_type > blas
BLAS wrappers.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:202
Stokhos::QuadOrthogPolyExpansion::use_quad_for_times
bool use_quad_for_times
Use quadrature for times functions.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:193
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:331
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:569
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:605
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:662
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:644
Stokhos::QuadOrthogPolyExpansion::fvals
Teuchos::Array< value_type > fvals
Temporary array for values of operation at quad points.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:229
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:755
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:596
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:148
Stokhos::QuadOrthogPolyExpansion::avals
Teuchos::Array< value_type > avals
Temporary array for values of first argument at quad points.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:220
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:707
Stokhos::QuadOrthogPolyExpansion::norms
const Teuchos::Array< value_type > & norms
Norms of basis vectors.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:214
Stokhos::QuadOrthogPolyExpansion::timesEqual
void timesEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition Stokhos_QuadOrthogPolyExpansionImp.hpp:416
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:850
Stokhos::QuadOrthogPolyExpansion::bvals
Teuchos::Array< value_type > bvals
Temporary array for values of second argument at quad points.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:223
Stokhos::QuadOrthogPolyExpansion::use_quad_for_division
bool use_quad_for_division
Use quadrature for division functions.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:196
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:689
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:671
Stokhos::QuadOrthogPolyExpansion::compute_times_coeff
value_type compute_times_coeff(ordinal_type k, const ExprT1 &a, const ExprT2 &b) const
Definition Stokhos_QuadOrthogPolyExpansionImp.hpp:774
Stokhos::QuadOrthogPolyExpansion::quad_weights
const Teuchos::Array< value_type > & quad_weights
Array of Quad weights.
Definition Stokhos_QuadOrthogPolyExpansion.hpp:208
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:88
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:698
Stokhos::QuadOrthogPolyExpansion::divideEqual
void divideEqual(OrthogPolyApprox< ordinal_type, value_type, node_type > &c, const value_type &x)
Definition Stokhos_QuadOrthogPolyExpansionImp.hpp:426
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:635
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:764
Stokhos::Sparse3Tensor
Data structure storing a sparse 3-tensor C(i,j,k) in a a compressed format.
Definition Stokhos_Sparse3Tensor.hpp:56
Stokhos::Sparse3Tensor::ikj_iterator
j_sparse_array::const_iterator ikj_iterator
Iterator for looping over j entries given i and k.
Definition Stokhos_Sparse3Tensor.hpp:100
Stokhos::Sparse3Tensor::ik_iterator
kj_sparse_array::const_iterator ik_iterator
Iterator for looping over k entries given i.
Definition Stokhos_Sparse3Tensor.hpp:97
Stokhos::Sparse3Tensor::i_iterator
ikj_sparse_array::const_iterator i_iterator
Iterator for looping over i entries.
Definition Stokhos_Sparse3Tensor.hpp:91
Stokhos::Sparse3Tensor::value
SparseArrayIterator< index_iterator, value_iterator >::value_reference value(const SparseArrayIterator< index_iterator, value_iterator > &it)
Definition Stokhos_Sparse3Tensor.hpp:315
Stokhos::Sparse3Tensor::index
SparseArrayIterator< index_iterator, value_iterator >::value_type index(const SparseArrayIterator< index_iterator, value_iterator > &it)
Definition Stokhos_Sparse3Tensor.hpp:295
Stokhos::QuadOrthogPolyExpansion::acos_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:356
Stokhos::QuadOrthogPolyExpansion::acosh_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:380
Stokhos::QuadOrthogPolyExpansion::asin_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:362
Stokhos::QuadOrthogPolyExpansion::asinh_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:386
Stokhos::QuadOrthogPolyExpansion::atan2_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:374
Stokhos::QuadOrthogPolyExpansion::atan_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:368
Stokhos::QuadOrthogPolyExpansion::atanh_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:392
Stokhos::QuadOrthogPolyExpansion::cbrt_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:308
Stokhos::QuadOrthogPolyExpansion::cos_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:320
Stokhos::QuadOrthogPolyExpansion::cosh_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:338
Stokhos::QuadOrthogPolyExpansion::div_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:278
Stokhos::QuadOrthogPolyExpansion::exp_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:284
Stokhos::QuadOrthogPolyExpansion::log10_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:296
Stokhos::QuadOrthogPolyExpansion::log_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:290
Stokhos::QuadOrthogPolyExpansion::pow_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:314
Stokhos::QuadOrthogPolyExpansion::sin_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:326
Stokhos::QuadOrthogPolyExpansion::sinh_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:344
Stokhos::QuadOrthogPolyExpansion::sqrt_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:302
Stokhos::QuadOrthogPolyExpansion::tan_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:332
Stokhos::QuadOrthogPolyExpansion::tanh_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:350
Stokhos::QuadOrthogPolyExpansion::times_quad_func
Definition Stokhos_QuadOrthogPolyExpansion.hpp:272
Generated by doxygen 1.13.2