Changeset 3607


Ignore:
Timestamp:
Jan 20, 2015 11:20:41 AM (5 years ago)
Author:
bradbell
Message:

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).

Location:
trunk
Files:
2 added
55 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/new_branch.sh

    r3593 r3607  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    3232# some settings
    3333svn_repository='https://projects.coin-or.org/svn/CppAD'
    34 git_repository='https://github.com/bradbell/cppad'
    3534work_directory='build/work'
    3635# -----------------------------------------------------------------------------
     
    6665        else
    6766                echo_eval svn revert --recursive $svn_directory
     67                echo_eval svn update $svn_directory
    6868                svn_status=`svn status $svn_directory | \
    6969                        sed -n -e '/^\?/p' | sed -e 's|^\? *||'`
     
    9494fi 
    9595# -----------------------------------------------------------------------------
     96echo_eval git checkout master
     97git_branch_name=`echo $svn_branch_path | sed -e 's|^branches/||'`
     98echo_eval git branch $git_branch_name
     99echo_eval git checkout $git_branch_name
     100git push --set-upstream origin $git_branch_name
     101# -----------------------------------------------------------------------------
    96102cat << EOF > $svn_directory/new_branch.log
    97103copy trunk to:   $svn_branch_path
    98104start hash code: $hash_origin
     105end   hash code: $hash_origin
    99106EOF
    100107echo_eval svn copy --file new_branch.log \
    101         $repository/trunk $repository/$branch_path
    102 # -----------------------------------------------------------------------------
    103 echo_eval git checkout master
    104 git_branch_name=`echo $svn_branch_path | sed -e 's|^branches/||'`
    105 echo_eval git branch $git_branch_name
     108        $svn_repository/trunk $svn_repository/$svn_branch_path
  • trunk/bin/push_git2svn.py

    r3593 r3607  
    3434# some settings
    3535svn_repository = 'https://projects.coin-or.org/svn/CppAD'
    36 git_repository = 'https://github.com/bradbell/cppad'
     36git_repository = 'https://github.com/coin-or/CppAD'
    3737work_directory = 'build/work'
    3838# -----------------------------------------------------------------------------
  • trunk/bin/search.sh

    r3212 r3607  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    2323fi
    2424pattern="$1"
    25 dir_list='
    26         bin
    27         cppad
    28         cppad_ipopt
    29         example
    30         introduction
    31         multi_thread
    32         omh
    33         pkgconfig
    34         print_for
    35         speed
    36         test_more
    37 '
    38 #
    39 grep -l -r  "$pattern" $dir_list | \
    40          sed -e '/\/makefile.in/d' -e '/test_one.exe/d'  -e '/\/new\//d'
    41 grep -l "$pattern" makefile.am CMakeLists.txt doc.omh | \
    42          sed -e '/\/makefile.in/d' -e '/test_one.exe/d'  -e '/\/new\//d'
     25if [ ! -e .git ]
     26then
     27        echo 'bin/search.sh: is only implemented for git repsoitory'
     28        exit 1
     29fi
     30# -----------------------------------------------------------------------------
     31file_list=`git ls-files`
     32grep -l "$pattern" $file_list
  • trunk/bin/speed_new.sh

    r3565 r3607  
    2121usage: bin/speed_new.sh option_1 option_2 ...
    2222where the possible options are:
    23         onetape, colpack, optimize, atomic, memory, boolsparsity
     23        onetape, colpack, optimize, atomic, memory, boolsparsity, colpack
    2424Use the special value 'none' for no options
    2525EOF
     
    9696        #
    9797        # run speed test for the current version
    98         echo "./speed_cppad speed 123 $tmp $* > cur_speed.out"
     98        echo "./speed_cppad speed 123 $* > cur_speed.out"
    9999        ./speed_cppad speed 123 $* > cur_speed.out
    100100        #
  • trunk/cppad/local/ad.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    4040        // template friend functions where template parameter is not bound
    4141        template <class VectorAD>
    42         friend void Independent(VectorAD &x);
     42        friend void Independent(VectorAD &x, size_t abort_op_index);
    4343
    4444        // one argument functions
  • trunk/cppad/local/ad_fun.hpp

    r3301 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    7777// Private member variables
    7878private:
     79        /// Has this ADFun object been optmized
     80        bool has_been_optimized_;
     81
    7982        /// Check for nan's and report message to user (default value is true).
    8083        bool check_for_nan_;
    8184
    82         /// debug checking number of comparision operations that changed
    83         size_t compare_change_;
     85        /// If zero, ignoring comparison operators. Otherwise is the
     86        /// compare change count at which to store the operator index.
     87        size_t compare_change_count_;
     88
     89        /// If compare_change_count_ is zero, compare_change_number_ is also zero.
     90        /// Otherwise, it is set to the number of comparison operations that had a
     91        /// different result during the subsequent zero order forward.
     92        size_t compare_change_number_;
     93
     94        /// If compare_change_count is zero, compare_change_op_index_ is also
     95        /// zero. Otherwise it is the operator index for the comparison operator
     96        //// that corresponded to the number changing from count-1 to count.
     97        size_t compare_change_op_index_;
    8498
    8599        /// number of orders stored in taylor_
     
    398412        }
    399413
    400 # ifndef NDEBUG
    401         /// in not NDEBUG case, number of comparison operations that change
     414        /// Deprecated: number of comparison operations that changed
     415        /// for the previous zero order forward (than when function was recorded)
    402416        size_t CompareChange(void) const
    403         {       return compare_change_; }
    404 # endif
     417        {       return compare_change_number_; }
     418
     419        /// count as which to store operator index
     420        void compare_change_count(size_t count)
     421        {       compare_change_count_    = count;
     422                compare_change_number_   = 0;
     423                compare_change_op_index_ = 0;
     424        }
     425
     426        /// number of comparison operations that changed
     427        size_t compare_change_number(void) const
     428        {       return compare_change_number_; }
     429
     430        /// operator index for the count-th  comparison change
     431        size_t compare_change_op_index(void) const
     432        {       if( has_been_optimized_ )
     433                        return 0;
     434                return compare_change_op_index_;
     435        }
    405436
    406437        /// calculate entire Jacobian
  • trunk/cppad/local/ad_tape.hpp

    r3153 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    119119        );
    120120
    121         // see Compare.h
    122         void RecordCompare(
    123                 enum CompareOp  cop      ,
    124                 bool            result   ,
    125                 const AD<Base> &left     ,
    126                 const AD<Base> &right
    127         );
    128 
    129121        // place a VecAD object in the tape
    130122        size_t AddVec(
     
    139131        template <typename VectorADBase>
    140132        void Independent(VectorADBase &u);
     133        template <typename VectorADBase>
     134        void Independent(VectorADBase &u, size_t abort_op_index);
    141135
    142136};
  • trunk/cppad/local/atomic_base.hpp

    r3232 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    243243$index atomic_sparsity$$
    244244$index sparsity, atomic$$
    245 You can used this option to set to type used for
     245You can used this option to set the type used for
    246246$icode afun$$ sparsity patterns.
    247247This does not apply individual calls to $icode afun$$,
  • trunk/cppad/local/checkpoint.hpp

    r3301 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    197197                // now optimize (we expect to use this function many times).
    198198                f_.optimize();
     199                // now disable checking of comparison opertaions
     200                // 2DO: add a debugging mode that checks for changes and aborts
     201                f_.compare_change_count(0);
    199202        }
    200203        /*!
  • trunk/cppad/local/comp_op.hpp

    r3301 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    2121*/
    2222
    23 /*!
    24 Zero order forward mode execution of op = CompOp.
    25 
    26 The C++ source code corresponding to this operation is
    27 \verbatim
    28         left Cop right
    29 \endverbatim
    30 where Cop is one of the following:
    31 <, <=, == , >=, >, !=.
    32 
    33 \tparam Base
    34 base type for the operator; i.e., this operation was recorded
    35 using AD< \a Base > and computations by this routine are done using type
    36 \a Base.
     23// -------------------------------- <= -----------------------------------
     24/*!
     25Zero order forward mode comparison check that left <= right
    3726
    3827\param count
    39 If the comparision has the same result as when t operation seqeunce was
    40 recorded, \a count is not affected.
    41 Otherwise it is incremented by one.
     28It the condition is not true, ths counter is incremented by one.
    4229
    4330\param arg
    44 \n
    45 \a arg[0]
    46 is static cast to size_t from the enum type
    47 \verbatim
    48         enum CompareOp {
    49                 CompareLt,
    50                 CompareLe,
    51                 CompareEq,
    52                 CompareGe,
    53                 CompareGt,
    54                 CompareNe
    55         }
    56 \endverbatim
    57 for this operation.
    58 \n
    59 \n
    60 \a arg[1] & 1
    61 \n
    62 If this expression is true,
    63 the result of the comparison during taping it true.
    64 Othwise the result if false.
    65 \n
    66 \n
    67 \a arg[1] & 2
    68 \n
    69 if this expression is true, left is a variable, otherwise it is a parameter.
    70 \n
    71 \n
    72 \a arg[1] & 4
    73 \n
    74 if this expression is true, right is a variable, otherwise it is a parameter.
    75 \n
    76 
    77 \param num_par
    78 is the lenght of the \a parameter vector.
    79 This value is only used for checking assumptions mentioned below
    80 (and is not used at all when NDEBUG is defined).
     31parameter[ arg[0] ] is the left operand and
     32taylor[ arg[1] * cap_order + 0 ] is the zero order Taylor coefficient
     33for the right operand.
    8134
    8235\param parameter
    83 Vector of parameters corresponding to the tape.
    84 If left is a parameter, \a parameter[ arg[2] ] is its value.
    85 If right is a parameter, \a parameter[ arg[3] ] is its value.
     36vector of parameter values.
    8637
    8738\param cap_order
    88 number of columns in the matrix containing the Taylor coefficients.
     39number of Taylor coefficients allocated for each variable
    8940
    9041\param taylor
    91 Matrix of Taylor coefficients.
    92 If left is a variable, \a taylor[ arg[2] * cap_order + 0 ] is its value.
    93 If right is a variable, \a taylor[ arg[3] * cap_order + 0 ] is its value.
    94 
    95 
    96 \par Checked Assertions where op is a binary operator:
    97 \li NumArg(ComOp) == 4
    98 \li NumRes(ComOp) == 0
    99 \li size_t(arg[0]) <= static_cast<size_t>( CompareNe )
    100 \li arg[1] != 0 (either left or right is a variable)
    101 \li if left is a parameter, \a arg[2] < \a num_par
    102 \li if right is a parameter, \a arg[3] < \a num_par
    103 
    104 */
    105 template <class Base>
    106 inline void forward_comp_op_0(
    107         size_t&        count       ,
    108         const addr_t*  arg         ,
    109         size_t         num_par     ,
    110         const Base*    parameter   ,
    111         size_t         cap_order   ,
    112         Base*          taylor      )
    113 {       bool result;
    114         Base left;
    115         Base right;
    116 
    117         CPPAD_ASSERT_UNKNOWN( NumArg(ComOp) == 4 );
    118         CPPAD_ASSERT_UNKNOWN( NumRes(ComOp) == 0 );
    119         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= static_cast<size_t> (CompareNe) );
    120         CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    121 
    122         // result of comparision during recording
    123         result = (arg[1] & 1) == 1;
    124 
    125         // value of left operand for this forward sweep
    126         if( arg[1] & 2 )
    127                 left = taylor[ arg[2] * cap_order + 0 ];
    128         else
    129         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
    130                 left = parameter[ arg[2] ];
    131         }
    132 
    133         // value of right operand for this forward sweep.
    134         if( arg[1] & 4 )
    135                 right = taylor[ arg[3] * cap_order + 0 ];
    136         else
    137         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
    138                 right = parameter[ arg[3] ];
    139         }
    140         switch( CompareOp( arg[0] ) )
    141         {       case CompareLt:
    142                 count += ( result != LessThanZero(left - right) );
    143                 break;
    144 
    145                 case CompareLe:
    146                 count += ( result != LessThanOrZero(left - right) );
    147                 break;
    148 
    149                 case CompareEq:
    150                 count += ( result != (left == right) );
    151                 break;
    152 
    153                 case CompareGe:
    154                 count += ( result != GreaterThanOrZero(left - right) );
    155                 break;
    156 
    157                 case CompareGt:
    158                 count += ( result != GreaterThanZero(left - right) );
    159                 break;
    160 
    161                 case CompareNe:
    162                 count += ( result != (left != right) );
    163                 break;
    164 
    165                 default:
    166                 CPPAD_ASSERT_UNKNOWN(0);
    167         }
    168         return;
    169 }
     42vector of taylor coefficients.
     43*/
     44template <class Base>
     45inline void forward_lepv_op_0(
     46        size_t&       count       ,
     47        const addr_t* arg         ,
     48        const Base*   parameter   ,
     49        size_t        cap_order   ,
     50        Base*         taylor      )
     51{
     52        // check assumptions
     53        CPPAD_ASSERT_UNKNOWN( NumArg(LepvOp) == 2 );
     54        CPPAD_ASSERT_UNKNOWN( NumRes(LepvOp) == 0 );
     55
     56        // Taylor coefficients corresponding to arguments and result
     57        Base  x = parameter[ arg[0] ];
     58        Base* y = taylor + arg[1] * cap_order;
     59
     60        count += GreaterThanZero(x - y[0]);
     61}
     62/*!
     63Zero order forward mode comparison check that left <= right
     64
     65\param count
     66It the condition is not true, ths counter is incremented by one.
     67
     68\param arg
     69taylor[ arg[0] * cap_order + 0 ] is the zero order Taylor coefficient
     70for the left operand and  parameter[ arg[1] ] is the right operand
     71
     72\param parameter
     73vector of parameter values.
     74
     75\param cap_order
     76number of Taylor coefficients allocated for each variable
     77
     78\param taylor
     79vector of taylor coefficients.
     80*/
     81template <class Base>
     82inline void forward_levp_op_0(
     83        size_t&       count       ,
     84        const addr_t* arg         ,
     85        const Base*   parameter   ,
     86        size_t        cap_order   ,
     87        Base*         taylor      )
     88{
     89        // check assumptions
     90        CPPAD_ASSERT_UNKNOWN( NumArg(LevpOp) == 2 );
     91        CPPAD_ASSERT_UNKNOWN( NumRes(LevpOp) == 0 );
     92
     93        // Taylor coefficients corresponding to arguments and result
     94        Base* x = taylor + arg[0] * cap_order;
     95        Base  y = parameter[ arg[1] ];
     96
     97        count += GreaterThanZero(x[0] - y);
     98}
     99/*!
     100Zero order forward mode comparison check that left <= right
     101
     102\param count
     103It the condition is not true, ths counter is incremented by one.
     104
     105\param arg
     106taylor[ arg[0] * cap_order + 0 ] is the zero order Taylor coefficient
     107for the left operand and 
     108taylor[ arg[1] * cap_order + 0 ] is the zero order Taylor coefficient
     109for the right operand.
     110
     111\param parameter
     112vector of parameter values.
     113
     114\param cap_order
     115number of Taylor coefficients allocated for each variable
     116
     117\param taylor
     118vector of taylor coefficients.
     119*/
     120template <class Base>
     121inline void forward_levv_op_0(
     122        size_t&       count       ,
     123        const addr_t* arg         ,
     124        const Base*   parameter   ,
     125        size_t        cap_order   ,
     126        Base*         taylor      )
     127{
     128        // check assumptions
     129        CPPAD_ASSERT_UNKNOWN( NumArg(LevvOp) == 2 );
     130        CPPAD_ASSERT_UNKNOWN( NumRes(LevvOp) == 0 );
     131
     132        // Taylor coefficients corresponding to arguments and result
     133        Base* x = taylor + arg[0] * cap_order;
     134        Base* y = taylor + arg[1] * cap_order;
     135
     136        count += GreaterThanZero(x[0] - y[0]);
     137}
     138// ------------------------------- < -------------------------------------
     139/*!
     140Zero order forward mode comparison check that left < right
     141
     142\copydetails forward_lepv_op_0
     143*/
     144template <class Base>
     145inline void forward_ltpv_op_0(
     146        size_t&       count       ,
     147        const addr_t* arg         ,
     148        const Base*   parameter   ,
     149        size_t        cap_order   ,
     150        Base*         taylor      )
     151{
     152        // check assumptions
     153        CPPAD_ASSERT_UNKNOWN( NumArg(LtpvOp) == 2 );
     154        CPPAD_ASSERT_UNKNOWN( NumRes(LtpvOp) == 0 );
     155
     156        // Taylor coefficients corresponding to arguments and result
     157        Base  x = parameter[ arg[0] ];
     158        Base* y = taylor + arg[1] * cap_order;
     159
     160        count += GreaterThanOrZero(x - y[0]);
     161}
     162/*!
     163Zero order forward mode comparison check that left < right
     164
     165\copydetails forward_levp_op_0
     166*/
     167template <class Base>
     168inline void forward_ltvp_op_0(
     169        size_t&       count       ,
     170        const addr_t* arg         ,
     171        const Base*   parameter   ,
     172        size_t        cap_order   ,
     173        Base*         taylor      )
     174{
     175        // check assumptions
     176        CPPAD_ASSERT_UNKNOWN( NumArg(LtvpOp) == 2 );
     177        CPPAD_ASSERT_UNKNOWN( NumRes(LtvpOp) == 0 );
     178
     179        // Taylor coefficients corresponding to arguments and result
     180        Base* x = taylor + arg[0] * cap_order;
     181        Base  y = parameter[ arg[1] ];
     182
     183        count += GreaterThanOrZero(x[0] - y);
     184}
     185/*!
     186Zero order forward mode comparison check that left < right
     187
     188\copydetails forward_levv_op_0
     189*/
     190template <class Base>
     191inline void forward_ltvv_op_0(
     192        size_t&       count       ,
     193        const addr_t* arg         ,
     194        const Base*   parameter   ,
     195        size_t        cap_order   ,
     196        Base*         taylor      )
     197{
     198        // check assumptions
     199        CPPAD_ASSERT_UNKNOWN( NumArg(LtvvOp) == 2 );
     200        CPPAD_ASSERT_UNKNOWN( NumRes(LtvvOp) == 0 );
     201
     202        // Taylor coefficients corresponding to arguments and result
     203        Base* x = taylor + arg[0] * cap_order;
     204        Base* y = taylor + arg[1] * cap_order;
     205
     206        count += GreaterThanOrZero(x[0] - y[0]);
     207}
     208// ------------------------------ == -------------------------------------
     209/*!
     210Zero order forward mode comparison check that left == right
     211
     212\copydetails forward_lepv_op_0
     213*/
     214template <class Base>
     215inline void forward_eqpv_op_0(
     216        size_t&       count       ,
     217        const addr_t* arg         ,
     218        const Base*   parameter   ,
     219        size_t        cap_order   ,
     220        Base*         taylor      )
     221{
     222        // check assumptions
     223        CPPAD_ASSERT_UNKNOWN( NumArg(EqpvOp) == 2 );
     224        CPPAD_ASSERT_UNKNOWN( NumRes(EqpvOp) == 0 );
     225
     226        // Taylor coefficients corresponding to arguments and result
     227        Base  x = parameter[ arg[0] ];
     228        Base* y = taylor + arg[1] * cap_order;
     229
     230        count += (x != y[0]);
     231}
     232/*!
     233Zero order forward mode comparison check that left == right
     234
     235\copydetails forward_levv_op_0
     236*/
     237template <class Base>
     238inline void forward_eqvv_op_0(
     239        size_t&       count       ,
     240        const addr_t* arg         ,
     241        const Base*   parameter   ,
     242        size_t        cap_order   ,
     243        Base*         taylor      )
     244{
     245        // check assumptions
     246        CPPAD_ASSERT_UNKNOWN( NumArg(EqvvOp) == 2 );
     247        CPPAD_ASSERT_UNKNOWN( NumRes(EqvvOp) == 0 );
     248
     249        // Taylor coefficients corresponding to arguments and result
     250        Base* x = taylor + arg[0] * cap_order;
     251        Base* y = taylor + arg[1] * cap_order;
     252
     253        count += (x[0] != y[0]);
     254}
     255// -------------------------------- != -----------------------------------
     256/*!
     257Zero order forward mode comparison check that left != right
     258
     259\copydetails forward_lepv_op_0
     260*/
     261template <class Base>
     262inline void forward_nepv_op_0(
     263        size_t&       count       ,
     264        const addr_t* arg         ,
     265        const Base*   parameter   ,
     266        size_t        cap_order   ,
     267        Base*         taylor      )
     268{
     269        // check assumptions
     270        CPPAD_ASSERT_UNKNOWN( NumArg(NepvOp) == 2 );
     271        CPPAD_ASSERT_UNKNOWN( NumRes(NepvOp) == 0 );
     272
     273        // Taylor coefficients corresponding to arguments and result
     274        Base  x = parameter[ arg[0] ];
     275        Base* y = taylor + arg[1] * cap_order;
     276
     277        count += (x == y[0]);
     278}
     279/*!
     280Zero order forward mode comparison check that left != right
     281
     282\copydetails forward_levv_op_0
     283*/
     284template <class Base>
     285inline void forward_nevv_op_0(
     286        size_t&       count       ,
     287        const addr_t* arg         ,
     288        const Base*   parameter   ,
     289        size_t        cap_order   ,
     290        Base*         taylor      )
     291{
     292        // check assumptions
     293        CPPAD_ASSERT_UNKNOWN( NumArg(NevvOp) == 2 );
     294        CPPAD_ASSERT_UNKNOWN( NumRes(NevvOp) == 0 );
     295
     296        // Taylor coefficients corresponding to arguments and result
     297        Base* x = taylor + arg[0] * cap_order;
     298        Base* y = taylor + arg[1] * cap_order;
     299
     300        count += (x[0] == y[0]);
     301}
     302
     303
    170304} // END_CPPAD_NAMESPACE
    171305# endif
  • trunk/cppad/local/compare.hpp

    r2506 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    4747Compares two operands where one of the operands is an
    4848$codei%AD<%Base%>%$$ object.
    49 The comparison has the same interpretation as for 
     49The comparison has the same interpretation as for
    5050the $icode Base$$ type.
    5151
     
    6262$code !=$$  $cnext is $icode x$$ not equal to $icode y$$
    6363$tend
    64  
     64
    6565$head x$$
    6666The operand $icode x$$ has prototype
     
    9292
    9393$$
    94 For example, suppose 
     94For example, suppose
    9595$icode x$$ and $icode y$$ are $codei%AD<%Base%>%$$ objects,
    9696the tape corresponding to $codei%AD<%Base%>%$$ is recording,
     
    100100        if( %b% )
    101101                %y% = cos(%x%);
    102         else    %y% = sin(%x%); 
     102        else    %y% = sin(%x%);
    103103%$$
    104104only the assignment $icode%y% = cos(%x%)%$$ is recorded on the tape
    105 (if $icode x$$ is a $cref/parameter/glossary/Parameter/$$, 
     105(if $icode x$$ is a $cref/parameter/glossary/Parameter/$$,
    106106nothing is recorded).
    107107The $cref CompareChange$$ function can yield
    108108some information about changes in comparison operation results.
    109109You can use $cref CondExp$$ to obtain comparison operations
    110 that depends on the 
    111 $cref/independent variable/glossary/Tape/Independent Variable/$$ 
     110that depends on the
     111$cref/independent variable/glossary/Tape/Independent Variable/$$
    112112values with out re-taping the AD sequence of operations.
    113113
     
    115115If one of the $icode Op$$ operators listed above
    116116is used with an $codei%AD<%Base%>%$$ object,
    117 it is assumed that the same operator is supported by the base type 
     117it is assumed that the same operator is supported by the base type
    118118$icode Base$$.
    119119
     
    133133namespace CppAD {
    134134
    135 template <class Base>
    136 
    137 // -------------- RecordCompare(cop, result, left, right) --------------------
    138 /// All these operations are done in \c Rec_, so we should move this
    139 /// routine to <tt>recorder<Base></tt>.
    140 void ADTape<Base>::RecordCompare(
    141         enum CompareOp  cop   ,
    142         bool           result ,
    143         const AD<Base> &left  ,
    144         const AD<Base> &right )
    145 {       addr_t ind0, ind1, ind2, ind3;
    146 
    147         // ind[1] = base 2 representation of [result, Var(left), Var(right])
    148         ind1 = 0;
    149 
    150         // ind[2] = left address
    151         if( Parameter(left) )
    152                 ind2 = Rec_.PutPar(left.value_);
    153         else
    154         {       ind1 += 2;
    155                 ind2 =  left.taddr_;
    156         }
    157 
    158         // ind[3] = right address
    159         if( Parameter(right) )
    160                 ind3 = Rec_.PutPar(right.value_);
    161         else
    162         {       ind1 += 4;
    163                 ind3 =  right.taddr_;
    164         }
    165 
    166         // If both left and right are parameters, do not need to record
    167         if( ind1 == 0 )
    168                 return;
    169 
    170         // ind[1] & 1 = result
    171         if( result )
    172                 ind1+= 1;
    173 
    174         // ind[0] = cop
    175         ind0 = size_t (cop);
    176 
    177         CPPAD_ASSERT_UNKNOWN( ind1 > 1 );
    178         CPPAD_ASSERT_UNKNOWN( NumArg(ComOp) == 4 );
    179         CPPAD_ASSERT_UNKNOWN( NumRes(ComOp) == 0 );
    180 
    181         // put the operator in the tape
    182         Rec_.PutOp(ComOp);
    183         Rec_.PutArg(ind0, ind1, ind2, ind3);
    184 }
    185 
    186 // -------------------------------- < -------------------------
    187 # ifdef NDEBUG
    188 
     135// -------------------------------- < --------------------------
    189136template <class Base>
    190137CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    191138bool operator < (const AD<Base> &left , const AD<Base> &right)
    192 {       bool result =  (left.value_ < right.value_);
    193         return result;
    194 }
    195 
    196 # else
    197 template <class Base>
    198 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    199 bool operator < (const AD<Base> &left , const AD<Base> &right)
    200 {       bool result =  (left.value_ < right.value_);
    201 
    202         ADTape<Base> *tape = CPPAD_NULL;
    203         if( Variable(left) )
    204                 tape = left.tape_this();
    205         else if ( Variable(right) )
    206                 tape = right.tape_this();
    207 
    208         if( tape != CPPAD_NULL )
    209                 tape->RecordCompare(CompareLt, result, left, right);
    210 
    211         return result;
    212 }
     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
    213425# endif
    214 
    215 // convert other cases into the case above
    216 CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(<)
    217 
    218 // -------------------------------- <= -------------------------
    219 # ifdef NDEBUG
    220 
    221 template <class Base>
    222 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    223 bool operator <= (const AD<Base> &left , const AD<Base> &right)
    224 {       bool result =  (left.value_ <= right.value_);
    225         return result;
    226 }
    227 
    228 # else
    229 template <class Base>
    230 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    231 bool operator <= (const AD<Base> &left , const AD<Base> &right)
    232 {       bool result =  (left.value_ <= right.value_);
    233 
    234         ADTape<Base> *tape = CPPAD_NULL;
    235         if( Variable(left) )
    236                 tape = left.tape_this();
    237         else if ( Variable(right) )
    238                 tape = right.tape_this();
    239 
    240         if( tape != CPPAD_NULL )
    241                 tape->RecordCompare(CompareLe, result, left, right);
    242 
    243         return result;
    244 }
    245 # endif
    246 
    247 // convert other cases into the case above
    248 CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(<=)
    249 
    250 
    251 // -------------------------------- > -------------------------
    252 # ifdef NDEBUG
    253 
    254 template <class Base>
    255 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    256 bool operator > (const AD<Base> &left , const AD<Base> &right)
    257 {       bool result =  (left.value_ > right.value_);
    258         return result;
    259 }
    260 
    261 # else
    262 template <class Base>
    263 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    264 bool operator > (const AD<Base> &left , const AD<Base> &right)
    265 {       bool result =  (left.value_ > right.value_);
    266 
    267         ADTape<Base> *tape = CPPAD_NULL;
    268         if( Variable(left) )
    269                 tape = left.tape_this();
    270         else if ( Variable(right) )
    271                 tape = right.tape_this();
    272 
    273         if( tape != CPPAD_NULL )
    274                 tape->RecordCompare(CompareGt, result, left, right);
    275 
    276 
    277         return result;
    278 }
    279 # endif
    280 
    281 // convert other cases into the case above
    282 CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(>)
    283 
    284 // -------------------------------- >= -------------------------
    285 # ifdef NDEBUG
    286 
    287 template <class Base>
    288 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    289 bool operator >= (const AD<Base> &left , const AD<Base> &right)
    290 {       bool result =  (left.value_ >= right.value_);
    291         return result;
    292 }
    293 
    294 # else
    295 template <class Base>
    296 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    297 bool operator >= (const AD<Base> &left , const AD<Base> &right)
    298 {       bool result =  (left.value_ >= right.value_);
    299 
    300         ADTape<Base> *tape = CPPAD_NULL;
    301         if( Variable(left) )
    302                 tape = left.tape_this();
    303         else if ( Variable(right) )
    304                 tape = right.tape_this();
    305 
    306         if( tape != CPPAD_NULL )
    307                 tape->RecordCompare(CompareGe, result, left, right);
    308 
    309         return result;
    310 }
    311 # endif
    312 
    313 // convert other cases into the case above
    314 CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(>=)
    315 
    316 
    317 // -------------------------------- == -------------------------
    318 # ifdef NDEBUG
    319 
    320 template <class Base>
    321 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    322 bool operator == (const AD<Base> &left , const AD<Base> &right)
    323 {       bool result =  (left.value_ == right.value_);
    324         return result;
    325 }
    326 
    327 # else
    328 template <class Base>
    329 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    330 bool operator == (const AD<Base> &left , const AD<Base> &right)
    331 {       bool result =  (left.value_ == right.value_);
    332 
    333         ADTape<Base> *tape = CPPAD_NULL;
    334         if( Variable(left) )
    335                 tape = left.tape_this();
    336         else if ( Variable(right) )
    337                 tape = right.tape_this();
    338 
    339         if( tape != CPPAD_NULL )
    340                 tape->RecordCompare(CompareEq, result, left, right);
    341 
    342         return result;
    343 }
    344 # endif
    345 
    346 // convert other cases into the case above
    347 CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(==)
    348 
    349 // -------------------------------- != -------------------------
    350 # ifdef NDEBUG
    351 
    352 template <class Base>
    353 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    354 bool operator != (const AD<Base> &left , const AD<Base> &right)
    355 {       bool result =  (left.value_ != right.value_);
    356         return result;
    357 }
    358 
    359 # else
    360 template <class Base>
    361 CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    362 bool operator != (const AD<Base> &left , const AD<Base> &right)
    363 {       bool result =  (left.value_ != right.value_);
    364 
    365         ADTape<Base> *tape = CPPAD_NULL;
    366         if( Variable(left) )
    367                 tape = left.tape_this();
    368         else if ( Variable(right) )
    369                 tape = right.tape_this();
    370 
    371         if( tape != CPPAD_NULL )
    372                 tape->RecordCompare(CompareNe, result, left, right);
    373 
    374         return result;
    375 }
    376 # endif
    377 
    378 // convert other cases into the case above
    379 CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(!=)
    380 
    381 } // END CppAD namespace
    382 
    383 # endif
  • trunk/cppad/local/cond_exp.hpp

    r3170 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    132132$cref/wish list/WishList/Conditional Expressions/$$.
    133133
    134 $head Deprecated$$
     134$head Deprecate 2005-08-07$$
    135135Previous versions of CppAD used
    136136$codei%
  • trunk/cppad/local/dependent.hpp

    r3301 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    279279
    280280        // some size_t values in ad_fun.hpp
    281         compare_change_       = 0;
    282         num_order_taylor_     = 0;
    283         num_direction_taylor_ = 0;
    284         cap_order_taylor_     = 0;
     281        has_been_optimized_        = false;
     282        compare_change_count_      = 1;
     283        compare_change_number_     = 0;
     284        compare_change_op_index_   = 0;
     285        num_order_taylor_          = 0;
     286        num_direction_taylor_      = 0;
     287        cap_order_taylor_          = 0;
    285288
    286289        // num_var_tape_
  • trunk/cppad/local/discrete.hpp

    r3359 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    148148shows how interpolation can be done with retaping.)
    149149
    150 $head Deprecated$$
     150$head CppADCreateDiscrete Deprecated 2007-07-28$$
    151151$index CppADCreateDiscrete, deprecated$$
    152152$index deprecated, CppADCreateDiscrete$$
  • trunk/cppad/local/epsilon.hpp

    r2506 r3607  
    33# define CPPAD_EPSILON_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    2828$section Machine Epsilon For AD Types$$
    2929
    30 $head Deprecated$$
     30$head Deprecated 2012-06-17$$
    3131$index deprecated, epsilon$$
    3232This routine has bee deprecated.
  • trunk/cppad/local/for_jac_sweep.hpp

    r3495 r3607  
    33# define CPPAD_FOR_JAC_SWEEP_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    274274                        );
    275275                        break;
    276                         // ---------------------------------------------------
    277 
    278                         case ComOp:
    279                         CPPAD_ASSERT_NARG_NRES(op, 4, 0);
    280                         CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    281                         break;
    282276                        // --------------------------------------------------
    283277
     
    381375                                vecad_sparsity
    382376                        );
     377                        break;
     378                        // -------------------------------------------------
     379
     380                        case EqpvOp:
     381                        case EqvvOp:
     382                        case LtpvOp:
     383                        case LtvpOp:
     384                        case LtvvOp:
     385                        case LepvOp:
     386                        case LevpOp:
     387                        case LevvOp:
     388                        case NepvOp:
     389                        case NevvOp:
     390                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    383391                        break;
    384392                        // -------------------------------------------------
  • trunk/cppad/local/forward.hpp

    r3301 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    148148        CPPAD_ASSERT_UNKNOWN( load_op_.size()  == play_.num_load_op_rec() );
    149149        if( q == 0 )
    150         {
    151                 compare_change_ = forward0sweep(s, true,
     150        {       forward0sweep(s, true,
    152151                        n, num_var_tape_, &play_, C,
    153                         taylor_.data(), cskip_op_.data(), load_op_
    154                 );
    155         }
    156         else if( p == 0 )
    157         {       compare_change_ = forward1sweep(s, true, p, q,
    158                         n, num_var_tape_, &play_, C,
    159                         taylor_.data(), cskip_op_.data(), load_op_
     152                        taylor_.data(), cskip_op_.data(), load_op_,
     153                        compare_change_count_,
     154                        compare_change_number_,
     155                        compare_change_op_index_
    160156                );
    161157        }
     
    163159        {       forward1sweep(s, true, p, q,
    164160                        n, num_var_tape_, &play_, C,
    165                         taylor_.data(), cskip_op_.data(), load_op_
     161                        taylor_.data(), cskip_op_.data(), load_op_,
     162                        compare_change_count_,
     163                        compare_change_number_,
     164                        compare_change_op_index_
    166165                );
    167166        }
  • trunk/cppad/local/forward0sweep.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    125125Note that the is no variable with index zero on the tape.
    126126
    127 \return
    128 The return value is equal to the number of ComOp operations
     127\param compare_change_count
     128Is the count value for changing number and op_index during
     129zero order foward mode.
     130
     131\param compare_change_number
     132If compare_change_count is zero, this value is set to zero.
     133Otherwise, the return value is the number of comparision operations
    129134that have a different result from when the information in
    130135play was recorded.
    131 (Note that if NDEBUG is true, there are no ComOp operations
    132 in play and hence this return value is always zero.)
     136
     137\param compare_change_op_index
     138If compare_change_count is zero, this value is set to zero.
     139Otherwise it is the operator index (see forward_next) for the count-th
     140comparision operation that has a different result from when the information in
     141play was recorded.
    133142*/
    134143
    135144template <class Base>
    136 size_t forward0sweep(
     145void forward0sweep(
    137146        std::ostream&         s_out,
    138147        bool                  print,
     
    143152        Base*                 taylor,
    144153        bool*                 cskip_op,
    145         pod_vector<addr_t>&   var_by_load_op
     154        pod_vector<addr_t>&   var_by_load_op,
     155        size_t                compare_change_count,
     156        size_t&               compare_change_number,
     157        size_t&               compare_change_op_index
    146158)
    147159{       CPPAD_ASSERT_UNKNOWN( J >= 1 );
     
    167179        const addr_t*   arg = CPPAD_NULL;
    168180
    169         // initialize the comparision operator (ComOp) counter
    170         size_t compareCount = 0;
     181        // initialize the comparision operator counter
     182        if( p == 0 )
     183        {       compare_change_number   = 0;
     184                compare_change_op_index = 0;
     185        }
    171186
    172187        // If this includes a zero calculation, initialize this information
     
    317332                        break;
    318333                        // ---------------------------------------------------
    319                         case ComOp:
    320                         forward_comp_op_0(
    321                         compareCount, arg, num_par, parameter, J, taylor
    322                         );
    323                         break;
    324                         // ---------------------------------------------------
    325334
    326335                        case CosOp:
     
    388397                        // -------------------------------------------------
    389398
     399                        case EqpvOp:
     400                        if( compare_change_count )
     401                        {       forward_eqpv_op_0(
     402                                        compare_change_number, arg, parameter, J, taylor
     403                                );
     404                                {       if( compare_change_count == compare_change_number )
     405                                                compare_change_op_index = i_op;
     406                                }
     407                        }
     408                        break;
     409                        // -------------------------------------------------
     410
     411                        case EqvvOp:
     412                        if( compare_change_count )
     413                        {       forward_eqvv_op_0(
     414                                        compare_change_number, arg, parameter, J, taylor
     415                                );
     416                                {       if( compare_change_count == compare_change_number )
     417                                                compare_change_op_index = i_op;
     418                                }
     419                        }
     420                        break;
     421                        // -------------------------------------------------
     422
    390423# if CPPAD_COMPILER_HAS_ERF
    391424                        case ErfOp:
     
    405438                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    406439                        break;
    407                         // -------------------------------------------------
     440                        // ---------------------------------------------------
    408441
    409442                        case LdpOp:
     
    437470                        // -------------------------------------------------
    438471
     472                        case LepvOp:
     473                        if( compare_change_count )
     474                        {       forward_lepv_op_0(
     475                                        compare_change_number, arg, parameter, J, taylor
     476                                );
     477                                {       if( compare_change_count == compare_change_number )
     478                                                compare_change_op_index = i_op;
     479                                }
     480                        }
     481                        break;
     482                        // -------------------------------------------------
     483
     484                        case LevpOp:
     485                        if( compare_change_count )
     486                        {       forward_levp_op_0(
     487                                        compare_change_number, arg, parameter, J, taylor
     488                                );
     489                                {       if( compare_change_count == compare_change_number )
     490                                                compare_change_op_index = i_op;
     491                                }
     492                        }
     493                        break;
     494                        // -------------------------------------------------
     495
     496                        case LevvOp:
     497                        if( compare_change_count )
     498                        {       forward_levv_op_0(
     499                                        compare_change_number, arg, parameter, J, taylor
     500                                );
     501                                {       if( compare_change_count == compare_change_number )
     502                                                compare_change_op_index = i_op;
     503                                }
     504                        }
     505                        break;
     506                        // -------------------------------------------------
     507
    439508                        case LogOp:
    440509                        forward_log_op_0(i_var, arg[0], J, taylor);
     510                        break;
     511                        // -------------------------------------------------
     512
     513                        case LtpvOp:
     514                        if( compare_change_count )
     515                        {       forward_ltpv_op_0(
     516                                        compare_change_number, arg, parameter, J, taylor
     517                                );
     518                                {       if( compare_change_count == compare_change_number )
     519                                                compare_change_op_index = i_op;
     520                                }
     521                        }
     522                        break;
     523                        // -------------------------------------------------
     524
     525                        case LtvpOp:
     526                        if( compare_change_count )
     527                        {       forward_ltvp_op_0(
     528                                        compare_change_number, arg, parameter, J, taylor
     529                                );
     530                                {       if( compare_change_count == compare_change_number )
     531                                                compare_change_op_index = i_op;
     532                                }
     533                        }
     534                        break;
     535                        // -------------------------------------------------
     536
     537                        case LtvvOp:
     538                        if( compare_change_count )
     539                        {       forward_ltvv_op_0(
     540                                        compare_change_number, arg, parameter, J, taylor
     541                                );
     542                                {       if( compare_change_count == compare_change_number )
     543                                                compare_change_op_index = i_op;
     544                                }
     545                        }
    441546                        break;
    442547                        // -------------------------------------------------
     
    450555                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    451556                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
     557                        break;
     558                        // -------------------------------------------------
     559
     560                        case NepvOp:
     561                        if( compare_change_count )
     562                        {       forward_nepv_op_0(
     563                                        compare_change_number, arg, parameter, J, taylor
     564                                );
     565                                {       if( compare_change_count == compare_change_number )
     566                                                compare_change_op_index = i_op;
     567                                }
     568                        }
     569                        break;
     570                        // -------------------------------------------------
     571
     572                        case NevvOp:
     573                        if( compare_change_count )
     574                        {       forward_nevv_op_0(
     575                                        compare_change_number, arg, parameter, J, taylor
     576                                );
     577                                {       if( compare_change_count == compare_change_number )
     578                                                compare_change_op_index = i_op;
     579                                }
     580                        }
    452581                        break;
    453582                        // -------------------------------------------------
     
    766895        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
    767896
    768         return compareCount;
     897        return;
    769898}
    770899
  • trunk/cppad/local/forward1sweep.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    165165the i-th variable.
    166166
    167 \return
    168 If p is not zero, the return value is zero.
    169 If p is zero,
    170 the return value is equal to the number of ComOp operations
     167
     168\param compare_change_count
     169Is the count value for changing number and op_index during
     170zero order foward mode.
     171
     172\param compare_change_number
     173If p is non-zero, this value is not changed, otherwise:
     174If compare_change_count is zero, this value is set to zero, otherwise:
     175this value is set to the number of comparision operations
    171176that have a different result from when the information in
    172 a play was recorded.
    173 (Note that if NDEBUG is true, there are no ComOp operations
    174 in play and hence this return value is always zero.)
     177play was recorded.
     178
     179\param compare_change_op_index
     180if p is non-zero, this value is not changed, otherwise:
     181If compare_change_count is zero, this value is set to zero.
     182Otherwise it is the operator index (see forward_next) for the count-th
     183comparision operation that has a different result from when the information in
     184play was recorded.
    175185*/
    176186
    177187template <class Base>
    178 size_t forward1sweep(
     188void forward1sweep(
    179189        std::ostream&         s_out,
    180190        const bool            print,
     
    187197        Base*                 taylor,
    188198        bool*                 cskip_op,
    189         pod_vector<addr_t>&   var_by_load_op
     199        pod_vector<addr_t>&   var_by_load_op,
     200        size_t                compare_change_count,
     201        size_t&               compare_change_number,
     202        size_t&               compare_change_op_index
    190203)
    191204{
     
    212225        const addr_t*   arg = CPPAD_NULL;
    213226
    214         // initialize the comparision operator (ComOp) counter
    215         size_t compareCount = 0;
     227        // initialize the comparision operator counter
     228        if( p == 0 )
     229        {       compare_change_number   = 0;
     230                compare_change_op_index = 0;
     231        }
    216232
    217233        // If this includes a zero calculation, initialize this information
     
    358374                        // -------------------------------------------------
    359375
    360 # if CPPAD_COMPILER_HAS_ERF
    361                         case ErfOp:
    362                         CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
    363                         // 2DO: implement zero order version of this function
    364                         forward_erf_op(p, q, i_var, arg, parameter, J, taylor);
    365                         break;
    366 # endif
    367                         // -------------------------------------------------
    368 
    369376                        case CExpOp:
    370377                        forward_cond_op(
    371378                                p, q, i_var, arg, num_par, parameter, J, taylor
    372                         );
    373                         break;
    374                         // ---------------------------------------------------
    375 
    376                         case ComOp:
    377                         if( p == 0 ) forward_comp_op_0(
    378                         compareCount, arg, num_par, parameter, J, taylor
    379379                        );
    380380                        break;
     
    447447                        // -------------------------------------------------
    448448
     449                        case EqpvOp:
     450                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     451                        {       forward_eqpv_op_0(
     452                                        compare_change_number, arg, parameter, J, taylor
     453                                );
     454                                if( compare_change_count == compare_change_number )
     455                                        compare_change_op_index = i_op;
     456                        }
     457                        break;
     458                        // -------------------------------------------------
     459
     460                        case EqvvOp:
     461                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     462                        {       forward_eqvv_op_0(
     463                                        compare_change_number, arg, parameter, J, taylor
     464                                );
     465                                if( compare_change_count == compare_change_number )
     466                                        compare_change_op_index = i_op;
     467                        }
     468                        break;
     469                        // -------------------------------------------------
     470
     471# if CPPAD_COMPILER_HAS_ERF
     472                        case ErfOp:
     473                        CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
     474                        // 2DO: implement zero order version of this function
     475                        forward_erf_op(p, q, i_var, arg, parameter, J, taylor);
     476                        break;
     477# endif
     478                        // -------------------------------------------------
     479
    449480                        case ExpOp:
    450481                        forward_exp_op(p, q, i_var, arg[0], J, taylor);
    451482                        break;
    452                         // -------------------------------------------------
     483                        // ---------------------------------------------------
    453484
    454485                        case InvOp:
     
    539570                        // -------------------------------------------------
    540571
     572                        case LepvOp:
     573                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     574                        {       forward_lepv_op_0(
     575                                        compare_change_number, arg, parameter, J, taylor
     576                                );
     577                                if( compare_change_count == compare_change_number )
     578                                        compare_change_op_index = i_op;
     579                        }
     580                        break;
     581
     582                        case LevpOp:
     583                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     584                        {       forward_levp_op_0(
     585                                        compare_change_number, arg, parameter, J, taylor
     586                                );
     587                                if( compare_change_count == compare_change_number )
     588                                        compare_change_op_index = i_op;
     589                        }
     590                        break;
     591                        // -------------------------------------------------
     592
     593                        case LevvOp:
     594                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     595                        {       forward_levv_op_0(
     596                                        compare_change_number, arg, parameter, J, taylor
     597                                );
     598                                if( compare_change_count == compare_change_number )
     599                                        compare_change_op_index = i_op;
     600                        }
     601                        break;
     602                        // -------------------------------------------------
     603
    541604                        case LogOp:
    542605                        forward_log_op(p, q, i_var, arg[0], J, taylor);
     606                        break;
     607                        // -------------------------------------------------
     608
     609                        case LtpvOp:
     610                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     611                        {       forward_ltpv_op_0(
     612                                        compare_change_number, arg, parameter, J, taylor
     613                                );
     614                                if( compare_change_count == compare_change_number )
     615                                        compare_change_op_index = i_op;
     616                        }
     617                        break;
     618
     619                        case LtvpOp:
     620                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     621                        {       forward_ltvp_op_0(
     622                                        compare_change_number, arg, parameter, J, taylor
     623                                );
     624                                if( compare_change_count == compare_change_number )
     625                                        compare_change_op_index = i_op;
     626                        }
     627                        break;
     628                        // -------------------------------------------------
     629
     630                        case LtvvOp:
     631                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     632                        {       forward_ltvv_op_0(
     633                                        compare_change_number, arg, parameter, J, taylor
     634                                );
     635                                if( compare_change_count == compare_change_number )
     636                                        compare_change_op_index = i_op;
     637                        }
    543638                        break;
    544639                        // -------------------------------------------------
     
    552647                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    553648                        forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
     649                        break;
     650                        // -------------------------------------------------
     651
     652                        case NepvOp:
     653                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     654                        {       forward_nepv_op_0(
     655                                        compare_change_number, arg, parameter, J, taylor
     656                                );
     657                                if( compare_change_count == compare_change_number )
     658                                        compare_change_op_index = i_op;
     659                        }
     660                        break;
     661                        // -------------------------------------------------
     662
     663                        case NevvOp:
     664                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
     665                        {       forward_nevv_op_0(
     666                                        compare_change_number, arg, parameter, J, taylor
     667                                );
     668                                if( compare_change_count == compare_change_number )
     669                                        compare_change_op_index = i_op;
     670                        }
    554671                        break;
    555672                        // -------------------------------------------------
     
    8861003        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
    8871004
    888         return compareCount;
     1005        if( (p == 0) & (compare_change_count == 0) )
     1006                compare_change_number = 0;
     1007        return;
    8891008}
    8901009
  • trunk/cppad/local/forward2sweep.hpp

    r3583 r3607  
    135135the instruction corresponds to a parameter (not variable).
    136136
    137 \return
    138 The return value is zero.
    139137*/
    140138
    141139template <class Base>
    142 size_t forward2sweep(
     140void forward2sweep(
    143141        const size_t                q,
    144142        const size_t                r,
     
    170168        // operation argument indices
    171169        const addr_t*   arg = CPPAD_NULL;
    172 
    173         // initialize the comparision operator (ComOp) counter
    174         const size_t compareCount = 0;
    175170
    176171        // work space used by UserOp.
     
    295290                        // ---------------------------------------------------
    296291
    297                         case ComOp:
    298                         CPPAD_ASSERT_UNKNOWN(q > 0 );
    299                         break;
    300                         // ---------------------------------------------------
    301 
    302292                        case CosOp:
    303293                        // sin(x), cos(x)
     
    387377                        );
    388378                        break;
     379                        // ---------------------------------------------------
     380
     381                        case EqpvOp:
     382                        case EqvvOp:
     383                        case LtpvOp:
     384                        case LtvpOp:
     385                        case LtvvOp:
     386                        case LepvOp:
     387                        case LevpOp:
     388                        case LevvOp:
     389                        case NepvOp:
     390                        case NevvOp:
     391                        CPPAD_ASSERT_UNKNOWN(q > 0 );
     392                        break;
    389393                        // -------------------------------------------------
    390394
     
    392396                        forward_log_op_dir(q, r, i_var, arg[0], J, taylor);
    393397                        break;
    394                         // -------------------------------------------------
     398                        // ---------------------------------------------------
    395399
    396400                        case MulvvOp:
     
    736740        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
    737741
    738         return compareCount;
     742        return;
    739743}
    740744
  • trunk/cppad/local/fun_construct.hpp

    r3301 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    262262template <typename Base>
    263263ADFun<Base>::ADFun(void) :
     264has_been_optimized_(false),
    264265check_for_nan_(true) ,
     266compare_change_count_(1),
     267compare_change_number_(0),
     268compare_change_op_index_(0),
    265269num_var_tape_(0)
    266270{ }
     
    294298        //
    295299        // size_t objects
     300        has_been_optimized_        = f.has_been_optimized_;
    296301        check_for_nan_             = f.check_for_nan_;
    297         compare_change_            = f.compare_change_;
     302        compare_change_count_      = f.compare_change_count_;
     303        compare_change_number_     = f.compare_change_number_;
     304        compare_change_op_index_   = f.compare_change_op_index_;
    298305        num_order_taylor_          = f.num_order_taylor_;
    299306        cap_order_taylor_          = f.cap_order_taylor_;
     
    428435        Dependent(tape, y);
    429436
     437
    430438        // ad_fun.hpp member values not set by dependent
    431439        check_for_nan_ = true;
     
    451459        CPPAD_ASSERT_UNKNOWN( cskip_op_.size() == play_.num_op_rec() );
    452460        CPPAD_ASSERT_UNKNOWN( load_op_.size()  == play_.num_load_op_rec() );
    453         compare_change_ = forward0sweep(std::cout, false,
     461        forward0sweep(std::cout, false,
    454462                n, num_var_tape_, &play_, cap_order_taylor_, taylor_.data(),
    455                 cskip_op_.data(), load_op_
     463                cskip_op_.data(), load_op_,
     464                compare_change_count_,
     465                compare_change_number_,
     466                compare_change_op_index_
    456467        );
    457         CPPAD_ASSERT_UNKNOWN( compare_change_ == 0 );
     468        CPPAD_ASSERT_UNKNOWN( compare_change_count_    == 1 );
     469        CPPAD_ASSERT_UNKNOWN( compare_change_number_   == 0 );
     470        CPPAD_ASSERT_UNKNOWN( compare_change_op_index_ == 0 );
    458471
    459472        // now set the number of orders stored
  • trunk/cppad/local/independent.hpp

    r3146 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    1818$begin Independent$$
    1919$spell
     20        op
    2021        alloc
    2122        num
     
    3536
    3637$head Syntax$$
    37 $codei%Independent(%x%)%$$
     38$codei%Independent(%x%)
     39%$$
     40$codei%Independent(%x%, %abort_op_index%)
     41%$$
    3842
    3943$head Purpose$$
     
    4650
    4751$head Start Recording$$
    48 An operation sequence recording is started by the command
     52An operation sequence recording is started by the commands
    4953$codei%
    5054        Independent(%x%)
     55        Independent(%x%, %abort_op_index%)
    5156%$$
    5257
     
    5661using either the $cref/function constructor/FunConstruct/$$
    5762$codei%
    58         ADFun<%Base%> %f%( %x%, %y%)
     63        ADFun<%Base%> %f%(%x%, %y%)
    5964%$$
    6065or the $cref/dependent variable specifier/Dependent/$$
    6166$codei%
    62         %f%.Dependent( %x%, %y%)
     67        %f%.Dependent(%x%, %y%)
    6368%$$
    6469The only other way to stop a recording is using
     
    7883and is the number of independent variables for this
    7984AD operation sequence.
     85
     86$head abort_op_index$$
     87$index abort_op_index$$
     88It specifies the operator index at which the execution is be aborted
     89by calling the CppAD $cref/error handler/ErrorHandler/$$.
     90When this error handler leads to an assert, the user
     91can inspect the call stack to see the source code corresponding to
     92this operator index; see
     93$cref/purpose/compare_change/op_index/Purpose/$$.
     94No abort will occur if $icode abort_op_index$$ is zero,
     95of if $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is defined.
    8096
    8197$head VectorAD$$
     
    121137template <typename Base>
    122138template <typename VectorAD>
    123 void ADTape<Base>::Independent(VectorAD &x)
     139void ADTape<Base>::Independent(VectorAD &x, size_t abort_op_index)
    124140{
    125141        // check VectorAD is Simple Vector class with AD<Base> elements
     
    133149        );
    134150        CPPAD_ASSERT_UNKNOWN( Rec_.num_var_rec() == 0 );
     151
     152        // set the abort index before doing anything else
     153        Rec_.set_abort_op_index(abort_op_index);
    135154
    136155        // mark the beginning of the tape and skip the first variable index
     
    156175
    157176template <typename VectorAD>
    158 inline void Independent(VectorAD &x)
     177inline void Independent(VectorAD &x, size_t abort_op_index)
    159178{       typedef typename VectorAD::value_type ADBase;
    160179        typedef typename ADBase::value_type   Base;
     
    166185        );
    167186        ADTape<Base>* tape = ADBase::tape_manage(tape_manage_new);
    168         tape->Independent(x);
     187        tape->Independent(x, abort_op_index);
    169188}
    170 
    171 
     189template <typename VectorAD>
     190inline void Independent(VectorAD &x)
     191{       size_t abort_op_index = 0;
     192        Independent(x, abort_op_index); }
    172193}
    173194// END CppAD namespace
  • trunk/cppad/local/op_code.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    6565        // arg[4]     = index correspoding to trueCase
    6666        // arg[5]     = index correspoding to falseCase
    67         ComOp,    // Compare(cop, result, left, right)
    6867        CosOp,    //  cos(variable)
    6968        CoshOp,   // cosh(variable)
     
    9190        DivvvOp,  //      variable   / variable
    9291        EndOp,    //  used to mark the end of the tape
     92        EqpvOp,   //  parameter  == variable
     93        EqvvOp,   //  variable   == variable
    9394        ErfOp,    //  erf(variable)
    9495        ExpOp,    //  exp(variable)
     
    9697        LdpOp,    //    z[parameter]
    9798        LdvOp,    //    z[variable]
     99        LepvOp,   //  parameter <= variable
     100        LevpOp,   //  variable  <= parameter
     101        LevvOp,   //  variable  <= variable
    98102        LogOp,    //  log(variable)
     103        LtpvOp,   //  parameter < variable
     104        LtvpOp,   //  variable  < parameter
     105        LtvvOp,   //  variable  < variable
    99106        MulpvOp,  //      parameter  * variable
    100107        MulvvOp,  //      variable   * variable
     108        NepvOp,   //  parameter  != variable
     109        NevvOp,   //  variable   != variable
    101110        ParOp,    //      parameter
    102111        PowpvOp,  //  pow(parameter,   variable)
     
    166175                1, // BeginOp  offset first real argument to have index 1
    167176                6, // CExpOp
    168                 4, // ComOp
    169177                1, // CosOp
    170178                1, // CoshOp
     
    176184                2, // DivvvOp
    177185                0, // EndOp
     186                2, // EqpvOp
     187                2, // EqvvOp
    178188                3, // ErfOp
    179189                1, // ExpOp
     
    181191                3, // LdpOp
    182192                3, // LdvOp
     193                2, // LepvOp
     194                2, // LevpOp
     195                2, // LevvOp
    183196                1, // LogOp
     197                2, // LtpvOp
     198                2, // LtvpOp
     199                2, // LtvvOp
    184200                2, // MulpvOp
    185201                2, // MulvvOp
     202                2, // NepvOp
     203                2, // NevvOp
    186204                1, // ParOp
    187205                2, // PowpvOp
     
    257275                1, // BeginOp  offsets first variable to have index one (not zero)
    258276                1, // CExpOp
    259                 0, // ComOp
    260277                2, // CosOp
    261278                2, // CoshOp
     
    267284                1, // DivvvOp
    268285                0, // EndOp
     286                0, // EqpvOp
     287                0, // EqvvOp
    269288                5, // ErfOp
    270289                1, // ExpOp
     
    272291                1, // LdpOp
    273292                1, // LdvOp
     293                0, // LepvOp
     294                0, // LevpOp
     295                0, // LevvOp
    274296                1, // LogOp
     297                0, // LtpvOp
     298                0, // LtvpOp
     299                0, // LtvvOp
    275300                1, // MulpvOp
    276301                1, // MulvvOp
     302                0, // NepvOp
     303                0, // NevvOp
    277304                1, // ParOp
    278305                3, // PowpvOp
     
    331358                "Begin" ,
    332359                "CExp"  ,
    333                 "Com"   ,
    334360                "Cos"   ,
    335361                "Cosh"  ,
     
    341367                "Divvv" ,
    342368                "End"   ,
     369                "Eqpv"  ,
     370                "Eqvv"  ,
    343371                "Erf"   ,
    344372                "Exp"   ,
     
    346374                "Ldp"   ,
    347375                "Ldv"   ,
     376                "Lepv"  ,
     377                "Levp"  ,
     378                "Levv"  ,
    348379                "Log"   ,
     380                "Ltpv"  ,
     381                "Ltvp"  ,
     382                "Ltvv"  ,
    349383                "Mulpv" ,
    350384                "Mulvv" ,
     385                "Nepv"  ,
     386                "Nevv"  ,
    351387                "Par"   ,
    352388                "Powpv" ,
     
    495531                printOpField(os,  "v=",      i_var, 5);
    496532        else    printOpField(os,  "v=",      "",    5);
    497         if( op == CExpOp || op == CSkipOp || op == ComOp )
     533        if( op == CExpOp || op == CSkipOp )
    498534        {       printOpField(os, "", OpName(op), 5);
    499535                printOpField(os, "", CompareOpName[ ind[0] ], 3);
     
    606642                case AddvvOp:
    607643                case DivvvOp:
     644                case LevvOp:
     645                case LtvvOp:
     646                case EqvvOp:
     647                case NevvOp:
    608648                case MulvvOp:
    609649                case PowvvOp:
     
    615655
    616656                case AddpvOp:
     657                case LepvOp:
     658                case LtpvOp:
     659                case EqpvOp:
     660                case NepvOp:
    617661                case SubpvOp:
    618662                case MulpvOp:
     
    625669
    626670                case DivvpOp:
     671                case LevpOp:
     672                case LtvpOp:
    627673                case PowvpOp:
    628674                case SubvpOp:
     
    722768                        printOpField(os, " vf=", ind[5], ncol);
    723769                else    printOpField(os, " pf=", play->GetPar(ind[5]), ncol);
    724                 break;
    725 
    726                 case ComOp:
    727                 CPPAD_ASSERT_UNKNOWN(ind[1] != 0);
    728                 CPPAD_ASSERT_UNKNOWN( NumArg(op) == 4 );
    729                 if( ind[1] & 1 )
    730                         printOpField(os, "res=", 1, ncol);
    731                 else    printOpField(os, "res=", 0, ncol);
    732                 if( ind[1] & 2 )
    733                         printOpField(os, " vl=", ind[2], ncol);
    734                 else    printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
    735                 if( ind[1] & 4 )
    736                         printOpField(os, " vr=", ind[3], ncol);
    737                 else    printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
    738770                break;
    739771
     
    860892                break;
    861893                // ------------------------------------------------------------------
     894                // 2 arguments, no results
     895                case LepvOp:
     896                case LtpvOp:
     897                case EqpvOp:
     898                case NepvOp:
     899                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
     900                break;
     901                //
     902                case LevpOp:
     903                case LtvpOp:
     904                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= result );
     905                break;
     906                //
     907                case LevvOp:
     908                case LtvvOp:
     909                case EqvvOp:
     910                case NevvOp:
     911                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= result );
     912                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
     913                break;
    862914
    863915                // 2 arguments (both variables), 1 results
     
    929981                // ------------------------------------------------------------------
    930982
    931                 // 4 arguments, no result
    932                 case ComOp:
    933                 if( arg[1] & 2 )
    934                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
    935                 }
    936                 if( arg[1] & 4 )
    937                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= result );
    938                 }
    939                 break;
    940                 // ------------------------------------------------------------------
    941 
    942983                // 5 arguments, no result
    943984                case PriOp:
  • trunk/cppad/local/optimize.hpp

    r3507 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    8888See the discussion about
    8989$cref/sequence constructors/FunConstruct/Sequence Constructor/$$.
    90 
    91 $head Comparison Operators$$
    92 Any comparison operators that are in the tape are removed by this operation.
    93 Hence the return value of $cref CompareChange$$ will always be zero
    94 for an optimized tape (even if $code NDEBUG$$ is not defined).
    9590
    9691$head Atomic Functions$$
     
    17051700
    17061701                        // Operations where there is nothing to do
    1707                         case ComOp:
    17081702                        case EndOp:
    17091703                        case ParOp:
     
    17171711                        break;
    17181712
    1719                         // Load using a parameter index
     1713                        // Compare operators never get removed -----------------
     1714                        case LepvOp:
     1715                        case LtpvOp:
     1716                        case EqpvOp:
     1717                        case NepvOp:
     1718                        tape[arg[1]].connect_type = yes_connected;
     1719                        break;
     1720
     1721                        case LevpOp:
     1722                        case LtvpOp:
     1723                        tape[arg[0]].connect_type = yes_connected;
     1724                        break;
     1725
     1726                        case LevvOp:
     1727                        case LtvvOp:
     1728                        case EqvvOp:
     1729                        case NevvOp:
     1730                        tape[arg[0]].connect_type = yes_connected;
     1731                        tape[arg[1]].connect_type = yes_connected;
     1732                        break;
     1733
     1734                        // Load using a parameter index ----------------------
    17201735                        case LdpOp:
    17211736                        if( tape[i_var].connect_type != not_connected )
     
    20902105                bool keep;
    20912106                switch( op )
    2092                 {       case ComOp:
     2107                {       // see wish_list/Optimize/CompareChange entry.
     2108                        case EqpvOp:
     2109                        case EqvvOp:
     2110                        case LepvOp:
     2111                        case LevpOp:
     2112                        case LevvOp:
     2113                        case LtpvOp:
     2114                        case LtvpOp:
     2115                        case LtvvOp:
     2116                        case NepvOp:
     2117                        case NevvOp:
     2118                        keep = true;
     2119                        break;
     2120
    20932121                        case PriOp:
    20942122                        keep = false;
     
    24062434                        break;
    24072435                        // ---------------------------------------------------
     2436                        // Operations with two arguments and no results
     2437                        case LepvOp:
     2438                        case LtpvOp:
     2439                        case EqpvOp:
     2440                        case NepvOp:
     2441                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     2442                        new_arg[0] = rec->PutPar( play->GetPar(arg[0]) );
     2443                        new_arg[1] = tape[arg[1]].new_var;
     2444                        rec->PutArg(new_arg[0], new_arg[1]);
     2445                        rec->PutOp(op);
     2446                        break;
     2447                        //
     2448                        case LevpOp:
     2449                        case LtvpOp:
     2450                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     2451                        new_arg[0] = tape[arg[0]].new_var;
     2452                        new_arg[1] = rec->PutPar( play->GetPar(arg[1]) );
     2453                        rec->PutArg(new_arg[0], new_arg[1]);
     2454                        rec->PutOp(op);
     2455                        break;
     2456                        //
     2457                        case LevvOp:
     2458                        case LtvvOp:
     2459                        case EqvvOp:
     2460                        case NevvOp:
     2461                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     2462                        new_arg[0] = tape[arg[0]].new_var;
     2463                        new_arg[1] = tape[arg[1]].new_var;
     2464                        rec->PutArg(new_arg[0], new_arg[1]);
     2465                        rec->PutOp(op);
     2466                        break;
     2467
     2468                        // ---------------------------------------------------
    24082469                        // Operations with no arguments and one result
    24092470                        case InvOp:
     
    27432804        play_.get(rec);
    27442805
     2806        // set flag so this function knows it has been optimized
     2807        has_been_optimized_ = true;
     2808
    27452809        // free memory allocated for sparse Jacobian calculation
    27462810        // (the results are no longer valid)
  • trunk/cppad/local/recorder.hpp

    r3232 r3607  
    33# define CPPAD_RECORDER_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    3434
    3535private:
     36        /// operator index at which to abort recording with an error
     37        /// (do not abort when zero)
     38        size_t abort_op_index_;
     39
    3640        /// offset for this thread in the static hash table
    3741        const size_t thread_offset_;
     
    7074        par_rec_( std::numeric_limits<addr_t>::max() )       ,
    7175        text_rec_( std::numeric_limits<addr_t>::max() )
    72         { }
     76        {
     77                abort_op_index_ = 0;
     78        }
     79
     80        /// Set the abort index
     81        void set_abort_op_index(size_t abort_op_index)
     82        {       abort_op_index_ = abort_op_index; }
     83
     84        /// Get the abort index
     85        size_t get_abort_op_index(void)
     86        {       return abort_op_index_; }
    7387
    7488        /// Destructor
     
    177191inline size_t recorder<Base>::PutOp(OpCode op)
    178192{       size_t i    = op_rec_.extend(1);
     193        CPPAD_ASSERT_KNOWN(
     194                (abort_op_index_ == 0) || (abort_op_index_ != i),
     195                "Operator index equals abort_op_index in Independent"
     196        );
    179197        op_rec_[i]  = static_cast<CPPAD_OP_CODE_TYPE>(op);
    180198        CPPAD_ASSERT_UNKNOWN( op_rec_.size() == i + 1 );
     
    224242inline size_t recorder<Base>::PutLoadOp(OpCode op)
    225243{       size_t i    = op_rec_.extend(1);
     244        CPPAD_ASSERT_KNOWN(
     245                (abort_op_index_ == 0) || (abort_op_index_ != i),
     246                "This is the abort operator index specified by "
     247                "Independent(x, abort_op_index)."
     248        );
    226249        op_rec_[i]  = static_cast<CPPAD_OP_CODE_TYPE>(op);
    227250        CPPAD_ASSERT_UNKNOWN( op_rec_.size() == i + 1 );
  • trunk/cppad/local/rev_hes_sweep.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    304304                        // ---------------------------------------------------
    305305
    306                         case ComOp:
    307                         CPPAD_ASSERT_NARG_NRES(op, 4, 0)
    308                         CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    309                         break;
    310                         // --------------------------------------------------
    311 
    312306                        case CosOp:
    313307                        // sin(x), cos(x)
     
    407401                                vecad_jac.data()
    408402                        );
     403                        break;
     404                        // -------------------------------------------------
     405
     406                        case EqpvOp:
     407                        case EqvvOp:
     408                        case LtpvOp:
     409                        case LtvpOp:
     410                        case LtvvOp:
     411                        case LepvOp:
     412                        case LevpOp:
     413                        case LevvOp:
     414                        case NepvOp:
     415                        case NevvOp:
     416                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    409417                        break;
    410418                        // -------------------------------------------------
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    293293                        // ---------------------------------------------------
    294294
    295                         case ComOp:
    296                         CPPAD_ASSERT_NARG_NRES(op, 4, 0);
    297                         CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    298                         break;
    299                         // --------------------------------------------------
    300 
    301295                        case CosOp:
    302296                        // sin(x), cos(x)
     
    391385                                vecad_sparsity
    392386                        );
     387                        break;
     388                        // -------------------------------------------------
     389
     390                        case EqpvOp:
     391                        case EqvvOp:
     392                        case LtpvOp:
     393                        case LtvpOp:
     394                        case LtvvOp:
     395                        case LepvOp:
     396                        case LevpOp:
     397                        case LevvOp:
     398                        case NepvOp:
     399                        case NevvOp:
     400                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    393401                        break;
    394402                        // -------------------------------------------------
  • trunk/cppad/local/reverse_sweep.hpp

    r3495 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    387387                        // --------------------------------------------------
    388388
    389                         case ComOp:
    390                         break;
    391                         // --------------------------------------------------
    392 
    393389                        case CosOp:
    394390                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     
    451447                        break;
    452448                        // --------------------------------------------------
     449
     450                        case InvOp:
     451                        break;
     452                        // --------------------------------------------------
     453
    453454                        case LdpOp:
    454455                        reverse_load_op(
     
    463464                        );
    464465                        break;
    465                         // -------------------------------------------------
    466 
    467                         case InvOp:
    468                         break;
    469                         // --------------------------------------------------
     466                        // --------------------------------------------------
     467
     468                        case EqpvOp:
     469                        case EqvvOp:
     470                        case LtpvOp:
     471                        case LtvpOp:
     472                        case LtvvOp:
     473                        case LepvOp:
     474                        case LevpOp:
     475                        case LevvOp:
     476                        case NepvOp:
     477                        case NevvOp:
     478                        break;
     479                        // -------------------------------------------------
    470480
    471481                        case LogOp:
  • trunk/cppad/local/test_vector.hpp

    r2506 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    3636$section Choosing The Vector Testing Template Class$$
    3737
    38 $head Deprecated$$
     38$head Deprecated 2012-07-03$$
    3939$index deprecated, test vector$$
    4040The $code CPPAD_TEST_VECTOR$$ macro has been deprecated,
     
    127127Ublas vector testing.
    128128
    129 $head CppADvector$$
     129$head CppADvector Deprecated 2007-07-28$$
    130130The preprocessor symbol $code CppADvector$$ is defined to
    131131have the same value as $code CPPAD_TEST_VECTOR$$ but its use is deprecated:
  • trunk/cppad/track_new_del.hpp

    r2506 r3607  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    3232$index memory, track$$
    3333
    34 $head Deprecated$$
     34$head Deprecated 2007-07-23$$
    3535$index deprecated, track memory$$
    3636All these routines have been deprecated.
  • trunk/cppad_ipopt/src/cppad_ipopt_nlp.hpp

    r2936 r3607  
    33# define CPPAD_CPPAD_IPOPT_NLP_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    4646$index AD, Ipopt$$
    4747
    48 $head Deprecated$$
     48$head Deprecated 2012-11-28$$
    4949This interface to Ipopt is deprecated, use $cref ipopt_solve$$ instead.
    5050
  • trunk/example/compare_change.cpp

    r2570 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4545                return y;
    4646        }
     47        struct error_info {
     48                bool known;
     49                int  line;
     50                std::string file;
     51                std::string exp;
     52                std::string msg;
     53        };
     54        void error_handler(
     55                bool        known       ,
     56                int         line        ,
     57                const char *file        ,
     58                const char *exp         ,
     59                const char *msg         )
     60        {       // error handler must not return, so throw an exception
     61                error_info info;
     62                info.known = known;
     63                info.line  = line;
     64                info.file  = file;
     65                info.exp   = exp;
     66                info.msg   = msg;
     67                throw info;
     68        }
     69
    4770}
    4871
    49 bool CompareChange(void)
     72bool compare_change(void)
    5073{       bool ok = true;
    51 // f.CompareChange not defined when NDEBUG is true
    52 # ifndef NDEBUG
    53 
    5474        using CppAD::AD;
    55         using CppAD::ADFun;
    56         using CppAD::Independent;
    5775
    5876        // domain space vector
    5977        size_t n = 2;
    60         CPPAD_TESTVECTOR(AD<double>) X(n);
    61         X[0] = 3.;
    62         X[1] = 4.;
     78        CPPAD_TESTVECTOR(AD<double>) ax(n);
     79        ax[0] = 3.;
     80        ax[1] = 4.;
    6381
    6482        // declare independent variables and start tape recording
    65         CppAD::Independent(X);
     83        CppAD::Independent(ax);
    6684
    6785        // range space vector
    6886        size_t m = 1;
    69         CPPAD_TESTVECTOR(AD<double>) Y(m);
    70         Y[0] = Minimum(X[0], X[1]);
     87        CPPAD_TESTVECTOR(AD<double>) ay(m);
     88        ay[0] = Minimum(ax[0], ax[1]);
    7189
    7290        // create f: x -> y and stop tape recording
    73         ADFun<double> f(X, Y);
     91        CppAD::ADFun<double> f(ax, ay);
    7492
    75         // evaluate zero mode Forward where conditional has the same result
    76         // note that f.CompareChange is not defined when NDEBUG is true
    77         CPPAD_TESTVECTOR(double) x(n);
    78         CPPAD_TESTVECTOR(double) y(m);
    79         x[0] = 3.5;
    80         x[1] = 4.; 
     93        // set count to one (not necessry because is its default value)
     94        f.compare_change_count(1);
     95
     96        // evaluate zero mode Forward where comparison has the same result
     97        // as during taping; i.e., x[0] < x[1].
     98        CPPAD_TESTVECTOR(double) x(n), y(m);
     99        x[0] = 2.;
     100        x[1] = 3.; 
    81101        y    = f.Forward(0, x);
    82102        ok  &= (y[0] == x[0]);
    83103        ok  &= (y[0] == Minimum(x[0], x[1]));
    84         ok  &= (f.CompareChange() == 0);
     104        ok  &= (f.compare_change_number() == 0);
     105        ok  &= (f.compare_change_op_index() == 0);
    85106
    86         // evaluate zero mode Forward where conditional has different result
    87         x[0] = 4.;
    88         x[1] = 3.;
     107        // evaluate zero mode Forward where comparison has different result
     108        // as during taping; i.e., x[0] >= x[1].
     109        x[0] = 3.;
     110        x[1] = 2.;
    89111        y    = f.Forward(0, x);
    90112        ok  &= (y[0] == x[0]);
    91113        ok  &= (y[0] != Minimum(x[0], x[1]));
    92         ok  &= (f.CompareChange() == 1);
     114        ok  &= (f.compare_change_number() == 1);
     115        ok  &= (f.compare_change_op_index() > 0 );
     116        size_t op_index = f.compare_change_op_index();
    93117
    94         // re-tape to obtain the new AD operation sequence
    95         X[0] = 4.;
    96         X[1] = 3.;
    97         Independent(X);
    98         Y[0] = Minimum(X[0], X[1]);
     118        // Local block during which default CppAD error handler is replaced.
     119        // If you do not replace the default CppAD error handler,
     120        // and you run in the debugger, you will be able to inspect the
     121        // call stack and see that 'if( x < y )' is where the comparison is.
     122        bool caught_error = false;
     123        {       CppAD::ErrorHandler local_error_handler(error_handler);
    99124
    100         // stop tape and store result in f
    101         f.Dependent(Y);
     125                std::string check_msg =
     126                        "Operator index equals abort_op_index in Independent";
     127                try {
     128                        // determine the operation index where the change occurred
     129                        CppAD::Independent(ax, op_index);
     130                        ay[0] = Minimum(ax[0], ax[1]);
     131                }
     132                catch( error_info info )
     133                {       caught_error = true;
     134                        ok          &= info.known;
     135                        ok          &= info.msg == check_msg;
     136                        // Must abort the recording so we can start a new one
     137                        // (and to avoid a memory leak).
     138                        AD<double>::abort_recording();
     139                }
     140        }
     141        ok &= caught_error;
    102142
    103         // evaluate the function at new argument values
     143
     144        // set count to zero to demonstrate case where comparisons are not checked
     145        f.compare_change_count(0);
     146        y    = f.Forward(0, x);
     147        ok  &= (y[0] == x[0]);
     148        ok  &= (y[0] != Minimum(x[0], x[1]));
     149        ok  &= (f.compare_change_number()   == 0);
     150        ok  &= (f.compare_change_op_index() == 0);
     151
     152        // now demonstrate that compare_change_number works for an optimized
     153        // tape (note that compare_change_op_index is always zero after optimize)
     154        f.optimize();
     155        f.compare_change_count(1);
     156        y    = f.Forward(0, x);
     157        ok  &= (y[0] == x[0]);
     158        ok  &= (y[0] != Minimum(x[0], x[1]));
     159        ok  &= (f.compare_change_number()   == 1);
     160        ok  &= (f.compare_change_op_index() == 0);
     161
     162        // now retape to get the a tape that agrees with the algorithm
     163        ax[0] = x[0];
     164        ax[1] = x[1];
     165        Independent(ax);
     166        ay[0] = Minimum(ax[0], ax[1]);
     167        f.Dependent(ax, ay);
    104168        y    = f.Forward(0, x);
    105169        ok  &= (y[0] == x[1]);
    106170        ok  &= (y[0] == Minimum(x[0], x[1]));
    107         ok  &= (f.CompareChange() == 0);
     171        ok  &= (f.compare_change_number()   == 0);
     172        ok  &= (f.compare_change_op_index() == 0);
    108173
    109 # endif
    110174        return ok;
    111175}
  • trunk/example/example.cpp

    r3552 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    7070extern bool colpack_jac(void);
    7171extern bool Compare(void);
    72 extern bool CompareChange(void);
     72extern bool compare_change(void);
    7373extern bool complex_poly(void);
    7474extern bool CondExp(void);
     
    229229        ok &= Run( CheckSimpleVector, "CheckSimpleVector");
    230230        ok &= Run( Compare,           "Compare"          );
    231         ok &= Run( CompareChange,     "CompareChange"    );
     231        ok &= Run( compare_change,    "compare_change"   );
    232232        ok &= Run( complex_poly,      "complex_poly"     );
    233233        ok &= Run( CondExp,           "CondExp"          );
  • trunk/example/optimize.cpp

    r2506 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    3131# include <cppad/cppad.hpp>
    3232namespace {
    33         template <class Float>
    34         void fun(const Float& x, Float& y, size_t& n_var, size_t& n_opt)
    35         {       using CppAD::exp;
     33        template <class VectorFloat> void fun(
     34                const VectorFloat& x, VectorFloat& y, size_t& n_var, size_t& n_opt )
     35        {       typedef typename VectorFloat::value_type Float;
    3636
    37                 // Create a variable that is optimized out because
    38                 // it is only used in the comparision operation.
    39                 Float a = 1. / x;
    40                 n_var += 1;
    41                 n_opt += 0;
     37                // One for each independent variable and one phantom variable at
     38                // the beginning of operation sequence.
     39                n_var = 1 + x.size();
    4240
    43                 // Create a variable that is used by the result
    44                 Float b = x * 5.;
     41                // One operator for each independent variable and one to mark
     42                // beginning of operation sequence.
     43                n_opt = 1 + x.size();
     44
     45                // Create a variable that is is only used in the comparision operation
     46                // (was optimized out until 2015-01-12).
     47                Float a = 1. / x[0];
    4548                n_var += 1;
    4649                n_opt += 1;
    4750
     51                // Create a variable that is used by the result
     52                Float b = x[0] * 5.;
     53                n_var += 1;
     54                n_opt += 1;
     55
     56                // only one variable created for this comparison operation
     57                // but the value depends on which branch is taken.
    4858                Float c;
    49                 if( a < x ) 
    50                         c = b / 3.; // only one variable created by this choice
    51                 else    c = b / 2.;
     59                if( a < x[0] )
     60                        c = 2.0 * b;
     61                else
     62                        c = 3.0 * b;
    5263                n_var += 1;
    5364                n_opt += 1;
     
    5566                // Create a variable that is optimized out because it
    5667                // will always have the same value as b
    57                 Float d = 5. * x;
     68                Float d = 5. * x[0];
    5869                n_var += 1;
    5970                n_opt += 0;
    6071
    6172                // Create three variables that will be converted to one
    62                 // cumulative summation. Note that a is not connected to 
     73                // cumulative summation. Note that a is not connected to
    6374                // the result y (in the operation sequence).
    64                 y      = 1. + b + c + d;
     75                y[0]   = 1.0 + b + c + d;
    6576                n_var += 3;
    6677                n_opt += 1;
     
    7485        // domain space vector
    7586        size_t n  = 1;
    76         CPPAD_TESTVECTOR(AD<double>) X(n);
    77         X[0]      = .5;
     87        CPPAD_TESTVECTOR(AD<double>) ax(n);
     88        ax[0] = 0.5;
    7889
    7990        // declare independent variables and start tape recording
    80         CppAD::Independent(X);
    81         size_t n_var = 1 + n; // one phantom variable at the beginning
    82         size_t n_opt = 1 + n; // and one for each independent variable
     91        CppAD::Independent(ax);
    8392
    84         // range space vector 
     93        // range space vector
    8594        size_t m = 1;
    86         CPPAD_TESTVECTOR(AD<double>) Y(m);
    87         fun(X[0], Y[0], n_var, n_opt);
     95        CPPAD_TESTVECTOR(AD<double>) ay(m);
     96        size_t n_var, n_opt;
     97        fun(ax, ay, n_var, n_opt);
    8898
    89         // create f: X -> Y and stop tape recording
    90         CppAD::ADFun<double> F(X, Y);
    91         ok &= (F.size_var() == n_var);
    92 
    93         // Check zero order forward mode on the original operation sequence
    94         CPPAD_TESTVECTOR(double) x(n), y(m);
    95         x[0] = Value(X[0]);
    96         size_t i = 0; // temporary variable (we do not use value)
    97         double check;
    98         fun(x[0], check, i, i);
    99         y   = F.Forward(0, x);
    100         ok &= (y[0] == check);
     99        // create f: x -> y and stop tape recording
     100        CppAD::ADFun<double> f(ax, ay);
     101        ok &= (f.size_var() == n_var);
    101102
    102103        // Optimize the operation sequence
    103         F.optimize();
    104         ok &= (F.size_var() == n_opt);
     104        f.optimize();
     105        ok &= (f.size_var() == n_opt);
    105106
    106         // Check result for a zero order calculation.
    107         // This has already been checked if NDEBUG is not defined.
    108         fun(x[0], check, i, i);
    109         ok &= (y[0] == check);
    110         y   = F.Forward(0, x);
     107        // Check result for a zero order calculation for a different x,
     108        // where the result of the comparison is he same.
     109        CPPAD_TESTVECTOR(double) x(n), y(m), check(m);
     110        x[0] = 0.75;
     111        y    = f.Forward(0, x);
     112        ok  &= f.CompareChange() == 0;
     113        fun(x, check, n_var, n_opt);
     114        ok  &= (y[0] == check[0]);
     115
     116        // Check case where result of the comparision is differnent
     117        x[0] = 2.0;
     118        y    = f.Forward(0, x);
     119        ok  &= f.CompareChange() == 1;
     120        fun(x, check, n_var, n_opt);
     121        ok &= (y[0] != check[0]);
     122
     123        // re-tape at new x value, re-optimize, and re-evaluate forward
     124        ax[0] = x[0];
     125        CppAD::Independent(ax);
     126        fun(ax, ay, n_var, n_opt);
     127        f.Dependent(ax, ay);
     128        f.optimize();
     129        y   = f.Forward(0, x);
     130        ok &= f.CompareChange() == 0;
     131        ok &= (y[0] == check[0]);
     132
    111133        return ok;
    112134}
  • trunk/omh/deprecated/deprecated.omh

    r2859 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121        omh/deprecated/include_deprecated.omh%
    2222        omh/deprecated/fun_deprecated.omh%
     23        omh/deprecated/compare_change.omh%
    2324        cppad/local/omp_max_thread.hpp%
    2425        cppad/track_new_del.hpp%
     
    3536        $title BoolFun$$
    3637$rnext
    37 $cref/CppADCreateDiscrete/Discrete/Deprecated/$$  $cnext
     38$cref/CppADCreateDiscrete/Discrete/CppADCreateDiscrete Deprecated 2007-07-28/$$  $cnext
    3839        $title Discrete$$
    3940$rnext
  • trunk/omh/deprecated/fun_deprecated.omh

    r3214 r3607  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    6363See $cref Dependent$$ for a description of this operation.
    6464
    65 $subhead Deprecated$$
     65$subhead Deprecated 2007-08-07$$
    6666This syntax was deprecated when CppAD was extended to allow
    6767for more than one $codei%AD<%Base%>%$$ recording to be
     
    8282that are currently stored in $icode f$$.
    8383
    84 $subhead Deprecated$$
     84$subhead Deprecated 2006-03-31$$
    8585Zero order corresponds to function values being stored in $icode f$$.
    8686In the future, we would like to be able to erase the function
     
    105105$icode f$$ is called.
    106106
    107 $subhead Deprecated$$
     107$subhead Deprecated 2006-03-31$$
    108108It used to be the case that an ADFun object just kept increasing its
    109109buffers to the maximum size necessary during its lifetime.
     
    127127and derivatives using $icode f$$ is roughly proportional to $icode s$$.
    128128
    129 $subhead Deprecated$$
     129$subhead Deprecated 2006-04-03$$
    130130There are other sizes attached to an ADFun object, for example,
    131131the number of operations in the sequence.
     
    144144currently calculated and stored in the ADFun object $icode f$$.
    145145
    146 $subhead Deprecated$$
     146$subhead Deprecated 2006-06-17$$
    147147This function has been replaced by $cref size_order$$.
    148148
     
    161161Otherwise $icode u$$ is false.
    162162
    163 $subhead Deprecated$$
     163$subhead Deprecated 2006-04-08$$
    164164You can instead use
    165165$codei%
     
    177177currently calculated and stored in the ADFun object $icode f$$.
    178178
    179 $subhead Deprecated$$
     179$subhead Deprecated 2014-03-18$$
    180180This function has been replaced by $cref size_order$$.
    181181
     
    190190in the ADFun object $icode f$$.
    191191
    192 $subhead Deprecated$$
     192$subhead Deprecated 2014-03-18$$
    193193This function has been replaced by $cref capacity_order$$.
    194194
  • trunk/omh/deprecated/include_deprecated.omh

    r2652 r3607  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3232$index file, deprecated include$$
    3333
    34 $head Purpose$$
     34$head Deprecated 2006-12-17$$
    3535The following is a list of deprecated include file names
    3636and the corresponding names that should be used.
  • trunk/omh/deprecated/omp_alloc.omh

    r2652 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4343the rest of the $code CppAD$$.
    4444
     45$head Deprecated 2011-08-23$$
     46Use $cref thread_alloc$$ instead.
     47
    4548$childtable%
    4649        cppad/omp_alloc.hpp%
  • trunk/omh/forward/compare_change.omh

    r3173 r3607  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1010Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1111-------------------------------------------------------------------------- */
    12 $begin CompareChange$$
    13 $spell
     12$begin compare_change$$
     13$spell
     14        op
    1415        const
    1516$$
    1617
    17 $section Comparison Changes During Zero Order Forward Mode$$
     18$section Comparison Changes Between Taping and Zero Order Forward$$
    1819
    19 $index ADFun, CompareChange$$
    20 $index CompareChange, ADFun$$
     20$index ADFun, compare_change$$
     21$index compare_change, ADFun$$
    2122$index zero, order forward$$
    2223$index forward, zero order$$
    2324
    2425$head Syntax$$
    25 $icode%c% = %f%.CompareChange()%$$
    26 $pre
    27 $$
     26$icode%f%.compare_change_count(%count%)
     27%$$
     28$icode%number% = %f%.compare_change_number()
     29%$$
     30$icode%op_index% = %f%.compare_change_op_index()
     31
     32%$$
    2833$bold See Also$$
    2934$cref FunCheck$$
     
    3237$head Purpose$$
    3338We use $latex F : B^n \rightarrow B^m$$ to denote the
    34 $cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
    35 This function may be not agree with the algorithm that was used
    36 to create the corresponding
    37 AD of $icode Base$$
    38 $cref/operation sequence/glossary/Operation/Sequence/$$
    39 because of changes in AD
    40 $cref/comparison/Compare/$$ results.
    41 The $code CompareChange$$ function can be used to detect these changes.
     39$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$; i.e,
     40given $latex x \in B^n$$, $latex F(x)$$ is defined by
     41$codei%
     42        %F%(%x%) = %f%.Forward(0, %x%)
     43%$$
     44see $cref forward_zero$$.
     45If $latex x$$ is such that
     46all the algorithm $cref/comparison/Compare/$$ operations
     47have the same result as when the algorithm was taped,
     48The function $latex F(x)$$ and the algorithm will have the same values.
     49(This is a sufficient, but not necessary condition).
     50
     51
     52
     53
    4254
    4355$head f$$
    44 The object $icode f$$ has prototype
     56In the $code compare_change_number$$ and $code compare_change_op_index$$
     57syntax, the object $icode f$$ has prototype
    4558$codei%
    4659        const ADFun<%Base%> %f%
    4760%$$
     61In the $code compare_change_count$$
     62syntax, the object $icode f$$ has prototype
     63$codei%
     64        ADFun<%Base%> %f%
     65%$$
    4866
    49 $head c$$
    50 The result $icode c$$ has prototype
    51 $codei%
    52         size_t %c%
     67$head count$$
     68The argument $icode count$$ has prototype
     69$icode%
     70        size_t %count%
    5371%$$
    54 It is the number of
    55 $codei%AD<%Base%>%$$ $cref/comparison/Compare/$$
    56 operations,
    57 corresponding to the previous call to $cref Forward$$
     72It specifies which comparison change should correspond to the
     73information stored in $icode f$$ during subsequent calls to
     74$cref forward_zero$$; i.e.,
    5875$codei%
    5976        %f%.Forward(0, %x%)
    6077%$$
    61 that have a different result from
    62 when $icode F$$ was created by taping an algorithm.
     78For example, if $icode%count% == 1%$$,
     79the operator index corresponding to the first comparison change
     80will be stored.
     81This is the default value used if $icode count$$ is not specified.
    6382
    64 $head Discussion$$
    65 If $icode c$$ is not zero,
    66 the boolean values resulting from some of the
    67 $cref/comparison operations/Compare/$$ corresponding to $icode x$$
    68 are different from when the
    69 AD of $icode Base$$
    70 $cref/operation sequence/glossary/Operation/Sequence/$$ was created.
    71 In this case, you may want to re-tape the algorithm with the
    72 $cref/independent variables/glossary/Tape/Independent Variable/$$
    73 equal to the values in $icode x$$
    74 (so AD operation sequence properly represents the algorithm
    75 for this value of independent variables).
    76 On the other hand, re-taping the AD operation sequence usually takes
     83$subhead Speed$$
     84The special case where $icode count == 0$$, should be faster because
     85the comparisons are not checked during
     86$codei%
     87        %f%.Forward(0, %x%)
     88%$$
     89
     90$head number$$
     91The return value $icode number$$ has prototype
     92$codei%
     93        size_t %number%
     94%$$
     95If $icode count$$ is non-zero,
     96$icode number$$ is the number of
     97$codei%AD<%Base%>%$$ $cref/comparison/Compare/$$ operations,
     98corresponding to the previous call to
     99$codei%
     100        %f%.Forward(0, %x%)
     101%$$
     102that have a different result for this value of $icode x$$
     103than the value used when $icode f$$ was created by taping an algorithm.
     104If $icode count$$ is zero,
     105or if no calls to $icode%f%.Forward(0, %x%)%$$ follow the previous
     106setting of $icode count$$,
     107$icode number$$ is zero.
     108
     109$subhead Discussion$$
     110If $icode count$$ and $icode number$$ are non-zero,
     111you may want to re-tape the algorithm with the
     112$cref/independent variables/glossary/Tape/Independent Variable/$$
     113equal to the values in $icode x$$,
     114so the AD operation sequence properly represents the algorithm
     115for this value of independent variables.
     116On the other hand, re-taping the AD operation sequence usually takes
    77117significantly more time than evaluation using $cref forward_zero$$.
    78118If the functions values have not changed (see $cref FunCheck$$)
    79 it may not be worth re-taping a new AD operation sequence. 
     119it may not be worth re-taping a new AD operation sequence.
    80120
    81 $head Restrictions$$
    82 $index NDEBUG, CompareChange$$
    83 Computation of this function requires extra operations in the tape.
    84 If $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is defined,
    85 of if a tape $cref/optimization/optimize/$$ has been preformed,
    86 these operations are not included in the tape and
    87 the value of $icode c$$ is always zero (and does not correspond
    88 to the actual number of comparison changes).
     121$head op_index$$
     122The return value $icode op_index$$ has prototype
     123$codei%
     124        size_t %op_index%
     125%$$
     126If $icode count$$ is non-zero,
     127$icode op_index$$ is the operator index corresponding the
     128$icode count$$-th comparison change during the previous call to
     129$codei%
     130        %f%.Forward(0, %x%)
     131%$$
     132If $icode count$$ is greater than the corresponding
     133$icode number$$, there is no such comparison change and $icode op_index$$
     134will also be zero.
     135If $icode count$$ is zero,
     136if the function $icode f$$ has been $cref/optimized/optimize/$$,
     137or if no calls to $icode%f%.Forward(0, %x%)%$$ follow the previous
     138setting of $icode count$$,
     139$icode op_index$$ is zero.
    89140
    90 $head Example$$
     141$subhead Purpose$$
     142The operator index can be used to generate an error during the taping
     143process so that the corresponding algorithm can be inspected.
     144In some cases, it is possible to re-design this part of the
     145algorithm to avoid the particular comparison operation.
     146For example, using an $cref/conditional expression/CondExp/$$
     147may be appropriate in some cases.
     148See $cref/abort_op_index/Independent/abort_op_index/$$ in the syntax
     149$codei%
     150        Independent(%x%, %abort_op_index%)
     151%$$
     152
    91153$children%
    92154        example/compare_change.cpp
    93155%$$
    94 The file
     156$head Example$$
    95157$cref compare_change.cpp$$
    96158contains an example and test of this operation.
    97 They return true if they succeed and false otherwise.
     159It returns true if they succeed and false otherwise.
    98160
    99161$end
  • trunk/omh/forward/forward.omh

    r3301 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
  • trunk/omh/install/unix.omh

    r3550 r3607  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    8282$section Deprecated Unix Test and Installation$$
    8383
    84 $head Deprecated$$
     84$head Deprecated 2012-12-26$$
    8585These install instructions have been deprecated and no improvements
    8686have been added since 2012.
  • trunk/omh/preprocessor.omh

    r2939 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    6363$head Deprecated$$
    6464$table
    65 $cref/CppADCreateDiscrete/Discrete/Deprecated/$$
     65$cref/CppADCreateDiscrete/Discrete/CppADCreateDiscrete Deprecated 2007-07-28/$$
    6666$rnext
    67 $cref/CppADvector/test_vector/Deprecated/$$
     67$cref/CppADvector/test_vector/Deprecated 2012-07-03/$$
    6868$rnext
    6969$cref/CPPAD_TEST_VECTOR/test_vector/$$
  • trunk/omh/whats_new/whats_new_12.omh

    r3537 r3607  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    616616$list number$$
    617617Remove the deprecated symbol
    618 $cref/CppADvector/test_vector/Deprecated/$$ from the
     618$cref/CppADvector/test_vector/Deprecated 2012-07-03/$$ from the
    619619$cref det_by_lu$$ speed test source code $cref det_by_lu.hpp$$.
    620620$lnext
  • trunk/omh/whats_new/whats_new_15.omh

    r3583 r3607  
    1414$dollar @$$
    1515$spell
     16        op
    1617        onetape
    1718        CppAD
     
    2930The purpose of this section is to
    3031assist you in learning about changes between various versions of CppAD.
     32
     33$head 01-20$$
     34$list number$$
     35The new $cref compare_change$$ interface has been created
     36and the old $cref CompareChange$$ function has been deprecated;
     37see the $cref compare_change.cpp$$ example.
     38This enables one to determine the source code during taping
     39that corresponds to changes in the comparisons during
     40$cref/zero order forward/forward_zero/$$ operations; see
     41$cref/abort_op_index/Independent/abort_op_index/$$.
     42
     43$lnext
     44This new $cref compare_change$$ interface can detect comparison changes
     45even if $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is defined and
     46even if $cref/f.optimize()/optimize/$$ has been called.
     47The deprecated function $code CompareChange$$ used to always return zero after
     48$codei%
     49        %f%.optimize()
     50%$$
     51and was not even defined when $code NDEBUG$$ was defined.
     52There was a resulting speed effect for this; see the wish list
     53$cref/compare change/WishList/Optimization/Comparison Changes/$$ entry.
     54
     55$lnext
     56The date when some features where deprecated has been added to the
     57documentation. For example, see
     58$cref/Deprecated 2006-12-17/include_deprecated/Deprecated 2006-12-17/$$.
     59$lend
    3160
    3261$head 01-09$$
  • trunk/omh/wish_list.omh

    r3301 r3607  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1212$begin WishList$$
    1313$spell
     14        onetape
     15        Op
    1416        jacobian
    1517        nz
     
    173175$index tape, optimize$$
    174176
     177$subhead Comparison Changes$$
     178The comparison operators used to not be taped when
     179$cref/NDEBUG/Faq/Speed/NDEBUG/$$ was defined.
     180They are now taped so that the $cref compare_change$$ interface
     181works even for compiler optimize code.
     182This caused a significant slow down in the
     183$cref cppad_det_lu.cpp$$ speed test (with no options specified).
     184Perhaps there should be an option to skip the comparison taping.
     185
    175186$subhead Expression Hashing$$
    176187During expression sequence $cref/optimization/optimize/$$,
  • trunk/speed/cppad/det_lu.cpp

    r3311 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    9898                        f.optimize();
    9999
     100                // skip comparison operators
     101                f.compare_change_count(0);
     102
    100103                // evaluate and return gradient using reverse mode
    101104                f.Forward(0, matrix);
  • trunk/speed/cppad/det_minor.cpp

    r3311 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    103103                if( global_optimize )
    104104                        f.optimize();
     105
     106                // skip comparison operators
     107                f.compare_change_count(0);
    105108       
    106109                // evaluate the determinant at the new matrix value
     
    128131                if( global_optimize )
    129132                        f.optimize();
     133
     134                // skip comparison operators
     135                f.compare_change_count(0);
    130136       
    131137                // ------------------------------------------------------
  • trunk/speed/cppad/mat_mul.cpp

    r3311 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    116116                        f.optimize();
    117117
     118                // skip comparison operators
     119                f.compare_change_count(0);
     120
    118121                // evaluate and return gradient using reverse mode
    119122                z  = f.Forward(0, x);
     
    149152                if( global_optimize )
    150153                        f.optimize();
     154
     155                // skip comparison operators
     156                f.compare_change_count(0);
     157
    151158                while(repeat--)
    152159                {       // get a next matrix
  • trunk/speed/cppad/ode.cpp

    r3311 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    9797                        f.optimize();
    9898
     99                // skip comparison operators
     100                f.compare_change_count(0);
     101
    99102                jacobian = f.Jacobian(x);
    100103        }
     
    116119                if( global_optimize )
    117120                        f.optimize();
     121
     122                // skip comparison operators
     123                f.compare_change_count(0);
     124
    118125                while(repeat--)
    119126                {       // get next argument value
  • trunk/speed/cppad/poly.cpp

    r3311 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    114114                        f.optimize();
    115115
     116                // skip comparison operators
     117                f.compare_change_count(0);
     118
    116119                // pre-allocate memory for three forward mode calculations
    117120                f.capacity_order(3);
     
    145148                        f.optimize();
    146149
     150                // skip comparison operators
     151                f.compare_change_count(0);
     152
    147153                while(repeat--)
    148154                {       // sufficient memory is allocated by second repetition
  • trunk/speed/cppad/sparse_hessian.cpp

    r3565 r3607  
    1 /* $Id: sparse_hessian.cpp 3552 2015-01-03 12:41:46Z bradbell $ */
     1/* $Id$ */
    22/* --------------------------------------------------------------------------
    33CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     
    157157                        f.optimize();
    158158
     159                // skip comparison operators
     160                f.compare_change_count(0);
     161
    159162                // calculate the Hessian sparsity pattern for this function
    160163                if( global_boolsparsity )
     
    195198                        f.optimize();
    196199
     200                // skip comparison operators
     201                f.compare_change_count(0);
     202
    197203                // calculate the Hessian sparsity pattern for this function
    198204                if( global_boolsparsity)
  • trunk/speed/cppad/sparse_jacobian.cpp

    r3581 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    139139                        f.optimize();
    140140
     141                // skip comparison operators
     142                f.compare_change_count(0);
     143
    141144                // calculate the Jacobian sparsity pattern for this function
    142145                if( global_boolsparsity )
     
    178181                        f.optimize();
    179182
     183                // skip comparison operators
     184                f.compare_change_count(0);
     185
    180186                // calculate the Jacobian sparsity pattern for this function
    181187                if( global_boolsparsity )
  • trunk/test_more/compare_change.cpp

    r2570 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1212
    1313/*
    14 Old CompareChange example and test, now just used for validation testing
     14Old CompareChange examples and tests, now just used for validation testing
    1515*/
    1616
    1717# include <cppad/cppad.hpp>
    1818
    19 bool CompareChange(void)
    20 {       bool ok = true;
    21 # ifndef NDEBUG
    22 
    23         using namespace CppAD;
    24 
    25         // ------------------------------- < ----------------------------
    26 
    27         // create independent variables
    28         CPPAD_TESTVECTOR(AD<double>) X(2);
    29         X[0] = 3.;
    30         X[1] = 4.;
    31         Independent(X);
    32 
    33         // create dependent variables
    34         CPPAD_TESTVECTOR(AD<double>) Y(6);
    35 
    36         // CondExp would never require retaping
    37         if( X[0] < X[1] )      // True variable < variable
    38                 Y[0] = X[0];
    39         else    Y[0] = X[1];
    40         if( X[1] < X[0] )      // False variable < variable
    41                 Y[1] = X[0];
    42         else    Y[1] = X[1];
    43         if( 3.5  < X[1] )      // True parameter < variable
    44                 Y[2] = X[0];
    45         else    Y[2] = X[1];
    46         if( 3.5  < X[0] )      // False parameter < variable
    47                 Y[3] = X[0];
    48         else    Y[3] = X[1];
    49         if( X[0] < 4.   )      // True variable < parameter
    50                 Y[4] = X[0];
    51         else    Y[4] = X[1];
    52         if( X[1] < 4.   )      // False variable < parameter
    53                 Y[5] = X[0];
    54         else    Y[5] = X[1];
    55 
    56         // f : X -> Y
    57         ADFun<double> *f;
    58         f = new ADFun<double>(X, Y);
    59 
    60         // new argument value
    61         CPPAD_TESTVECTOR(double) x( X.size() );
    62         x[0] = 4.;
    63         x[1] = 3.;
    64 
    65         // evaluate the function at new argument
    66         CPPAD_TESTVECTOR(double) y( Y.size() );
    67         y = f->Forward(0, x);
    68 
    69         // check results
    70         ok &= (y[0] == x[0]);           // this is what the was taped
    71         ok &= (y[1] == x[1]);
    72         ok &= (y[2] == x[0]);
    73         ok &= (y[3] == x[1]);
    74         ok &= (y[4] == x[0]);
    75         ok &= (y[5] == x[1]);
    76         ok &= (f->CompareChange() == 6); // all comparisions have changed
    77 
    78         // done with this function
    79         delete f;
    80 
    81         // ------------------------------- > ----------------------------
    82         // create independent variables
    83         Independent(X);
    84 
    85         if( X[0] > X[1] )      // False variable > variable
    86                 Y[0] = X[0];
    87         else    Y[0] = X[1];
    88         if( X[1] > X[0] )      // True variable > variable
    89                 Y[1] = X[0];
    90         else    Y[1] = X[1];
    91         if( 3.5  > X[1] )      // False parameter > variable
    92                 Y[2] = X[0];
    93         else    Y[2] = X[1];
    94         if( 3.5  > X[0] )      // True parameter > variable
    95                 Y[3] = X[0];
    96         else    Y[3] = X[1];
    97         if( X[0] > 3.   )      // False variable > parameter
    98                 Y[4] = X[0];
    99         else    Y[4] = X[1];
    100         if( X[1] > 3.   )      // True variable > parameter
    101                 Y[5] = X[0];
    102         else    Y[5] = X[1];
    103 
    104         // f : X -> Y
    105         f = new ADFun<double> (X, Y);
    106 
    107         // evaluate the function at new argument
    108         y = f->Forward(0, x);
    109 
    110         // check results
    111         ok &= (y[0] == x[1]);           // this is what the was taped
    112         ok &= (y[1] == x[0]);
    113         ok &= (y[2] == x[1]);
    114         ok &= (y[3] == x[0]);
    115         ok &= (y[4] == x[1]);
    116         ok &= (y[5] == x[0]);
    117         ok &= (f->CompareChange() == 6); // all comparisions have changed
    118 
    119         // done with this function
    120         delete f;
    121 
    122         // ------------------------------- <= ----------------------------
    123         // create independent variables
    124         Independent(X);
    125 
    126         if( X[0] <= X[1] )      // True variable <= variable
    127                 Y[0] = X[0];
    128         else    Y[0] = X[1];
    129         if( X[1] <= X[0] )      // False variable <= variable
    130                 Y[1] = X[0];
    131         else    Y[1] = X[1];
    132         if( 4.  <= X[1] )       // True parameter <= variable
    133                 Y[2] = X[0];
    134         else    Y[2] = X[1];
    135         if( 4.  <= X[0] )       // False parameter <= variable
    136                 Y[3] = X[0];
    137         else    Y[3] = X[1];
    138         if( X[0] <= 3.5   )     // True variable <= parameter
    139                 Y[4] = X[0];
    140         else    Y[4] = X[1];
    141         if( X[1] <= 3.5  )      // False variable <= parameter
    142                 Y[5] = X[0];
    143         else    Y[5] = X[1];
    144 
    145         // f : X -> Y
    146         f = new ADFun<double> (X, Y);
    147 
    148         // evaluate the function at new argument
    149         y = f->Forward(0, x);
    150 
    151         // check results
    152         ok &= (y[0] == x[0]);           // this is what the was taped
    153         ok &= (y[1] == x[1]);
    154         ok &= (y[2] == x[0]);
    155         ok &= (y[3] == x[1]);
    156         ok &= (y[4] == x[0]);
    157         ok &= (y[5] == x[1]);
    158         ok &= (f->CompareChange() == 6); // all comparisions have changed
    159 
    160         // done with this function
    161         delete f;
    162 
    163 
    164         // ------------------------------- >= ----------------------------
    165         // create independent variables
    166         Independent(X);
    167 
    168         if( X[0] >= X[1] )      // False variable >= variable
    169                 Y[0] = X[0];
    170         else    Y[0] = X[1];
    171         if( X[1] >= X[0] )      // True variable >= variable
    172                 Y[1] = X[0];
    173         else    Y[1] = X[1];
    174         if( 3.5  >= X[1] )      // False parameter >= variable
    175                 Y[2] = X[0];
    176         else    Y[2] = X[1];
    177         if( 3.5  >= X[0] )      // True parameter >= variable
    178                 Y[3] = X[0];
    179         else    Y[3] = X[1];
    180         if( X[0] >= 4.   )      // False variable >= parameter
    181                 Y[4] = X[0];
    182         else    Y[4] = X[1];
    183         if( X[1] >= 4.   )      // True variable >= parameter
    184                 Y[5] = X[0];
    185         else    Y[5] = X[1];
    186 
    187         // f : X -> Y
    188         f = new ADFun<double> (X, Y);
    189 
    190         // evaluate the function at new argument
    191         y = f->Forward(0, x);
    192 
    193         // check results
    194         ok &= (y[0] == x[1]);           // this is what the was taped
    195         ok &= (y[1] == x[0]);
    196         ok &= (y[2] == x[1]);
    197         ok &= (y[3] == x[0]);
    198         ok &= (y[4] == x[1]);
    199         ok &= (y[5] == x[0]);
    200         ok &= (f->CompareChange() == 6); // all comparisions have changed
    201 
    202         // done with this function
    203         delete f;
    204 
    205         // ------------------------------- == ----------------------------
    206         // create independent variables
    207         Independent(X);
    208 
    209         if( X[0] == X[1] )      // False variable == variable
    210                 Y[0] = X[0];
    211         else    Y[0] = X[1];
    212         if( X[0] == X[0] )      // True variable == variable
    213                 Y[1] = X[0];
    214         else    Y[1] = X[1];
    215         if( 3.  == X[1] )       // False parameter == variable
    216                 Y[2] = X[0];
    217         else    Y[2] = X[1];
    218         if( 3.  == X[0] )       // True parameter == variable
    219                 Y[3] = X[0];
    220         else    Y[3] = X[1];
    221         if( X[0] == 4.   )      // False variable == parameter
    222                 Y[4] = X[0];
    223         else    Y[4] = X[1];
    224         if( X[1] == 4.   )      // True variable == parameter
    225                 Y[5] = X[0];
    226         else    Y[5] = X[1];
    227 
    228         // f : X -> Y
    229         f = new ADFun<double> (X, Y);
    230 
    231         // evaluate the function at new argument
    232         y = f->Forward(0, x);
    233 
    234         // check results
    235         ok &= (y[0] == x[1]);           // this is what the was taped
    236         ok &= (y[1] == x[0]);
    237         ok &= (y[2] == x[1]);
    238         ok &= (y[3] == x[0]);
    239         ok &= (y[4] == x[1]);
    240         ok &= (y[5] == x[0]);
    241         // the first two comparisions do not change
    242         ok &= (f->CompareChange() == 4);
    243 
    244         // done with this function
    245         delete f;
    246 
    247         // ------------------------------- != ----------------------------
    248         // create independent variables
    249         Independent(X);
    250 
    251         if( X[0] != X[1] )      // True variable != variable
    252                 Y[0] = X[0];
    253         else    Y[0] = X[1];
    254         if( X[0] != X[0] )      // False variable != variable
    255                 Y[1] = X[0];
    256         else    Y[1] = X[1];
    257         if( 3.  != X[1] )       // True parameter != variable
    258                 Y[2] = X[0];
    259         else    Y[2] = X[1];
    260         if( 3.  != X[0] )       // False parameter != variable
    261                 Y[3] = X[0];
    262         else    Y[3] = X[1];
    263         if( X[0] != 4.   )      // True variable != parameter
    264                 Y[4] = X[0];
    265         else    Y[4] = X[1];
    266         if( X[1] != 4.   )      // False variable != parameter
    267                 Y[5] = X[0];
    268         else    Y[5] = X[1];
    269 
    270         // f : X -> Y
    271         f = new ADFun<double> (X, Y);
    272 
    273         // evaluate the function at new argument
    274         y = f->Forward(0, x);
    275 
    276         // check results
    277         ok &= (y[0] == x[0]);           // this is what the was taped
    278         ok &= (y[1] == x[1]);
    279         ok &= (y[2] == x[0]);
    280         ok &= (y[3] == x[1]);
    281         ok &= (y[4] == x[0]);
    282         ok &= (y[5] == x[1]);
    283         // the first two comparisions do not change
    284         ok &= (f->CompareChange() == 4);
    285 
    286         // done with this function
    287         delete f;
    288 
    289 # endif
     19namespace {
     20        // ----------------------------------------------------------------------
     21        bool CompareChange_one(void)
     22        {       bool ok = true;
     23
     24                using namespace CppAD;
     25
     26                // ------------------------------- < ----------------------------
     27
     28                // create independent variables
     29                CPPAD_TESTVECTOR(AD<double>) X(2);
     30                X[0] = 3.;
     31                X[1] = 4.;
     32                Independent(X);
     33
     34                // create dependent variables
     35                CPPAD_TESTVECTOR(AD<double>) Y(6);
     36
     37                // CondExp would never require retaping
     38                if( X[0] < X[1] )      // True variable < variable
     39                        Y[0] = X[0];
     40                else    Y[0] = X[1];
     41                if( X[1] < X[0] )      // False variable < variable
     42                        Y[1] = X[0];
     43                else    Y[1] = X[1];
     44                if( 3.5  < X[1] )      // True parameter < variable
     45                        Y[2] = X[0];
     46                else    Y[2] = X[1];
     47                if( 3.5  < X[0] )      // False parameter < variable
     48                        Y[3] = X[0];
     49                else    Y[3] = X[1];
     50                if( X[0] < 4.   )      // True variable < parameter
     51                        Y[4] = X[0];
     52                else    Y[4] = X[1];
     53                if( X[1] < 4.   )      // False variable < parameter
     54                        Y[5] = X[0];
     55                else    Y[5] = X[1];
     56
     57                // f : X -> Y
     58                ADFun<double> *f;
     59                f = new ADFun<double>(X, Y);
     60
     61                // new argument value
     62                CPPAD_TESTVECTOR(double) x( X.size() );
     63                x[0] = 4.;
     64                x[1] = 3.;
     65
     66                // evaluate the function at new argument
     67                CPPAD_TESTVECTOR(double) y( Y.size() );
     68                y = f->Forward(0, x);
     69
     70                // check results
     71                ok &= (y[0] == x[0]);           // this is what the was taped
     72                ok &= (y[1] == x[1]);
     73                ok &= (y[2] == x[0]);
     74                ok &= (y[3] == x[1]);
     75                ok &= (y[4] == x[0]);
     76                ok &= (y[5] == x[1]);
     77                ok &= (f->CompareChange() == 6); // all comparisions have changed
     78
     79                // done with this function
     80                delete f;
     81
     82                // ------------------------------- > ----------------------------
     83                // create independent variables
     84                Independent(X);
     85
     86                if( X[0] > X[1] )      // False variable > variable
     87                        Y[0] = X[0];
     88                else    Y[0] = X[1];
     89                if( X[1] > X[0] )      // True variable > variable
     90                        Y[1] = X[0];
     91                else    Y[1] = X[1];
     92                if( 3.5  > X[1] )      // False parameter > variable
     93                        Y[2] = X[0];
     94                else    Y[2] = X[1];
     95                if( 3.5  > X[0] )      // True parameter > variable
     96                        Y[3] = X[0];
     97                else    Y[3] = X[1];
     98                if( X[0] > 3.   )      // False variable > parameter
     99                        Y[4] = X[0];
     100                else    Y[4] = X[1];
     101                if( X[1] > 3.   )      // True variable > parameter
     102                        Y[5] = X[0];
     103                else    Y[5] = X[1];
     104
     105                // f : X -> Y
     106                f = new ADFun<double> (X, Y);
     107
     108                // evaluate the function at new argument
     109                y = f->Forward(0, x);
     110
     111                // check results
     112                ok &= (y[0] == x[1]);           // this is what the was taped
     113                ok &= (y[1] == x[0]);
     114                ok &= (y[2] == x[1]);
     115                ok &= (y[3] == x[0]);
     116                ok &= (y[4] == x[1]);
     117                ok &= (y[5] == x[0]);
     118                ok &= (f->CompareChange() == 6); // all comparisions have changed
     119
     120                // done with this function
     121                delete f;
     122
     123                // ------------------------------- <= ----------------------------
     124                // create independent variables
     125                Independent(X);
     126
     127                if( X[0] <= X[1] )      // True variable <= variable
     128                        Y[0] = X[0];
     129                else    Y[0] = X[1];
     130                if( X[1] <= X[0] )      // False variable <= variable
     131                        Y[1] = X[0];
     132                else    Y[1] = X[1];
     133                if( 4.  <= X[1] )       // True parameter <= variable
     134                        Y[2] = X[0];
     135                else    Y[2] = X[1];
     136                if( 4.  <= X[0] )       // False parameter <= variable
     137                        Y[3] = X[0];
     138                else    Y[3] = X[1];
     139                if( X[0] <= 3.5   )     // True variable <= parameter
     140                        Y[4] = X[0];
     141                else    Y[4] = X[1];
     142                if( X[1] <= 3.5  )      // False variable <= parameter
     143                        Y[5] = X[0];
     144                else    Y[5] = X[1];
     145
     146                // f : X -> Y
     147                f = new ADFun<double> (X, Y);
     148
     149                // evaluate the function at new argument
     150                y = f->Forward(0, x);
     151
     152                // check results
     153                ok &= (y[0] == x[0]);           // this is what the was taped
     154                ok &= (y[1] == x[1]);
     155                ok &= (y[2] == x[0]);
     156                ok &= (y[3] == x[1]);
     157                ok &= (y[4] == x[0]);
     158                ok &= (y[5] == x[1]);
     159                ok &= (f->CompareChange() == 6); // all comparisions have changed
     160
     161                // done with this function
     162                delete f;
     163
     164
     165                // ------------------------------- >= ----------------------------
     166                // create independent variables
     167                Independent(X);
     168
     169                if( X[0] >= X[1] )      // False variable >= variable
     170                        Y[0] = X[0];
     171                else    Y[0] = X[1];
     172                if( X[1] >= X[0] )      // True variable >= variable
     173                        Y[1] = X[0];
     174                else    Y[1] = X[1];
     175                if( 3.5  >= X[1] )      // False parameter >= variable
     176                        Y[2] = X[0];
     177                else    Y[2] = X[1];
     178                if( 3.5  >= X[0] )      // True parameter >= variable
     179                        Y[3] = X[0];
     180                else    Y[3] = X[1];
     181                if( X[0] >= 4.   )      // False variable >= parameter
     182                        Y[4] = X[0];
     183                else    Y[4] = X[1];
     184                if( X[1] >= 4.   )      // True variable >= parameter
     185                        Y[5] = X[0];
     186                else    Y[5] = X[1];
     187
     188                // f : X -> Y
     189                f = new ADFun<double> (X, Y);
     190
     191                // evaluate the function at new argument
     192                y = f->Forward(0, x);
     193
     194                // check results
     195                ok &= (y[0] == x[1]);           // this is what the was taped
     196                ok &= (y[1] == x[0]);
     197                ok &= (y[2] == x[1]);
     198                ok &= (y[3] == x[0]);
     199                ok &= (y[4] == x[1]);
     200                ok &= (y[5] == x[0]);
     201                ok &= (f->CompareChange() == 6); // all comparisions have changed
     202
     203                // done with this function
     204                delete f;
     205
     206                // ------------------------------- == ----------------------------
     207                // create independent variables
     208                Independent(X);
     209
     210                if( X[0] == X[1] )      // False variable == variable
     211                        Y[0] = X[0];
     212                else    Y[0] = X[1];
     213                if( X[0] == X[0] )      // True variable == variable
     214                        Y[1] = X[0];
     215                else    Y[1] = X[1];
     216                if( 3.  == X[1] )       // False parameter == variable
     217                        Y[2] = X[0];
     218                else    Y[2] = X[1];
     219                if( 3.  == X[0] )       // True parameter == variable
     220                        Y[3] = X[0];
     221                else    Y[3] = X[1];
     222                if( X[0] == 4.   )      // False variable == parameter
     223                        Y[4] = X[0];
     224                else    Y[4] = X[1];
     225                if( X[1] == 4.   )      // True variable == parameter
     226                        Y[5] = X[0];
     227                else    Y[5] = X[1];
     228
     229                // f : X -> Y
     230                f = new ADFun<double> (X, Y);
     231
     232                // evaluate the function at new argument
     233                y = f->Forward(0, x);
     234
     235                // check results
     236                ok &= (y[0] == x[1]);           // this is what the was taped
     237                ok &= (y[1] == x[0]);
     238                ok &= (y[2] == x[1]);
     239                ok &= (y[3] == x[0]);
     240                ok &= (y[4] == x[1]);
     241                ok &= (y[5] == x[0]);
     242                // the first two comparisions do not change
     243                ok &= (f->CompareChange() == 4);
     244
     245                // done with this function
     246                delete f;
     247
     248                // ------------------------------- != ----------------------------
     249                // create independent variables
     250                Independent(X);
     251
     252                if( X[0] != X[1] )      // True variable != variable
     253                        Y[0] = X[0];
     254                else    Y[0] = X[1];
     255                if( X[0] != X[0] )      // False variable != variable
     256                        Y[1] = X[0];
     257                else    Y[1] = X[1];
     258                if( 3.  != X[1] )       // True parameter != variable
     259                        Y[2] = X[0];
     260                else    Y[2] = X[1];
     261                if( 3.  != X[0] )       // False parameter != variable
     262                        Y[3] = X[0];
     263                else    Y[3] = X[1];
     264                if( X[0] != 4.   )      // True variable != parameter
     265                        Y[4] = X[0];
     266                else    Y[4] = X[1];
     267                if( X[1] != 4.   )      // False variable != parameter
     268                        Y[5] = X[0];
     269                else    Y[5] = X[1];
     270
     271                // f : X -> Y
     272                f = new ADFun<double> (X, Y);
     273
     274                // evaluate the function at new argument
     275                y = f->Forward(0, x);
     276
     277                // check results
     278                ok &= (y[0] == x[0]);           // this is what the was taped
     279                ok &= (y[1] == x[1]);
     280                ok &= (y[2] == x[0]);
     281                ok &= (y[3] == x[1]);
     282                ok &= (y[4] == x[0]);
     283                ok &= (y[5] == x[1]);
     284                // the first two comparisions do not change
     285                ok &= (f->CompareChange() == 4);
     286
     287                // done with this function
     288                delete f;
     289
     290                return ok;
     291        }
     292        // ----------------------------------------------------------------------
     293        template <typename Type>
     294        Type Minimum(const Type &x, const Type &y)
     295        {       // Use a comparision to compute the min(x, y)
     296                // (note that CondExp would never require retaping).
     297                if( x < y )
     298                        return x;
     299                return y;
     300        }
     301
     302        bool CompareChange_two(void)
     303        {       bool ok = true;
     304
     305                using CppAD::AD;
     306                using CppAD::ADFun;
     307                using CppAD::Independent;
     308
     309                // domain space vector
     310                size_t n = 2;
     311                CPPAD_TESTVECTOR(AD<double>) X(n);
     312                X[0] = 3.;
     313                X[1] = 4.;
     314
     315                // declare independent variables and start tape recording
     316                CppAD::Independent(X);
     317
     318                // range space vector
     319                size_t m = 1;
     320                CPPAD_TESTVECTOR(AD<double>) Y(m);
     321                Y[0] = Minimum(X[0], X[1]);
     322
     323                // create f: x -> y and stop tape recording
     324                ADFun<double> f(X, Y);
     325
     326                // evaluate zero mode Forward where conditional has the same result
     327                // note that f.CompareChange is not defined when NDEBUG is true
     328                CPPAD_TESTVECTOR(double) x(n);
     329                CPPAD_TESTVECTOR(double) y(m);
     330                x[0] = 3.5;
     331                x[1] = 4.;
     332                y    = f.Forward(0, x);
     333                ok  &= (y[0] == x[0]);
     334                ok  &= (y[0] == Minimum(x[0], x[1]));
     335                ok  &= (f.CompareChange() == 0);
     336
     337                // evaluate zero mode Forward where conditional has different result
     338                x[0] = 4.;
     339                x[1] = 3.;
     340                y    = f.Forward(0, x);
     341                ok  &= (y[0] == x[0]);
     342                ok  &= (y[0] != Minimum(x[0], x[1]));
     343                ok  &= (f.CompareChange() == 1);
     344
     345                // re-tape to obtain the new AD operation sequence
     346                X[0] = 4.;
     347                X[1] = 3.;
     348                Independent(X);
     349                Y[0] = Minimum(X[0], X[1]);
     350
     351                // stop tape and store result in f
     352                f.Dependent(Y);
     353
     354                // evaluate the function at new argument values
     355                y    = f.Forward(0, x);
     356                ok  &= (y[0] == x[1]);
     357                ok  &= (y[0] == Minimum(x[0], x[1]));
     358                ok  &= (f.CompareChange() == 0);
     359
     360                return ok;
     361        }
     362}
     363
     364bool compare_change(void)
     365{       bool ok  = true;
     366        ok &= CompareChange_one();
     367        ok &= CompareChange_two();
    290368        return ok;
    291369}
     370
     371// END C++
  • trunk/test_more/optimize.cpp

    r3507 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    311311        (const Vector& x, Vector& y, size_t& original, size_t& opt)
    312312        {       typedef typename Vector::value_type Scalar;
    313                 Scalar a;
     313                Scalar not_used;
    314314                Scalar one(1), two(2), three(3), four(4);
    315                 original = 0;
    316                 opt      = 0;
     315
     316                // independent variable and phantom at beginning
     317                original = 1 + x.size();
     318                opt      = 1 + x.size();
    317319
    318320                // unary operator where operand is arg[0]
    319                 a = CppAD::abs(x[0]);
    320                 if( a < 1. )
    321                         y[0] = sin(x[0]);
    322                 else    y[0] = cos(x[0]);
     321                // (note that sin corresponds to two tape variables)
     322                not_used = CppAD::abs(x[0]);
     323                y[0]     = sin(x[0]);
    323324                original += 3;
    324325                opt      += 2;
     
    326327                // binary operator where left operand is a variable
    327328                // and right operand is a parameter
    328                 a = x[1] + 2.;
    329                 if( a < 3. )
    330                         y[1] = x[1] * 3.;
    331                 else    y[1] = x[1] / 2.;
     329                not_used = not_used + 2.;
     330                y[1]     = x[1] * 3.;
    332331                original += 2;
    333332                opt      += 1;
     
    335334                // binary operator where left operand is a parameter
    336335                // and right operation is a variable
    337                 a = 2. - x[2];
    338                 if( a < 4. )
    339                         y[2] = 3. / x[2];
    340                 else    y[2] = 4. + x[2];
     336                not_used = 2. - not_used;
     337                y[2]     = 3. / x[2];
    341338                original += 2;
    342339                opt      += 1;
    343340
    344341                // binary operator where both operands are variables
    345                 a = x[3] - x[2];
    346                 if( a < 4. )
    347                         y[3] = x[3] / x[2];
    348                 else    y[3] = x[3] + x[2];
     342                not_used  = x[3] - not_used;
     343                y[3]      = x[3] / x[2];
    349344                original += 2;
    350345                opt      += 1;
    351346
    352                 // this conditional expression that will be optimized out
    353                 a = CppAD::CondExpLt(x[0], x[1], x[2], x[3]);
    354                 // 1 of the following 2 conditional expressions will be kept
    355                 if( a < 5. )
    356                         y[4] = CppAD::CondExpLt(x[4], one, two, three);
    357                 else    y[4] = CppAD::CondExpLt(x[4], two, three, four);
    358                 original += 2;
     347                // conditional expression that will be optimized out
     348                not_used = CppAD::CondExpLt(x[0], x[1], x[2], x[3]) + not_used;
     349                y[4]     = CppAD::CondExpLt(x[4], one, two, three);
     350                original += 3;
    359351                opt      += 1;
    360352
    361                 // Make sure that a parameter dependent variable
     353                // y[5] does not depend on the value of not_used.
     354                // Make sure a parameter, corresponding to a dependent variable,
    362355                // is not optimized out of the operation sequence.
    363                 // In addition, we do not use the argument x[5], to
    364                 // make sure it is not optimized out.
    365                 y[5] = 1.;
     356                y[5]      = 0.0 * not_used;
    366357                original += 1;
    367358                opt      += 1;
     359
     360                // Wwe do not use the argument x[5], to
     361                // make sure it is not optimized out.
    368362
    369363                return;
     
    405399       
    406400                // Check size before optimization
    407                 ok &= F.size_var() == (n + 1 + original);
     401                ok &= F.size_var() == original;
    408402       
    409403                // Optimize the operation sequence
     
    411405       
    412406                // Check size after optimization
    413                 ok &= F.size_var() == (n + 1 + opt);
     407                ok &= F.size_var() == opt;
    414408       
    415409                // check result now
  • trunk/test_more/test_more.cpp

    r3520 r3607  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3434extern bool checkpoint(void);
    3535extern bool Compare(void);
    36 extern bool CompareChange(void);
     36extern bool compare_change(void);
    3737extern bool CondExp(void);
    3838extern bool CondExpAD(void);
     
    145145        ok &= Run( checkpoint,      "checkpoint"     );
    146146        ok &= Run( Compare,         "Compare"        );
    147         ok &= Run( CompareChange,   "CompareChange" );
     147        ok &= Run( compare_change,  "compare_change" );
    148148        ok &= Run( CondExp,         "CondExp"        );
    149149        ok &= Run( CondExpAD,       "CondExpAD"      );
Note: See TracChangeset for help on using the changeset viewer.