Changeset 3341


Ignore:
Timestamp:
Sep 19, 2014 7:47:30 AM (6 years ago)
Author:
bradbell
Message:
  1. Add num_var and cache2var to cppad_assert_arg_before_result.
  2. In sweeps, change numvar to num_var.

forward2sweep.hpp: remove extra asserts (arg_before_result cases).

Location:
branches/cache/cppad/local
Files:
7 edited

Legend:

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

    r3338 r3341  
    5252        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    5353
     54# ifndef NDEBUG
     55        CPPAD_ASSERT_UNKNOWN( play.num_cache_rec() == 0 );
     56        CppAD::vector<addr_t> cache2var;
     57# endif
     58
    5459        while( op != EndOp )
    5560        {       // next op
    5661                play.forward_next(op, arg, i_op, i_var);
    57                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     62                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
    5863
    5964                if( op == UserOp )
     
    144149        {       // next op
    145150                play.forward_next(op, arg, i_op, i_var);
    146                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     151                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
    147152
    148153                rec.PutOp(op);
  • branches/cache/cppad/local/cppad_assert.hpp

    r3324 r3341  
    204204If \c NDEBUG is defined, this macro has no effect,
    205205otherwise it calls the function assert_arg_before_result.
    206 */
    207 # ifdef NDEBUG
    208 # define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, result)
    209 # else
    210 # define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, result) \
    211         assert_arg_before_result(op, arg, result)
     206
     207\param op
     208is the operator we are checking.
     209
     210\param arg
     211is all of the arguemnt values for this operator.
     212
     213\param num_var
     214is the number of variables in the tape.
     215
     216\param cache2var
     217If this has size zero, there is no cache.
     218Otherwise it maps the zero orgin cache index to the corresponding
     219variable index. To be specific, if arg[i] corresponds to a variable,
     220then arg[i] - num_var is the corresponding zero orgin cache index.
     221
     222\param result
     223is the result variable index for this operator.
     224*/
     225# ifdef NDEBUG
     226# define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, result)
     227# else
     228# define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, result) \
     229        assert_arg_before_result(op, arg, num_var, cache2var, result)
    212230       
    213231# endif
  • branches/cache/cppad/local/for_jac_sweep.hpp

    r3338 r3341  
    6666is the number of independent variables on the tape.
    6767
    68 \param numvar
     68\param num_var
    6969is the total number of variables on the tape; i.e.,
    7070\a play->num_var_rec().
     
    8989\n
    9090\n
    91 \b Output: For i = \a n + 1 , ... , \a numvar - 1,
     91\b Output: For i = \a n + 1 , ... , \a num_var - 1,
    9292the sparsity pattern for the variable with index i on the tape
    9393corresponds to the set with index i in \a var_sparsity.
    9494
    9595\par Checked Assertions:
    96 \li numvar == var_sparsity.n_set()
    97 \li numvar == play->num_var_rec()
     96\li num_var == var_sparsity.n_set()
     97\li num_var == play->num_var_rec()
    9898*/
    9999
     
    101101void ForJacSweep(
    102102        size_t                n            ,
    103         size_t                numvar       ,
     103        size_t                num_var      ,
    104104        player<Base>*         play         ,
    105105        Vector_set&           var_sparsity )
     
    113113        size_t            i, j, k;
    114114
    115         // check numvar argument
    116         CPPAD_ASSERT_UNKNOWN( play->num_var_rec()  == numvar );
    117         CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == numvar );
     115        // check num_var argument
     116        CPPAD_ASSERT_UNKNOWN( play->num_var_rec()  == num_var );
     117        CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == num_var );
    118118
    119119        // length of the parameter vector (used by CppAD assert macros)
     
    182182        std::cout << std::endl;
    183183        CppAD::vectorBool z_value(limit);
    184 
     184# endif
     185# ifndef NDEBUG
    185186        // 2DO: implement tracing cache
    186187        CppAD::vector<addr_t> cache2var;
     
    197198                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    198199                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    199                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     200                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
    200201
    201202                // rest of information depends on the case
  • branches/cache/cppad/local/forward0sweep.hpp

    r3338 r3341  
    6868is the number of independent variables on the tape.
    6969
    70 \param numvar
     70\param num_var
    7171is the total number of variables on the tape.
    7272This is also equal to the number of rows in the matrix taylor; i.e.,
     
    104104\n
    105105\b Output:
    106 For i = n + 1, ... , numvar - 1,
     106For i = n + 1, ... , num_var - 1,
    107107<code>taylor [i * J + 0]</code>
    108108is the zero order Taylor coefficient for the variable with
     
    138138        bool                  print,
    139139        size_t                n,
    140         size_t                numvar,
     140        size_t                num_var,
    141141        player<Base>*         play,
    142142        size_t                J,
     
    146146)
    147147{       CPPAD_ASSERT_UNKNOWN( J >= 1 );
    148         CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
     148        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
    149149
    150150        // use p, q, r so other forward sweeps can use code defined here
     
    236236        // (done differently for order zero).
    237237        vector<size_t> user_iy;     
    238 
     238# endif
     239# ifndef NDEBUG
    239240        // 2DO: implement tracing cache
    240241        CppAD::vector<addr_t> cache2var;
     
    262263                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    263264                }
    264                 CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     265                CPPAD_ASSERT_UNKNOWN( i_var < num_var  );
    265266                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    266267                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    267268                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    268                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     269                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
    269270
    270271                // action to take depends on the case
  • branches/cache/cppad/local/forward1sweep.hpp

    r3338 r3341  
    6767is the number of independent variables on the tape.
    6868
    69 \param numvar
     69\param num_var
    7070is the total number of variables on the tape.
    7171This is also equal to the number of rows in the matrix taylor; i.e.,
     
    142142\n
    143143\b Input:
    144 For <code>i = 1 , ... , numvar-1</code>,
     144For <code>i = 1 , ... , num_var-1</code>,
    145145<code>k = 0 , ... , p-1</code>,
    146146<code>taylor[ J*i + k]</code>
     
    159159\n
    160160\b Output:
    161 For <code>i = n+1 , ... , numvar-1</code>, and
     161For <code>i = n+1 , ... , num_var-1</code>, and
    162162<code>k = 0 , ... , p-1</code>,
    163163<code>taylor[ J*i + k]</code>
     
    182182        const size_t          q,
    183183        const size_t          n,
    184         const size_t          numvar,
     184        const size_t          num_var,
    185185        player<Base>*         play,
    186186        const size_t          J,
     
    195195        CPPAD_ASSERT_UNKNOWN( p <= q );
    196196        CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
    197         CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
     197        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
    198198
    199199        /*
     
    292292# if CPPAD_FORWARD1SWEEP_TRACE
    293293        std::cout << std::endl;
    294 
     294# endif
     295# ifndef NDEBUG
    295296        // 2DO: implement tracing cache
    296297        CppAD::vector<addr_t> cache2var;
     
    311312                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    312313                }
    313                 CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     314                CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    314315                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    315316                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    316317                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    317                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     318                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
    318319
    319320                // action depends on the operator
  • branches/cache/cppad/local/forward2sweep.hpp

    r3338 r3341  
    6767is the number of independent variables on the tape.
    6868
    69 \param numvar
     69\param num_var
    7070is the total number of variables on the tape.
    7171This is also equal to the number of rows in the matrix taylor; i.e.,
     
    9494\n
    9595\b Input:
    96 For <code>i = 1 , ... , numvar-1</code>,
     96For <code>i = 1 , ... , num_var-1</code>,
    9797<code>taylor[ (J-1)*r*i + i + 0 ]</code>
    9898is the zero order Taylor coefficient corresponding to
    9999the i-th variable and all directions.
    100 For <code>i = 1 , ... , numvar-1</code>,
     100For <code>i = 1 , ... , num_var-1</code>,
    101101For <code>k = 1 , ... , q-1</code>,
    102102<code>ell = 0 , ... , r-1</code>,
     
    116116\n
    117117\b Output:
    118 For <code>i = n+1 , ... , numvar-1</code>,
     118For <code>i = n+1 , ... , num_var-1</code>,
    119119<code>ell = 0 , ... , r-1</code>,
    120120<code>taylor[ (J-1)*r*i + i + (q-1)*r + ell + 1 ]</code>
     
    144144        const size_t                r,
    145145        const size_t                n,
    146         const size_t                numvar,
     146        const size_t                num_var,
    147147              player<Base>*         play,
    148148        const size_t                J,
     
    154154        CPPAD_ASSERT_UNKNOWN( q > 0 );
    155155        CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
    156         CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
     156        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
    157157
    158158        // used to avoid compiler errors until all operators are implemented
     
    222222        std::cout << std::endl;
    223223        CppAD::vector<Base> Z_vec(q+1);
    224 
     224# endif
     225# ifndef NDEBUG
    225226        // 2DO: implement tracing cache
    226227        CppAD::vector<addr_t> cache2var;
     
    234235                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    235236                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    236                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     237                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
    237238
    238239                // check if we are skipping this operation
     
    267268                        case AcosOp:
    268269                        // sqrt(1 - x * x), acos(x)
    269                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    270270                        forward_acos_op_dir(q, r, i_var, arg[0], J, taylor);
    271271                        break;
     
    274274                        case AsinOp:
    275275                        // sqrt(1 - x * x), asin(x)
    276                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    277276                        forward_asin_op_dir(q, r, i_var, arg[0], J, taylor);
    278277                        break;
     
    281280                        case AtanOp:
    282281                        // 1 + x * x, atan(x)
    283                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    284282                        forward_atan_op_dir(q, r, i_var, arg[0], J, taylor);
    285283                        break;
     
    300298                        case CosOp:
    301299                        // sin(x), cos(x)
    302                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    303300                        forward_cos_op_dir(q, r, i_var, arg[0], J, taylor);
    304301                        break;
     
    307304                        case CoshOp:
    308305                        // sinh(x), cosh(x)
    309                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    310306                        forward_cosh_op_dir(q, r, i_var, arg[0], J, taylor);
    311307                        break;
     
    434430                        case SignOp:
    435431                        // sign(x)
    436                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    437432                        forward_sign_op_dir(q, r, i_var, arg[0], J, taylor);
    438433                        break;
     
    441436                        case SinOp:
    442437                        // cos(x), sin(x)
    443                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    444438                        forward_sin_op_dir(q, r, i_var, arg[0], J, taylor);
    445439                        break;
     
    448442                        case SinhOp:
    449443                        // cosh(x), sinh(x)
    450                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    451444                        forward_sinh_op_dir(q, r, i_var, arg[0], J, taylor);
    452445                        break;
     
    485478                        case TanOp:
    486479                        // tan(x)^2, tan(x)
    487                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    488480                        forward_tan_op_dir(q, r, i_var, arg[0], J, taylor);
    489481                        break;
     
    492484                        case TanhOp:
    493485                        // tanh(x)^2, tanh(x)
    494                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    495486                        forward_tanh_op_dir(q, r, i_var, arg[0], J, taylor);
    496487                        break;
  • branches/cache/cppad/local/op_code.hpp

    r3340 r3341  
    625625        //
    626626        size_t n_arg = NumArg(op);
    627         CppAD::vector<addr_t> ind(n_arg);
     627        CppAD::vector<size_t> ind(n_arg);
    628628        for(i = 0; i < n_arg; i++)
    629629                ind[i] = arg[i];
     
    937937All the operators are checked except for those of the form UserOp or Usr..Op.
    938938
    939 \param result
    940 is the variable index for the result.
    941 
    942939\param arg
    943940is a vector of lenght NumArg(op) pointing to the arguments
    944941for this operation.
     942
     943\param result
     944is the variable index for the result.
     945
     946\param num_var
     947is the number of varialbes on the tape.
     948
     949\param cache2var
     950If this has size zero, there is no cache.
     951Otherwise it maps the zero orgin cache index to the corresponding
     952variable index. To be specific, if arg[i] corresponds to a variable,
     953then arg[i] - num_var is the corresponding zero orgin cache index.
    945954*/
    946955inline void assert_arg_before_result(
    947         OpCode op, const addr_t* arg, size_t result
    948 )
     956        OpCode                       op        ,
     957        const addr_t*                arg       ,
     958        size_t                       num_var   ,
     959        const CppAD::vector<addr_t>& cache2var ,
     960        size_t                       result    )
    949961{       size_t n_result = 0;
    950962        CppAD::vector<size_t> var;
     
    11221134
    11231135        }
    1124         for(size_t i = 0; i < var.size(); i++)
    1125         {       CPPAD_ASSERT_UNKNOWN( var[i] + n_result <= result );
     1136        if( cache2var.size() == 0 )
     1137        {       for(size_t i = 0; i < var.size(); i++)
     1138                {       CPPAD_ASSERT_UNKNOWN( var[i] + n_result <= result );
     1139                }
     1140        }
     1141        else
     1142        {       for(size_t i = 0; i < var.size(); i++)
     1143                {       CPPAD_ASSERT_UNKNOWN( var[i] >= num_var );
     1144                        size_t i_var = cache2var[ var[i] - num_var ];
     1145                        CPPAD_ASSERT_UNKNOWN( i_var + n_result <= result );
     1146                }
    11261147        }
    11271148        return;
Note: See TracChangeset for help on using the changeset viewer.