Changeset 3342


Ignore:
Timestamp:
Sep 19, 2014 8:22:05 AM (6 years ago)
Author:
bradbell
Message:
  1. Zero order forward mode trace is correct, but results not getteing back

to function object; i.e. y and y_cache different.

  1. Change numvar to num_var in reverse mode sweep functions.
Location:
branches/cache
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/cache/bug/cache.sh

    r3340 r3342  
    6060
    6161        f.cache();
    62         /*
    6362        vector<double> y_cache(2);
    6463        y = f.Forward(0, x);
     
    6665        std::cout << "y       = " << y       << std::endl;
    6766        std::cout << "y_cache = " << y_cache << std::endl;
    68         */
    6967
    7068        return ok;
  • branches/cache/cppad/local/for_jac_sweep.hpp

    r3341 r3342  
    721721                        op,
    722722                        arg_tmp,
     723                        num_var,
    723724                        cache2var
    724725                );
  • branches/cache/cppad/local/forward0sweep.hpp

    r3341 r3342  
    108108is the zero order Taylor coefficient for the variable with
    109109index i on the tape.
     110\n
     111\n
     112\b Cache:
     113For i = num_var, ... , num_var + play->num_cache_rec() - 1,
     114<code>taylor [i * J + 0]</code>
     115is a temporary (used for cache storage).
    110116
    111117\param cskip_op
     
    147153{       CPPAD_ASSERT_UNKNOWN( J >= 1 );
    148154        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
     155        size_t num_cache = play->num_cache_rec();
     156
     157        // initialize cache indices with invalid variable value
     158        CppAD::vector<addr_t> cache2var( num_cache );
     159        for(size_t i = 0; i < num_cache; i++)
     160                cache2var[i] = addr_t(0);
    149161
    150162        // use p, q, r so other forward sweeps can use code defined here
     
    236248        // (done differently for order zero).
    237249        vector<size_t> user_iy;     
    238 # endif
    239 # ifndef NDEBUG
    240         // 2DO: implement tracing cache
    241         CppAD::vector<addr_t> cache2var;
    242250# endif
    243251
     
    686694                        CPPAD_ASSERT_UNKNOWN(false);
    687695                }
     696                if( num_cache != 0 )
     697                {       size_t i_cache = size_t( play->GetVar2Cache(i_var) );
     698                        CPPAD_ASSERT_UNKNOWN( i_cache >= num_var );
     699                        taylor[ i_cache * J + 0 ]      = taylor[ i_var * J + 0 ];
     700                        // use zero orgin cache indiex for cache2var vector
     701                        cache2var[ i_cache - num_var ] = i_var;
     702                }
    688703# if CPPAD_FORWARD0SWEEP_TRACE
    689704                size_t  d  = 0;
     
    702717                                        UsrrvOp,
    703718                                        CPPAD_NULL,
     719                                        num_var,
    704720                                        cache2var
    705721                                );
     
    730746                                op,
    731747                                arg_tmp,
     748                                num_var,
    732749                                cache2var
    733750                        );
  • branches/cache/cppad/local/forward1sweep.hpp

    r3341 r3342  
    822822                                        UsrrvOp,
    823823                                        CPPAD_NULL,
     824                                        num_var,
    824825                                        cache2var
    825826                                );
     
    850851                                op,
    851852                                arg_tmp,
     853                                num_var,
    852854                                cache2var
    853855                        );
  • branches/cache/cppad/local/forward2sweep.hpp

    r3341 r3342  
    662662                                        UsrrvOp,
    663663                                        CPPAD_NULL,
     664                                        num_var,
    664665                                        cache2var
    665666                                );
     
    695696                                op,
    696697                                arg_tmp,
     698                                num_var,
    697699                                cache2var
    698700                        );
  • branches/cache/cppad/local/op_code.hpp

    r3341 r3342  
    601601(must have NumArg(op) elements).
    602602
     603\param num_var
     604is the number of variables in the tape.
     605
    603606\param cache2var
    604607If this vector has size zero, there is no cache and the argument indices
    605608are the variable indices.
    606609Otherwise, there is a cache and if arg[i_arg] is a variable
    607         cache2var[ arg[i_arg] - play->num_var_rec() ]
     610        cache2var[ arg[i_arg] - num_var
    608611is the corresponding varialbe index. Note that this is a sort of kludge
    609 becasue the cache comes after the varialbes and uses the same taylor vector.
     612becasue the cache comes after the variables and uses the same taylor vector.
    610613*/
    611614template <class Base>
     
    617620        OpCode                       op        ,
    618621        const addr_t*                arg       ,
     622        size_t                       num_var   ,
    619623        const CppAD::vector<addr_t>& cache2var )
    620624{       size_t i;
     
    631635        {       for(i = 0; i < n_arg; i++)
    632636                        if( arg_is_variable(op, arg, i) )
    633                                 ind[i] = cache2var[ arg[i] ];
     637                        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) >= num_var );
     638                                ind[i] = cache2var[ size_t(arg[i]) - num_var ];
     639                        }
    634640        }
    635641        //
  • branches/cache/cppad/local/rev_hes_sweep.hpp

    r3334 r3342  
    4646is the number of independent variables on the tape.
    4747
    48 \param numvar
     48\param num_var
    4949is the total number of variables on the tape; i.e.,
    5050\a play->num_var_rec().
     
    6666
    6767\param for_jac_sparse
    68 For i = 0 , ... , \a numvar - 1,
     68For i = 0 , ... , \a num_var - 1,
    6969(for all the variables on the tape),
    7070the forward Jacobian sparsity pattern for the variable with index i
     
    7373\param RevJac
    7474\b Input:
    75 For i = 0, ... , \a numvar - 1
     75For i = 0, ... , \a num_var - 1
    7676the if the variable with index i on the tape is an dependent variable and
    7777included in the Hessian, \a RevJac[ i ] is equal to true,
     
    8787\n
    8888\n
    89 \b Input: For i = 0 , ... , \a numvar - 1 
     89\b Input: For i = 0 , ... , \a num_var - 1 
    9090the reverse Hessian sparsity pattern for the variable with index i is empty.
    9191\n
     
    102102void RevHesSweep(
    103103        size_t                n,
    104         size_t                numvar,
     104        size_t                num_var,
    105105        player<Base>         *play,
    106106        Vector_set&           for_jac_sparse, // should be const
     
    120120        size_t             i, j, k;
    121121
    122         // check numvar argument
    123         CPPAD_ASSERT_UNKNOWN( play->num_var_rec()     == numvar );
    124         CPPAD_ASSERT_UNKNOWN( for_jac_sparse.n_set() == numvar );
    125         CPPAD_ASSERT_UNKNOWN( rev_hes_sparse.n_set() == numvar );
    126         CPPAD_ASSERT_UNKNOWN( numvar > 0 );
     122        // check num_var argument
     123        CPPAD_ASSERT_UNKNOWN( play->num_var_rec()     == num_var );
     124        CPPAD_ASSERT_UNKNOWN( for_jac_sparse.n_set() == num_var );
     125        CPPAD_ASSERT_UNKNOWN( rev_hes_sparse.n_set() == num_var );
     126        CPPAD_ASSERT_UNKNOWN( num_var > 0 );
    127127
    128128        // upper limit exclusive for set elements
     
    796796                        op,
    797797                        arg,
     798                        num_var,
    798799                        cache2var
    799800                );
  • branches/cache/cppad/local/rev_jac_sweep.hpp

    r3334 r3342  
    7272is the number of independent variables on the tape.
    7373
    74 \param numvar
     74\param num_var
    7575is the total number of variables on the tape; i.e.,
    7676\a play->num_var_rec().
     
    9191
    9292\param var_sparsity
    93 For i = 0 , ... , \a numvar - 1,
     93For i = 0 , ... , \a num_var - 1,
    9494(all the variables on the tape)
    9595the forward Jacobian sparsity pattern for variable i
     
    9898\b
    9999\b Input:
    100 For i = 0 , ... , \a numvar - 1,
     100For i = 0 , ... , \a num_var - 1,
    101101the forward Jacobian sparsity pattern for variable i is an input
    102102if i corresponds to a dependent variable.
     
    113113        bool                  nz_compare,
    114114        size_t                n,
    115         size_t                numvar,
     115        size_t                num_var,
    116116        player<Base>         *play,
    117117        Vector_set&           var_sparsity
     
    129129        const size_t num_par = play->num_par_rec();
    130130
    131         // check numvar argument
    132         CPPAD_ASSERT_UNKNOWN( numvar > 0 );
    133         CPPAD_ASSERT_UNKNOWN( play->num_var_rec()   == numvar );
    134         CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == numvar );
     131        // check num_var argument
     132        CPPAD_ASSERT_UNKNOWN( num_var > 0 );
     133        CPPAD_ASSERT_UNKNOWN( play->num_var_rec()   == num_var );
     134        CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == num_var );
    135135
    136136        // upper limit (exclusive) for elements in the set
     
    722722                        op,
    723723                        arg,
     724                        num_var,
    724725                        cache2var
    725726                );
  • branches/cache/cppad/local/reverse_sweep.hpp

    r3335 r3342  
    6464is the number of independent variables on the tape.
    6565
    66 \param numvar
     66\param num_var
    6767is the total number of variables on the tape.
    6868This is also equal to the number of rows in the matrix \a Taylor; i.e.,
     
    107107
    108108\param Taylor
    109 For i = 1 , ... , \a numvar, and for k = 0 , ... , \a d,
     109For i = 1 , ... , \a num_var, and for k = 0 , ... , \a d,
    110110\a Taylor [ i * J + k ]
    111111is the k-th order Taylor coefficient corresponding to
     
    126126The vector \f$ v \f$, used to define \f$ G(u) \f$,
    127127is specified by these rows.
    128 For i = 0 , ... , m - 1, \a Partial [ ( \a numvar - m + i ) * K + d ] = v_i.
     128For i = 0 , ... , m - 1, \a Partial [ ( \a num_var - m + i ) * K + d ] = v_i.
    129129For i = 0 , ... , m - 1 and for k = 0 , ... , d - 1,
    130 \a Partial [ ( \a numvar - m + i ) * K + k ] = 0.
     130\a Partial [ ( \a num_var - m + i ) * K + k ] = 0.
    131131\n
    132132\n
    133133\b Temporary:
    134 For i = n+1 , ... , \a numvar - 1 and for k = 0 , ... , d,
     134For i = n+1 , ... , \a num_var - 1 and for k = 0 , ... , d,
    135135the value of \a Partial [ i * K + k ] is used for temporary work space
    136136and its output value is not defined.
     
    164164        size_t                      d,
    165165        size_t                      n,
    166         size_t                      numvar,
     166        size_t                      num_var,
    167167        player<Base>*               play,
    168168        size_t                      J,
     
    180180        const addr_t*   arg = CPPAD_NULL;
    181181
    182         // check numvar argument
    183         CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
    184         CPPAD_ASSERT_UNKNOWN( numvar > 0 );
     182        // check num_var argument
     183        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
     184        CPPAD_ASSERT_UNKNOWN( num_var > 0 );
    185185
    186186        // length of the parameter vector (used by CppAD assert macros)
     
    257257                        op,
    258258                        arg,
     259                        num_var,
    259260                        cache2var
    260261                );
     
    295296                        case AcosOp:
    296297                        // sqrt(1 - x * x), acos(x)
    297                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     298                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    298299                        reverse_acos_op(
    299300                                d, i_var, arg[0], J, Taylor, K, Partial
     
    304305                        case AsinOp:
    305306                        // sqrt(1 - x * x), asin(x)
    306                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     307                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    307308                        reverse_asin_op(
    308309                                d, i_var, arg[0], J, Taylor, K, Partial
     
    313314                        case AtanOp:
    314315                        // 1 + x * x, atan(x)
    315                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     316                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    316317                        reverse_atan_op(
    317318                                d, i_var, arg[0], J, Taylor, K, Partial
     
    366367
    367368                        case CosOp:
    368                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     369                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    369370                        reverse_cos_op(
    370371                                d, i_var, arg[0], J, Taylor, K, Partial
     
    374375
    375376                        case CoshOp:
    376                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     377                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    377378                        reverse_cosh_op(
    378379                                d, i_var, arg[0], J, Taylor, K, Partial
     
    489490
    490491                        case SignOp:
    491                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     492                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    492493                        reverse_sign_op(
    493494                                d, i_var, arg[0], J, Taylor, K, Partial
     
    497498
    498499                        case SinOp:
    499                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     500                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    500501                        reverse_sin_op(
    501502                                d, i_var, arg[0], J, Taylor, K, Partial
     
    505506
    506507                        case SinhOp:
    507                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     508                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    508509                        reverse_sinh_op(
    509510                                d, i_var, arg[0], J, Taylor, K, Partial
     
    559560
    560561                        case TanOp:
    561                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     562                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    562563                        reverse_tan_op(
    563564                                d, i_var, arg[0], J, Taylor, K, Partial
     
    567568
    568569                        case TanhOp:
    569                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     570                        CPPAD_ASSERT_UNKNOWN( i_var < num_var );
    570571                        reverse_tanh_op(
    571572                                d, i_var, arg[0], J, Taylor, K, Partial
Note: See TracChangeset for help on using the changeset viewer.