Changeset 2986


Ignore:
Timestamp:
Oct 21, 2013 10:35:05 AM (6 years ago)
Author:
bradbell
Message:

Test and fix using conditional expr optimization with first order reverse.

forward0sweep.hpp: fix typos in comments.
forward_sweep.hpp: fix typos in comments.

Location:
branches/opt_cond_exp
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • branches/opt_cond_exp/cppad/local/forward0sweep.hpp

    r2979 r2986  
    231231                while( cskip_op[i_op] )
    232232                {       if( op == CSumOp )
    233                         {       // CSumOp has a variable number of arguments and
     233                        {       // CSumOp has a variable number of arguments
    234234                                Rec->forward_csum(op, arg, i_op, i_var);
    235235                        }
     
    307307
    308308                        case CSkipOp:
    309                         // CSumOp has a variable number of arguments and
     309                        // CSkipOp has a variable number of arguments and
    310310                        // next_forward thinks it one has one argument.
    311311                        // we must inform next_forward of this special case.
  • branches/opt_cond_exp/cppad/local/forward_sweep.hpp

    r2985 r2986  
    263263                while( cskip_op[i_op] )
    264264                {       if( op == CSumOp )
    265                         {       // CSumOp has a variable number of arguments and
     265                        {       // CSumOp has a variable number of arguments
    266266                                Rec->forward_csum(op, arg, i_op, i_var);
    267267                        }
     
    338338
    339339                        case CSkipOp:
    340                         // CSumOp has a variable number of arguments and
     340                        // CSkipOp has a variable number of arguments and
    341341                        // next_forward thinks it one has one argument.
    342342                        // we must inform next_forward of this special case.
  • branches/opt_cond_exp/cppad/local/reverse.hpp

    r2910 r2986  
    182182                taylor_.data(),
    183183                p,
    184                 Partial.data()
     184                Partial.data(),
     185                cskip_op_
    185186        );
    186187
  • branches/opt_cond_exp/cppad/local/reverse_sweep.hpp

    r2981 r2986  
    7272
    7373\param Rec
     742DO: change this name from Rec to play (becuase it is a player
     75and not a recorder).
    7476The information stored in \a Rec
    7577is a recording of the operations corresponding to the function
     
    145147respect to \f$ u_j^{(k)} \f$.
    146148
     149\param cskip_op
     150Is a vector with size Rec->num_rec_op().
     151If cskip_op[i] is true, the operator index i in the recording
     152does not affect any of the dependent variable (given the value
     153of the independent variables).
     154
    147155\par Assumptions
    148156The first operator on the tape is a BeginOp,
     
    152160template <class Base>
    153161void ReverseSweep(
    154         size_t                d,
    155         size_t                n,
    156         size_t                numvar,
    157         player<Base>*         Rec,
    158         size_t                J,
    159         const Base*           Taylor,
    160         size_t                K,
    161         Base*                 Partial
     162        size_t                      d,
     163        size_t                      n,
     164        size_t                      numvar,
     165        player<Base>*               Rec,
     166        size_t                      J,
     167        const Base*                 Taylor,
     168        size_t                      K,
     169        Base*                       Partial,
     170        const CppAD::vector<bool>&  cskip_op
    162171)
    163172{
     
    215224        {       // next op
    216225                Rec->next_reverse(op, arg, i_op, i_var);
    217 # ifndef NDEBUG
    218                 if( i_op <= n )
    219                 {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
     226                CPPAD_ASSERT_UNKNOWN((i_op >  n) | (op == InvOp) | (op == BeginOp));
     227                CPPAD_ASSERT_UNKNOWN((i_op <= n) | (op != InvOp) | (op != BeginOp));
     228
     229                // check if we are skipping this operation
     230                while( cskip_op[i_op] )
     231                {       if( op == CSumOp )
     232                        {       // CSumOp has a variable number of arguments
     233                                Rec->reverse_csum(op, arg, i_op, i_var);
     234                        }
     235                        Rec->next_reverse(op, arg, i_op, i_var);
    220236                }
    221                 else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
    222 # endif
    223237
    224238                // rest of informaiton depends on the case
     
    298312                        break;
    299313                        // --------------------------------------------------
     314
     315                        case CSkipOp:
     316                        // CSkipOp has a variable number of arguments and
     317                        // next_forward thinks it one has one argument.
     318                        // we must inform next_forward of this special case.
     319                        Rec->reverse_cskip(op, arg, i_op, i_var);
     320                        break;
     321                        // -------------------------------------------------
    300322
    301323                        case CSumOp:
  • branches/opt_cond_exp/test_more/optimize.cpp

    r2985 r2986  
    1818namespace {
    1919        // -------------------------------------------------------------------
    20         // Test conditional optimizing out call to an atomic function
     20        // Test conditional optimizing out call to an atomic function call
    2121        void k_algo(
    2222                const CppAD::vector< CppAD::AD<double> >& x ,
     
    5656                // use zero order to evaluate when condition is true
    5757                CppAD::vector<double>  x(2), dx(2);
    58                 CppAD::vector<double>  y(1), dy(1);
     58                CppAD::vector<double>  y(1), dy(1), w(1);
    5959                x[0] = 3.;
    6060                x[1] = 4.;
     
    8282                dy    = f.Forward(1, dx);
    8383                ok   &= dy[0] == dx[0] - dx[1];
     84
     85                // optimized first order reverse
     86                w[0]  = 1.;
     87                dx    = f.Reverse(1, w);
     88                ok   &= dx[0] == 1.;
     89                ok   &= dx[1] == -1.;
    8490       
    8591                return ok;
Note: See TracChangeset for help on using the changeset viewer.