Changeset 1587


Ignore:
Timestamp:
Nov 24, 2009 2:48:58 PM (11 years ago)
Author:
bradbell
Message:

branches/multiple_result: Replace NonOp? by BeginOp? at begining and EndOp? at end of tape.

Undo the changes on this branch:
seq_property.cpp, */optimize.cpp

Replace NonOp? by BeginOp? at begining and EndOp? at end of tape:
player.hpp, for_jac_sweep.hpp, optimize.hpp, op_code.hpp, forward0sweep.hpp,
independent.hpp, recorder.hpp, forward_sweep.hpp, rev_jac_sweep.hpp,
rev_hes_sweep.hpp, dependent.hpp, reverse_sweep.hpp

for_jac_sweep.hpp: remove special cases (no longer needed).

Location:
branches/multiple_result
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • branches/multiple_result/cppad/local/dependent.hpp

    r1586 r1587  
    215215        }
    216216
    217         // put a NonOp at the end of the tape
    218         tape->Rec_.PutOp(NonOp);
     217        // put an EndOp at the end of the tape
     218        tape->Rec_.PutOp(EndOp);
    219219
    220220        // total number of variables on the tape
     
    222222
    223223        // now that each dependent variable has a place in the tape,
    224         // and there is a NonOp at the end of the tape,
     224        // and there is a EndOp at the end of the tape,
    225225        // we can make a copy for this function and erase the tape.
    226226        play_ = tape->Rec_;
  • branches/multiple_result/cppad/local/for_jac_sweep.hpp

    r1585 r1587  
    134134# endif
    135135
    136         // skip the NonOp at the beginning of the recording
     136        // skip the BeginOp at the beginning of the recording
    137137        play->start_forward(op, arg, i_op, i_var);
     138        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    138139        arg_0 = arg;
    139140        while(i_op < numop_m1)
     
    269270                                i_var, arg[0], var_sparsity
    270271                        );
     272                        break;
     273                        // -------------------------------------------------
     274
     275                        case EndOp:
     276                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    271277                        break;
    272278                        // -------------------------------------------------
     
    343349                        break;
    344350                        // -------------------------------------------------
    345 
    346                         case NonOp:
    347                         CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    348                         var_sparsity.clear(i_var);
    349                         break;
    350351
    351352                        case ParOp:
     
    507508        }
    508509# endif
    509 # ifndef NDEBUG
    510         // temporary: remove when all cases with NumRes(op) > 1
    511         // have been converted
    512         size_t check = i_var + NumRes(op);
    513         switch(op)
    514         {       case PowpvOp:
    515                 case PowvpOp:
    516                 case PowvvOp:
    517                 case CosOp:
    518                 case SinOp:
    519                 case CoshOp:
    520                 case SinhOp:
    521                 check = i_var + 1;
    522                 break;
    523 
    524                 default:
    525                 break;
    526         }
    527         CPPAD_ASSERT_UNKNOWN( check == play->num_rec_var() );
    528 # endif
     510        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_rec_var() );
    529511
    530512        if( vecad_ind != CPPAD_NULL )
  • branches/multiple_result/cppad/local/forward0sweep.hpp

    r1586 r1587  
    158158                text = Rec->GetTxt(0);
    159159
    160         // skip the NonOp at the beginning of the recording
     160        // skip the BeginOp at the beginning of the recording
    161161        Rec->start_forward(op, arg, i_op, i_var);
    162         CPPAD_ASSERT_UNKNOWN( op == NonOp );
     162        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    163163# if CPPAD_FORWARD0SWEEP_TRACE
    164164        std::cout << std::endl;
     
    266266                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
    267267                        forward_divvp_op_0(i_var, arg, parameter, J, Taylor);
     268                        break;
     269                        // -------------------------------------------------
     270
     271                        case EndOp:
     272                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    268273                        break;
    269274                        // -------------------------------------------------
     
    333338                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
    334339                        forward_mulvp_op_0(i_var, arg, parameter, J, Taylor);
    335                         break;
    336                         // -------------------------------------------------
    337 
    338                         case NonOp:
    339                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
    340                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    341340                        break;
    342341                        // -------------------------------------------------
  • branches/multiple_result/cppad/local/forward_sweep.hpp

    r1586 r1587  
    169169       
    170170
    171         // skip the NonOp at the beginning of the recording
     171        // skip the BeginOp at the beginning of the recording
    172172        Rec->start_forward(op, arg, i_op, i_var);
    173         CPPAD_ASSERT_UNKNOWN( op == NonOp );
     173        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    174174# if CPPAD_FORWARD_SWEEP_TRACE
    175175        std::cout << std::endl;
     
    283283                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
    284284                        forward_divvp_op(d, i_var, arg, parameter, J, Taylor);
     285                        break;
     286                        // -------------------------------------------------
     287
     288                        case EndOp:
     289                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    285290                        break;
    286291                        // -------------------------------------------------
     
    361366                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
    362367                        forward_mulvp_op(d, i_var, arg, parameter, J, Taylor);
    363                         break;
    364                         // -------------------------------------------------
    365 
    366                         case NonOp:
    367                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
    368                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    369368                        break;
    370369                        // -------------------------------------------------
  • branches/multiple_result/cppad/local/independent.hpp

    r1447 r1587  
    141141        CPPAD_ASSERT_UNKNOWN( Rec_.num_rec_var() == 0 );
    142142
    143         // skip the first record (parameters use taddr zero)
    144         CPPAD_ASSERT_UNKNOWN( NumRes(NonOp) == 1 );
    145         CPPAD_ASSERT_UNKNOWN( NumArg(NonOp) == 0 );
    146         Rec_.PutOp(NonOp);
    147 
     143        // mark the beginning of the tape and skip the first variable index
     144        // (zero) because parameters use taddr zero
     145        CPPAD_ASSERT_NARG_NRES(BeginOp, 0, 1);
     146        Rec_.PutOp(BeginOp);
    148147
    149148        // place each of the independent variables in the tape
    150         CPPAD_ASSERT_UNKNOWN( NumRes(InvOp) == 1 );
    151         CPPAD_ASSERT_UNKNOWN( NumArg(InvOp) == 0 );
     149        CPPAD_ASSERT_NARG_NRES(InvOp, 0, 1);
    152150        size_t j;
    153151        for(j = 0; j < n; j++)
  • branches/multiple_result/cppad/local/op_code.hpp

    r1586 r1587  
    5151        AsinOp,   // asin(variable)
    5252        AtanOp,   // atan(variable)
     53        BeginOp,  // used to mark the beginning of the tape
    5354        CExpOp,   // CondExp(cop, left, right, trueCase, falseCase)
    5455        ComOp,    // Compare(cop, result, left, right)
     
    5960        DivvpOp,  //      variable   / parameter
    6061        DivvvOp,  //      variable   / variable
     62        EndOp,    //  used to mark the end of the tape
    6163        ExpOp,    //  exp(variable)
    6264        LdpOp,    //    z[parameter]
     
    6769        MulvpOp,  //      variable   * parameter
    6870        MulvvOp,  //      variable   * variable
    69         NonOp,    //  used to offset the first actual variable to have index 1
    7071        ParOp,    //      parameter
    7172        PowvpOp,  //  pow(variable,    parameter)
     
    108109        1, // AsinOp
    109110        1, // AtanOp
     111        0, // BeginOp
    110112        6, // CExpOp
    111113        4, // ComOp
     
    116118        2, // DivvpOp
    117119        2, // DivvvOp
     120        0, // EndOp
    118121        1, // ExpOp
    119122        3, // LdpOp
     
    124127        2, // MulpvOp
    125128        2, // MulvpOp
    126         0, // NonOp
    127129        1, // ParOp
    128130        2, // PowvpOp
     
    184186        2, // AsinOp
    185187        2, // AtanOp
     188        1, // BeginOp  offsets first variable to have index one (not zero)
    186189        1, // CExpOp
    187190        0, // ComOp
     
    192195        1, // DivvpOp
    193196        1, // DivvvOp
     197        0, // EndOp
    194198        1, // ExpOp
    195199        1, // LdpOp
     
    200204        1, // MulpvOp
    201205        1, // MulvpOp
    202         1, // NonOp    (used to offset the first variable to have index one)
    203206        1, // ParOp
    204207        3, // PowvpOp
     
    373376                "Asin"  ,
    374377                "Atan"  ,
     378                "Begin" ,
    375379                "CExp"  ,
    376380                "Com"   ,
     
    381385                "Divvp" ,
    382386                "Divvv" ,
     387                "End"   ,
    383388                "Exp"   ,
    384389                "Ldp"   ,
     
    389394                "Mulvp" ,
    390395                "Mulvv" ,
    391                 "Non"   ,
    392396                "Par"   ,
    393397                "Powvp" ,
     
    529533                break;
    530534
     535                case BeginOp:
     536                case EndOp:
    531537                case InvOp:
    532                 case NonOp:
    533538                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
    534539                break;
  • branches/multiple_result/cppad/local/optimize.hpp

    r1586 r1587  
    236236
    237237        // Initialize a reverse mode sweep through the operation sequence
    238         play->start_reverse();
    239         size_t i_op = 2;
     238        size_t i_op;
     239        play->start_reverse(op, arg, i_op, i_var);
     240        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    240241        size_t mask;
    241242# if CPPAD_OPTIMIZE_TRACE
     
    319320
    320321                        // Operations where there is noting to do
     322                        case BeginOp:
    321323                        case ComOp:
     324                        case EndOp:
    322325                        case InvOp:
    323                         case NonOp:
    324326                        case ParOp:
    325327                        case PripOp:
     
    404406        play->start_forward(op, arg, i_op, i_var);
    405407
    406         // playing forward skips NonOp at the beginning, but not the end.
    407         // Put the beginning NonOp in the recording
    408         CPPAD_ASSERT_UNKNOWN( op == NonOp );
    409         CPPAD_ASSERT_NARG_NRES(NonOp, 0, 1);
    410         new_var[ i_var ] = rec->PutOp(NonOp);
     408        // playing forward skips BeginOp at the beginning, but not EndOp at
     409        // the end.  Put BeginOp at beginning of recording
     410        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
     411        CPPAD_ASSERT_NARG_NRES(BeginOp, 0, 1);
     412        new_var[ i_var ] = rec->PutOp(BeginOp);
    411413
    412414        // temporary buffer for new argument values
     
    429431
    430432                        case InvOp:
    431                         case NonOp:
     433                        case EndOp:
    432434                        keep = true;
    433435                        break;
     
    576578                        break;
    577579
     580                        // Operations with no arguments and no results
     581                        case EndOp:
     582                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     583                        break;
     584
    578585                        // Operations with no arguments and one result
    579586                        case InvOp:
    580                         case NonOp:
    581587                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    582588                        new_var[ i_var ] = rec->PutOp(op);
  • branches/multiple_result/cppad/local/player.hpp

    r1586 r1587  
    456456        \param op
    457457        The input value of op does not matter. Its output value is the
    458         first operator in the recording; i.e., NonOp.
     458        first operator in the recording; i.e., BeginOp.
    459459
    460460        \param op_arg
     
    470470        The input value of var_index does not matter. Its output value is the
    471471        index of the primary (last) result corresponding to the the first
    472         operator (which must be a NonOp); i.e., 0.
     472        operator (which must be a BeginOp); i.e., 0.
    473473        */
    474474        void start_forward(
     
    480480                op_index  = op_index_    = 0;
    481481                var_index = var_index_   = 0;
    482 # ifndef NDEBUG
    483                 CPPAD_ASSERT_UNKNOWN( op_         == NonOp );
    484                 CPPAD_ASSERT_UNKNOWN( NumRes(op_) == 1     );
    485                 CPPAD_ASSERT_UNKNOWN( NumArg(op_) == 0     );
    486 # endif
     482
     483                CPPAD_ASSERT_UNKNOWN( op_  == BeginOp );
     484                CPPAD_ASSERT_NARG_NRES(op_, 0, 1);
     485
    487486                return;
    488487        }
     
    492491
    493492        Use start_forward to initialize to the first operator; i.e.,
    494         the NonOp at the beginning of the recording.
     493        the BeginOp at the beginning of the recording.
    495494
    496495        \param op
     
    548547        Start a play back of the recording during a reverse sweep.
    549548
    550         Initialize by pointing to data for NonOp at the end of the tape.
    551549        Use repeated calls to next_reverse to play back one operator at a time.
    552         The NonOp at the end is skipped by this procedure.
    553         */
    554         void start_reverse(void)
     550
     551        \param op
     552        The input value of op does not matter. Its output value is the
     553        last operator in the recording; i.e., EndOp.
     554
     555        \param op_arg
     556        The input value of *op_arg does not matter. Its output value is the
     557        beginning of the vector of argument indices for the last operation;
     558        (there are no arguments for the last operation so \a op_arg is invalid).
     559
     560        \param op_index
     561        The input value of op_index does not matter. Its output value
     562        is the index of the last operator in the recording.
     563
     564        \param var_index
     565        The input value of var_index does not matter. Its output value is the
     566        index of the primary (last) result corresponding to the the last
     567        operator (which must be a EndOp).
     568        (there are no results for the last operation
     569        so \a var_index is invalid).
     570        */
     571
     572        void start_reverse(
     573        OpCode& op, const size_t*& op_arg, size_t& op_index, size_t& var_index)
    555574        {
    556                 op_arg_     = num_rec_op_arg_;
    557                 op_index_   = num_rec_op_ - 1;
    558                 var_index_  = num_rec_var_ - 1;
    559                 op_         = rec_op_[ op_index_ ];
    560 
    561                 CPPAD_ASSERT_UNKNOWN( op_ == NonOp );
     575                op_arg_     = num_rec_op_arg_;                // index
     576                op_arg      = op_arg_ + rec_op_arg_;          // pointer
     577
     578                op_index    = op_index_   = num_rec_op_ - 1;
     579                var_index   = var_index_  = num_rec_var_ - 1;
     580
     581                op          = op_         = rec_op_[ op_index_ ];
     582                CPPAD_ASSERT_UNKNOWN( op_ == EndOp );
     583                CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    562584                return;
    563585        }
     
    573595        The input value of op does not matter. Its output value is the
    574596        next operator in the recording (in reverse order).
    575         The last operator sets op equal to NonOp.
     597        The last operator sets op equal to EndOp.
    576598
    577599        \param op_arg
     
    593615        The input value of var_index does not matter. Its output value is the
    594616        index of the primary (last) result corresponding to the operator op.
    595         The last operator sets var_index equal to 0 (corresponding to NonOp
     617        The last operator sets var_index equal to 0 (corresponding to BeginOp
    596618        at beginning of operation sequence).
    597619        */
  • branches/multiple_result/cppad/local/recorder.hpp

    r1586 r1587  
    238238        num_rec_var_ += NumRes(op);
    239239
    240         // first operator should be a NonOp and NumRes( NonOp ) > 0
     240        // first operator should be a BeginOp and NumRes( BeginOp ) > 0
    241241        CPPAD_ASSERT_UNKNOWN( num_rec_var_ > 0 );
    242242
  • branches/multiple_result/cppad/local/rev_hes_sweep.hpp

    r1585 r1587  
    166166
    167167        // Initialize
    168         play->start_reverse();
     168        play->start_reverse(op, arg, i_op, i_var);
     169        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    169170        i_op = 2;
    170171# if CPPAD_REV_HES_SWEEP_TRACE
     
    245246                        break;
    246247                        // -------------------------------------------------
     248
     249                        case BeginOp:
     250                        CPPAD_ASSERT_NARG_NRES(op, 0, 0)
     251                        break;
     252                        // -------------------------------------------------
     253
    247254                        case CExpOp:
    248255                        reverse_sparse_hessian_cond_op(
     
    381388                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    382389                        );
    383                         break;
    384                         // -------------------------------------------------
    385 
    386                         case NonOp:
    387                         CPPAD_ASSERT_NARG_NRES(op, 0, 1)
    388 
    389390                        break;
    390391                        // -------------------------------------------------
     
    558559        }
    559560        CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    560         CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == NonOp );
    561         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(NonOp)  );
     561        CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == BeginOp );
     562        CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp)  );
    562563
    563564        if( vecad_jac != CPPAD_NULL )
  • branches/multiple_result/cppad/local/rev_jac_sweep.hpp

    r1585 r1587  
    134134
    135135        // Initialize
    136         play->start_reverse();
     136        play->start_reverse(op, arg, i_op, i_var);
     137        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    137138        i_op = 2;
    138139# if CPPAD_REV_JAC_SWEEP_TRACE
     
    213214                        // -------------------------------------------------
    214215
     216                        case BeginOp:
     217                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     218                        break;
     219                        // -------------------------------------------------
     220
    215221                        case CExpOp:
    216222                        reverse_sparse_jacobian_cond_op(
     
    344350                                i_var, arg[0], var_sparsity
    345351                        );
    346                         break;
    347                         // -------------------------------------------------
    348 
    349                         case NonOp:
    350                         CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    351 
    352352                        break;
    353353                        // -------------------------------------------------
     
    506506        }
    507507        CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    508         CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == NonOp );
    509         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(NonOp)  );
     508        CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == BeginOp );
     509        CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp)  );
    510510
    511511        if( vecad_ind != CPPAD_NULL )
  • branches/multiple_result/cppad/local/reverse_sweep.hpp

    r1586 r1587  
    124124
    125125\par Assumptions
    126 The first operator on the tape is a NonOp,
     126The first operator on the tape is a BeginOp,
    127127and the next \a n operators are InvOp operations for the
    128128corresponding independent variables.
     
    159159
    160160        // Initialize
    161         Rec->start_reverse();
     161        Rec->start_reverse(op, arg, i_op, i_var);
     162        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    162163        i_op   = 2;
    163164# if CPPAD_REVERSE_SWEEP_TRACE
     
    249250                        // -------------------------------------------------
    250251
     252                        case BeginOp:
     253                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     254                        break;
     255                        // --------------------------------------------------
     256
    251257                        case CExpOp:
    252258                        reverse_cond_op(
     
    367373                        // --------------------------------------------------
    368374
    369                         case NonOp:
    370                         break;
    371                         // --------------------------------------------------
    372 
    373375                        case ParOp:
    374376                        break;
     
    479481# endif
    480482        CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    481         CPPAD_ASSERT_UNKNOWN( Rec->GetOp(i_op-1) == NonOp );
    482         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(NonOp)  );
     483        CPPAD_ASSERT_UNKNOWN( Rec->GetOp(i_op-1) == BeginOp );
     484        CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp)  );
    483485}
    484486
  • branches/multiple_result/example/optimize.cpp

    r1586 r1587  
    7373        // a:     the temporary variable inside the function fun.
    7474        // y:     the return value for the function fun and dependent variable.
    75         // NonOp: at the end of every operation sequence.
    76         ok &= (F.size_var() == 5);
     75        ok &= (F.size_var() == 4);
    7776
    7877        // Check zero order forward mode on the original operation sequence
     
    8988        // X[0]:  the independent variable.
    9089        // y:     the return value for the function fun and dependent variable.
    91         // NonOp: at the end of every operation sequence.
    92         ok &= (F.size_var() == 4);
     90        ok &= (F.size_var() == 3);
    9391
    9492        // Check result for a zero order calculation.
  • branches/multiple_result/example/seq_property.cpp

    r1586 r1587  
    5757
    5858        // Use nvar to track the number of variables in the operation sequence.
    59         // Start with two for the phantom variable at the beginning and end
    60         // of the tape.
    61         size_t nvar = 2;
     59        // Start with one for the phantom variable at tape address zero.
     60        size_t nvar = 1;
    6261
    6362        // Use npar to track the number of parameters in the operation sequence.
  • branches/multiple_result/test_more/optimize.cpp

    r1586 r1587  
    8888                CPPAD_TEST_VECTOR< AD<double> > X(n);
    8989                for(j = 0; j < n; j++)
    90                         X[j] = 1. / double(j + 2);
     90                        X[j] = 1. / double(j + 1);
    9191       
    9292                // declare independent variables and start tape recording
     
    111111       
    112112                // Check size before optimization
    113                 // (add 2 for the NonOp at the beginning and end of op seq)
    114                 ok &= F.size_var() == (n + 2 + original);
     113                ok &= F.size_var() == (n + 1 + original);
    115114       
    116115                // Optimize the operation sequence
     
    118117       
    119118                // Check size after optimization
    120                 // (add 2 for the NonOp at the beginning and end of op seq)
    121                 ok &= F.size_var() == (n + 2 + opt);
     119                ok &= F.size_var() == (n + 1 + opt);
    122120       
    123121                // check result now
Note: See TracChangeset for help on using the changeset viewer.