Changeset 3598


Ignore:
Timestamp:
Jan 15, 2015 7:28:14 AM (5 years ago)
Author:
bradbell
Message:

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

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.

Location:
branches/compare_op
Files:
15 edited

Legend:

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

    r3212 r3598  
    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
  • branches/compare_op/cppad/local/ad_fun.hpp

    r3595 r3598  
    8080        bool check_for_nan_;
    8181
    82         /// debug checking number of comparision operations that changed
     82        /// number of comparision operations that had a different result
     83        /// for the previous zero order forward (than when function was recorded)
    8384        size_t compare_change_;
    8485
     
    398399        }
    399400
    400         /// how many comparision operations have a different result
     401        /// number of comparision operations that had a different result
     402        /// for the previous zero order forward (than when function was recorded)
    401403        size_t CompareChange(void) const
    402404        {       return compare_change_; }
  • branches/compare_op/cppad/local/ad_tape.hpp

    r3153 r3598  
    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(
  • branches/compare_op/cppad/local/atomic_base.hpp

    r3232 r3598  
    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$$,
  • branches/compare_op/cppad/local/comp_op.hpp

    r3597 r3598  
    4343*/
    4444template <class Base>
    45 inline 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 );
     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 );
    5555
    5656        // Taylor coefficients corresponding to arguments and result
     
    8080*/
    8181template <class Base>
    82 inline 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 );
     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 );
    9292
    9393        // Taylor coefficients corresponding to arguments and result
     
    119119*/
    120120template <class Base>
    121 inline 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 );
     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 );
    131131
    132132        // Taylor coefficients corresponding to arguments and result
     
    140140Zero order forward mode comparison check that left < right
    141141
    142 \copydetails forward_leqpv_op_0
     142\copydetails forward_lepv_op_0
    143143*/
    144144template <class Base>
     
    163163Zero order forward mode comparison check that left < right
    164164
    165 \copydetails forward_leqvp_op_0
     165\copydetails forward_levp_op_0
    166166*/
    167167template <class Base>
     
    186186Zero order forward mode comparison check that left < right
    187187
    188 \copydetails forward_leqvv_op_0
     188\copydetails forward_levv_op_0
    189189*/
    190190template <class Base>
     
    210210Zero order forward mode comparison check that left == right
    211211
    212 \copydetails forward_leqpv_op_0
     212\copydetails forward_lepv_op_0
    213213*/
    214214template <class Base>
     
    233233Zero order forward mode comparison check that left == right
    234234
    235 \copydetails forward_leqvv_op_0
     235\copydetails forward_levv_op_0
    236236*/
    237237template <class Base>
     
    257257Zero order forward mode comparison check that left != right
    258258
    259 \copydetails forward_leqpv_op_0
     259\copydetails forward_lepv_op_0
    260260*/
    261261template <class Base>
     
    280280Zero order forward mode comparison check that left != right
    281281
    282 \copydetails forward_leqvv_op_0
     282\copydetails forward_levv_op_0
    283283*/
    284284template <class Base>
  • branches/compare_op/cppad/local/compare.hpp

    r3597 r3598  
    150150                        }
    151151                        else
    152                         {       tape->Rec_.PutOp(LeqvvOp);
     152                        {       tape->Rec_.PutOp(LevvOp);
    153153                                tape->Rec_.PutArg(right.taddr_, left.taddr_);
    154154                        }
     
    161161                        }
    162162                        else
    163                         {       tape->Rec_.PutOp(LeqpvOp);
     163                        {       tape->Rec_.PutOp(LepvOp);
    164164                                tape->Rec_.PutArg(arg1, left.taddr_);
    165165                        }
     
    174174                }
    175175                else
    176                 {       tape->Rec_.PutOp(LeqvpOp);
     176                {       tape->Rec_.PutOp(LevpOp);
    177177                        tape->Rec_.PutArg(right.taddr_, arg0);
    178178                }
     
    197197                if( var_right )
    198198                {       if( result )
    199                         {       tape->Rec_.PutOp(LeqvvOp);
     199                        {       tape->Rec_.PutOp(LevvOp);
    200200                                tape->Rec_.PutArg(left.taddr_, right.taddr_);
    201201                        }
     
    208208                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
    209209                        if( result )
    210                         {       tape->Rec_.PutOp(LeqvpOp);
     210                        {       tape->Rec_.PutOp(LevpOp);
    211211                                tape->Rec_.PutArg(left.taddr_, arg1);
    212212                        }
     
    221221                addr_t arg0 = tape->Rec_.PutPar(left.value_);
    222222                if( result )
    223                 {       tape->Rec_.PutOp(LeqpvOp);
     223                {       tape->Rec_.PutOp(LepvOp);
    224224                        tape->Rec_.PutArg(arg0, right.taddr_);
    225225                }
     
    252252                        }
    253253                        else
    254                         {       tape->Rec_.PutOp(LeqvvOp);
     254                        {       tape->Rec_.PutOp(LevvOp);
    255255                                tape->Rec_.PutArg(left.taddr_, right.taddr_);
    256256                        }
     
    263263                        }
    264264                        else
    265                         {       tape->Rec_.PutOp(LeqvpOp);
     265                        {       tape->Rec_.PutOp(LevpOp);
    266266                                tape->Rec_.PutArg(left.taddr_, arg1);
    267267                        }
     
    276276                }
    277277                else
    278                 {       tape->Rec_.PutOp(LeqpvOp);
     278                {       tape->Rec_.PutOp(LepvOp);
    279279                        tape->Rec_.PutArg(arg0, right.taddr_);
    280280                }
     
    299299                if( var_right )
    300300                {       if( result )
    301                         {       tape->Rec_.PutOp(LeqvvOp);
     301                        {       tape->Rec_.PutOp(LevvOp);
    302302                                tape->Rec_.PutArg(right.taddr_, left.taddr_);
    303303                        }
     
    310310                {       addr_t arg1 = tape->Rec_.PutPar(right.value_);
    311311                        if( result )
    312                         {       tape->Rec_.PutOp(LeqpvOp);
     312                        {       tape->Rec_.PutOp(LepvOp);
    313313                                tape->Rec_.PutArg(arg1, left.taddr_);
    314314                        }
     
    323323                addr_t arg0 = tape->Rec_.PutPar(left.value_);
    324324                if( result )
    325                 {       tape->Rec_.PutOp(LeqvpOp);
     325                {       tape->Rec_.PutOp(LevpOp);
    326326                        tape->Rec_.PutArg(right.taddr_, arg0);
    327327                }
  • branches/compare_op/cppad/local/for_jac_sweep.hpp

    r3597 r3598  
    383383                        case LtvpOp:
    384384                        case LtvvOp:
    385                         case LeqpvOp:
    386                         case LeqvpOp:
    387                         case LeqvvOp:
     385                        case LepvOp:
     386                        case LevpOp:
     387                        case LevvOp:
    388388                        case NepvOp:
    389389                        case NevvOp:
  • branches/compare_op/cppad/local/forward0sweep.hpp

    r3597 r3598  
    443443                        // -------------------------------------------------
    444444
    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(
     445                        case LepvOp:
     446                        forward_lepv_op_0(
     447                                compareCount, arg, parameter, J, taylor
     448                        );
     449                        break;
     450                        // -------------------------------------------------
     451
     452                        case LevpOp:
     453                        forward_levp_op_0(
     454                                compareCount, arg, parameter, J, taylor
     455                        );
     456                        break;
     457                        // -------------------------------------------------
     458
     459                        case LevvOp:
     460                        forward_levv_op_0(
    461461                                compareCount, arg, parameter, J, taylor
    462462                        );
  • branches/compare_op/cppad/local/forward1sweep.hpp

    r3597 r3598  
    544544                        // -------------------------------------------------
    545545
    546                         case LeqpvOp:
    547                         if( p == 0 ) forward_leqpv_op_0(
     546                        case LepvOp:
     547                        if( p == 0 ) forward_lepv_op_0(
    548548                                compareCount, arg, parameter, J, taylor
    549549                        );
    550550                        break;
    551551
    552                         case LeqvpOp:
    553                         if( p == 0 ) forward_leqvp_op_0(
     552                        case LevpOp:
     553                        if( p == 0 ) forward_levp_op_0(
    554554                                compareCount, arg, parameter, J, taylor
    555555                        );
     
    557557                        // -------------------------------------------------
    558558
    559                         case LeqvvOp:
    560                         if( p == 0 ) forward_leqvv_op_0(
     559                        case LevvOp:
     560                        if( p == 0 ) forward_levv_op_0(
    561561                                compareCount, arg, parameter, J, taylor
    562562                        );
  • branches/compare_op/cppad/local/forward2sweep.hpp

    r3597 r3598  
    389389                        case LtvpOp:
    390390                        case LtvvOp:
    391                         case LeqpvOp:
    392                         case LeqvpOp:
    393                         case LeqvvOp:
     391                        case LepvOp:
     392                        case LevpOp:
     393                        case LevvOp:
    394394                        case NepvOp:
    395395                        case NevvOp:
  • branches/compare_op/cppad/local/op_code.hpp

    r3597 r3598  
    9797        LdpOp,    //    z[parameter]
    9898        LdvOp,    //    z[variable]
    99         LeqpvOp,  //  parameter <= variable
    100         LeqvpOp,  //  variable  <= parameter
    101         LeqvvOp,  //  variable  <= variable
     99        LepvOp,   //  parameter <= variable
     100        LevpOp,   //  variable  <= parameter
     101        LevvOp,   //  variable  <= variable
    102102        LogOp,    //  log(variable)
    103103        LtpvOp,   //  parameter < variable
     
    191191                3, // LdpOp
    192192                3, // LdvOp
    193                 2, // LeqpvOp
    194                 2, // LeqvpOp
    195                 2, // LeqvvOp
     193                2, // LepvOp
     194                2, // LevpOp
     195                2, // LevvOp
    196196                1, // LogOp
    197197                2, // LtpvOp
     
    291291                1, // LdpOp
    292292                1, // LdvOp
    293                 0, // LeqpvOp
    294                 0, // LeqvpOp
    295                 0, // LeqvvOp
     293                0, // LepvOp
     294                0, // LevpOp
     295                0, // LevvOp
    296296                1, // LogOp
    297297                0, // LtpvOp
     
    374374                "Ldp"   ,
    375375                "Ldv"   ,
    376                 "Leqpv" ,
    377                 "Leqvp" ,
    378                 "Leqvv" ,
     376                "Lepv" ,
     377                "Levp" ,
     378                "Levv" ,
    379379                "Log"   ,
    380380                "Ltpv"  ,
     
    642642                case AddvvOp:
    643643                case DivvvOp:
    644                 case LeqvvOp:
     644                case LevvOp:
    645645                case LtvvOp:
    646646                case EqvvOp:
     
    655655
    656656                case AddpvOp:
    657                 case LeqpvOp:
     657                case LepvOp:
    658658                case LtpvOp:
    659659                case EqpvOp:
     
    669669
    670670                case DivvpOp:
    671                 case LeqvpOp:
     671                case LevpOp:
    672672                case LtvpOp:
    673673                case PowvpOp:
     
    893893                // ------------------------------------------------------------------
    894894                // 2 arguments, no results
    895                 case LeqpvOp:
     895                case LepvOp:
    896896                case LtpvOp:
    897897                case EqpvOp:
     
    900900                break;
    901901                //
    902                 case LeqvpOp:
     902                case LevpOp:
    903903                case LtvpOp:
    904904                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= result );
    905905                break;
    906906                //
    907                 case LeqvvOp:
     907                case LevvOp:
    908908                case LtvvOp:
    909909                case EqvvOp:
  • branches/compare_op/cppad/local/optimize.hpp

    r3597 r3598  
    17121712
    17131713                        // Compare operators never get removed -----------------
    1714                         case LeqpvOp:
     1714                        case LepvOp:
    17151715                        case LtpvOp:
    17161716                        case EqpvOp:
     
    17191719                        break;
    17201720
    1721                         case LeqvpOp:
     1721                        case LevpOp:
    17221722                        case LtvpOp:
    17231723                        tape[arg[0]].connect_type = yes_connected;
    17241724                        break;
    17251725
    1726                         case LeqvvOp:
     1726                        case LevvOp:
    17271727                        case LtvvOp:
    17281728                        case EqvvOp:
     
    21082108                        case EqpvOp:
    21092109                        case EqvvOp:
    2110                         case LeqpvOp:
    2111                         case LeqvpOp:
    2112                         case LeqvvOp:
     2110                        case LepvOp:
     2111                        case LevpOp:
     2112                        case LevvOp:
    21132113                        case LtpvOp:
    21142114                        case LtvpOp:
     
    24352435                        // ---------------------------------------------------
    24362436                        // Operations with two arguments and no results
    2437                         case LeqpvOp:
     2437                        case LepvOp:
    24382438                        case LtpvOp:
    24392439                        case EqpvOp:
     
    24462446                        break;
    24472447                        //
    2448                         case LeqvpOp:
     2448                        case LevpOp:
    24492449                        case LtvpOp:
    24502450                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     
    24552455                        break;
    24562456                        //
    2457                         case LeqvvOp:
     2457                        case LevvOp:
    24582458                        case LtvvOp:
    24592459                        case EqvvOp:
  • branches/compare_op/cppad/local/rev_hes_sweep.hpp

    r3597 r3598  
    409409                        case LtvpOp:
    410410                        case LtvvOp:
    411                         case LeqpvOp:
    412                         case LeqvpOp:
    413                         case LeqvvOp:
     411                        case LepvOp:
     412                        case LevpOp:
     413                        case LevvOp:
    414414                        case NepvOp:
    415415                        case NevvOp:
  • branches/compare_op/cppad/local/rev_jac_sweep.hpp

    r3597 r3598  
    393393                        case LtvpOp:
    394394                        case LtvvOp:
    395                         case LeqpvOp:
    396                         case LeqvpOp:
    397                         case LeqvvOp:
     395                        case LepvOp:
     396                        case LevpOp:
     397                        case LevvOp:
    398398                        case NepvOp:
    399399                        case NevvOp:
  • branches/compare_op/cppad/local/reverse_sweep.hpp

    r3597 r3598  
    471471                        case LtvpOp:
    472472                        case LtvvOp:
    473                         case LeqpvOp:
    474                         case LeqvpOp:
    475                         case LeqvvOp:
     473                        case LepvOp:
     474                        case LevpOp:
     475                        case LevvOp:
    476476                        case NepvOp:
    477477                        case NevvOp:
Note: See TracChangeset for help on using the changeset viewer.