Codebase list cppad / upstream/2015.00.00.7 doc / base_adolc.hpp.xml
upstream/2015.00.00.7

Tree @upstream/2015.00.00.7 (Download .tar.gz)

base_adolc.hpp.xml @upstream/2015.00.00.7 — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
<?xml version='1.0'?>
<html xmlns='http://www.w3.org/1999/xhtml'
      xmlns:math='http://www.w3.org/1998/Math/MathML'
>
<head>
<title>Enable use of AD&lt;Base&gt; where Base is Adolc's adouble Type</title>
<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
<meta name="description" id="description" content="Enable use of AD&lt;Base&gt; where Base is Adolc's adouble Type"/>
<meta name="keywords" id="keywords" content=" Adolc adouble as Base Adolc's enable use of ad&lt;base&gt; where base is adolc's type syntax example include files condexpop equalopseq identical integer ordered unary standard math erf sign abs pow limits "/>
<style type='text/css'>
body { color : black }
body { background-color : white }
A:link { color : blue }
A:visited { color : purple }
A:active { color : purple }
</style>
<script type='text/javascript' language='JavaScript' src='_base_adolc.hpp_xml.js'>
</script>
</head>
<body>
<table><tr>
<td>
<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
</td>
<td><a href="base_require.cpp.xml" target="_top">Prev</a>
</td><td><a href="mul_level_adolc.cpp.xml" target="_top">Next</a>
</td><td>
<select onchange='choose_across0(this)'>
<option>Index-&gt;</option>
<option>contents</option>
<option>reference</option>
<option>index</option>
<option>search</option>
<option>external</option>
</select>
</td>
<td>
<select onchange='choose_up0(this)'>
<option>Up-&gt;</option>
<option>CppAD</option>
<option>AD</option>
<option>base_require</option>
<option>base_example</option>
<option>base_adolc.hpp</option>
</select>
</td>
<td>
<select onchange='choose_down3(this)'>
<option>AD-&gt;</option>
<option>ad_ctor</option>
<option>ad_assign</option>
<option>Convert</option>
<option>ADValued</option>
<option>BoolValued</option>
<option>VecAD</option>
<option>base_require</option>
</select>
</td>
<td>
<select onchange='choose_down2(this)'>
<option>base_require-&gt;</option>
<option>base_member</option>
<option>base_cond_exp</option>
<option>base_identical</option>
<option>base_ordered</option>
<option>base_std_math</option>
<option>base_example</option>
</select>
</td>
<td>
<select onchange='choose_down1(this)'>
<option>base_example-&gt;</option>
<option>base_alloc.hpp</option>
<option>base_require.cpp</option>
<option>base_adolc.hpp</option>
<option>base_float.hpp</option>
<option>base_double.hpp</option>
<option>base_complex.hpp</option>
</select>
</td>
<td>
<select onchange='choose_down0(this)'>
<option>base_adolc.hpp-&gt;</option>
<option>mul_level_adolc.cpp</option>
</select>
</td>
<td>
<select onchange='choose_current0(this)'>
<option>Headings-&gt;</option>
<option>Syntax</option>
<option>Example</option>
<option>Include Files</option>
<option>CondExpOp</option>
<option>EqualOpSeq</option>
<option>Identical</option>
<option>Integer</option>
<option>Ordered</option>
<option>Unary Standard Math</option>
<option>erf</option>
<option>sign</option>
<option>abs</option>
<option>pow</option>
<option>limits</option>
</select>
</td>
</tr></table><br/>





 

<center><b><big><big>Enable use of AD&lt;Base&gt; where Base is Adolc's adouble Type</big></big></b></center>
<br/>
<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

<br/>

<code><font color="blue"><span style='white-space: nowrap'>#&#xA0;include&#xA0;&lt;cppad/example/base_adolc.hpp&gt;<br/>
</span></font></code>
<br/>
<b><big><a name="Example" id="Example">Example</a></big></b>
<br/>
The file <a href="mul_level_adolc.cpp.xml" target="_top"><span style='white-space: nowrap'>mul_level_adolc.cpp</span></a>
 contains an example use of
Adolc's <code><font color="blue">adouble</font></code> type for a CppAD 
<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
 type.
It returns true if it succeeds and false otherwise.
The file <a href="mul_level_adolc_ode.cpp.xml" target="_top"><span style='white-space: nowrap'>mul_level_adolc_ode.cpp</span></a>
 contains a more realistic
(and complex) example.

<br/>
<br/>
<b><big><a name="Include Files" id="Include Files">Include Files</a></big></b>
<br/>
This file <code><font color="blue">base_adolc.hpp</font></code> requires <code><font color="blue">adouble</font></code> to be defined.
In addition, it is included before <code><font color="blue">&lt;cppad/cppad.hpp&gt;</font></code>,
but it needs to include parts of CppAD that are used by this file.
This is done with the following include commands:
<code><font color='blue'><pre style='display:inline'> 
# include &lt;adolc/adolc.h&gt;
# include &lt;cppad/base_require.hpp&gt;
</pre></font></code>


<br/>
<br/>
<b><big><a name="CondExpOp" id="CondExpOp">CondExpOp</a></big></b>
<br/>
The type <code><font color="blue">adouble</font></code> supports a conditional assignment function
with the syntax

<code><font color="blue"><span style='white-space: nowrap'><br/>
&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;condassign(</span></font><i><font color="black"><span style='white-space: nowrap'>a</span></font></i><font color="blue"><span style='white-space: nowrap'>,&#xA0;</span></font><i><font color="black"><span style='white-space: nowrap'>b</span></font></i><font color="blue"><span style='white-space: nowrap'>,&#xA0;</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>,&#xA0;</span></font><i><font color="black"><span style='white-space: nowrap'>d</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
</span></font></code>
which evaluates to

<code><font color="blue"><span style='white-space: nowrap'><br/>
&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;</span></font><i><font color="black"><span style='white-space: nowrap'>a</span></font></i><font color="blue"><span style='white-space: nowrap'>&#xA0;=&#xA0;(</span></font><i><font color="black"><span style='white-space: nowrap'>b</span></font></i><font color="blue"><span style='white-space: nowrap'>&#xA0;&gt;&#xA0;0)&#xA0;?&#xA0;</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>&#xA0;:&#xA0;</span></font><i><font color="black"><span style='white-space: nowrap'>d</span></font></i><font color="blue"><span style='white-space: nowrap'>;<br/>
</span></font></code>
This enables one to include conditionals in the recording of
<code><font color="blue">adouble</font></code> operations and later evaluation for different
values of the independent variables 
(in the same spirit as the CppAD <a href="condexp.xml" target="_top"><span style='white-space: nowrap'>CondExp</span></a>
 function).
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	inline adouble CondExpOp(
		enum  CppAD::CompareOp     cop ,
		const adouble            &amp;left ,
		const adouble           &amp;right ,
		const adouble        &amp;trueCase ,
		const adouble       &amp;falseCase )
	{	adouble result;
		switch( cop )
		{
			case CompareLt: // left &lt; right
			condassign(result, right - left, trueCase, falseCase);
			break;

			case CompareLe: // left &lt;= right
			condassign(result, left - right, falseCase, trueCase);
			break;

			case CompareEq: // left == right
			condassign(result, left - right, falseCase, trueCase);
			condassign(result, right - left, falseCase, result);
			break;

			case CompareGe: // left &gt;= right
			condassign(result, right - left, falseCase, trueCase);
			break;

			case CompareGt: // left &gt; right
			condassign(result, left - right, trueCase, falseCase);
			break;
			default:
			CppAD::ErrorHandler::Call(
				true     , __LINE__ , __FILE__ ,
				&quot;CppAD::CondExp&quot;,
				&quot;Error: for unknown reason.&quot;
			);
			result = trueCase;
		}
		return result;
	}
}
</pre></font></code>


<br/>
<br/>
<b><big><a name="EqualOpSeq" id="EqualOpSeq">EqualOpSeq</a></big></b>
<br/>
The Adolc user interface does not specify a way to determine if 
two <code><font color="blue">adouble</font></code> variables correspond to the same operations sequence. 
Make <code><font color="blue">EqualOpSeq</font></code> an error if it gets used:
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	inline bool EqualOpSeq(const adouble &amp;x, const adouble &amp;y)
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			&quot;CppAD::EqualOpSeq(x, y)&quot;,
			&quot;Error: adouble does not support EqualOpSeq.&quot;
		);
		return false;
	}
}
</pre></font></code>


<br/>
<br/>
<b><big><a name="Identical" id="Identical">Identical</a></big></b>
<br/>
The Adolc user interface does not specify a way to determine if an 
<code><font color="blue">adouble</font></code> depends on the independent variables. 
To be safe (but slow) return <code><font color="blue">false</font></code> in all the cases below.
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	inline bool IdenticalPar(const adouble &amp;x)
	{	return false; }
	inline bool IdenticalZero(const adouble &amp;x)
	{	return false; }
	inline bool IdenticalOne(const adouble &amp;x)
	{	return false; }
	inline bool IdenticalEqualPar(const adouble &amp;x, const adouble &amp;y)
	{	return false; }
}
</pre></font></code>


<br/>
<br/>
<b><big><a name="Integer" id="Integer">Integer</a></big></b>

<code><font color='blue'><pre style='display:inline'> 
	inline int Integer(const adouble &amp;x)
	{    return static_cast&lt;int&gt;( x.getValue() ); }
</pre></font></code>


<br/>
<br/>
<b><big><a name="Ordered" id="Ordered">Ordered</a></big></b>

<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	inline bool GreaterThanZero(const adouble &amp;x)
	{    return (x &gt; 0); }
	inline bool GreaterThanOrZero(const adouble &amp;x)
	{    return (x &gt;= 0); }
	inline bool LessThanZero(const adouble &amp;x)
	{    return (x &lt; 0); }
	inline bool LessThanOrZero(const adouble &amp;x)
	{    return (x &lt;= 0); }
	inline bool abs_geq(const adouble&amp; x, const adouble&amp; y)
	{	return fabs(x) &gt;= fabs(y); }
}
</pre></font></code>


<br/>
<br/>
<b><big><a name="Unary Standard Math" id="Unary Standard Math">Unary Standard Math</a></big></b>
<br/>
The following <a href="base_require.xml" target="_top"><span style='white-space: nowrap'>required</span></a>
 functions 
are defined by the Adolc package for the <code><font color="blue">adouble</font></code> base case:
<code><span style='white-space: nowrap'><br/>
</span></code><code><font color="blue">acos</font></code>,
<code><font color="blue">asin</font></code>,
<code><font color="blue">atan</font></code>,
<code><font color="blue">cos</font></code>,
<code><font color="blue">cosh</font></code>,
<code><font color="blue">exp</font></code>,
<code><font color="blue">fabs</font></code>,
<code><font color="blue">log</font></code>,
<code><font color="blue">sin</font></code>,
<code><font color="blue">sinh</font></code>,
<code><font color="blue">sqrt</font></code>,
<code><font color="blue">tan</font></code>.

<br/>
<br/>
<b><big><a name="erf" id="erf">erf</a></big></b>
<br/>
If the error function is supported by the compiler,
it must also be supported by a 
<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
 type;
see <a href="base_std_math.xml#erf" target="_top"><span style='white-space: nowrap'>erf</span></a>
.
The adolc package does not support this function:
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
# if CPPAD_COMPILER_HAS_ERF
	inline adouble erf(const adouble&amp; x)
	{	CPPAD_ASSERT_KNOWN( 
			false,
			&quot;erf: adolc does not support the error function&quot;
		);
		return 0;
	}
# endif
}
</pre></font></code>
 



<br/>
<br/>
<b><big><a name="sign" id="sign">sign</a></big></b>
<br/>
This <a href="base_require.xml" target="_top"><span style='white-space: nowrap'>required</span></a>
 function is defined using the 
<code><font color="blue">codassign</font></code> function so that its <code><font color="blue">adouble</font></code> operation sequence
does not depend on the value of 
<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
.
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	inline adouble sign(const adouble&amp; x)
	{	adouble s_plus, s_minus, half(.5);
		// set s_plus to sign(x)/2,  except for case x == 0, s_plus = -.5
		condassign(s_plus,  +x, -half, +half);
		// set s_minus to -sign(x)/2, except for case x == 0, s_minus = -.5
		condassign(s_minus, -x, -half, +half);
		// set s to sign(x)
		return s_plus - s_minus;
	}
}
</pre></font></code>


<br/>
<br/>
<b><big><a name="abs" id="abs">abs</a></big></b>
<br/>
This <a href="base_require.xml" target="_top"><span style='white-space: nowrap'>required</span></a>
 function uses the adolc <code><font color="blue">fabs</font></code> 
function:
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	inline adouble abs(const adouble&amp; x)
	{	return fabs(x); }
}
</pre></font></code>


<br/>
<br/>
<b><big><a name="pow" id="pow">pow</a></big></b>
<br/>
This <a href="base_require.xml" target="_top"><span style='white-space: nowrap'>required</span></a>
 function 
is defined by the Adolc package for the <code><font color="blue">adouble</font></code> base case.

<br/>
<br/>
<b><big><a name="limits" id="limits">limits</a></big></b>
<br/>
The following defines the numeric limits functions
<code><font color="blue">epsilon</font></code>, <code><font color="blue">min</font></code>, and <code><font color="blue">max</font></code> for the type
<code><font color="blue">adouble</font></code>.
It also defines the deprecated <code><font color="blue">epsilon</font></code> function:
<code><font color='blue'><pre style='display:inline'> 
namespace CppAD {
	template &lt;&gt;
	class numeric_limits&lt;adouble&gt; {
	public:
		// machine epsilon
		static adouble epsilon(void)
		{	return adouble( std::numeric_limits&lt;double&gt;::epsilon() ); }
		// minimum positive normalized value
		static adouble min(void)
		{	return adouble( std::numeric_limits&lt;float&gt;::min() ); }
		// maximum finite value
		static adouble max(void)
		{	return adouble( std::numeric_limits&lt;float&gt;::max() ); }
	};
	// deprecated machine epsilon
	template &lt;&gt; inline adouble epsilon&lt;adouble&gt;(void)
	{	return numeric_limits&lt;adouble&gt;::epsilon(); }
}
</pre></font></code>


<hr/>Input File: cppad/example/base_adolc.hpp

</body>
</html>