Prev Next

Enable use of AD<Base> where Base is Adolc's adouble Type

Syntax
This file in located in the example directory. It can be copied into the current working directory and included with the command:
     # include "base_adolc.hpp"

Example
The file mul_level_adolc.cpp contains an example use of Adolc's adouble type for a CppAD Base type. It returns true if it succeeds and false otherwise. The file ode_taylor_adolc.cpp contains a more realistic (and complex) example.

Include File
This file is included before <cppad/cppad.hpp> so it is necessary to define the error handler in addition to including declare.hpp
# include <cppad/declare.hpp>
# include <cppad/error_handler.hpp>

abs
The abs function is called fabs in the Adolc package.
namespace CppAD {
     inline adouble abs(const adouble &x)    \
     {    return fabs(x); }
}

Standard Math Functions Defined by Adolc Package
The following required functions are defined by the Adolc package:
acos, asin, atan, cos, cosh, erf, exp, log, pow, sin, sinh, sqrt, tan.

CondExpOp
The type adouble supports a conditional assignment function with the syntax
     condassign(
abcd)
which evaluates to
     
a = (b > 0) ? c : d;
This enables one to include conditionals in the recording of adouble operations and later evaluation for different values of the independent variables (in the same spirit as the CppAD CondExp function).
namespace CppAD {
     inline adouble CondExpOp(
          enum  CppAD::CompareOp     cop ,
          const adouble            &left ,
          const adouble           &right ,
          const adouble        &trueCase ,
          const adouble       &falseCase )
     {    adouble result;
          switch( cop )
          {
               case CompareLt: // left < right
               condassign(result, right - left, trueCase, falseCase);
               break;

               case CompareLe: // left <= right
               condassign(result, left - right, falseCase, trueCase);
               break;

               case CompareEq: // left == right
               condassign(result, left - right, falseCase, trueCase);
               condassign(result, right - left, falseCase, result);
               break;

               case CompareGe: // left >= right
               condassign(result, right - left, falseCase, trueCase);
               break;

               case CompareGt: // left > right
               condassign(result, left - right, trueCase, falseCase);
               break;

               default:
               CppAD::ErrorHandler::Call(
                    true     , __LINE__ , __FILE__ ,
                    "CppAD::CondExp",
                    "Error: for unknown reason."
               );
               result = trueCase;
          }
          return result;
     }
}

EqualOpSeq
The Adolc user interface does not specify a way to determine if two adouble variables correspond to the same operations sequence. Make EqualOpSeq an error if it gets used:
namespace CppAD {
     inline bool EqualOpSeq(const adouble &x, const adouble &y)
     {    CppAD::ErrorHandler::Call(
               true     , __LINE__ , __FILE__ ,
               "CppAD::EqualOpSeq(x, y)",
               "Error: adouble does not support EqualOpSeq."
          );
          return false;
     }
}

Identical
The Adolc user interface does not specify a way to determine if an adouble depends on the independent variables. To be safe (but slow) return false in all the cases below.
namespace CppAD {
     inline bool IdenticalPar(const adouble &x)
     {    return false; }
     inline bool IdenticalZero(const adouble &x)
     {    return false; }
     inline bool IdenticalOne(const adouble &x)
     {    return false; }
     inline bool IdenticalEqualPar(const adouble &x, const adouble &y)
     {    return false; }
}

Ordered
     inline bool GreaterThanZero(const adouble &x)
     {    return (x > 0); }
     inline bool GreaterThanOrZero(const adouble &x)
     {    return (x >= 0); }
     inline bool LessThanZero(const adouble &x)
     {    return (x < 0); }
     inline bool LessThanOrZero(const adouble &x)
     {    return (x <= 0); }

Integer
     inline int Integer(const adouble &x)
     {    return static_cast<int>( x.value() ); }

Input File: example/base_adolc.hpp