Changeset 1453


Ignore:
Timestamp:
Jul 6, 2009 12:57:14 PM (11 years ago)
Author:
bradbell
Message:

trunk: New interface to LdvOp? operation (and fix bug in reverse_sweep).

vec_ad.cpp: add new test that checks for bug.
whats_new_09.omh. User's view of the changes.
prototype_op.hpp. Combine documentation for zero order forward Ldp and Ldv.
load_op.hpp: new LdvOp? interface.
forward0sweep.hpp: use new Ldv interface.
forward_sweep.hpp: use new Ldv interface.
reverse_sweep.hpp: use new Ldv interface.

Location:
trunk
Files:
7 edited

Legend:

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

    r1451 r1453  
    159159        size_t         i_op;
    160160        size_t        i_var;
    161         size_t        i_arg;
    162161
    163162        size_t*         non_const_arg;
     
    166165        const Base       *P = 0;
    167166        const Base       *X = 0;
    168         const Base       *Y = 0;
    169167
    170168        Base             *Z = 0;
     
    346344
    347345                        case LdpOp:
     346                        CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
     347                        CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
    348348                        non_const_arg = Rec->forward_non_const_arg();
    349349                        forward_load_p_op_0(
     
    362362
    363363                        case LdvOp:
    364                         n_res = 1;
    365                         n_arg = 3;
    366                        
    367                         CPPAD_ASSERT_UNKNOWN( arg[0] > 0 );
    368                         CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_vecad_ind() );
    369364                        CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
    370365                        CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
    371 
    372                         // d == 0
    373                         {
    374                                 X   = Taylor + arg[1] * J;
    375                                 i   = Integer( X[0] );
    376                                 len = VectorInd[ arg[0] - 1 ];
    377                                 CPPAD_ASSERT_KNOWN(
    378                                         i < len,
    379                                         "VecAD index value >= vector length"
    380                                 );
    381                                 CPPAD_ASSERT_UNKNOWN(
    382                                         i + arg[0] < Rec->num_rec_vecad_ind()
    383                                 );
    384 
    385                                 if( VectorVar[ i + arg[0] ] )
    386                                 {       i     = VectorInd[ i + arg[0] ];
    387                                         i_arg = arg - arg_0;
    388                                         Rec->ReplaceInd(i_arg + 2, i);
    389                                         CPPAD_ASSERT_UNKNOWN(i > 0 );
    390                                         CPPAD_ASSERT_UNKNOWN( i < i_var );
    391                                         Y     = Taylor + i * J;
    392                                         Z[0]  = Y[0];
    393                                 }
    394                                 else
    395                                 {       i     = VectorInd[ i + arg[0] ];
    396                                         i_arg = arg - arg_0;
    397                                         Rec->ReplaceInd(i_arg + 2, 0);
    398                                         Z[0] = *(CPPAD_GET_PAR(i));
    399                                         i    = 0;
    400                                 }
    401                         }
     366                        non_const_arg = Rec->forward_non_const_arg();
     367                        forward_load_v_op_0(
     368                                i_var,
     369                                non_const_arg,
     370                                num_par,
     371                                parameter,
     372                                J,
     373                                Taylor,
     374                                Rec->num_rec_vecad_ind(),
     375                                VectorVar,
     376                                VectorInd
     377                        );
    402378                        break;
    403379                        // -------------------------------------------------
  • trunk/cppad/local/forward_sweep.hpp

    r1451 r1453  
    171171        size_t         i_op;
    172172        size_t        i_var;
    173         size_t        i_arg;
    174173
    175174# if ! CPPAD_USE_FORWARD0SWEEP
     
    180179        const Base       *P = 0;
    181180        const Base       *X = 0;
    182         const Base       *Y = 0;
    183181
    184182        Base             *Z = 0;
     
    364362# if ! CPPAD_USE_FORWARD0SWEEP
    365363                        if( d == 0 )
    366                         {
     364                        {       CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
     365                                CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
    367366                                non_const_arg = Rec->forward_non_const_arg();
    368367                                forward_load_p_op_0(
     
    380379                        else
    381380# endif
    382                         {       forward_load_p_op( d, i_var, arg, J, Taylor);
     381                        {       forward_load_op( d, i_var, arg, J, Taylor);
    383382                        }
    384383                        break;
     
    386385
    387386                        case LdvOp:
    388                         CPPAD_ASSERT_UNKNOWN( n_res == 1);
    389                         CPPAD_ASSERT_UNKNOWN( n_arg == 3 );
    390                        
    391                         CPPAD_ASSERT_UNKNOWN( arg[0] > 0 );
    392                         CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_vecad_ind() );
    393                         CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
    394                         CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
    395 
     387# if ! CPPAD_USE_FORWARD0SWEEP
    396388                        if( d == 0 )
    397                         {
    398                                 X   = Taylor + arg[1] * J;
    399                                 i   = Integer( X[0] );
    400                                 len = VectorInd[ arg[0] - 1 ];
    401                                 CPPAD_ASSERT_KNOWN(
    402                                         i < len,
    403                                         "VecAD index value >= vector length"
    404                                 );
    405                                 CPPAD_ASSERT_UNKNOWN(
    406                                         i + arg[0] < Rec->num_rec_vecad_ind()
    407                                 );
    408 
    409                                 if( VectorVar[ i + arg[0] ] )
    410                                 {       i     = VectorInd[ i + arg[0] ];
    411                                         i_arg = arg - arg_0;
    412                                         Rec->ReplaceInd(i_arg + 2, i);
    413                                         CPPAD_ASSERT_UNKNOWN(i > 0 );
    414                                         CPPAD_ASSERT_UNKNOWN( i < i_var );
    415                                         Y     = Taylor + i * J;
    416                                         Z[d]  = Y[d];
    417                                 }
    418                                 else
    419                                 {       i     = VectorInd[ i + arg[0] ];
    420                                         i_arg = arg - arg_0;
    421                                         Rec->ReplaceInd(i_arg + 2, 0);
    422                                         Z[d] = *(Rec->GetPar(i));
    423                                         i    = 0;
    424                                 }
     389                        {       CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
     390                                CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
     391                                non_const_arg = Rec->forward_non_const_arg();
     392                                forward_load_v_op_0(
     393                                        i_var,
     394                                        non_const_arg,
     395                                        num_par,
     396                                        parameter,
     397                                        J,
     398                                        Taylor,
     399                                        Rec->num_rec_vecad_ind(),
     400                                        VectorVar,
     401                                        VectorInd
     402                                );
    425403                        }
    426404                        else
    427                         {       i = arg[2];
    428                                 if( i > 0 )
    429                                 {       CPPAD_ASSERT_UNKNOWN( i < i_var );
    430                                         Y     = Taylor + i * J;
    431                                         Z[d]  = Y[d];
    432                                 }
    433                                 else    Z[d]  = Base(0);
     405# endif
     406                        {       forward_load_op( d, i_var, arg, J, Taylor);
    434407                        }
    435408                        break;
  • trunk/cppad/local/load_op.hpp

    r1452 r1453  
    2020Setting a VecAD element so that it corresponds to an AD variable address.
    2121*/
    22 /*!
    23 Zero order forward mode implementation of op = LdpOp
    24 
    25 The C++ source code corresponding to this operation is
    26 \verbatim
    27         z = x[a]
    28 \endverbatim
    29 where v is a VecAD<Base> vector and x is an AD<Base> index.
    30 In the documentation below, we use the notation
    31 \verbatim
    32         i_x_a = combined[ arg[0] + arg[1] ]
    33 \endverbatim
    34 
    35 \tparam Base
    36 base type for the operator; i.e., this operation was recorded
    37 using AD< \a Base > and computations by this routine are done using type
    38 \a Base.
    39 
    40 \param i_z
    41 is the AD variable index corresponding to the variable z.
    42 
    43 \param arg
    44 \n
    45 \a arg[0]
    46 is the offset of this VecAD vector relative to the beginning
    47 of the \a combined VecAD array.
    48 \n
    49 \n
    50 \a arg[1]
    51 \n
    52 Is this index of this VecAD element with in this VecAD vector.
    53 \n
    54 \n
    55 \a arg[2]
    56 \b Input: The input value of \a arg[2] does not matter.
    57 \n
    58 \b Output:
    59 If x[a] is a parameter, \a arg[2] is set to zero
    60 (which is not a valid variable index).
    61 If x[a] is a variable,
    62 \a arg[2] is set to the variable index corresponding to x[a]; i.e.  i_x_a.
    63 
    64 \param num_par
    65 is the number of parameters in \a parameter.
    66 
    67 \param parameter
    68 \b Input: If x[a] is a parameter, \a parameter [ i_x_a ] is its value.
    69 
    70 \param nc_taylor
    71 number of columns in the matrix containing the Taylor coefficients.
    72 
    73 \param taylor
    74 \b Input: if x[a] is a variable, \a taylor[ i_x_a * nc_taylor + 0 ]
    75 is the zero order Taylor coefficient for x[a]
    76 \n
    77 \b Output: \a taylor[ i_z * nc_taylor + 0 ]
    78 is the zero order Taylor coefficient for the variable z.
    79 
    80 \param nc_combined
    81 is the total number of elements in the combined VecAD array.
    82 
    83 \param variable
    84 If \a variable [ \a arg[0] + \a arg[1] ] is true,
    85 x[a] is a variable.  Otherwise it is a parameter.
    86 
    87 \param combined
    88 \b Input: \a combined[ \a arg[0] - 1 ]
    89 is the number of elements in the VecAD vector containing this element.
    90 \n
    91 \b Input:
    92 if x[a] is a variable,
    93 \verbatim
    94         i_x_a = combined[ arg[0] + arg[1] ]
    95 \endverbatim
    96 is its index in the Taylor coefficient array \a taylor.
    97 Otherwise, i_x_a is its index in parameter array \a parameter.
    98 
    99 \par Checked Assertions where op is a binary operator:
    100 \li NumArg(LdpOp) == 3
    101 \li NumRes(LdpOp) == 1
    102 \li 0 <  \a \a arg[0]
    103 \li \a arg[0] + \a arg[1] < nc_combined
    104 \li \a arg[1] < combined[ \a arg[0] - 1 ]
    105 \li if x[a] is a parameter, i_x_a < num_par
    106 \li if x[a] is a variable, i_x_a < i_z
    107 */
    108 
     22
     23/*!
     24Zero order forward mode implementation of op = LdpOp.
     25
     26\copydetails forward_load_op_0
     27*/
    10928template <class Base>
    11029inline void forward_load_p_op_0(
     30        size_t         i_z         ,
     31        size_t*        arg         ,
     32        size_t         num_par     ,
     33        const Base*    parameter   ,
     34        size_t         nc_taylor   ,
     35        Base*          taylor      ,
     36        size_t         nc_combined ,
     37        const bool*    variable    ,
     38        const size_t*  combined    )
     39{       size_t i_vec = arg[1];
     40
     41        CPPAD_ASSERT_UNKNOWN( NumArg(LdpOp) == 3 );
     42        CPPAD_ASSERT_UNKNOWN( NumRes(LdpOp) == 1 );
     43        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
     44        CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
     45        CPPAD_ASSERT_UNKNOWN( i_vec < combined[ arg[0] - 1 ] );
     46
     47        size_t combined_index = arg[0] + i_vec;
     48        size_t i_y_x          = combined[ combined_index ];     
     49        Base* z  = taylor + i_z * nc_taylor;
     50        if( variable[ combined_index ] )
     51        {       CPPAD_ASSERT_UNKNOWN( i_y_x < i_z );
     52                Base* y_x = taylor + i_y_x * nc_taylor;
     53                arg[2]    = i_y_x;
     54                z[0]      = y_x[0];
     55        }
     56        else
     57        {       CPPAD_ASSERT_UNKNOWN( i_y_x < num_par );
     58                Base y_x  = parameter[i_y_x];
     59                arg[2]    = 0;
     60                z[0]      = y_x;
     61        }
     62}
     63
     64/*!
     65Zero order forward mode implementation of op = LdvOp.
     66
     67\copydetails forward_load_op_0
     68*/
     69template <class Base>
     70inline void forward_load_v_op_0(
    11171        size_t         i_z         ,
    11272        size_t*        arg         ,
     
    11979        const size_t*  combined    )
    12080{
    121 
    122         size_t combined_index = arg[0] + arg[1];
    123         size_t i_x_a          = combined[ combined_index ];     
    12481        CPPAD_ASSERT_UNKNOWN( NumArg(LdpOp) == 3 );
    12582        CPPAD_ASSERT_UNKNOWN( NumRes(LdpOp) == 1 );
    12683        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    127         CPPAD_ASSERT_UNKNOWN( arg[0] + arg[1] < nc_combined );
    128         CPPAD_ASSERT_UNKNOWN( arg[1] < combined[ arg[0] - 1 ] );
     84        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     85
     86        size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
     87        CPPAD_ASSERT_KNOWN(
     88                i_vec < combined[ arg[0] - 1 ] ,
     89                "VecAD: index during zero order forward sweep is out of range"
     90        );
     91        CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
     92
     93        size_t combined_index = arg[0] + i_vec;
     94        size_t i_y_x          = combined[ combined_index ];     
     95
    12996
    13097        Base* z  = taylor + i_z * nc_taylor;
    131 
    13298        if( variable[ combined_index ] )
    133         {       CPPAD_ASSERT_UNKNOWN( i_x_a < i_z );
    134                 Base* x_a = taylor + i_x_a * nc_taylor;
    135                 arg[2]    = i_x_a;
    136                 z[0]      = x_a[0];
     99        {       CPPAD_ASSERT_UNKNOWN( i_y_x < i_z );
     100                Base* y_x = taylor + i_y_x * nc_taylor;
     101                arg[2]    = i_y_x;
     102                z[0]      = y_x[0];
    137103        }
    138104        else
    139         {       CPPAD_ASSERT_UNKNOWN( i_x_a < num_par );
    140                 Base x_a  = parameter[i_x_a];
     105        {       CPPAD_ASSERT_UNKNOWN( i_y_x < num_par );
     106                Base y_x  = parameter[i_y_x];
    141107                arg[2]    = 0;
    142                 z[0]      = x_a;
    143         }
    144 }
    145 
    146 /*!
    147 Forward mode, except for zero order, for op = LdpOp
     108                z[0]      = y_x;
     109        }
     110}
     111
     112/*!
     113Forward mode, except for zero order, for op = LdpOp or op = LdvOp
    148114
    149115The C++ source code corresponding to this operation is
    150116\verbatim
    151         z = x[a]
     117        z = y[x]
    152118\endverbatim
    153119where v is a VecAD<Base> vector and x is an AD<Base> index.
     
    166132\param arg
    167133\a arg[2]
    168 If x[a] is a parameter, \a arg[2] is zero
     134If y[x] is a parameter, \a arg[2] is zero
    169135(which is not a valid variable index).
    170 If x[a] is a variable,
    171 \a arg[2] is the variable index corresponding to x[a].
     136If y[x] is a variable,
     137\a arg[2] is the variable index corresponding to y[x].
    172138
    173139\param nc_taylor
     
    175141
    176142\param taylor
    177 \b Input: if x[a] is a variable, \a taylor[ \a arg[2] * nc_taylor + d ]
    178 is the d-order Taylor coefficient corresponding to x[a].
     143\b Input: if y[x] is a variable, \a taylor[ \a arg[2] * nc_taylor + d ]
     144is the d-order Taylor coefficient corresponding to y[x].
    179145\n
    180146\b Output: \a taylor[ i_z * nc_taylor + d ]
     
    188154*/
    189155template <class Base>
    190 inline void forward_load_p_op(
     156inline void forward_load_op(
    191157        size_t         d           ,
    192158        size_t         i_z         ,
     
    204170        Base* z      = taylor + i_z * nc_taylor;
    205171        if( arg[2] > 0 )
    206         {       Base* x_a = taylor + arg[2] * nc_taylor;
    207                 z[d]      = x_a[d];
     172        {       Base* y_x = taylor + arg[2] * nc_taylor;
     173                z[d]      = y_x[d];
    208174        }
    209175        else    z[d]      = Base(0);
     
    211177
    212178/*!
    213 Reverse mode, except for zero order, for op = LdpOp
     179Reverse mode for op = LdpOp or LdvOp.
    214180
    215181The C++ source code corresponding to this operation is
    216182\verbatim
    217         z = x[a]
     183        z = y[x]
    218184\endverbatim
    219185where v is a VecAD<Base> vector and x is an AD<Base> index.
    220186
    221187This routine is given the partial derivatives of a function
    222 G(z , x[a] , w , u ... )
     188G(z , y[x] , w , u ... )
    223189and it uses them to compute the partial derivatives of
    224190\verbatim
    225         H( x[a] , w , u , ... ) = G[ z( x[a] ) , x[a] , w , u , ... ]
     191        H( y[x] , w , u , ... ) = G[ z( y[x] ) , y[x] , w , u , ... ]
    226192\endverbatim
    227193
     
    240206\param arg
    241207\a arg[2]
    242 If x[a] is a parameter, \a arg[2] is zero
     208If y[x] is a parameter, \a arg[2] is zero
    243209(which is not a valid variable index).
    244 If x[a] is a variable,
    245 \a arg[2] is the variable index corresponding to x[a].
     210If y[x] is a variable,
     211\a arg[2] is the variable index corresponding to y[x].
    246212
    247213\param nc_taylor
     
    257223
    258224\param partial
    259 If \a arg[0] is zero, x[a] is a parameter
     225If \a arg[0] is zero, y[x] is a parameter
    260226and no values need to be modified; i.e., \a partial is not used.
    261 Otherwise, x[a] is a variable and:
     227Otherwise, y[x] is a variable and:
    262228\n
    263229\b Input: \a partial [ \a arg[2] * \a nc_partial + k ]
    264230for k = 0 , ... , \a d
    265 is the partial derivative of G( z( x[a] ) , x[a], w , u , ... )
    266 with respect to the k-th order Taylor coefficient for x[a].
     231is the partial derivative of G( z( y[x] ) , y[x], w , u , ... )
     232with respect to the k-th order Taylor coefficient for y[x].
    267233\n
    268234\b Input: \a partial [ \a i_z * \a nc_partial + k ]
    269235for k = 0 , ... , \a d
    270 is the partial derivative of G( z( x[a] ) , x[a] , w , u , ... )
     236is the partial derivative of G( z( y[x] ) , y[x] , w , u , ... )
    271237with respect to the k-th order Taylor coefficient for z.
    272238\n
    273239\b Output: \a partial [ \a arg[2] * \a nc_partial + k ]
    274240for k = 0 , ... , \a d
    275 is the partial derivative of H( x[a] , w , u , ... ) with respect to
     241is the partial derivative of H( y[x] , w , u , ... ) with respect to
    276242the k-th order Taylor coefficient for x.
    277243
     
    283249*/
    284250template <class Base>
    285 inline void reverse_load_p_op(
     251inline void reverse_load_op(
    286252        size_t         d           ,
    287253        size_t         i_z         ,
     
    302268        {
    303269                Base* pz   = partial + i_z    * nc_partial;
    304                 Base* px_a = partial + arg[2] * nc_partial;
     270                Base* py_x = partial + arg[2] * nc_partial;
    305271                size_t j = d + 1;
    306272                while(j--)
    307                         px_a[j]   += pz[j];
     273                        py_x[j]   += pz[j];
    308274        }
    309275}
  • trunk/cppad/local/prototype_op.hpp

    r1447 r1453  
    911911        CPPAD_ASSERT_UNKNOWN( false );
    912912}
     913// ====================  VecAD Operations     ==============================
     914/*!
     915Prototype for zero order forward mode implementation of op = LdpOp or LdvOp.
     916
     917The C++ source code corresponding to this operation is
     918\verbatim
     919        z = y[x]
     920\endverbatim
     921where v is a VecAD<Base> vector and x is an AD<Base> index.
     922We define the index corresponding to y[x] by
     923\verbatim
     924        i_y_x = combined[ arg[0] + i_vec ]
     925\endverbatim
     926where i_vec is defined under the heading \a arg[1] below:
     927
     928\tparam Base
     929base type for the operator; i.e., this operation was recorded
     930using AD< \a Base > and computations by this routine are done using type
     931\a Base.
     932
     933\param i_z
     934is the AD variable index corresponding to the variable z.
     935
     936\param arg
     937\n
     938\a arg[0]
     939is the offset of this VecAD vector relative to the beginning
     940of the \a combined VecAD array.
     941\n
     942\n
     943\a arg[1]
     944\n
     945If this is the LdpOp operation (load by parameter), i_vec is defined by
     946\verbatim
     947        i_vec = arg[1]
     948\endverbatim
     949If this is the LdvOp operation (load by variable),
     950the value i_vec is defined by
     951\verbatim
     952        i_vec = floor( taylor[ arg[1] * nc_taylor + 0 ] )
     953\endverbatim
     954where floor(c) is the greatest integer less that or equal c.
     955\n
     956\a arg[2]
     957\b Input: The input value of \a arg[2] does not matter.
     958\n
     959\b Output:
     960If y[x] is a parameter, \a arg[2] is set to zero
     961(which is not a valid variable index).
     962If y[x] is a variable,
     963\a arg[2] is set to the variable index corresponding to y[x]; i.e.  i_y_x.
     964
     965\param num_par
     966is the number of parameters in \a parameter.
     967
     968\param parameter
     969\b Input: If y[x] is a parameter, \a parameter [ i_y_x ] is its value.
     970
     971\param nc_taylor
     972number of columns in the matrix containing the Taylor coefficients.
     973
     974\param taylor
     975\b Input: in LdvOp case, \a taylor[ arg[1] * nc_taylor + 0 ]
     976is used to compute the index in the definition of i_vec above
     977\n
     978\b Input: if y[x] is a variable, \a taylor[ i_y_x * nc_taylor + 0 ]
     979is the zero order Taylor coefficient for y[x].
     980\n
     981\b Output: \a taylor[ i_z * nc_taylor + 0 ]
     982is the zero order Taylor coefficient for the variable z.
     983
     984\param nc_combined
     985is the total number of elements in the combined VecAD array.
     986
     987\param variable
     988If \a variable [ \a arg[0] + i_vec ] is true,
     989y[x] is a variable.  Otherwise it is a parameter.
     990
     991\param combined
     992\b Input: \a combined[ \a arg[0] - 1 ]
     993is the number of elements in the VecAD vector containing this element.
     994\n
     995\b Input: \a combined[ \a arg[0] + i_vec ]
     996if y[x] is a variable, i_y_x
     997is its index in the Taylor coefficient array \a taylor.
     998Otherwise, i_y_x is its index in parameter array \a parameter.
     999
     1000\par Check User Errors
     1001\li In the LdvOp case check that the index is with in range; i.e.
     1002i_vec < combined[ \a arg[0] - 1 ]
     1003
     1004\par Checked Assertions
     1005\li NumArg(LdpOp) == 3
     1006\li NumRes(LdpOp) == 1
     1007\li 0 <  \a arg[0]
     1008\li \a arg[0] + i_vec < nc_combined
     1009\li In the LdpOp case, i_vec < combined[ \a arg[0] - 1 ]
     1010\li if y[x] is a parameter, i_y_x < num_par
     1011\li if y[x] is a variable, i_y_x < i_z
     1012\li if x is a variable (LpvOp case), arg[1] < i_z
     1013*/
     1014template <class Base>
     1015inline void forward_load_op_0(
     1016        size_t         i_z         ,
     1017        size_t*        arg         ,
     1018        size_t         num_par     ,
     1019        const Base*    parameter   ,
     1020        size_t         nc_taylor   ,
     1021        Base*          taylor      ,
     1022        size_t         nc_combined ,
     1023        const bool*    variable    ,
     1024        const size_t*  combined    )
     1025{
     1026        // This routine is only for documentaiton, it should not be used
     1027        CPPAD_ASSERT_UNKNOWN( false );
     1028}
     1029
    9131030// ==================== Sparsity Calculations ==============================
    9141031/*!
  • trunk/cppad/local/reverse_sweep.hpp

    r1452 r1453  
    153153
    154154        Base            *pZ = 0;
    155         Base            *pY = 0;
    156155
    157156        // check numvar argument
     
    343342                        // --------------------------------------------------
    344343                        case LdpOp:
    345                         reverse_load_p_op(
     344                        reverse_load_op(
    346345                                d, i_var, arg, J, Taylor, K, Partial
    347346                        );
     
    350349
    351350                        case LdvOp:
    352                         CPPAD_ASSERT_UNKNOWN( n_res == 1);
    353                         CPPAD_ASSERT_UNKNOWN( n_arg == 3 );
    354                         CPPAD_ASSERT_UNKNOWN( arg[2] < i_var );
    355                         if( arg[2] > 0 )
    356                         {       pY     = Partial + arg[2] * K;
    357                                 pY[d] += pZ[d];
    358                         }
     351                        reverse_load_op(
     352                                d, i_var, arg, J, Taylor, K, Partial
     353                        );
    359354                        break;
    360355                        // -------------------------------------------------
  • trunk/omh/whats_new_09.omh

    r1452 r1453  
    5252$subhead 07-06$$
    5353Fixed a bug in second or higher order reverse mode calculations
    54 that included $cref/VecAD/$$.
     54that used $cref/VecAD/$$.
    5555This bug was demonstrated by the test case $code SecondOrderReverse$$
    5656in the file $code test_more/vec_ad.cpp$$.
     57$pre
     58
     59$$
     60Add developer documentation for tape evaluation of the
     61VecAD load operations
     62(a load operation accesses an element of the vector but
     63does not change it.)
     64
    5765
    5866$head 07-04$$
  • trunk/test_more/vec_ad.cpp

    r1452 r1453  
    188188        CppAD::Independent(X);
    189189
    190         size_t m = 1;
     190        size_t m = 2;
    191191        CPPAD_TEST_VECTOR< AD<double> > Y(m);
    192192
    193193        // The LdpOp instruction corresponds to operations with VecAD vectors.
    194         CppAD::VecAD<double> Z(1);
     194        CppAD::VecAD<double> Z(2);
    195195        AD<double> zero = 0;
    196196        Z[zero] = X[0] + 1;
     197
     198        // The LdvOp instruction corresponds to the index being a variable.
     199        AD<double> one = X[0] - 1; // one in a variable here
     200        Z[one]  = X[0] + 1.;
     201       
    197202
    198203        // Compute a function where the second order partial for y
     
    201206        // access to z is the parameter zero.
    202207        Y[0] = Z[zero] * Z[zero];
     208        Y[1] = Z[one]  * Z[one];
    203209
    204210        CppAD::ADFun<double> f(X, Y);
     
    210216        f.Forward(p, dx);
    211217
     218        // Test LdpOp
    212219        // second order reverse (test exp_if_true case)
    213220        CPPAD_TEST_VECTOR<double> w(m), dw(2 * n);
    214221        w[0] = 1.;
     222        w[1] = 0.;
    215223        p    = 2;
    216224        dw = f.Reverse(p, w);
     
    218226        // check first derivative in dw
    219227        double check = 2. * (Value( X[0] ) + 1.);
     228        ok &= NearEqual(dw[0], check, eps, eps);
     229
     230        // check second derivative in dw
     231        check = 2.;
     232        ok &= NearEqual(dw[1], check, eps, eps);
     233
     234        // Test LdvOp
     235        // second order reverse (test exp_if_true case)
     236        w[0] = 0.;
     237        w[1] = 1.;
     238        p    = 2;
     239        dw = f.Reverse(p, w);
     240
     241        // check first derivative in dw
     242        check = 2. * (Value( X[0] ) + 1.);
    220243        ok &= NearEqual(dw[0], check, eps, eps);
    221244
Note: See TracChangeset for help on using the changeset viewer.