Changeset 3708


Ignore:
Timestamp:
Aug 18, 2015 10:42:15 AM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: d15b95f6fc28aad327295d1206aa1a0619716931
end hash code: 85e7bf01a3307b219f6f37b3cdfbc8e18b0e3223

commit 85e7bf01a3307b219f6f37b3cdfbc8e18b0e3223
Author: Brad Bell <bradbell@…>
Date: Tue Aug 18 07:35:38 2015 -0700

cond_op.hpp: simplify and do complete set of asserts using loop.

commit 59c772b0af68e0e774504827e5d3dd78794a09ad
Author: Brad Bell <bradbell@…>
Date: Tue Aug 18 06:38:21 2015 -0700

Remove invisible white space.

commit 5cf55f486ff7d524e3b322cc558e9759f5f125c9
Author: Brad Bell <bradbell@…>
Date: Tue Aug 18 06:38:08 2015 -0700

Change nz_compare -> dependency (for dependency calculation).

commit 4eaf5d43f97ba457689dbb19d8188dafd63b3aec
Author: Brad Bell <bradbell@…>
Date: Mon Aug 17 14:29:02 2015 -0700

compile: change from link to a regular file.

commit 3923c32b8bc295d6c9c124210dc573d4777c0f75
Author: Brad Bell <bradbell@…>
Date: Mon Aug 17 13:06:31 2015 -0700

Remove invisible white space.

commit ffad20f56767d146b9f8ad7a043b152975a62376
Author: Brad Bell <bradbell@…>
Date: Mon Aug 17 13:06:19 2015 -0700

checkpoint.cpp: prepare for more tests.

commit cc906d981f0b0eb9bdcf3a99cb66d03e484cd1d6
Author: Brad Bell <bradbell@…>
Date: Mon Aug 17 13:01:59 2015 -0700

vector.hpp: fix local data was showdowing data() member function.

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/compile

    r3705 r3708  
    44scriptversion=2012-10-14.11; # UTC
    55
    6 # Copyright (C) 1999-2014 Free Software Foundation, Inc.
     6# Copyright (C) 1999-2013 Free Software Foundation, Inc.
    77# Written by Tom Tromey <tromey@cygnus.com>.
    88#
  • trunk/cppad/local/ad_fun.hpp

    r3667 r3708  
    176176                bool               set_type  ,
    177177                bool               transpose ,
    178                 bool               nz_compare,
     178                bool               dependency,
    179179                size_t             p         ,
    180180                const VectorSet&   s         ,
     
    187187                const std::set<size_t>&  set_type  ,
    188188                bool                     transpose ,
    189                 bool                     nz_compare,
     189                bool                     dependency,
    190190                size_t                   p         ,
    191191                const VectorSet&         s         ,
     
    315315        VectorSet RevSparseJac(
    316316                size_t q, const VectorSet &s, bool transpose = false,
    317                 bool nz_compare = false
     317                bool dependency = false
    318318        );
    319319        // reverse mode Hessian sparsity
  • trunk/cppad/local/checkpoint.hpp

    r3706 r3708  
    403403
    404404                // compute rt
    405                 // 2DO: remove need for nz_compare all the time. It is only really
     405                // 2DO: remove need for dependency all the time. It is only really
    406406                // necessary when optimizer calls this member function.
    407407                bool transpose = true;
    408                 bool nz_compare = true;
    409                 st = f_.RevSparseJac(q, rt, transpose, nz_compare);
     408                bool dependency = true;
     409                st = f_.RevSparseJac(q, rt, transpose, dependency);
    410410
    411411                return ok;
     
    425425                // compute rt
    426426                bool transpose  = true;
    427                 bool nz_compare = true;
    428                 // 2DO: remove need for nz_compare all the time. It is only really
     427                bool dependency = true;
     428                // 2DO: remove need for dependency all the time. It is only really
    429429                // necessary when optimizer calls this member function.
    430                 st = f_.RevSparseJac(q, rt, transpose, nz_compare);
     430                st = f_.RevSparseJac(q, rt, transpose, dependency);
    431431
    432432                return ok;
  • trunk/cppad/local/cond_op.hpp

    r3323 r3708  
    33# define CPPAD_COND_OP_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
    8 the terms of the 
     8the terms of the
    99                    Eclipse Public License Version 1.0.
    1010
     
    2727        z = CondExpRel(y_0, y_1, y_2, y_3)
    2828\endverbatim
    29 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     29where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    3030
    3131\tparam Base
    3232base type for the operator; i.e., this operation was recorded
    33 using AD< \a Base > and computations by this routine are done using type 
     33using AD< \a Base > and computations by this routine are done using type
    3434\a Base.
    3535
     
    4343\verbatim
    4444        enum CompareOp {
    45                 CompareLt, 
    46                 CompareLe, 
    47                 CompareEq, 
    48                 CompareGe, 
    49                 CompareGt, 
     45                CompareLt,
     46                CompareLe,
     47                CompareEq,
     48                CompareGe,
     49                CompareGt,
    5050                CompareNe
    5151        }
     
    100100inline void conditional_exp_op(
    101101        size_t         i_z         ,
    102         const addr_t*  arg         , 
     102        const addr_t*  arg         ,
    103103        size_t         num_par     ,
    104104        const Base*    parameter   ,
     
    116116        z = CondExpRel(y_0, y_1, y_2, y_3)
    117117\endverbatim
    118 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     118where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    119119
    120120\tparam Vector_set
     
    131131\verbatim
    132132        enum CompareOp {
    133                 CompareLt, 
    134                 CompareLe, 
    135                 CompareEq, 
    136                 CompareGe, 
    137                 CompareGt, 
     133                CompareLt,
     134                CompareLe,
     135                CompareEq,
     136                CompareGe,
     137                CompareGt,
    138138                CompareNe
    139139        }
     
    181181inline void sparse_conditional_exp_op(
    182182        size_t         i_z           ,
    183         const addr_t*  arg           , 
     183        const addr_t*  arg           ,
    184184        size_t         num_par       )
    185185{       // This routine is only for documentation, it should never be used
     
    195195        z = CondExpRel(y_0, y_1, y_2, y_3)
    196196\endverbatim
    197 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     197where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    198198
    199199\tparam Base
    200200base type for the operator; i.e., this operation was recorded
    201 using AD< \a Base > and computations by this routine are done using type 
     201using AD< \a Base > and computations by this routine are done using type
    202202\a Base.
    203203
     
    211211\verbatim
    212212        enum CompareOp {
    213                 CompareLt, 
    214                 CompareLe, 
    215                 CompareEq, 
    216                 CompareGe, 
    217                 CompareGt, 
     213                CompareLt,
     214                CompareLe,
     215                CompareEq,
     216                CompareGe,
     217                CompareGt,
    218218                CompareNe
    219219        }
     
    278278is the k-th order Taylor coefficient corresponding to y_j.
    279279\n
    280 \b Input: <code>taylor [ i_z * cap_order + k ]</code> 
     280\b Input: <code>taylor [ i_z * cap_order + k ]</code>
    281281for k = 0 , ... , p-1,
    282282is the k-th order Taylor coefficient corresponding to z.
    283283\n
    284284\b Output: <code>taylor [ i_z * cap_order + k ]</code>
    285 for k = p , ... , q, 
    286 is the k-th order Taylor coefficient corresponding to z. 
     285for k = p , ... , q,
     286is the k-th order Taylor coefficient corresponding to z.
    287287
    288288*/
     
    292292        size_t         q           ,
    293293        size_t         i_z         ,
    294         const addr_t*  arg         , 
     294        const addr_t*  arg         ,
    295295        size_t         num_par     ,
    296296        const Base*    parameter   ,
     
    378378        z = CondExpRel(y_0, y_1, y_2, y_3)
    379379\endverbatim
    380 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     380where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    381381
    382382\tparam Base
    383383base type for the operator; i.e., this operation was recorded
    384 using AD< \a Base > and computations by this routine are done using type 
     384using AD< \a Base > and computations by this routine are done using type
    385385\a Base.
    386386
     
    394394\verbatim
    395395        enum CompareOp {
    396                 CompareLt, 
    397                 CompareLe, 
    398                 CompareEq, 
    399                 CompareGe, 
    400                 CompareGt, 
     396                CompareLt,
     397                CompareLe,
     398                CompareEq,
     399                CompareGe,
     400                CompareGt,
    401401                CompareNe
    402402        }
     
    468468k-th order Taylor coefficient in the ell-th direction.
    469469\n
    470 \b Input: 
     470\b Input:
    471471For j = 0, 1, 2, 3, k = 1, ..., q-1,
    472 <code>taylor [ i_z * tpv + 0 ]</code> 
     472<code>taylor [ i_z * tpv + 0 ]</code>
    473473is the zero order Taylor coefficient corresponding to z and
    474474<code>taylor [ i_z * tpv + (k-1)*r+1+ell</code> is its
     
    477477\b Output: <code>taylor [ i_z * tpv + (q-1)*r+1+ell ]</code>
    478478is the q-th order Taylor coefficient corresponding to z
    479 in the ell-th direction. 
     479in the ell-th direction.
    480480*/
    481481template <class Base>
     
    484484        size_t         r           ,
    485485        size_t         i_z         ,
    486         const addr_t*  arg         , 
     486        const addr_t*  arg         ,
    487487        size_t         num_par     ,
    488488        const Base*    parameter   ,
     
    548548        z = CondExpRel(y_0, y_1, y_2, y_3)
    549549\endverbatim
    550 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     550where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    551551
    552552\tparam Base
    553553base type for the operator; i.e., this operation was recorded
    554 using AD< \a Base > and computations by this routine are done using type 
     554using AD< \a Base > and computations by this routine are done using type
    555555\a Base.
    556556
     
    564564\verbatim
    565565        enum CompareOp {
    566                 CompareLt, 
    567                 CompareLe, 
    568                 CompareEq, 
    569                 CompareGe, 
    570                 CompareGt, 
     566                CompareLt,
     567                CompareLe,
     568                CompareEq,
     569                CompareGe,
     570                CompareGt,
    571571                CompareNe
    572572        }
     
    625625is the zero order Taylor coefficient corresponding to y_j.
    626626\n
    627 \b Output: \a taylor [ \a i_z * \a cap_order + 0 ] 
    628 is the zero order Taylor coefficient corresponding to z. 
     627\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
     628is the zero order Taylor coefficient corresponding to z.
    629629*/
    630630template <class Base>
    631631inline void forward_cond_op_0(
    632632        size_t         i_z         ,
    633         const addr_t*  arg         , 
     633        const addr_t*  arg         ,
    634634        size_t         num_par     ,
    635635        const Base*    parameter   ,
     
    690690Compute reverse mode Taylor coefficients for op = CExpOp.
    691691
    692 This routine is given the partial derivatives of a function 
     692This routine is given the partial derivatives of a function
    693693G( z , y , x , w , ... )
    694 and it uses them to compute the partial derivatives of 
     694and it uses them to compute the partial derivatives of
    695695\verbatim
    696696        H( y , x , w , u , ... ) = G[ z(y) , y , x , w , u , ... ]
     
    703703        z = CondExpRel(y_0, y_1, y_2, y_3)
    704704\endverbatim
    705 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     705where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    706706
    707707\tparam Base
    708708base type for the operator; i.e., this operation was recorded
    709 using AD< \a Base > and computations by this routine are done using type 
     709using AD< \a Base > and computations by this routine are done using type
    710710\a Base.
    711711
     
    719719\verbatim
    720720        enum CompareOp {
    721                 CompareLt, 
    722                 CompareLe, 
    723                 CompareEq, 
    724                 CompareGe, 
    725                 CompareGt, 
     721                CompareLt,
     722                CompareLe,
     723                CompareEq,
     724                CompareGe,
     725                CompareGt,
    726726                CompareNe
    727727        }
     
    783783is the k-th order Taylor coefficient corresponding to y_j.
    784784\n
    785 \a taylor [ \a i_z * \a cap_order + k ] 
     785\a taylor [ \a i_z * \a cap_order + k ]
    786786for k = 0 , ... , \a d
    787787is the k-th order Taylor coefficient corresponding to z.
     
    798798with respect to the k-th order Taylor coefficient corresponding to y_j.
    799799\n
    800 \b Input: \a partial [ \a i_z * \a cap_order + k ] 
     800\b Input: \a partial [ \a i_z * \a cap_order + k ]
    801801for k = 0 , ... , \a d
    802802is the partial derivative of G( z , y , x , w , u , ... )
     
    815815        size_t         d           ,
    816816        size_t         i_z         ,
    817         const addr_t*  arg         , 
     817        const addr_t*  arg         ,
    818818        size_t         num_par     ,
    819819        const Base*    parameter   ,
     
    889889        z = CondExpRel(y_0, y_1, y_2, y_3)
    890890\endverbatim
    891 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     891where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    892892
    893893\tparam Vector_set
     
    904904\verbatim
    905905        enum CompareOp {
    906                 CompareLt, 
    907                 CompareLe, 
    908                 CompareEq, 
    909                 CompareGe, 
    910                 CompareGt, 
     906                CompareLt,
     907                CompareLe,
     908                CompareEq,
     909                CompareGe,
     910                CompareGt,
    911911                CompareNe
    912912        }
     
    964964depends on.
    965965\n
    966 \b Output: 
     966\b Output:
    967967The set with index T is
    968968the sparsity pattern corresponding to z.
    969969This identifies which of the independent variables the variable z
    970 depends on. 
     970depends on.
    971971*/
    972972template <class Vector_set>
    973973inline void forward_sparse_jacobian_cond_op(
    974974        size_t             i_z           ,
    975         const addr_t*      arg           , 
     975        const addr_t*      arg           ,
    976976        size_t             num_par       ,
    977977        Vector_set&        sparsity      )
     
    981981        CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
    982982        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    983 
    984983# ifndef NDEBUG
    985         if( arg[1] & 1 )
    986         {
    987         }
    988         else
    989         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
    990         }
    991         if( arg[1] & 2 )
    992         {
    993         }
    994         else
    995         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
     984        size_t k = 1;
     985        for( size_t j = 0; j < 4; j++)
     986        {       if( ! ( arg[1] & k ) )
     987                        CPPAD_ASSERT_UNKNOWN( size_t(arg[2+j]) < num_par );
     988                k *= 2;
    996989        }
    997990# endif
     
    1006999                        sparsity.assignment(i_z, arg[4], sparsity);
    10071000                }
    1008         }       
     1001        }
    10091002        else
    10101003        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
     
    10261019This routine is given the sparsity patterns
    10271020for a function G(z, y, x, ... )
    1028 and it uses them to compute the sparsity patterns for 
     1021and it uses them to compute the sparsity patterns for
    10291022\verbatim
    10301023        H( y, x, w , u , ... ) = G[ z(x,y) , y , x , w , u , ... ]
     
    10371030        z = CondExpRel(y_0, y_1, y_2, y_3)
    10381031\endverbatim
    1039 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     1032where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    10401033
    10411034\tparam Vector_set
     
    10521045\verbatim
    10531046        enum CompareOp {
    1054                 CompareLt, 
    1055                 CompareLe, 
    1056                 CompareEq, 
    1057                 CompareGe, 
    1058                 CompareGt, 
     1047                CompareLt,
     1048                CompareLe,
     1049                CompareEq,
     1050                CompareGe,
     1051                CompareGt,
    10591052                CompareNe
    10601053        }
     
    10991092<!-- end sparse_conditional_exp_op -->
    11001093
    1101 \param nz_compare
     1094\param dependency
    11021095Are the derivatives with respect to left and right of the expression below
    11031096considered to be non-zero:
     
    11221115On ouput, it corresponds to the function H.
    11231116\n
    1124 \b Output: 
     1117\b Output:
    11251118The set with index T is
    11261119the sparsity pattern corresponding to z.
     
    11301123template <class Vector_set>
    11311124inline void reverse_sparse_jacobian_cond_op(
    1132         bool                nz_compare    ,
     1125        bool                dependency    ,
    11331126        size_t              i_z           ,
    1134         const addr_t*       arg           , 
     1127        const addr_t*       arg           ,
    11351128        size_t              num_par       ,
    11361129        Vector_set&         sparsity      )
    1137 {       
     1130{
    11381131        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
    11391132        CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
    11401133        CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
    11411134        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    1142 
    11431135# ifndef NDEBUG
    1144         if( arg[1] & 1 )
    1145         {
    1146         }
    1147         else
    1148         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
    1149         }
    1150         if( arg[1] & 2 )
    1151         {
    1152         }
    1153         else
    1154         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
    1155         }
    1156         if( ! ( arg[1] & 4 ) )
    1157         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
    1158         }
    1159         if( ! ( arg[1] & 8 ) )
    1160         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
     1136        size_t k = 1;
     1137        for( size_t j = 0; j < 4; j++)
     1138        {       if( ! ( arg[1] & k ) )
     1139                        CPPAD_ASSERT_UNKNOWN( size_t(arg[2+j]) < num_par );
     1140                k *= 2;
    11611141        }
    11621142# endif
    1163         if( nz_compare )
     1143        if( dependency )
    11641144        {       if( arg[1] & 1 )
    11651145                {
     
    11881168This routine is given the sparsity patterns
    11891169for a function G(z, y, x, ... )
    1190 and it uses them to compute the sparsity patterns for 
     1170and it uses them to compute the sparsity patterns for
    11911171\verbatim
    11921172        H( y, x, w , u , ... ) = G[ z(x,y) , y , x , w , u , ... ]
     
    11991179        z = CondExpRel(y_0, y_1, y_2, y_3)
    12001180\endverbatim
    1201 where Rel is one of the following: Lt, Le, Eq, Ge, Gt. 
     1181where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    12021182
    12031183\tparam Vector_set
     
    12141194\verbatim
    12151195        enum CompareOp {
    1216                 CompareLt, 
    1217                 CompareLe, 
    1218                 CompareEq, 
    1219                 CompareGe, 
    1220                 CompareGt, 
     1196                CompareLt,
     1197                CompareLe,
     1198                CompareEq,
     1199                CompareGe,
     1200                CompareGt,
    12211201                CompareNe
    12221202        }
     
    12631243
    12641244\param jac_reverse
    1265 \a jac_reverse[i_z] 
    1266 is false (true) if the Jacobian of G with respect to z is always zero 
     1245\a jac_reverse[i_z]
     1246is false (true) if the Jacobian of G with respect to z is always zero
    12671247(may be non-zero).
    12681248\n
    12691249\n
    1270 \a jac_reverse[ arg[4] ] 
     1250\a jac_reverse[ arg[4] ]
    12711251If y_2 is a variable,
    1272 \a jac_reverse[ arg[4] ] 
    1273 is false (true) if the Jacobian with respect to y_2 is always zero 
     1252\a jac_reverse[ arg[4] ]
     1253is false (true) if the Jacobian with respect to y_2 is always zero
    12741254(may be non-zero).
    12751255On input, it corresponds to the function G,
     
    12771257\n
    12781258\n
    1279 \a jac_reverse[ arg[5] ] 
     1259\a jac_reverse[ arg[5] ]
    12801260If y_3 is a variable,
    1281 \a jac_reverse[ arg[5] ] 
    1282 is false (true) if the Jacobian with respect to y_3 is always zero 
     1261\a jac_reverse[ arg[5] ]
     1262is false (true) if the Jacobian with respect to y_3 is always zero
    12831263(may be non-zero).
    12841264On input, it corresponds to the function G,
     
    12861266
    12871267\param hes_sparsity
    1288 The set with index \a i_z in \a hes_sparsity 
     1268The set with index \a i_z in \a hes_sparsity
    12891269is the Hessian sparsity pattern for the function G
    12901270where one of the partials is with respect to z.
     
    12921272\n
    12931273If y_2 is a variable,
    1294 the set with index \a arg[4] in \a hes_sparsity 
    1295 is the Hessian sparsity pattern 
     1274the set with index \a arg[4] in \a hes_sparsity
     1275is the Hessian sparsity pattern
    12961276where one of the partials is with respect to y_2.
    12971277On input, this pattern corresponds to the function G.
     
    13001280\n
    13011281If y_3 is a variable,
    1302 the set with index \a arg[5] in \a hes_sparsity 
    1303 is the Hessian sparsity pattern 
     1282the set with index \a arg[5] in \a hes_sparsity
     1283is the Hessian sparsity pattern
    13041284where one of the partials is with respect to y_3.
    13051285On input, this pattern corresponds to the function G.
     
    13091289inline void reverse_sparse_hessian_cond_op(
    13101290        size_t               i_z           ,
    1311         const addr_t*        arg           , 
     1291        const addr_t*        arg           ,
    13121292        size_t               num_par       ,
    13131293        bool*                jac_reverse   ,
    13141294        Vector_set&          hes_sparsity  )
    1315 {       
     1295{
    13161296
    13171297        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
     
    13191299        CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
    13201300        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    1321 
    13221301# ifndef NDEBUG
    1323         if( arg[1] & 1 )
    1324         {
    1325         }
    1326         else
    1327         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
    1328         }
    1329         if( arg[1] & 2 )
    1330         {
    1331         }
    1332         else
    1333         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
    1334         }
    1335         if( ! ( arg[1] & 4 ) )
    1336         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
    1337         }
    1338         if( ! ( arg[1] & 8 ) )
    1339         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
     1302        size_t k = 1;
     1303        for( size_t j = 0; j < 4; j++)
     1304        {       if( ! ( arg[1] & k ) )
     1305                        CPPAD_ASSERT_UNKNOWN( size_t(arg[2+j]) < num_par );
     1306                k *= 2;
    13401307        }
    13411308# endif
    13421309        if( arg[1] & 4 )
    13431310        {
    1344 
    13451311                hes_sparsity.binary_union(arg[4], arg[4], i_z, hes_sparsity);
    13461312                jac_reverse[ arg[4] ] |= jac_reverse[i_z];
     
    13481314        if( arg[1] & 8 )
    13491315        {
    1350 
    13511316                hes_sparsity.binary_union(arg[5], arg[5], i_z, hes_sparsity);
    13521317                jac_reverse[ arg[5] ] |= jac_reverse[i_z];
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3685 r3708  
    6161\c sparse_pack, \c sparse_set, or \c sparse_list.
    6262
    63 \param nz_compare
     63\param dependency
    6464Are the derivatives with respect to left and right of the expression below
    6565considered to be non-zero:
     
    111111template <class Base, class Vector_set>
    112112void RevJacSweep(
    113         bool                  nz_compare,
     113        bool                  dependency,
    114114        size_t                n,
    115115        size_t                numvar,
     
    321321                        case CExpOp:
    322322                        reverse_sparse_jacobian_cond_op(
    323                                 nz_compare, i_var, arg, num_par, var_sparsity
     323                                dependency, i_var, arg, num_par, var_sparsity
    324324                        );
    325325                        break;
     
    511511
    512512                        case PriOp:
    513                         CPPAD_ASSERT_NARG_NRES(op, 5, 0);
     513                        CPPAD_ASSERT_NARG_NRES(op, 5, 0);
    514514                        break;
    515515                        // -------------------------------------------------
  • trunk/cppad/local/rev_sparse_jac.hpp

    r3232 r3708  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    3131$$
    3232
    33 $section Jacobian Sparsity Pattern: Reverse Mode$$ 
     33$section Jacobian Sparsity Pattern: Reverse Mode$$
    3434
    3535$index RevSparseJac$$
     
    5353\] $$
    5454Given a
    55 $cref/sparsity pattern/glossary/Sparsity Pattern/$$ 
     55$cref/sparsity pattern/glossary/Sparsity Pattern/$$
    5656for $latex R$$,
    5757$code RevSparseJac$$ returns a sparsity pattern for the $latex S(x)$$.
     
    6464
    6565$head x$$
    66 the sparsity pattern is valid for all values of the independent 
     66the sparsity pattern is valid for all values of the independent
    6767variables in $latex x \in B^n$$
    6868(even if it has $cref CondExp$$ or $cref VecAD$$ operations).
     
    7474%$$
    7575It specifies the number of rows in
    76 $latex R \in B^{q \times m}$$ and the 
    77 Jacobian $latex S(x) \in B^{q \times n}$$. 
     76$latex R \in B^{q \times m}$$ and the
     77Jacobian $latex S(x) \in B^{q \times n}$$.
    7878
    7979$head transpose$$
     
    8484The default value $code false$$ is used when $icode transpose$$ is not present.
    8585
    86 $head nz_compare$$
    87 The argument $icode nz_compare$$ has prototype
     86$head dependency$$
     87The argument $icode dependency$$ has prototype
    8888$codei%
    89         bool %nz_compare%
    90 %$$
    91 If $icode nz_compare$$ is true,
    92 the derivatives with respect to left and right of the 
     89        bool %dependency%
     90%$$
     91If $icode dependency$$ is true,
     92the derivatives with respect to left and right of the
    9393$cref CondExp$$ below are considered to be non-zero:
    9494$codei%
    9595        %CondExp%Rel%(%left%, %right%, %if_true%, %if_false%)
    9696%$$
    97 This is used by the 
     97This is used by the
    9898$cref/optimizer/optimize/$$ with $cref checkpoint$$ functions
    9999to obtain the correct dependency relations.
    100 The default value $icode%nz_compare% = false%$$ is used when
    101 $icode nz_compare$$ is not present.
     100The default value $icode%dependency% = false%$$ is used when
     101$icode dependency$$ is not present.
    102102
    103103$head r$$
     
    114114its size is $icode q$$ and all its set elements are between
    115115zero and $latex m - 1$$.
    116 It specifies a 
    117 $cref/sparsity pattern/glossary/Sparsity Pattern/$$ 
     116It specifies a
     117$cref/sparsity pattern/glossary/Sparsity Pattern/$$
    118118for the matrix $latex R \in B^{q \times m}$$.
    119119
     
    124124its size is $icode m$$ and all its set elements are between
    125125zero and $latex q - 1$$.
    126 It specifies a 
    127 $cref/sparsity pattern/glossary/Sparsity Pattern/$$ 
     126It specifies a
     127$cref/sparsity pattern/glossary/Sparsity Pattern/$$
    128128for the matrix $latex R^\R{T} \in B^{m \times q}$$.
    129129
     
    141141its size is $icode q$$ and all its set elements are between
    142142zero and $latex n - 1$$.
    143 It specifies a 
    144 $cref/sparsity pattern/glossary/Sparsity Pattern/$$ 
     143It specifies a
     144$cref/sparsity pattern/glossary/Sparsity Pattern/$$
    145145for the matrix $latex S(x) \in {q \times n}$$.
    146146
     
    151151its size is $icode n$$ and all its set elements are between
    152152zero and $latex q - 1$$.
    153 It specifies a 
    154 $cref/sparsity pattern/glossary/Sparsity Pattern/$$ 
     153It specifies a
     154$cref/sparsity pattern/glossary/Sparsity Pattern/$$
    155155for the matrix $latex S(x)^\R{T} \in {n \times q}$$.
    156156
     
    165165Suppose that $latex q = m$$ and
    166166$latex R$$ is the $latex m \times m$$ identity matrix.
    167 In this case, 
    168 the corresponding value for $icode s$$ is a 
     167In this case,
     168the corresponding value for $icode s$$ is a
    169169sparsity pattern for the Jacobian $latex S(x) = F^{(1)} ( x )$$.
    170170
     
    208208are the sparsity patterns transposed.
    209209
    210 \param nz_compare
     210\param dependency
    211211Are the derivatives with respect to left and right of the expression below
    212212considered to be non-zero:
     
    225225the input value of \a s must be a vector with size <tt>p*n</tt>
    226226where \c n is the number of independent variables
    227 corresponding to the operation sequence stored in \a play. 
     227corresponding to the operation sequence stored in \a play.
    228228The input value of the components of \c s does not matter.
    229229On output, \a s is the sparsity pattern for the matrix
     
    246246
    247247\param play
    248 is the recording that defines the function we are computing the sparsity 
     248is the recording that defines the function we are computing the sparsity
    249249pattern for.
    250250*/
    251251
    252 template <class Base, class VectorSet> 
     252template <class Base, class VectorSet>
    253253void RevSparseJacBool(
    254254        bool                   transpose        ,
    255         bool                   nz_compare       ,
    256         size_t                 q                , 
     255        bool                   dependency       ,
     256        size_t                 q                ,
    257257        const VectorSet&       r                ,
    258258        VectorSet&             s                ,
     
    301301        // evaluate the sparsity patterns
    302302        RevJacSweep(
    303                 nz_compare,
     303                dependency,
    304304                n,
    305305                total_num_var,
     
    322322                }
    323323                else
    324                 {       for(i = 0; i < q; i++) 
     324                {       for(i = 0; i < q; i++)
    325325                                s[ i * n + j ] = false;
    326326                }
     
    353353see \c RevSparseJacBool.
    354354
    355 \param nz_compare
     355\param dependency
    356356see \c RevSparseJacBool.
    357357
     
    377377see \c RevSparseJacBool.
    378378*/
    379 template <class Base, class VectorSet> 
     379template <class Base, class VectorSet>
    380380void RevSparseJacSet(
    381381        bool                   transpose        ,
    382         bool                   nz_compare       ,
    383         size_t                 q                , 
     382        bool                   dependency       ,
     383        size_t                 q                ,
    384384        const VectorSet&       r                ,
    385385        VectorSet&             s                ,
     
    424424                {       itr = r[i].begin();
    425425                        while(itr != r[i].end())
    426                         {       j = *itr++; 
     426                        {       j = *itr++;
    427427                                CPPAD_ASSERT_KNOWN(
    428428                                j < q,
     
    439439                {       itr = r[i].begin();
    440440                        while(itr != r[i].end())
    441                         {       j = *itr++; 
     441                        {       j = *itr++;
    442442                                CPPAD_ASSERT_KNOWN(
    443443                                j < m,
     
    452452        // evaluate the sparsity patterns
    453453        RevJacSweep(
    454                 nz_compare,
     454                dependency,
    455455                n,
    456456                total_num_var,
     
    484484Private helper function for \c RevSparseJac(q, r, transpose).
    485485
    486 All of the description in the public member function 
     486All of the description in the public member function
    487487\c RevSparseJac(q, r, transpose) apply.
    488488
     
    493493
    494494\param transpose
    495 See \c RevSparseJac(q, r, transpose, nz_compare)
    496 
    497 \param nz_compare
    498 See \c RevSparseJac(q, r, transpose, nz_compare)
     495See \c RevSparseJac(q, r, transpose, dependency)
     496
     497\param dependency
     498See \c RevSparseJac(q, r, transpose, dependency)
    499499
    500500\param q
    501 See \c RevSparseJac(q, r, transpose, nz_compare)
     501See \c RevSparseJac(q, r, transpose, dependency)
    502502
    503503\param r
    504 See \c RevSparseJac(q, r, transpose, nz_compare)
     504See \c RevSparseJac(q, r, transpose, dependency)
    505505
    506506\param s
    507 is the return value for the corresponding call to 
     507is the return value for the corresponding call to
    508508RevSparseJac(q, r, transpose).
    509509*/
     
    514514        bool                set_type          ,
    515515        bool                transpose         ,
    516         bool                nz_compare        ,
     516        bool                dependency        ,
    517517        size_t              q                 ,
    518518        const VectorSet&    r                 ,
     
    526526        RevSparseJacBool(
    527527                transpose      ,
    528                 nz_compare     ,
     528                dependency     ,
    529529                q              ,
    530530                r              ,
     
    540540Private helper function for \c RevSparseJac(q, r, transpose).
    541541
    542 All of the description in the public member function 
     542All of the description in the public member function
    543543\c RevSparseJac(q, r, transpose) apply.
    544544
     
    549549
    550550\param transpose
    551 See \c RevSparseJac(q, r, transpose, nz_compare)
    552 
    553 \param nz_compare
    554 See \c RevSparseJac(q, r, transpose, nz_compare)
     551See \c RevSparseJac(q, r, transpose, dependency)
     552
     553\param dependency
     554See \c RevSparseJac(q, r, transpose, dependency)
    555555
    556556\param q
    557 See \c RevSparseJac(q, r, transpose, nz_compare)
     557See \c RevSparseJac(q, r, transpose, dependency)
    558558
    559559\param r
    560 See \c RevSparseJac(q, r, transpose, nz_compare)
     560See \c RevSparseJac(q, r, transpose, dependency)
    561561
    562562\param s
     
    569569        const std::set<size_t>&      set_type          ,
    570570        bool                         transpose         ,
    571         bool                         nz_compare        ,
     571        bool                         dependency        ,
    572572        size_t                       q                 ,
    573573        const VectorSet&             r                 ,
     
    581581        RevSparseJacSet(
    582582                transpose      ,
    583                 nz_compare     ,
     583                dependency     ,
    584584                q              ,
    585585                r              ,
     
    597597The C++ source code corresponding to this operation is
    598598\verbatim
    599         s = f.RevSparseJac(q, r, transpose, nz_compare)
     599        s = f.RevSparseJac(q, r, transpose, dependency)
    600600\endverbatim
    601601
     
    616616are the sparsity patterns for \f$ R \f$ and \f$ S(x) \f$ transposed.
    617617
    618 \param nz_compare
     618\param dependency
    619619Are the derivatives with respect to left and right of the expression below
    620620considered to be non-zero:
     
    642642template <class VectorSet>
    643643VectorSet ADFun<Base>::RevSparseJac(
    644         size_t              q          , 
     644        size_t              q          ,
    645645        const VectorSet&    r          ,
    646646        bool                transpose  ,
    647         bool                nz_compare )
     647        bool                dependency )
    648648{
    649649        VectorSet s;
     
    653653                Set_type()    ,
    654654                transpose     ,
    655                 nz_compare    ,
     655                dependency    ,
    656656                q             ,
    657657                r             ,
  • trunk/cppad/vector.hpp

    r3706 r3708  
    351351        Type*  data_;
    352352        /// delete data pointer
    353         void delete_data(Type* data)
    354         {       thread_alloc::delete_array(data); }
     353        void delete_data(Type* data_ptr)
     354        {       thread_alloc::delete_array(data_ptr); }
    355355public:
    356356        /// type of the elements in the vector
  • trunk/omh/whats_new/whats_new_13.omh

    r3706 r3708  
    164164This bug existed before recent change to optimizing conditional expressions.
    165165This required adding the
    166 $cref/nz_compare/RevSparseJac/nz_compare/$$ argument to the
     166$cref/dependency/RevSparseJac/dependency/$$ argument to the
    167167reverse Jacobian sparsity pattern calculation.
    168168For further details; see sparsity heading under conditional expressions in the
  • trunk/omh/whats_new/whats_new_15.omh

    r3706 r3708  
    6161assist you in learning about changes between various versions of CppAD.
    6262
     63$head 08-17$$
     64$list number$$
     65Fix a warning (introduced on 08-11) where the $code CppAD::vector$$
     66$cref/data/CppAD_vector/data/$$ function was being shadowed by
     67a local variable.
     68$lnext
     69The source code control for CppAD has a link to $code compile$$,
     70instead of real file.
     71This sometimes caused problems with the
     72deprecated $cref auto_tools$$ install procedure and has been fixed.
     73$lend
     74
    6375$head 08-16$$
    6476$list number$$
  • trunk/omh/wish_list.omh

    r3707 r3708  
    148148$icode right$$.
    149149The $cref checkpoint$$ functions use the value true for
    150 $cref/nz_compare/RevSparseJac/nz_compare/$$ when computing
     150$cref/dependency/RevSparseJac/dependency/$$ when computing
    151151reverse jacobian sparsity patterns.
    152152This enables the optimizer to properly track the dependencies.
  • trunk/test_more/checkpoint.cpp

    r2859 r3708  
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    3636                return true;
    3737        }
     38
     39        bool test_one(void)
     40        {       bool ok = true;
     41                using CppAD::checkpoint;
     42                using CppAD::ADFun;
     43                using CppAD::NearEqual;
     44                size_t i, j, k, n = 4, ell = n-1 , m = ell + 1;
     45                double eps = 10. * std::numeric_limits<double>::epsilon();
     46
     47                // checkpoint version of the function F(x)
     48                ADVector ax(n), ay(ell), az(m);
     49                for(j = 0; j < n; j++)
     50                        ax[j] = double(j);
     51                checkpoint<double> f_check("f_check", f_algo, ax, ay);
     52                checkpoint<double> g_check("g_check", g_algo, ay, az);
     53
     54                // Record a version of z = g[f(x)] without checkpointing
     55                Independent(ax);
     56                f_algo(ax, ay);
     57                g_algo(ay, az);
     58                ADFun<double> check_not(ax, az);
     59
     60                // Record a version of z = g[f(x)] with checkpointing
     61                Independent(ax);
     62                f_check(ax, ay);
     63                g_check(ay, az);
     64                ADFun<double> check_yes(ax, az);
     65
     66                // compare forward mode results for orders 0, 1, 2
     67                size_t p = 2;
     68                CPPAD_TESTVECTOR(double) x_p(n*(p+1)), z_not(m*(p+1)), z_yes(m*(p+1));
     69                for(j = 0; j < n; j++)
     70                {       for(k = 0; k <= p; k++)
     71                                x_p[ j * (p+1) + k ] = 1.0 / (p + 1 - k);
     72                }
     73                z_not = check_not.Forward(p, x_p);
     74                z_yes = check_yes.Forward(p, x_p);
     75                for(i = 0; i < m; i++)
     76                {       for(k = 0; k <= p; k++)
     77                        {       double zik_not = z_not[ i * (p+1) + k];
     78                                double zik_yes = z_yes[ i * (p+1) + k];
     79                                ok &= NearEqual(zik_not, zik_yes, eps, eps);
     80                        }
     81                }
     82
     83                // compare reverse mode results
     84                CPPAD_TESTVECTOR(double) w(m*(p+1)), dw_not(n*(p+1)), dw_yes(n*(p+1));
     85                dw_not = check_not.Reverse(p+1, w);
     86                dw_yes = check_yes.Reverse(p+1, w);
     87                for(j = 0; j < n; j++)
     88                {       for(k = 0; k <= p; k++)
     89                        {       double dwjk_not = dw_not[ j * (p+1) + k];
     90                                double dwjk_yes = dw_yes[ j * (p+1) + k];
     91                                ok &= NearEqual(dwjk_not, dwjk_yes, eps, eps);
     92                        }
     93                }
     94
     95                // mix sparsity so test both cases
     96                f_check.option( CppAD::atomic_base<double>::bool_sparsity_enum );
     97                g_check.option( CppAD::atomic_base<double>::set_sparsity_enum );
     98
     99                // compare forward mode Jacobian sparsity patterns
     100                size_t q = n - 1;
     101                CppAD::vector< std::set<size_t> > r(n), s_not(m), s_yes(m);
     102                for(j = 0; j < n; j++)
     103                {       if( j < q )
     104                                r[j].insert(j);
     105                        else
     106                        {       r[j].insert(0);
     107                                r[j].insert(1);
     108                        }
     109                }
     110                s_not = check_not.ForSparseJac(q, r);
     111                s_yes = check_yes.ForSparseJac(q, r);
     112                for(i = 0; i < m; i++)
     113                        ok &= s_not[i] == s_yes[i];
     114
     115                // compare reverse mode Jacobian sparsity patterns
     116                CppAD::vector< std::set<size_t> > s(m), r_not(m), r_yes(m);
     117                for(i = 0; i < m; i++)
     118                        s[i].insert(i);
     119                r_not = check_not.RevSparseJac(m, s);
     120                r_yes = check_yes.RevSparseJac(m, s);
     121                for(i = 0; i < m; i++)
     122                        ok &= s_not[i] == s_yes[i];
     123
     124
     125                // compare reverse mode Hessian sparsity patterns
     126                CppAD::vector< std::set<size_t> > s_one(1), h_not(q), h_yes(q);
     127                for(i = 0; i < m; i++)
     128                        s_one[0].insert(i);
     129                h_not = check_not.RevSparseHes(q, s_one);
     130                h_yes = check_yes.RevSparseHes(q, s_one);
     131                for(i = 0; i < q; i++)
     132                        ok &= h_not[i] == h_yes[i];
     133
     134                checkpoint<double>::clear();
     135                return ok;
     136        }
    38137}
    39138
    40139bool checkpoint(void)
    41140{       bool ok = true;
    42         using CppAD::checkpoint;
    43         using CppAD::ADFun;
    44         using CppAD::NearEqual;
    45         size_t i, j, k, n = 4, ell = n-1 , m = ell + 1;
    46         double eps = 10. * std::numeric_limits<double>::epsilon();
     141        ok  &= test_one();
    47142
    48         // checkpoint version of the function F(x)
    49         ADVector ax(n), ay(ell), az(m);
    50         for(j = 0; j < n; j++)
    51                 ax[j] = double(j);
    52         checkpoint<double> f_check("f_check", f_algo, ax, ay);
    53         checkpoint<double> g_check("g_check", g_algo, ay, az);
    54 
    55         // Record a version of z = g[f(x)] without checkpointing
    56         Independent(ax);
    57         f_algo(ax, ay);
    58         g_algo(ay, az);
    59         ADFun<double> check_not(ax, az);
    60 
    61         // Record a version of z = g[f(x)] with checkpointing
    62         Independent(ax);
    63         f_check(ax, ay);
    64         g_check(ay, az);
    65         ADFun<double> check_yes(ax, az);
    66 
    67         // compare forward mode results for orders 0, 1, 2
    68         size_t p = 2;
    69         CPPAD_TESTVECTOR(double) x_p(n*(p+1)), z_not(m*(p+1)), z_yes(m*(p+1));
    70         for(j = 0; j < n; j++)
    71         {       for(k = 0; k <= p; k++)
    72                         x_p[ j * (p+1) + k ] = 1.0 / (p + 1 - k);
    73         }
    74         z_not = check_not.Forward(p, x_p);
    75         z_yes = check_yes.Forward(p, x_p);
    76         for(i = 0; i < m; i++)
    77         {       for(k = 0; k <= p; k++)
    78                 {       double zik_not = z_not[ i * (p+1) + k];
    79                         double zik_yes = z_yes[ i * (p+1) + k];
    80                         ok &= NearEqual(zik_not, zik_yes, eps, eps);
    81                 }
    82         }
    83 
    84         // compare reverse mode results
    85         CPPAD_TESTVECTOR(double) w(m*(p+1)), dw_not(n*(p+1)), dw_yes(n*(p+1));
    86         dw_not = check_not.Reverse(p+1, w);
    87         dw_yes = check_yes.Reverse(p+1, w);
    88         for(j = 0; j < n; j++)
    89         {       for(k = 0; k <= p; k++)
    90                 {       double dwjk_not = dw_not[ j * (p+1) + k];
    91                         double dwjk_yes = dw_yes[ j * (p+1) + k];
    92                         ok &= NearEqual(dwjk_not, dwjk_yes, eps, eps);
    93                 }
    94         }
    95 
    96         // mix sparsity so test both cases
    97         f_check.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    98         g_check.option( CppAD::atomic_base<double>::set_sparsity_enum );
    99 
    100         // compare forward mode Jacobian sparsity patterns
    101         size_t q = n - 1;
    102         CppAD::vector< std::set<size_t> > r(n), s_not(m), s_yes(m);
    103         for(j = 0; j < n; j++)
    104         {       if( j < q )
    105                         r[j].insert(j);
    106                 else
    107                 {       r[j].insert(0);
    108                         r[j].insert(1);
    109                 }
    110         }
    111         s_not = check_not.ForSparseJac(q, r);
    112         s_yes = check_yes.ForSparseJac(q, r);
    113         for(i = 0; i < m; i++)
    114                 ok &= s_not[i] == s_yes[i];
    115 
    116         // compare reverse mode Jacobian sparsity patterns
    117         CppAD::vector< std::set<size_t> > s(m), r_not(m), r_yes(m);
    118         for(i = 0; i < m; i++)
    119                 s[i].insert(i);
    120         r_not = check_not.RevSparseJac(m, s);
    121         r_yes = check_yes.RevSparseJac(m, s);
    122         for(i = 0; i < m; i++)
    123                 ok &= s_not[i] == s_yes[i];
    124        
    125 
    126         // compare reverse mode Hessian sparsity patterns
    127         CppAD::vector< std::set<size_t> > s_one(1), h_not(q), h_yes(q);
    128         for(i = 0; i < m; i++)
    129                 s_one[0].insert(i);
    130         h_not = check_not.RevSparseHes(q, s_one);
    131         h_yes = check_yes.RevSparseHes(q, s_one);
    132         for(i = 0; i < q; i++)
    133                 ok &= h_not[i] == h_yes[i];
    134        
    135         checkpoint<double>::clear();
    136143        return ok;
    137144}
Note: See TracChangeset for help on using the changeset viewer.