\(\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}} }\)

check_numeric_type.cpp

View page source

The CheckNumericType Function: Example and Test

# include <cppad/utility/check_numeric_type.hpp>
# include <cppad/utility/near_equal.hpp>


// Chosing a value between 1 and 10 selects a numeric class properity to be
// omitted and result in an error message being generated
# define CppADMyTypeOmit 0

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 constuctor
      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; }
# if CppADMyTypeOmit != 1
      // unary plus
      MyType operator + (void) const
      {  MyType x;
         x.d =  d;
         return x;
      }
# endif
# if CppADMyTypeOmit != 2
      // unary plus
      MyType operator - (void) const
      {  MyType x;
         x.d = - d;
         return x;
      }
# endif
# if CppADMyTypeOmit != 3
      // binary addition
      MyType operator + (const MyType &x) const
      {  MyType y;
         y.d = d + x.d ;
         return y;
      }
# endif
# if CppADMyTypeOmit != 4
      // binary subtraction
      MyType operator - (const MyType &x) const
      {  MyType y;
         y.d = d - x.d ;
         return y;
      }
# endif
# if CppADMyTypeOmit != 5
      // binary multiplication
      MyType operator * (const MyType &x) const
      {  MyType y;
         y.d = d * x.d ;
         return y;
      }
# endif
# if CppADMyTypeOmit != 6
      // binary division
      MyType operator / (const MyType &x) const
      {  MyType y;
         y.d = d / x.d ;
         return y;
      }
# endif
# if CppADMyTypeOmit != 7
      // compound assignment addition
      void operator += (const MyType &x)
      {  d += x.d; }
# endif
# if CppADMyTypeOmit != 8
      // compound assignment subtraction
      void operator -= (const MyType &x)
      {  d -= x.d; }
# endif
# if CppADMyTypeOmit != 9
      // compound assignment multiplication
      void operator *= (const MyType &x)
      {  d *= x.d; }
# endif
# if CppADMyTypeOmit != 10
      // compound assignment division
      void operator /= (const MyType &x)
      {  d /= x.d; }
# endif
   };
   // -------------------------------------------------------------------
   /*
   Solve: A[0] * x[0] + A[1] * x[1] = b[0]
           A[2] * x[0] + A[3] * x[1] = b[1]
   */
   template <class NumericType>
   void Solve(NumericType *A, NumericType *x, NumericType *b)
   {
      // make sure NumericType satisfies its conditions
      CppAD::CheckNumericType<NumericType>();

      // copy b to x
      x[0] = b[0];
      x[1] = b[1];

      // copy A to work space
      NumericType W[4];
      W[0] = A[0];
      W[1] = A[1];
      W[2] = A[2];
      W[3] = A[3];

      // divide first row by W(1,1)
      W[1] /= W[0];
      x[0] /= W[0];
      W[0] = NumericType(1);

      // subtract W(2,1) times first row from second row
      W[3] -= W[2] * W[1];
      x[1] -= W[2] * x[0];
      W[2] = NumericType(0);

      // divide second row by W(2, 2)
      x[1] /= W[3];
      W[3]  = NumericType(1);

      // use first row to solve for x[0]
      x[0] -= W[1] * x[1];
   }
} // End Empty namespace

bool CheckNumericType(void)
{  bool ok  = true;
   using CppAD::NearEqual;
   double eps99 = 99.0 * std::numeric_limits<double>::epsilon();

   MyType A[4];
   A[0] = MyType(1); A[1] = MyType(2);
   A[2] = MyType(3); A[3] = MyType(4);

   MyType b[2];
   b[0] = MyType(1);
   b[1] = MyType(2);

   MyType x[2];
   Solve(A, x, b);

   MyType sum;
   sum = A[0] * x[0] + A[1] * x[1];
   ok &= NearEqual(sum.Double(), b[0].Double(), eps99, eps99);

   sum = A[2] * x[0] + A[3] * x[1];
   ok &= NearEqual(sum.Double(), b[1].Double(), eps99, eps99);

   return ok;
}