52#ifndef SACADO_ELRFAD_OPS_HPP
53#define SACADO_ELRFAD_OPS_HPP
59#define FAD_UNARYOP_MACRO(OPNAME,OP,VALUE,ADJOINT, \
60 LINEAR,DX,FASTACCESSDX) \
64 template <typename ExprT> \
67 template <typename ExprT> \
68 class Expr< OP<ExprT> > { \
71 typedef typename ExprT::value_type value_type; \
72 typedef typename ExprT::scalar_type scalar_type; \
73 typedef typename ExprT::base_expr_type base_expr_type; \
75 static const int num_args = ExprT::num_args; \
77 static const bool is_linear = LINEAR; \
79 SACADO_INLINE_FUNCTION \
80 explicit Expr(const ExprT& expr_) : expr(expr_) {} \
82 SACADO_INLINE_FUNCTION \
83 int size() const { return expr.size(); } \
86 SACADO_INLINE_FUNCTION \
87 bool isActive() const { return expr.template isActive<Arg>(); } \
89 SACADO_INLINE_FUNCTION \
90 bool isActive2(int j) const { return expr.isActive2(j); } \
92 SACADO_INLINE_FUNCTION \
93 bool updateValue() const { return expr.updateValue(); } \
95 SACADO_INLINE_FUNCTION \
96 void cache() const {} \
98 SACADO_INLINE_FUNCTION \
99 value_type val() const { \
103 SACADO_INLINE_FUNCTION \
104 void computePartials(const value_type& bar, \
105 value_type partials[]) const { \
106 expr.computePartials(ADJOINT, partials); \
109 SACADO_INLINE_FUNCTION \
110 void getTangents(int i, value_type dots[]) const { \
111 expr.getTangents(i, dots); } \
114 SACADO_INLINE_FUNCTION \
115 const value_type& getTangent(int i) const { \
116 return expr.template getTangent<Arg>(i); \
119 SACADO_INLINE_FUNCTION \
120 bool isLinear() const { \
124 SACADO_INLINE_FUNCTION \
125 bool hasFastAccess() const { \
126 return expr.hasFastAccess(); \
129 SACADO_INLINE_FUNCTION \
130 const value_type dx(int i) const { \
134 SACADO_INLINE_FUNCTION \
135 const value_type fastAccessDx(int i) const { \
136 return FASTACCESSDX; \
139 SACADO_INLINE_FUNCTION \
140 const value_type* getDx(int j) const { \
141 return expr.getDx(j); \
144 SACADO_INLINE_FUNCTION \
145 int numActiveArgs() const { \
146 return expr.numActiveArgs(); \
149 SACADO_INLINE_FUNCTION \
150 void computeActivePartials(const value_type& bar, \
151 value_type *partials) const { \
152 expr.computePartials(ADJOINT, partials); \
160 template <typename T> \
161 SACADO_INLINE_FUNCTION \
162 Expr< OP< Expr<T> > > \
163 OPNAME (const Expr<T>& expr) \
165 typedef OP< Expr<T> > expr_t; \
167 return Expr<expr_t>(expr); \
178 expr.fastAccessDx(
i))
185 -expr.fastAccessDx(
i))
188 std::exp(expr.val()),
189 bar*std::exp(expr.val()),
191 std::exp(expr.val())*expr.dx(
i),
192 std::exp(expr.val())*expr.fastAccessDx(
i))
195 std::log(expr.val()),
198 expr.dx(
i)/expr.val(),
199 expr.fastAccessDx(
i)/expr.val())
205 expr.
dx(
i)/(
std::log(value_type(10))*expr.
val()),
210 value_type(0.5)*
bar/
std::sqrt(expr.
val()),
212 expr.
dx(
i)/(value_type(2)*
std::sqrt(expr.
val())),
217 expr.
val() == value_type(0.0) ? value_type(0.0) : value_type(value_type(0.5)*
bar/
std::sqrt(expr.
val())),
219 expr.
val() == value_type(0.0) ? value_type(0.0) : value_type(expr.
dx(
i)/(value_type(2)*
std::sqrt(expr.
val()))),
220 expr.
val() == value_type(0.0) ? value_type(0.0) : value_type(expr.
fastAccessDx(
i)/(value_type(2)*
std::sqrt(expr.
val()))))
241 (value_type(1)+
std::tan(expr.
val())*
std::tan(expr.
val())),
243 (value_type(1)+
std::tan(expr.
val())*
std::tan(expr.
val())))
249 -expr.
dx(
i)/
std::sqrt(value_type(1)-expr.
val()*expr.
val()),
251 std::sqrt(value_type(1)-expr.
val()*expr.
val()))
257 expr.
dx(
i)/
std::sqrt(value_type(1)-expr.
val()*expr.
val()),
259 std::sqrt(value_type(1)-expr.
val()*expr.
val()))
263 bar/(value_type(1.)+expr.
val()*expr.
val()),
265 expr.
dx(
i)/(value_type(1)+expr.
val()*expr.
val()),
286 expr.
dx(
i)*(value_type(1)-
std::tanh(expr.
val())*
std::tanh(expr.
val())),
291 bar/
std::sqrt((expr.
val()-value_type(1.)) *
292 (expr.
val()+value_type(1.))),
294 expr.
dx(
i)/
std::sqrt((expr.
val()-value_type(1)) *
295 (expr.
val()+value_type(1))),
297 (expr.
val()+value_type(1))))
303 expr.
dx(
i)/
std::sqrt(value_type(1)+expr.
val()*expr.
val()),
309 bar/(value_type(1.)-expr.
val()*expr.
val()),
311 expr.
dx(
i)/(value_type(1)-expr.
val()*expr.
val()),
317 (expr.
val() >= value_type(0.)) ?
bar : value_type(-
bar),
319 expr.
val() >= 0 ? value_type(+expr.
dx(
i)) :
320 value_type(-expr.
dx(
i)),
326 (expr.
val() >= value_type(0.)) ?
bar : value_type(-
bar),
328 expr.
val() >= 0 ? value_type(+expr.
dx(
i)) :
329 value_type(-expr.
dx(
i)),
332#ifdef HAVE_SACADO_CXX11
335 std::cbrt(expr.val()),
336 bar/(value_type(3)*std::cbrt(expr.val()*expr.val())),
338 expr.dx(
i)/(value_type(3)*std::cbrt(expr.val()*expr.val())),
339 expr.fastAccessDx(
i)/(value_type(3)*std::cbrt(expr.val()*expr.val())))
342#undef FAD_UNARYOP_MACRO
344#define FAD_BINARYOP_MACRO( \
345 OPNAME,OP,VALUE,LADJOINT,RADJOINT, \
346 LINEAR,CONST_LINEAR_1, CONST_LINEAR_2, \
347 LINEAR_2,CONST_LINEAR_1_2, CONST_LINEAR_2_2, \
348 DX,FASTACCESSDX,CONST_DX_1,CONST_DX_2, \
349 CONST_FASTACCESSDX_1,CONST_FASTACCESSDX_2) \
353 template <typename ExprT1, typename ExprT2> \
356 template <typename ExprT1, typename ExprT2> \
357 class Expr< OP<ExprT1,ExprT2> > { \
361 typedef typename ExprT1::value_type value_type_1; \
362 typedef typename ExprT2::value_type value_type_2; \
363 typedef typename Sacado::Promote<value_type_1, \
364 value_type_2>::type value_type; \
366 typedef typename ExprT1::scalar_type scalar_type_1; \
367 typedef typename ExprT2::scalar_type scalar_type_2; \
368 typedef typename Sacado::Promote<scalar_type_1, \
369 scalar_type_2>::type scalar_type; \
371 typedef typename ExprT1::base_expr_type base_expr_type_1; \
372 typedef typename ExprT2::base_expr_type base_expr_type_2; \
373 typedef typename Sacado::Promote<base_expr_type_1, \
374 base_expr_type_2>::type base_expr_type; \
376 static const int num_args1 = ExprT1::num_args; \
377 static const int num_args2 = ExprT2::num_args; \
378 static const int num_args = num_args1 + num_args2; \
380 static const bool is_linear = LINEAR_2; \
382 SACADO_INLINE_FUNCTION \
383 Expr(const ExprT1& expr1_, const ExprT2& expr2_) : \
384 expr1(expr1_), expr2(expr2_) {} \
386 SACADO_INLINE_FUNCTION \
388 int sz1 = expr1.size(), sz2 = expr2.size(); \
389 return sz1 > sz2 ? sz1 : sz2; \
393 SACADO_INLINE_FUNCTION \
394 bool isActive() const { \
395 if (Arg < num_args1) \
396 return expr1.template isActive<Arg>(); \
398 return expr2.template isActive<Arg-num_args1>(); \
401 SACADO_INLINE_FUNCTION \
402 bool isActive2(int j) const { \
404 return expr1.isActive2(j); \
406 return expr2.isActive2(j); \
409 SACADO_INLINE_FUNCTION \
410 bool updateValue() const { \
411 return expr1.updateValue() && expr2.updateValue(); \
414 SACADO_INLINE_FUNCTION \
415 void cache() const {} \
417 SACADO_INLINE_FUNCTION \
418 value_type val() const { \
422 SACADO_INLINE_FUNCTION \
423 void computePartials(const value_type& bar, \
424 value_type partials[]) const { \
426 expr1.computePartials(LADJOINT, partials); \
428 expr2.computePartials(RADJOINT, partials+num_args1); \
431 SACADO_INLINE_FUNCTION \
432 void getTangents(int i, value_type dots[]) const { \
433 expr1.getTangents(i, dots); \
434 expr2.getTangents(i, dots+num_args1); \
438 SACADO_INLINE_FUNCTION \
439 const value_type& getTangent(int i) const { \
440 if (Arg < num_args1) \
441 return expr1.template getTangent<Arg>(i); \
443 return expr2.template getTangent<Arg-num_args1>(i); \
446 SACADO_INLINE_FUNCTION \
447 bool isLinear() const { \
451 SACADO_INLINE_FUNCTION \
452 bool hasFastAccess() const { \
453 return expr1.hasFastAccess() && expr2.hasFastAccess(); \
456 SACADO_INLINE_FUNCTION \
457 const value_type dx(int i) const { \
461 SACADO_INLINE_FUNCTION \
462 const value_type fastAccessDx(int i) const { \
463 return FASTACCESSDX; \
466 SACADO_INLINE_FUNCTION \
467 const value_type* getDx(int j) const { \
469 return expr1.getDx(j); \
471 return expr2.getDx(j-num_args1); \
474 SACADO_INLINE_FUNCTION \
475 int numActiveArgs() const { \
476 return expr1.numActiveArgs() + expr2.numActiveArgs(); \
479 SACADO_INLINE_FUNCTION \
480 void computeActivePartials(const value_type& bar, \
481 value_type *partials) const { \
482 if (expr1.numActiveArgs() > 0) \
483 expr1.computePartials(LADJOINT, partials); \
484 if (expr2.numActiveArgs() > 0) \
485 expr2.computePartials(RADJOINT, partials+expr2.numActiveArgs()); \
489 typename ExprConstRef<ExprT1>::type expr1; \
490 typename ExprConstRef<ExprT2>::type expr2; \
494 template <typename ExprT1, typename T2> \
495 class Expr< OP<ExprT1, ConstExpr<T2> > > { \
499 typedef ConstExpr<T2> ExprT2; \
500 typedef typename ExprT1::value_type value_type_1; \
501 typedef typename ExprT2::value_type value_type_2; \
502 typedef typename Sacado::Promote<value_type_1, \
503 value_type_2>::type value_type; \
505 typedef typename ExprT1::scalar_type scalar_type_1; \
506 typedef typename ExprT2::scalar_type scalar_type_2; \
507 typedef typename Sacado::Promote<scalar_type_1, \
508 scalar_type_2>::type scalar_type; \
510 typedef typename ExprT1::base_expr_type base_expr_type_1; \
511 typedef typename ExprT2::base_expr_type base_expr_type_2; \
512 typedef typename Sacado::Promote<base_expr_type_1, \
513 base_expr_type_2>::type base_expr_type; \
515 static const int num_args = ExprT1::num_args; \
517 static const bool is_linear = CONST_LINEAR_2_2; \
519 SACADO_INLINE_FUNCTION \
520 Expr(const ExprT1& expr1_, const ExprT2& expr2_) : \
521 expr1(expr1_), expr2(expr2_) {} \
523 SACADO_INLINE_FUNCTION \
525 return expr1.size(); \
529 SACADO_INLINE_FUNCTION \
530 bool isActive() const { \
531 return expr1.template isActive<Arg>(); \
534 SACADO_INLINE_FUNCTION \
535 bool isActive2(int j) const { return expr1.isActive2(j); } \
537 SACADO_INLINE_FUNCTION \
538 bool updateValue() const { \
539 return expr1.updateValue(); \
542 SACADO_INLINE_FUNCTION \
543 void cache() const {} \
545 SACADO_INLINE_FUNCTION \
546 value_type val() const { \
550 SACADO_INLINE_FUNCTION \
551 void computePartials(const value_type& bar, \
552 value_type partials[]) const { \
553 expr1.computePartials(LADJOINT, partials); \
556 SACADO_INLINE_FUNCTION \
557 void getTangents(int i, value_type dots[]) const { \
558 expr1.getTangents(i, dots); \
562 SACADO_INLINE_FUNCTION \
563 const value_type& getTangent(int i) const { \
564 return expr1.template getTangent<Arg>(i); \
567 SACADO_INLINE_FUNCTION \
568 bool isLinear() const { \
569 return CONST_LINEAR_2; \
572 SACADO_INLINE_FUNCTION \
573 bool hasFastAccess() const { \
574 return expr1.hasFastAccess(); \
577 SACADO_INLINE_FUNCTION \
578 const value_type dx(int i) const { \
582 SACADO_INLINE_FUNCTION \
583 const value_type fastAccessDx(int i) const { \
584 return CONST_FASTACCESSDX_2; \
587 SACADO_INLINE_FUNCTION \
588 const value_type* getDx(int j) const { \
589 return expr1.getDx(j); \
592 SACADO_INLINE_FUNCTION \
593 int numActiveArgs() const { \
594 return expr1.numActiveArgs(); \
597 SACADO_INLINE_FUNCTION \
598 void computeActivePartials(const value_type& bar, \
599 value_type *partials) const { \
600 expr1.computePartials(LADJOINT, partials); \
605 typename ExprConstRef<ExprT1>::type expr1; \
606 typename ExprConstRef<ExprT2>::type expr2; \
610 template <typename T1, typename ExprT2> \
611 class Expr< OP<ConstExpr<T1>,ExprT2> > { \
615 typedef ConstExpr<T1> ExprT1; \
616 typedef typename ExprT1::value_type value_type_1; \
617 typedef typename ExprT2::value_type value_type_2; \
618 typedef typename Sacado::Promote<value_type_1, \
619 value_type_2>::type value_type; \
621 typedef typename ExprT1::scalar_type scalar_type_1; \
622 typedef typename ExprT2::scalar_type scalar_type_2; \
623 typedef typename Sacado::Promote<scalar_type_1, \
624 scalar_type_2>::type scalar_type; \
626 typedef typename ExprT1::base_expr_type base_expr_type_1; \
627 typedef typename ExprT2::base_expr_type base_expr_type_2; \
628 typedef typename Sacado::Promote<base_expr_type_1, \
629 base_expr_type_2>::type base_expr_type; \
631 static const int num_args = ExprT2::num_args; \
633 static const bool is_linear = CONST_LINEAR_1_2; \
635 SACADO_INLINE_FUNCTION \
636 Expr(const ExprT1& expr1_, const ExprT2& expr2_) : \
637 expr1(expr1_), expr2(expr2_) {} \
639 SACADO_INLINE_FUNCTION \
641 return expr2.size(); \
645 SACADO_INLINE_FUNCTION \
646 bool isActive() const { \
647 return expr2.template isActive<Arg>(); \
650 SACADO_INLINE_FUNCTION \
651 bool isActive2(int j) const { return expr2.isActive2(j); } \
653 SACADO_INLINE_FUNCTION \
654 bool updateValue() const { \
655 return expr2.updateValue(); \
658 SACADO_INLINE_FUNCTION \
659 void cache() const {} \
661 SACADO_INLINE_FUNCTION \
662 value_type val() const { \
666 SACADO_INLINE_FUNCTION \
667 void computePartials(const value_type& bar, \
668 value_type partials[]) const { \
669 expr2.computePartials(RADJOINT, partials); \
672 SACADO_INLINE_FUNCTION \
673 void getTangents(int i, value_type dots[]) const { \
674 expr2.getTangents(i, dots); \
678 SACADO_INLINE_FUNCTION \
679 const value_type& getTangent(int i) const { \
680 return expr2.template getTangent<Arg>(i); \
683 SACADO_INLINE_FUNCTION \
684 bool isLinear() const { \
685 return CONST_LINEAR_1; \
688 SACADO_INLINE_FUNCTION \
689 bool hasFastAccess() const { \
690 return expr2.hasFastAccess(); \
693 SACADO_INLINE_FUNCTION \
694 const value_type dx(int i) const { \
698 SACADO_INLINE_FUNCTION \
699 const value_type fastAccessDx(int i) const { \
700 return CONST_FASTACCESSDX_1; \
703 SACADO_INLINE_FUNCTION \
704 const value_type* getDx(int j) const { \
705 return expr2.getDx(j); \
708 SACADO_INLINE_FUNCTION \
709 int numActiveArgs() const { \
710 return expr2.numActiveArgs(); \
713 SACADO_INLINE_FUNCTION \
714 void computeActivePartials(const value_type& bar, \
715 value_type *partials) const { \
716 expr2.computePartials(RADJOINT, partials); \
720 typename ExprConstRef<ExprT1>::type expr1; \
721 typename ExprConstRef<ExprT2>::type expr2; \
725 template <typename T1, typename T2> \
726 SACADO_INLINE_FUNCTION \
727 SACADO_FAD_OP_ENABLE_EXPR_EXPR(OP) \
728 OPNAME (const T1& expr1, const T2& expr2) \
730 typedef OP< T1, T2 > expr_t; \
732 return Expr<expr_t>(expr1, expr2); \
735 template <typename T> \
736 SACADO_INLINE_FUNCTION \
737 Expr< OP< Expr<T>, Expr<T> > > \
738 OPNAME (const Expr<T>& expr1, const Expr<T>& expr2) \
740 typedef OP< Expr<T>, Expr<T> > expr_t; \
742 return Expr<expr_t>(expr1, expr2); \
745 template <typename T> \
746 SACADO_INLINE_FUNCTION \
747 Expr< OP< ConstExpr<typename Expr<T>::value_type>, \
749 OPNAME (const typename Expr<T>::value_type& c, \
750 const Expr<T>& expr) \
752 typedef ConstExpr<typename Expr<T>::value_type> ConstT; \
753 typedef OP< ConstT, Expr<T> > expr_t; \
755 return Expr<expr_t>(ConstT(c), expr); \
758 template <typename T> \
759 SACADO_INLINE_FUNCTION \
761 ConstExpr<typename Expr<T>::value_type> > > \
762 OPNAME (const Expr<T>& expr, \
763 const typename Expr<T>::value_type& c) \
765 typedef ConstExpr<typename Expr<T>::value_type> ConstT; \
766 typedef OP< Expr<T>, ConstT > expr_t; \
768 return Expr<expr_t>(expr, ConstT(c)); \
771 template <typename T> \
772 SACADO_INLINE_FUNCTION \
773 SACADO_FAD_OP_ENABLE_SCALAR_EXPR(OP) \
774 OPNAME (const typename Expr<T>::scalar_type& c, \
775 const Expr<T>& expr) \
777 typedef ConstExpr<typename Expr<T>::scalar_type> ConstT; \
778 typedef OP< ConstT, Expr<T> > expr_t; \
780 return Expr<expr_t>(ConstT(c), expr); \
783 template <typename T> \
784 SACADO_INLINE_FUNCTION \
785 SACADO_FAD_OP_ENABLE_EXPR_SCALAR(OP) \
786 OPNAME (const Expr<T>& expr, \
787 const typename Expr<T>::scalar_type& c) \
789 typedef ConstExpr<typename Expr<T>::scalar_type> ConstT; \
790 typedef OP< Expr<T>, ConstT > expr_t; \
792 return Expr<expr_t>(expr, ConstT(c)); \
800 expr1.val() + expr2.val(),
803 expr1.isLinear() && expr2.isLinear(),
806 ExprT1::is_linear && ExprT2::is_linear,
809 expr1.dx(
i) + expr2.dx(
i),
810 expr1.fastAccessDx(
i) + expr2.fastAccessDx(
i),
813 expr2.fastAccessDx(
i),
814 expr1.fastAccessDx(
i))
817 expr1.val() - expr2.val(),
820 expr1.isLinear() && expr2.isLinear(),
823 ExprT1::is_linear && ExprT2::is_linear,
826 expr1.dx(
i) - expr2.dx(
i),
827 expr1.fastAccessDx(
i) - expr2.fastAccessDx(
i),
830 -expr2.fastAccessDx(
i),
831 expr1.fastAccessDx(
i))
834 expr1.val() * expr2.val(),
843 expr1.val()*expr2.dx(
i) + expr1.dx(
i)*expr2.val(),
844 expr1.val()*expr2.fastAccessDx(
i) +
845 expr1.fastAccessDx(
i)*expr2.val(),
846 expr1.val()*expr2.dx(
i),
847 expr1.dx(
i)*expr2.val(),
848 expr1.val()*expr2.fastAccessDx(
i),
849 expr1.fastAccessDx(
i)*expr2.val())
852 expr1.
val() / expr2.
val(),
862 (expr2.
val()*expr2.
val()),
865 (expr2.
val()*expr2.
val()),
893 expr2.size() == 0 && expr2.
val() == value_type(1) ?
bar : expr1.
val() == value_type(0) ? value_type(0) : value_type(
bar*
std::pow(expr1.
val(),expr2.
val())*expr2.
val()/expr1.
val()),
894 expr1.
val() == value_type(0) ? value_type(0) : value_type(
bar*
std::pow(expr1.
val(),expr2.
val())*
std::log(expr1.
val())),
901 expr1.
val() == value_type(0) ? value_type(0) : value_type((expr2.
dx(
i)*
std::log(expr1.
val())+expr2.
val()*expr1.
dx(
i)/expr1.
val())*
std::pow(expr1.
val(),expr2.
val())),
903 expr1.
val() == value_type(0) ? value_type(0) : value_type(expr2.
dx(
i)*
std::log(expr1.
val())*
std::pow(expr1.
val(),expr2.
val())),
904 expr2.
val() == value_type(1) ? expr1.
dx(
i) : expr1.
val() == value_type(0) ? value_type(0) : value_type(expr2.
val()*expr1.
dx(
i)/expr1.
val()*
std::pow(expr1.
val(),expr2.
val())),
910 expr1.
val() >= expr2.
val() ?
bar : value_type(0.),
911 expr2.
val() > expr1.
val() ?
bar : value_type(0.),
912 expr1.isLinear() && expr2.isLinear(),
915 ExprT1::is_linear && ExprT2::is_linear,
921 expr1.
val() >= expr2.
val() ? value_type(0) : expr2.
dx(
i),
922 expr1.
val() >= expr2.
val() ? expr1.
dx(
i) : value_type(0),
923 expr1.
val() >= expr2.
val() ? value_type(0) :
930 expr1.
val() <= expr2.
val() ?
bar : value_type(0.),
931 expr2.
val() < expr1.
val() ?
bar : value_type(0.),
932 expr1.isLinear() && expr2.isLinear(),
935 ExprT1::is_linear && ExprT2::is_linear,
941 expr1.
val() <= expr2.
val() ? value_type(0) : expr2.
dx(
i),
942 expr1.
val() <= expr2.
val() ? expr1.
dx(
i) : value_type(0),
943 expr1.
val() <= expr2.
val() ? value_type(0) :
948#undef FAD_BINARYOP_MACRO
952#define FAD_RELOP_MACRO(OP) \
955 template <typename ExprT1, typename ExprT2> \
956 SACADO_INLINE_FUNCTION \
958 operator OP (const Expr<ExprT1>& expr1, \
959 const Expr<ExprT2>& expr2) \
961 return expr1.val() OP expr2.val(); \
964 template <typename ExprT2> \
965 SACADO_INLINE_FUNCTION \
967 operator OP (const typename Expr<ExprT2>::value_type& a, \
968 const Expr<ExprT2>& expr2) \
970 return a OP expr2.val(); \
973 template <typename ExprT1> \
974 SACADO_INLINE_FUNCTION \
976 operator OP (const Expr<ExprT1>& expr1, \
977 const typename Expr<ExprT1>::value_type& b) \
979 return expr1.val() OP b; \
995#undef FAD_RELOP_MACRO
1001 template <
typename ExprT>
1003 bool operator ! (
const Expr<ExprT>& expr)
1005 return ! expr.val();
1017 template <
typename ExprT>
1019 bool toBool(
const Expr<ExprT>&
x) {
1020 bool is_zero = (
x.val() == 0.0);
1021 for (
int i=0;
i<
x.size();
i++)
1022 is_zero = is_zero && (
x.dx(
i) == 0.0);
1030#define FAD_BOOL_MACRO(OP) \
1032 namespace ELRFad { \
1033 template <typename ExprT1, typename ExprT2> \
1034 SACADO_INLINE_FUNCTION \
1036 operator OP (const Expr<ExprT1>& expr1, \
1037 const Expr<ExprT2>& expr2) \
1039 return toBool(expr1) OP toBool(expr2); \
1042 template <typename ExprT2> \
1043 SACADO_INLINE_FUNCTION \
1045 operator OP (const typename Expr<ExprT2>::value_type& a, \
1046 const Expr<ExprT2>& expr2) \
1048 return a OP toBool(expr2); \
1051 template <typename ExprT1> \
1052 SACADO_INLINE_FUNCTION \
1054 operator OP (const Expr<ExprT1>& expr1, \
1055 const typename Expr<ExprT1>::value_type& b) \
1057 return toBool(expr1) OP b; \
1065#undef FAD_BOOL_MACRO
1073 template <
typename ExprT>
1074 std::ostream&
operator << (std::ostream& os,
const Expr<ExprT>&
x) {
1075 os <<
x.val() <<
" [";
1077 for (
int i=0;
i<
x.size();
i++) {
1078 os <<
" " <<
x.dx(
i);
#define SACADO_INLINE_FUNCTION
expr expr expr bar bar expr expr expr Log10Op
expr expr expr fastAccessDx(i)) FAD_UNARYOP_MACRO(exp
#define FAD_RELOP_MACRO(OP)
#define FAD_UNARYOP_MACRO(OPNAME, OP, VALUE, ADJOINT, LINEAR, DX, FASTACCESSDX)
#define FAD_BOOL_MACRO(OP)
#define FAD_BINARYOP_MACRO( OPNAME, OP, VALUE, LADJOINT, RADJOINT, LINEAR, CONST_LINEAR_1, CONST_LINEAR_2, LINEAR_2, CONST_LINEAR_1_2, CONST_LINEAR_2_2, DX, FASTACCESSDX, CONST_DX_1, CONST_DX_2, CONST_FASTACCESSDX_1, CONST_FASTACCESSDX_2)
expr2 expr1 expr2 expr2 c *expr2 c *expr1 c *expr2 c *expr1 MaxOp
expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 expr1 expr1 c *expr2 expr1 c *expr2 expr1 c *expr2 expr1 DivisionOp
expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 expr1 expr1 c *expr2 expr1 c *expr2 expr1 c *expr2 expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 Atan2Op
expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 MultiplicationOp
expr expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c *expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr2 expr1 expr2 expr1 PowerOp
std::ostream & operator<<(std::ostream &os, const GeneralFad< T, Storage > &x)
SACADO_INLINE_FUNCTION bool toBool(const Expr< T > &xx)