source: trunk/cppad/local/compare.hpp @ 3607

Last change on this file since 3607 was 3607, checked in by bradbell, 5 years ago

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: f4baab0ea7c2679ba9351b0439b6efebfa77ba04
end hash code: 894d554a00ceec8a3545f05eca62708a7b5cb43d

commit 894d554a00ceec8a3545f05eca62708a7b5cb43d
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 09:06:10 2015 -0700

Fix copyright end date.


whats_new_15.omh: Add comment about date of deprecation.

commit 611e982000168db91aba22b763c14bb78d57da47
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 08:53:00 2015 -0700

Squashed commit from old/compare_op to master:


In addition, fix copyright end date for some files, and add note about
deprecated date in whats_new_15.omh.


commit 6e46df5c850ecd58d7a886db4043bc3f2d4579d1
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 08:16:57 2015 -0700


Always return f.compare_change_op_index() == 0 after f.optimize().


checkpoint.hpp: ignore comparison operators.
fun_construct.hpp: remove double initilaization of values.
compare_change.cpp: demonstrate more features of new interface.
whats_new_15.omh: prepare for merging this branch into master.
wish_list.omh: update wish list item to new compare_change interface.


commit 45315907c70e5b383d984fb9498b54a474001af0
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 05:04:37 2015 -0700


Use the new f.compare_change_count(0) option in speed tests.


commit bb6e72befd6d01f1fb62c43b9b19471ffaa7cc2c
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 04:51:16 2015 -0700


Move CompareChange? -> deprecated and plan -> compare_change.


forward0sweep.hpp: skip comparison operator when count is zero.
forward1sweep.hpp: skip comparison operator when count is zero.
compare_change.cpp: demonstrate count == 0 case.


commit 622a13c568c612d9dfe9ccd1a01f4ac5f74ba824
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 23:17:42 2015 -0700


Add example and test of new compare change user API.


ad_fun.hpp: fix f.compare_change_op_index.
compare_change.cpp: Change example to use new API.
compare_change.cpp: Move old example here (just test now).


commit ec4c1613eae8df56fbf31e7b8711ce69cc41df83
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 21:12:11 2015 -0700


Implement the compare change plan, still needs an example and test.
Also have the change from 'plan' to just plain documentation.


commit a81a46f27011bee08ba072551044dc9f4a99a906
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 17:49:05 2015 -0700


Change name of compare_change functions and partially implement this new plan.


commit 146faad48a700a56362e74f9c3a3c39144a79738
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 14:22:40 2015 -0700


Branch: compare_op
plan.omh: change name of count function.


commit 35d91d126765d1a0ab4bfe9e2b006bbf535cd648
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 13:19:07 2015 -0700


Add deprecation date for some more cases.


commit 5bb65a8c48fae4263b66fcd04520e10e66febc11
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 13:13:51 2015 -0700


Add date of deprecation for some more cases.


commit e95ee6b209601cd9a075d2e37c602e73c32fb6ab
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 12:58:44 2015 -0700


Add date of deprecation for some more cases.


commit 0ea84ccd87383edc62a6ae1711da104b12e8c444
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 12:47:01 2015 -0700


Add date of deprecation for some cases.


commit 17755e609ea8e03472b08dcc2fb5ad347eb723cb
Author: Brad Bell <bradbell@…>
Date: Mon Jan 19 08:20:45 2015 -0700


plan.omh: changs some names.


commit 29f369c06d4d0ee284c4c668d52d8461613066dc
Author: Brad Bell <bradbell@…>
Date: Fri Jan 16 06:39:45 2015 -0700


Document the plan for compare_change user API.


compare_change.omh: fix minor typo.
plan.txt: change to the omhelp file plan.omh.


commit a3a2f4dedd202a722812b6eb2714851b40726e6e
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 21:03:44 2015 -0700


new_branch.sh: remove unused variable.
push_git2svn.py: move repository from github/bradbell to coin-or/bradbell.


commit 3751a197ab2897e76616f9d9b0915148bd855356
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 20:56:17 2015 -0700


plan.txt: plan for this branches API will go here.


commit 76013ec2ad7baacdeab5e761812d542867910174
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 18:04:33 2015 -0700


Store the operator index for the first comparision change in the ADFun object.


commit 9caf25014079a60df5de17bcac76775daf8ee201
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 12:45:56 2015 -0700


Make compare_change a parameter (so will be easy to add compare_first).


commit 2246d22fe82b8909d432f82ab0d783ce3351a02f
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 09:12:40 2015 -0700


speed_branch.sh: fix directory (before cd).


commit b3910de86558a97749741bfb728e45c5a86d1c73
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 05:14:01 2015 -0700


search.sh: use git to get list of source files.
ad_fun.hpp: imporve doxygen doc for compare_change_.
ad_tape.hpp: remove RecordCompare? (no longer used).
atomic_base.hpp: minor edit to user documentation.


commit dd74f331386cadc9cc272c264296e575691aa3f8
Author: Brad Bell <bradbell@…>
Date: Thu Jan 15 04:12:34 2015 -0700


Change Leq..Op -> Le..Op and leq.._op -> le.._op.


commit ae729296323eb7f4f4a7c0e90a303a8d7f4ed42a
Author: Brad Bell <bradbell@…>
Date: Wed Jan 14 21:19:55 2015 -0700


comp_op.hpp: Add doxygen documentaiton for compare operators.
compare.hpp: avoid an extra branch.


commit b064d59a5ad01dff5c708cc8c02f628f58c863ec
Author: Brad Bell <bradbell@…>
Date: Wed Jan 14 16:11:25 2015 -0700


Remove ComOp?, replaced by specific cases Eq..Op, Ne..Op, Leq..Op, Lt..Op,
which should run faster.


forward0sweep.hpp: Remove out-dated comment about CompOp?.
forward1sweep.hpp: Remove out-dated comment about CompOp?.


commit 5bb0a70d1151e9086b88024050cea6cf11e83aa7
Author: Brad Bell <bradbell@…>
Date: Wed Jan 14 09:02:17 2015 -0700


Use Eq..Op, Ne..Op to implement == and !=.


commit 0ebeec61bc040a00c50db41ca5da31fb87194f93
Author: Brad Bell <bradbell@…>
Date: Wed Jan 14 07:19:26 2015 -0700


compare.hpp: Finish folding < <= > >= into Lt..Op and Leq..Op.


commit c949e5b72158b98cbab61c8aea98e76008e9c2f4
Author: Brad Bell <bradbell@…>
Date: Wed Jan 14 06:28:41 2015 -0700


  1. Change plan to fold all compare operations into Leq..Op and Lt..Op cases.
  2. Fix alphabetical order between Ld and Leq.


commit 6ffee88b68b682359d62bc75a8c2ba3e28d012ac
Author: Brad Bell <bradbell@…>
Date: Tue Jan 13 22:40:18 2015 -0700


Splite parameter <= variable and parameter > variable as separate compare
operators.


commit 0841014db4ead690d1c2358f5e09494030ae1e5f
Author: Brad Bell <bradbell@…>
Date: Tue Jan 13 21:12:57 2015 -0700


Attempting to recording and playback of compare operators faster:
Split variable <= variable and variable > variable out as separate cases.


compare.hpp: remove white space at end of lines.


commit cfd3afceebd4b3383b3042cbca98caf82ff77670
Author: Brad Bell <bradbell@…>
Date: Tue Jan 13 08:39:12 2015 -0700


speed_branch.sh: compare speed_cppad between two git branches.
speed_new.sh: correct list of options, remove unused variable.
wish_list.omh: correct discussion of effect of keeping compare operators.


commit 9ed03e1ee2c258ca38561ad083067e235d032e14
Author: Brad Bell <bradbell@…>
Date: Tue Jan 13 05:54:30 2015 -0700


Change test so it corresponds to optimization keeping compare operators.


commit 5c418d477d58984b094bba027ebb0794e759e557
Author: Brad Bell <bradbell@…>
Date: Tue Jan 13 05:12:50 2015 -0700


Include example and test of using CompareChange? with optimized tape.


commit c1b48edfa56ca096ce8c2db1dbadb2658cb13fe3
Author: Brad Bell <bradbell@…>
Date: Tue Jan 13 04:24:54 2015 -0700


Fix optimization so variables used in compare opertions are alwasy available.


commit 6fe607ca30db07b356fd3a9fe9779fa2dfd382d8
Author: Brad Bell <bradbell@…>
Date: Mon Jan 12 07:56:41 2015 -0700


Keep CompareChange? in optimized versions of tape and when NDEBUG is defined.

commit b4c0e51489cc0878499a331b4af4875b2781d8d8
Author: Brad Bell <bradbell@…>
Date: Sun Jan 11 17:01:59 2015 -0700

new_branch.sh: final procedure (only hand tested).

  • Property svn:keywords set to Id
File size: 10.6 KB
Line 
1/* $Id: compare.hpp 3607 2015-01-20 16:20:41Z bradbell $ */
2# ifndef CPPAD_COMPARE_INCLUDED
3# define CPPAD_COMPARE_INCLUDED
4
5/* --------------------------------------------------------------------------
6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 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-------------------------------------------------------------------------------
18$begin Compare$$
19$spell
20        cos
21        Op
22        bool
23        const
24$$
25
26$index binary, AD compare operator$$
27$index AD, binary compare operator$$
28$index compare, AD binary operator$$
29$index operator, AD binary compare$$
30
31$index <, AD operator$$
32$index <=, AD operator$$
33$index >, AD operator$$
34$index >=, AD operator$$
35$index ==, AD operator$$
36$index !=, AD operator$$
37
38$section AD Binary Comparison Operators$$
39
40
41$head Syntax$$
42
43$icode%b% = %x% %Op% %y%$$
44
45
46$head Purpose$$
47Compares two operands where one of the operands is an
48$codei%AD<%Base%>%$$ object.
49The comparison has the same interpretation as for
50the $icode Base$$ type.
51
52
53$head Op$$
54The operator $icode Op$$ is one of the following:
55$table
56$bold Op$$ $pre $$  $cnext $bold Meaning$$                           $rnext
57$code <$$   $cnext is $icode x$$ less than $icode y$$              $rnext
58$code <=$$  $cnext is $icode x$$ less than or equal $icode y$$     $rnext
59$code >$$   $cnext is $icode x$$ greater than $icode y$$           $rnext
60$code >=$$  $cnext is $icode x$$ greater than or equal $icode y$$  $rnext
61$code ==$$  $cnext is $icode x$$ equal to $icode y$$               $rnext
62$code !=$$  $cnext is $icode x$$ not equal to $icode y$$
63$tend
64
65$head x$$
66The operand $icode x$$ has prototype
67$codei%
68        const %Type% &%x%
69%$$
70where $icode Type$$ is $codei%AD<%Base%>%$$, $icode Base$$, or $code int$$.
71
72$head y$$
73The operand $icode y$$ has prototype
74$codei%
75        const %Type% &%y%
76%$$
77where $icode Type$$ is $codei%AD<%Base%>%$$, $icode Base$$, or $code int$$.
78
79$head b$$
80The result $icode b$$ has type
81$codei%
82        bool %b%
83%$$
84
85$head Operation Sequence$$
86The result of this operation is a $code bool$$ value
87(not an $cref/AD of Base/glossary/AD of Base/$$ object).
88Thus it will not be recorded as part of an
89AD of $icode Base$$
90$cref/operation sequence/glossary/Operation/Sequence/$$.
91$pre
92
93$$
94For example, suppose
95$icode x$$ and $icode y$$ are $codei%AD<%Base%>%$$ objects,
96the tape corresponding to $codei%AD<%Base%>%$$ is recording,
97$icode b$$ is true,
98and the subsequent code is
99$codei%
100        if( %b% )
101                %y% = cos(%x%);
102        else    %y% = sin(%x%);
103%$$
104only the assignment $icode%y% = cos(%x%)%$$ is recorded on the tape
105(if $icode x$$ is a $cref/parameter/glossary/Parameter/$$,
106nothing is recorded).
107The $cref CompareChange$$ function can yield
108some information about changes in comparison operation results.
109You can use $cref CondExp$$ to obtain comparison operations
110that depends on the
111$cref/independent variable/glossary/Tape/Independent Variable/$$
112values with out re-taping the AD sequence of operations.
113
114$head Assumptions$$
115If one of the $icode Op$$ operators listed above
116is used with an $codei%AD<%Base%>%$$ object,
117it is assumed that the same operator is supported by the base type
118$icode Base$$.
119
120$head Example$$
121$children%
122        example/compare.cpp
123%$$
124The file
125$cref compare.cpp$$
126contains an example and test of these operations.
127It returns true if it succeeds and false otherwise.
128
129$end
130-------------------------------------------------------------------------------
131*/
132//  BEGIN CppAD namespace
133namespace CppAD {
134
135// -------------------------------- < --------------------------
136template <class Base>
137CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
138bool operator < (const AD<Base> &left , const AD<Base> &right)
139{       bool result    =  (left.value_ < right.value_);
140        bool var_left  = Variable(left);
141        bool var_right = Variable(right);
142
143        ADTape<Base> *tape = CPPAD_NULL;
144        if( var_left )
145        {       tape = left.tape_this();
146                if( var_right )
147                {       if( result )
148                        {       tape->Rec_.PutOp(LtvvOp);
149                                tape->Rec_.PutArg(left.taddr_, right.taddr_);
150                        }
151                        else
152                        {       tape->Rec_.PutOp(LevvOp);
153                                tape->Rec_.PutArg(right.taddr_, left.taddr_);
154                        }
155                }
156                else
157                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
158                        if( result )
159                        {       tape->Rec_.PutOp(LtvpOp);
160                                tape->Rec_.PutArg(left.taddr_, arg1);
161                        }
162                        else
163                        {       tape->Rec_.PutOp(LepvOp);
164                                tape->Rec_.PutArg(arg1, left.taddr_);
165                        }
166                }
167        }
168        else if ( var_right )
169        {       tape = right.tape_this();
170                addr_t arg0 = tape->Rec_.PutPar(left.value_);
171                if( result )
172                {       tape->Rec_.PutOp(LtpvOp);
173                        tape->Rec_.PutArg(arg0, right.taddr_);
174                }
175                else
176                {       tape->Rec_.PutOp(LevpOp);
177                        tape->Rec_.PutArg(right.taddr_, arg0);
178                }
179        }
180
181        return result;
182}
183// convert other cases into the case above
184CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(<)
185
186// -------------------------------- <= -------------------------
187template <class Base>
188CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
189bool operator <= (const AD<Base> &left , const AD<Base> &right)
190{       bool result    =  (left.value_ <= right.value_);
191        bool var_left  = Variable(left);
192        bool var_right = Variable(right);
193
194        ADTape<Base> *tape = CPPAD_NULL;
195        if( var_left )
196        {       tape = left.tape_this();
197                if( var_right )
198                {       if( result )
199                        {       tape->Rec_.PutOp(LevvOp);
200                                tape->Rec_.PutArg(left.taddr_, right.taddr_);
201                        }
202                        else
203                        {       tape->Rec_.PutOp(LtvvOp);
204                                tape->Rec_.PutArg(right.taddr_, left.taddr_);
205                        }
206                }
207                else
208                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
209                        if( result )
210                        {       tape->Rec_.PutOp(LevpOp);
211                                tape->Rec_.PutArg(left.taddr_, arg1);
212                        }
213                        else
214                        {       tape->Rec_.PutOp(LtpvOp);
215                                tape->Rec_.PutArg(arg1, left.taddr_);
216                        }
217                }
218        }
219        else if ( var_right )
220        {       tape = right.tape_this();
221                addr_t arg0 = tape->Rec_.PutPar(left.value_);
222                if( result )
223                {       tape->Rec_.PutOp(LepvOp);
224                        tape->Rec_.PutArg(arg0, right.taddr_);
225                }
226                else
227                {       tape->Rec_.PutOp(LtvpOp);
228                        tape->Rec_.PutArg(right.taddr_, arg0);
229                }
230        }
231
232        return result;
233}
234// convert other cases into the case above
235CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(<=)
236
237// -------------------------------- > --------------------------
238template <class Base>
239CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
240bool operator > (const AD<Base> &left , const AD<Base> &right)
241{       bool result    =  (left.value_ > right.value_);
242        bool var_left  = Variable(left);
243        bool var_right = Variable(right);
244
245        ADTape<Base> *tape = CPPAD_NULL;
246        if( var_left )
247        {       tape = left.tape_this();
248                if( var_right )
249                {       if( result )
250                        {       tape->Rec_.PutOp(LtvvOp);
251                                tape->Rec_.PutArg(right.taddr_, left.taddr_);
252                        }
253                        else
254                        {       tape->Rec_.PutOp(LevvOp);
255                                tape->Rec_.PutArg(left.taddr_, right.taddr_);
256                        }
257                }
258                else
259                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
260                        if( result )
261                        {       tape->Rec_.PutOp(LtpvOp);
262                                tape->Rec_.PutArg(arg1, left.taddr_);
263                        }
264                        else
265                        {       tape->Rec_.PutOp(LevpOp);
266                                tape->Rec_.PutArg(left.taddr_, arg1);
267                        }
268                }
269        }
270        else if ( var_right )
271        {       tape = right.tape_this();
272                addr_t arg0 = tape->Rec_.PutPar(left.value_);
273                if( result )
274                {       tape->Rec_.PutOp(LtvpOp);
275                        tape->Rec_.PutArg(right.taddr_, arg0);
276                }
277                else
278                {       tape->Rec_.PutOp(LepvOp);
279                        tape->Rec_.PutArg(arg0, right.taddr_);
280                }
281        }
282
283        return result;
284}
285// convert other cases into the case above
286CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(>)
287
288// -------------------------------- >= -------------------------
289template <class Base>
290CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
291bool operator >= (const AD<Base> &left , const AD<Base> &right)
292{       bool result    =  (left.value_ >= right.value_);
293        bool var_left  = Variable(left);
294        bool var_right = Variable(right);
295
296        ADTape<Base> *tape = CPPAD_NULL;
297        if( var_left )
298        {       tape = left.tape_this();
299                if( var_right )
300                {       if( result )
301                        {       tape->Rec_.PutOp(LevvOp);
302                                tape->Rec_.PutArg(right.taddr_, left.taddr_);
303                        }
304                        else
305                        {       tape->Rec_.PutOp(LtvvOp);
306                                tape->Rec_.PutArg(left.taddr_, right.taddr_);
307                        }
308                }
309                else
310                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
311                        if( result )
312                        {       tape->Rec_.PutOp(LepvOp);
313                                tape->Rec_.PutArg(arg1, left.taddr_);
314                        }
315                        else
316                        {       tape->Rec_.PutOp(LtvpOp);
317                                tape->Rec_.PutArg(left.taddr_, arg1);
318                        }
319                }
320        }
321        else if ( var_right )
322        {       tape = right.tape_this();
323                addr_t arg0 = tape->Rec_.PutPar(left.value_);
324                if( result )
325                {       tape->Rec_.PutOp(LevpOp);
326                        tape->Rec_.PutArg(right.taddr_, arg0);
327                }
328                else
329                {       tape->Rec_.PutOp(LtpvOp);
330                        tape->Rec_.PutArg(arg0, right.taddr_);
331                }
332        }
333
334        return result;
335}
336// convert other cases into the case above
337CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(>=)
338
339// -------------------------------- == -------------------------
340template <class Base>
341CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
342bool operator == (const AD<Base> &left , const AD<Base> &right)
343{       bool result    =  (left.value_ == right.value_);
344        bool var_left  = Variable(left);
345        bool var_right = Variable(right);
346
347        ADTape<Base> *tape = CPPAD_NULL;
348        if( var_left )
349        {       tape = left.tape_this();
350                if( var_right )
351                {       tape->Rec_.PutArg(left.taddr_, right.taddr_);
352                        if( result )
353                                tape->Rec_.PutOp(EqvvOp);
354                        else
355                                tape->Rec_.PutOp(NevvOp);
356                }
357                else
358                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
359                        tape->Rec_.PutArg(arg1, left.taddr_);
360                        if( result )
361                                tape->Rec_.PutOp(EqpvOp);
362                        else
363                                tape->Rec_.PutOp(NepvOp);
364                }
365        }
366        else if ( var_right )
367        {       tape = right.tape_this();
368                addr_t arg0 = tape->Rec_.PutPar(left.value_);
369                tape->Rec_.PutArg(arg0, right.taddr_);
370                if( result )
371                        tape->Rec_.PutOp(EqpvOp);
372                else
373                        tape->Rec_.PutOp(NepvOp);
374        }
375
376        return result;
377}
378// convert other cases into the case above
379CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(==)
380
381// -------------------------------- != -------------------------
382template <class Base>
383CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
384bool operator != (const AD<Base> &left , const AD<Base> &right)
385{       bool result    =  (left.value_ != right.value_);
386        bool var_left  = Variable(left);
387        bool var_right = Variable(right);
388
389        ADTape<Base> *tape = CPPAD_NULL;
390        if( var_left )
391        {       tape = left.tape_this();
392                if( var_right )
393                {       tape->Rec_.PutArg(left.taddr_, right.taddr_);
394                        if( result )
395                                tape->Rec_.PutOp(NevvOp);
396                        else
397                                tape->Rec_.PutOp(EqvvOp);
398                }
399                else
400                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
401                        tape->Rec_.PutArg(arg1, left.taddr_);
402                        if( result )
403                                tape->Rec_.PutOp(NepvOp);
404                        else
405                                tape->Rec_.PutOp(EqpvOp);
406                }
407        }
408        else if ( var_right )
409        {       tape = right.tape_this();
410                addr_t arg0 = tape->Rec_.PutPar(left.value_);
411                tape->Rec_.PutArg(arg0, right.taddr_);
412                if( result )
413                        tape->Rec_.PutOp(NepvOp);
414                else
415                        tape->Rec_.PutOp(EqpvOp);
416        }
417
418        return result;
419}
420// convert other cases into the case above
421CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(!=)
422
423} // END CppAD namespace
424
425# endif
Note: See TracBrowser for help on using the repository browser.