CppAD: A C++ Algorithmic Differentiation Package  20130102
declare_ad.hpp
Go to the documentation of this file.
00001 /* $Id$ */
00002 # ifndef CPPAD_DECLARE_AD_INCLUDED
00003 # define CPPAD_DECLARE_AD_INCLUDED
00004 
00005 /* --------------------------------------------------------------------------
00006 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
00007 
00008 CppAD is distributed under multiple licenses. This distribution is under
00009 the terms of the 
00010                     Eclipse Public License Version 1.0.
00011 
00012 A copy of this license is included in the COPYING file of this distribution.
00013 Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
00014 -------------------------------------------------------------------------- */
00015 
00016 namespace CppAD {
00017      // The conditional expression operator enum type
00018      enum CompareOp 
00019      {    CompareLt, // less than
00020           CompareLe, // less than or equal
00021           CompareEq, // equal
00022           CompareGe, // greater than or equal
00023           CompareGt, // greater than
00024           CompareNe  // not equal
00025      };
00026 
00027      // simple typedefs
00028      typedef CPPAD_TAPE_ADDR_TYPE addr_t;
00029      typedef CPPAD_TAPE_ID_TYPE   tape_id_t;
00030 
00031      // classes
00032      class sparse_jacobian_work;
00033      class sparse_hessian_work;
00034      template <class Base> class AD;
00035      template <class Base> class ADFun;
00036      template <class Base> class ADTape;
00037      template <class Base> class discrete;
00038      template <class Base> class player;
00039      template <class Base> class recorder;
00040      template <class Base> class user_atomic;
00041      template <class Base> class VecAD;
00042      template <class Base> class VecAD_reference;
00043 
00044      // functions with one VecAD<Base> argument
00045      template <class Base> bool Parameter         (const VecAD<Base> &u);
00046      template <class Base> bool Variable          (const VecAD<Base> &u);
00047      
00048      // functions with one AD<Base> argument
00049      template <class Base> int  Integer           (const AD<Base> &u);
00050      template <class Base> bool Parameter         (const AD<Base> &u);
00051      template <class Base> bool Variable          (const AD<Base> &u);
00052      template <class Base> bool IdenticalZero     (const AD<Base> &u);
00053      template <class Base> bool IdenticalOne      (const AD<Base> &u);
00054      template <class Base> bool IdenticalPar      (const AD<Base> &u);
00055      template <class Base> bool LessThanZero      (const AD<Base> &u);
00056      template <class Base> bool LessThanOrZero    (const AD<Base> &u);
00057      template <class Base> bool GreaterThanZero   (const AD<Base> &u);
00058      template <class Base> bool GreaterThanOrZero (const AD<Base> &u);
00059      template <class Base> AD<Base> Var2Par       (const AD<Base> &u);
00060      template <class Base> AD<Base> abs           (const AD<Base> &u);
00061      template <class Base> AD<Base> acos          (const AD<Base> &u);
00062      template <class Base> AD<Base> asin          (const AD<Base> &u);
00063      template <class Base> AD<Base> atan          (const AD<Base> &u);
00064      template <class Base> AD<Base> cos           (const AD<Base> &u);
00065      template <class Base> AD<Base> cosh          (const AD<Base> &u);
00066      template <class Base> AD<Base> exp           (const AD<Base> &u);
00067      template <class Base> AD<Base> log           (const AD<Base> &u);
00068      template <class Base> AD<Base> log10         (const AD<Base> &u);
00069      template <class Base> AD<Base> sin           (const AD<Base> &u);
00070      template <class Base> AD<Base> sinh          (const AD<Base> &u);
00071      template <class Base> AD<Base> sqrt          (const AD<Base> &u);
00072      template <class Base> AD<Base> tan           (const AD<Base> &u);
00073 
00074      // arithematic operators
00075      template <class Base> AD<Base> operator + (
00076           const AD<Base> &left, const AD<Base> &right);
00077      template <class Base> AD<Base> operator - (
00078           const AD<Base> &left, const AD<Base> &right);
00079      template <class Base> AD<Base> operator * (
00080           const AD<Base> &left, const AD<Base> &right);
00081      template <class Base> AD<Base> operator / (
00082           const AD<Base> &left, const AD<Base> &right);
00083 
00084      // comparison operators
00085      template <class Base> bool operator < (
00086           const AD<Base> &left, const AD<Base> &right);
00087      template <class Base> bool operator <= (
00088           const AD<Base> &left, const AD<Base> &right);
00089      template <class Base> bool operator > (
00090           const AD<Base> &left, const AD<Base> &right);
00091      template <class Base> bool operator >= (
00092           const AD<Base> &left, const AD<Base> &right);
00093      template <class Base> bool operator == (
00094           const AD<Base> &left, const AD<Base> &right);
00095      template <class Base> bool operator != (
00096           const AD<Base> &left, const AD<Base> &right);
00097 
00098      // pow
00099      template <class Base> AD<Base> pow (
00100           const AD<Base> &x, const AD<Base> &y);
00101 
00102      // NearEqual
00103      template <class Base> bool NearEqual(
00104      const AD<Base> &x, const AD<Base> &y, const Base &r, const Base &a);
00105 
00106      template <class Base> bool NearEqual(
00107      const Base &x, const AD<Base> &y, const Base &r, const Base &a);
00108 
00109      template <class Base> bool NearEqual(
00110      const AD<Base> &x, const Base &y, const Base &r, const Base &a);
00111      
00112      // CondExpOp
00113      template <class Base> AD<Base> CondExpOp (
00114           enum CompareOp         cop ,
00115           const AD<Base>       &left , 
00116           const AD<Base>      &right , 
00117           const AD<Base>   &trueCase , 
00118           const AD<Base>  &falseCase 
00119      );
00120      
00121      // IdenticalEqualPar
00122      template <class Base> 
00123      bool IdenticalEqualPar (const AD<Base> &u, const AD<Base> &v);
00124      
00125      // EqualOpSeq
00126      template <class Base> 
00127      bool EqualOpSeq (const AD<Base> &u, const AD<Base> &v);
00128      
00129      // PrintFor
00130      template <class Base> 
00131      void PrintFor(
00132           const AD<Base>&    flag   ,
00133           const char*        before ,
00134           const AD<Base>&    var    , 
00135           const char*        after
00136      );
00137 
00138      // Value
00139      template <class Base> Base Value(const AD<Base> &x);
00140 
00141      // Pow function
00142      template <class Base> AD<Base> pow
00143           (const AD<Base> &x, const AD<Base> &y);
00144 
00145      // input operator
00146      template <class Base> std::istream&
00147           operator >> (std::istream &is, AD<Base> &x);
00148 
00149      // output operator
00150      template <class Base> std::ostream&
00151           operator << (std::ostream &os, const AD<Base> &x);
00152      template <class Base> std::ostream&
00153           operator << (std::ostream &os, const VecAD_reference<Base> &e);
00154      template <class Base> std::ostream&
00155           operator << (std::ostream &os, const VecAD<Base> &vec);
00156 }
00157 
00158 # endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines