Sacado Package Browser (Single Doxygen Collection) Version of the Day
Classes | Namespaces | Defines | Functions
Sacado_Tay_CacheTaylorOps.hpp File Reference
#include "Sacado_Tay_CacheTaylorExpr.hpp"
#include <cmath>
#include <valarray>
#include <algorithm>
#include <ostream>
#include "Sacado_mpl_disable_if.hpp"
#include "Sacado_mpl_is_same.hpp"
Include dependency graph for Sacado_Tay_CacheTaylorOps.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  Sacado::Tay::UnaryPlusOp< ExprT >
class  Sacado::Tay::UnaryMinusOp< ExprT >
class  Sacado::Tay::ExpOp< ExprT >
class  Sacado::Tay::LogOp< ExprT >
class  Sacado::Tay::SqrtOp< ExprT >
class  Sacado::Tay::CosOp< ExprT >
class  Sacado::Tay::SinOp< ExprT >
class  Sacado::Tay::CoshOp< ExprT >
class  Sacado::Tay::SinhOp< ExprT >
class  Sacado::Tay::FAbsOp< ExprT >
class  Sacado::Tay::AdditionOp< ExprT1, ExprT2 >
class  Sacado::Tay::AdditionOp< ExprT1, ConstExpr< typename ExprT1::value_type > >
class  Sacado::Tay::AdditionOp< ConstExpr< typename ExprT2::value_type >, ExprT2 >
class  Sacado::Tay::SubtractionOp< ExprT1, ExprT2 >
class  Sacado::Tay::SubtractionOp< ExprT1, ConstExpr< typename ExprT1::value_type > >
class  Sacado::Tay::SubtractionOp< ConstExpr< typename ExprT2::value_type >, ExprT2 >
class  Sacado::Tay::MultiplicationOp< ExprT1, ExprT2 >
class  Sacado::Tay::MultiplicationOp< ExprT1, ConstExpr< typename ExprT1::value_type > >
class  Sacado::Tay::MultiplicationOp< ConstExpr< typename ExprT2::value_type >, ExprT2 >
class  Sacado::Tay::DivisionOp< ExprT1, ExprT2 >
class  Sacado::Tay::DivisionOp< ExprT1, ConstExpr< typename ExprT1::value_type > >
class  Sacado::Tay::DivisionOp< ConstExpr< typename ExprT2::value_type >, ExprT2 >
class  Sacado::Tay::MaxOp< ExprT1, ExprT2 >
class  Sacado::Tay::MaxOp< ExprT1, ConstExpr< typename ExprT1::value_type > >
class  Sacado::Tay::MaxOp< ConstExpr< typename ExprT2::value_type >, ExprT2 >
class  Sacado::Tay::MinOp< ExprT1, ExprT2 >
class  Sacado::Tay::MinOp< ExprT1, ConstExpr< typename ExprT1::value_type > >
class  Sacado::Tay::MinOp< ConstExpr< typename ExprT2::value_type >, ExprT2 >
class  Sacado::Tay::ASinQuadOp< ExprT1, ExprT2 >
class  Sacado::Tay::ACosQuadOp< ExprT1, ExprT2 >
class  Sacado::Tay::ATanQuadOp< ExprT1, ExprT2 >
struct  Sacado::Tay::PowExprType< ExprT1, ExprT2 >
struct  Sacado::Tay::PowExprType< typename ExprT2::value_type, ExprT2 >
struct  Sacado::Tay::PowExprType< ExprT1, typename ExprT1::value_type >
struct  Sacado::Tay::Log10ExprType< T >
struct  Sacado::Tay::TanExprType< T >
struct  Sacado::Tay::ASinExprType< T >
struct  Sacado::Tay::ACosExprType< T >
struct  Sacado::Tay::ATanExprType< T >
struct  Sacado::Tay::TanhExprType< T >

Namespaces

namespace  Sacado
 

Abstract class that provides access to a parameter value in a code for the parameter library. An object of this type is required to construct a ParameterRegistration object.


namespace  Sacado::Tay
 

Namespace for Taylor polynomial AD classes.


namespace  std

Defines

#define TAYLOR_UNARYOP_MACRO(OPNAME, OP)
#define TAYLOR_BINARYOP_MACRO(OPNAME, OP)
#define TAYLOR_SFINAE_BINARYOP_MACRO(OPNAME, OP)
#define TAYLOR_RELOP_MACRO(OP)

Functions

template<typename T1 , typename T2 >
Expr< BinaryExpr< Expr< T1 >
, Expr< T2 >, ASinQuadOp > > 
Sacado::Tay::asin_quad (const Expr< T1 > &expr1, const Expr< T2 > &expr2)
template<typename T1 , typename T2 >
Expr< BinaryExpr< Expr< T1 >
, Expr< T2 >, ACosQuadOp > > 
Sacado::Tay::acos_quad (const Expr< T1 > &expr1, const Expr< T2 > &expr2)
template<typename T1 , typename T2 >
Expr< BinaryExpr< Expr< T1 >
, Expr< T2 >, ATanQuadOp > > 
Sacado::Tay::atan_quad (const Expr< T1 > &expr1, const Expr< T2 > &expr2)
template<typename T1 , typename T2 >
PowExprType< Expr< T1 >, Expr
< T2 > >::expr_type 
Sacado::Tay::pow (const Expr< T1 > &expr1, const Expr< T2 > &expr2)
template<typename T >
PowExprType< typename Expr< T >
::value_type, Expr< T >
>::expr_type 
Sacado::Tay::pow (const typename Expr< T >::value_type &c, const Expr< T > &expr)
template<typename T >
PowExprType< Expr< T >
, typename Expr< T >
::value_type >::expr_type 
Sacado::Tay::pow (const Expr< T > &expr, const typename Expr< T >::value_type &c)
template<typename T >
Log10ExprType< T >::expr_type Sacado::Tay::log10 (const Expr< T > &expr)
template<typename T >
TanExprType< T >::expr_type Sacado::Tay::tan (const Expr< T > &expr)
template<typename T >
ASinExprType< T >::expr_type Sacado::Tay::asin (const Expr< T > &expr)
template<typename T >
ACosExprType< T >::expr_type Sacado::Tay::acos (const Expr< T > &expr)
template<typename T >
ATanExprType< T >::expr_type Sacado::Tay::atan (const Expr< T > &expr)
template<typename T >
TanhExprType< T >::expr_type Sacado::Tay::tanh (const Expr< T > &expr)
template<typename ExprT >
bool Sacado::Tay::operator! (const Expr< ExprT > &expr)
template<typename ExprT >
std::ostream & Sacado::Tay::operator<< (std::ostream &os, const Expr< ExprT > &x)

Define Documentation

#define TAYLOR_UNARYOP_MACRO (   OPNAME,
  OP 
)
Value:
namespace Sacado {              \
  namespace Tay {             \
    template <typename T>           \
    inline Expr< UnaryExpr< Expr<T>, OP > >       \
    OPNAME (const Expr<T>& expr)          \
    {                 \
      typedef UnaryExpr< Expr<T>, OP > expr_t;        \
                        \
      return Expr<expr_t>(expr_t(expr));        \
    }                 \
  }                 \
}                                                                       \
                                                                        \
namespace std {                                                         \
  using Sacado::Tay::OPNAME;                                            \
}

Definition at line 576 of file Sacado_Tay_CacheTaylorOps.hpp.

#define TAYLOR_BINARYOP_MACRO (   OPNAME,
  OP 
)

Definition at line 1434 of file Sacado_Tay_CacheTaylorOps.hpp.

#define TAYLOR_SFINAE_BINARYOP_MACRO (   OPNAME,
  OP 
)

Definition at line 1487 of file Sacado_Tay_CacheTaylorOps.hpp.

#define TAYLOR_RELOP_MACRO (   OP)
Value:
namespace Sacado {              \
  namespace Tay {             \
    template <typename ExprT1, typename ExprT2>       \
    inline bool               \
    operator OP (const Expr<ExprT1>& expr1,       \
     const Expr<ExprT2>& expr2)       \
    {                 \
      return expr1.fastAccessCoeff(0) OP expr2.fastAccessCoeff(0);  \
    }                 \
                  \
    template <typename ExprT2>            \
    inline bool               \
    operator OP (const typename Expr<ExprT2>::value_type& a,    \
     const Expr<ExprT2>& expr2)       \
    {                 \
      return a OP expr2.fastAccessCoeff(0);       \
    }                 \
                  \
    template <typename ExprT1>            \
    inline bool               \
    operator OP (const Expr<ExprT1>& expr1,       \
     const typename Expr<ExprT1>::value_type& b)    \
    {                 \
      return expr1.fastAccessCoeff(0) OP b;       \
    }                 \
  }                 \
}

Definition at line 1752 of file Sacado_Tay_CacheTaylorOps.hpp.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines