42 #include "Teuchos_SerialDenseMatrix.hpp" 70 template <
typename Storage>
71 KOKKOS_INLINE_FUNCTION
74 standard_deviation()
const {
77 const_pointer c = this->coeff();
83 template <
typename Storage>
84 KOKKOS_INLINE_FUNCTION
87 two_norm_squared()
const {
90 const_pointer c = this->coeff();
96 template <
typename Storage>
97 KOKKOS_INLINE_FUNCTION
100 inner_product(
const PCE&
x)
const {
105 const_pointer c = this->coeff();
106 const_pointer xc =
x.coeff();
112 template <
typename Storage>
113 KOKKOS_INLINE_FUNCTION
116 isEqualTo(
const PCE&
x)
const {
117 typedef IsEqual<value_type> IE;
119 if (
x.size() != sz)
return false;
122 eq = eq && IE::eval(
x.coeff(i), this->coeff(i));
126 template <
typename Storage>
127 KOKKOS_INLINE_FUNCTION
130 isEqualTo(
const PCE&
x)
const volatile {
131 typedef IsEqual<value_type> IE;
133 if (
x.size() != sz)
return false;
136 eq = eq && IE::eval(
x.coeff(i), this->coeff(i));
140 template <
typename Storage>
141 KOKKOS_INLINE_FUNCTION
151 template <
typename Storage>
152 KOKKOS_INLINE_FUNCTION
159 return const_cast<PCE&
>(*this);
162 template <
typename Storage>
163 KOKKOS_INLINE_FUNCTION
166 operator=(
const PCE<Storage>&
x)
181 if (s_.size() >
x.s_.size())
188 template <
typename Storage>
189 KOKKOS_INLINE_FUNCTION
192 operator=(
const volatile PCE<Storage>&
x)
196 cijk_ = const_cast<const my_cijk_type&>(
x.cijk_);
207 if (s_.size() >
x.s_.size())
214 template <
typename Storage>
215 KOKKOS_INLINE_FUNCTION
218 operator=(
const PCE<Storage>&
x)
volatile 222 const_cast<my_cijk_type&>(cijk_) =
x.cijk_;
233 if (s_.size() >
x.s_.size())
237 return const_cast<PCE&
>(*this);
240 template <
typename Storage>
241 KOKKOS_INLINE_FUNCTION
244 operator=(
const volatile PCE<Storage>&
x)
volatile 248 const_cast<my_cijk_type&>(cijk_) =
249 const_cast<const my_cijk_type&
>(
x.cijk_);
260 if (s_.size() >
x.s_.size())
264 return const_cast<PCE&
>(*this);
267 template <
typename Storage>
268 KOKKOS_INLINE_FUNCTION
274 PCE<Storage>
x(cijk_, sz);
275 pointer xc =
x.coeff();
276 const_pointer cc = this->coeff();
282 template <
typename Storage>
283 KOKKOS_INLINE_FUNCTION
289 PCE<Storage>
x(const_cast<const my_cijk_type&>(cijk_), sz);
290 pointer xc =
x.coeff();
291 const_volatile_pointer cc = this->coeff();
297 template <
typename Storage>
298 KOKKOS_INLINE_FUNCTION
303 pointer cc = this->coeff();
310 template <
typename Storage>
311 KOKKOS_INLINE_FUNCTION
316 volatile_pointer cc = this->coeff();
320 return const_cast<PCE&
>(*this);
323 template <
typename Storage>
324 KOKKOS_INLINE_FUNCTION
329 pointer cc = this->coeff();
336 template <
typename Storage>
337 KOKKOS_INLINE_FUNCTION
342 volatile pointer cc = this->coeff();
346 return const_cast<PCE&
>(*this);
349 template <
typename Storage>
350 KOKKOS_INLINE_FUNCTION
353 operator+=(
const PCE<Storage>&
x)
358 this->reset(
x.cijk_, xsz);
360 const_pointer xc =
x.coeff();
361 pointer cc = this->coeff();
367 template <
typename Storage>
368 KOKKOS_INLINE_FUNCTION
371 operator-=(
const PCE<Storage>&
x)
376 this->reset(
x.cijk_, xsz);
378 const_pointer xc =
x.coeff();
379 pointer cc = this->coeff();
385 template <
typename Storage>
386 KOKKOS_INLINE_FUNCTION
389 operator*=(
const PCE<Storage>&
x)
395 #if !defined(__CUDA_ARCH__) 396 TEUCHOS_TEST_FOR_EXCEPTION(
397 sz != xsz && sz != 1 && xsz != 1, std::logic_error,
398 "Sacado::UQ::PCE::operator*=(): input sizes do not match");
401 if (cijk_.is_empty() && !
x.cijk_.is_empty())
404 #
if !defined(__CUDA_ARCH__)
405 TEUCHOS_TEST_FOR_EXCEPTION(
406 cijk_.is_empty() && csz != 1, std::logic_error,
407 "Sacado::UQ::PCE::operator*(): empty cijk but expansion size > 1");
413 const_pointer xc =
x.coeff();
414 pointer cc = this->coeff();
426 PCE<Storage>
y(cijk_, csz);
427 pointer yc =
y.coeff();
429 const cijk_size_type num_entry = cijk_.num_entry(i);
430 const cijk_size_type entry_beg = cijk_.entry_begin(i);
431 const cijk_size_type entry_end = entry_beg + num_entry;
433 for (cijk_size_type entry = entry_beg; entry < entry_end; ++entry) {
434 const cijk_size_type
j = cijk_.coord(entry,0);
435 const cijk_size_type k = cijk_.coord(entry,1);
436 ytmp += cijk_.value(entry) * ( cc[
j] * xc[k] + cc[k] * xc[
j] );
445 template <
typename Storage>
446 KOKKOS_INLINE_FUNCTION
449 operator/=(
const PCE<Storage>&
x)
455 #if !defined(__CUDA_ARCH__) 456 TEUCHOS_TEST_FOR_EXCEPTION(
457 sz != xsz && sz != 1 && xsz != 1, std::logic_error,
458 "Sacado::UQ::PCE::operator/=(): input sizes do not match");
461 if (cijk_.is_empty() && !
x.cijk_.is_empty())
467 const_pointer xc =
x.coeff();
468 pointer cc = this->coeff();
470 #if defined(__CUDA_ARCH__) 476 #if !defined(__CUDA_ARCH__) 484 PCE<Storage>
y(cijk_, csz);
494 template <
typename Storage>
495 KOKKOS_INLINE_FUNCTION
507 my_cijk_type c_cijk = asz > bsz ? a.cijk() : b.cijk();
510 const_pointer ac = a.coeff();
511 const_pointer bc = b.coeff();
512 pointer cc = c.coeff();
515 cc[i] = ac[i] + bc[i];
521 cc[i] = ac[i] + bc[i];
529 template <
typename Storage>
530 KOKKOS_INLINE_FUNCTION
541 const_pointer bc = b.coeff();
542 pointer cc = c.coeff();
549 template <
typename Storage>
550 KOKKOS_INLINE_FUNCTION
561 const_pointer ac = a.coeff();
562 pointer cc = c.coeff();
569 template <
typename Storage>
570 KOKKOS_INLINE_FUNCTION
582 my_cijk_type c_cijk = asz > bsz ? a.cijk() : b.cijk();
585 const_pointer ac = a.coeff();
586 const_pointer bc = b.coeff();
587 pointer cc = c.coeff();
590 cc[i] = ac[i] - bc[i];
596 cc[i] = ac[i] - bc[i];
604 template <
typename Storage>
605 KOKKOS_INLINE_FUNCTION
616 const_pointer bc = b.coeff();
617 pointer cc = c.coeff();
624 template <
typename Storage>
625 KOKKOS_INLINE_FUNCTION
636 const_pointer ac = a.coeff();
637 pointer cc = c.coeff();
644 template <
typename Storage>
645 KOKKOS_INLINE_FUNCTION
654 typedef typename my_cijk_type::size_type cijk_size_type;
660 #if !defined(__CUDA_ARCH__) 661 TEUCHOS_TEST_FOR_EXCEPTION(
662 asz != bsz && asz != 1 && bsz != 1, std::logic_error,
663 "Sacado::UQ::PCE::operator*(): input sizes do not match");
666 my_cijk_type c_cijk = a.cijk().is_empty() ? b.cijk() : a.cijk();
668 #if !defined(__CUDA_ARCH__) 669 TEUCHOS_TEST_FOR_EXCEPTION(
670 c_cijk.is_empty() && csz != 1, std::logic_error,
671 "Sacado::UQ::PCE::operator*(): empty cijk but expansion size > 1");
675 const_pointer ac = a.coeff();
676 const_pointer bc = b.coeff();
677 pointer cc = c.coeff();
691 const cijk_size_type num_entry = c_cijk.num_entry(i);
692 const cijk_size_type entry_beg = c_cijk.entry_begin(i);
693 const cijk_size_type entry_end = entry_beg + num_entry;
695 for (cijk_size_type entry = entry_beg; entry < entry_end; ++entry) {
696 const cijk_size_type
j = c_cijk.coord(entry,0);
697 const cijk_size_type k = c_cijk.coord(entry,1);
698 ytmp += c_cijk.value(entry) * ( ac[
j] * bc[k] + ac[k] * bc[
j] );
707 template <
typename Storage>
708 KOKKOS_INLINE_FUNCTION
719 const_pointer bc = b.coeff();
720 pointer cc = c.coeff();
726 template <
typename Storage>
727 KOKKOS_INLINE_FUNCTION
738 const_pointer ac = a.coeff();
739 pointer cc = c.coeff();
745 template <
typename Storage>
746 KOKKOS_INLINE_FUNCTION
760 #if !defined(__CUDA_ARCH__) 761 TEUCHOS_TEST_FOR_EXCEPTION(
762 asz != bsz && asz != 1 && bsz != 1, std::logic_error,
763 "Sacado::UQ::PCE::operator/(): input sizes do not match");
765 my_cijk_type c_cijk = asz == bsz || asz >1 ? a.cijk() : b.cijk();
769 #if defined(__CUDA_ARCH__) 770 const_pointer ac = a.coeff();
771 pointer cc = c.coeff();
777 #if !defined(__CUDA_ARCH__) 779 const_pointer ac = a.coeff();
780 const_pointer bc = b.coeff();
781 pointer cc = c.coeff();
794 template <
typename Storage>
795 KOKKOS_INLINE_FUNCTION
805 template <
typename Storage>
806 KOKKOS_INLINE_FUNCTION
817 const_pointer ac = a.coeff();
818 pointer cc = c.coeff();
824 template <
typename Storage>
825 KOKKOS_INLINE_FUNCTION
829 #if !defined(__CUDA_ARCH__) 830 TEUCHOS_TEST_FOR_EXCEPTION(
831 a.size() != 1, std::logic_error,
832 "Sacado::UQ::PCE::exp(): argument has size != 1");
836 c.fastAccessCoeff(0) =
std::exp( a.fastAccessCoeff(0) );
841 template <
typename Storage>
842 KOKKOS_INLINE_FUNCTION
846 #if !defined(__CUDA_ARCH__) 847 TEUCHOS_TEST_FOR_EXCEPTION(
848 a.size() != 1, std::logic_error,
849 "Sacado::UQ::PCE::log(): argument has size != 1");
853 c.fastAccessCoeff(0) =
std::log( a.fastAccessCoeff(0) );
858 template <
typename Storage>
859 KOKKOS_INLINE_FUNCTION
863 #if !defined(__CUDA_ARCH__) 864 TEUCHOS_TEST_FOR_EXCEPTION(
865 a.size() != 1, std::logic_error,
866 "Sacado::UQ::PCE::log10(): argument has size != 1");
870 c.fastAccessCoeff(0) =
std::log10( a.fastAccessCoeff(0) );
875 template <
typename Storage>
876 KOKKOS_INLINE_FUNCTION
880 #if !defined(__CUDA_ARCH__) 881 TEUCHOS_TEST_FOR_EXCEPTION(
882 a.size() != 1, std::logic_error,
883 "Sacado::UQ::PCE::sqrt(): argument has size != 1");
887 c.fastAccessCoeff(0) =
std::sqrt( a.fastAccessCoeff(0) );
892 template <
typename Storage>
893 KOKKOS_INLINE_FUNCTION
897 #if !defined(__CUDA_ARCH__) 898 TEUCHOS_TEST_FOR_EXCEPTION(
899 a.size() != 1, std::logic_error,
900 "Sacado::UQ::PCE::cbrt(): argument has size != 1");
904 c.fastAccessCoeff(0) =
std::cbrt( a.fastAccessCoeff(0) );
909 template <
typename Storage>
910 KOKKOS_INLINE_FUNCTION
914 #if !defined(__CUDA_ARCH__) 915 TEUCHOS_TEST_FOR_EXCEPTION(
916 a.size() != 1 || b.size() != 1, std::logic_error,
917 "Sacado::UQ::PCE::pow(): arguments have size != 1");
921 c.fastAccessCoeff(0) =
std::pow(a.fastAccessCoeff(0), b.fastAccessCoeff(0));
926 template <
typename Storage>
927 KOKKOS_INLINE_FUNCTION
932 #if !defined(__CUDA_ARCH__) 933 TEUCHOS_TEST_FOR_EXCEPTION(
934 b.size() != 1, std::logic_error,
935 "Sacado::UQ::PCE::pow(): arguments have size != 1");
939 c.fastAccessCoeff(0) =
std::pow(a, b.fastAccessCoeff(0));
944 template <
typename Storage>
945 KOKKOS_INLINE_FUNCTION
950 #if !defined(__CUDA_ARCH__) 951 TEUCHOS_TEST_FOR_EXCEPTION(
952 a.size() != 1, std::logic_error,
953 "Sacado::UQ::PCE::pow(): arguments have size != 1");
957 c.fastAccessCoeff(0) =
std::pow(a.fastAccessCoeff(0), b);
962 template <
typename Storage>
963 KOKKOS_INLINE_FUNCTION
967 #if !defined(__CUDA_ARCH__) 968 TEUCHOS_TEST_FOR_EXCEPTION(
969 a.size() != 1, std::logic_error,
970 "Sacado::UQ::PCE::sin(): argument has size != 1");
974 c.fastAccessCoeff(0) =
std::sin( a.fastAccessCoeff(0) );
979 template <
typename Storage>
980 KOKKOS_INLINE_FUNCTION
984 #if !defined(__CUDA_ARCH__) 985 TEUCHOS_TEST_FOR_EXCEPTION(
986 a.size() != 1, std::logic_error,
987 "Sacado::UQ::PCE::cos(): argument has size != 1");
991 c.fastAccessCoeff(0) =
std::cos( a.fastAccessCoeff(0) );
996 template <
typename Storage>
997 KOKKOS_INLINE_FUNCTION
1001 #if !defined(__CUDA_ARCH__) 1002 TEUCHOS_TEST_FOR_EXCEPTION(
1003 a.size() != 1, std::logic_error,
1004 "Sacado::UQ::PCE::tan(): argument has size != 1");
1008 c.fastAccessCoeff(0) =
std::tan( a.fastAccessCoeff(0) );
1013 template <
typename Storage>
1014 KOKKOS_INLINE_FUNCTION
1018 #if !defined(__CUDA_ARCH__) 1019 TEUCHOS_TEST_FOR_EXCEPTION(
1020 a.size() != 1, std::logic_error,
1021 "Sacado::UQ::PCE::sinh(): argument has size != 1");
1025 c.fastAccessCoeff(0) =
std::sinh( a.fastAccessCoeff(0) );
1030 template <
typename Storage>
1031 KOKKOS_INLINE_FUNCTION
1035 #if !defined(__CUDA_ARCH__) 1036 TEUCHOS_TEST_FOR_EXCEPTION(
1037 a.size() != 1, std::logic_error,
1038 "Sacado::UQ::PCE::cosh(): argument has size != 1");
1042 c.fastAccessCoeff(0) =
std::cosh( a.fastAccessCoeff(0) );
1047 template <
typename Storage>
1048 KOKKOS_INLINE_FUNCTION
1052 #if !defined(__CUDA_ARCH__) 1053 TEUCHOS_TEST_FOR_EXCEPTION(
1054 a.size() != 1, std::logic_error,
1055 "Sacado::UQ::PCE::tanh(): argument has size != 1");
1059 c.fastAccessCoeff(0) =
std::tanh( a.fastAccessCoeff(0) );
1064 template <
typename Storage>
1065 KOKKOS_INLINE_FUNCTION
1069 #if !defined(__CUDA_ARCH__) 1070 TEUCHOS_TEST_FOR_EXCEPTION(
1071 a.size() != 1, std::logic_error,
1072 "Sacado::UQ::PCE::acos(): argument has size != 1");
1076 c.fastAccessCoeff(0) =
std::acos( a.fastAccessCoeff(0) );
1081 template <
typename Storage>
1082 KOKKOS_INLINE_FUNCTION
1086 #if !defined(__CUDA_ARCH__) 1087 TEUCHOS_TEST_FOR_EXCEPTION(
1088 a.size() != 1, std::logic_error,
1089 "Sacado::UQ::PCE::asin(): argument has size != 1");
1093 c.fastAccessCoeff(0) =
std::asin( a.fastAccessCoeff(0) );
1098 template <
typename Storage>
1099 KOKKOS_INLINE_FUNCTION
1103 #if !defined(__CUDA_ARCH__) 1104 TEUCHOS_TEST_FOR_EXCEPTION(
1105 a.size() != 1, std::logic_error,
1106 "Sacado::UQ::PCE::atan(): argument has size != 1");
1110 c.fastAccessCoeff(0) =
std::atan( a.fastAccessCoeff(0) );
1168 template <
typename Storage>
1169 KOKKOS_INLINE_FUNCTION
1174 c.fastAccessCoeff(0) = a.two_norm();
1178 template <
typename Storage>
1179 KOKKOS_INLINE_FUNCTION
1184 c.fastAccessCoeff(0) = a.two_norm();
1198 template <
typename Storage>
1199 KOKKOS_INLINE_FUNCTION
1204 if (a >= b.two_norm()) {
1206 c.fastAccessCoeff(0) = a;
1212 template <
typename Storage>
1217 if (a.two_norm() >= b)
1220 c.fastAccessCoeff(0) = b;
1234 template <
typename Storage>
1235 KOKKOS_INLINE_FUNCTION
1240 if (a <= b.two_norm()) {
1242 c.fastAccessCoeff(0) = a;
1248 template <
typename Storage>
1249 KOKKOS_INLINE_FUNCTION
1254 if (a.two_norm() <= b)
1257 c.fastAccessCoeff(0) = b;
1261 template <
typename Storage>
1262 KOKKOS_INLINE_FUNCTION
1271 if (a.coeff(i) != b.coeff(i))
1276 template <
typename Storage>
1277 KOKKOS_INLINE_FUNCTION
1284 if (a != b.coeff(0))
1292 template <
typename Storage>
1293 KOKKOS_INLINE_FUNCTION
1300 if (a.coeff(0) != b)
1308 template <
typename Storage>
1309 KOKKOS_INLINE_FUNCTION
1316 template <
typename Storage>
1317 KOKKOS_INLINE_FUNCTION
1325 template <
typename Storage>
1326 KOKKOS_INLINE_FUNCTION
1334 template <
typename Storage>
1335 KOKKOS_INLINE_FUNCTION
1339 return a.two_norm() <= b.two_norm();
1342 template <
typename Storage>
1343 KOKKOS_INLINE_FUNCTION
1348 return a <= b.two_norm();
1351 template <
typename Storage>
1352 KOKKOS_INLINE_FUNCTION
1354 operator<=(const PCE<Storage>& a,
1357 return a.two_norm() <= b;
1360 template <
typename Storage>
1361 KOKKOS_INLINE_FUNCTION
1365 return a.two_norm() >= b.two_norm();
1368 template <
typename Storage>
1369 KOKKOS_INLINE_FUNCTION
1374 return a >= b.two_norm();
1377 template <
typename Storage>
1378 KOKKOS_INLINE_FUNCTION
1383 return a.two_norm() >= b;
1386 template <
typename Storage>
1387 KOKKOS_INLINE_FUNCTION
1391 return a.two_norm() < b.two_norm();
1394 template <
typename Storage>
1395 KOKKOS_INLINE_FUNCTION
1400 return a < b.two_norm();
1403 template <
typename Storage>
1404 KOKKOS_INLINE_FUNCTION
1406 operator<(const PCE<Storage>& a,
1409 return a.two_norm() < b;
1412 template <
typename Storage>
1413 KOKKOS_INLINE_FUNCTION
1417 return a.two_norm() > b.two_norm();
1420 template <
typename Storage>
1421 KOKKOS_INLINE_FUNCTION
1426 return a > b.two_norm();
1429 template <
typename Storage>
1430 KOKKOS_INLINE_FUNCTION
1435 return a.two_norm() > b;
1438 template <
typename Storage>
1439 KOKKOS_INLINE_FUNCTION
1442 bool is_zero =
true;
1445 is_zero = is_zero && (
x.fastAccessCoeff(i) == 0.0);
1449 template <
typename Storage>
1450 KOKKOS_INLINE_FUNCTION
1457 template <
typename Storage>
1458 KOKKOS_INLINE_FUNCTION
1466 template <
typename Storage>
1467 KOKKOS_INLINE_FUNCTION
1475 template <
typename Storage>
1476 KOKKOS_INLINE_FUNCTION
1483 template <
typename Storage>
1484 KOKKOS_INLINE_FUNCTION
1492 template <
typename Storage>
1493 KOKKOS_INLINE_FUNCTION
1501 template <
typename Storage>
1503 operator << (std::ostream& os, const PCE<Storage>& a)
1510 os << a.coeff(i) <<
" ";
1517 template <
typename Storage>
1528 is >> a.fastAccessCoeff(i);
1537 template <
typename Storage>
1558 resid = r.two_norm();
1560 rTz = r.inner_product(z);
1563 while ( resid > tol && k < 100){
1566 alpha = rTz/p.inner_product(bp);
1572 resid = r.two_norm();
1575 rTz = r.inner_product(z);
KOKKOS_INLINE_FUNCTION PCE< Storage > sqrt(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > fabs(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > tan(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION bool operator||(const PCE< Storage > &x1, const PCE< Storage > &x2)
KOKKOS_INLINE_FUNCTION PCE< Storage > sinh(const PCE< Storage > &a)
OrthogPoly< T, Storage > operator-(const OrthogPoly< T, Storage > &a, const OrthogPoly< T, Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > pow(const PCE< Storage > &a, const typename PCE< Storage >::value_type &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > pow(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > tanh(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > cbrt(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION bool operator!=(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > acos(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION bool operator&&(const PCE< Storage > &x1, const PCE< Storage > &x2)
KOKKOS_INLINE_FUNCTION PCE< Storage > min(const typename PCE< Storage >::value_type &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION bool operator>(const PCE< Storage > &a, const PCE< Storage > &b)
std::istream & operator>>(std::istream &is, PCE< Storage > &a)
const IndexType const IndexType const IndexType const IndexType const ValueType const ValueType * x
KOKKOS_INLINE_FUNCTION PCE< Storage > operator/(const PCE< Storage > &a, const PCE< Storage > &b)
void CG_divide(const PCE< Storage > &a, const PCE< Storage > &b, PCE< Storage > &c)
KOKKOS_INLINE_FUNCTION PCE< Storage > operator-(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION bool operator>=(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > max(const typename PCE< Storage >::value_type &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > cosh(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION bool is_constant(const T &x)
KOKKOS_INLINE_FUNCTION bool operator==(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > abs(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > atan(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > exp(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > sin(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > operator+(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > operator*(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION PCE< Storage > log(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > log10(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > asin(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > cos(const PCE< Storage > &a)
const IndexType const IndexType const IndexType const IndexType const ValueType const ValueType ValueType * y
KOKKOS_INLINE_FUNCTION bool toBool(const PCE< Storage > &x)