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.

Namespaces

namespace  Sacado
namespace  Sacado::Tay
namespace  std

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 >

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.


Generated on Wed May 12 21:39:44 2010 for Sacado Package Browser (Single Doxygen Collection) by  doxygen 1.4.7