#include "Sacado_ELRCacheFad_Expression.hpp"
#include "Sacado_cmath.hpp"
#include "Sacado_mpl_disable_if.hpp"
#include "Sacado_mpl_is_same.hpp"
#include <ostream>

Include dependency graph for Sacado_ELRCacheFad_Ops.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	Sacado::ELRCacheFad::UnaryPlusOp< ExprT >

class	Sacado::ELRCacheFad::Expr< UnaryPlusOp< ExprT > >

class	Sacado::ELRCacheFad::UnaryMinusOp< ExprT >

class	Sacado::ELRCacheFad::Expr< UnaryMinusOp< ExprT > >

class	Sacado::ELRCacheFad::AbsOp< ExprT >

class	Sacado::ELRCacheFad::Expr< AbsOp< ExprT > >

class	Sacado::ELRCacheFad::FAbsOp< ExprT >

class	Sacado::ELRCacheFad::Expr< FAbsOp< ExprT > >

Namespaces
	Sacado

	Sacado::ELRCacheFad
	Namespace for expression-level reverse forward-mode AD classes.

Macros
#define	FAD_UNARYOP_MACRO(OPNAME, OP, PARTIAL, VALUE)

#define	FAD_BINARYOP_MACRO(OPNAME, OP)

#define	FAD_RELOP_MACRO(OP)

#define	FAD_BOOL_MACRO(OP)

Functions
template<typename T >
KOKKOS_INLINE_FUNCTION Expr < UnaryPlusOp< Expr< T > > >	Sacado::ELRCacheFad::operator+ (const Expr< T > &expr)

template<typename T >
KOKKOS_INLINE_FUNCTION Expr < UnaryMinusOp< Expr< T > > >	Sacado::ELRCacheFad::operator- (const Expr< T > &expr)

template<typename T >
KOKKOS_INLINE_FUNCTION Expr < AbsOp< Expr< T > > >	Sacado::ELRCacheFad::abs (const Expr< T > &expr)

template<typename T >
KOKKOS_INLINE_FUNCTION Expr < FAbsOp< Expr< T > > >	Sacado::ELRCacheFad::fabs (const Expr< T > &expr)

	FAD_UNARYOP_MACRO (exp, ExpOp, a=std::exp(v), a) FAD_UNARYOP_MACRO(log

template<typename ExprT >
KOKKOS_INLINE_FUNCTION bool	Sacado::ELRCacheFad::operator! (const Expr< ExprT > &expr)

template<typename ExprT >
KOKKOS_INLINE_FUNCTION bool	Sacado::ELRCacheFad::toBool (const Expr< ExprT > &x)

template<typename ExprT >
std::ostream &	Sacado::ELRCacheFad::operator<< (std::ostream &os, const Expr< ExprT > &x)

Variables
	LogOp

	a =scalar_type(1.0)/v

	Log10Op

	SqrtOp

	CosOp

	SinOp

	TanOp

	ACosOp

	ASinOp

	ATanOp

	CoshOp

	SinhOp

	TanhOp

	ACoshOp

	ASinhOp

	ATanhOp

Macro Definition Documentation

#define FAD_UNARYOP_MACRO	(	OPNAME,
		OP,
		PARTIAL,
		VALUE
	)

Definition at line 479 of file Sacado_ELRCacheFad_Ops.hpp.

#define FAD_BINARYOP_MACRO	(	OPNAME,
		OP
	)

Definition at line 3486 of file Sacado_ELRCacheFad_Ops.hpp.

#define FAD_RELOP_MACRO ( OP )

Definition at line 3576 of file Sacado_ELRCacheFad_Ops.hpp.

#define FAD_BOOL_MACRO ( OP )

Value:

namespace Sacado {                                                      \
  namespace ELRCacheFad {                                               \
    template <typename ExprT1, typename ExprT2>                         \
    KOKKOS_INLINE_FUNCTION                                              \
    bool                                                                \
    operator OP (const Expr<ExprT1>& expr1,                             \
                 const Expr<ExprT2>& expr2)                             \
    {                                                                   \
      return toBool(expr1) OP toBool(expr2);                            \
    }                                                                   \
                                                                        \
    template <typename ExprT2>                                          \
    KOKKOS_INLINE_FUNCTION                                              \
    bool                                                                \
    operator OP (const typename Expr<ExprT2>::value_type& a,            \
                 const Expr<ExprT2>& expr2)                             \
    {                                                                   \
      return a OP toBool(expr2);                                        \
    }                                                                   \
                                                                        \
    template <typename ExprT1>                                          \
    KOKKOS_INLINE_FUNCTION                                              \
    bool                                                                \
    operator OP (const Expr<ExprT1>& expr1,                             \
                 const typename Expr<ExprT1>::value_type& b)            \
    {                                                                   \
      return toBool(expr1) OP b;                                        \
    }                                                                   \
  }                                                                     \
}