source: branches/temp/cppad/local/define.hpp @ 3045

Last change on this file since 3045 was 3045, checked in by bradbell, 6 years ago

define.hpp: supress folding unary operators.

  • Property svn:keywords set to Id
File size: 17.5 KB
Line 
1/* $Id: define.hpp 3045 2013-12-26 16:29:40Z bradbell $ */
2# ifndef CPPAD_DEFINE_INCLUDED
3# define CPPAD_DEFINE_INCLUDED
4
5/* --------------------------------------------------------------------------
6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
7
8CppAD is distributed under multiple licenses. This distribution is under
9the terms of the
10                    Eclipse Public License Version 1.0.
11
12A copy of this license is included in the COPYING file of this distribution.
13Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
14-------------------------------------------------------------------------- */
15
16/*!
17\defgroup define_hpp define.hpp
18\{
19\file define.hpp
20Define processor symbols and macros that are used by CppAD.
21*/
22
23/*!
24\def CPPAD_OP_CODE_TYPE
25Is the type used to store enum OpCode values. If not the same as OpCode, then
26<code>sizeof(CPPAD_OP_CODE_TYPE) <= sizeof( enum OpCode )</code>
27to conserve memory.
28This type must support \c std::numeric_limits,
29the \c <= operator,
30and conversion to \c size_t.
31Make sure that the type chosen returns true for is_pod<CPPAD_OP_CODE_TYPE>
32in pod_vector.hpp.
33*/
34# define CPPAD_OP_CODE_TYPE unsigned char
35
36/*!
37\def CPPAD_USE_FORWARD0SWEEP
38If ture, use compute zero order sweeps using a specialized routine.
39
40The value of this define should be zero or one.
41If it is one, a specialized routine is used for zero order forward sweeps.
42Otherwise, use the general forward routine is used for zero order.
43Using the specialized routine is an optimization that makes the source
44more complicated and a significant speed improvement has not been
45verified (as yet).
46This preprocessor symbol makes it easier to compare these two options.
47*/
48# define CPPAD_USE_FORWARD0SWEEP 1
49
50/*!
51\def CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
52A version of the inline command that works with MC compiler.
53
54Microsoft Visual C++ version 9.0 generates a warning if a template
55function is declared as a friend
56(this was not a problem for version 7.0).
57The warning identifier is
58\verbatim
59        warning C4396
60\endverbatim
61and it contains the text
62\verbatim
63        the inline specifier cannot be used when a friend declaration refers
64        to a specialization of a function template
65\endverbatim
66This happens even if the function is not a specialization.
67This macro is defined as empty for Microsoft compilers.
68*/
69# ifdef _MSC_VER
70# define CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
71# else
72# define CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION inline
73# endif
74
75/*!
76\def CPPAD_NULL
77This preprocessor symbol is used for a null pointer.
78
79If it is not yet defined,
80it is defined when cppad/local/define.hpp is included.
81*/
82# ifndef CPPAD_NULL
83# if CPPAD_HAS_NULLPTR
84# define CPPAD_NULL     nullptr 
85# else
86# define CPPAD_NULL     0
87# endif
88# endif
89 
90/*!
91\def CPPAD_FOLD_ASSIGNMENT_OPERATOR(Op)
92Declares automatic coercion for certain AD assignment operations.
93
94This macro assumes that the operator
95\verbatim
96        left Op right
97\endverbatim
98is defined for the case where left and right have type AD<Base>.
99It uses this case to define the cases where
100left has type AD<Base> and right has type
101VecAD_reference<Base>,
102Base, or
103double.
104The argument right is const and call by reference.
105This macro converts the operands to AD<Base> and then
106uses the definition of the same operation for that case.
107*/
108
109# if 0
110# define CPPAD_FOLD_ASSIGNMENT_OPERATOR(Op)                             \
111/* ----------------------------------------------------------------*/   \
112template <class Base>                                                   \
113inline AD<Base>& operator Op                                            \
114(AD<Base> &left, double right)                                          \
115{       return left Op AD<Base>(right); }                                  \
116                                                                        \
117template <class Base>                                                   \
118inline AD<Base>& operator Op                                            \
119(AD<Base> &left, const Base &right)                                     \
120{       return left Op AD<Base>(right); }                                  \
121                                                                        \
122inline AD<double>& operator Op                                          \
123(AD<double> &left, const double &right)                                 \
124{       return left Op AD<double>(right); }                                \
125                                                                        \
126template <class Base>                                                   \
127inline AD<Base>& operator Op                                            \
128(AD<Base> &left, const VecAD_reference<Base> &right)                    \
129{       return left Op right.ADBase(); }
130# else
131# define CPPAD_FOLD_ASSIGNMENT_OPERATOR(Op)
132# endif
133
134// =====================================================================
135/*!
136\def CPPAD_FOLD_AD_VALUED_BINARY_OPERATOR(Op)
137Declares automatic coercion for certain binary operations with AD result.
138
139This macro assumes that the operator
140\verbatim
141        left Op right
142\endverbatim
143is defined for the case where left and right
144and the result of the operation all
145have type AD<Base>.
146It uses this case to define the cases either left
147or right has type VecAD_reference<Base> or AD<Base>
148and the type of the other operand is one of the following:
149VecAD_reference<Base>, AD<Base>, Base, double.
150All of the arguments are const and call by reference.
151This macro converts the operands to AD<Base> and then
152uses the definition of the same operation for that case.
153*/
154# define CPPAD_FOLD_AD_VALUED_BINARY_OPERATOR(Op)                      \
155/* ----------------------------------------------------------------*/  \
156/* Operations with VecAD_reference<Base> and AD<Base> only*/           \
157                                                                       \
158template <class Base>                                                  \
159inline AD<Base> operator Op                                            \
160(const AD<Base> &left, const VecAD_reference<Base> &right)             \
161{       return left Op right.ADBase(); }                                  \
162                                                                       \
163template <class Base>                                                  \
164inline AD<Base> operator Op                                            \
165(const VecAD_reference<Base> &left, const VecAD_reference<Base> &right)\
166{       return left.ADBase() Op right.ADBase(); }                         \
167                                                                       \
168template <class Base>                                                  \
169inline AD<Base> operator Op                                            \
170        (const VecAD_reference<Base> &left, const AD<Base> &right)        \
171{       return left.ADBase() Op right; }                                  \
172/* ----------------------------------------------------------------*/  \
173/* Operations Base */                                                  \
174                                                                       \
175template <class Base>                                                  \
176inline AD<Base> operator Op                                            \
177        (const Base &left, const AD<Base> &right)                         \
178{       return AD<Base>(left) Op right; }                                 \
179                                                                       \
180template <class Base>                                                  \
181inline AD<Base> operator Op                                            \
182        (const Base &left, const VecAD_reference<Base> &right)            \
183{       return AD<Base>(left) Op right.ADBase(); }                        \
184                                                                       \
185template <class Base>                                                  \
186inline AD<Base> operator Op                                            \
187        (const AD<Base> &left, const Base &right)                         \
188{       return left Op AD<Base>(right); }                                 \
189                                                                       \
190template <class Base>                                                  \
191inline AD<Base> operator Op                                            \
192        (const VecAD_reference<Base> &left, const Base &right)            \
193{       return left.ADBase() Op AD<Base>(right); }                        \
194                                                                       \
195/* ----------------------------------------------------------------*/  \
196/* Operations double */                                                \
197                                                                       \
198template <class Base>                                                  \
199inline AD<Base> operator Op                                            \
200        (const double &left, const AD<Base> &right)                       \
201{       return AD<Base>(left) Op right; }                                 \
202                                                                       \
203template <class Base>                                                  \
204inline AD<Base> operator Op                                            \
205        (const double &left, const VecAD_reference<Base> &right)          \
206{       return AD<Base>(left) Op right.ADBase(); }                        \
207                                                                       \
208template <class Base>                                                  \
209inline AD<Base> operator Op                                            \
210        (const AD<Base> &left, const double &right)                       \
211{       return left Op AD<Base>(right); }                                 \
212                                                                       \
213template <class Base>                                                  \
214inline AD<Base> operator Op                                            \
215        (const VecAD_reference<Base> &left, const double &right)          \
216{       return left.ADBase() Op AD<Base>(right); }                        \
217/* ----------------------------------------------------------------*/  \
218/* Special case to avoid ambuigity when Base is double */              \
219                                                                       \
220inline AD<double> operator Op                                          \
221        (const double &left, const AD<double> &right)                     \
222{       return AD<double>(left) Op right; }                               \
223                                                                       \
224inline AD<double> operator Op                                          \
225        (const double &left, const VecAD_reference<double> &right)        \
226{       return AD<double>(left) Op right.ADBase(); }                      \
227                                                                       \
228inline AD<double> operator Op                                          \
229        (const AD<double> &left, const double &right)                     \
230{       return left Op AD<double>(right); }                               \
231                                                                       \
232inline AD<double> operator Op                                          \
233        (const VecAD_reference<double> &left, const double &right)        \
234{       return left.ADBase() Op AD<double>(right); }
235
236// =======================================================================
237
238/*!
239\def CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(Op)
240Declares automatic coercion for certain binary operations with bool result.
241
242This macro assumes that the operator
243\verbatim
244        left Op right
245\endverbatim
246is defined for the case where left and right
247have type AD<Base> and the result has type bool.
248It uses this case to define the cases either left
249or right has type
250VecAD_reference<Base> or AD<Base>
251and the type of the other operand is one of the following:
252VecAD_reference<Base>, AD<Base>, Base, double.
253All of the arguments are const and call by reference.
254This macro converts the operands to AD<Base> and then
255uses the definition of the same operation for that case.
256*/
257# define CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(Op)                    \
258/* ----------------------------------------------------------------*/  \
259/* Operations with VecAD_reference<Base> and AD<Base> only*/           \
260                                                                       \
261template <class Base>                                                  \
262inline bool operator Op                                                \
263(const AD<Base> &left, const VecAD_reference<Base> &right)             \
264{       return left Op right.ADBase(); }                                  \
265                                                                       \
266template <class Base>                                                  \
267inline bool operator Op                                                \
268(const VecAD_reference<Base> &left, const VecAD_reference<Base> &right)\
269{       return left.ADBase() Op right.ADBase(); }                         \
270                                                                       \
271template <class Base>                                                  \
272inline bool operator Op                                                \
273        (const VecAD_reference<Base> &left, const AD<Base> &right)        \
274{       return left.ADBase() Op right; }                                  \
275/* ----------------------------------------------------------------*/  \
276/* Operations Base */                                                  \
277                                                                       \
278template <class Base>                                                  \
279inline bool operator Op                                                \
280        (const Base &left, const AD<Base> &right)                         \
281{       return AD<Base>(left) Op right; }                                 \
282                                                                       \
283template <class Base>                                                  \
284inline bool operator Op                                                \
285        (const Base &left, const VecAD_reference<Base> &right)            \
286{       return AD<Base>(left) Op right.ADBase(); }                        \
287                                                                       \
288template <class Base>                                                  \
289inline bool operator Op                                                \
290        (const AD<Base> &left, const Base &right)                         \
291{       return left Op AD<Base>(right); }                                 \
292                                                                       \
293template <class Base>                                                  \
294inline bool operator Op                                                \
295        (const VecAD_reference<Base> &left, const Base &right)            \
296{       return left.ADBase() Op AD<Base>(right); }                        \
297                                                                       \
298/* ----------------------------------------------------------------*/  \
299/* Operations double */                                                \
300                                                                       \
301template <class Base>                                                  \
302inline bool operator Op                                                \
303        (const double &left, const AD<Base> &right)                       \
304{       return AD<Base>(left) Op right; }                                 \
305                                                                       \
306template <class Base>                                                  \
307inline bool operator Op                                                \
308        (const double &left, const VecAD_reference<Base> &right)          \
309{       return AD<Base>(left) Op right.ADBase(); }                        \
310                                                                       \
311template <class Base>                                                  \
312inline bool operator Op                                                \
313        (const AD<Base> &left, const double &right)                       \
314{       return left Op AD<Base>(right); }                                 \
315                                                                       \
316template <class Base>                                                  \
317inline bool operator Op                                                \
318        (const VecAD_reference<Base> &left, const double &right)          \
319{       return left.ADBase() Op AD<Base>(right); }                        \
320/* ----------------------------------------------------------------*/  \
321/* Special case to avoid ambuigity when Base is double */              \
322                                                                       \
323inline bool operator Op                                                \
324        (const double &left, const AD<double> &right)                     \
325{       return AD<double>(left) Op right; }                               \
326                                                                       \
327inline bool operator Op                                                \
328        (const double &left, const VecAD_reference<double> &right)        \
329{       return AD<double>(left) Op right.ADBase(); }                      \
330                                                                       \
331inline bool operator Op                                                \
332        (const AD<double> &left, const double &right)                     \
333{       return left Op AD<double>(right); }                               \
334                                                                       \
335inline bool operator Op                                                \
336        (const VecAD_reference<double> &left, const double &right)        \
337{       return left.ADBase() Op AD<double>(right); }
338
339/*! \} */
340# endif
Note: See TracBrowser for help on using the repository browser.