Changeset 3793


Ignore:
Timestamp:
Feb 29, 2016 1:18:32 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 001743ad36561e8047c36cff04f6ba6c53c107cb
end hash code: 833d34533ed5aa34a589f0b17ffd5d8f7fa79e6c

commit 833d34533ed5aa34a589f0b17ffd5d8f7fa79e6c
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 11:09:41 2016 -0700

whats_new_16.omh: comments for meging sparse branch.

commit 568b9233843de4c66370f497fda890a268c3db71
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 08:46:07 2016 -0700

Advance version to 20160229.

commit cf120d3613f0c34c17291d6f780623d1c9275817
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 08:39:04 2016 -0700

sparse branch:
hes_sparsity.cpp: test ForSparseHes? on all cases it can handle.

commit 454e63520c5faa699fec138e530147a08d4fbf66
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 08:23:04 2016 -0700

sparse branch:
hes_sparsity.cpp: user routine to check bool, set, forward, reverse.

commit e3a431f3b2a4b825a471cd64101a61920d8506dc
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 07:47:50 2016 -0700

sparse branch:
hes_sparsity.cpp: Reduce code using routines for forward sparse Jacobian calculation.

commit dc028132d953c720db4d2049bf0f97c8200e0b7f
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 07:18:34 2016 -0700

sparse branch:
hes_sparsity.cpp: include ForSparseHes? to case_one test.

commit 0616c4c8a41124779578817c0cfa69c1946bb027
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 20:04:50 2016 -0700

sparse branch:
Move test_more/rev_sparse_hes.cpp -> test_more/hes_sparsity.cpp
(prepare for also testing ForSparseHes? with these cases).

commit 6f5283c706ecc6bf17040fb70a93a898c09d408d
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 14:11:04 2016 -0700

sparse branch:
Test user atomic functions with for_sparse_hes.
sparsity.cpp: fix mistake in rev_sparse_hes.cpp
atomic_base.hpp: put for_sparse_hes before rev_spares_hes, fix parameter name.

commit f7782a41eac5715399d017863b00afd265a867b8
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 08:54:40 2016 -0700

sparse branch:
Add code (not yet tested) for for_sparse_hes with atomic functions.

commit fcfeecf4ea23c147267749471725573a2f7fba28
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 06:50:42 2016 -0700

sparse branch:
Use a separate local forward jacobian sparsity structure for for_sparse_hes.

commit 79fea014f5d74f145bd84fa36f4f37b0e4350c73
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 06:33:24 2016 -0700

sparse branch:
Finish forward sparse hessian all operators but the user atomics.

commit 8d9706d82c7500c48028872aaf9ef796b8f46fbb
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 06:02:45 2016 -0700

sparse branch:
Implement and test VecAD and pow operations.

commit ab4f6a764aadc32b7240e8167373d637374cdf14
Author: Brad Bell <bradbell@…>
Date: Sun Feb 28 05:09:29 2016 -0700

sparse branch:
for_hes_sweep.hpp: implement some more operators.
load_op.hpp: fix a typo in doxygen documentation.
rev_hes_sweep.hpp: fix a comment.
for_sparse_hes.cpp: test some more cases (need to test load ops).

commit a0c903088992f5218651a64f2ab258ee044b0868
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 19:02:23 2016 -0700

sparse branch:
for_sparse_hes.cpp: include variable / variable operator.

commit 15f1ee1a965c49670816d4a4f0b1632f96b56063
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 17:28:40 2016 -0700

sparse branch:
Start a test for each operator (will implement one by one).
for_sparse_hes.cpp: begin with MulvvOp? (already implemented).

commit de6927c0f9ec760a669f1e4e600988e7194aa207
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 16:39:02 2016 -0700

sparse branch:
Run all the cases in the example/test and turn off the tracing.

commit 747f3a6d2deb2269280284edc0ec594686b11a39
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 16:13:15 2016 -0700

sparse branch:
First version of ForSparseHes? that passes a test (only two operators implemented).

commit 344add6858a0ddbe4fc2db712f84ceec749fd423
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 11:33:12 2016 -0700

sparse branch:
Add tracing of for_sparse_jac and for_sparse_hes values.

commit bffab572848831be17dfde13d2455f18e779a37d
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 11:11:24 2016 -0700

sparse branch:
Change for_sparse_hes to use diagonal matrix to select which independent variables.

commit ab94dba08a38c85dc2a57e0dbda83d9d7d0130ae
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 08:26:54 2016 -0700

sparse branch: (merge into master even if abort)

  1. Remove referecnes to old sparse_set class which has been deleted.
  2. Some updates to the auto-tools testing and install.

commit ceca9457a75282222af33640f375e0ba61a5814c
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 06:57:00 2016 -0700

sparse branch:
Use a forward (not reverse) pass and skip operators that have no effect.

commit 7991ea5b384b595cdc84dda02ffdc33fd5708805
Author: Brad Bell <bradbell@…>
Date: Sat Feb 27 05:58:36 2016 -0700

sparse branch:
for_hes_sweep.hpp: ifdef out out setting values for now.
example.cpp: ifdef out call for_sparse (until test passes).
for_sparse_hes.cpp: reduce number calls to for_hes_sweep to 1 (for now).

commit 620a3d684ae3e267980f1a283c8a2a09176168b2
Author: Brad Bell <bradbell@…>
Date: Fri Feb 26 12:52:37 2016 -0700

sparse branch:
change row dimension of for_hes_sparse.
rev_hes_sweep.hpp: minor white space edit.
CMakeLists.txt: include for_sparse_hes.cpp example/test.

commit 065eb55bbe45eb231a9cfad1a12ef826e45f26cc
Author: Brad Bell <bradbell@…>
Date: Fri Feb 26 09:52:29 2016 -0700

sparse branch:
Forward mode Hessian sparsity calculation (under construction).

commit a088bf586d9c4a940fa14daa6c78d1218775b671
Author: Brad Bell <bradbell@…>
Date: Fri Feb 26 08:37:08 2016 -0700

sparse branch:
Forward mode Hessian sparsity algorithm (under construction).

Location:
trunk
Files:
5 added
1 deleted
60 edited

Legend:

Unmodified
Added
Removed
  • trunk/AUTHORS

    r3792 r3793  
    22             ===========================================
    33
    4 To date, 2016-02-26, Bradley M. Bell is the sole author of CppAD.
     4To date, 2016-02-29, Bradley M. Bell is the sole author of CppAD.
    55While Bradley M. Bell worked for the University of Washington during
    66the development of CppAD, the following are also true:
  • trunk/CMakeLists.txt

    r3792 r3793  
    1818
    1919# cppad_version is used by set_version.sh to get the version number.
    20 SET(cppad_version      "20160226" )
     20SET(cppad_version      "20160229" )
    2121SET(cppad_url          "http://www.coin-or.org/CppAD" )
    2222SET(cppad_description  "Differentiation of C++ Algorithms" )
  • trunk/bin/batch_edit.sh

    r3792 r3793  
    1818#
    1919cat << EOF > junk.sed
    20 s|CPPAD_INTERNAL_SPARSE_SET  |sparse_list                |
    21 s|CPPAD_INTERNAL_SPARSE_SET&  |sparse_list\&                |
    22 s|CPPAD_INTERNAL_SPARSE_SET |sparse_list |
    23 /cppad\/local\/sparse_set.hpp/d
    24 : end
     20s|sparse_set, sparse_list|sparse_list|
     21s|.c sparse_pack, .c sparse_set,* or .c sparse_list|sparse_pack or sparse_list|
    2522EOF
    2623# -----------------------------------------------------------------------------
  • trunk/build.sh

    r3762 r3793  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    8080if [ "$1" = "version" ]
    8181then
    82         echo 'bin/version.sh copy'
    83         bin/version.sh copy
     82        echo 'bin/version.sh check'
     83        bin/version.sh check
    8484        #
    8585        echo "OK: ./build.sh version"
     
    227227CXX_FLAGS=\"$cxx_flags\" \\
    228228$special_types OPENMP_FLAGS=-fopenmp \\
    229 --with-sparse_list --with-Documentation \\
     229--with-Documentation \\
    230230--with-deprecated
    231231EOF
     
    235235                CXX_FLAGS="$cxx_flags" \
    236236                $special_types OPENMP_FLAGS=-fopenmp \
    237                 --with-sparse_list --with-Documentation \
     237                --with-Documentation \
    238238                --with-deprecated
    239239        #
     
    280280        echo "mv doc.omh.save doc.omh"
    281281              mv doc.omh.save doc.omh
    282         #
     282        # No longer run these because tested when bin/package.sh is run.
    283283        # Run automated checking of file names in original source directory
    284         list="
    285                 check_define.sh
    286                 check_example.sh
    287                 check_if.sh
    288                 check_include_def.sh
    289                 check_include_file.sh
    290                 check_include_omh.sh
    291                 check_makefile.sh
    292                 check_op_code.sh
    293                 check_replace.sh
    294                 check_svn_id.sh
    295                 check_verbatim.sh
    296         "
    297         for check in $list
    298         do
    299                 echo "bin/$check"
    300                       bin/$check
    301         done
     284        # list="
     285        #       check_define.sh
     286        #       check_example.sh
     287        #       check_if.sh
     288        #       check_include_def.sh
     289        #       check_include_file.sh
     290        #       check_include_omh.sh
     291        #       check_makefile.sh
     292        #       check_op_code.sh
     293        #       check_replace.sh
     294        #       check_svn_id.sh
     295        #       check_verbatim.sh
     296        # "
     297        # for check in $list
     298        # do
     299        #       echo "bin/$check"
     300        #             bin/$check
     301        # done
    302302        # ----------------------------------------------------------------------
    303303        # Things to do in the build directory
     
    471471              bin/run_omhelp.sh xml  >> $log_dir/$log_file
    472472        #
     473        # Developer documentation no longer works for auto-tools install
    473474        # test developer documentation
    474         echo "./build.sh doxygen   >> $log_file"
    475               ./build.sh doxygen   >> $log_dir/$log_file
     475        # echo "./build.sh doxygen   >> $log_file"
     476        #      ./build.sh doxygen   >> $log_dir/$log_file
    476477        #
    477478        # ----------------------------------------------------------------------
  • trunk/compare_c/makefile.in

    r3762 r3793  
    287287cppad_has_nullptr = @cppad_has_nullptr@
    288288cppad_has_rvalue = @cppad_has_rvalue@
    289 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    290289cppad_max_num_threads = @cppad_max_num_threads@
    291290cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/configure

    r3792 r3793  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.69 for cppad 20160226.
     3# Generated by GNU Autoconf 2.69 for cppad 20160229.
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    581581PACKAGE_NAME='cppad'
    582582PACKAGE_TARNAME='cppad'
    583 PACKAGE_VERSION='20160226'
    584 PACKAGE_STRING='cppad 20160226'
     583PACKAGE_VERSION='20160229'
     584PACKAGE_STRING='cppad 20160229'
    585585PACKAGE_BUGREPORT='cppad@list.coin-or.org'
    586586PACKAGE_URL=''
     
    727727CppAD_DEPRECATED_FALSE
    728728CppAD_DEPRECATED_TRUE
    729 cppad_internal_sparse_set
    730729cppad_eigenvector
    731730cppad_boostvector
     
    833832with_TestMore
    834833with_PrintFor
     834with_sparse_set
     835with_sparse_list
    835836enable_msvc
    836837with_Documentation
     
    838839with_boostvector
    839840with_eigenvector
    840 with_sparse_set
    841 with_sparse_list
    842841with_deprecated
    843842'
     
    14081407  # This message is too long to be a string in the A/UX 3.1 sh.
    14091408  cat <<_ACEOF
    1410 \`configure' configures cppad 20160226 to adapt to many kinds of systems.
     1409\`configure' configures cppad 20160229 to adapt to many kinds of systems.
    14111410
    14121411Usage: $0 [OPTION]... [VAR=VALUE]...
     
    14781477if test -n "$ac_init_help"; then
    14791478  case $ac_init_help in
    1480      short | recursive ) echo "Configuration of cppad 20160226:";;
     1479     short | recursive ) echo "Configuration of cppad 20160229:";;
    14811480   esac
    14821481  cat <<\_ACEOF
     
    15071506  --with-TestMore         is not necessary, see install instructions.
    15081507  --with-PrintFor         is not necessary, see install instructions.
     1508  --with-sparse_set       no longer available
     1509  --with-sparse_list      no longer necessary
    15091510  --with-Documentation    default is no
    15101511  --with-stdvector        default is no
    15111512  --with-boostvector      default is no
    15121513  --with-eigenvector      default is no
    1513   --with-sparse_set       default is not specified
    1514   --with-sparse_list      default is not specified
    15151514  --with-deprecated       include an implicit AD<Base> constructor from any
    15161515                          type
     
    16121611if $ac_init_version; then
    16131612  cat <<\_ACEOF
    1614 cppad configure 20160226
     1613cppad configure 20160229
    16151614generated by GNU Autoconf 2.69
    16161615
     
    22412240running configure, to aid debugging if configure makes a mistake.
    22422241
    2243 It was created by cppad $as_me 20160226, which was
     2242It was created by cppad $as_me 20160229, which was
    22442243generated by GNU Autoconf 2.69.  Invocation command line was
    22452244
     
    31313130# Define the identity of the package.
    31323131 PACKAGE='cppad'
    3133  VERSION='20160226'
     3132 VERSION='20160229'
    31343133
    31353134
     
    45314530    as_fn_error $? "--with-PrintFor not necessary, see install instructions." "$LINENO" 5
    45324531fi
     4532
     4533# Check whether --with-sparse_set was given.
     4534if test "${with_sparse_set+set}" = set; then :
     4535  withval=$with_sparse_set; sparse_set="yes"
     4536else
     4537  sparse_set="no"
     4538
     4539fi
     4540
     4541if test "$sparse_set" = "yes" ; then
     4542        as_fn_error $? "--with-sparse_set is no longer available" "$LINENO" 5
     4543fi
     4544
     4545# Check whether --with-sparse_list was given.
     4546if test "${with_sparse_list+set}" = set; then :
     4547  withval=$with_sparse_list; sparse_set="yes"
     4548else
     4549  sparse_set="no"
     4550
     4551fi
     4552
     4553if test "$sparse_set" = "yes" ; then
     4554        as_fn_error $? "--with-sparse_set is no longer necessary" "$LINENO" 5
     4555fi
    45334556{ $as_echo "$as_me:${as_lineno-$LINENO}: ******  Check command line arguments that are used ***********" >&5
    45344557$as_echo "$as_me: ******  Check command line arguments that are used ***********" >&6;}
     
    46514674
    46524675fi
    4653 
    4654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_set" >&5
    4655 $as_echo_n "checking --with-sparse_set... " >&6; }
    4656 
    4657 # Check whether --with-sparse_set was given.
    4658 if test "${with_sparse_set+set}" = set; then :
    4659   withval=$with_sparse_set; sparse_set="yes"
    4660 else
    4661   sparse_set="no"
    4662 
    4663 fi
    4664 
    4665 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_set" >&5
    4666 $as_echo "$sparse_set" >&6; }
    4667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_list" >&5
    4668 $as_echo_n "checking --with-sparse_list... " >&6; }
    4669 
    4670 # Check whether --with-sparse_list was given.
    4671 if test "${with_sparse_list+set}" = set; then :
    4672   withval=$with_sparse_list; sparse_list="yes"
    4673 else
    4674   sparse_list="no"
    4675 
    4676 fi
    4677 
    4678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_list" >&5
    4679 $as_echo "$sparse_list" >&6; }
    4680 if test "$sparse_set" = "yes" ; then
    4681         if test "$sparse_list" == "yes" ; then
    4682                 as_fn_error $? "cannot --with both sparse_set and sparse_list" "$LINENO" 5
    4683         fi
    4684         cppad_internal_sparse_set=sparse_set
    4685 
    4686 else
    4687         cppad_internal_sparse_set=sparse_list
    4688 
    4689 fi
    4690 
    46914676
    46924677{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-deprecated" >&5
     
    85838568# values after options handling.
    85848569ac_log="
    8585 This file was extended by cppad $as_me 20160226, which was
     8570This file was extended by cppad $as_me 20160229, which was
    85868571generated by GNU Autoconf 2.69.  Invocation command line was
    85878572
     
    86408625ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
    86418626ac_cs_version="\\
    8642 cppad config.status 20160226
     8627cppad config.status 20160229
    86438628configured by $0, generated by GNU Autoconf 2.69,
    86448629  with options \\"\$ac_cs_config\\"
  • trunk/configure.ac

    r3792 r3793  
    1313dnl Process this file with autoconf to produce a configure script.
    1414dnl   package   version              bug-report
    15 AC_INIT([cppad], [20160226], [cppad@list.coin-or.org])
     15AC_INIT([cppad], [20160229], [cppad@list.coin-or.org])
    1616AM_SILENT_RULES([yes])
    1717
     
    9999if test "$PrintFor" = "yes" ; then
    100100    AC_MSG_ERROR([--with-PrintFor not necessary, see install instructions.])
     101fi
     102AC_ARG_WITH(sparse_set,
     103        AC_HELP_STRING([--with-sparse_set], [no longer available]),
     104        [sparse_set="yes"],
     105        [sparse_set="no"]
     106)
     107if test "$sparse_set" = "yes" ; then
     108        AC_MSG_ERROR([--with-sparse_set is no longer available])
     109fi
     110AC_ARG_WITH(sparse_list,
     111        AC_HELP_STRING([--with-sparse_list], [no longer necessary]),
     112        [sparse_set="yes"],
     113        [sparse_set="no"]
     114)
     115if test "$sparse_set" = "yes" ; then
     116        AC_MSG_ERROR([--with-sparse_set is no longer necessary])
    101117fi
    102118dnl --------------------------------------------------------------------------
     
    187203        AC_SUBST(cppad_eigenvector, 0)
    188204fi
    189 
    190 dnl Are we using sparse_set or sparse_list ----------------------------
    191 AC_MSG_CHECKING([--with-sparse_set])
    192 AC_ARG_WITH(sparse_set,
    193         AC_HELP_STRING([--with-sparse_set], [default is not specified]),
    194         [sparse_set="yes"],
    195         [sparse_set="no"]
    196 )
    197 AC_MSG_RESULT([$sparse_set])
    198 dnl
    199 AC_MSG_CHECKING([--with-sparse_list])
    200 AC_ARG_WITH(sparse_list,
    201         AC_HELP_STRING([--with-sparse_list], [default is not specified]),
    202         [sparse_list="yes"],
    203         [sparse_list="no"]
    204 )
    205 AC_MSG_RESULT([$sparse_list])
    206 if test "$sparse_set" = "yes" ; then
    207         if test "$sparse_list" == "yes" ; then
    208                 AC_MSG_ERROR([cannot --with both sparse_set and sparse_list])
    209         fi
    210         AC_SUBST(cppad_internal_sparse_set, sparse_set)
    211 else
    212         AC_SUBST(cppad_internal_sparse_set, sparse_list)
    213 fi
    214 
    215205
    216206dnl Are we including deprecated features in the install-----------
  • trunk/cppad/local/ad_fun.hpp

    r3792 r3793  
    193193        );
    194194        // ------------------------------------------------------------
     195        // vector of bool version of ForSparseHes
     196        // (see doxygen in rev_sparse_hes.hpp)
     197        template <class VectorSet>
     198        void ForSparseHesCase(
     199                bool               set_type  ,
     200                const VectorSet&   r         ,
     201                const VectorSet&   s         ,
     202                VectorSet&         h
     203        );
     204        // vector of std::set<size_t> version of ForSparseHes
     205        // (see doxygen in rev_sparse_hes.hpp)
     206        template <class VectorSet>
     207        void ForSparseHesCase(
     208                const std::set<size_t>&  set_type  ,
     209                const VectorSet&         r         ,
     210                const VectorSet&         s         ,
     211                VectorSet&               h
     212        );
     213        // ------------------------------------------------------------
    195214        // vector of bool version of RevSparseHes
    196215        // (see doxygen in rev_sparse_hes.hpp)
     
    237256        );
    238257        // ------------------------------------------------------------
    239         // combined sparse_set, sparse_list and sparse_pack version of
     258        // combined sparse_list and sparse_pack version of
    240259        // SparseHessian (see doxygen in sparse_hessian.hpp)
    241260        template <class VectorBase, class VectorSet, class VectorSize>
     
    318337                bool dependency = false
    319338        );
     339        // forward mode Hessian sparsity
     340        // (see doxygen documentation in rev_sparse_hes.hpp)
     341        template <typename VectorSet>
     342        VectorSet ForSparseHes(
     343                const VectorSet &r, const VectorSet &s
     344        );
     345        // internal set sparsity version of ForSparseHes
     346        // (used by checkpoint functions only)
     347        void ForSparseHesCheckpoint(
     348                vector<bool>&                 r         ,
     349                vector<bool>&                 s         ,
     350                sparse_list&                  h
     351        );
    320352        // reverse mode Hessian sparsity
    321353        // (see doxygen documentation in rev_sparse_hes.hpp)
     
    609641# include <cppad/local/rev_jac_sweep.hpp>
    610642# include <cppad/local/rev_hes_sweep.hpp>
     643# include <cppad/local/for_hes_sweep.hpp>
    611644
    612645// user interfaces
  • trunk/cppad/local/atomic_base.hpp

    r3757 r3793  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    627627in the corresponding call to
    628628$codei%
    629         %afun%(%ax%, %ay%, %id%)
     629        %afun%(%ax%, %ay%)
    630630%$$
    631631If $icode%vx%.size() == 0%$$,
     
    12491249/*
    12501250-------------------------------------- ---------------------------------------
     1251$begin atomic_for_sparse_hes$$
     1252$spell
     1253        sq
     1254        mul.hpp
     1255        vx
     1256        afun
     1257        Jacobian
     1258        jac
     1259        CppAD
     1260        std
     1261        bool
     1262        hes
     1263        const
     1264$$
     1265
     1266$section Atomic Forward Hessian Sparsity Patterns$$
     1267
     1268$head Syntax$$
     1269$icode%ok% = %afun%.for_sparse_hes(%vx%, %r%, %s%, %h%)%$$
     1270
     1271$head Purpose$$
     1272This function is used by $cref ForSparseHes$$ to compute
     1273Hessian sparsity patterns.
     1274There is an unspecified scalar valued function
     1275$latex g : B^m \rightarrow B$$.
     1276Given a $cref/sparsity pattern/glossary/Sparsity Pattern/$$ for
     1277$latex R \in B^{n \times q}$$,
     1278and information about the function $latex z = g(y)$$,
     1279this routine computes the sparsity pattern for
     1280$latex \[
     1281        H(x) = R^\R{T} (g \circ f)^{(2)}( x ) R
     1282\] $$
     1283
     1284$head Implementation$$
     1285If you are using and $cref ForSparseHes$$,
     1286this virtual function must be defined by the
     1287$cref/atomic_user/atomic_ctor/atomic_user/$$ class.
     1288
     1289$subhead vx$$
     1290The argument $icode vx$$ has prototype
     1291$codei%
     1292     const CppAD:vector<bool>& %vx%
     1293%$$
     1294$icode%vx%.size() == %n%$$, and
     1295for $latex j = 0 , \ldots , n-1$$,
     1296$icode%vx%[%j%]%$$ is true if and only if
     1297$icode%ax%[%j%]%$$ is a $cref/variable/glossary/Variable/$$
     1298in the corresponding call to
     1299$codei%
     1300        %afun%(%ax%, %ay%)
     1301%$$
     1302
     1303$subhead r$$
     1304This argument has prototype
     1305$codei%
     1306     const %atomic_sparsity%& %r%
     1307%$$
     1308and is a $cref/atomic_sparsity/atomic_option/atomic_sparsity/$$ pattern for
     1309the diagonal of $latex R \in B^{n \times n}$$.
     1310
     1311$subhead s$$
     1312The argument $icode s$$ has prototype
     1313$codei%
     1314     const CppAD:vector<bool>& %s%
     1315%$$
     1316and its size is $icode m$$.
     1317It is a sparsity pattern for
     1318$latex S(x) = g^{(1)} (y) \in B^{1 \times m}$$.
     1319
     1320$subhead h$$
     1321This argument has prototype
     1322$codei%
     1323     %atomic_sparsity%& %h%
     1324%$$
     1325The input value of its elements
     1326are not specified (must not matter).
     1327Upon return, $icode v$$ is a
     1328$cref/atomic_sparsity/atomic_option/atomic_sparsity/$$ pattern for
     1329$latex H(x) \in B^{n \times q}$$ which is defined by
     1330$latex \[
     1331H(x) = R^\R{T} (g \circ f)^{(2)}( x ) R
     1332\] $$
     1333
     1334$head Examples$$
     13352DO
     1336
     1337$end
     1338-----------------------------------------------------------------------------
     1339*/
     1340/*!
     1341Link from forward Hessian sparsity sweep to base_atomic
     1342
     1343\param vx [in]
     1344which componens of x are variables.
     1345
     1346\param r [in]
     1347is the forward Jacobian sparsity pattern w.r.t the argument vector x.
     1348
     1349\param s [in]
     1350is the reverse Jacobian sparsity pattern w.r.t the result vector y.
     1351
     1352\param h [out]
     1353is the Hessian sparsity pattern w.r.t the argument vector x.
     1354*/
     1355virtual bool for_sparse_hes(
     1356        const vector<bool>&             vx ,
     1357        const vector<bool>&             r  ,
     1358        const vector<bool>&             s  ,
     1359        vector< std::set<size_t> >&     h  )
     1360{       return false; }
     1361virtual bool for_sparse_hes(
     1362        const vector<bool>&             vx ,
     1363        const vector<bool>&             r  ,
     1364        const vector<bool>&             s  ,
     1365        vector<bool>&                   h  )
     1366{       return false; }
     1367virtual bool for_sparse_hes(
     1368        const vector<bool>&             vx ,
     1369        const vector<bool>&             r  ,
     1370        const vector<bool>&             s  ,
     1371        vectorBool&                     h  )
     1372{       return false; }
     1373/*
     1374-------------------------------------- ---------------------------------------
    12511375$begin atomic_rev_sparse_hes$$
    12521376$spell
     
    12981422in the corresponding call to
    12991423$codei%
    1300         %afun%(%ax%, %ay%, %id%)
     1424        %afun%(%ax%, %ay%)
    13011425%$$
    13021426
  • trunk/cppad/local/cond_op.hpp

    r3757 r3793  
    33# define CPPAD_COND_OP_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    120120\tparam Vector_set
    121121is the type used for vectors of sets. It can be either
    122 \c sparse_pack, \c sparse_set, or \c sparse_list.
     122sparse_pack or sparse_list.
    123123
    124124\param i_z
     
    893893\tparam Vector_set
    894894is the type used for vectors of sets. It can be either
    895 \c sparse_pack, \c sparse_set, or \c sparse_list.
     895sparse_pack or sparse_list.
    896896
    897897\param i_z
     
    10321032\tparam Vector_set
    10331033is the type used for vectors of sets. It can be either
    1034 \c sparse_pack, \c sparse_set, or \c sparse_list.
     1034sparse_pack or sparse_list.
    10351035
    10361036\param i_z
     
    11731173\tparam Vector_set
    11741174is the type used for vectors of sets. It can be either
    1175 \c sparse_pack, \c sparse_set, or \c sparse_list.
     1175sparse_pack or sparse_list.
    11761176
    11771177\param i_z
  • trunk/cppad/local/csum_op.hpp

    r3757 r3793  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    376376\tparam Vector_set
    377377is the type used for vectors of sets. It can be either
    378 \c sparse_pack, \c sparse_set, or \c sparse_list.
     378sparse_pack or sparse_list.
    379379
    380380\param i_z
     
    454454\tparam Vector_set
    455455is the type used for vectors of sets. It can be either
    456 \c sparse_pack, \c sparse_set, or \c sparse_list.
     456sparse_pack or sparse_list.
    457457
    458458\param i_z
     
    530530\tparam Vector_set
    531531is the type used for vectors of sets. It can be either
    532 \c sparse_pack, \c sparse_set, or \c sparse_list.
     532sparse_pack or sparse_list.
    533533
    534534\param i_z
  • trunk/cppad/local/for_jac_sweep.hpp

    r3792 r3793  
    6161\tparam Vector_set
    6262is the type used for vectors of sets. It can be either
    63 \c sparse_pack, \c sparse_set, or \c sparse_list.
     63sparse_pack or sparse_list.
    6464
    6565\param dependency
  • trunk/cppad/local/load_op.hpp

    r3757 r3793  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    7070arg[0]
    7171is the offset of this VecAD vector relative to the beginning
    72 of the isvar_by_ind and index)_by_ind arrays.
     72of the isvar_by_ind and index_by_ind arrays.
    7373\n
    7474\n
     
    8383i_vec is defined by
    8484\verbatim
    85         i_vec = floor( taylor[ arg[1] * cap_order + 0 ] )
    8685\endverbatim
    8786where floor(c) is the greatest integer less that or equal c.
     
    177176\tparam Vector_set
    178177is the type used for vectors of sets. It can be either
    179 \c sparse_pack, \c sparse_set, or \c sparse_list.
     178sparse_pack or sparse_list.
    180179
    181180\param op
  • trunk/cppad/local/prototype_op.hpp

    r3757 r3793  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    13121312\tparam Vector_set
    13131313is the type used for vectors of sets. It can be either
    1314 \c sparse_pack, \c sparse_set, or \c sparse_list.
     1314sparse_pack or sparse_list.
    13151315
    13161316\param i_z
     
    13781378\tparam Vector_set
    13791379is the type used for vectors of sets. It can be either
    1380 \c sparse_pack, \c sparse_set, or \c sparse_list.
     1380sparse_pack or sparse_list.
    13811381
    13821382\param i_z
  • trunk/cppad/local/rev_hes_sweep.hpp

    r3792 r3793  
    4141\tparam Vector_set
    4242is the type used for vectors of sets. It can be either
    43 \c sparse_pack, \c sparse_set, or \c sparse_list.
     43sparse_pack or sparse_list.
    4444
    4545\param n
     
    121121
    122122        // check numvar argument
    123         CPPAD_ASSERT_UNKNOWN( play->num_var_rec()     == numvar );
     123        CPPAD_ASSERT_UNKNOWN( play->num_var_rec()    == numvar );
    124124        CPPAD_ASSERT_UNKNOWN( for_jac_sparse.n_set() == numvar );
    125125        CPPAD_ASSERT_UNKNOWN( rev_hes_sparse.n_set() == numvar );
     
    393393                        case ErfOp:
    394394                        // arg[1] is always the parameter 0
    395                         // arg[0] is always the parameter 2 / sqrt(pi)
     395                        // arg[2] is always the parameter 2 / sqrt(pi)
    396396                        CPPAD_ASSERT_NARG_NRES(op, 3, 5);
    397397                        reverse_sparse_hessian_nonlinear_unary_op(
     
    527527                        case PowvvOp:
    528528                        CPPAD_ASSERT_NARG_NRES(op, 2, 3)
    529                         reverse_sparse_hessian_pow_op(
     529                        reverse_sparse_hessian_pow_op(
    530530                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
    531531                        );
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3792 r3793  
    5959\tparam Vector_set
    6060is the type used for vectors of sets. It can be either
    61 \c sparse_pack, \c sparse_set, or \c sparse_list.
     61sparse_pack or sparse_list.
    6262
    6363\param dependency
  • trunk/cppad/local/sparse.hpp

    r3757 r3793  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    2727        example/dependency.cpp%
    2828        cppad/local/rev_sparse_hes.hpp%
     29        cppad/local/for_sparse_hes.hpp%
    2930        example/bool_sparsity.cpp
    3031%$$
     
    3637# include <cppad/local/rev_sparse_jac.hpp>
    3738# include <cppad/local/rev_sparse_hes.hpp>
     39# include <cppad/local/for_sparse_hes.hpp>
    3840
    3941# endif
  • trunk/cppad/local/sparse_binary_op.hpp

    r3757 r3793  
    33# define CPPAD_SPARSE_BINARY_OP_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    3636\tparam Vector_set
    3737is the type used for vectors of sets. It can be either
    38 \c sparse_pack, \c sparse_set, or \c sparse_list.
     38sparse_pack or sparse_list.
    3939
    4040\param i_z
     
    115115\tparam Vector_set
    116116is the type used for vectors of sets. It can be either
    117 \c sparse_pack, \c sparse_set, or \c sparse_list.
     117sparse_pack or sparse_list.
    118118
    119119\param i_z
     
    168168        return;
    169169}
    170 
     170// ---------------------------------------------------------------------------
    171171/*!
    172172Reverse mode Hessian sparsity pattern for add and subtract operators.
     
    324324        return;
    325325}
    326 
     326// ---------------------------------------------------------------------------
     327/*!
     328Forward mode Hessian sparsity pattern for multiplication operator.
     329
     330The C++ source code corresponding to this operation is
     331\verbatim
     332        w(x) = v0(x) * v1(x)
     333\endverbatim
     334
     335\param arg
     336is the index of the argument vector for the multiplication operation; i.e.,
     337arg[0], arg[1] are the left and right operands.
     338
     339\param for_jac_sparsity
     340for_jac_sparsity(arg[0]) constains the Jacobian sparsity for v0(x),
     341for_jac_sparsity(arg[1]) constains the Jacobian sparsity for v1(x).
     342
     343\param for_hes_sparsity
     344On input, for_hes_sparsity includes the Hessian sparsity for v0(x)
     345and v1(x); i.e., the sparsity can be a super set.
     346Upon return it includes the Hessian sparsity for  w(x)
     347*/
     348template <class Vector_set>
     349inline void forward_sparse_hessian_mul_op(
     350        const addr_t*        arg              ,
     351        Vector_set&         for_jac_sparsity  ,
     352        Vector_set&         for_hes_sparsity  )
     353{       // --------------------------------------------------
     354        // set of independent variables that v0 depends on
     355        for_jac_sparsity.begin(arg[0]);
     356
     357        // loop over dependent variables with non-zero partial
     358        size_t i_x = for_jac_sparsity.next_element();
     359        while( i_x < for_jac_sparsity.end() )
     360        {       // N(i_x) = N(i_x) union L(v1)
     361                for_hes_sparsity.binary_union(i_x, i_x, arg[1], for_jac_sparsity);
     362                i_x = for_jac_sparsity.next_element();
     363        }
     364        // --------------------------------------------------
     365        // set of independent variables that v1 depends on
     366        for_jac_sparsity.begin(arg[1]);
     367
     368        // loop over dependent variables with non-zero partial
     369        i_x = for_jac_sparsity.next_element();
     370        while( i_x < for_jac_sparsity.end() )
     371        {       // N(i_x) = N(i_x) union L(v0)
     372                for_hes_sparsity.binary_union(i_x, i_x, arg[0], for_jac_sparsity);
     373                i_x = for_jac_sparsity.next_element();
     374        }
     375        return;
     376}
     377/*!
     378Forward mode Hessian sparsity pattern for division operator.
     379
     380The C++ source code corresponding to this operation is
     381\verbatim
     382        w(x) = v0(x) / v1(x)
     383\endverbatim
     384
     385\param arg
     386is the index of the argument vector for the division operation; i.e.,
     387arg[0], arg[1] are the left and right operands.
     388
     389\param for_jac_sparsity
     390for_jac_sparsity(arg[0]) constains the Jacobian sparsity for v0(x),
     391for_jac_sparsity(arg[1]) constains the Jacobian sparsity for v1(x).
     392
     393\param for_hes_sparsity
     394On input, for_hes_sparsity includes the Hessian sparsity for v0(x)
     395and v1(x); i.e., the sparsity can be a super set.
     396Upon return it includes the Hessian sparsity for  w(x)
     397*/
     398template <class Vector_set>
     399inline void forward_sparse_hessian_div_op(
     400        const addr_t*        arg              ,
     401        Vector_set&         for_jac_sparsity  ,
     402        Vector_set&         for_hes_sparsity  )
     403{       // --------------------------------------------------
     404        // set of independent variables that v0 depends on
     405        for_jac_sparsity.begin(arg[0]);
     406
     407        // loop over dependent variables with non-zero partial
     408        size_t i_x = for_jac_sparsity.next_element();
     409        while( i_x < for_jac_sparsity.end() )
     410        {       // N(i_x) = N(i_x) union L(v1)
     411                for_hes_sparsity.binary_union(i_x, i_x, arg[1], for_jac_sparsity);
     412                i_x = for_jac_sparsity.next_element();
     413        }
     414        // --------------------------------------------------
     415        // set of independent variables that v1 depends on
     416        for_jac_sparsity.begin(arg[1]);
     417
     418        // loop over dependent variables with non-zero partial
     419        i_x = for_jac_sparsity.next_element();
     420        while( i_x < for_jac_sparsity.end() )
     421        {       // N(i_x) = N(i_x) union L(v0)
     422                for_hes_sparsity.binary_union(i_x, i_x, arg[0], for_jac_sparsity);
     423                // N(i_x) = N(i_x) union L(v1)
     424                for_hes_sparsity.binary_union(i_x, i_x, arg[1], for_jac_sparsity);
     425                i_x = for_jac_sparsity.next_element();
     426        }
     427        return;
     428}
     429/*!
     430Forward mode Hessian sparsity pattern for power operator.
     431
     432The C++ source code corresponding to this operation is
     433\verbatim
     434        w(x) = pow( v0(x) , v1(x) )
     435\endverbatim
     436
     437\param arg
     438is the index of the argument vector for the power operation; i.e.,
     439arg[0], arg[1] are the left and right operands.
     440
     441\param for_jac_sparsity
     442for_jac_sparsity(arg[0]) constains the Jacobian sparsity for v0(x),
     443for_jac_sparsity(arg[1]) constains the Jacobian sparsity for v1(x).
     444
     445\param for_hes_sparsity
     446On input, for_hes_sparsity includes the Hessian sparsity for v0(x)
     447and v1(x); i.e., the sparsity can be a super set.
     448Upon return it includes the Hessian sparsity for  w(x)
     449*/
     450template <class Vector_set>
     451inline void forward_sparse_hessian_pow_op(
     452        const addr_t*        arg              ,
     453        Vector_set&         for_jac_sparsity  ,
     454        Vector_set&         for_hes_sparsity  )
     455{       // --------------------------------------------------
     456        // set of independent variables that v0 depends on
     457        for_jac_sparsity.begin(arg[0]);
     458
     459        // loop over dependent variables with non-zero partial
     460        size_t i_x = for_jac_sparsity.next_element();
     461        while( i_x < for_jac_sparsity.end() )
     462        {       // N(i_x) = N(i_x) union L(v0)
     463                for_hes_sparsity.binary_union(i_x, i_x, arg[0], for_jac_sparsity);
     464                // N(i_x) = N(i_x) union L(v1)
     465                for_hes_sparsity.binary_union(i_x, i_x, arg[1], for_jac_sparsity);
     466                i_x = for_jac_sparsity.next_element();
     467        }
     468        // --------------------------------------------------
     469        // set of independent variables that v1 depends on
     470        for_jac_sparsity.begin(arg[1]);
     471
     472        // loop over dependent variables with non-zero partial
     473        i_x = for_jac_sparsity.next_element();
     474        while( i_x < for_jac_sparsity.end() )
     475        {       // N(i_x) = N(i_x) union L(v0)
     476                for_hes_sparsity.binary_union(i_x, i_x, arg[0], for_jac_sparsity);
     477                // N(i_x) = N(i_x) union L(v1)
     478                for_hes_sparsity.binary_union(i_x, i_x, arg[1], for_jac_sparsity);
     479                i_x = for_jac_sparsity.next_element();
     480        }
     481        return;
     482}
     483// ---------------------------------------------------------------------------
    327484} // END_CPPAD_NAMESPACE
    328485# endif
  • trunk/cppad/local/sparse_hessian.hpp

    r3792 r3793  
    356356
    357357\tparam VectorSize
    358 is \c sparse_pack, \c sparse_set or \c sparse_list.
     358is sparse_pack or sparse_list.
    359359
    360360\param x [in]
  • trunk/cppad/local/sparse_jacobian.hpp

    r3792 r3793  
    321321
    322322\tparam VectorSet
    323 is either \c sparse_pack, \c sparse_set or \c sparse_list.
     323is either sparse_pack or sparse_list.
    324324
    325325\tparam VectorSize
     
    518518
    519519\tparam VectorSet
    520 is either \c sparse_pack, \c sparse_set or \c sparse_list.
     520is either sparse_pack or sparse_list.
    521521
    522522\tparam VectorSize
  • trunk/cppad/local/sparse_unary_op.hpp

    r3757 r3793  
    33# define CPPAD_SPARSE_UNARY_OP_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    3535\tparam Vector_set
    3636is the type used for vectors of sets. It can be either
    37 \c sparse_pack, \c sparse_set or \c sparse_list.
     37sparse_pack or sparse_list.
    3838
    3939\param i_z
     
    7474        sparsity.assignment(i_z, i_x, sparsity);
    7575}
    76 
    7776/*!
    7877Reverse mode Jacobian sparsity pattern for all unary operators.
     
    9796\tparam Vector_set
    9897is the type used for vectors of sets. It can be either
    99 \c sparse_pack, \c sparse_set, or \c sparse_list.
     98sparse_pack or sparse_list.
    10099
    101100
     
    138137        return;
    139138}
    140 
     139// ---------------------------------------------------------------------------
    141140/*!
    142141Reverse mode Hessian sparsity pattern for linear unary operators.
     
    206205}
    207206
     207// ---------------------------------------------------------------------------
     208/*!
     209Forward mode Hessian sparsity pattern for non-linear unary operators.
     210
     211The C++ source code corresponding to this operation is
     212\verbatim
     213        w(x) = fun( v(x) )
     214\endverbatim
     215where fun is a non-linear function.
     216
     217\param i_v
     218is the index of the argument variable v
     219
     220\param for_jac_sparsity
     221for_jac_sparsity(i_v) constains the Jacobian sparsity for v(x).
     222
     223\param for_hes_sparsity
     224On input, for_hes_sparsity includes the Hessian sparsity for v(x); i.e.,
     225the sparsity can be a super set.
     226Upon return it includes the Hessian sparsity for  w(x)
     227*/
     228template <class Vector_set>
     229inline void forward_sparse_hessian_nonlinear_unary_op(
     230        size_t              i_v               ,
     231        Vector_set&         for_jac_sparsity  ,
     232        Vector_set&         for_hes_sparsity  )
     233{
     234        // set of independent variables that v depends on
     235        for_jac_sparsity.begin(i_v);
     236
     237        // next independent variables that v depends on
     238        size_t i_x = for_jac_sparsity.next_element();
     239
     240        // loop over dependent variables with non-zero partial
     241        while( i_x < for_jac_sparsity.end() )
     242        {       // N(i_x) = N(i_x) union L(i_v)
     243                for_hes_sparsity.binary_union(i_x, i_x, i_v, for_jac_sparsity);
     244                i_x = for_jac_sparsity.next_element();
     245        }
     246        return;
     247}
     248
    208249} // END_CPPAD_NAMESPACE
    209250# endif
  • trunk/cppad/local/store_op.hpp

    r3757 r3793  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    145145\tparam Vector_set
    146146is the type used for vectors of sets. It can be either
    147 \c sparse_pack, \c sparse_set, or \c sparse_list.
     147sparse_pack or sparse_list.
    148148
    149149\param op
  • trunk/cppad_ipopt/example/makefile.in

    r3762 r3793  
    303303cppad_has_nullptr = @cppad_has_nullptr@
    304304cppad_has_rvalue = @cppad_has_rvalue@
    305 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    306305cppad_max_num_threads = @cppad_max_num_threads@
    307306cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/cppad_ipopt/speed/makefile.in

    r3762 r3793  
    305305cppad_has_nullptr = @cppad_has_nullptr@
    306306cppad_has_rvalue = @cppad_has_rvalue@
    307 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    308307cppad_max_num_threads = @cppad_max_num_threads@
    309308cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/cppad_ipopt/src/makefile.in

    r3762 r3793  
    340340cppad_has_nullptr = @cppad_has_nullptr@
    341341cppad_has_rvalue = @cppad_has_rvalue@
    342 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    343342cppad_max_num_threads = @cppad_max_num_threads@
    344343cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/cppad_ipopt/test/makefile.in

    r3762 r3793  
    291291cppad_has_nullptr = @cppad_has_nullptr@
    292292cppad_has_rvalue = @cppad_has_rvalue@
    293 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    294293cppad_max_num_threads = @cppad_max_num_threads@
    295294cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/doc.omh

    r3792 r3793  
    9292$comment bin/version assumes that : follows cppad version number here$$
    9393$section
    94 cppad-20160226: A Package for Differentiation of C++ Algorithms
     94cppad-20160229: A Package for Differentiation of C++ Algorithms
    9595$$
    9696$mindex AD algorithmic differentiation automatic C++ algorithm derivative CppAD version cppad.hpp$$
  • trunk/example/CMakeLists.txt

    r3788 r3793  
    121121        forward_dir.cpp
    122122        forward_order.cpp
     123        for_sparse_hes.cpp
    123124        for_sparse_jac.cpp
    124125        fun_assign.cpp
  • trunk/example/atomic/makefile.in

    r3762 r3793  
    288288cppad_has_nullptr = @cppad_has_nullptr@
    289289cppad_has_rvalue = @cppad_has_rvalue@
    290 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    291290cppad_max_num_threads = @cppad_max_num_threads@
    292291cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/example/atomic/sparsity.cpp

    r3788 r3793  
    127127                //                                       [ 1, 0  ]
    128128                for(size_t j = 0; j < p; j++)
    129                 {       st[ 0 * p + j ] = rt[ 1 * m + j ];
    130                         st[ 1 * p + j ] = rt[ 1 * m + j ];
    131                         st[ 2 * p + j ] = rt[ 0 * m + j ];
    132                 }
     129                {       st[ 0 * p + j ] = rt[ 1 * p + j ];
     130                        st[ 1 * p + j ] = rt[ 1 * p + j ];
     131                        st[ 2 * p + j ] = rt[ 0 * p + j ];
     132                }
     133                return true;
     134        }
     135/* %$$
     136$srccode%cpp% */
     137        virtual bool for_sparse_hes(
     138                const vector<bool>&                   vx,
     139                const vector<bool>&                   r ,
     140                const vector<bool>&                   s ,
     141                vectorBool&                           h )
     142        {       size_t n = r.size();
     143                size_t m = s.size();
     144                assert( h.size() == n * n );
     145                assert( n == 3 );
     146                assert( m == 2 );
     147
     148                // iniialize h as empty
     149                for(size_t i = 0; i < n * n; i++)
     150                        h[i] = false;
     151
     152                // only f_1 has a non-zero hessian
     153                if( ! s[1] )
     154                        return true;
     155
     156                // only the cross term between x[0] and x[1] is non-zero
     157                if( ! ( r[0] & r[1] ) )
     158                        return true;
     159
     160                // set the possibly non-zero terms in the hessian
     161                h[ 0 * n + 1 ] = h[ 1 * n + 0 ] = true;
     162
    133163                return true;
    134164        }
     
    259289        }
    260290/* %$$
     291$subhead for_sparse_hes$$
     292$srccode%cpp% */
     293        {       vectorBool s(m), r(n), h(n * n);
     294                s[0] = s[1] = true;
     295                r[0] = r[1] = r[2] = true;
     296                h    = f.ForSparseHes(r, s);
     297                for(size_t i = 0; i < n; i++)
     298                {       for(size_t j = 0; j < n; j++)
     299                        {       bool check = false;
     300                                check     |= (i == 0) && (j == 1);
     301                                check     |= (j == 0) && (i == 1);
     302                                ok        &= h[ i * n + j] == check;
     303                        }
     304                }
     305        }
     306/* %$$
    261307$subhead rev_sparse_hes$$
    262308$srccode%cpp% */
  • trunk/example/example.cpp

    r3788 r3793  
    9292extern bool ForOne(void);
    9393extern bool ForTwo(void);
     94extern bool for_sparse_hes(void);
    9495extern bool ForSparseJac(void);
    9596extern bool Forward(void);
     
    150151extern bool reverse_two(void);
    151152extern bool RevOne(void);
    152 extern bool RevSparseHes(void);
     153extern bool rev_sparse_hes(void);
    153154extern bool RevSparseJac(void);
    154155extern bool RevTwo(void);
     
    263264        ok &= Run( forward_dir,       "forward_dir"      );
    264265        ok &= Run( forward_order,     "forward_order"    );
     266        ok &= Run( for_sparse_hes,    "for_sparse_hes"   );
    265267        ok &= Run( ForSparseJac,      "ForSparseJac"     );
    266268        ok &= Run( fun_assign,        "fun_assign"       );
     
    315317        ok &= Run( reverse_two,       "reverse_two"      );
    316318        ok &= Run( RevOne,            "RevOne"           );
    317         ok &= Run( RevSparseHes,      "RevSparseHes"     );
     319        ok &= Run( rev_sparse_hes,    "rev_sparse_hes"   );
    318320        ok &= Run( RevSparseJac,      "RevSparseJac"     );
    319321        ok &= Run( RevTwo,            "RevTwo"           );
  • trunk/example/ipopt_solve/makefile.in

    r3762 r3793  
    290290cppad_has_nullptr = @cppad_has_nullptr@
    291291cppad_has_rvalue = @cppad_has_rvalue@
    292 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    293292cppad_max_num_threads = @cppad_max_num_threads@
    294293cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/example/makefile.am

    r3768 r3793  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    129129        forward_dir.cpp \
    130130        forward_order.cpp \
     131        for_sparse_hes.cpp \
    131132        for_sparse_jac.cpp \
    132133        fun_assign.cpp \
  • trunk/example/makefile.in

    r3768 r3793  
    124124        equal_op_seq.cpp erf.cpp error_handler.cpp exp.cpp expm1.cpp \
    125125        for_one.cpp for_two.cpp forward.cpp forward_dir.cpp \
    126         forward_order.cpp for_sparse_jac.cpp fun_assign.cpp \
    127         fun_check.cpp hes_lagrangian.cpp hes_lu_det.cpp \
     126        forward_order.cpp for_sparse_hes.cpp for_sparse_jac.cpp \
     127        fun_assign.cpp fun_check.cpp hes_lagrangian.cpp hes_lu_det.cpp \
    128128        hes_minor_det.cpp hessian.cpp hes_times_dir.cpp \
    129129        independent.cpp index_sort.cpp integer.cpp interface2c.cpp \
     
    168168        exp.$(OBJEXT) expm1.$(OBJEXT) for_one.$(OBJEXT) \
    169169        for_two.$(OBJEXT) forward.$(OBJEXT) forward_dir.$(OBJEXT) \
    170         forward_order.$(OBJEXT) for_sparse_jac.$(OBJEXT) \
    171         fun_assign.$(OBJEXT) fun_check.$(OBJEXT) \
    172         hes_lagrangian.$(OBJEXT) hes_lu_det.$(OBJEXT) \
    173         hes_minor_det.$(OBJEXT) hessian.$(OBJEXT) \
     170        forward_order.$(OBJEXT) for_sparse_hes.$(OBJEXT) \
     171        for_sparse_jac.$(OBJEXT) fun_assign.$(OBJEXT) \
     172        fun_check.$(OBJEXT) hes_lagrangian.$(OBJEXT) \
     173        hes_lu_det.$(OBJEXT) hes_minor_det.$(OBJEXT) hessian.$(OBJEXT) \
    174174        hes_times_dir.$(OBJEXT) independent.$(OBJEXT) \
    175175        index_sort.$(OBJEXT) integer.$(OBJEXT) interface2c.$(OBJEXT) \
     
    410410cppad_has_nullptr = @cppad_has_nullptr@
    411411cppad_has_rvalue = @cppad_has_rvalue@
    412 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    413412cppad_max_num_threads = @cppad_max_num_threads@
    414413cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
     
    562561        forward_dir.cpp \
    563562        forward_order.cpp \
     563        for_sparse_hes.cpp \
    564564        for_sparse_jac.cpp \
    565565        fun_assign.cpp \
     
    753753@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/expm1.Po@am__quote@
    754754@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_one.Po@am__quote@
     755@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_sparse_hes.Po@am__quote@
    755756@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_sparse_jac.Po@am__quote@
    756757@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_two.Po@am__quote@
  • trunk/example/rev_sparse_hes.cpp

    r3788 r3793  
    5656        // domain space vector
    5757        size_t n = 3;
    58         CPPAD_TESTVECTOR(AD<double>) X(n);
    59         X[0] = 0.;
    60         X[1] = 1.;
    61         X[2] = 2.;
     58        CPPAD_TESTVECTOR(AD<double>) ax(n);
     59        ax[0] = 0.;
     60        ax[1] = 1.;
     61        ax[2] = 2.;
    6262
    6363        // declare independent variables and start recording
    64         CppAD::Independent(X);
     64        CppAD::Independent(ax);
    6565
    6666        // range space vector
    6767        size_t m = 2;
    68         CPPAD_TESTVECTOR(AD<double>) Y(m);
    69         Y[0] = sin( X[2] );
    70         Y[1] = X[0] * X[1];
    71 
    72         // create f: X -> Y and stop tape recording
    73         CppAD::ADFun<double> f(X, Y);
     68        CPPAD_TESTVECTOR(AD<double>) ay(m);
     69        ay[0] = sin( ax[2] );
     70        ay[1] = ax[0] * ax[1];
     71
     72        // create f: x -> y and stop tape recording
     73        CppAD::ADFun<double> f(ax, ay);
    7474
    7575        // sparsity pattern for the identity matrix
     
    127127        // domain space vector
    128128        size_t n = 3;
    129         CPPAD_TESTVECTOR(AD<double>) X(n);
    130         X[0] = 0.;
    131         X[1] = 1.;
    132         X[2] = 2.;
     129        CPPAD_TESTVECTOR(AD<double>) ax(n);
     130        ax[0] = 0.;
     131        ax[1] = 1.;
     132        ax[2] = 2.;
    133133
    134134        // declare independent variables and start recording
    135         CppAD::Independent(X);
     135        CppAD::Independent(ax);
    136136
    137137        // range space vector
    138138        size_t m = 2;
    139         CPPAD_TESTVECTOR(AD<double>) Y(m);
    140         Y[0] = sin( X[2] );
    141         Y[1] = X[0] * X[1];
    142 
    143         // create f: X -> Y and stop tape recording
    144         CppAD::ADFun<double> f(X, Y);
     139        CPPAD_TESTVECTOR(AD<double>) ay(m);
     140        ay[0] = sin( ax[2] );
     141        ay[1] = ax[0] * ax[1];
     142
     143        // create f: x -> y and stop tape recording
     144        CppAD::ADFun<double> f(ax, ay);
    145145
    146146        // sparsity pattern for the identity matrix
     
    204204# include <vector>
    205205# include <valarray>
    206 bool RevSparseHes(void)
     206bool rev_sparse_hes(void)
    207207{       bool ok = true;
    208208        // Run with Vector equal to four different cases
  • trunk/introduction/exp_apx/makefile.in

    r3762 r3793  
    303303cppad_has_nullptr = @cppad_has_nullptr@
    304304cppad_has_rvalue = @cppad_has_rvalue@
    305 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    306305cppad_max_num_threads = @cppad_max_num_threads@
    307306cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/introduction/get_started/makefile.in

    r3762 r3793  
    286286cppad_has_nullptr = @cppad_has_nullptr@
    287287cppad_has_rvalue = @cppad_has_rvalue@
    288 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    289288cppad_max_num_threads = @cppad_max_num_threads@
    290289cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/makefile.am

    r3792 r3793  
    175175        cppad/local/expm1.hpp \
    176176        cppad/local/expm1_op.hpp \
     177        cppad/local/for_hes_sweep.hpp \
    177178        cppad/local/for_jac_sweep.hpp \
    178179        cppad/local/for_one.hpp \
     180        cppad/local/for_sparse_hes.hpp \
    179181        cppad/local/for_sparse_jac.hpp \
    180182        cppad/local/for_two.hpp \
  • trunk/makefile.in

    r3792 r3793  
    357357cppad_has_nullptr = @cppad_has_nullptr@
    358358cppad_has_rvalue = @cppad_has_rvalue@
    359 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    360359cppad_max_num_threads = @cppad_max_num_threads@
    361360cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
     
    408407# $Id$
    409408# -----------------------------------------------------------------------------
    410 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     409# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    411410#
    412411# CppAD is distributed under multiple licenses. This distribution is under
     
    526525        cppad/local/base_double.hpp \
    527526        cppad/local/base_float.hpp \
     527        cppad/local/base_hash.hpp \
    528528        cppad/local/base_limits.hpp \
    529529        cppad/local/base_std_math.hpp \
     
    565565        cppad/local/expm1.hpp \
    566566        cppad/local/expm1_op.hpp \
     567        cppad/local/for_hes_sweep.hpp \
    567568        cppad/local/for_jac_sweep.hpp \
    568569        cppad/local/for_one.hpp \
     570        cppad/local/for_sparse_hes.hpp \
    569571        cppad/local/for_sparse_jac.hpp \
    570572        cppad/local/for_two.hpp \
  • trunk/multi_thread/makefile.in

    r3762 r3793  
    328328cppad_has_nullptr = @cppad_has_nullptr@
    329329cppad_has_rvalue = @cppad_has_rvalue@
    330 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    331330cppad_max_num_threads = @cppad_max_num_threads@
    332331cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/multi_thread/test_multi/makefile.in

    r3762 r3793  
    285285cppad_has_nullptr = @cppad_has_nullptr@
    286286cppad_has_rvalue = @cppad_has_rvalue@
    287 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    288287cppad_max_num_threads = @cppad_max_num_threads@
    289288cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/omh/atomic_base.omh

    r3717 r3793  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4242%ok% = %afun%.for_sparse_jac(%q%, %r%, %s%)
    4343%ok% = %afun%.rev_sparse_jac(%q%, %r%, %s%)
     44%ok% = %afun%.for_sparse_hes(%vx%, %r%, %s%, %h%)
    4445%ok% = %afun%.rev_sparse_hes(%vx%, %s%, %t%, %q%, %r%, %u%, %v%)
    4546atomic_base<%Base%>::clear()%$$
  • trunk/omh/example_list.omh

    r3768 r3793  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    150150$rref forward_order.cpp$$
    151151$rref for_one.cpp$$
     152$rref for_sparse_hes.cpp$$
    152153$rref for_sparse_jac.cpp$$
    153154$rref for_two.cpp$$
  • trunk/omh/install/auto_tools.omh

    r3778 r3793  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    104104        --with-Documentation                     \
    105105        --with-%test%vector                      \
    106         --with-sparse_%option%                   \
    107106        --with-deprecated                        \
    108107        MAX_NUM_THREADS=%max_num_threads%         \
     
    288287$cref/eigen_dir/auto_tools/eigen_dir/$$.
    289288
    290 
    291 $head --with-sparse_option$$
    292 There are two options for the preprocessor symbol
    293 $code CPPAD_INTERNAL_SPARSE_SET$$.
    294 If $code --with-sparse_set$$
    295 ($code --with-sparse_list$$) is specified,
    296 this symbol is $code sparse_set$$ ($code sparse_list$$).
    297 This should affect the speed and memory required by the
    298 $cref sparse_jacobian$$, $cref sparse_hessian$$, and the
    299 $cref/sparse drivers/sparse/$$.
    300 
    301289$head --with-deprecated$$
    302290If this configure argument is present, then all the
  • trunk/omh/install/download.omh

    r3792 r3793  
    9797$rnext
    9898current  $cnext EPL $cnext $href%
    99 http://www.coin-or.org/download/source/CppAD/cppad-20160226.epl.tgz%
    100 cppad-20160226.epl.tgz%$$
     99http://www.coin-or.org/download/source/CppAD/cppad-20160229.epl.tgz%
     100cppad-20160229.epl.tgz%$$
    101101$rnext
    102102current  $cnext GPL $cnext $href%
    103 http://www.coin-or.org/download/source/CppAD/cppad-20160226.gpl.tgz%
    104 cppad-20160226.gpl.tgz%$$
     103http://www.coin-or.org/download/source/CppAD/cppad-20160229.gpl.tgz%
     104cppad-20160229.gpl.tgz%$$
    105105$tend
    106106
  • trunk/omh/whats_new/whats_new_12.omh

    r3792 r3793  
    426426$cref/vector of sets/glossary/Sparsity Pattern/Vector of Sets/$$
    427427sparsity patterns; see the configure
    428 $cref/--with-sparse_option/auto_tools/--with-sparse_option/$$.
     428$code --with-sparse_option$$ (since removed).
    429429$lnext
    430430A new speed test, $cref compare_c$$, compares the speed of the same
  • trunk/omh/whats_new/whats_new_16.omh

    r3792 r3793  
    3434The purpose of these sections is to
    3535assist you in learning about changes between various versions of CppAD.
     36
     37$head 02-29$$
     38Merged sparse into master branch. This makes the
     39$cref ForSparseHes$$ routine available for use.
     40
     41
     42$head 02-28$$
     43Fix a mistake in the atomic
     44$cref/rev_sparse_jac/atomic_sparsity.cpp/rev_sparse_jac/$$ example.
     45To be specific
     46$srccode%cpp%
     47        {       st[ 0 * p + j ] = rt[ 1 * m + j ];
     48                st[ 1 * p + j ] = rt[ 1 * m + j ];
     49                st[ 2 * p + j ] = rt[ 0 * m + j ];
     50        }
     51%$$
     52was changed to
     53$srccode%cpp%
     54        {       st[ 0 * p + j ] = rt[ 1 * p + j ];
     55                st[ 1 * p + j ] = rt[ 1 * p + j ];
     56                st[ 2 * p + j ] = rt[ 0 * p + j ];
     57        }
     58%$$
     59
     60
     61$head 02-27$$
     62The $code --with-sparse_set$$ and $code --with-sparse_set$$ options
     63were removed from the $cref auto_tools$$ install procedure.
    3664
    3765$head 02-26$$
  • trunk/print_for/makefile.in

    r3762 r3793  
    285285cppad_has_nullptr = @cppad_has_nullptr@
    286286cppad_has_rvalue = @cppad_has_rvalue@
    287 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    288287cppad_max_num_threads = @cppad_max_num_threads@
    289288cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/adolc/makefile.in

    r3762 r3793  
    289289cppad_has_nullptr = @cppad_has_nullptr@
    290290cppad_has_rvalue = @cppad_has_rvalue@
    291 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    292291cppad_max_num_threads = @cppad_max_num_threads@
    293292cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/cppad/makefile.in

    r3762 r3793  
    276276cppad_has_nullptr = @cppad_has_nullptr@
    277277cppad_has_rvalue = @cppad_has_rvalue@
    278 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    279278cppad_max_num_threads = @cppad_max_num_threads@
    280279cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/double/makefile.in

    r3762 r3793  
    276276cppad_has_nullptr = @cppad_has_nullptr@
    277277cppad_has_rvalue = @cppad_has_rvalue@
    278 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    279278cppad_max_num_threads = @cppad_max_num_threads@
    280279cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/example/makefile.in

    r3762 r3793  
    292292cppad_has_nullptr = @cppad_has_nullptr@
    293293cppad_has_rvalue = @cppad_has_rvalue@
    294 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    295294cppad_max_num_threads = @cppad_max_num_threads@
    296295cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/fadbad/makefile.in

    r3762 r3793  
    277277cppad_has_nullptr = @cppad_has_nullptr@
    278278cppad_has_rvalue = @cppad_has_rvalue@
    279 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    280279cppad_max_num_threads = @cppad_max_num_threads@
    281280cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/profile/makefile.in

    r3762 r3793  
    280280cppad_has_nullptr = @cppad_has_nullptr@
    281281cppad_has_rvalue = @cppad_has_rvalue@
    282 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    283282cppad_max_num_threads = @cppad_max_num_threads@
    284283cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/sacado/makefile.in

    r3762 r3793  
    277277cppad_has_nullptr = @cppad_has_nullptr@
    278278cppad_has_rvalue = @cppad_has_rvalue@
    279 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    280279cppad_max_num_threads = @cppad_max_num_threads@
    281280cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/speed/src/makefile.in

    r3762 r3793  
    295295cppad_has_nullptr = @cppad_has_nullptr@
    296296cppad_has_rvalue = @cppad_has_rvalue@
    297 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    298297cppad_max_num_threads = @cppad_max_num_threads@
    299298cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/test_more/CMakeLists.txt

    r3791 r3793  
    9999        extern_value.cpp
    100100        for_hess.cpp
     101        for_sparse_hes.cpp
    101102        for_sparse_jac.cpp
    102103        forward.cpp
     
    105106        from_base.cpp
    106107        fun_check.cpp
     108        hes_sparsity.cpp
    107109        jacobian.cpp
    108110        num_limits.cpp
     
    131133        runge_45.cpp
    132134        reverse.cpp
    133         rev_sparse_hes.cpp
    134135        rev_sparse_jac.cpp
    135136        rev_two.cpp
  • trunk/test_more/makefile.am

    r3769 r3793  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    125125        extern_value.hpp \
    126126        for_hess.cpp \
     127        for_sparse_hes.cpp \
    127128        for_sparse_jac.cpp \
    128129        forward.cpp \
     
    131132        from_base.cpp \
    132133        fun_check.cpp \
     134        hes_sparsity.cpp \
    133135        jacobian.cpp \
    134136        num_limits.cpp \
     
    163165        runge_45.cpp \
    164166        reverse.cpp \
    165         rev_sparse_hes.cpp \
    166167        rev_sparse_jac.cpp \
    167168        rev_two.cpp \
  • trunk/test_more/makefile.in

    r3769 r3793  
    386386cppad_has_nullptr = @cppad_has_nullptr@
    387387cppad_has_rvalue = @cppad_has_rvalue@
    388 cppad_internal_sparse_set = @cppad_internal_sparse_set@
    389388cppad_max_num_threads = @cppad_max_num_threads@
    390389cppad_pkgconfig_cflags = @cppad_pkgconfig_cflags@
  • trunk/test_more/test_more.cpp

    r3791 r3793  
    5454extern bool expm1(void);
    5555extern bool ForHess(void);
     56extern bool for_sparse_hes(void);
    5657extern bool for_sparse_jac(void);
    5758extern bool Forward(void);
     
    6061extern bool FromBase(void);
    6162extern bool FunCheck(void);
     63extern bool hes_sparsity(void);
    6264extern bool ipopt_solve(void);
    6365extern bool jacobian(void);
     
    8991extern bool print_for(void);
    9092extern bool reverse(void);
    91 extern bool rev_sparse_hes(void);
    9293extern bool rev_sparse_jac(void);
    9394extern bool RevTwo(void);
     
    185186        ok &= Run( expm1,           "expm1"          );
    186187        ok &= Run( ForHess,         "ForHess"        );
     188        ok &= Run( for_sparse_hes,  "for_sparse_hes" );
    187189        ok &= Run( for_sparse_jac,  "for_sparse_jac" );
    188190        ok &= Run( Forward,         "Forward"        );
     
    191193        ok &= Run( FromBase,        "FromBase"       );
    192194        ok &= Run( FunCheck,        "FunCheck"       );
     195        ok &= Run( hes_sparsity,    "hes_sparsity"   );
    193196        ok &= Run( jacobian,        "jacobian"       );
    194197        ok &= Run( log,             "log"            );
     
    219222        ok &= Run( print_for,       "print_for"      );
    220223        ok &= Run( reverse,         "reverse"        );
    221         ok &= Run( rev_sparse_hes,  "rev_sparse_hes" );
    222224        ok &= Run( rev_sparse_jac,  "rev_sparse_jac" );
    223225        ok &= Run( RevTwo,          "RevTwo"         );
Note: See TracChangeset for help on using the changeset viewer.