Changeset 3338


Ignore:
Timestamp:
Sep 17, 2014 8:24:49 AM (6 years ago)
Author:
bradbell
Message:

Add one result to EndOp? so always have i_var < num_var.

cache.hpp: Add copyright and svn Id.
forward0sweep.hpp: check all operators (even after skip).
forward1sweep.hpp: check all operators (even after skip).
player.hpp: set num_cache_rec_ in all cases.
plan.txt: add copyright and svn Id.

Location:
branches/cache
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • branches/cache/cppad/local/cache.hpp

    r3336 r3338  
     1/* $Id$ */
     2/* --------------------------------------------------------------------------
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4
     5CppAD is distributed under multiple licenses. This distribution is under
     6the terms of the
     7                    Eclipse Public License Version 1.0.
     8
     9A copy of this license is included in the COPYING file of this distribution.
     10Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
     11-------------------------------------------------------------------------- */
     12# ifndef CPPAD_CACHE_INCLUDED
     13# define CPPAD_CACHE_INCLUDED
     14
    115/*
    216$begin cache$$
     
    126140        rec.PutArg(0);
    127141
     142        CPPAD_ASSERT_UNKNOWN( NumArg(EndOp) == 0 );
    128143        while( op != EndOp )
    129144        {       // next op
     
    155170
    156171} // END_CPPAD_NAMESPACE
     172
     173# endif
  • branches/cache/cppad/local/for_jac_sweep.hpp

    r3334 r3338  
    334334
    335335                        case EndOp:
    336                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     336                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    337337                        more_operators = false;
    338338                        break;
  • branches/cache/cppad/local/forward0sweep.hpp

    r3335 r3338  
    252252                // this op
    253253                play->forward_next(op, arg, i_op, i_var);
    254                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    255                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    256                 CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    257                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    258254
    259255                // check if we are skipping this operation
     
    266262                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    267263                }
     264                CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     265                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
     266                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     267                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
     268                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    268269
    269270                // action to take depends on the case
     
    288289                        case AcosOp:
    289290                        // sqrt(1 - x * x), acos(x)
    290                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    291291                        forward_acos_op_0(i_var, arg[0], J, taylor);
    292292                        break;
     
    295295                        case AsinOp:
    296296                        // sqrt(1 - x * x), asin(x)
    297                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    298297                        forward_asin_op_0(i_var, arg[0], J, taylor);
    299298                        break;
     
    302301                        case AtanOp:
    303302                        // 1 + x * x, atan(x)
    304                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    305303                        forward_atan_op_0(i_var, arg[0], J, taylor);
    306304                        break;
     
    324322                        case CosOp:
    325323                        // sin(x), cos(x)
    326                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    327324                        forward_cos_op_0(i_var, arg[0], J, taylor);
    328325                        break;
     
    331328                        case CoshOp:
    332329                        // sinh(x), cosh(x)
    333                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    334330                        forward_cosh_op_0(i_var, arg[0], J, taylor);
    335331                        break;
     
    381377
    382378                        case EndOp:
    383                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     379                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    384380                        more_operators = false;
    385381                        break;
     
    475471                        case SignOp:
    476472                        // cos(x), sin(x)
    477                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    478473                        forward_sign_op_0(i_var, arg[0], J, taylor);
    479474                        break;
     
    482477                        case SinOp:
    483478                        // cos(x), sin(x)
    484                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    485479                        forward_sin_op_0(i_var, arg[0], J, taylor);
    486480                        break;
     
    489483                        case SinhOp:
    490484                        // cosh(x), sinh(x)
    491                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    492485                        forward_sinh_op_0(i_var, arg[0], J, taylor);
    493486                        break;
     
    570563                        case TanOp:
    571564                        // tan(x)^2, tan(x)
    572                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    573565                        forward_tan_op_0(i_var, arg[0], J, taylor);
    574566                        break;
     
    577569                        case TanhOp:
    578570                        // tanh(x)^2, tanh(x)
    579                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    580571                        forward_tanh_op_0(i_var, arg[0], J, taylor);
    581572                        break;
  • branches/cache/cppad/local/forward1sweep.hpp

    r3334 r3338  
    301301                // this op
    302302                play->forward_next(op, arg, i_op, i_var);
    303                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    304                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    305                 CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    306                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    307303
    308304                // check if we are skipping this operation
     
    315311                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    316312                }
     313                CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     314                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
     315                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     316                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
     317                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    317318
    318319                // action depends on the operator
     
    337338                        case AcosOp:
    338339                        // sqrt(1 - x * x), acos(x)
    339                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    340340                        forward_acos_op(p, q, i_var, arg[0], J, taylor);
    341341                        break;
     
    344344                        case AsinOp:
    345345                        // sqrt(1 - x * x), asin(x)
    346                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    347346                        forward_asin_op(p, q, i_var, arg[0], J, taylor);
    348347                        break;
     
    351350                        case AtanOp:
    352351                        // 1 + x * x, atan(x)
    353                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    354352                        forward_atan_op(p, q, i_var, arg[0], J, taylor);
    355353                        break;
     
    372370                        case CosOp:
    373371                        // sin(x), cos(x)
    374                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    375372                        forward_cos_op(p, q, i_var, arg[0], J, taylor);
    376373                        break;
     
    379376                        case CoshOp:
    380377                        // sinh(x), cosh(x)
    381                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    382378                        forward_cosh_op(p, q, i_var, arg[0], J, taylor);
    383379                        break;
     
    431427
    432428                        case EndOp:
    433                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     429                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    434430                        more_operators = false;
    435431                        break;
     
    585581                        case SignOp:
    586582                        // sign(x)
    587                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    588583                        forward_sign_op(p, q, i_var, arg[0], J, taylor);
    589584                        break;
     
    592587                        case SinOp:
    593588                        // cos(x), sin(x)
    594                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    595589                        forward_sin_op(p, q, i_var, arg[0], J, taylor);
    596590                        break;
     
    599593                        case SinhOp:
    600594                        // cosh(x), sinh(x)
    601                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    602595                        forward_sinh_op(p, q, i_var, arg[0], J, taylor);
    603596                        break;
     
    688681                        case TanOp:
    689682                        // tan(x)^2, tan(x)
    690                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    691683                        forward_tan_op(p, q, i_var, arg[0], J, taylor);
    692684                        break;
     
    695687                        case TanhOp:
    696688                        // tanh(x)^2, tanh(x)
    697                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    698689                        forward_tanh_op(p, q, i_var, arg[0], J, taylor);
    699690                        break;
  • branches/cache/cppad/local/forward2sweep.hpp

    r3334 r3338  
    355355                        case EndOp:
    356356                        // needed for sparse_jacobian test
    357                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     357                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    358358                        more_operators = false;
    359359                        break;
  • branches/cache/cppad/local/op_code.hpp

    r3334 r3338  
    264264                1, // DivvpOp
    265265                1, // DivvvOp
    266                 0, // EndOp
     266                1, // EndOp    (dummy result that is not used)
    267267                1, // ExpOp
    268268                1, // InvOp
  • branches/cache/cppad/local/optimize.hpp

    r3326 r3338  
    23152315                        // Operations with no arguments and no results
    23162316                        case EndOp:
    2317                         CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     2317                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    23182318                        rec->PutOp(op);
    23192319                        break;
  • branches/cache/cppad/local/player.hpp

    r3336 r3338  
    3636        size_t    num_var_rec_;
    3737
     38        /// Number of cache indices used in the recording
     39        size_t    num_cache_rec_;
     40
    3841        /// number of vecad load opeations in the reconding
    3942        size_t    num_load_op_rec_;
     
    4144        /// Number of VecAD vectors in the recording
    4245        size_t    num_vecad_vec_rec_;
    43 
    44         /// Number of cache indices used in the recording
    45         size_t    num_cache_rec_;
    4646
    4747        /// The operators in the recording.
     
    7070        player(void) :
    7171        num_var_rec_(0)                                      ,
    72         num_load_op_rec_(0)                                      ,
     72        num_cache_rec_(0)                                    ,
     73        num_load_op_rec_(0)                                  ,
    7374        op_rec_( std::numeric_limits<addr_t>::max() )        ,
    7475        vecad_ind_rec_( std::numeric_limits<addr_t>::max() ) ,
     
    108109                // just set size_t values
    109110                num_var_rec_        = rec.num_var_rec_;
     111                num_cache_rec_      = num_cache;
    110112                num_load_op_rec_    = rec.num_load_op_rec_;
    111                 num_cache_rec_      = num_cache;
    112113
    113114                // op_rec_
     
    172173        {       
    173174                num_var_rec_        = play.num_var_rec_;
     175                num_cache_rec_      = play.num_var_rec_;
    174176                num_load_op_rec_    = play.num_load_op_rec_;
    175177                op_rec_             = play.op_rec_;
     
    186188        {       
    187189                num_var_rec_       = 0;
     190                num_cache_rec_     = 0;
    188191                num_load_op_rec_   = 0;
    189192                num_vecad_vec_rec_ = 0;
     
    279282        {       return num_var_rec_; }
    280283
     284        /// Fetch number of cache values
     285        size_t num_cache_rec(void) const
     286        {       return num_cache_rec_; }
     287
    281288        /// Fetch number of vecad load operations
    282289        size_t num_load_op_rec(void) const
     
    306313        size_t num_text_rec(void) const
    307314        {       return text_rec_.size(); }
    308 
    309         /// Fetch number of cache values
    310         size_t num_cache_rec(void) const
    311         {       return num_cache_rec_; }
    312315
    313316        /// Fetch a rough measure of amount of memory used to store recording
     
    571574                op          = op_         = OpCode( op_rec_[ op_index_ ] );
    572575                CPPAD_ASSERT_UNKNOWN( op_ == EndOp );
    573                 CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     576                CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    574577                return;
    575578        }
  • branches/cache/makefile.am

    r3301 r3338  
    150150        cppad/local/bool_fun.hpp \
    151151        cppad/local/bool_valued.hpp \
     152        cppad/local/cache.hpp \
    152153        cppad/local/capacity_order.hpp \
    153154        cppad/local/checkpoint.hpp \
  • branches/cache/plan.txt

    r3330 r3338  
     1/* $Id$ */
     2/* --------------------------------------------------------------------------
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4
     5CppAD is distributed under multiple licenses. This distribution is under
     6the terms of the
     7                    Eclipse Public License Version 1.0.
     8
     9A copy of this license is included in the COPYING file of this distribution.
     10Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
     11-------------------------------------------------------------------------- */
     12
    113Plan for implementing caching
    214
Note: See TracChangeset for help on using the changeset viewer.