CppAD: A C++ Algorithmic Differentiation Package 20110419
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-11 Bradley M. Bell
00007 
00008 CppAD is distributed under multiple licenses. This distribution is under
00009 the terms of the 
00010                     Common 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         // classes
00018         template <class Base> class AD;
00019         template <class Base> class ADFun;
00020         template <class Base> class ADTape;
00021         template <class Base> class discrete;
00022         template <class Base> class player;
00023         template <class Base> class recorder;
00024         template <class Base> class user_atomic;
00025         template <class Base> class VecAD;
00026         template <class Base> class VecAD_reference;
00027 
00028         // functions with one VecAD<Base> argument
00029         template <class Base> bool Parameter         (const VecAD<Base> &u);
00030         template <class Base> bool Variable          (const VecAD<Base> &u);
00031         
00032         // functions with one AD<Base> argument
00033         template <class Base> int  Integer           (const AD<Base> &u);
00034         template <class Base> bool Parameter         (const AD<Base> &u);
00035         template <class Base> bool Variable          (const AD<Base> &u);
00036         template <class Base> bool IdenticalZero     (const AD<Base> &u);
00037         template <class Base> bool IdenticalOne      (const AD<Base> &u);
00038         template <class Base> bool IdenticalPar      (const AD<Base> &u);
00039         template <class Base> bool LessThanZero      (const AD<Base> &u);
00040         template <class Base> bool LessThanOrZero    (const AD<Base> &u);
00041         template <class Base> bool GreaterThanZero   (const AD<Base> &u);
00042         template <class Base> bool GreaterThanOrZero (const AD<Base> &u);
00043         template <class Base> AD<Base> Var2Par       (const AD<Base> &u);
00044         template <class Base> AD<Base> abs           (const AD<Base> &u);
00045         template <class Base> AD<Base> acos          (const AD<Base> &u);
00046         template <class Base> AD<Base> asin          (const AD<Base> &u);
00047         template <class Base> AD<Base> atan          (const AD<Base> &u);
00048         template <class Base> AD<Base> cos           (const AD<Base> &u);
00049         template <class Base> AD<Base> cosh          (const AD<Base> &u);
00050         template <class Base> AD<Base> exp           (const AD<Base> &u);
00051         template <class Base> AD<Base> log           (const AD<Base> &u);
00052         template <class Base> AD<Base> log10         (const AD<Base> &u);
00053         template <class Base> AD<Base> sin           (const AD<Base> &u);
00054         template <class Base> AD<Base> sinh          (const AD<Base> &u);
00055         template <class Base> AD<Base> sqrt          (const AD<Base> &u);
00056         template <class Base> AD<Base> tan           (const AD<Base> &u);
00057 
00058         // arithematic operators
00059         template <class Base> AD<Base> operator + (
00060                 const AD<Base> &left, const AD<Base> &right);
00061         template <class Base> AD<Base> operator - (
00062                 const AD<Base> &left, const AD<Base> &right);
00063         template <class Base> AD<Base> operator * (
00064                 const AD<Base> &left, const AD<Base> &right);
00065         template <class Base> AD<Base> operator / (
00066                 const AD<Base> &left, const AD<Base> &right);
00067 
00068         // comparison operators
00069         template <class Base> bool operator < (
00070                 const AD<Base> &left, const AD<Base> &right);
00071         template <class Base> bool operator <= (
00072                 const AD<Base> &left, const AD<Base> &right);
00073         template <class Base> bool operator > (
00074                 const AD<Base> &left, const AD<Base> &right);
00075         template <class Base> bool operator >= (
00076                 const AD<Base> &left, const AD<Base> &right);
00077         template <class Base> bool operator == (
00078                 const AD<Base> &left, const AD<Base> &right);
00079         template <class Base> bool operator != (
00080                 const AD<Base> &left, const AD<Base> &right);
00081 
00082         // pow
00083         template <class Base> AD<Base> pow (
00084                 const AD<Base> &x, const AD<Base> &y);
00085 
00086         // NearEqual
00087         template <class Base> bool NearEqual(
00088         const AD<Base> &x, const AD<Base> &y, const Base &r, const Base &a);
00089 
00090         template <class Base> bool NearEqual(
00091         const Base &x, const AD<Base> &y, const Base &r, const Base &a);
00092 
00093         template <class Base> bool NearEqual(
00094         const AD<Base> &x, const Base &y, const Base &r, const Base &a);
00095         
00096         // CondExpOp
00097         template <class Base> AD<Base> CondExpOp (
00098                 enum CompareOp         cop ,
00099                 const AD<Base>       &left , 
00100                 const AD<Base>      &right , 
00101                 const AD<Base>   &trueCase , 
00102                 const AD<Base>  &falseCase 
00103         );
00104         
00105         // IdenticalEqualPar
00106         template <class Base> 
00107         bool IdenticalEqualPar (const AD<Base> &u, const AD<Base> &v);
00108         
00109         // EqualOpSeq
00110         template <class Base> 
00111         bool EqualOpSeq (const AD<Base> &u, const AD<Base> &v);
00112         
00113         // PrintFor
00114         template <class Base>
00115         void PrintFor(const char *text, const AD<Base> &x);
00116 
00117         // Value
00118         template <class Base> Base Value(const AD<Base> &x);
00119 
00120         // Pow function
00121         template <class Base> AD<Base> pow
00122                 (const AD<Base> &x, const AD<Base> &y);
00123 
00124         // output operator
00125         template <class Base> std::ostream&
00126         operator << (std::ostream &os, const AD<Base> &x);
00127         template <class Base> std::ostream&
00128         operator << (std::ostream &os, const VecAD_reference<Base> &e);
00129         template <class Base> std::ostream&
00130         operator << (std::ostream &os, const VecAD<Base> &vec);
00131 }
00132 
00133 # endif