42 #include "Sacado_cmath.hpp" 46 #include <math_functions.h> 113 #define MP_UNARYOP_MACRO(OPNAME,OP,OPER) \ 118 template <typename T> \ 120 public Expr< OP< T > > { \ 123 typedef typename remove_volatile<T>::type Tnv; \ 124 typedef typename Tnv::value_type value_type; \ 125 typedef typename Tnv::storage_type storage_type; \ 126 typedef typename Tnv::base_expr_type base_expr_type; \ 128 KOKKOS_INLINE_FUNCTION \ 129 OP(const T& expr_) : expr(expr_) {} \ 131 KOKKOS_INLINE_FUNCTION \ 132 std::string name() const { \ 133 return std::string(#OPER) + expr.name(); \ 136 KOKKOS_INLINE_FUNCTION \ 138 return expr.size(); \ 141 KOKKOS_INLINE_FUNCTION \ 142 bool hasFastAccess(int sz) const { \ 143 return expr.hasFastAccess(sz); \ 146 KOKKOS_INLINE_FUNCTION \ 147 value_type val() const { \ 148 return OPER(expr.val()); \ 151 KOKKOS_INLINE_FUNCTION \ 152 value_type coeff(int i) const { \ 153 return OPER(expr.coeff(i)); \ 156 KOKKOS_INLINE_FUNCTION \ 157 value_type fastAccessCoeff(int i) const { \ 158 return OPER(expr.fastAccessCoeff(i)); \ 162 KOKKOS_INLINE_FUNCTION \ 163 value_type getCoeff() const { \ 164 return OPER(expr.template getCoeff<i>()); \ 169 typename const_expr_ref<T>::type expr; \ 173 template <typename T> \ 174 KOKKOS_INLINE_FUNCTION \ 176 OPNAME (const Expr<T>& expr) \ 178 typedef OP< typename Expr<T>::derived_type > expr_t; \ 180 return expr_t(expr.derived()); \ 183 template <typename T> \ 184 KOKKOS_INLINE_FUNCTION \ 186 OPNAME (const volatile Expr<T>& expr) \ 188 typedef typename Expr<T>::derived_type derived; \ 189 typedef OP< typename add_volatile<derived>::type > expr_t; \ 191 return expr_t(expr.derived()); \ 195 template <typename T> \ 196 struct IsExpr< MP::OP<T> > { \ 197 static const bool value = true; \ 200 template <typename T> \ 201 struct BaseExprType< MP::OP<T> > { \ 202 typedef typename MP::OP<T>::base_expr_type type; \ 228 #undef MP_UNARYOP_MACRO 230 #define MP_BINARYOP_MACRO(OPNAME,OP,OPER) \ 234 template <typename T1, typename T2> \ 236 public Expr< OP< T1, T2> > { \ 240 typedef typename remove_volatile<T1>::type Tnv1; \ 241 typedef typename remove_volatile<T2>::type Tnv2; \ 242 typedef typename Tnv1::value_type value_type_1; \ 243 typedef typename Tnv2::value_type value_type_2; \ 244 typedef typename Sacado::Promote<value_type_1, \ 245 value_type_2>::type value_type; \ 247 typedef typename Tnv1::storage_type storage_type; \ 248 typedef typename Tnv1::base_expr_type base_expr_type; \ 250 KOKKOS_INLINE_FUNCTION \ 251 OP(const T1& expr1_, const T2& expr2_) : \ 252 expr1(expr1_), expr2(expr2_) {} \ 254 KOKKOS_INLINE_FUNCTION \ 255 std::string name() const { \ 256 return expr1.name() + std::string(#OPER) + expr2.name(); \ 259 KOKKOS_INLINE_FUNCTION \ 261 int sz1 = expr1.size(), sz2 = expr2.size(); \ 262 return sz1 > sz2 ? sz1 : sz2; \ 265 KOKKOS_INLINE_FUNCTION \ 266 bool hasFastAccess(int sz) const { \ 267 return expr1.hasFastAccess(sz) && expr2.hasFastAccess(sz); \ 270 KOKKOS_INLINE_FUNCTION \ 271 value_type val() const { \ 272 return (expr1.val() OPER expr2.val()); \ 275 KOKKOS_INLINE_FUNCTION \ 276 value_type coeff(int i) const { \ 277 return (expr1.coeff(i) OPER expr2.coeff(i)); \ 280 KOKKOS_INLINE_FUNCTION \ 281 value_type fastAccessCoeff(int i) const { \ 282 return (expr1.fastAccessCoeff(i) OPER expr2.fastAccessCoeff(i)); \ 286 KOKKOS_INLINE_FUNCTION \ 287 value_type getCoeff() const { \ 288 return expr1.template getCoeff<i>() OPER expr2.template getCoeff<i>(); \ 293 typename const_expr_ref<T1>::type expr1; \ 294 typename const_expr_ref<T2>::type expr2; \ 298 template <typename T1> \ 299 class OP< T1, typename T1::value_type > : \ 300 public Expr< OP< T1, typename T1::value_type > > { \ 304 typedef typename remove_volatile<T1>::type Tnv1; \ 305 typedef typename Tnv1::value_type value_type; \ 306 typedef typename Tnv1::value_type ConstT; \ 308 typedef typename Tnv1::storage_type storage_type; \ 309 typedef typename Tnv1::base_expr_type base_expr_type; \ 311 KOKKOS_INLINE_FUNCTION \ 312 OP(const T1& expr1_, const ConstT& c_) : \ 313 expr1(expr1_), c(c_) {} \ 315 KOKKOS_INLINE_FUNCTION \ 316 std::string name() const { \ 317 return expr1.name() + std::string(#OPER) + std::string("c"); \ 320 KOKKOS_INLINE_FUNCTION \ 322 return expr1.size(); \ 325 KOKKOS_INLINE_FUNCTION \ 326 bool hasFastAccess(int sz) const { \ 327 return expr1.hasFastAccess(sz); \ 330 KOKKOS_INLINE_FUNCTION \ 331 value_type val() const { \ 332 return (expr1.val() OPER c); \ 335 KOKKOS_INLINE_FUNCTION \ 336 value_type coeff(int i) const { \ 337 return (expr1.coeff(i) OPER c); \ 340 KOKKOS_INLINE_FUNCTION \ 341 value_type fastAccessCoeff(int i) const { \ 342 return (expr1.fastAccessCoeff(i) OPER c); \ 346 KOKKOS_INLINE_FUNCTION \ 347 value_type getCoeff() const { \ 348 return expr1.template getCoeff<i>() OPER c; \ 353 typename const_expr_ref<T1>::type expr1; \ 357 template <typename T2> \ 358 class OP< typename T2::value_type, T2 > : \ 359 public Expr< OP< typename T2::value_type, T2 > > { \ 363 typedef typename remove_volatile<T2>::type Tnv2; \ 364 typedef typename Tnv2::value_type value_type; \ 365 typedef typename Tnv2::value_type ConstT; \ 367 typedef typename Tnv2::storage_type storage_type; \ 368 typedef typename Tnv2::base_expr_type base_expr_type; \ 370 KOKKOS_INLINE_FUNCTION \ 371 OP(const ConstT& c_, const T2& expr2_) : \ 372 c(c_), expr2(expr2_) {} \ 374 KOKKOS_INLINE_FUNCTION \ 375 std::string name() const { \ 376 return std::string("c") + std::string(#OPER) + expr2.name(); \ 379 KOKKOS_INLINE_FUNCTION \ 380 int size() const { return expr2.size(); } \ 382 KOKKOS_INLINE_FUNCTION \ 383 bool hasFastAccess(int sz) const { \ 384 return expr2.hasFastAccess(sz); \ 387 KOKKOS_INLINE_FUNCTION \ 388 value_type val() const { \ 389 return (c OPER expr2.val()); \ 392 KOKKOS_INLINE_FUNCTION \ 393 value_type coeff(int i) const { \ 394 return (c OPER expr2.coeff(i)); \ 397 KOKKOS_INLINE_FUNCTION \ 398 value_type fastAccessCoeff(int i) const { \ 399 return (c OPER expr2.fastAccessCoeff(i)); \ 403 KOKKOS_INLINE_FUNCTION \ 404 value_type getCoeff() const { \ 405 return c OPER expr2.template getCoeff<i>(); \ 411 typename const_expr_ref<T2>::type expr2; \ 414 template <typename T1, typename T2> \ 415 KOKKOS_INLINE_FUNCTION \ 417 OPNAME (const Expr<T1>& expr1, \ 418 const Expr<T2>& expr2) \ 420 typedef OP< typename Expr<T1>::derived_type, \ 421 typename Expr<T2>::derived_type > expr_t; \ 423 return expr_t(expr1.derived(), expr2.derived()); \ 426 template <typename T1, typename T2> \ 427 KOKKOS_INLINE_FUNCTION \ 428 OP< volatile T1, volatile T2 > \ 429 OPNAME (const volatile Expr<T1>& expr1, \ 430 const volatile Expr<T2>& expr2) \ 432 typedef typename Expr<T1>::derived_type derived1; \ 433 typedef typename Expr<T2>::derived_type derived2; \ 434 typedef OP< typename add_volatile<derived1>::type, \ 435 typename add_volatile<derived2>::type > expr_t; \ 437 return expr_t(expr1.derived(), expr2.derived()); \ 440 template <typename T1, typename T2> \ 441 KOKKOS_INLINE_FUNCTION \ 442 OP< T1, volatile T2 > \ 443 OPNAME (const Expr<T1>& expr1, \ 444 const volatile Expr<T2>& expr2) \ 446 typedef typename Expr<T1>::derived_type derived1; \ 447 typedef typename Expr<T2>::derived_type derived2; \ 448 typedef OP< derived1, \ 449 typename add_volatile<derived2>::type > expr_t; \ 451 return expr_t(expr1.derived(), expr2.derived()); \ 454 template <typename T1, typename T2> \ 455 KOKKOS_INLINE_FUNCTION \ 456 OP< volatile T1, T2 > \ 457 OPNAME (const volatile Expr<T1>& expr1, \ 458 const Expr<T2>& expr2) \ 460 typedef typename Expr<T1>::derived_type derived1; \ 461 typedef typename Expr<T2>::derived_type derived2; \ 462 typedef OP< typename add_volatile<derived1>::type, \ 465 return expr_t(expr1.derived(), expr2.derived()); \ 468 template <typename T> \ 469 KOKKOS_INLINE_FUNCTION \ 470 OP< typename T::value_type, T > \ 471 OPNAME (const typename T::value_type& c, \ 472 const Expr<T>& expr) \ 474 typedef typename T::value_type ConstT; \ 475 typedef OP< ConstT, typename Expr<T>::derived_type > expr_t; \ 477 return expr_t(c, expr.derived()); \ 480 template <typename T> \ 481 KOKKOS_INLINE_FUNCTION \ 482 OP< typename T::value_type, volatile T > \ 483 OPNAME (const typename T::value_type& c, \ 484 const volatile Expr<T>& expr) \ 486 typedef typename T::value_type ConstT; \ 487 typedef typename Expr<T>::derived_type derived; \ 488 typedef OP< ConstT, \ 489 typename add_volatile<derived>::type > expr_t; \ 491 return expr_t(c, expr.derived()); \ 494 template <typename T> \ 495 KOKKOS_INLINE_FUNCTION \ 496 OP< T, typename T::value_type > \ 497 OPNAME (const Expr<T>& expr, \ 498 const typename T::value_type& c) \ 500 typedef typename T::value_type ConstT; \ 501 typedef OP< typename Expr<T>::derived_type, ConstT > expr_t; \ 503 return expr_t(expr.derived(), c); \ 506 template <typename T> \ 507 KOKKOS_INLINE_FUNCTION \ 508 OP< volatile T, typename T::value_type > \ 509 OPNAME (const volatile Expr<T>& expr, \ 510 const typename T::value_type& c) \ 512 typedef typename T::value_type ConstT; \ 513 typedef typename Expr<T>::derived_type derived; \ 514 typedef OP< typename add_volatile<derived>::type, \ 517 return expr_t(expr.derived(), c); \ 521 template <typename T1, typename T2> \ 522 struct IsExpr< MP::OP<T1,T2> > { \ 523 static const bool value = true; \ 526 template <typename T1, typename T2> \ 527 struct BaseExprType< MP::OP<T1,T2> > { \ 528 typedef typename MP::OP<T1,T2>::base_expr_type type; \ 537 #undef MP_BINARYOP_MACRO 539 #define MP_BINARYOP_MACRO(OPNAME,OP,OPER) \ 543 template <typename T1, typename T2> \ 545 public Expr< OP< T1, T2 > > { \ 549 typedef typename T1::value_type value_type_1; \ 550 typedef typename T2::value_type value_type_2; \ 551 typedef typename Sacado::Promote<value_type_1, \ 552 value_type_2>::type value_type; \ 554 typedef typename T1::storage_type storage_type; \ 555 typedef typename T1::base_expr_type base_expr_type; \ 558 KOKKOS_INLINE_FUNCTION \ 559 OP(const T1& expr1_, const T2& expr2_) : \ 560 expr1(expr1_), expr2(expr2_) {} \ 562 KOKKOS_INLINE_FUNCTION \ 563 std::string name() const { \ 564 return expr1.name() + std::string(#OPER) + expr2.name(); \ 567 KOKKOS_INLINE_FUNCTION \ 569 int sz1 = expr1.size(), sz2 = expr2.size(); \ 570 return sz1 > sz2 ? sz1 : sz2; \ 573 KOKKOS_INLINE_FUNCTION \ 574 bool hasFastAccess(int sz) const { \ 575 return expr1.hasFastAccess(sz) && expr2.hasFastAccess(sz); \ 578 KOKKOS_INLINE_FUNCTION \ 579 value_type val() const { \ 580 return OPER(expr1.val(), expr2.val()); \ 583 KOKKOS_INLINE_FUNCTION \ 584 value_type coeff(int i) const { \ 585 return OPER(expr1.coeff(i), expr2.coeff(i)); \ 588 KOKKOS_INLINE_FUNCTION \ 589 value_type fastAccessCoeff(int i) const { \ 590 return OPER(expr1.fastAccessCoeff(i), expr2.fastAccessCoeff(i)); \ 594 KOKKOS_INLINE_FUNCTION \ 595 value_type getCoeff() const { \ 596 return OPER(expr1.template getCoeff<i>(), \ 597 expr2.template getCoeff<i>()); \ 602 typename const_expr_ref<T1>::type expr1; \ 603 typename const_expr_ref<T2>::type expr2; \ 607 template <typename T1> \ 608 class OP< T1, typename T1::value_type > : \ 609 public Expr< OP< T1, typename T1::value_type > > { \ 613 typedef typename T1::value_type value_type; \ 614 typedef typename T1::value_type ConstT; \ 616 typedef typename T1::storage_type storage_type; \ 617 typedef typename T1::base_expr_type base_expr_type; \ 619 KOKKOS_INLINE_FUNCTION \ 620 OP(const T1& expr1_, const ConstT& c_) : \ 621 expr1(expr1_), c(c_) {} \ 623 KOKKOS_INLINE_FUNCTION \ 624 std::string name() const { \ 625 return expr1.name() + std::string(#OPER) + std::string("c"); \ 628 KOKKOS_INLINE_FUNCTION \ 629 int size() const { return expr1.size(); } \ 631 KOKKOS_INLINE_FUNCTION \ 632 bool hasFastAccess(int sz) const { \ 633 return expr1.hasFastAccess(sz); \ 636 KOKKOS_INLINE_FUNCTION \ 637 value_type val() const { \ 638 return OPER(expr1.val(), c); \ 641 KOKKOS_INLINE_FUNCTION \ 642 value_type coeff(int i) const { \ 643 return OPER(expr1.coeff(i), c); \ 646 KOKKOS_INLINE_FUNCTION \ 647 value_type fastAccessCoeff(int i) const { \ 648 return OPER(expr1.fastAccessCoeff(i), c); \ 652 KOKKOS_INLINE_FUNCTION \ 653 value_type getCoeff() const { \ 654 return OPER(expr1.template getCoeff<i>(), c); \ 659 typename const_expr_ref<T1>::type expr1; \ 663 template <typename T2> \ 664 class OP< typename T2::value_type, T2 > : \ 665 public Expr< OP< typename T2::value_type, T2 > > { \ 669 typedef typename T2::value_type value_type; \ 670 typedef typename T2::value_type ConstT; \ 672 typedef typename T2::storage_type storage_type; \ 673 typedef typename T2::base_expr_type base_expr_type; \ 675 KOKKOS_INLINE_FUNCTION \ 676 OP(const ConstT& c_, const T2& expr2_) : \ 677 c(c_), expr2(expr2_) {} \ 679 KOKKOS_INLINE_FUNCTION \ 680 std::string name() const { \ 681 return std::string("c") + std::string(#OPER) + expr2.name(); \ 684 KOKKOS_INLINE_FUNCTION \ 685 int size() const { return expr2.size(); } \ 687 KOKKOS_INLINE_FUNCTION \ 688 bool hasFastAccess(int sz) const { \ 689 return expr2.hasFastAccess(sz); \ 692 KOKKOS_INLINE_FUNCTION \ 693 value_type val() const { \ 694 return OPER(c, expr2.val()); \ 697 KOKKOS_INLINE_FUNCTION \ 698 value_type coeff(int i) const { \ 699 return OPER(c, expr2.coeff(i)); \ 702 KOKKOS_INLINE_FUNCTION \ 703 value_type fastAccessCoeff(int i) const { \ 704 return OPER(c, expr2.fastAccessCoeff(i)); \ 708 KOKKOS_INLINE_FUNCTION \ 709 value_type getCoeff() const { \ 710 return OPER(c, expr2.template getCoeff<i>()); \ 716 typename const_expr_ref<T2>::type expr2; \ 719 template <typename T1, typename T2> \ 720 KOKKOS_INLINE_FUNCTION \ 722 OPNAME (const Expr<T1>& expr1, \ 723 const Expr<T2>& expr2) \ 725 typedef OP< typename Expr<T1>::derived_type, \ 726 typename Expr<T2>::derived_type > expr_t; \ 728 return expr_t(expr1.derived(), expr2.derived()); \ 731 template <typename T> \ 732 KOKKOS_INLINE_FUNCTION \ 733 OP< typename T::value_type, T > \ 734 OPNAME (const typename T::value_type& c, \ 735 const Expr<T>& expr) \ 737 typedef typename T::value_type ConstT; \ 738 typedef OP< ConstT, typename Expr<T>::derived_type > expr_t; \ 740 return expr_t(c, expr.derived()); \ 743 template <typename T> \ 744 KOKKOS_INLINE_FUNCTION \ 745 OP< T, typename T::value_type > \ 746 OPNAME (const Expr<T>& expr, \ 747 const typename T::value_type& c) \ 749 typedef typename T::value_type ConstT; \ 750 typedef OP< typename Expr<T>::derived_type, ConstT > expr_t; \ 752 return expr_t(expr.derived(), c); \ 756 template <typename T1, typename T2> \ 757 struct IsExpr< MP::OP<T1,T2> > { \ 758 static const bool value = true; \ 761 template <typename T1, typename T2> \ 762 struct BaseExprType< MP::OP<T1,T2> > { \ 763 typedef typename MP::OP<T1,T2>::base_expr_type type; \ 777 #undef MP_BINARYOP_MACRO 781 #define MP_RELOP_MACRO(OP) \ 785 template <typename T1, typename T2> \ 786 KOKKOS_INLINE_FUNCTION \ 788 operator OP (const Expr<T1>& expr1, \ 789 const Expr<T2>& expr2) \ 791 return expr1.derived().val() OP expr2.derived().val(); \ 794 template <typename T1, typename T2> \ 795 KOKKOS_INLINE_FUNCTION \ 797 operator OP (const volatile Expr<T1>& expr1, \ 798 const volatile Expr<T2>& expr2) \ 800 return expr1.derived().val() OP expr2.derived().val(); \ 803 template <typename T1, typename T2> \ 804 KOKKOS_INLINE_FUNCTION \ 806 operator OP (const volatile Expr<T1>& expr1, \ 807 const Expr<T2>& expr2) \ 809 return expr1.derived().val() OP expr2.derived().val(); \ 812 template <typename T1, typename T2> \ 813 KOKKOS_INLINE_FUNCTION \ 815 operator OP (const Expr<T1>& expr1, \ 816 const volatile Expr<T2>& expr2) \ 818 return expr1.derived().val() OP expr2.derived().val(); \ 821 template <typename T2> \ 822 KOKKOS_INLINE_FUNCTION \ 824 operator OP (const typename T2::value_type& a, \ 825 const Expr<T2>& expr2) \ 827 return a OP expr2.derived().val(); \ 830 template <typename T2> \ 831 KOKKOS_INLINE_FUNCTION \ 833 operator OP (const typename T2::value_type& a, \ 834 const volatile Expr<T2>& expr2) \ 836 return a OP expr2.derived().val(); \ 839 template <typename T1> \ 840 KOKKOS_INLINE_FUNCTION \ 842 operator OP (const Expr<T1>& expr1, \ 843 const typename T1::value_type& b) \ 845 return expr1.derived().val() OP b; \ 848 template <typename T1> \ 849 KOKKOS_INLINE_FUNCTION \ 851 operator OP (const volatile Expr<T1>& expr1, \ 852 const typename T1::value_type& b) \ 854 return expr1.derived().val() OP b; \ 870 #undef MP_RELOP_MACRO 876 template <
typename T>
877 KOKKOS_INLINE_FUNCTION
880 return ! expr.derived().val();
893 template <
typename T>
894 KOKKOS_INLINE_FUNCTION
899 for (
int i=0; i<
x.size(); i++)
900 is_zero = is_zero && (
x.coeff(i) == 0.0);
908 #define PCE_BOOL_MACRO(OP) \ 912 template <typename T1, typename T2> \ 913 KOKKOS_INLINE_FUNCTION \ 915 operator OP (const Expr<T1>& expr1, \ 916 const Expr<T2>& expr2) \ 918 return toBool(expr1) OP toBool(expr2); \ 921 template <typename T2> \ 922 KOKKOS_INLINE_FUNCTION \ 924 operator OP (const typename T2::value_type& a, \ 925 const Expr<T2>& expr2) \ 927 return a OP toBool(expr2); \ 930 template <typename T1> \ 931 KOKKOS_INLINE_FUNCTION \ 933 operator OP (const Expr<T1>& expr1, \ 934 const typename T1::value_type& b) \ 936 return toBool(expr1) OP b; \ 944 #undef PCE_BOOL_MACRO 953 template <
typename T>
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)
Stokhos::StandardStorage< int, double > storage_type
KOKKOS_INLINE_FUNCTION PCE< Storage > sinh(const PCE< Storage > &a)
expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 MultiplicationOp
#define MP_BINARYOP_MACRO(OPNAME, OP, OPER)
expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 j expr1 expr1 expr1 expr1 j expr1 c *expr2 expr1 c expr1 c expr1 c expr1 DivisionOp
KOKKOS_INLINE_FUNCTION PCE< Storage > pow(const PCE< Storage > &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION bool toBool(const Expr< T > &xx)
KOKKOS_INLINE_FUNCTION PCE< Storage > tanh(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > cbrt(const PCE< Storage > &a)
KOKKOS_INLINE_FUNCTION PCE< Storage > acos(const PCE< Storage > &a)
atan2(expr1.val(), expr2.val())
KOKKOS_INLINE_FUNCTION PCE< Storage > min(const typename PCE< Storage >::value_type &a, const PCE< Storage > &b)
KOKKOS_INLINE_FUNCTION bool operator!(const Expr< T > &expr)
const IndexType const IndexType const IndexType const IndexType const ValueType const ValueType * x
expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 j expr1 expr1 expr1 expr1 j expr1 c *expr2 expr1 c expr1 c expr1 c expr1 expr1 expr1 expr1 j *expr1 expr2 expr1 expr1 j *expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 Atan2Op
#define MP_UNARYOP_MACRO(OPNAME, OP, OPER)
#define MP_RELOP_MACRO(OP)
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 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)
expr2 j expr1 expr1 expr2 expr2 j expr1 c c c c PowerOp
std::ostream & operator<<(std::ostream &os, const Expr< T > &x)
expr expr expr expr ExpOp
KOKKOS_INLINE_FUNCTION PCE< Storage > sin(const PCE< Storage > &a)
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)
#define PCE_BOOL_MACRO(OP)