Sacado  Development
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Pages
Classes | Functions
Sacado::ELRFad Namespace Reference

Namespace for expression-level reverse forward-mode AD classes. More...

Classes

class  DFad
 
struct  BaseExpr
 Meta-function for determining concrete base expression. More...
 
class  Expr
 Wrapper for a generic expression template. More...
 
struct  ExprLevel
 Meta-function for determining nesting with an expression. More...
 
struct  ExprLevel< Expr< T > >
 
struct  IsFadExpr
 Determine whether a given type is an expression. More...
 
struct  IsFadExpr< Expr< T > >
 
class  ConstExpr
 Constant expression template. More...
 
struct  ExprConstRef
 
struct  ExprConstRef< ConstExpr< T > >
 
class  GeneralFad
 Forward-mode AD class templated on the storage for the derivative array. More...
 
class  Expr< GeneralFad< T, Storage > >
 GeneralFad expression template specialization. More...
 
class  UnaryPlusOp
 
class  Expr< UnaryPlusOp< ExprT > >
 
class  UnaryMinusOp
 
class  Expr< UnaryMinusOp< ExprT > >
 
class  ExpOp
 
class  Expr< ExpOp< ExprT > >
 
class  LogOp
 
class  Expr< LogOp< ExprT > >
 
class  Log10Op
 
class  Expr< Log10Op< ExprT > >
 
class  SqrtOp
 
class  Expr< SqrtOp< ExprT > >
 
class  SafeSqrtOp
 
class  Expr< SafeSqrtOp< ExprT > >
 
class  CosOp
 
class  Expr< CosOp< ExprT > >
 
class  SinOp
 
class  Expr< SinOp< ExprT > >
 
class  TanOp
 
class  Expr< TanOp< ExprT > >
 
class  ACosOp
 
class  Expr< ACosOp< ExprT > >
 
class  ASinOp
 
class  Expr< ASinOp< ExprT > >
 
class  ATanOp
 
class  Expr< ATanOp< ExprT > >
 
class  CoshOp
 
class  Expr< CoshOp< ExprT > >
 
class  SinhOp
 
class  Expr< SinhOp< ExprT > >
 
class  TanhOp
 
class  Expr< TanhOp< ExprT > >
 
class  ACoshOp
 
class  Expr< ACoshOp< ExprT > >
 
class  ASinhOp
 
class  Expr< ASinhOp< ExprT > >
 
class  ATanhOp
 
class  Expr< ATanhOp< ExprT > >
 
class  AbsOp
 
class  Expr< AbsOp< ExprT > >
 
class  FAbsOp
 
class  Expr< FAbsOp< ExprT > >
 
class  AdditionOp
 
class  Expr< AdditionOp< ExprT1, ExprT2 > >
 
class  Expr< AdditionOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< AdditionOp< ConstExpr< T1 >, ExprT2 > >
 
class  SubtractionOp
 
class  Expr< SubtractionOp< ExprT1, ExprT2 > >
 
class  Expr< SubtractionOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< SubtractionOp< ConstExpr< T1 >, ExprT2 > >
 
class  MultiplicationOp
 
class  Expr< MultiplicationOp< ExprT1, ExprT2 > >
 
class  Expr< MultiplicationOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< MultiplicationOp< ConstExpr< T1 >, ExprT2 > >
 
class  DivisionOp
 
class  Expr< DivisionOp< ExprT1, ExprT2 > >
 
class  Expr< DivisionOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< DivisionOp< ConstExpr< T1 >, ExprT2 > >
 
class  Atan2Op
 
class  Expr< Atan2Op< ExprT1, ExprT2 > >
 
class  Expr< Atan2Op< ExprT1, ConstExpr< T2 > > >
 
class  Expr< Atan2Op< ConstExpr< T1 >, ExprT2 > >
 
class  PowerOp
 
class  Expr< PowerOp< ExprT1, ExprT2 > >
 
class  Expr< PowerOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< PowerOp< ConstExpr< T1 >, ExprT2 > >
 
class  MaxOp
 
class  Expr< MaxOp< ExprT1, ExprT2 > >
 
class  Expr< MaxOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< MaxOp< ConstExpr< T1 >, ExprT2 > >
 
class  MinOp
 
class  Expr< MinOp< ExprT1, ExprT2 > >
 
class  Expr< MinOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< MinOp< ConstExpr< T1 >, ExprT2 > >
 
struct  SFadExprTag
 A tag for specializing Expr for SFad expressions. More...
 
class  SFad
 
class  Expr< SFadExprTag< T, Num > >
 Expression template forward-mode AD class with static memory allocation. More...
 
class  SLFad
 
class  ViewFad
 

Functions

template<typename T , typename Storage >
std::ostream & operator<< (std::ostream &os, const GeneralFad< T, Storage > &x)
 
template<typename T >
Expr< UnaryPlusOp< Expr< T > > > operator+ (const Expr< T > &expr)
 
template<typename T >
Expr< UnaryMinusOp< Expr< T > > > operator- (const Expr< T > &expr)
 
template<typename T >
Expr< ExpOp< Expr< T > > > exp (const Expr< T > &expr)
 
template<typename T >
Expr< LogOp< Expr< T > > > log (const Expr< T > &expr)
 
template<typename T >
Expr< Log10Op< Expr< T > > > log10 (const Expr< T > &expr)
 
template<typename T >
Expr< SqrtOp< Expr< T > > > sqrt (const Expr< T > &expr)
 
template<typename T >
Expr< SafeSqrtOp< Expr< T > > > safe_sqrt (const Expr< T > &expr)
 
template<typename T >
Expr< CosOp< Expr< T > > > cos (const Expr< T > &expr)
 
template<typename T >
Expr< SinOp< Expr< T > > > sin (const Expr< T > &expr)
 
template<typename T >
Expr< TanOp< Expr< T > > > tan (const Expr< T > &expr)
 
template<typename T >
Expr< ACosOp< Expr< T > > > acos (const Expr< T > &expr)
 
template<typename T >
Expr< ASinOp< Expr< T > > > asin (const Expr< T > &expr)
 
template<typename T >
Expr< ATanOp< Expr< T > > > atan (const Expr< T > &expr)
 
template<typename T >
Expr< CoshOp< Expr< T > > > cosh (const Expr< T > &expr)
 
template<typename T >
Expr< SinhOp< Expr< T > > > sinh (const Expr< T > &expr)
 
template<typename T >
Expr< TanhOp< Expr< T > > > tanh (const Expr< T > &expr)
 
template<typename T >
Expr< ACoshOp< Expr< T > > > acosh (const Expr< T > &expr)
 
template<typename T >
Expr< ASinhOp< Expr< T > > > asinh (const Expr< T > &expr)
 
template<typename T >
Expr< ATanhOp< Expr< T > > > atanh (const Expr< T > &expr)
 
template<typename T >
Expr< AbsOp< Expr< T > > > abs (const Expr< T > &expr)
 
template<typename T >
Expr< FAbsOp< Expr< T > > > fabs (const Expr< T > &expr)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< AdditionOp< T1,
T2 > > >::type 
operator+ (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< AdditionOp< Expr< T >
, Expr< T > > > 
operator+ (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< AdditionOp< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
operator+ (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< AdditionOp< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
operator+ (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< AdditionOp< ConstExpr
< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
operator+ (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< AdditionOp< Expr< T >
, ConstExpr< typename Expr< T >
::scalar_type > > > >::type 
operator+ (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< SubtractionOp
< T1, T2 > > >::type 
operator- (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< SubtractionOp< Expr< T >
, Expr< T > > > 
operator- (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< SubtractionOp< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
operator- (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< SubtractionOp< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
operator- (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< SubtractionOp< ConstExpr
< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
operator- (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< SubtractionOp< Expr< T >
, ConstExpr< typename Expr< T >
::scalar_type > > > >::type 
operator- (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr
< MultiplicationOp< T1, T2 >
> >::type 
operator* (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< MultiplicationOp< Expr
< T >, Expr< T > > > 
operator* (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< MultiplicationOp
< ConstExpr< typename Expr< T >
::value_type >, Expr< T > > > 
operator* (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< MultiplicationOp< Expr
< T >, ConstExpr< typename
Expr< T >::value_type > > > 
operator* (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< MultiplicationOp< ConstExpr
< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
operator* (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< MultiplicationOp< Expr< T >
, ConstExpr< typename Expr< T >
::scalar_type > > > >::type 
operator* (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< DivisionOp< T1,
T2 > > >::type 
operator/ (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< DivisionOp< Expr< T >
, Expr< T > > > 
operator/ (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< DivisionOp< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
operator/ (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< DivisionOp< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
operator/ (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< DivisionOp< ConstExpr
< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
operator/ (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr
< DivisionOp< Expr< T >
, ConstExpr< typename Expr< T >
::scalar_type > > > >::type 
operator/ (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< Atan2Op< T1, T2 >
> >::type 
atan2 (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< Atan2Op< Expr< T >, Expr
< T > > > 
atan2 (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< Atan2Op< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
atan2 (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< Atan2Op< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
atan2 (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< Atan2Op
< ConstExpr< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
atan2 (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< Atan2Op
< Expr< T >, ConstExpr
< typename Expr< T >
::scalar_type > > > >::type 
atan2 (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< PowerOp< T1, T2 >
> >::type 
pow (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< PowerOp< Expr< T >, Expr
< T > > > 
pow (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< PowerOp< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
pow (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< PowerOp< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
pow (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< PowerOp
< ConstExpr< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
pow (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< PowerOp
< Expr< T >, ConstExpr
< typename Expr< T >
::scalar_type > > > >::type 
pow (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< MaxOp< T1, T2 >
> >::type 
max (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< MaxOp< Expr< T >, Expr
< T > > > 
max (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< MaxOp< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
max (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< MaxOp< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
max (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< MaxOp
< ConstExpr< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
max (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< MaxOp
< Expr< T >, ConstExpr
< typename Expr< T >
::scalar_type > > > >::type 
max (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< IsFadExpr
< T1 >::value &&IsFadExpr< T2 >
::value &&ExprLevel< T1 >
::value==ExprLevel< T2 >
::value, Expr< MinOp< T1, T2 >
> >::type 
min (const T1 &expr1, const T2 &expr2)
 
template<typename T >
Expr< MinOp< Expr< T >, Expr
< T > > > 
min (const Expr< T > &expr1, const Expr< T > &expr2)
 
template<typename T >
Expr< MinOp< ConstExpr
< typename Expr< T >
::value_type >, Expr< T > > > 
min (const typename Expr< T >::value_type &c, const Expr< T > &expr)
 
template<typename T >
Expr< MinOp< Expr< T >
, ConstExpr< typename Expr< T >
::value_type > > > 
min (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< MinOp
< ConstExpr< typename Expr< T >
::scalar_type >, Expr< T >
> > >::type 
min (const typename Expr< T >::scalar_type &c, const Expr< T > &expr)
 
template<typename T >
mpl::disable_if< mpl::is_same
< typename Expr< T >
::value_type, typename Expr< T >
::scalar_type >, Expr< MinOp
< Expr< T >, ConstExpr
< typename Expr< T >
::scalar_type > > > >::type 
min (const Expr< T > &expr, const typename Expr< T >::scalar_type &c)
 
template<typename ExprT1 , typename ExprT2 >
bool operator== (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator== (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator== (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator!= (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator!= (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator!= (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator< (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator< (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator< (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator> (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator> (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator> (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator<= (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator<= (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator<= (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator>= (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator>= (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator>= (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator<<= (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator<<= (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator<<= (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator>>= (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator>>= (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator>>= (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator& (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator& (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator& (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator| (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator| (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator| (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT >
bool operator! (const Expr< ExprT > &expr)
 
template<typename ExprT >
bool toBool (const Expr< ExprT > &x)
 
template<typename ExprT1 , typename ExprT2 >
bool operator&& (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator&& (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator&& (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT1 , typename ExprT2 >
bool operator|| (const Expr< ExprT1 > &expr1, const Expr< ExprT2 > &expr2)
 
template<typename ExprT2 >
bool operator|| (const typename Expr< ExprT2 >::value_type &a, const Expr< ExprT2 > &expr2)
 
template<typename ExprT1 >
bool operator|| (const Expr< ExprT1 > &expr1, const typename Expr< ExprT1 >::value_type &b)
 
template<typename ExprT >
std::ostream & operator<< (std::ostream &os, const Expr< ExprT > &x)
 

Detailed Description

Namespace for expression-level reverse forward-mode AD classes.