base_double.hpp

Enable use of AD<Base> where Base is double

CondExpOp

The type double is a relatively simple type that supports < , <= , == , >= , and > operators; see Ordered Type . Hence its CondExpOp function is defined by

namespace CppAD {
   inline double CondExpOp(
      enum CompareOp     cop          ,
      const double&       left         ,
      const double&       right        ,
      const double&       exp_if_true  ,
      const double&       exp_if_false )
   {  return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
   }
}

CondExpRel

The CPPAD_COND_EXP_REL macro invocation

namespace CppAD {
   CPPAD_COND_EXP_REL(double)
}

uses CondExpOp above to define CondExp Rel for double arguments and Rel equal to Lt , Le , Eq , Ge , and Gt .

EqualOpSeq

The type double is simple (in this respect) and so we define

namespace CppAD {
   inline bool EqualOpSeq(const double& x, const double& y)
   {  return x == y; }
}

Identical

The type double is simple (in this respect) and so we define

namespace CppAD {
   inline bool IdenticalCon(const double& x)
   {  return true; }
   inline bool IdenticalZero(const double& x)
   {  return (x == 0.); }
   inline bool IdenticalOne(const double& x)
   {  return (x == 1.); }
   inline bool IdenticalEqualCon(const double& x, const double& y)
   {  return (x == y); }
}

Integer

namespace CppAD {
   inline int Integer(const double& x)
   {  return static_cast<int>(x); }
}

azmul

namespace CppAD {
   CPPAD_AZMUL( double )
}

Ordered

The double type supports ordered comparisons

namespace CppAD {
   inline bool GreaterThanZero(const double& x)
   {  return x > 0.; }
   inline bool GreaterThanOrZero(const double& x)
   {  return x >= 0.; }
   inline bool LessThanZero(const double& x)
   {  return x < 0.; }
   inline bool LessThanOrZero(const double& x)
   {  return x <= 0.; }
   inline bool abs_geq(const double& x, const double& y)
   {  return std::fabs(x) >= std::fabs(y); }
}

Unary Standard Math

The following macro invocations import the double versions of the unary standard math functions into the CppAD namespace. Importing avoids ambiguity errors when using both the CppAD and std namespaces. Note this also defines the float versions of these functions.

namespace CppAD {
   using std::acos;
   using std::asin;
   using std::atan;
   using std::cos;
   using std::cosh;
   using std::exp;
   using std::fabs;
   using std::log;
   using std::log10;
   using std::sin;
   using std::sinh;
   using std::sqrt;
   using std::tan;
   using std::tanh;
   using std::asinh;
   using std::acosh;
   using std::atanh;
   using std::erf;
   using std::erfc;
   using std::expm1;
   using std::log1p;
}

The absolute value function is special because its std name is fabs

namespace CppAD {
   inline double abs(const double& x)
   {  return std::fabs(x); }
}

sign

The following defines the CppAD::sign function that is required to use AD<double> :

namespace CppAD {
   inline double sign(const double& x)
   {  if( x > 0. )
         return 1.;
      if( x == 0. )
         return 0.;
      return -1.;
   }
}

pow

The following defines a CppAD::pow function that is required to use AD<double> . As with the unary standard math functions, this has the exact same signature as std::pow , so use it instead of defining another function.

namespace CppAD {
   using std::pow;
}

numeric_limits

The following defines the CppAD numeric_limits for the type double :

namespace CppAD {
   CPPAD_NUMERIC_LIMITS(double, double)
}

to_string

There is no need to define to_string for double because it is defined by including cppad/utility/to_string.hpp ; see to_string . See base_complex.hpp for an example where it is necessary to define to_string for a Base type.