Changeset 1589


Ignore:
Timestamp:
Nov 24, 2009 10:15:10 PM (11 years ago)
Author:
bradbell
Message:

trunk: Fix optimize.hpp bug, special operations to indicate ends of tape.

optimize.cpp: test a reverse mode case (demonstrates bug).

Use EndOp? (BeginOp?) as indication of end of a forward (reverse) sweep:
for_jac_sweep.hpp, optimize.hpp, forward0sweep.hpp, forward_sweep.hpp,
rev_jac_sweep.hpp, rev_hes_sweep.hpp, reverse_sweep.hpp

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/local/for_jac_sweep.hpp

    r1588 r1589  
    9595        CPPAD_ASSERT_UNKNOWN( play->num_rec_var()  == numvar );
    9696        CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == numvar );
    97 
    98         // set the number of operators
    99         const size_t numop_m1 = play->num_rec_op() - 1;
    10097
    10198        // length of the parameter vector (used by CppAD assert macros)
     
    138135        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    139136        arg_0 = arg;
    140         while(i_op < numop_m1)
     137        while(op != EndOp)
    141138        {
    142139                // this op
  • trunk/cppad/local/forward0sweep.hpp

    r1588 r1589  
    139139        CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
    140140
    141         // set the number of operators
    142         const size_t numop_m1 = Rec->num_rec_op() - 1;
    143 
    144141        // length of the parameter vector (used by CppAD assert macros)
    145142        const size_t num_par = Rec->num_rec_par();
     
    164161        std::cout << std::endl;
    165162# endif
    166         while(i_op < numop_m1)
     163        while(op != EndOp)
    167164        {
    168165                // this op
    169166                Rec->next_forward(op, arg, i_op, i_var);
    170                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    171                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     167# ifndef NDEBUG
     168                if( i_op <= n )
     169                {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
     170                }
     171                else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
     172# endif
    172173
    173174                // action to take depends on the case
  • trunk/cppad/local/forward_sweep.hpp

    r1588 r1589  
    149149        CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
    150150
    151         // set the number of operators
    152         const size_t numop_m1 = Rec->num_rec_op() - 1;
    153 
    154151        // length of the parameter vector (used by CppAD assert macros)
    155152        const size_t num_par = Rec->num_rec_par();
     
    175172        std::cout << std::endl;
    176173# endif
    177         while(i_op < numop_m1)
     174        while(op != EndOp)
    178175        {
    179176                // this op
  • trunk/cppad/local/optimize.hpp

    r1588 r1589  
    192192        const size_t num_var = play->num_rec_var();
    193193
    194         // set the number of operators
    195         const size_t numop_m1 = play->num_rec_op() - 1;
    196 
    197194        // number of  VecAD indices
    198195        size_t num_vecad_ind   = play->num_rec_vecad_ind();
     
    243240        std::cout << std::endl;
    244241# endif
    245         while(i_op > 1 )
     242        while(op != BeginOp)
    246243        {       // next op
    247244                play->next_reverse(op, arg, i_op, i_var);
    248                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
    249                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
     245# ifndef NDEBUG
     246                if( i_op <= n )
     247                {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
     248                }
     249                else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
     250# endif
    250251
    251252# if CPPAD_OPTIMIZE_TRACE
     
    360361                }
    361362        }
     363        // values corresponding to BeginOp
     364        CPPAD_ASSERT_UNKNOWN( i_op == 0 && i_var == 0 );
    362365# if CPPAD_OPTIMIZE_TRACE
    363366        for(i = 0; i < num_vecad_vec; i++)
     
    415418        size_t new_arg[6];
    416419
    417         while(i_op < numop_m1 )
     420        while(op != EndOp)
    418421        {       // next op
    419422                play->next_forward(op, arg, i_op, i_var);
     
    581584                        case EndOp:
    582585                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     586                        rec->PutOp(op);
    583587                        break;
    584588
  • trunk/cppad/local/rev_hes_sweep.hpp

    r1588 r1589  
    168168        play->start_reverse(op, arg, i_op, i_var);
    169169        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    170         i_op = 2;
    171170# if CPPAD_REV_HES_SWEEP_TRACE
    172171        std::cout << std::endl;
     
    174173        CppAD::vectorBool zh_value(limit);
    175174# endif
    176         while(i_op > 1)
     175        while(op != BeginOp)
    177176        {
    178177                // next op
    179178                play->next_reverse(op, arg, i_op, i_var);
    180                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
    181                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    182 
     179# ifndef NDEBUG
     180                if( i_op <= n )
     181                {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
     182                }
     183                else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
     184# endif
    183185
    184186                // rest of information depends on the case
     
    248250
    249251                        case BeginOp:
    250                         CPPAD_ASSERT_NARG_NRES(op, 0, 0)
     252                        CPPAD_ASSERT_NARG_NRES(op, 0, 1)
    251253                        break;
    252254                        // -------------------------------------------------
     
    558560# endif
    559561        }
    560         CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    561         CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == BeginOp );
    562         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp) );
     562        // values corresponding to BeginOp
     563        CPPAD_ASSERT_UNKNOWN( i_op == 0 );
     564        CPPAD_ASSERT_UNKNOWN( i_var == 0 );
    563565
    564566        if( vecad_jac != CPPAD_NULL )
  • trunk/cppad/local/rev_jac_sweep.hpp

    r1588 r1589  
    136136        play->start_reverse(op, arg, i_op, i_var);
    137137        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    138         i_op = 2;
    139138# if CPPAD_REV_JAC_SWEEP_TRACE
    140139        std::cout << std::endl;
    141140        CppAD::vector<bool> z_value(limit);
    142141# endif
    143         while(i_op > 1)
     142        while(op != BeginOp )
    144143        {
    145144                // next op
    146145                play->next_reverse(op, arg, i_op, i_var);
    147                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
    148                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    149 
     146# ifndef NDEBUG
     147                if( i_op <= n )
     148                {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
     149                }
     150                else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
     151# endif
    150152
    151153                // rest of information depends on the case
     
    215217
    216218                        case BeginOp:
    217                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     219                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    218220                        break;
    219221                        // -------------------------------------------------
     
    505507# endif
    506508        }
    507         CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    508         CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == BeginOp );
    509         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp) );
     509        // values corresponding to BeginOp
     510        CPPAD_ASSERT_UNKNOWN( i_op == 0 );
     511        CPPAD_ASSERT_UNKNOWN( i_var == 0 );
    510512
    511513        if( vecad_ind != CPPAD_NULL )
  • trunk/cppad/local/reverse_sweep.hpp

    r1588 r1589  
    161161        Rec->start_reverse(op, arg, i_op, i_var);
    162162        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    163         i_op   = 2;
    164163# if CPPAD_REVERSE_SWEEP_TRACE
    165164        std::cout << std::endl;
    166165# endif
    167         while(i_op > 1)
     166        while(op != BeginOp )
    168167        {       // next op
    169168                Rec->next_reverse(op, arg, i_op, i_var);
    170                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    171                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     169# ifndef NDEBUG
     170                if( i_op <= n )
     171                {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
     172                }
     173                else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
     174# endif
    172175
    173176                // rest of informaiton depends on the case
     
    251254
    252255                        case BeginOp:
    253                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     256                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    254257                        break;
    255258                        // --------------------------------------------------
     
    480483        std::cout << std::endl;
    481484# endif
    482         CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    483         CPPAD_ASSERT_UNKNOWN( Rec->GetOp(i_op-1) == BeginOp );
    484         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp) );
     485        // values corresponding to BeginOp
     486        CPPAD_ASSERT_UNKNOWN( i_op == 0 );
     487        CPPAD_ASSERT_UNKNOWN( i_var == 0 );
    485488}
    486489
  • trunk/test_more/optimize.cpp

    r1581 r1589  
    1111-------------------------------------------------------------------------- */
    1212
     13# include <limits>
    1314# include <cppad/cppad.hpp>
    1415
     
    211212       
    212213                for(j = 0; j < n; j++)
    213                         X[j] = x[j] = double(j+1);
     214                        X[j] = x[j] = double(j+2);
    214215       
    215216                CppAD::Independent(X);
     
    228229                for(j = 0; j < n; j++)
    229230                        ok &= ( y[j] == Value(Y[j]) );
     231
     232                // check reverse mode derivative
     233                vector<double>   w(n), dw(n);
     234                w[0] = 0.;
     235                w[1] = 0.;
     236                w[2] = 1.;
     237                dw = F.Reverse(1, w);
     238
     239                double eps = 20. * std::numeric_limits<double>::epsilon();
     240                double check = x[1] * pow( x[0], x[1] - 1. );
     241                ok &= CppAD::NearEqual( dw[0], check, eps, eps );
     242
     243                check = log( x[0] ) * pow( x[0], x[1] );
     244                ok &= CppAD::NearEqual( dw[1], check, eps, eps );
     245
     246                check = 0.;
     247                ok &= CppAD::NearEqual( dw[2], check, eps, eps );
    230248       
    231249                return ok;
Note: See TracChangeset for help on using the changeset viewer.