source: trunk/cppad/example/base_adolc.hpp @ 2506

Last change on this file since 2506 was 2506, checked in by bradbell, 8 years ago

Change Licenses: CPL-1.0 -> EPL-1.0, GPL-2.0->GPL-3.0

  • Property svn:keywords set to Id
File size: 6.7 KB
Line 
1/* $Id: base_adolc.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
2# ifndef CPPAD_BASE_ADOLC_INCLUDED
3# define CPPAD_BASE_ADOLC_INCLUDED
4/* --------------------------------------------------------------------------
5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
6
7CppAD is distributed under multiple licenses. This distribution is under
8the terms of the
9                    Eclipse Public License Version 1.0.
10
11A copy of this license is included in the COPYING file of this distribution.
12Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13-------------------------------------------------------------------------- */
14/*
15$begin base_adolc.hpp$$
16$spell
17        ifndef
18        define
19        endif
20        Rel
21        codassign
22        eps
23        std
24        abs_geq
25        fabs
26        cppad.hpp
27        undef
28        Lt
29        Le
30        Eq
31        Ge
32        Gt
33        namespace
34        cassert
35        condassign
36        hpp
37        bool
38        const
39        Adolc
40        adouble
41        CondExpOp
42        inline
43        enum
44        CppAD
45        pow
46        acos
47        asin
48        atan
49        cos
50        cosh
51        exp
52        sqrt
53$$
54
55$index Adolc, adouble as Base$$
56$index Base, Adolc's adouble$$
57$index adouble, as Base$$
58
59$section Enable use of AD<Base> where Base is Adolc's adouble Type$$
60
61$head Syntax$$
62$codei%# include <cppad/example/base_adolc.hpp>
63%$$
64$children%
65        example/mul_level_adolc.cpp
66%$$
67
68$head Example$$
69The file $cref mul_level_adolc.cpp$$ contains an example use of
70Adolc's $code adouble$$ type for a CppAD $icode Base$$ type.
71It returns true if it succeeds and false otherwise.
72The file $cref mul_level_adolc_ode.cpp$$ contains a more realistic
73(and complex) example.
74
75$head Include Files$$
76This file $code base_adolc.hpp$$ requires $code adouble$$ to be defined.
77In addition, it is included before $code <cppad/cppad.hpp>$$,
78but it needs to include parts of CppAD that are used by this file.
79This is done with the following include commands:
80$codep */
81# include <adolc/adolc.h>
82# include <cppad/base_require.hpp>
83/* $$
84
85$head CondExpOp$$
86The type $code adouble$$ supports a conditional assignment function
87with the syntax
88$codei%
89        condassign(%a%, %b%, %c%, %d%)
90%$$
91which evaluates to
92$codei%
93        %a% = (%b% > 0) ? %c% : %d%;
94%$$
95This enables one to include conditionals in the recording of
96$code adouble$$ operations and later evaluation for different
97values of the independent variables
98(in the same spirit as the CppAD $cref CondExp$$ function).
99$codep */
100namespace CppAD {
101        inline adouble CondExpOp(
102                enum  CppAD::CompareOp     cop ,
103                const adouble            &left ,
104                const adouble           &right ,
105                const adouble        &trueCase ,
106                const adouble       &falseCase )
107        {       adouble result;
108                switch( cop )
109                {
110                        case CompareLt: // left < right
111                        condassign(result, right - left, trueCase, falseCase);
112                        break;
113
114                        case CompareLe: // left <= right
115                        condassign(result, left - right, falseCase, trueCase);
116                        break;
117
118                        case CompareEq: // left == right
119                        condassign(result, left - right, falseCase, trueCase);
120                        condassign(result, right - left, falseCase, result);
121                        break;
122
123                        case CompareGe: // left >= right
124                        condassign(result, right - left, falseCase, trueCase);
125                        break;
126
127                        case CompareGt: // left > right
128                        condassign(result, left - right, trueCase, falseCase);
129                        break;
130                        default:
131                        CppAD::ErrorHandler::Call(
132                                true     , __LINE__ , __FILE__ ,
133                                "CppAD::CondExp",
134                                "Error: for unknown reason."
135                        );
136                        result = trueCase;
137                }
138                return result;
139        }
140}
141/* $$
142
143$head EqualOpSeq$$
144The Adolc user interface does not specify a way to determine if
145two $code adouble$$ variables correspond to the same operations sequence.
146Make $code EqualOpSeq$$ an error if it gets used:
147$codep */
148namespace CppAD {
149        inline bool EqualOpSeq(const adouble &x, const adouble &y)
150        {       CppAD::ErrorHandler::Call(
151                        true     , __LINE__ , __FILE__ ,
152                        "CppAD::EqualOpSeq(x, y)",
153                        "Error: adouble does not support EqualOpSeq."
154                );
155                return false;
156        }
157}
158/* $$
159
160$head Identical$$
161The Adolc user interface does not specify a way to determine if an
162$code adouble$$ depends on the independent variables.
163To be safe (but slow) return $code false$$ in all the cases below.
164$codep */
165namespace CppAD {
166        inline bool IdenticalPar(const adouble &x)
167        {       return false; }
168        inline bool IdenticalZero(const adouble &x)
169        {       return false; }
170        inline bool IdenticalOne(const adouble &x)
171        {       return false; }
172        inline bool IdenticalEqualPar(const adouble &x, const adouble &y)
173        {       return false; }
174}
175/* $$
176
177$head Integer$$
178$codep */
179        inline int Integer(const adouble &x)
180        {    return static_cast<int>( x.getValue() ); }
181/* $$
182
183$head Ordered$$
184$codep */
185namespace CppAD {
186        inline bool GreaterThanZero(const adouble &x)
187        {    return (x > 0); }
188        inline bool GreaterThanOrZero(const adouble &x)
189        {    return (x >= 0); }
190        inline bool LessThanZero(const adouble &x)
191        {    return (x < 0); }
192        inline bool LessThanOrZero(const adouble &x)
193        {    return (x <= 0); }
194        inline bool abs_geq(const adouble& x, const adouble& y)
195        {       return fabs(x) >= fabs(y); }
196}
197/* $$
198
199$head Unary Standard Math$$
200The following $cref/required/base_require/$$ functions
201are defined by the Adolc package for the $code adouble$$ base case:
202$pre
203$$
204$code acos$$,
205$code asin$$,
206$code atan$$,
207$code cos$$,
208$code cosh$$,
209$code exp$$,
210$code fabs$$,
211$code log$$,
212$code sin$$,
213$code sinh$$,
214$code sqrt$$,
215$code tan$$.
216
217$head sign$$
218This $cref/required/base_require/$$ function is defined using the
219$code codassign$$ function so that its $code adouble$$ operation sequence
220does not depend on the value of $icode x$$.
221$codep */
222namespace CppAD {
223        inline adouble sign(const adouble& x)
224        {       adouble s_plus, s_minus;
225                // set s_plus to sign(x)/2,  except for case x == 0, s_plus = -.5
226                condassign(s_plus,  +x, -.5, .5);
227                // set s_minus to -sign(x)/2, except for case x == 0, s_minus = -.5
228                condassign(s_minus, -x, -.5, .5);
229                // set s to sign(x)
230                return s_plus - s_minus;
231        }
232}
233/* $$
234
235$head abs$$
236This $cref/required/base_require/$$ function uses the adolc $code fabs$$
237function:
238$codep */
239namespace CppAD {
240        inline adouble abs(const adouble& x)
241        {       return fabs(x); }
242}
243/* $$
244
245$head pow$$
246This $cref/required/base_require/$$ function
247is defined by the Adolc package for the $code adouble$$ base case.
248
249$head limits$$
250The following defines the numeric limits functions
251$code epsilon$$, $code min$$, and $code max$$ for the type
252$code adouble$$.
253It also defines the deprecated $code epsilon$$ function:
254$codep */
255namespace CppAD {
256        template <>
257        class numeric_limits<adouble> {
258        public:
259                // machine epsilon
260                static adouble epsilon(void)
261                {       return adouble( std::numeric_limits<double>::epsilon() ); }
262                // minimum positive normalized value
263                static adouble min(void)
264                {       return adouble( std::numeric_limits<float>::min() ); }
265                // maximum finite value
266                static adouble max(void)
267                {       return adouble( std::numeric_limits<float>::max() ); }
268        };
269        // deprecated machine epsilon
270        template <> inline adouble epsilon<adouble>(void)
271        {       return numeric_limits<adouble>::epsilon(); }
272}
273/* $$
274$end
275*/
276# endif
277
Note: See TracBrowser for help on using the repository browser.