Changeset 3597


Ignore:
Timestamp:
Jan 14, 2015 11:22:49 PM (5 years ago)
Author:
bradbell
Message:

merge to branch: branches/compare_op
from repository: https://github.com/bradbell/cppad
start hash code: 9ed03e1ee2c258ca38561ad083067e235d032e14
end hash code: ae729296323eb7f4f4a7c0e90a303a8d7f4ed42a

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.

Location:
branches/compare_op
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed
  • branches/compare_op/bin/speed_new.sh

    r3565 r3597  
    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        #
  • branches/compare_op/cppad/local/comp_op.hpp

    r3301 r3597  
    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_leqpv_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(LeqpvOp) == 2 );
     54        CPPAD_ASSERT_UNKNOWN( NumRes(LeqpvOp) == 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_leqvp_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(LeqvpOp) == 2 );
     91        CPPAD_ASSERT_UNKNOWN( NumRes(LeqvpOp) == 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_leqvv_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(LeqvvOp) == 2 );
     130        CPPAD_ASSERT_UNKNOWN( NumRes(LeqvvOp) == 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_leqpv_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_leqvp_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_leqvv_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_leqpv_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_leqvv_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_leqpv_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_leqvv_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
  • branches/compare_op/cppad/local/compare.hpp

    r3595 r3597  
    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 // -------------------------------- < -------------------------
     135// -------------------------------- < --------------------------
    187136template <class Base>
    188137CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    189138bool operator < (const AD<Base> &left , const AD<Base> &right)
    190 {       bool result =  (left.value_ < right.value_);
    191 
    192         ADTape<Base> *tape = CPPAD_NULL;
    193         if( Variable(left) )
    194                 tape = left.tape_this();
    195         else if ( Variable(right) )
    196                 tape = right.tape_this();
    197 
    198         if( tape != CPPAD_NULL )
    199                 tape->RecordCompare(CompareLt, result, left, right);
    200 
    201         return result;
    202 }
    203 
     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(LeqvvOp);
     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(LeqpvOp);
     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(LeqvpOp);
     177                        tape->Rec_.PutArg(right.taddr_, arg0);
     178                }
     179        }
     180
     181        return result;
     182}
    204183// convert other cases into the case above
    205184CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(<)
     
    209188CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    210189bool operator <= (const AD<Base> &left , const AD<Base> &right)
    211 {       bool result =  (left.value_ <= right.value_);
    212 
    213         ADTape<Base> *tape = CPPAD_NULL;
    214         if( Variable(left) )
    215                 tape = left.tape_this();
    216         else if ( Variable(right) )
    217                 tape = right.tape_this();
    218 
    219         if( tape != CPPAD_NULL )
    220                 tape->RecordCompare(CompareLe, result, left, right);
    221 
    222         return result;
    223 }
    224 
     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(LeqvvOp);
     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(LeqvpOp);
     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(LeqpvOp);
     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}
    225234// convert other cases into the case above
    226235CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(<=)
    227236
    228 
    229 // -------------------------------- > -------------------------
     237// -------------------------------- > --------------------------
    230238template <class Base>
    231239CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    232240bool operator > (const AD<Base> &left , const AD<Base> &right)
    233 {       bool result =  (left.value_ > right.value_);
    234 
    235         ADTape<Base> *tape = CPPAD_NULL;
    236         if( Variable(left) )
    237                 tape = left.tape_this();
    238         else if ( Variable(right) )
    239                 tape = right.tape_this();
    240 
    241         if( tape != CPPAD_NULL )
    242                 tape->RecordCompare(CompareGt, result, left, right);
    243 
    244 
    245         return result;
    246 }
    247 
     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(LeqvvOp);
     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(LeqvpOp);
     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(LeqpvOp);
     279                        tape->Rec_.PutArg(arg0, right.taddr_);
     280                }
     281        }
     282
     283        return result;
     284}
    248285// convert other cases into the case above
    249286CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(>)
     
    253290CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    254291bool operator >= (const AD<Base> &left , const AD<Base> &right)
    255 {       bool result =  (left.value_ >= right.value_);
    256 
    257         ADTape<Base> *tape = CPPAD_NULL;
    258         if( Variable(left) )
    259                 tape = left.tape_this();
    260         else if ( Variable(right) )
    261                 tape = right.tape_this();
    262 
    263         if( tape != CPPAD_NULL )
    264                 tape->RecordCompare(CompareGe, result, left, right);
    265 
    266         return result;
    267 }
    268 
     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(LeqvvOp);
     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(LeqpvOp);
     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(LeqvpOp);
     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}
    269336// convert other cases into the case above
    270337CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(>=)
    271338
    272 
    273339// -------------------------------- == -------------------------
    274340template <class Base>
    275341CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    276342bool operator == (const AD<Base> &left , const AD<Base> &right)
    277 {       bool result =  (left.value_ == right.value_);
    278 
    279         ADTape<Base> *tape = CPPAD_NULL;
    280         if( Variable(left) )
    281                 tape = left.tape_this();
    282         else if ( Variable(right) )
    283                 tape = right.tape_this();
    284 
    285         if( tape != CPPAD_NULL )
    286                 tape->RecordCompare(CompareEq, result, left, right);
    287 
    288         return result;
    289 }
    290 
     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}
    291378// convert other cases into the case above
    292379CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(==)
     
    296383CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    297384bool 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(CompareNe, result, left, right);
    308 
    309         return result;
    310 }
    311 
     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}
    312420// convert other cases into the case above
    313421CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR(!=)
  • branches/compare_op/cppad/local/for_jac_sweep.hpp

    r3495 r3597  
    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 LeqpvOp:
     386                        case LeqvpOp:
     387                        case LeqvvOp:
     388                        case NepvOp:
     389                        case NevvOp:
     390                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    383391                        break;
    384392                        // -------------------------------------------------
  • branches/compare_op/cppad/local/forward0sweep.hpp

    r3495 r3597  
    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
     
    126126
    127127\return
    128 The return value is equal to the number of ComOp operations
     128The return value is equal to the number of comparision operations
    129129that have a different result from when the information in
    130130play 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.)
    133131*/
    134132
     
    167165        const addr_t*   arg = CPPAD_NULL;
    168166
    169         // initialize the comparision operator (ComOp) counter
     167        // initialize the comparision operator counter
    170168        size_t compareCount = 0;
    171169
     
    317315                        break;
    318316                        // ---------------------------------------------------
    319                         case ComOp:
    320                         forward_comp_op_0(
    321                         compareCount, arg, num_par, parameter, J, taylor
    322                         );
    323                         break;
    324                         // ---------------------------------------------------
    325317
    326318                        case CosOp:
     
    388380                        // -------------------------------------------------
    389381
     382                        case EqpvOp:
     383                        forward_eqpv_op_0(
     384                                compareCount, arg, parameter, J, taylor
     385                        );
     386                        break;
     387                        // -------------------------------------------------
     388
     389                        case EqvvOp:
     390                        forward_eqvv_op_0(
     391                                compareCount, arg, parameter, J, taylor
     392                        );
     393                        break;
     394                        // -------------------------------------------------
     395
    390396# if CPPAD_COMPILER_HAS_ERF
    391397                        case ErfOp:
     
    405411                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    406412                        break;
    407                         // -------------------------------------------------
     413                        // ---------------------------------------------------
    408414
    409415                        case LdpOp:
     
    437443                        // -------------------------------------------------
    438444
     445                        case LeqpvOp:
     446                        forward_leqpv_op_0(
     447                                compareCount, arg, parameter, J, taylor
     448                        );
     449                        break;
     450                        // -------------------------------------------------
     451
     452                        case LeqvpOp:
     453                        forward_leqvp_op_0(
     454                                compareCount, arg, parameter, J, taylor
     455                        );
     456                        break;
     457                        // -------------------------------------------------
     458
     459                        case LeqvvOp:
     460                        forward_leqvv_op_0(
     461                                compareCount, arg, parameter, J, taylor
     462                        );
     463                        break;
     464                        // -------------------------------------------------
     465
    439466                        case LogOp:
    440467                        forward_log_op_0(i_var, arg[0], J, taylor);
     468                        break;
     469                        // -------------------------------------------------
     470
     471                        case LtpvOp:
     472                        forward_ltpv_op_0(
     473                                compareCount, arg, parameter, J, taylor
     474                        );
     475                        break;
     476                        // -------------------------------------------------
     477
     478                        case LtvpOp:
     479                        forward_ltvp_op_0(
     480                                compareCount, arg, parameter, J, taylor
     481                        );
     482                        break;
     483                        // -------------------------------------------------
     484
     485                        case LtvvOp:
     486                        forward_ltvv_op_0(
     487                                compareCount, arg, parameter, J, taylor
     488                        );
    441489                        break;
    442490                        // -------------------------------------------------
     
    450498                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    451499                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
     500                        break;
     501                        // -------------------------------------------------
     502
     503                        case NepvOp:
     504                        forward_nepv_op_0(
     505                                compareCount, arg, parameter, J, taylor
     506                        );
     507                        break;
     508                        // -------------------------------------------------
     509
     510                        case NevvOp:
     511                        forward_nevv_op_0(
     512                                compareCount, arg, parameter, J, taylor
     513                        );
    452514                        break;
    453515                        // -------------------------------------------------
  • branches/compare_op/cppad/local/forward1sweep.hpp

    r3495 r3597  
    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
     
    168168If p is not zero, the return value is zero.
    169169If p is zero,
    170 the return value is equal to the number of ComOp operations
     170the return value is equal to the number of comparison operations
    171171that have a different result from when the information in
    172172a 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.)
    175173*/
    176174
     
    212210        const addr_t*   arg = CPPAD_NULL;
    213211
    214         // initialize the comparision operator (ComOp) counter
     212        // initialize the comparision operator counter
    215213        size_t compareCount = 0;
    216214
     
    358356                        // -------------------------------------------------
    359357
    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 
    369358                        case CExpOp:
    370359                        forward_cond_op(
    371360                                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
    379361                        );
    380362                        break;
     
    447429                        // -------------------------------------------------
    448430
     431                        case EqpvOp:
     432                        if( p == 0 ) forward_eqpv_op_0(
     433                                compareCount, arg, parameter, J, taylor
     434                        );
     435                        break;
     436                        // -------------------------------------------------
     437
     438                        case EqvvOp:
     439                        if( p == 0 ) forward_eqvv_op_0(
     440                                compareCount, arg, parameter, J, taylor
     441                        );
     442                        break;
     443                        // -------------------------------------------------
     444
     445# if CPPAD_COMPILER_HAS_ERF
     446                        case ErfOp:
     447                        CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
     448                        // 2DO: implement zero order version of this function
     449                        forward_erf_op(p, q, i_var, arg, parameter, J, taylor);
     450                        break;
     451# endif
     452                        // -------------------------------------------------
     453
    449454                        case ExpOp:
    450455                        forward_exp_op(p, q, i_var, arg[0], J, taylor);
    451456                        break;
    452                         // -------------------------------------------------
     457                        // ---------------------------------------------------
    453458
    454459                        case InvOp:
     
    539544                        // -------------------------------------------------
    540545
     546                        case LeqpvOp:
     547                        if( p == 0 ) forward_leqpv_op_0(
     548                                compareCount, arg, parameter, J, taylor
     549                        );
     550                        break;
     551
     552                        case LeqvpOp:
     553                        if( p == 0 ) forward_leqvp_op_0(
     554                                compareCount, arg, parameter, J, taylor
     555                        );
     556                        break;
     557                        // -------------------------------------------------
     558
     559                        case LeqvvOp:
     560                        if( p == 0 ) forward_leqvv_op_0(
     561                                compareCount, arg, parameter, J, taylor
     562                        );
     563                        break;
     564                        // -------------------------------------------------
     565
    541566                        case LogOp:
    542567                        forward_log_op(p, q, i_var, arg[0], J, taylor);
     568                        break;
     569                        // -------------------------------------------------
     570
     571                        case LtpvOp:
     572                        if( p == 0 ) forward_ltpv_op_0(
     573                                compareCount, arg, parameter, J, taylor
     574                        );
     575                        break;
     576
     577                        case LtvpOp:
     578                        if( p == 0 ) forward_ltvp_op_0(
     579                                compareCount, arg, parameter, J, taylor
     580                        );
     581                        break;
     582                        // -------------------------------------------------
     583
     584                        case LtvvOp:
     585                        if( p == 0 ) forward_ltvv_op_0(
     586                                compareCount, arg, parameter, J, taylor
     587                        );
    543588                        break;
    544589                        // -------------------------------------------------
     
    552597                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    553598                        forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
     599                        break;
     600                        // -------------------------------------------------
     601
     602                        case NepvOp:
     603                        if( p == 0 ) forward_nepv_op_0(
     604                                compareCount, arg, parameter, J, taylor
     605                        );
     606                        break;
     607                        // -------------------------------------------------
     608
     609                        case NevvOp:
     610                        if( p == 0 ) forward_nevv_op_0(
     611                                compareCount, arg, parameter, J, taylor
     612                        );
    554613                        break;
    555614                        // -------------------------------------------------
  • branches/compare_op/cppad/local/forward2sweep.hpp

    r3583 r3597  
    171171        const addr_t*   arg = CPPAD_NULL;
    172172
    173         // initialize the comparision operator (ComOp) counter
     173        // the comparision operator comparison counter
    174174        const size_t compareCount = 0;
    175175
     
    295295                        // ---------------------------------------------------
    296296
    297                         case ComOp:
    298                         CPPAD_ASSERT_UNKNOWN(q > 0 );
    299                         break;
    300                         // ---------------------------------------------------
    301 
    302297                        case CosOp:
    303298                        // sin(x), cos(x)
     
    387382                        );
    388383                        break;
     384                        // ---------------------------------------------------
     385
     386                        case EqpvOp:
     387                        case EqvvOp:
     388                        case LtpvOp:
     389                        case LtvpOp:
     390                        case LtvvOp:
     391                        case LeqpvOp:
     392                        case LeqvpOp:
     393                        case LeqvvOp:
     394                        case NepvOp:
     395                        case NevvOp:
     396                        CPPAD_ASSERT_UNKNOWN(q > 0 );
     397                        break;
    389398                        // -------------------------------------------------
    390399
     
    392401                        forward_log_op_dir(q, r, i_var, arg[0], J, taylor);
    393402                        break;
    394                         // -------------------------------------------------
     403                        // ---------------------------------------------------
    395404
    396405                        case MulvvOp:
  • branches/compare_op/cppad/local/op_code.hpp

    r3495 r3597  
    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        LeqpvOp,  //  parameter <= variable
     100        LeqvpOp,  //  variable  <= parameter
     101        LeqvvOp,  //  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, // LeqpvOp
     194                2, // LeqvpOp
     195                2, // LeqvvOp
    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, // LeqpvOp
     294                0, // LeqvpOp
     295                0, // LeqvvOp
    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                "Leqpv" ,
     377                "Leqvp" ,
     378                "Leqvv" ,
    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 LeqvvOp:
     645                case LtvvOp:
     646                case EqvvOp:
     647                case NevvOp:
    608648                case MulvvOp:
    609649                case PowvvOp:
     
    615655
    616656                case AddpvOp:
     657                case LeqpvOp:
     658                case LtpvOp:
     659                case EqpvOp:
     660                case NepvOp:
    617661                case SubpvOp:
    618662                case MulpvOp:
     
    625669
    626670                case DivvpOp:
     671                case LeqvpOp:
     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 LeqpvOp:
     896                case LtpvOp:
     897                case EqpvOp:
     898                case NepvOp:
     899                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
     900                break;
     901                //
     902                case LeqvpOp:
     903                case LtvpOp:
     904                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= result );
     905                break;
     906                //
     907                case LeqvvOp:
     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:
  • branches/compare_op/cppad/local/optimize.hpp

    r3596 r3597  
    17111711                        break;
    17121712
    1713                         // Another operator that never gets removed
    1714                         case ComOp:
    1715                         if( arg[1] & 2 )
    1716                                 tape[arg[2]].connect_type = yes_connected;
    1717                         if( arg[1] & 4 )
    1718                                 tape[arg[3]].connect_type = yes_connected;
    1719                         break;
    1720 
    1721                         // Load using a parameter index
     1713                        // Compare operators never get removed -----------------
     1714                        case LeqpvOp:
     1715                        case LtpvOp:
     1716                        case EqpvOp:
     1717                        case NepvOp:
     1718                        tape[arg[1]].connect_type = yes_connected;
     1719                        break;
     1720
     1721                        case LeqvpOp:
     1722                        case LtvpOp:
     1723                        tape[arg[0]].connect_type = yes_connected;
     1724                        break;
     1725
     1726                        case LeqvvOp:
     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 ----------------------
    17221735                        case LdpOp:
    17231736                        if( tape[i_var].connect_type != not_connected )
     
    20922105                bool keep;
    20932106                switch( op )
    2094                 {       case ComOp: // see wish_list/Optimize/CompareChange entry.
     2107                {       // see wish_list/Optimize/CompareChange entry.
     2108                        case EqpvOp:
     2109                        case EqvvOp:
     2110                        case LeqpvOp:
     2111                        case LeqvpOp:
     2112                        case LeqvvOp:
     2113                        case LtpvOp:
     2114                        case LtvpOp:
     2115                        case LtvvOp:
     2116                        case NepvOp:
     2117                        case NevvOp:
    20952118                        keep = true;
    20962119                        break;
     
    24112434                        break;
    24122435                        // ---------------------------------------------------
    2413                         // Operations with 4 arguments and no results
    2414                         case ComOp:
    2415                         CPPAD_ASSERT_NARG_NRES(op, 4, 0);
    2416                         new_arg[0] = arg[0];
    2417                         new_arg[1] = arg[1];
    2418                         if( arg[1] & 2 )
    2419                                 new_arg[2] = tape[arg[2]].new_var;
    2420                         else
    2421                                 new_arg[2] = rec->PutPar( play->GetPar(arg[2]) );
    2422                         if( arg[1] & 4 )
    2423                                 new_arg[3] = tape[arg[3]].new_var;
    2424                         else
    2425                                 new_arg[3] = rec->PutPar( play->GetPar(arg[3]) );
    2426                         rec->PutArg(
    2427                                 new_arg[0] ,
    2428                                 new_arg[1] ,
    2429                                 new_arg[2] ,
    2430                                 new_arg[3]
    2431                         );
     2436                        // Operations with two arguments and no results
     2437                        case LeqpvOp:
     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]);
    24322445                        rec->PutOp(op);
    24332446                        break;
     2447                        //
     2448                        case LeqvpOp:
     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 LeqvvOp:
     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
    24342468                        // ---------------------------------------------------
    24352469                        // Operations with no arguments and one result
  • branches/compare_op/cppad/local/rev_hes_sweep.hpp

    r3495 r3597  
    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 LeqpvOp:
     412                        case LeqvpOp:
     413                        case LeqvvOp:
     414                        case NepvOp:
     415                        case NevvOp:
     416                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    409417                        break;
    410418                        // -------------------------------------------------
  • branches/compare_op/cppad/local/rev_jac_sweep.hpp

    r3495 r3597  
    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 LeqpvOp:
     396                        case LeqvpOp:
     397                        case LeqvvOp:
     398                        case NepvOp:
     399                        case NevvOp:
     400                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    393401                        break;
    394402                        // -------------------------------------------------
  • branches/compare_op/cppad/local/reverse_sweep.hpp

    r3495 r3597  
    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 LeqpvOp:
     474                        case LeqvpOp:
     475                        case LeqvvOp:
     476                        case NepvOp:
     477                        case NevvOp:
     478                        break;
     479                        // -------------------------------------------------
    470480
    471481                        case LogOp:
  • branches/compare_op/omh/wish_list.omh

    r3595 r3597  
    179179the $cref optimize$$ procedure (so that $cref CompareChange$$
    180180can be used after optimization).
    181 This caused a 5% slow down in the
    182 $cref speed_cppad$$ tests (using the
    183 $cref/optimize/speed_main/option_list/optimize/$$ and
    184 $cref/onetape/speed_main/option_list/onetape/$$ options).
     181This caused a significant slow down in the
     182$cref cppad_det_lu.cpp$$ speed test.
     183For the other $cref speed_cppad$$ tests, this had little
     184or no effect.
    185185Perhaps $code optimize$$ should have an option whereby
    186 these operators can be removed.
     186the user can choose to have these operators removed.
    187187
    188188$subhead Expression Hashing$$
Note: See TracChangeset for help on using the changeset viewer.