CppAD: A C++ Algorithmic Differentiation Package  20171217
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
declare_ad.hpp
Go to the documentation of this file.
1 # ifndef CPPAD_LOCAL_DECLARE_AD_HPP
2 # define CPPAD_LOCAL_DECLARE_AD_HPP
3 
4 /* --------------------------------------------------------------------------
5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
6 
7 CppAD is distributed under multiple licenses. This distribution is under
8 the terms of the
9  Eclipse Public License Version 1.0.
10 
11 A copy of this license is included in the COPYING file of this distribution.
12 Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13 -------------------------------------------------------------------------- */
14 
15 # include <cppad/configure.hpp>
16 # if CPPAD_USE_CPLUSPLUS_2011
17 # include <cstdint>
18 # endif
19 
20 /*!
21 \file declare_ad.hpp CppAD forward declarations; i.e., before definition
22 */
23 
24 namespace CppAD { namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
25 
26 template <class Base> class ADTape;
27 template <class Base> class player;
28 template <class Base> class recorder;
29 
30 } } // END_CPPAD_LOCAL_NAMESPACE
31 
32 namespace CppAD {
33  // The conditional expression operator enum type
34  enum CompareOp
35  { CompareLt, // less than
36  CompareLe, // less than or equal
37  CompareEq, // equal
38  CompareGe, // greater than or equal
39  CompareGt, // greater than
40  CompareNe // not equal
41  };
42 
43  // simple typedefs
44  typedef CPPAD_TAPE_ADDR_TYPE addr_t;
45  typedef CPPAD_TAPE_ID_TYPE tape_id_t;
46 
47  // classes
48  class sparse_hes_work;
49  class sparse_jac_work;
51  class sparse_hessian_work;
52  template <class Base> class AD;
53  template <class Base> class ADFun;
54  template <class Base> class atomic_base;
55  template <class Base> class discrete;
56  template <class Base> class VecAD;
57  template <class Base> class VecAD_reference;
58 
59  // functions with one VecAD<Base> argument
60  template <class Base> bool Parameter (const VecAD<Base> &u);
61  template <class Base> bool Variable (const VecAD<Base> &u);
62 
63  // functions with one AD<Base> argument
64  template <class Base> int Integer (const AD<Base> &u);
65  template <class Base> bool Parameter (const AD<Base> &u);
66  template <class Base> bool Variable (const AD<Base> &u);
67  template <class Base> bool IdenticalZero (const AD<Base> &u);
68  template <class Base> bool IdenticalOne (const AD<Base> &u);
69  template <class Base> bool IdenticalPar (const AD<Base> &u);
70  template <class Base> bool LessThanZero (const AD<Base> &u);
71  template <class Base> bool LessThanOrZero (const AD<Base> &u);
72  template <class Base> bool GreaterThanZero (const AD<Base> &u);
73  template <class Base> bool GreaterThanOrZero (const AD<Base> &u);
74  template <class Base> AD<Base> Var2Par (const AD<Base> &u);
75  template <class Base> AD<Base> abs (const AD<Base> &u);
76  template <class Base> AD<Base> acos (const AD<Base> &u);
77  template <class Base> AD<Base> asin (const AD<Base> &u);
78  template <class Base> AD<Base> atan (const AD<Base> &u);
79  template <class Base> AD<Base> cos (const AD<Base> &u);
80  template <class Base> AD<Base> cosh (const AD<Base> &u);
81  template <class Base> AD<Base> exp (const AD<Base> &u);
82  template <class Base> AD<Base> log (const AD<Base> &u);
83  template <class Base> AD<Base> log10 (const AD<Base> &u);
84  template <class Base> AD<Base> sin (const AD<Base> &u);
85  template <class Base> AD<Base> sinh (const AD<Base> &u);
86  template <class Base> AD<Base> sqrt (const AD<Base> &u);
87  template <class Base> AD<Base> tan (const AD<Base> &u);
88 
89  // arithematic operators
90  template <class Base> AD<Base> operator + (
91  const AD<Base> &left, const AD<Base> &right);
92  template <class Base> AD<Base> operator - (
93  const AD<Base> &left, const AD<Base> &right);
94  template <class Base> AD<Base> operator * (
95  const AD<Base> &left, const AD<Base> &right);
96  template <class Base> AD<Base> operator / (
97  const AD<Base> &left, const AD<Base> &right);
98 
99  // comparison operators
100  template <class Base> bool operator < (
101  const AD<Base> &left, const AD<Base> &right);
102  template <class Base> bool operator <= (
103  const AD<Base> &left, const AD<Base> &right);
104  template <class Base> bool operator > (
105  const AD<Base> &left, const AD<Base> &right);
106  template <class Base> bool operator >= (
107  const AD<Base> &left, const AD<Base> &right);
108  template <class Base> bool operator == (
109  const AD<Base> &left, const AD<Base> &right);
110  template <class Base> bool operator != (
111  const AD<Base> &left, const AD<Base> &right);
112 
113  // pow
114  template <class Base> AD<Base> pow (
115  const AD<Base> &x, const AD<Base> &y);
116 
117  // azmul
118  template <class Base> AD<Base> azmul (
119  const AD<Base> &x, const AD<Base> &y);
120 
121  // NearEqual
122  template <class Base> bool NearEqual(
123  const AD<Base> &x, const AD<Base> &y, const Base &r, const Base &a);
124 
125  template <class Base> bool NearEqual(
126  const Base &x, const AD<Base> &y, const Base &r, const Base &a);
127 
128  template <class Base> bool NearEqual(
129  const AD<Base> &x, const Base &y, const Base &r, const Base &a);
130 
131  // CondExpOp
132  template <class Base> AD<Base> CondExpOp (
133  enum CompareOp cop ,
134  const AD<Base> &left ,
135  const AD<Base> &right ,
136  const AD<Base> &trueCase ,
137  const AD<Base> &falseCase
138  );
139 
140  // IdenticalEqualPar
141  template <class Base>
142  bool IdenticalEqualPar (const AD<Base> &u, const AD<Base> &v);
143 
144  // EqualOpSeq
145  template <class Base>
146  bool EqualOpSeq (const AD<Base> &u, const AD<Base> &v);
147 
148  // PrintFor
149  template <class Base>
150  void PrintFor(
151  const AD<Base>& flag ,
152  const char* before ,
153  const AD<Base>& var ,
154  const char* after
155  );
156 
157  // Value
158  template <class Base> Base Value(const AD<Base> &x);
159 
160  // Pow function
161  template <class Base> AD<Base> pow
162  (const AD<Base> &x, const AD<Base> &y);
163 
164  // input operator
165  template <class Base> std::istream&
166  operator >> (std::istream &is, AD<Base> &x);
167 
168  // output operator
169  template <class Base> std::ostream&
170  operator << (std::ostream &os, const AD<Base> &x);
171  template <class Base> std::ostream&
172  operator << (std::ostream &os, const VecAD_reference<Base> &e);
173  template <class Base> std::ostream&
174  operator << (std::ostream &os, const VecAD<Base> &vec);
175 }
176 
177 # endif
AD< Base > cosh(const AD< Base > &x)
class used by SparseHessian to hold information so it does not need to be recomputed.
AD< Base > azmul(const AD< Base > &x, const AD< Base > &y)
Definition: azmul.hpp:94
Class used to hold function objects.
Definition: ad_fun.hpp:69
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool operator>(const AD< Base > &left, const AD< Base > &right)
Definition: compare.hpp:230
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION AD< Base > Var2Par(const AD< Base > &x)
Definition: var2par.hpp:75
CPPAD_TAPE_ADDR_TYPE addr_t
Definition: declare_ad.hpp:44
AD< Base > log(const AD< Base > &x)
Definition: ad.hpp:34
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool operator==(const AD< Base > &left, const AD< Base > &right)
Definition: compare.hpp:332
std::complex< double > atan(const std::complex< double > &x)
AD< Base > sinh(const AD< Base > &x)
Class used to store and play back an operation sequence recording.
Definition: declare_ad.hpp:27
bool GreaterThanOrZero(const std::complex< double > &x)
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION Base Value(const AD< Base > &x)
Definition: value.hpp:82
AD< Base > abs(const AD< Base > &x)
Definition: abs.hpp:105
std::complex< double > acos(const std::complex< double > &x)
bool IdenticalPar(const std::complex< double > &x)
AD< Base > tan(const AD< Base > &x)
bool EqualOpSeq(const std::complex< double > &x, const std::complex< double > &y)
void PrintFor(const AD< Base > &pos, const char *before, const AD< Base > &var, const char *after)
Definition: print_for.hpp:137
bool IdenticalZero(const std::complex< double > &x)
AD< Base > exp(const AD< Base > &x)
AD< Base > log10(const AD< Base > &x)
Compute the log of base 10 of x where has type AD&lt;Base&gt;
Class used to store an operation sequence while it is being recorded (the operation sequence is copie...
Definition: declare_ad.hpp:28
AD< Base > operator*(const AD< Base > &left, const AD< Base > &right)
Definition: mul.hpp:20
AD< Base > operator-(const AD< Base > &left, const AD< Base > &right)
Definition: sub.hpp:20
Type pow(const Type &x, const int &n)
Definition: pow_int.hpp:116
bool LessThanOrZero(const std::complex< double > &x)
AD< Base > sqrt(const AD< Base > &x)
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool Variable(const AD< Base > &x)
Definition: par_var.hpp:99
class used by SparseJacobian to hold information so it does not need to be recomputed.
bool NearEqual(const Type &x, const Type &y, const Type &r, const Type &a)
Definition: near_equal.hpp:168
Class used to hold information used by Sparse Hessian routine in this file, so it does not need to be...
Definition: sparse_hes.hpp:246
AD< Base > sin(const AD< Base > &x)
bool IdenticalEqualPar(const std::complex< double > &x, const std::complex< double > &y)
AD< Base > cos(const AD< Base > &x)
bool IdenticalOne(const std::complex< double > &x)
Class used to hold information used by Sparse Jacobian routines in this file, so they do not need to ...
Definition: sparse_jac.hpp:221
std::complex< double > asin(const std::complex< double > &x)
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool operator<=(const AD< Base > &left, const AD< Base > &right)
Definition: compare.hpp:179
int Integer(const std::complex< double > &x)
bool LessThanZero(const std::complex< double > &x)
Class used to hold a reference to an element of a VecAD object.
Definition: vec_ad.hpp:352
AD< Base > operator+(const AD< Base > &left, const AD< Base > &right)
Definition: add.hpp:20
Vector of AD objects that tracks indexing operations on the tape.
Definition: vec_ad.hpp:462
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool Parameter(const AD< Base > &x)
Definition: par_var.hpp:80
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool operator!=(const AD< Base > &left, const AD< Base > &right)
Definition: compare.hpp:374
std::complex< double > CondExpOp(enum CppAD::CompareOp cop, const std::complex< double > &left, const std::complex< double > &right, const std::complex< double > &trueCase, const std::complex< double > &falseCase)
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool operator>=(const AD< Base > &left, const AD< Base > &right)
Definition: compare.hpp:281
AD< Base > operator/(const AD< Base > &left, const AD< Base > &right)
Definition: div.hpp:20
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION std::istream & operator>>(std::istream &is, AD< Base > &x)
Read an AD&lt;Base&gt; object from an input stream.
Definition: ad_io.hpp:179
bool GreaterThanZero(const std::complex< double > &x)
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool operator<(const AD< Base > &left, const AD< Base > &right)
Definition: compare.hpp:128
CPPAD_TAPE_ID_TYPE tape_id_t
Definition: declare_ad.hpp:45