\(\newcommand{\W}[1]{ \; #1 \; }\) \(\newcommand{\R}[1]{ {\rm #1} }\) \(\newcommand{\B}[1]{ {\bf #1} }\) \(\newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} }\) \(\newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} }\) \(\newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} }\) \(\newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }\)

numeric_type.cpp

View page source

The NumericType: Example and Test

# include <cppad/cppad.hpp>

namespace { // Empty namespace

   // -------------------------------------------------------------------
   class MyType {
   private:
      double d;
   public:
      // constructor from void
      MyType(void) : d(0.)
      { }
      // constructor from an int
      MyType(int d_) : d(d_)
      { }
      // copy constructor
      MyType(const MyType &x)
      {  d = x.d; }
      // assignment operator
      void operator = (const MyType &x)
      {  d = x.d; }
      // member function that converts to double
      double Double(void) const
      {  return d; }
      // unary plus
      MyType operator + (void) const
      {  MyType x;
         x.d =  d;
         return x;
      }
      // unary plus
      MyType operator - (void) const
      {  MyType x;
         x.d = - d;
         return x;
      }
      // binary addition
      MyType operator + (const MyType &x) const
      {  MyType y;
         y.d = d + x.d ;
         return y;
      }
      // binary subtraction
      MyType operator - (const MyType &x) const
      {  MyType y;
         y.d = d - x.d ;
         return y;
      }
      // binary multiplication
      MyType operator * (const MyType &x) const
      {  MyType y;
         y.d = d * x.d ;
         return y;
      }
      // binary division
      MyType operator / (const MyType &x) const
      {  MyType y;
         y.d = d / x.d ;
         return y;
      }
      // compound assignment addition
      void operator += (const MyType &x)
      {  d += x.d; }
      // compound assignment subtraction
      void operator -= (const MyType &x)
      {  d -= x.d; }
      // compound assignment multiplication
      void operator *= (const MyType &x)
      {  d *= x.d; }
      // compound assignment division
      void operator /= (const MyType &x)
      {  d /= x.d; }
   };
}
bool NumericType(void)
{  bool ok  = true;
   using CppAD::AD;
   using CppAD::CheckNumericType;

   CheckNumericType<MyType>            ();

   CheckNumericType<int>               ();
   CheckNumericType<double>            ();
   CheckNumericType< AD<double> >      ();
   CheckNumericType< AD< AD<double> > >();

   return ok;
}