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

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

Classes

class  ArrayTraits
 
struct  ArrayValueType
 
class  BLAS
 Fad specializations for Teuchos::BLAS wrappers. More...
 
struct  ArrayValueType< Sacado::Fad::DFad< ValueT > >
 
struct  ArrayValueType< Sacado::Fad::SFad< ValueT, Num > >
 
struct  ArrayValueType< Sacado::Fad::SLFad< ValueT, Num > >
 
struct  ArrayValueType< Sacado::Fad::DVFad< ValueT > >
 
struct  ArrayValueType< Sacado::ELRFad::DFad< ValueT > >
 
struct  ArrayValueType< Sacado::ELRFad::SFad< ValueT, Num > >
 
struct  ArrayValueType< Sacado::ELRFad::SLFad< ValueT, Num > >
 
struct  ArrayValueType< Sacado::CacheFad::DFad< ValueT > >
 
class  DFad
 
class  DVFad
 Forward-mode AD class using dynamic memory allocation and expression templates. More...
 
struct  BaseExpr< GeneralFad< T, Fad::VectorDynamicStorage< T > > >
 
struct  ExprLevel< DVFad< T > >
 
struct  IsFadExpr< DVFad< T > >
 
class  DynamicStorage
 Derivative array storage class using dynamic memory allocation. More...
 
struct  BaseExpr
 Meta-function for determining concrete base expression. More...
 
struct  ExprSpecDefault
 
struct  ExprSpec
 
class  Expr
 Wrapper for a generic expression template. More...
 
struct  ExprSpec< Expr< ExprT, Spec > >
 
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...
 
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  Fad_LAPACK
 Fad specializations for Teuchos::LAPACK wrappers. More...
 
class  UnaryPlusOp
 
struct  ExprSpec< UnaryPlusOp< ExprT > >
 
class  Expr< UnaryPlusOp< ExprT >, ExprSpecDefault >
 
class  UnaryMinusOp
 
struct  ExprSpec< UnaryMinusOp< ExprT > >
 
class  Expr< UnaryMinusOp< ExprT >, ExprSpecDefault >
 
class  ExpOp
 
struct  ExprSpec< ExpOp< ExprT > >
 
class  Expr< ExpOp< ExprT >, ExprSpecDefault >
 
class  LogOp
 
struct  ExprSpec< LogOp< ExprT > >
 
class  Expr< LogOp< ExprT >, ExprSpecDefault >
 
class  Log10Op
 
struct  ExprSpec< Log10Op< ExprT > >
 
class  Expr< Log10Op< ExprT >, ExprSpecDefault >
 
class  SqrtOp
 
struct  ExprSpec< SqrtOp< ExprT > >
 
class  Expr< SqrtOp< ExprT >, ExprSpecDefault >
 
class  CosOp
 
struct  ExprSpec< CosOp< ExprT > >
 
class  Expr< CosOp< ExprT >, ExprSpecDefault >
 
class  SinOp
 
struct  ExprSpec< SinOp< ExprT > >
 
class  Expr< SinOp< ExprT >, ExprSpecDefault >
 
class  TanOp
 
struct  ExprSpec< TanOp< ExprT > >
 
class  Expr< TanOp< ExprT >, ExprSpecDefault >
 
class  ACosOp
 
struct  ExprSpec< ACosOp< ExprT > >
 
class  Expr< ACosOp< ExprT >, ExprSpecDefault >
 
class  ASinOp
 
struct  ExprSpec< ASinOp< ExprT > >
 
class  Expr< ASinOp< ExprT >, ExprSpecDefault >
 
class  ATanOp
 
struct  ExprSpec< ATanOp< ExprT > >
 
class  Expr< ATanOp< ExprT >, ExprSpecDefault >
 
class  CoshOp
 
struct  ExprSpec< CoshOp< ExprT > >
 
class  Expr< CoshOp< ExprT >, ExprSpecDefault >
 
class  SinhOp
 
struct  ExprSpec< SinhOp< ExprT > >
 
class  Expr< SinhOp< ExprT >, ExprSpecDefault >
 
class  TanhOp
 
struct  ExprSpec< TanhOp< ExprT > >
 
class  Expr< TanhOp< ExprT >, ExprSpecDefault >
 
class  ACoshOp
 
struct  ExprSpec< ACoshOp< ExprT > >
 
class  Expr< ACoshOp< ExprT >, ExprSpecDefault >
 
class  ASinhOp
 
struct  ExprSpec< ASinhOp< ExprT > >
 
class  Expr< ASinhOp< ExprT >, ExprSpecDefault >
 
class  ATanhOp
 
struct  ExprSpec< ATanhOp< ExprT > >
 
class  Expr< ATanhOp< ExprT >, ExprSpecDefault >
 
class  AbsOp
 
struct  ExprSpec< AbsOp< ExprT > >
 
class  Expr< AbsOp< ExprT >, ExprSpecDefault >
 
class  FAbsOp
 
struct  ExprSpec< FAbsOp< ExprT > >
 
class  Expr< FAbsOp< ExprT >, ExprSpecDefault >
 
class  SafeSqrtOp
 
struct  ExprSpec< SafeSqrtOp< ExprT > >
 
class  Expr< SafeSqrtOp< ExprT, true >, ExprSpecDefault >
 
class  Expr< SafeSqrtOp< ExprT, false >, ExprSpecDefault >
 
class  AdditionOp
 
struct  ExprSpec< AdditionOp< ExprT1, ExprT2 > >
 
class  Expr< AdditionOp< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< AdditionOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< AdditionOp< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< AdditionOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< AdditionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  SubtractionOp
 
struct  ExprSpec< SubtractionOp< ExprT1, ExprT2 > >
 
class  Expr< SubtractionOp< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< SubtractionOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< SubtractionOp< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< SubtractionOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< SubtractionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  DivisionOp
 
struct  ExprSpec< DivisionOp< ExprT1, ExprT2 > >
 
class  Expr< DivisionOp< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< DivisionOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< DivisionOp< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< DivisionOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< DivisionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  Atan2Op
 
struct  ExprSpec< Atan2Op< ExprT1, ExprT2 > >
 
class  Expr< Atan2Op< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< Atan2Op< ExprT1, ConstExpr< T2 > > >
 
class  Expr< Atan2Op< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< Atan2Op< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< Atan2Op< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  MaxOp
 
struct  ExprSpec< MaxOp< ExprT1, ExprT2 > >
 
class  Expr< MaxOp< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< MaxOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< MaxOp< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< MaxOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< MaxOp< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  MinOp
 
struct  ExprSpec< MinOp< ExprT1, ExprT2 > >
 
class  Expr< MinOp< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< MinOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< MinOp< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< MinOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< MinOp< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  MultiplicationOp
 
struct  ExprSpec< MultiplicationOp< ExprT1, ExprT2 > >
 
class  Expr< MultiplicationOp< ExprT1, ExprT2 >, ExprSpecDefault >
 
struct  ExprSpec< MultiplicationOp< ExprT1, ConstExpr< T2 > > >
 
class  Expr< MultiplicationOp< ExprT1, ConstExpr< T2 > >, ExprSpecDefault >
 
struct  ExprSpec< MultiplicationOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< MultiplicationOp< ConstExpr< T1 >, ExprT2 >, ExprSpecDefault >
 
class  PowerOp
 
struct  ExprSpec< PowerOp< ExprT1, ExprT2 > >
 
struct  ExprSpec< PowerOp< ExprT1, ConstExpr< T2 > > >
 
struct  ExprSpec< PowerOp< ConstExpr< T1 >, ExprT2 > >
 
class  Expr< PowerOp< ExprT1, ExprT2, PowerImpl::Simd >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ConstExpr< T2 >, PowerImpl::Simd >, ExprSpecDefault >
 
class  Expr< PowerOp< ConstExpr< T1 >, ExprT2, PowerImpl::Simd >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ExprT2, PowerImpl::Scalar >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ConstExpr< T2 >, PowerImpl::Scalar >, ExprSpecDefault >
 
class  Expr< PowerOp< ConstExpr< T1 >, ExprT2, PowerImpl::Scalar >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ExprT2, PowerImpl::Nested >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ConstExpr< T2 >, PowerImpl::Nested >, ExprSpecDefault >
 
class  Expr< PowerOp< ConstExpr< T1 >, ExprT2, PowerImpl::Nested >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ExprT2, PowerImpl::NestedSimd >, ExprSpecDefault >
 
class  Expr< PowerOp< ExprT1, ConstExpr< T2 >, PowerImpl::NestedSimd >, ExprSpecDefault >
 
class  Expr< PowerOp< ConstExpr< T1 >, ExprT2, PowerImpl::NestedSimd >, ExprSpecDefault >
 
class  Multiplicationp
 
struct  SFadExprTag
 A tag for specializing Expr for SFad expressions. More...
 
class  SFad
 
class  Expr< SFadExprTag< T, Num >, ExprSpecDefault >
 Expression template forward-mode AD class with static memory allocation. More...
 
class  SimpleFad
 Forward-mode AD class using dynamic memory allocation but no expression templates. More...
 
class  SLFad
 
class  StaticStorage
 Derivative array storage class using static memory allocation. More...
 
class  Vector
 A class for storing a contiguously allocated array of Fad objects. This is a general definition that will work for all Fad types, and is merely a wrapper around std::vector. A specialization for Sacado::Fad::DVFad providing contiguous allocation of values and derivatives is below. More...
 
class  Vector< OrdinalType, Sacado::Fad::DVFad< ValueType > >
 A class for storing a contiguously allocated array of Fad objects where the values and derivative arrays for each Fad object are stored in contiguous memory. To preserve this structure, many vector operations aren't supported (like resizing). More...
 
class  VectorDynamicStorage
 Derivative array storage class using dynamic memory allocation. More...
 
class  ViewFad
 
class  ViewStorage
 Derivative array storage class that is a view into a contiguous memory allocation. It does not provide proper value semantics and thus should not be used in a general-purpose scalar type. More...
 

Enumerations

enum  VectorDerivOrientation { Row, Column }
 

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 T >
Expr< SafeSqrtOp< Expr< T > > > safe_sqrt (const Expr< T > &expr)
 
template<typename T1 , typename T2 >
mpl::enable_if_c< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< AdditionOp< Expr< T1 >, Expr
< T2 > > > >::type 
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< 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< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< SubtractionOp< Expr< T1 >
, Expr< T2 > > > >::type 
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< 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< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< DivisionOp< Expr< T1 >, Expr
< T2 > > > >::type 
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< 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< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< Atan2Op< Expr< T1 >, Expr
< T2 > > > >::type 
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< 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< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< MaxOp< Expr< T1 >, Expr< T2 >
> > >::type 
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< 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< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< MinOp< Expr< T1 >, Expr< T2 >
> > >::type 
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< 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 T1 , typename T2 >
mpl::enable_if_c< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< MultiplicationOp< Expr< T1 >
, Expr< T2 > > > >::type 
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
< 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< ExprLevel
< Expr< T1 > >::value==ExprLevel
< Expr< T2 > >::value, Expr
< PowerOp< Expr< T1 >, Expr
< T2 > > > >::type 
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< 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 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)
 
template<typename ValueT >
SimpleFad< ValueT > operator+ (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > operator- (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > exp (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > log (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > log10 (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > sqrt (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > cos (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > sin (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > tan (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > acos (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > asin (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > atan (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > cosh (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > sinh (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > tanh (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > acosh (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > asinh (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > atanh (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > abs (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > fabs (const SimpleFad< ValueT > &a)
 
template<typename ValueT >
SimpleFad< ValueT > operator+ (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator+ (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator+ (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator- (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator- (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator- (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator* (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator* (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator* (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator/ (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator/ (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > operator/ (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > pow (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > pow (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > pow (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > atan2 (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > atan2 (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > atan2 (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > max (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > max (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > max (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
SimpleFad< ValueT > min (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > min (const typename SimpleFad< ValueT >::value_type &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
SimpleFad< ValueT > min (const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
 
template<typename ValueT >
bool operator== (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator== (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator== (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator!= (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator!= (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator!= (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator< (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator< (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator< (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator> (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator> (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator> (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator<= (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator<= (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator<= (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator>= (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator>= (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator>= (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator<<= (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator<<= (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator<<= (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator>>= (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator>>= (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator>>= (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator& (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator& (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator& (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator| (const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator| (const ValueT &a, const SimpleFad< ValueT > &b)
 
template<typename ValueT >
bool operator| (const SimpleFad< ValueT > &a, const ValueT &b)
 
template<typename ValueT >
bool operator! (const SimpleFad< ValueT > &a)
 
template<typename T >
bool toBool (const SimpleFad< T > &x)
 
template<typename T1 , typename T2 >
bool operator&& (const SimpleFad< T1 > &expr1, const SimpleFad< T2 > &expr2)
 
template<typename T2 >
bool operator&& (const typename SimpleFad< T2 >::value_type &a, const SimpleFad< T2 > &expr2)
 
template<typename T1 >
bool operator&& (const SimpleFad< T1 > &expr1, const typename SimpleFad< T1 >::value_type &b)
 
template<typename T1 , typename T2 >
bool operator|| (const SimpleFad< T1 > &expr1, const SimpleFad< T2 > &expr2)
 
template<typename T2 >
bool operator|| (const typename SimpleFad< T2 >::value_type &a, const SimpleFad< T2 > &expr2)
 
template<typename T1 >
bool operator|| (const SimpleFad< T1 > &expr1, const typename SimpleFad< T1 >::value_type &b)
 
template<typename ValueT >
std::ostream & operator<< (std::ostream &os, const SimpleFad< ValueT > &x)
 
template<typename T >
SimpleFad< T > exp (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > log (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > log10 (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > sqrt (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > cos (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > sin (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > tan (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > acos (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > asin (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > atan (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > cosh (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > sinh (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > tanh (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > acosh (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > asinh (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > atanh (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > abs (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > fabs (const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > atan2 (const SimpleFad< T > &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > atan2 (const SimpleFad< T > &, const typename SimpleFad< T >::value_type &)
 
template<typename T >
SimpleFad< T > atan2 (const typename SimpleFad< T >::value_type &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > pow (const SimpleFad< T > &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > pow (const SimpleFad< T > &, const typename SimpleFad< T >::value_type &)
 
template<typename T >
SimpleFad< T > pow (const typename SimpleFad< T >::value_type &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > max (const SimpleFad< T > &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > max (const SimpleFad< T > &, const typename SimpleFad< T >::value_type &)
 
template<typename T >
SimpleFad< T > max (const typename SimpleFad< T >::value_type &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > min (const SimpleFad< T > &, const SimpleFad< T > &)
 
template<typename T >
SimpleFad< T > min (const SimpleFad< T > &, const typename SimpleFad< T >::value_type &)
 
template<typename T >
SimpleFad< T > min (const typename SimpleFad< T >::value_type &, const SimpleFad< T > &)
 

Detailed Description

Namespace for forward-mode AD classes.

Enumeration Type Documentation

Enumerator
Column 

Derivatives are stored row-wise (strided)

Derivatives ar stored column-wise (unit stride)