Sacado Development
Loading...
Searching...
No Matches
Classes | Functions
Sacado::LFad Namespace Reference

Namespace for logical forward-mode AD classes. More...

Classes

class  AbsOp
 
class  ACoshOp
 
class  ACosOp
 
class  AdditionOp
 
class  ASinhOp
 
class  ASinOp
 
class  Atan2Op
 
class  ATanhOp
 
class  ATanOp
 
class  CoshOp
 
class  CosOp
 
class  DivisionOp
 
class  ExpOp
 
class  Expr
 Wrapper for a generic expression template. More...
 
class  Expr< AbsOp< ExprT > >
 
class  Expr< ACoshOp< ExprT > >
 
class  Expr< ACosOp< ExprT > >
 
class  Expr< AdditionOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< AdditionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< AdditionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< ASinhOp< ExprT > >
 
class  Expr< ASinOp< ExprT > >
 
class  Expr< Atan2Op< Expr< T1 >, Expr< T2 > > >
 
class  Expr< Atan2Op< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< Atan2Op< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< ATanhOp< ExprT > >
 
class  Expr< ATanOp< ExprT > >
 
class  Expr< CoshOp< ExprT > >
 
class  Expr< CosOp< ExprT > >
 
class  Expr< DivisionOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< ExpOp< ExprT > >
 
class  Expr< FAbsOp< ExprT > >
 
class  Expr< Log10Op< ExprT > >
 
class  Expr< LogicalSparseImp< ValT, LogT > >
 Expression template specialization for LogicalSparse. More...
 
class  Expr< LogOp< ExprT > >
 
class  Expr< MaxOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< MaxOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< MaxOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< MinOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< MinOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< MinOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< PowerOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< PowerOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< PowerOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< SinhOp< ExprT > >
 
class  Expr< SinOp< ExprT > >
 
class  Expr< SqrtOp< ExprT > >
 
class  Expr< SubtractionOp< Expr< T1 >, Expr< T2 > > >
 
class  Expr< SubtractionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 
class  Expr< SubtractionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 
class  Expr< TanhOp< ExprT > >
 
class  Expr< TanOp< ExprT > >
 
class  Expr< UnaryMinusOp< ExprT > >
 
class  Expr< UnaryPlusOp< ExprT > >
 
struct  ExprLevel
 Meta-function for determining nesting with an expression. More...
 
struct  ExprLevel< Expr< T > >
 
struct  ExprLevel< LogicalSparse< T, L > >
 
class  FAbsOp
 
struct  IsFadExpr
 Determine whether a given type is an expression. More...
 
struct  IsFadExpr< Expr< T > >
 
class  Log10Op
 
class  LogicalSparse
 User inteface class for computing the logical sparsity pattern of a derivative via forward-mode AD. More...
 
class  LogicalSparseImp
 Implementation class for computing the logical sparsity of a derivative using forward-mode AD. More...
 
class  LogOp
 
class  MaxOp
 
class  MinOp
 
class  MultiplicationOp
 
class  PowerOp
 
class  SinhOp
 
class  SinOp
 
class  SqrtOp
 
class  SubtractionOp
 
class  TanhOp
 
class  TanOp
 
class  UnaryMinusOp
 
class  UnaryPlusOp
 

Functions

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< 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 >
Expr< AdditionOp< Expr< T1 >, Expr< T2 > > > operator+ (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > operator+ (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< SubtractionOp< Expr< T1 >, Expr< T2 > > > operator- (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > operator- (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > > operator* (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > operator* (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< DivisionOp< Expr< T1 >, Expr< T2 > > > operator/ (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > operator/ (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< Atan2Op< Expr< T1 >, Expr< T2 > > > atan2 (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > atan2 (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< PowerOp< Expr< T1 >, Expr< T2 > > > pow (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > pow (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< MaxOp< Expr< T1 >, Expr< T2 > > > max (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > max (const Expr< T > &expr, const typename Expr< T >::value_type &c)
 
template<typename T1 , typename T2 >
Expr< MinOp< Expr< T1 >, Expr< T2 > > > min (const Expr< T1 > &expr1, const Expr< 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< 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 >, typename Expr< T >::value_type > > min (const Expr< T > &expr, const typename Expr< T >::value_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 logical forward-mode AD classes.