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

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

define.hpp: comment out more versions of operator floding.

  • Property svn:keywords set to Id
File size: 17.6 KB
Line 
1/* $Id: define.hpp 3046 2013-12-26 18:16:44Z 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
155# if 0
156# define CPPAD_FOLD_AD_VALUED_BINARY_OPERATOR(Op)                      \
157/* ----------------------------------------------------------------*/  \
158/* Operations with VecAD_reference<Base> and AD<Base> only*/           \
159                                                                       \
160template <class Base>                                                  \
161inline AD<Base> operator Op                                            \
162(const AD<Base> &left, const VecAD_reference<Base> &right)             \
163{       return left Op right.ADBase(); }                                  \
164                                                                       \
165template <class Base>                                                  \
166inline AD<Base> operator Op                                            \
167(const VecAD_reference<Base> &left, const VecAD_reference<Base> &right)\
168{       return left.ADBase() Op right.ADBase(); }                         \
169                                                                       \
170template <class Base>                                                  \
171inline AD<Base> operator Op                                            \
172        (const VecAD_reference<Base> &left, const AD<Base> &right)        \
173{       return left.ADBase() Op right; }                                  \
174/* ----------------------------------------------------------------*/  \
175/* Operations Base */                                                  \
176                                                                       \
177template <class Base>                                                  \
178inline AD<Base> operator Op                                            \
179        (const Base &left, const AD<Base> &right)                         \
180{       return AD<Base>(left) Op right; }                                 \
181                                                                       \
182template <class Base>                                                  \
183inline AD<Base> operator Op                                            \
184        (const Base &left, const VecAD_reference<Base> &right)            \
185{       return AD<Base>(left) Op right.ADBase(); }                        \
186                                                                       \
187template <class Base>                                                  \
188inline AD<Base> operator Op                                            \
189        (const AD<Base> &left, const Base &right)                         \
190{       return left Op AD<Base>(right); }                                 \
191                                                                       \
192template <class Base>                                                  \
193inline AD<Base> operator Op                                            \
194        (const VecAD_reference<Base> &left, const Base &right)            \
195{       return left.ADBase() Op AD<Base>(right); }                        \
196                                                                       \
197/* ----------------------------------------------------------------*/  \
198/* Operations double */                                                \
199                                                                       \
200template <class Base>                                                  \
201inline AD<Base> operator Op                                            \
202        (const double &left, const AD<Base> &right)                       \
203{       return AD<Base>(left) Op right; }                                 \
204                                                                       \
205template <class Base>                                                  \
206inline AD<Base> operator Op                                            \
207        (const double &left, const VecAD_reference<Base> &right)          \
208{       return AD<Base>(left) Op right.ADBase(); }                        \
209                                                                       \
210template <class Base>                                                  \
211inline AD<Base> operator Op                                            \
212        (const AD<Base> &left, const double &right)                       \
213{       return left Op AD<Base>(right); }                                 \
214                                                                       \
215template <class Base>                                                  \
216inline AD<Base> operator Op                                            \
217        (const VecAD_reference<Base> &left, const double &right)          \
218{       return left.ADBase() Op AD<Base>(right); }                        \
219/* ----------------------------------------------------------------*/  \
220/* Special case to avoid ambuigity when Base is double */              \
221                                                                       \
222inline AD<double> operator Op                                          \
223        (const double &left, const AD<double> &right)                     \
224{       return AD<double>(left) Op right; }                               \
225                                                                       \
226inline AD<double> operator Op                                          \
227        (const double &left, const VecAD_reference<double> &right)        \
228{       return AD<double>(left) Op right.ADBase(); }                      \
229                                                                       \
230inline AD<double> operator Op                                          \
231        (const AD<double> &left, const double &right)                     \
232{       return left Op AD<double>(right); }                               \
233                                                                       \
234inline AD<double> operator Op                                          \
235        (const VecAD_reference<double> &left, const double &right)        \
236{       return left.ADBase() Op AD<double>(right); }
237# else
238# define CPPAD_FOLD_AD_VALUED_BINARY_OPERATOR(Op)
239# endif
240
241// =======================================================================
242
243/*!
244\def CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(Op)
245Declares automatic coercion for certain binary operations with bool result.
246
247This macro assumes that the operator
248\verbatim
249        left Op right
250\endverbatim
251is defined for the case where left and right
252have type AD<Base> and the result has type bool.
253It uses this case to define the cases either left
254or right has type
255VecAD_reference<Base> or AD<Base>
256and the type of the other operand is one of the following:
257VecAD_reference<Base>, AD<Base>, Base, double.
258All of the arguments are const and call by reference.
259This macro converts the operands to AD<Base> and then
260uses the definition of the same operation for that case.
261*/
262
263# if 0
264# define CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(Op)                    \
265/* ----------------------------------------------------------------*/  \
266/* Operations with VecAD_reference<Base> and AD<Base> only*/           \
267                                                                       \
268template <class Base>                                                  \
269inline bool operator Op                                                \
270(const AD<Base> &left, const VecAD_reference<Base> &right)             \
271{       return left Op right.ADBase(); }                                  \
272                                                                       \
273template <class Base>                                                  \
274inline bool operator Op                                                \
275(const VecAD_reference<Base> &left, const VecAD_reference<Base> &right)\
276{       return left.ADBase() Op right.ADBase(); }                         \
277                                                                       \
278template <class Base>                                                  \
279inline bool operator Op                                                \
280        (const VecAD_reference<Base> &left, const AD<Base> &right)        \
281{       return left.ADBase() Op right; }                                  \
282/* ----------------------------------------------------------------*/  \
283/* Operations Base */                                                  \
284                                                                       \
285template <class Base>                                                  \
286inline bool operator Op                                                \
287        (const Base &left, const AD<Base> &right)                         \
288{       return AD<Base>(left) Op right; }                                 \
289                                                                       \
290template <class Base>                                                  \
291inline bool operator Op                                                \
292        (const Base &left, const VecAD_reference<Base> &right)            \
293{       return AD<Base>(left) Op right.ADBase(); }                        \
294                                                                       \
295template <class Base>                                                  \
296inline bool operator Op                                                \
297        (const AD<Base> &left, const Base &right)                         \
298{       return left Op AD<Base>(right); }                                 \
299                                                                       \
300template <class Base>                                                  \
301inline bool operator Op                                                \
302        (const VecAD_reference<Base> &left, const Base &right)            \
303{       return left.ADBase() Op AD<Base>(right); }                        \
304                                                                       \
305/* ----------------------------------------------------------------*/  \
306/* Operations double */                                                \
307                                                                       \
308template <class Base>                                                  \
309inline bool operator Op                                                \
310        (const double &left, const AD<Base> &right)                       \
311{       return AD<Base>(left) Op right; }                                 \
312                                                                       \
313template <class Base>                                                  \
314inline bool operator Op                                                \
315        (const double &left, const VecAD_reference<Base> &right)          \
316{       return AD<Base>(left) Op right.ADBase(); }                        \
317                                                                       \
318template <class Base>                                                  \
319inline bool operator Op                                                \
320        (const AD<Base> &left, const double &right)                       \
321{       return left Op AD<Base>(right); }                                 \
322                                                                       \
323template <class Base>                                                  \
324inline bool operator Op                                                \
325        (const VecAD_reference<Base> &left, const double &right)          \
326{       return left.ADBase() Op AD<Base>(right); }                        \
327/* ----------------------------------------------------------------*/  \
328/* Special case to avoid ambuigity when Base is double */              \
329                                                                       \
330inline bool operator Op                                                \
331        (const double &left, const AD<double> &right)                     \
332{       return AD<double>(left) Op right; }                               \
333                                                                       \
334inline bool operator Op                                                \
335        (const double &left, const VecAD_reference<double> &right)        \
336{       return AD<double>(left) Op right.ADBase(); }                      \
337                                                                       \
338inline bool operator Op                                                \
339        (const AD<double> &left, const double &right)                     \
340{       return left Op AD<double>(right); }                               \
341                                                                       \
342inline bool operator Op                                                \
343        (const VecAD_reference<double> &left, const double &right)        \
344{       return left.ADBase() Op AD<double>(right); }
345# else
346# define CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(Op)
347# endif
348
349/*! \} */
350# endif
Note: See TracBrowser for help on using the repository browser.