Changeset 3987


Ignore:
Timestamp:
Dec 1, 2017 6:09:09 PM (21 months ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 4d661f88400b95784dd62cb3df2be0c802e191d3
end hash code: b69966e04b91c70dee9a792fb6a29885968039a5

commit b69966e04b91c70dee9a792fb6a29885968039a5
Author: Brad Bell <bradbell@…>
Date: Fri Dec 1 16:02:47 2017 -0700

Change codes so 0 = not subset, 1 = one is subset, 2 = two is subset, 3 = equal.

commit 27e68f419c9f6df604051df4e455c37a215dc846
Author: Brad Bell <bradbell@…>
Date: Fri Dec 1 08:05:42 2017 -0700

Add the hold_reverse_memory option to ADFun objects.


check_for_nan.hpp: move implementation of check_for_nan here.
reverse_one.cpp: Chage X -> ax, Y -> ay.

commit b9584032fdcedfe3234b3ad9d93c8a277f84f6f7
Author: Brad Bell <bradbell@…>
Date: Fri Dec 1 03:41:44 2017 -0700

Advance to cppad-20171201.

commit 95e1db364bbc9866ddfae090eaec9fd691be4606
Author: Brad Bell <bradbell@…>
Date: Fri Dec 1 03:39:30 2017 -0700

Merge in change on tmb branch
(use get_argument_variable instead of sparse_list).

commit 9a7b399c2f3dd9389fd5c41116fde4144248f7ce
Author: Brad Bell <bradbell@…>
Date: Thu Nov 30 19:21:20 2017 -0700

If n_set is zero, check that end is also zero.
sparse_sizevec.hpp: Fix bug, post_ not being cleared.

commit 99ab161cf1fc7c8da1feae1d0313b7b4d6a4ebb4
Author: Brad Bell <bradbell@…>
Date: Thu Nov 30 06:21:34 2017 -0700

version.sh: No longer necessary to modify download.omh file.

commit e1e5a91b21bf0cf0aac57f9d087351c66b0b60f1
Author: Brad Bell <bradbell@…>
Date: Thu Nov 30 06:08:33 2017 -0700

Edit download instructions.

commit 06981550126a721c08cd625858f0da1c91c17435
Author: Brad Bell <bradbell@…>
Date: Thu Nov 30 04:34:40 2017 -0700

Advance to cppad-20171130.

commit e9747abeeb42ffc04a6360261b8b75c40df72f3a
Author: Brad Bell <bradbell@…>
Date: Thu Nov 30 04:32:03 2017 -0700

Backout previous commint; i.e., in subgraph change sparse_sizevec to sparse_list.

commit 14fa41a4abb874806358476ff4f61a0653037c2f
Author: Brad Bell <bradbell@…>
Date: Wed Nov 29 06:52:21 2017 -0700

In subgraph routines, replace sparse_list by sparse_sizevec.

commit 223767465bd944a22aa98b5613b66fb63d99d49a
Author: Brad Bell <bradbell@…>
Date: Wed Nov 29 04:04:45 2017 -0700

Advance to cppad-20171129.

commit 6433c25fc309a42a76da4d5270ad90d6aeb1899e
Author: Brad Bell <bradbell@…>
Date: Wed Nov 29 04:04:00 2017 -0700

Improve definition of vector_of_sets concept.
sparse_sizevec.hpp: imporve speed of is_element.

commit 879c88d6cde2e5a9fc06d9973b438f6d0a0cb140
Author: Brad Bell <bradbell@…>
Date: Tue Nov 28 06:28:35 2017 -0700

sparse_sizevec.hpp: allow non-empty post in more cases.

commit ff6edf7f2024e2a4a385471848dd43e40038e895
Author: Brad Bell <bradbell@…>
Date: Tue Nov 28 06:07:21 2017 -0700

sparse_sizevec.hpp: working on post_element.

commit 587485ad34d1098e2bc4a897c9df17f69d229d57
Author: Brad Bell <bradbell@…>
Date: Tue Nov 28 04:46:52 2017 -0700

Make assignment operator part of vector_of_sets concept.
sparse_sizevec.hpp: working on adding post_element operation.

commit 46c5ee6719add4553a43b5586b25f0cb9c198e35
Author: Brad Bell <bradbell@…>
Date: Tue Nov 28 03:31:12 2017 -0700

sparse_sizevec.hpp: remove 'Private member function' where clean in doxygen output.

commit 8d4d4056d4b4174f7d1516d56cfd5379c08d862f
Author: Brad Bell <bradbell@…>
Date: Tue Nov 28 03:28:28 2017 -0700

Advance to cppad-20171127.

commit ec199493c142d245c112385d1acb6e26e1fcbc3a
Author: Brad Bell <bradbell@…>
Date: Tue Nov 28 03:27:42 2017 -0700

  1. Check if garbage collection indicated in one place.
  2. Remove 'Private member function' where obvious in doxygen output.

commit 599eda73a12bc620ead00fea9c8898451282840b
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 17:04:01 2017 -0700

sparse_pack.hpp: change index -> i when referring to set index.

commit 50f9cda7e3ba0cf1d21ad6ddfc0b79590d80b057
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 16:59:54 2017 -0700

sparse_list.hpp: change index -> i when referring to set index.

commit 66eec30456c58d5369a788ec73a6fd4347c1c3ca
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 16:56:04 2017 -0700

sparse_sizevec.hpp: change index -> i when referring to a set index.

commit 01d649a4f23df7b93aeda338708a398743cd81c7
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 16:25:48 2017 -0700

sparse_sizevec.hpp: reduce amount of checking (now that its working).

commit e85e007d053e6ab7172a65487d7fb986dfc6dd52
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 10:30:42 2017 -0700

Advance to cppad-20171127.

commit 14237846bb5c28a89d8eb1706d00c7224f8ea450
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 10:29:39 2017 -0700

sparse_sizevec.hpp: first version that passes tests.
vector_set.cpp: test sparse_sizevec.

commit 20776b2a4956322e58b071fd18b16f7c46860f97
Author: Brad Bell <bradbell@…>
Date: Mon Nov 27 06:16:43 2017 -0700

sparse_internal.hpp: add sparse_sizevec.hpp.
sparse_list.hpp: number_list_entries->data_used, rename arges to resize, doxygen edits,
sparse_pack.hpp: white space edits.
sparse_sizevec.hpp: Under construction.
makefile.am: add sparse_sizevec.hpp.

commit 2e39f5ca64897ca80160eb482f32cb05e8edc373
Author: Brad Bell <bradbell@…>
Date: Sun Nov 26 04:53:41 2017 -0700

Advance to cppad-20171126.
check_all.sh: incude command in check_all.err.
sparse_list.hpp: fix bug in previous commit.

commit a14a100a497e3e0db119f162d29edb08cdcccead
Author: Brad Bell <bradbell@…>
Date: Sun Nov 26 04:50:31 2017 -0700

sparse_internal.hpp: more use set[i] = set[i] union vector.

commit 91940f2d75383e64186e8300761b9206f7f64542
Author: Brad Bell <bradbell@…>
Date: Sat Nov 25 05:19:02 2017 -0700

sparse_internal.hpp: more use set[i] = set[i] union vector.

commit fb30c8193510db5a1799c6fb7d441e7cd6d40b9d
Author: Brad Bell <bradbell@…>
Date: Sat Nov 25 05:15:38 2017 -0700

sparse_internal.hpp: more use set[i] = set[i] union vector.

commit cd01c7cd5726d0e535b3f4c2b5955d3b602c5fd7
Author: Brad Bell <bradbell@…>
Date: Sat Nov 25 05:12:17 2017 -0700

sparse_internal.hpp: use set[i] = set[i] union vector.

commit c5a55874bdf7080f1b4e6b75eeba1e4c332842a2
Author: Brad Bell <bradbell@…>
Date: Sat Nov 25 04:59:42 2017 -0700

Detect subset case and avoid deep copy of set (when not necessary).

commit 5d61d6331b6228c633e5ec47560581db41ee59c8
Author: Brad Bell <bradbell@…>
Date: Sat Nov 25 04:23:22 2017 -0700

Advance to cppad-20171125.

commit 0c820af50cca16381a5769193e8060c2dab9d7a0
Author: Brad Bell <bradbell@…>
Date: Sat Nov 25 04:21:49 2017 -0700

Change set[i] = vector -> set[i] = set[j] union vector.

commit c7cb1aacf0f820b73b83ed819722740d07dcaaab
Author: Brad Bell <bradbell@…>
Date: Fri Nov 24 05:11:18 2017 -0700

Advance to cppad-20171124.

commit df1a220b26c9630ca41d59f76a7897b5e593ecfb
Author: Brad Bell <bradbell@…>
Date: Fri Nov 24 05:10:00 2017 -0700

For speed, add assignment of set[i] = vector where vector is sorted.

commit 12c2390e751807cf5ba59c1f1c2b2a3bed3a9256
Author: Brad Bell <bradbell@…>
Date: Fri Nov 24 04:20:07 2017 -0700

new_release.sh: advance to cppad-20170000.8

commit 6e10e75233a49f13f5cba66e0856554ef11aaad8
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 18:57:56 2017 -0700

fix bug in optimizer.
match_op.hpp: only variables were checked on hash code match.
optimize.cpp: test that demonstrates the bug.

commit a2e45fbe145633138de8a1d5571778b09dd2941d
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 17:49:34 2017 -0700

optimize.sh: simpler case that demonstrates bug.

commit 1420d1f71439a4f6344cf77df7c1b94f4c8f8aa2
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 16:23:09 2017 -0700

Check that bin/run_cmake.sh has been run.
optimize.sh: More isolation of the problem.

commit 82bd3df0096f4deb2dd6ee5f5d76b74f9872cbaa
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 11:59:50 2017 -0700

optimize.sh: a simpler case.

commit c75dc9ee72805c4ba21480447f4407266b7643c9
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 06:28:41 2017 -0700

optimize.sh: fix exact size where test starts failing.
optimize.hpp: more information when optimizer check fails.

commit 08b89a51781260072cf991e84c8fc527e1412d66
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 05:30:46 2017 -0700

Move bug/subgraph.sh -> bug/optimize.sh.

commit a1841898fc1c4234d8197bbebafce559187e6b69
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 05:03:50 2017 -0700

subgraph.sh: test case that is not working in TMB.

commit f198028791815071277930fbcbe5d61b7fa934bc
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 04:21:37 2017 -0700

sparse_list.sh: bug has been fixed (test passes).

commit a57616e308c8630bcc2211102a864fc97fc93ab1
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 04:19:41 2017 -0700

sparse_list.sh: Add expected result to output (bug appears to be fixed).

commit 4376e4aa02e330911aac947346d73cacbb25caac
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 03:43:08 2017 -0700

subgraph.cpp: better naming of test functions.

commit cc48a5245b0a724f7a6842a9fdc9fe4edd8c8f9f
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 03:35:24 2017 -0700

Advance to cppad-20171123.

commit f87aa57f3b4983c5f64394becc2f137d033c689a
Author: Brad Bell <bradbell@…>
Date: Thu Nov 23 03:34:38 2017 -0700

subgraph.cpp: add more testing of CSumOp.

Location:
trunk
Files:
4 added
1 deleted
42 edited

Legend:

Unmodified
Added
Removed
  • trunk/CMakeLists.txt

    r3980 r3987  
    2525#
    2626# cppad_version is used by set_version.sh to get the version number.
    27 SET(cppad_version      "20171122" )
     27SET(cppad_version      "20171201" )
    2828SET(cppad_url          "http://www.coin-or.org/CppAD" )
    2929SET(cppad_description  "Differentiation of C++ Algorithms" )
  • trunk/authors

    r3980 r3987  
    22             ===========================================
    33
    4 To date, 2017-11-22, Bradley M. Bell is the sole author of CppAD.
     4To date, 2017-12-01, 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/bin/check_all.sh

    r3977 r3987  
    2828        echo $*
    2929        echo $* >> $top_srcdir/check_all.log
    30         if ! eval $* >> $top_srcdir/check_all.log 2> $top_srcdir/check_all.err
     30        echo $* >  $top_srcdir/check_all.err
     31        if ! eval $* >> $top_srcdir/check_all.log 2>> $top_srcdir/check_all.err
    3132        then
    3233                cat $top_srcdir/check_all.err
     
    3435                exit 1
    3536        fi
    36         msg=`cat $top_srcdir/check_all.err`
    37         if [ "$msg" != '' ]
     37        count=`wc -l $top_srcdir/check_all.err | sed -e 's|\([0-9]*\) .*|\1|'`
     38        if [ "$count" != '1' ]
    3839        then
    39                 echo "$msg"
     40                cat "$top_srcdir/check_all.err"
    4041                echo 'Warning: see check_all.err'
    4142                exit 1
  • trunk/bin/new_release.sh

    r3957 r3987  
    2323svn_repo="https://projects.coin-or.org/svn/CppAD"
    2424stable_version="20170000" # start each stable_version at yyyy0000
    25 release='7'               # first release for each stable version is 0
     25release='8'               # first release for each stable version is 0
    2626# -----------------------------------------------------------------------------
    2727branch=`git branch | grep '^\*'`
  • trunk/bin/version.sh

    r3921 r3987  
    8989list='
    9090        omh/install/autotools.omh
    91         omh/install/download.omh
    9291        doc.omh
    9392'
     
    9594do
    9695        sed -e "s/cppad-[0-9]\{8\}\(\.[eg]pl\)/cppad-$version\1/" \
    97                 -e "s/cppad-[0-9]\{8\}\.[0-9]*\(\.[eg]pl\)/cppad-$version\1/" \
    9896                -e "s/cppad-[0-9]\{8\}[0-9.]*\:/cppad-$version:/" \
    9997                -i.old $file
  • trunk/bug/template.sh

    r3719 r3987  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    3131EOF
    3232# -----------------------------------------------------------------------------
     33if [ ! -e ../cppad/configure.hpp ]
     34then
     35        echo
     36        echo 'Cannot find the file cppad/configure.hpp in directory ..'
     37        echo 'Must change into .. directory and run bin/run_cmake.sh'
     38        rm bug.$$
     39        exit 1
     40fi
    3341if [ ! -e build ]
    3442then
  • trunk/configure

    r3980 r3987  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.69 for cppad 20171122.
     3# Generated by GNU Autoconf 2.69 for cppad 20171201.
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    580580PACKAGE_NAME='cppad'
    581581PACKAGE_TARNAME='cppad'
    582 PACKAGE_VERSION='20171122'
    583 PACKAGE_STRING='cppad 20171122'
     582PACKAGE_VERSION='20171201'
     583PACKAGE_STRING='cppad 20171201'
    584584PACKAGE_BUGREPORT='cppad@list.coin-or.org'
    585585PACKAGE_URL=''
     
    13751375  # This message is too long to be a string in the A/UX 3.1 sh.
    13761376  cat <<_ACEOF
    1377 \`configure' configures cppad 20171122 to adapt to many kinds of systems.
     1377\`configure' configures cppad 20171201 to adapt to many kinds of systems.
    13781378
    13791379Usage: $0 [OPTION]... [VAR=VALUE]...
     
    14451445if test -n "$ac_init_help"; then
    14461446  case $ac_init_help in
    1447      short | recursive ) echo "Configuration of cppad 20171122:";;
     1447     short | recursive ) echo "Configuration of cppad 20171201:";;
    14481448   esac
    14491449  cat <<\_ACEOF
     
    15791579if $ac_init_version; then
    15801580  cat <<\_ACEOF
    1581 cppad configure 20171122
     1581cppad configure 20171201
    15821582generated by GNU Autoconf 2.69
    15831583
     
    19521952running configure, to aid debugging if configure makes a mistake.
    19531953
    1954 It was created by cppad $as_me 20171122, which was
     1954It was created by cppad $as_me 20171201, which was
    19551955generated by GNU Autoconf 2.69.  Invocation command line was
    19561956
     
    28422842# Define the identity of the package.
    28432843 PACKAGE='cppad'
    2844  VERSION='20171122'
     2844 VERSION='20171201'
    28452845
    28462846
     
    78257825# values after options handling.
    78267826ac_log="
    7827 This file was extended by cppad $as_me 20171122, which was
     7827This file was extended by cppad $as_me 20171201, which was
    78287828generated by GNU Autoconf 2.69.  Invocation command line was
    78297829
     
    78827882ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
    78837883ac_cs_version="\\
    7884 cppad config.status 20171122
     7884cppad config.status 20171201
    78857885configured by $0, generated by GNU Autoconf 2.69,
    78867886  with options \\"\$ac_cs_config\\"
  • trunk/configure.ac

    r3980 r3987  
    1212dnl Process this file with autoconf to produce a configure script.
    1313dnl   package   version              bug-report
    14 AC_INIT([cppad], [20171122], [cppad@list.coin-or.org])
     14AC_INIT([cppad], [20171201], [cppad@list.coin-or.org])
    1515AM_SILENT_RULES([yes])
    1616
  • trunk/cppad/core/ad_fun.hpp

    r3980 r3987  
    4444        example/abs_normal/abs_normal.omh%
    4545        cppad/core/fun_check.hpp%
    46         cppad/core/check_for_nan.hpp
     46        cppad/core/check_for_nan.hpp%
     47        cppad/core/hold_reverse_memory.hpp
    4748%$$
    4849
     
    7475        bool has_been_optimized_;
    7576
     77        /// Hold onto memory used for reverse mode calculations; i.e., partial_
     78        bool hold_reverse_memory_;
     79
    7680        /// Check for nan's and report message to user (default value is true).
    7781        bool check_for_nan_;
     
    114118        /// results of the forward mode calculations
    115119        local::pod_vector<Base> taylor_;
     120
     121        /// memory used for reverse mode calculations
     122        local::pod_vector<Base> partial_;
    116123
    117124        /// which operations can be conditionally skipped
     
    298305        { }
    299306
    300         /// set value of check_for_nan_
    301         void check_for_nan(bool value)
    302         {       check_for_nan_ = value; }
    303         bool check_for_nan(void) const
    304         {       return check_for_nan_; }
     307        /// set hold_reverse_memory
     308        void hold_reverse_memory(bool value);
     309
     310        /// get hold_reverse_memory
     311        bool hold_reverse_memory(void) const;
     312
     313        /// set check_for_nan
     314        void check_for_nan(bool value);
     315
     316        /// get check_for_nan
     317        bool check_for_nan(void) const;
    305318
    306319        /// assign a new operation sequence
  • trunk/cppad/core/check_for_nan.hpp

    r3928 r3987  
    150150namespace CppAD { // BEGIN_CPPAD_NAMESPACE
    151151
     152/*!
     153Set check_for_nan
     154
     155\param value
     156new value for this flag.
     157*/
     158template <class Base>
     159void ADFun<Base>::check_for_nan(bool value)
     160{       check_for_nan_ = value; }
     161
     162/*!
     163Get check_for_nan
     164
     165\return
     166current value of check_for_nan_.
     167*/
     168template <class Base>
     169bool ADFun<Base>::check_for_nan(void) const
     170{       return check_for_nan_; }
     171
     172/*!
     173Stores a vector in a file when nans occur.
     174
     175\param vec [in]
     176is the vector that is stored.
     177
     178\param [out] file_name
     179is the file where the vector is stored
     180*/
    152181template <class Base>
    153182void put_check_for_nan(const CppAD::vector<Base>& vec, std::string& file_name)
     
    181210}
    182211
     212/*!
     213Gets a vector that was stored by put_check_for_nan.
     214
     215\param vec [out]
     216is the vector that is stored.
     217
     218\param file_name [in]
     219is the file where the vector is stored
     220*/
    183221template <class Base>
    184222void get_check_for_nan(CppAD::vector<Base>& vec, const std::string& file_name)
  • trunk/cppad/core/fun_construct.hpp

    r3980 r3987  
    245245ADFun<Base>::ADFun(void) :
    246246has_been_optimized_(false),
     247hold_reverse_memory_(false),
    247248check_for_nan_(true) ,
    248249compare_change_count_(1),
     
    281282        // size_t objects
    282283        has_been_optimized_        = f.has_been_optimized_;
     284        hold_reverse_memory_       = f.hold_reverse_memory_;
    283285        check_for_nan_             = f.check_for_nan_;
    284286        compare_change_count_      = f.compare_change_count_;
     
    420422
    421423        // ad_fun.hpp member values not set by dependent
    422         check_for_nan_ = true;
     424        hold_reverse_memory_ = false;
     425        check_for_nan_       = true;
    423426
    424427        // allocate memory for one zero order taylor_ coefficient
  • trunk/cppad/core/optimize.hpp

    r3980 r3987  
    288288
    289289                // check results
    290                 Base eps = 10. * CppAD::numeric_limits<Base>::epsilon();
    291                 for(i = 0; i < m; i++) CPPAD_ASSERT_KNOWN(
    292                         abs_geq( eps * max_taylor , check[i] - y[i] ) ,
    293                         "Error during check of f.optimize()."
    294                 );
     290                Base eps99 = Base(99) * CppAD::numeric_limits<Base>::epsilon();
     291                for(i = 0; i < m; i++)
     292                if( ! abs_geq( eps99 * max_taylor , check[i] - y[i] ) )
     293                {       std::string msg = "Error during check of f.optimize().";
     294                        msg += "\neps99 * max_taylor = " + to_string(eps99 * max_taylor);
     295                        msg += "\ncheck[i] = " + to_string(check[i]);
     296                        msg += "\ny[i]     = " + to_string(y[i]);
     297                        CPPAD_ASSERT_KNOWN(
     298                                abs_geq( eps99 * max_taylor , check[i] - y[i] ) ,
     299                                msg.c_str()
     300                        );
     301                }
    295302
    296303                // Erase memory that this calculation was done so NDEBUG gives
  • trunk/cppad/core/reverse.hpp

    r3980 r3987  
    1515# include <algorithm>
    1616# include <cppad/local/pod_vector.hpp>
     17# include <cppad/core/hold_reverse_memory.hpp>
    1718
    1819namespace CppAD { // BEGIN_CPPAD_NAMESPACE
     
    133134        );
    134135
    135         // initialize entire Partial matrix to zero
    136         local::pod_vector<Base> Partial(num_var_tape_ * q);
     136        // initialize entire partial matrix to zero
     137        partial_.resize(num_var_tape_ * q);
    137138        for(i = 0; i < num_var_tape_; i++)
    138139                for(j = 0; j < q; j++)
    139                         Partial[i * q + j] = zero;
     140                        partial_[i * q + j] = zero;
    140141
    141142        // set the dependent variable direction
     
    144145        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_  );
    145146                if( size_t(w.size()) == m )
    146                         Partial[dep_taddr_[i] * q + q - 1] += w[i];
     147                        partial_[dep_taddr_[i] * q + q - 1] += w[i];
    147148                else
    148149                {       for(k = 0; k < q; k++)
    149150                                // ? should use += here, first make test to demonstrate bug
    150                                 Partial[ dep_taddr_[i] * q + k ] = w[i * q + k ];
     151                                partial_[ dep_taddr_[i] * q + k ] = w[i * q + k ];
    151152                }
    152153        }
     
    163164                taylor_.data(),
    164165                q,
    165                 Partial.data(),
     166                partial_.data(),
    166167                cskip_op_.data(),
    167168                load_op_,
     
    183184                {       for(k = 0; k < q; k++)
    184185                                value[j * q + k ] =
    185                                         Partial[ind_taddr_[j] * q + q - 1 - k];
     186                                        partial_[ind_taddr_[j] * q + q - 1 - k];
    186187                }
    187188                else
    188189                {       for(k = 0; k < q; k++)
    189190                                value[j * q + k ] =
    190                                         Partial[ind_taddr_[j] * q + k];
     191                                        partial_[ind_taddr_[j] * q + k];
    191192                }
    192193        }
     
    196197        );
    197198
     199        // check hold_reverse_memory
     200        if( ! hold_reverse_memory_ )
     201                partial_.clear();
     202
    198203        return value;
    199204}
  • trunk/cppad/core/subgraph_reverse.hpp

    r3980 r3987  
    185185        // map_user_op
    186186        if( subgraph_info_.map_user_op().size() == 0 )
    187                 subgraph_info_.set_map_user_op_and_arg_variable(&play_);
     187                subgraph_info_.set_map_user_op(&play_);
    188188        else
    189189        {       CPPAD_ASSERT_UNKNOWN( subgraph_info_.check_map_user_op(&play_) );
     
    314314        */
    315315
    316         // initialize Partial matrix to zero on subgraph
     316        // initialize partial matrix to zero on subgraph
    317317        Base zero(0);
    318         local::pod_vector<Base> Partial(num_var_tape_ * q);
     318        partial_.resize(num_var_tape_ * q);
    319319        for(size_t k = 0; k < subgraph.size(); ++k)
    320320        {
     
    337337                        for(size_t i = j_var; i <= i_var; ++i)
    338338                        {       for(size_t j = 0; j < q; ++j)
    339                                         Partial[i * q + j] = zero;
     339                                        partial_[i * q + j] = zero;
    340340                        }
    341341                }
     
    343343
    344344        // set partial to one for component we are differentiating
    345         Partial[ dep_taddr_[ell] * q + q - 1] = Base(1);
     345        partial_[ dep_taddr_[ell] * q + q - 1] = Base(1);
    346346
    347347        // evaluate the derivatives
     
    357357                taylor_.data(),
    358358                q,
    359                 Partial.data(),
     359                partial_.data(),
    360360                cskip_op_.data(),
    361361                load_op_,
     
    389389                col[c] = j;
    390390                for(size_t k = 0; k < q; k++)
    391                         dw[j * q + k ] = Partial[ind_taddr_[j] * q + k];
     391                        dw[j * q + k ] = partial_[ind_taddr_[j] * q + k];
    392392        }
    393393        //
     
    397397        );
    398398        //
     399
     400        // check hold_reverse_memory
     401        if( ! hold_reverse_memory_ )
     402                partial_.clear();
     403
    399404        return;
    400405}
  • trunk/cppad/local/for_hes_sweep.hpp

    r3980 r3987  
    127127        size_t num_vecad_vec   = play->num_vecad_vec_rec();
    128128        Vector_set vecad_sparse;
    129         vecad_sparse.resize(num_vecad_vec, limit);
    130129        pod_vector<size_t> vecad_ind;
    131130        pod_vector<bool>   vecad_jac;
    132131        if( num_vecad_vec > 0 )
    133132        {       size_t length;
     133                vecad_sparse.resize(num_vecad_vec, limit);
    134134                vecad_ind.extend(num_vecad_ind);
    135135                vecad_jac.extend(num_vecad_vec);
  • trunk/cppad/local/for_jac_sweep.hpp

    r3980 r3987  
    112112        size_t num_vecad_vec   = play->num_vecad_vec_rec();
    113113        Vector_set  vecad_sparsity;
    114         vecad_sparsity.resize(num_vecad_vec, limit);
    115114        pod_vector<size_t> vecad_ind;
    116115        if( num_vecad_vec > 0 )
    117116        {       size_t length;
     117                vecad_sparsity.resize(num_vecad_vec, limit);
    118118                vecad_ind.extend(num_vecad_ind);
    119119                j             = 0;
  • trunk/cppad/local/optimize/get_opt_op_info.hpp

    r3978 r3987  
    320320        size_t end_set = 2 * num_cexp_op;
    321321        //
    322         cexp_set.resize(num_set, end_set);
     322        if( num_set > 0 )
     323                cexp_set.resize(num_set, end_set);
    323324        // -----------------------------------------------------------------------
    324325        //
  • trunk/cppad/local/optimize/match_op.hpp

    r3978 r3987  
    161161                                        }
    162162                                        else match &= arg_match[j] == arg_c[j];
     163                                }
     164                                else
     165                                {       match &= arg_match[j] == arg_c[j];
    163166                                }
    164167                        }
  • trunk/cppad/local/rev_hes_sweep.hpp

    r3980 r3987  
    134134        size_t num_vecad_vec   = play->num_vecad_vec_rec();
    135135        Vector_set vecad_sparse;
    136         vecad_sparse.resize(num_vecad_vec, limit);
    137136        pod_vector<size_t> vecad_ind;
    138137        pod_vector<bool>   vecad_jac;
    139138        if( num_vecad_vec > 0 )
    140139        {       size_t length;
     140                vecad_sparse.resize(num_vecad_vec, limit);
    141141                vecad_ind.extend(num_vecad_ind);
    142142                vecad_jac.extend(num_vecad_vec);
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3980 r3987  
    116116        size_t num_vecad_vec   = play->num_vecad_vec_rec();
    117117        Vector_set  vecad_sparsity;
    118         vecad_sparsity.resize(num_vecad_vec, limit);
    119118        pod_vector<size_t> vecad_ind;
    120119        if( num_vecad_vec > 0 )
    121120        {       size_t length;
     121                vecad_sparsity.resize(num_vecad_vec, limit);
    122122                vecad_ind.extend(num_vecad_ind);
    123123                j             = 0;
  • trunk/cppad/local/sparse_internal.hpp

    r3884 r3987  
    1717# include <cppad/local/sparse_pack.hpp>
    1818# include <cppad/local/sparse_list.hpp>
     19# include <cppad/local/sparse_sizevec.hpp>
    1920
    2021namespace CppAD { namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
     
    125126        const SizeVector& row( pattern_in.row() );
    126127        const SizeVector& col( pattern_in.col() );
    127         size_t nnz = row.size();
    128         for(size_t k = 0; k < nnz; k++)
    129         {       size_t r = row[k];
    130                 size_t c = col[k];
    131                 if( transpose )
    132                         std::swap(r, c);
     128        size_t nnz = pattern_in.nnz();
     129        pod_vector<size_t> internal_row;
     130        if( transpose )
     131        {       CPPAD_ASSERT_UNKNOWN( pattern_in.nr() == nc );
     132                CPPAD_ASSERT_UNKNOWN( pattern_in.nc() == nr );
    133133                //
    134                 size_t i_var = internal_index[r];
    135                 CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
    136                 CPPAD_ASSERT_UNKNOWN( c < nc );
    137                 bool ignore  = zero_empty && i_var == 0;
    138                 if( ! ignore )
    139                         internal_pattern.add_element( internal_index[r], c );
     134                SizeVector col_major = pattern_in.col_major();
     135                size_t k = 0;
     136                while( k < nnz )
     137                {       // this column of pattern_in
     138                        size_t c   = col[ col_major[k] ];
     139                        // length of the column
     140                        size_t len = 0;
     141                        internal_row.resize(0);
     142                        while( k + len < nnz && c == col[ col_major[k + len] ] )
     143                        {       internal_row.push_back( row[ col_major[k + len] ] );
     144                                ++len;
     145                        }
     146                        size_t i_var = internal_index[c];
     147                        CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
     148                        bool ignore  = zero_empty && i_var == 0;
     149                        if( ! ignore )
     150                                internal_pattern.binary_union(i_var, i_var, internal_row);
     151                        //
     152                        CPPAD_ASSERT_UNKNOWN( len > 0 );
     153                        k += len;
     154                }
     155        }
     156        else
     157        {       CPPAD_ASSERT_UNKNOWN( pattern_in.nr() == nr );
     158                CPPAD_ASSERT_UNKNOWN( pattern_in.nc() == nc );
     159                //
     160                SizeVector row_major = pattern_in.row_major();
     161                size_t k = 0;
     162                while( k < nnz )
     163                {       // this row of pattern_in
     164                        size_t r   = row[ row_major[k] ];
     165                        // length of the row
     166                        size_t len = 0;
     167                        internal_row.resize(0);
     168                        while( k + len < nnz && r == row[ row_major[k + len] ] )
     169                        {       internal_row.push_back( col[ row_major[k + len] ] );
     170                                ++len;
     171                        }
     172                        size_t i_var = internal_index[r];
     173                        CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
     174                        bool ignore  = zero_empty && i_var == 0;
     175                        if( ! ignore )
     176                                internal_pattern.binary_union(i_var, i_var, internal_row);
     177                        //
     178                        CPPAD_ASSERT_UNKNOWN( len > 0 );
     179                        k += len;
     180                }
    140181        }
    141182}
     
    150191{       size_t nr = internal_index.size();
    151192        size_t nc = internal_pattern.end();
     193        CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nr * nc );
    152194# ifndef NDEBUG
    153195        CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nr * nc );
     
    157199        }
    158200# endif
    159         for(size_t i = 0; i < nr; i++)
    160         {       for(size_t j = 0; j < nc; j++)
     201        pod_vector<size_t> internal_row;
     202        for(size_t i = 0; i < nr; i++)
     203        {       internal_row.resize(0);
     204                for(size_t j = 0; j < nc; j++)
    161205                {       bool flag = pattern_in[i * nc + j];
    162206                        if( transpose )
    163207                                flag = pattern_in[j * nr + i];
    164208                        if( flag )
    165                         {       size_t i_var = internal_index[i];
    166                                 CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
    167                                 CPPAD_ASSERT_UNKNOWN( j < nc );
    168                                 bool ignore  = zero_empty && i_var == 0;
    169                                 if( ! ignore )
    170                                         internal_pattern.add_element( i_var, j);
    171                         }
    172                 }
     209                                internal_row.push_back(j);
     210                }
     211                size_t i_var = internal_index[i];
     212                CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
     213                bool ignore  = zero_empty && i_var == 0;
     214                if( ! ignore )
     215                        internal_pattern.binary_union(i_var, i_var, internal_row);
    173216        }
    174217        return;
     
    184227{       size_t nr = internal_index.size();
    185228        size_t nc = internal_pattern.end();
     229        CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nr * nc );
    186230# ifndef NDEBUG
    187231        CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nr * nc );
     
    191235        }
    192236# endif
    193         for(size_t i = 0; i < nr; i++)
    194         {       for(size_t j = 0; j < nc; j++)
     237        pod_vector<size_t> internal_row;
     238        for(size_t i = 0; i < nr; i++)
     239        {       internal_row.resize(0);
     240                for(size_t j = 0; j < nc; j++)
    195241                {       bool flag = pattern_in[i * nc + j];
    196242                        if( transpose )
    197243                                flag = pattern_in[j * nr + i];
    198244                        if( flag )
    199                         {       size_t i_var = internal_index[i];
    200                                 CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
    201                                 CPPAD_ASSERT_UNKNOWN( j < nc );
    202                                 bool ignore  = zero_empty && i_var == 0;
    203                                 if( ! ignore )
    204                                         internal_pattern.add_element( i_var, j);
    205                         }
    206                 }
     245                                internal_row.push_back(j);
     246                }
     247                size_t i_var = internal_index[i];
     248                CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
     249                bool ignore  = zero_empty && i_var == 0;
     250                if( ! ignore )
     251                        internal_pattern.binary_union(i_var, i_var, internal_row);
    207252        }
    208253        return;
     
    216261        InternalSparsity&                  internal_pattern ,
    217262        const vector< std::set<size_t> >&  pattern_in       )
    218 {       size_t nr = internal_index.size();
    219         size_t nc = internal_pattern.end();
    220 # ifndef NDEBUG
    221         if( input_empty ) for(size_t i = 0; i < nr; i++)
    222         {       size_t i_var = internal_index[i];
    223                 CPPAD_ASSERT_UNKNOWN( internal_pattern.number_elements(i_var) == 0 );
    224         }
    225 # endif
     263{       // not worried about efficiency with vectors of standard sets
     264        // should use sparse_rc<SizeVector> for efficiency
     265        //
     266        size_t nr = internal_index.size();
     267        size_t nc = internal_pattern.end();
     268        //
     269        // number of non-zeros in pattern_in
     270        size_t nnz = 0;
     271        for(size_t i = 0; i < pattern_in.size(); ++i)
     272                nnz += pattern_in[i].size();
     273        //
     274        // convert pattern_in to a sparse_rc
     275        size_t nr_in = pattern_in.size();
     276        size_t nc_in;
    226277        if( transpose )
    227         {       CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nc );
    228                 for(size_t j = 0; j < nc; j++)
    229                 {       std::set<size_t>::const_iterator itr( pattern_in[j].begin() );
    230                         while( itr != pattern_in[j].end() )
    231                         {       size_t i = *itr;
    232                                 size_t i_var = internal_index[i];
    233                                 CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
    234                                 CPPAD_ASSERT_UNKNOWN( j < nc );
    235                                 bool ignore  = zero_empty && i_var == 0;
    236                                 if( ! ignore )
    237                                         internal_pattern.add_element( i_var, j);
    238                                 ++itr;
    239                         }
    240                 }
     278        {       CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nc )
     279                nc_in = nr;
    241280        }
    242281        else
    243         {       CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nr );
    244                 for(size_t i = 0; i < nr; i++)
    245                 {       std::set<size_t>::const_iterator itr( pattern_in[i].begin() );
    246                         while( itr != pattern_in[i].end() )
    247                         {       size_t j = *itr;
    248                                 size_t i_var = internal_index[i];
    249                                 CPPAD_ASSERT_UNKNOWN( i_var < internal_pattern.n_set() );
    250                                 CPPAD_ASSERT_UNKNOWN( j < nc );
    251                                 bool ignore  = zero_empty && i_var == 0;
    252                                 if( ! ignore )
    253                                         internal_pattern.add_element( i_var, j);
    254                                 ++itr;
    255                         }
    256                 }
    257         }
     282        {       CPPAD_ASSERT_UNKNOWN( pattern_in.size() == nr )
     283                nc_in = nc;
     284        }
     285        sparse_rc< vector<size_t> > pattern_rc(nr_in, nc_in, nnz);
     286        size_t k = 0;
     287        for(size_t i = 0; i < pattern_in.size(); ++i)
     288        {       std::set<size_t>::const_iterator itr( pattern_in[i].begin() );
     289                while( itr != pattern_in[i].end() )
     290                {       size_t j = *itr++;
     291                        pattern_rc.set(k++, i, j);
     292                }
     293        }
     294        set_internal_sparsity(
     295                zero_empty,
     296                input_empty,
     297                transpose,
     298                internal_index,
     299                internal_pattern,
     300                pattern_rc
     301        );
     302        //
    258303        return;
    259304}
  • trunk/cppad/local/sparse_list.hpp

    r3980 r3987  
    2020\file sparse_list.hpp
    2121Vector of sets of positive integers stored as singly linked lists
    22 in with the element values strictly increasing.
     22with the element values strictly increasing.
    2323*/
    2424class sparse_list_const_iterator;
     
    2929linked list.
    3030
    31 All the public member functions for this class are also in the
    32 sparse_pack class. This defines the CppAD vector_of_sets concept.
     31All the public members for this class are also in the
     32sparse_pack and sparse_vecsize classes.
     33This defines the CppAD vector_of_sets concept.
    3334*/
    3435class sparse_list {
     
    4243                size_t value;
    4344
    44                 /// This is the index in data_ of the next entry in the list.
     45                /// This is the data index of the next entry in the list.
    4546                /// If there are no more entries in the list, this value is zero.
    4647                /// (The first entry in data_ is not used.)
     
    5657        size_t data_not_used_;
    5758
    58         /*!
    59         The number of elements in this vector is the number of sets,
    60         which is also the number of singly linked lists.
     59        /// The data for all the singly linked lists.
     60        pod_vector<pair_size_t> data_;
     61
     62        /*!
     63        Starting point for i-th set is start_[i].
    6164
    6265        \li
    6366        If the i-th set has no elements, start_[i] is zero.
     67        Otherwise the conditions below hold.
    6468
    6569        \li
    66         If the i-th set is non-empty, start_[i] is the index in data_
    67         for the first entry in the i-th singly linked list for this set.
    68         In this case and data_[ start_[i] ].value is the reference count
    69         for this list and data_[ start_[i] ].next is not zero because there
     70        data_[ start_[i] ].value is the reference count for this list.
     71
     72        \li
     73        data_[ start_[i] ].next is not zero because there
    7074        is at least one entry in this list.
    7175        */
    7276        pod_vector<size_t> start_;
    7377
    74         /// The data for all the singly linked lists.
    75         pod_vector<pair_size_t> data_;
    76 
    77         // -----------------------------------------------------------------
    78         /*!
    79         Private member functiont that counts references to sets.
    80 
    81         \param index
     78        // -----------------------------------------------------------------
     79        /*!
     80        Counts references to sets.
     81
     82        \param i
    8283        is the index of the set that we are counting the references to.
    8384
    8485        \return
    85         if the set is empty, the return value is empty.
     86        if the set is empty, the return value is zero.
    8687        Otherwise it is the number of sets that share the same linked list
    8788        */
    88         size_t reference_count(size_t index) const
    89         {       size_t ret = start_[index];
     89        size_t reference_count(size_t i) const
     90        {       size_t ret = start_[i];
    9091                if( ret != 0 )
    9192                {       CPPAD_ASSERT_UNKNOWN( data_[ret].value != 0 );
     
    9798        // -----------------------------------------------------------------
    9899        /*!
    99         Member function that checks the number of data elements not used
     100        Checks the number of data elements not used
    100101        (effectively const, but modifies and restores values)
    101102        */
     
    109110                        ref_count[i] = reference_count(i);
    110111
    111                 // count the number of entries in the singly linked lists
    112                 size_t number_list_entries = 0;
    113                 for(size_t i = 0; i < start_.size(); i++)
     112                // count the number of entries in data_ that are used
     113                size_t data_used = 0;
     114                for(size_t i = 0; i < n_set; i++)
    114115                {       size_t start = start_[i];
    115116                        if( start != 0 )
    116                         {       CPPAD_ASSERT_UNKNOWN( data_[start].value > 0 );
    117                                 // decrement the reference counter
     117                        {       // decrement the reference counter
     118                                CPPAD_ASSERT_UNKNOWN( data_[start].value > 0 );
    118119                                data_[start].value--;
    119                                 // copy the list when we hit zero
     120                                //
     121                                // count the entries when find last reference
    120122                                if( data_[start].value == 0 )
    121                                 {       // This should be the last reference to this linked list.
    122                                         // Restore reference count
     123                                {       // restore reference count
    123124                                        data_[start].value = ref_count[i];
    124                                         // count number of entries in this list
    125                                         // (is one more than number in set)
    126                                         number_list_entries += number_elements(i) + 1;
     125
     126                                        // number of data entries used for this set
     127                                        data_used += number_elements(i) + 1;
    127128                                }
    128129                        }
    129130                }
    130131                CPPAD_ASSERT_UNKNOWN(
    131                         number_list_entries + data_not_used_ == data_.size()
     132                        data_used + data_not_used_ == data_.size()
    132133                );
    133134                return;
     
    138139
    139140        \param one_this
    140         is the index in this sparse_list object of the first set.
     141        is the index in this sparse_sizevec object of the first set.
    141142
    142143        \param two_other
    143         is the index in other sparse_list object of the second set.
     144        is the index in other sparse_sizevec object of the second set.
    144145
    145146        \param other
    146         is the other sparse_list object (which may be the same as this
    147         sparse_list object).
     147        is the other sparse_sizevec object which may be the same as this object.
    148148
    149149        \return
    150150        If zero, niether set is a subset of the other.
    151         If one, then the two sets are equal.
    152         If two, then set one is a subset of set two and not equal set two.
    153         If three, then set two is a subset of set one and not equal set one..
     151        If one, then one is a subset of two and they are not equal.
     152        If two, then two is a subset of one and they are not equal.
     153        If three, then the sets are equal.
    154154        */
    155155        size_t is_subset(
     
    170170                        if( start_two == 0 )
    171171                        {       // set two is empty
    172                                 return 1;
    173                         }
    174                         return 2;
     172                                return 3;
     173                        }
     174                        return 1;
    175175                }
    176176                if( start_two == 0 )
    177177                {       // set two is empty and one is not empty
    178                         return 3;
     178                        return 2;
    179179                }
    180180                //
     
    215215                {       if( two_subset )
    216216                        {       // sets are equal
    217                                 return 1;
     217                                return 3;
    218218                        }
    219219                        // one is a subset of two
     220                        return 1;
     221                }
     222                if( two_subset )
     223                {       // two is a subset of one
    220224                        return 2;
    221                 }
    222                 if( two_subset )
    223                 {       // two is a subset of on
    224                         return 3;
    225225                }
    226226                //
     
    230230        // -----------------------------------------------------------------
    231231        /*!
    232         Private member functions that does garbage collection.
    233 
    234         This routine should be called when the number entries in data_
    235         that are not being used is greater that data_.size() / 2.
    236 
    237         Note that the size of data_ should equal the number of entries
    238         in the singly linked lists plust the number of entries in data_
    239         that are not being used. (Note that data_[0] never gets used.)
     232        Does garbage collection when indicated.
     233
     234        This routine should be called when more entries are not being used.
     235        If a significant propotion are not being used, the data structure
     236        will be compacted.
     237
     238        The size of data_ should equal the number of entries used by the sets
     239        plus the number of entries that are not being used data_not_used_.
     240        Note that data_[0] never gets used.
    240241        */
    241242        void collect_garbage(void)
    242         {       CPPAD_ASSERT_UNKNOWN( data_not_used_ > data_.size() / 2 );
     243        {       if( data_not_used_ < data_.size() / 2 +  100)
     244                        return;
    243245# ifndef NDEBUG
    244246                check_data_not_used();
     
    248250                size_t n_set  = start_.size();
    249251                //
    250                 // copy the sets to a temporary data vector
     252                // copy the sets to a temporary version of data_
    251253                pod_vector<pair_size_t> data_tmp(1); // data_tmp[0] will not be used
    252254                //
     
    307309        Make a separate copy of the shared list
    308310
    309         \param index
    310         is the index, in the vector of sets, for this list.
    311         */
    312         void separate_copy(size_t index)
    313         {       size_t ref_count = reference_count(index);
     311        \param i
     312        is the index, in the vector of sets, for this set.
     313        */
     314        void separate_copy(size_t i)
     315        {       size_t ref_count = reference_count(i);
    314316                if( ref_count <= 1 )
    315317                        return;
    316318                //
    317                 size_t start = start_[index];
     319                size_t start = start_[i];
    318320                size_t next  = data_[start].next;
    319321                size_t value = data_[next].value;
     
    321323                size_t copy_cur       = data_.extend(2);
    322324                size_t copy_next      = copy_cur + 1;
    323                 start_[index]         = copy_cur;
     325                start_[i]             = copy_cur;
    324326                data_[copy_cur].value = 1;
    325327                data_[copy_cur].next  = copy_next;
     
    347349                //
    348350        }
     351// ===========================================================================
    349352public:
    350         /*!
    351         Assignement operator.
    352 
    353         \param other
    354         this sparse_list with be set to a deep copy of other.
    355 
    356         \par vector_of_sets
    357         This public member function is not yet part of
    358         the vector_of_sets concept. If usefull in this regard,
    359         it needs to be implemented for the spare_pack class.
    360         */
    361         void operator=(const sparse_list& other)
    362         {       end_           = other.end_;
    363                 data_not_used_ = other.data_not_used_;
    364                 start_         = other.start_;
    365                 data_          = other.data_;
    366         }
    367353        /// declare a const iterator
    368354        typedef sparse_list_const_iterator const_iterator;
    369 
    370         // -----------------------------------------------------------------
    371         /*! Default constructor (no sets)
     355        // -----------------------------------------------------------------
     356        /*!
     357        Default constructor (no sets)
    372358        */
    373359        sparse_list(void) :
    374         end_(0)                   ,
    375         data_not_used_(0)
     360        end_(0)            ,
     361        data_not_used_(0)  ,
     362        data_(0)           ,
     363        start_(0)
    376364        { }
    377365        // -----------------------------------------------------------------
     
    384372        }
    385373        // -----------------------------------------------------------------
    386         /*! Using copy constructor is a programing (not user) error
     374        /*!
     375        Using copy constructor is a programing (not user) error
    387376
    388377        \param v
     
    395384        // -----------------------------------------------------------------
    396385        /*!
     386        Assignement operator.
     387
     388        \param other
     389        this sparse_list with be set to a deep copy of other.
     390
     391        \par vector_of_sets
     392        This public member function is not yet part of
     393        the vector_of_sets concept.
     394        */
     395        void operator=(const sparse_list& other)
     396        {       end_           = other.end_;
     397                data_not_used_ = other.data_not_used_;
     398                start_         = other.start_;
     399                data_          = other.data_;
     400        }
     401        // -----------------------------------------------------------------
     402        /*!
    397403        Start a new vector of sets.
    398404
    399         \param n_set_in
     405        \param n_set
    400406        is the number of sets in this vector of sets.
    401407        \li
    402         If n_set_in is zero, any memory currently allocated for this object
    403         is freed. Otherwise, new memory may be allocated for the sets (if needed).
     408        If n_set is zero, any memory currently allocated for this object
     409        is freed.
    404410        \li
    405         If n_set_in is non-zero, a vector of n_set_in is created and all
     411        If n_set is non-zero, a vector of n_set sets is created and all
    406412        the sets are initilaized as empty.
    407413
    408         \param end_in
     414        \param end
    409415        is the maximum element plus one (the minimum element is 0).
    410         */
    411         void resize(size_t n_set_in, size_t end_in)
     416        If n_set is zero, end must also be zero.
     417        */
     418        void resize(size_t n_set, size_t end)
    412419        {
    413420# ifndef NDEBUG
    414421                check_data_not_used();
    415422# endif
    416                 if( n_set_in == 0 )
    417                 {       // restore object to start after constructor
     423                if( n_set == 0 )
     424                {       CPPAD_ASSERT_UNKNOWN( end == 0 );
     425                        //
     426                        // restore object to start after constructor
    418427                        // (no memory allocated for this object)
    419428                        data_.clear();
     
    424433                        return;
    425434                }
    426                 end_                   = end_in;
    427                 //
    428                 start_.resize(n_set_in);
    429                 for(size_t i = 0; i < n_set_in; i++)
     435                end_                   = end;
     436                //
     437                start_.resize(n_set);
     438                for(size_t i = 0; i < n_set; i++)
    430439                        start_[i] = 0;
    431440                //
     
    437446        Count number of elements in a set.
    438447
    439         \param index
     448        \param i
    440449        is the index of the set we are counting the elements of.
    441450        */
    442         size_t number_elements(size_t index) const
    443         {       CPPAD_ASSERT_UNKNOWN(index < start_.size() );
     451        size_t number_elements(size_t i) const
     452        {       CPPAD_ASSERT_UNKNOWN(i < start_.size() );
    444453
    445454                size_t count   = 0;
    446                 size_t start   = start_[index];
     455                size_t start   = start_[i];
    447456
    448457                // check if the set is empty
    449458                if( start == 0 )
    450459                        return count;
    451                 CPPAD_ASSERT_UNKNOWN( reference_count(index) > 0 );
     460                CPPAD_ASSERT_UNKNOWN( reference_count(i) > 0 );
    452461
    453462                // advance to the first element in the set
     
    465474        Add one element to a set.
    466475
    467         \param index
     476        \param i
    468477        is the index for this set in the vector of sets.
    469478
     
    471480        is the element we are adding to the set.
    472481        */
    473         void add_element(size_t index, size_t element)
    474         {       CPPAD_ASSERT_UNKNOWN( index   < start_.size() );
     482        void add_element(size_t i, size_t element)
     483        {       CPPAD_ASSERT_UNKNOWN( i   < start_.size() );
    475484                CPPAD_ASSERT_UNKNOWN( element < end_ );
    476485
    477486                // check if element is already in the set
    478                 if( is_element(index, element) )
     487                if( is_element(i, element) )
    479488                        return;
    480489
    481490                // check for case where starting set is empty
    482                 size_t start = start_[index];
     491                size_t start = start_[i];
    483492                if( start == 0 )
    484493                {       start         = data_.extend(2);
    485                         start_[index] = start;
     494                        start_[i]    = start;
    486495                        size_t next   = start + 1;
    487496                        data_[start].value = 1; // reference count
     
    492501                }
    493502                // make sure that we have a separate copy of this set
    494                 separate_copy(index);
    495                 //
    496                 // start of list with this index (after separate_copy)
    497                 size_t previous = start_[index];
     503                separate_copy(i);
     504                //
     505                // start of set with this index (after separate_copy)
     506                size_t previous = start_[i];
    498507                // check reference count for this list
    499508                CPPAD_ASSERT_UNKNOWN( data_[previous].value == 1 );
     
    522531        check an element is in a set.
    523532
    524         \param index
     533        \param i
    525534        is the index for this set in the vector of sets.
    526535
     
    528537        is the element we are checking to see if it is in the set.
    529538        */
    530         bool is_element(size_t index, size_t element) const
    531         {       CPPAD_ASSERT_UNKNOWN( index   < start_.size() );
     539        bool is_element(size_t i, size_t element) const
     540        {       CPPAD_ASSERT_UNKNOWN( i   < start_.size() );
    532541                CPPAD_ASSERT_UNKNOWN( element < end_ );
    533542                //
    534                 size_t start = start_[index];
     543                size_t start = start_[i];
    535544                if( start == 0 )
    536545                        return false;
     
    551560        }
    552561        // -----------------------------------------------------------------
    553         /*! Assign the empty set to one of the sets.
     562        /*!
     563        Assign the empty set to one of the sets.
    554564
    555565        \param target
     
    584594                        // adjust data_not_used_
    585595                        data_not_used_ += number_delete;
    586 
    587                         if( data_not_used_ > data_.size() / 2 + 100 )
    588                                 collect_garbage();
    589                 }
    590                 //
    591         }
    592         // -----------------------------------------------------------------
    593         /*! Assign one set equal to another set.
     596                        collect_garbage();
     597                }
     598                //
     599        }
     600        // -----------------------------------------------------------------
     601        /*!
     602        Assign one set equal to another set.
    594603
    595604        \param this_target
     
    669678                // adjust data_not_used_
    670679                data_not_used_ += number_delete;
    671 
    672                 // check if time for garbage collection
    673                 if( data_not_used_ > data_.size() / 2 + 100 )
    674                         collect_garbage();
    675         }
    676         // -----------------------------------------------------------------
    677         /*! Assign a set equal to the union of two other sets.
     680                collect_garbage();
     681        }
     682        // -----------------------------------------------------------------
     683        /*!
     684        Assign a set equal to the union of a set and a vector;
     685
     686        \param target
     687        is the index in this sparse_list object of the set being assinged.
     688
     689        \param left
     690        is the index in this sparse_list object of the
     691        left operand for the union operation.
     692        It is OK for target and left to be the same value.
     693
     694        \param right
     695        is a vector of size_t, sorted in accending order.
     696        right operand for the union operation.
     697        Elements can be repeated in right, but are not be repeated in the
     698        resulting set.
     699        All of the elements must have value less than end();
     700        */
     701        void binary_union(
     702                size_t                    target ,
     703                size_t                    left   ,
     704                const pod_vector<size_t>& right  )
     705        {
     706                CPPAD_ASSERT_UNKNOWN( target < start_.size() );
     707                CPPAD_ASSERT_UNKNOWN( left   < start_.size() );
     708
     709                // get start indices before we modify start_ in case target
     710                // and left are the same.
     711                size_t start_target = start_[target];
     712                size_t start_left   = start_[left];
     713
     714                // -------------------------------------------------------------------
     715                // Check if right is a subset of left so that we used reference count
     716                // and not copies of identical sets.
     717                //
     718                // initialize index for left and right sets
     719                size_t current_left  = start_left;
     720                size_t current_right = 0;
     721                //
     722                // initialize value_left
     723                size_t value_left  = end_;
     724                if( current_left > 0 )
     725                {       // advance from reference counter to data
     726                        current_left = data_[current_left].next;
     727                        CPPAD_ASSERT_UNKNOWN( current_left != 0 )
     728                        //
     729                        value_left = data_[current_left].value;
     730                        CPPAD_ASSERT_UNKNOWN( value_left < end_);
     731                }
     732                //
     733                // initialize value_right
     734                size_t value_right = end_;
     735                if( right.size() > 0 )
     736                        value_right = right[current_right];
     737                //
     738                bool subset = true;
     739                while( subset & (value_right < end_) )
     740                {       while( value_left < value_right )
     741                        {       // advance left
     742                                current_left = data_[current_left].next;
     743                                if( current_left == 0 )
     744                                        value_left = end_;
     745                                else
     746                                        value_left = data_[current_left].value;
     747                        }
     748                        if( value_right < value_left )
     749                                subset = false;
     750                        else
     751                        {       // advance right
     752                                ++current_right;
     753                                if( current_right == right.size() )
     754                                        value_right = end_;
     755                                else
     756                                        value_right = right[current_right];
     757                        }
     758                }
     759                //
     760                if( subset )
     761                {       // target = left will use reference count for identical sets
     762                        assignment(target, left, *this);
     763                        return;
     764                }
     765
     766                // -------------------------------------------------------------------
     767                // number of elements that will be deleted by removing old version
     768                // of target
     769                size_t number_delete = 0;
     770                size_t ref_count     = reference_count(target);
     771                //
     772                if( ref_count == 1 )
     773                        number_delete = number_elements(target) + 1;
     774                else if (ref_count > 1 )
     775                {       // decrement reference counter
     776                        CPPAD_ASSERT_UNKNOWN( data_[start_target].value > 1 )
     777                        data_[start_target].value--;
     778                }
     779                //
     780                // start new version of target
     781                size_t start        = data_.extend(1);
     782                start_[target]      = start;
     783                data_[start].value  = 1; // reference count
     784                //
     785                // previous index for new set
     786                size_t previous_target = start;
     787                //
     788                // initialize index for left and right sets
     789                current_left  = start_left;
     790                current_right = 0;
     791                //
     792                // initialize value_left
     793                value_left  = end_;
     794                if( current_left > 0 )
     795                {       // advance from reference counter to data
     796                        current_left = data_[current_left].next;
     797                        CPPAD_ASSERT_UNKNOWN( current_left != 0 )
     798                        //
     799                        value_left = data_[current_left].value;
     800                        CPPAD_ASSERT_UNKNOWN( value_left < end_);
     801                }
     802                //
     803                // initialize value_right
     804                value_right = end_;
     805                if( right.size() > 0 )
     806                        value_right = right[current_right];
     807                //
     808                // merge
     809                while( (value_left < end_) | (value_right < end_) )
     810                {       if( value_left == value_right)
     811                        {       // advance left so left and right are no longer equal
     812                                current_left = data_[current_left].next;
     813                                if( current_left == 0 )
     814                                        value_left = end_;
     815                                else
     816                                        value_left = data_[current_left].value;
     817                                CPPAD_ASSERT_UNKNOWN( value_right < value_left );
     818                        }
     819                        // place to put new element
     820                        size_t current_target       = data_.extend(1);
     821                        data_[previous_target].next = current_target;
     822                        //
     823                        if( value_left < value_right )
     824                        {       // value_left case
     825                                CPPAD_ASSERT_UNKNOWN( value_left < end_ );
     826                                data_[current_target].value = value_left;
     827                                //
     828                                // advance left
     829                                current_left = data_[current_left].next;
     830                                if( current_left == 0 )
     831                                        value_left = end_;
     832                                else
     833                                        value_left = data_[current_left].value;
     834                        }
     835                        else
     836                        {       CPPAD_ASSERT_UNKNOWN( value_right < value_left )
     837                                // value_right case
     838                                CPPAD_ASSERT_UNKNOWN( value_right < end_);
     839                                data_[current_target].value = value_right;
     840                                //
     841                                // advance right (skip values equal to this one)
     842                                size_t previous_value = value_right;
     843                                while( value_right == previous_value )
     844                                {       ++current_right;
     845                                        if( current_right == right.size() )
     846                                                value_right = end_;
     847                                        else
     848                                        {       value_right = right[current_right];
     849                                                CPPAD_ASSERT_UNKNOWN( value_right < end_ );
     850                                        }
     851                                }
     852                        }
     853                        // done setting current target value
     854                        previous_target  = current_target;
     855                }
     856                // make end of target list
     857                data_[previous_target].next = 0;
     858
     859                // adjust data_not_used_
     860                data_not_used_ += number_delete;
     861                collect_garbage();
     862        }
     863        // -----------------------------------------------------------------
     864        /*!
     865        Assign a set equal to the union of two other sets.
    678866
    679867        \param this_target
     
    709897
    710898                // case where right is a subset of left or right and left are equal
    711                 if( subset == 1 || subset == 3 )
     899                if( subset == 2 || subset == 3 )
    712900                {       assignment(this_target, this_left, *this);
    713901                        return;
    714902                }
    715903                // case where the left is a subset of right and they are not equal
    716                 if( subset == 2 )
     904                if( subset == 1 )
    717905                {       assignment(this_target, other_right, other);
    718906                        return;
     
    794982                // adjust data_not_used_
    795983                data_not_used_ += number_delete;
    796 
    797                 if( data_not_used_ > data_.size() / 2 + 100 )
    798                         collect_garbage();
    799         }
    800         // -----------------------------------------------------------------
    801         /*! Assign a set equal to the intersection of two other sets.
     984                collect_garbage();
     985        }
     986        // -----------------------------------------------------------------
     987        /*!
     988        Assign a set equal to the intersection of two other sets.
    802989
    803990        \param this_target
     
    8331020
    8341021                // case where left is a subset of right or left and right are equal
    835                 if( subset == 1 || subset == 2 )
     1022                if( subset == 1 || subset == 3 )
    8361023                {       assignment(this_target, this_left, *this);
    8371024                        return;
    8381025                }
    8391026                // case where the right is a subset of left and they are not equal
    840                 if( subset == 3 )
     1027                if( subset == 2 )
    8411028                {       assignment(this_target, other_right, other);
    8421029                        return;
     
    9251112                // adjust data_not_used_
    9261113                data_not_used_ += number_delete;
    927                 //
    928                 if( data_not_used_ > data_.size() / 2 + 100 )
    929                         collect_garbage();
     1114                collect_garbage();
    9301115        }
    9311116        // -----------------------------------------------------------------
     
    9631148cons_iterator for one set of positive integers in a sparse_list object.
    9641149
    965 All the public member functions for this class are also in the
    966 sparse_pack_const_iterator class.
     1150All the public members for this class are also in the
     1151sparse_pack_const_iterator and sparse_sizevec_const_iterator classes.
    9671152This defines the CppAD vector_of_sets iterator concept.
    9681153*/
     
    9831168public:
    9841169        /// construct a const_iterator for a list in a sparse_list object
    985         sparse_list_const_iterator (const sparse_list& list, size_t index)
     1170        sparse_list_const_iterator (const sparse_list& list, size_t i)
    9861171        :
    9871172        data_( list.data_ )    ,
    9881173        end_ ( list.end_ )
    989         {       CPPAD_ASSERT_UNKNOWN( index < list.start_.size() );
    990                 size_t start = list.start_[index];
     1174        {       CPPAD_ASSERT_UNKNOWN( i < list.start_.size() );
     1175                size_t start = list.start_[i];
    9911176                if( start == 0 )
    9921177                {       next_pair_.next  = 0;
     
    9971182                        CPPAD_ASSERT_UNKNOWN( data_[start].value > 0 );
    9981183
    999                         // index where list truely starts
     1184                        // data index where list truely starts
    10001185                        size_t next = data_[start].next;
    10011186                        CPPAD_ASSERT_UNKNOWN( next != 0 );
  • trunk/cppad/local/sparse_pack.hpp

    r3980 r3987  
    2626Vector of sets of postivie integers, each set stored as a packed boolean array.
    2727
    28 All the public member functions for this class are also in the
    29 sparse_list class. This defines the CppAD vector_of_sets concept.
     28All the public members for this class are also in the
     29sparse_list and sparse_vecsize classes.
     30This defines the CppAD vector_of_sets concept.
    3031*/
    3132
     
    4950        /// Data for all the sets.
    5051        pod_vector<Pack>  data_;
     52// ============================================================================
    5153public:
    5254        /// declare a const iterator
    5355        typedef sparse_pack_const_iterator const_iterator;
    54 
    55         // -----------------------------------------------------------------
    56         /*! Default constructor (no sets)
     56        // -----------------------------------------------------------------
     57        /*!
     58        Default constructor (no sets)
    5759        */
    5860        sparse_pack(void) :
     
    6365        { }
    6466        // -----------------------------------------------------------------
    65         /*! Make use of copy constructor an error
     67        /*!
     68        Make use of copy constructor an error
    6669
    6770        \param v
     
    7578        }
    7679        // -----------------------------------------------------------------
    77         /*! Destructor
     80        /*!
     81        Assignment operator.
     82
     83        \param other
     84        this sparse_pack will be set to a deep copyof other.
     85
     86        */
     87        void operator=(const sparse_pack& other)
     88        {       CPPAD_ASSERT_UNKNOWN( n_bit_  == other.n_bit_);
     89                n_set_  = other.n_set_;
     90                end_    = other.end_;
     91                n_pack_ = other.n_pack_;
     92                data_   = other.data_;
     93        }
     94        // -----------------------------------------------------------------
     95        /*!
     96        Destructor
    7897        */
    7998        ~sparse_pack(void)
    8099        { }
    81100        // -----------------------------------------------------------------
    82         /*! Change number of sets, set end, and initialize all sets as empty
    83 
    84         If \c n_set_in is zero, any memory currently allocated for this object
     101        /*!
     102        Change number of sets, set end, and initialize all sets as empty
     103
     104        If \c n_set is zero, any memory currently allocated for this object
    85105        is freed. Otherwise, new memory may be allocated for the sets (if needed).
    86106
    87         \param n_set_in
     107        \param n_set
    88108        is the number of sets in this vector of sets.
    89109
    90         \param end_in
     110        \param end
    91111        is the maximum element plus one. The minimum element is 0 and
    92112        end must be greater than zero (unless n_set is also zero).
    93         */
    94         void resize(size_t n_set_in, size_t end_in)
    95         {       CPPAD_ASSERT_UNKNOWN( n_set_in == 0 || 0 < end_in );
    96                 n_set_          = n_set_in;
    97                 end_            = end_in;
     113        If n_set is zero, end must also be zero.
     114        */
     115        void resize(size_t n_set, size_t end)
     116        {
     117                n_set_          = n_set;
     118                end_            = end;
    98119                if( n_set_ == 0 )
    99                 {       data_.clear();
     120                {       CPPAD_ASSERT_UNKNOWN( end == 0 );
     121                        data_.clear();
    100122                        return;
    101123                }
     
    114136        Count number of elements in a set.
    115137
    116         \param index
     138        \param i
    117139        is the index in of the set we are counting the elements of.
    118140        */
    119         size_t number_elements(size_t index) const
     141        size_t number_elements(size_t i) const
    120142        {       static Pack one(1);
    121                 CPPAD_ASSERT_UNKNOWN( index < n_set_ );
     143                CPPAD_ASSERT_UNKNOWN( i < n_set_ );
    122144                size_t count  = 0;
    123145                for(size_t k = 0; k < n_pack_; k++)
    124                 {       Pack   unit = data_[ index * n_pack_ + k ];
     146                {       Pack   unit = data_[ i * n_pack_ + k ];
    125147                        Pack   mask = one;
    126148                        size_t n    = std::min(n_bit_, end_ - n_bit_ * k);
     
    135157        }
    136158        // -----------------------------------------------------------------
    137         /*! Add one element to a set.
    138 
    139         \param index
     159        /*!
     160        Add one element to a set.
     161
     162        \param i
    140163        is the index for this set in the vector of sets.
    141164
    142165        \param element
    143166        is the element we are adding to the set.
    144 
    145         \par Checked Assertions
    146         \li index    < n_set_
    147         \li element  < end_
    148         */
    149         void add_element(size_t index, size_t element)
     167        */
     168        void add_element(size_t i, size_t element)
    150169        {       static Pack one(1);
    151                 CPPAD_ASSERT_UNKNOWN( index   < n_set_ );
     170                CPPAD_ASSERT_UNKNOWN( i   < n_set_ );
    152171                CPPAD_ASSERT_UNKNOWN( element < end_ );
    153172                size_t j  = element / n_bit_;
    154173                size_t k  = element - j * n_bit_;
    155174                Pack mask = one << k;
    156                 data_[ index * n_pack_ + j] |= mask;
    157         }
    158         // -----------------------------------------------------------------
    159         /*! Is an element of a set.
    160 
    161         \param index
     175                data_[ i * n_pack_ + j] |= mask;
     176        }
     177        // -----------------------------------------------------------------
     178        /*!
     179        Is an element of a set.
     180
     181        \param i
    162182        is the index for this set in the vector of sets.
    163183
    164184        \param element
    165185        is the element we are checking to see if it is in the set.
    166 
    167         \par Checked Assertions
    168         \li index    < n_set_
    169         \li element  < end_
    170         */
    171         bool is_element(size_t index, size_t element) const
     186        */
     187        bool is_element(size_t i, size_t element) const
    172188        {       static Pack one(1);
    173189                static Pack zero(0);
    174                 CPPAD_ASSERT_UNKNOWN( index   < n_set_ );
     190                CPPAD_ASSERT_UNKNOWN( i   < n_set_ );
    175191                CPPAD_ASSERT_UNKNOWN( element < end_ );
    176192                size_t j  = element / n_bit_;
    177193                size_t k  = element - j * n_bit_;
    178194                Pack mask = one << k;
    179                 return (data_[ index * n_pack_ + j] & mask) != zero;
    180         }
    181         // -----------------------------------------------------------------
    182         /*! Assign the empty set to one of the sets.
     195                return (data_[ i * n_pack_ + j] & mask) != zero;
     196        }
     197        // -----------------------------------------------------------------
     198        /*!
     199        Assign the empty set to one of the sets.
    183200
    184201        \param target
     
    199216        }
    200217        // -----------------------------------------------------------------
    201         /*! Assign one set equal to another set.
     218        /*!
     219        Assign one set equal to another set.
    202220
    203221        \param this_target
     
    231249                        data_[t++] = other.data_[v++];
    232250        }
    233 
    234         // -----------------------------------------------------------------
    235         /*! Assing a set equal to the union of two other sets.
     251        // -----------------------------------------------------------------
     252        /*!
     253        Assign a set equal to the union of a set and a vector;
     254
     255        \param target
     256        is the index in this sparse_list object of the set being assinged.
     257
     258        \param left
     259        is the index in this sparse_list object of the
     260        left operand for the union operation.
     261        It is OK for target and left to be the same value.
     262
     263        \param right
     264        is a vector of size_t, sorted in accending order.
     265        right operand for the union operation.
     266        Elements can be repeated in right, but are not be repeated in the
     267        resulting set.
     268        All of the elements must have value less than end();
     269        */
     270        void binary_union(
     271                size_t                    target ,
     272                size_t                    left   ,
     273                const pod_vector<size_t>& right  )
     274        {
     275                // initialize target = left
     276                size_t t = target * n_pack_;
     277                size_t l = left   * n_pack_;
     278                size_t j = n_pack_;
     279                while(j--)
     280                        data_[t++] = data_[l++];
     281
     282                // add the elements in right
     283                for(size_t i = 0; i < right.size(); ++i)
     284                        add_element(target, right[i]);
     285        }
     286        // -----------------------------------------------------------------
     287        /*!
     288        Assing a set equal to the union of two other sets.
    236289
    237290        \param this_target
     
    277330        }
    278331        // -----------------------------------------------------------------
    279         /*! Assing a set equal to the intersection of two other sets.
     332        /*!
     333        Assing a set equal to the intersection of two other sets.
    280334
    281335        \param this_target
     
    321375        }
    322376        // -----------------------------------------------------------------
    323         /*! Fetch n_set for vector of sets object.
     377        /*!
     378        Fetch n_set for vector of sets object.
    324379
    325380        \return
     
    329384        {       return n_set_; }
    330385        // -----------------------------------------------------------------
    331         /*! Fetch end for this vector of sets object.
     386        /*!
     387        Fetch end for this vector of sets object.
    332388
    333389        \return
     
    337393        {       return end_; }
    338394        // -----------------------------------------------------------------
    339         /*! Amount of memory used by this vector of sets
     395        /*!
     396        Amount of memory used by this vector of sets
    340397
    341398        \return
     
    354411cons_iterator for one set of positive integers in a sparse_pack object.
    355412
    356 All the public member functions for this class are also in the
    357 sparse_list_const_iterator class.
     413All the public members for this class are also in the
     414sparse_list_const_iterator and sparse_sizevec_const_iterator classes.
    358415This defines the CppAD vector_of_sets iterator concept.
    359416*/
     
    376433
    377434        /// index of this set in the vector of sets;
    378         const size_t             index_;
     435        const size_t             set_index_;
    379436
    380437        /// value of the next element in this set
     
    383440public:
    384441        /// construct a const_iterator for a set in a sparse_pack object
    385         sparse_pack_const_iterator (const sparse_pack& pack, size_t index)
     442        sparse_pack_const_iterator (const sparse_pack& pack, size_t set_index)
    386443        :
    387         data_      ( pack.data_ )         ,
    388         n_bit_     ( pack.n_bit_ )        ,
    389         n_pack_    ( pack.n_pack_ )       ,
    390         end_       ( pack.end_ )          ,
    391         index_     ( index )
     444        data_          ( pack.data_ )         ,
     445        n_bit_         ( pack.n_bit_ )        ,
     446        n_pack_        ( pack.n_pack_ )       ,
     447        end_           ( pack.end_ )          ,
     448        set_index_     ( set_index )
    392449        {       static Pack one(1);
    393                 CPPAD_ASSERT_UNKNOWN( index < pack.n_set_ );
     450                CPPAD_ASSERT_UNKNOWN( set_index_ < pack.n_set_ );
    394451                //
    395452                next_element_ = 0;
    396453                if( next_element_ < end_ )
    397                 {       Pack check = data_[ index_ * n_pack_ + 0 ];
     454                {       Pack check = data_[ set_index_ * n_pack_ + 0 ];
    398455                        if( check & one )
    399456                                return;
     
    425482
    426483                // start search at this packed value
    427                 Pack check = data_[ index_ * n_pack_ + j ];
     484                Pack check = data_[ set_index_ * n_pack_ + j ];
    428485                //
    429486                while( true )
     
    450507                                j++;
    451508                                CPPAD_ASSERT_UNKNOWN( j < n_pack_ );
    452                                 check = data_[ index_ * n_pack_ + j ];
     509                                check = data_[ set_index_ * n_pack_ + j ];
    453510                        }
    454511                }
  • trunk/cppad/local/subgraph/get_rev.hpp

    r3980 r3987  
    8989{       // check sizes
    9090        CPPAD_ASSERT_UNKNOWN( map_user_op_.size()   == n_op_ );
    91         CPPAD_ASSERT_UNKNOWN( arg_variable_.n_set() == n_op_ );
    92         CPPAD_ASSERT_UNKNOWN( arg_variable_.end()   == n_var_ );
    9391
    9492        // process_range_
     
    120118        }
    121119
     120        // space used to return set of arguments that are variables
     121        pod_vector<size_t> argument_variable;
     122
     123        // temporary space used by get_argument_variable
     124        pod_vector<bool> work;
     125
    122126        // scan all the operators in this subgraph
    123127        size_t sub_index = 0;
     
    134138                //
    135139                // which variables are connected to this operator
    136                 sparse_list::const_iterator itr(arg_variable_, i_op);
    137                 size_t j_var = *itr;
    138                 while( j_var < n_var_ )
     140                get_argument_variable(play, i_op, argument_variable, work);
     141                for(size_t j = 0; j < argument_variable.size(); ++j)
    139142                {       // add the corresponding operators to the subgraph
     143                        size_t j_var = argument_variable[j];
    140144                        size_t j_op  = play->var2op(j_var);
    141145                        j_op         = map_user_op_[j_op];
     
    150154                                in_subgraph_[j_op] = i_dep;
    151155                        }
    152                         j_var = *(++itr);
    153156                }
    154157                // we are done scaning this subgraph operator
  • trunk/cppad/local/subgraph/info.hpp

    r3980 r3987  
    4444
    4545        // -----------------------------------------------------------------------
    46         // private member data set by set_map_user_op_and_arg_variable
     46        // private member data set by set_map_user_op
    4747        // -----------------------------------------------------------------------
    4848
     
    5252        pod_vector<addr_t> map_user_op_;
    5353
    54         /// Mapping operator to variables that are arguments to the operator.
    55         /// (size (0,0) after construtor or resize)
    56         sparse_list arg_variable_;
    57 
    5854        // -----------------------------------------------------------------------
    5955        // other private member data
     
    9894        const pod_vector<addr_t>& map_user_op(void) const
    9995        {       return map_user_op_; }
    100 
    101         /// arguments that are variables as a function of operator index
    102         const sparse_list& arg_variable(void) const
    103         {       return arg_variable_; }
    10496
    10597        /// previous select_domain argument to init_rev
     
    118110                sum       += map_user_op_.size()  * sizeof(addr_t);
    119111                sum       += in_subgraph_.size()  * sizeof(addr_t);
    120                 sum       += arg_variable_.memory();
    121112                return sum;
    122113        }
     
    130121        \return
    131122        is true, if map_user_op has the correct value for this operation sequence
    132         (is the same as it would be after a set_map_user_op_and_arg_variable).
     123        (is the same as it would be after a set_map_user_op).
    133124        */
    134125        template <typename Base>
     
    171162        {       CPPAD_ASSERT_UNKNOWN( entire_graph_.size()  == 0 );
    172163                CPPAD_ASSERT_UNKNOWN( map_user_op_.size()   == 0 );
    173                 CPPAD_ASSERT_UNKNOWN( arg_variable_.n_set() == 0 );
    174                 CPPAD_ASSERT_UNKNOWN( arg_variable_.end()   == 0 );
    175164                CPPAD_ASSERT_UNKNOWN( in_subgraph_.size()   == 0 );
    176165        }
     
    183172                entire_graph_     = info.entire_graph_;
    184173                map_user_op_      = info.map_user_op_;
    185                 arg_variable_     = info.arg_variable_;
    186174                in_subgraph_      = info.in_subgraph_;
    187175                return;
     
    210198        \par map_user_op_
    211199        is resized to zero.
    212 
    213         \par arg_variable_
    214         is resized to (0, 0)
    215200
    216201        \par in_subgraph_
     
    247232                map_user_op_.resize(0);
    248233                //
    249                 // arg_variable_
    250                 arg_variable_.resize(0, 0);
    251                 //
    252234                // in_subgraph_
    253235                in_subgraph_.resize(0);
     
    257239        // -----------------------------------------------------------------------
    258240        /*!
    259         set the value of map_user_op and arg_variable for this operation sequence
     241        set the value of map_user_op for this operation sequence
    260242
    261243        \param play
     
    278260        Otherwise j_op == i_op;
    279261
    280         \par arg_variable_
    281         The size of arg_variable_ must be (0, 0) when this fucntion is called
    282         (which is true after a resize operation).
    283         This function sets its size to (n_op_, n_var_).
    284         For each opeartor, if NumRes(op) > 0, or if it is the first UserOp
    285         in an atomic function call, the corresponding set is the arugments
    286         that are variables for this operator.
    287         If NumRes(op) == 0 and this is not the first UserOp in an atomic fucntion
    288         call, the corresponding set is empty.
    289262        */
    290263        template <typename Base>
    291         void set_map_user_op_and_arg_variable(const player<Base>* play)
     264        void set_map_user_op(const player<Base>* play)
    292265        {       CPPAD_ASSERT_UNKNOWN( map_user_op_.size()   == 0 );
    293                 CPPAD_ASSERT_UNKNOWN( arg_variable_.n_set() == 0 );
    294                 CPPAD_ASSERT_UNKNOWN( arg_variable_.end()   == 0 );
    295266                //
    296267                CPPAD_ASSERT_UNKNOWN( n_op_  == play->num_op_rec() );
    297268                CPPAD_ASSERT_UNKNOWN( n_var_ == play->num_var_rec() );
    298269                //
    299                 // variables that are arguments to a particular operator
    300                 pod_vector<size_t> argument_variable;
    301                 //
    302                 // work space used by get_argument_variable
    303                 pod_vector<bool> work;
    304                 //
    305                 // resize map_user_op_ and arg_variable_
     270                // resize map_user_op_
    306271                map_user_op_.resize(n_op_);
    307                 arg_variable_.resize(n_op_, n_var_);
    308                 //
    309                 // set map_user_op and arg_variable for each operator
     272                //
     273                // set map_user_op for each operator
    310274                for(size_t i_op = 0; i_op < n_op_; ++i_op)
    311275                {       // this operator
     
    315279                        map_user_op_[i_op] = addr_t( i_op );
    316280                        //
    317                         if( NumRes(op) > 0 )
    318                         {       // arg_varable_ for this operator
    319                                 get_argument_variable(play, i_op, argument_variable, work);
    320                                 for(size_t j = 0; j < argument_variable.size(); ++j)
    321                                         arg_variable_.add_element(i_op, argument_variable[j]);
    322                         }
    323281                        if( op == UserOp )
    324282                        {       // first UserOp in an atomic function call sequence
    325                                 // arg_variable_ for this operator
    326                                 get_argument_variable(play, i_op, argument_variable, work);
    327                                 for(size_t j = 0; j < argument_variable.size(); ++j)
    328                                         arg_variable_.add_element(i_op, argument_variable[j]);
    329283                                //
    330284                                // All operators in this atomic call sequence will be
  • trunk/cppad/local/subgraph/init_rev.hpp

    r3980 r3987  
    6969        // check sizes
    7070        CPPAD_ASSERT_UNKNOWN( map_user_op_.size()   == n_op_ );
    71         CPPAD_ASSERT_UNKNOWN( arg_variable_.n_set() == n_op_ );
    72         CPPAD_ASSERT_UNKNOWN( arg_variable_.end()   == n_var_ );
    7371        CPPAD_ASSERT_UNKNOWN( play->num_op_rec()    == n_op_ );
    7472        CPPAD_ASSERT_UNKNOWN( size_t( select_domain.size() ) == n_ind_ );
     
    9088        // set in_subgraph to have proper size
    9189        in_subgraph_.resize(n_op_);
     90
     91        // space used to return set of arguments that are variables
     92        pod_vector<size_t> argument_variable;
     93
     94        // temporary space used by get_argument_variable
     95        pod_vector<bool> work;
    9296
    9397# ifndef NDEBUG
     
    123127                        begin_atomic_call  = not begin_atomic_call;
    124128                        if( begin_atomic_call )
    125                         {       sparse_list::const_iterator itr(arg_variable_, i_op);
    126                                 size_t j_var = *itr;
    127                                 while( j_var < n_var_ )
    128                                 {       size_t j_op  = play->var2op(j_var);
     129                        {       get_argument_variable(play, i_op, argument_variable, work);
     130                                for(size_t j = 0; j < argument_variable.size(); ++j)
     131                                {       size_t j_var = argument_variable[j];
     132                                        size_t j_op  = play->var2op(j_var);
    129133                                        j_op         = map_user_op_[j_op];
    130134                                        CPPAD_ASSERT_UNKNOWN( j_op < i_op );
    131135                                        if( in_subgraph_[j_op] == depend_yes )
    132136                                                in_subgraph_[i_op] =  depend_yes;
    133 
    134                                         j_var = *(++itr);
    135137                                }
    136138                        }
     
    145147                        // Except for UserOp, only include when NumRes(op) > 0.
    146148                        if( NumRes(op) > 0 )
    147                         {       sparse_list::const_iterator itr(arg_variable_, i_op);
    148                                 size_t j_var = *itr;
    149                                 while( j_var < n_var_ )
    150                                 {       size_t j_op  = play->var2op(j_var);
     149                        {       get_argument_variable(play, i_op, argument_variable, work);
     150                                for(size_t j = 0; j < argument_variable.size(); ++j)
     151                                {       size_t j_var = argument_variable[j];
     152                                        size_t j_op  = play->var2op(j_var);
    151153                                        j_op         = map_user_op_[j_op];
    152154                                        CPPAD_ASSERT_UNKNOWN( j_op < i_op );
    153155                                        if( in_subgraph_[j_op] == depend_yes )
    154156                                                in_subgraph_[i_op] =  depend_yes;
    155                                         j_var = *(++itr);
    156157                                }
    157158                        }
  • trunk/cppad/local/subgraph/sparsity.hpp

    r3980 r3987  
    111111        // map_user_op
    112112        if( sub_info.map_user_op().size() == 0 )
    113                 sub_info.set_map_user_op_and_arg_variable(play);
     113                sub_info.set_map_user_op(play);
    114114        else
    115115        {       CPPAD_ASSERT_UNKNOWN( sub_info.check_map_user_op(play) );
  • trunk/doc.omh

    r3980 r3987  
    9191$comment bin/version assumes that : follows cppad version number here$$
    9292$section
    93 cppad-20171122: A Package for Differentiation of C++ Algorithms
     93cppad-20171201: A Package for Differentiation of C++ Algorithms
    9494$$
    9595$mindex AD algorithmic differentiation automatic C++ algorithm derivative CppAD version cppad.hpp$$
  • trunk/example/general/CMakeLists.txt

    r3941 r3987  
    8080        hessian.cpp
    8181        hes_times_dir.cpp
     82        hold_reverse_memory.cpp
    8283        independent.cpp
    8384        integer.cpp
  • trunk/example/general/general.cpp

    r3941 r3987  
    9898extern bool Hessian(void);
    9999extern bool HesTimesDir(void);
     100extern bool hold_reverse_memory(void);
    100101extern bool Independent(void);
    101102extern bool Integer(void);
     
    209210        Run( Hessian,           "Hessian"          );
    210211        Run( HesTimesDir,       "HesTimesDir"      );
     212        Run( hold_reverse_memory, "hold_reverse_memory" );
    211213        Run( Independent,       "Independent"      );
    212214        Run( Integer,           "Integer"          );
  • trunk/example/general/makefile.am

    r3928 r3987  
    124124        hessian.cpp \
    125125        hes_times_dir.cpp \
     126        hold_reverse_memory.cpp \
    126127        independent.cpp \
    127128        integer.cpp \
  • trunk/example/general/reverse_one.cpp

    r3928 r3987  
    3838        // domain space vector
    3939        size_t n = 2;
    40         CPPAD_TESTVECTOR(AD<double>) X(n);
    41         X[0] = 0.;
    42         X[1] = 1.;
     40        CPPAD_TESTVECTOR(AD<double>) ax(n);
     41        ax[0] = 0.;
     42        ax[1] = 1.;
    4343
    4444        // declare independent variables and start recording
    45         CppAD::Independent(X);
     45        CppAD::Independent(ax);
    4646
    4747        // range space vector
    4848        size_t m = 1;
    49         CPPAD_TESTVECTOR(AD<double>) Y(m);
    50         Y[0] = X[0] * X[0] * X[1];
     49        CPPAD_TESTVECTOR(AD<double>) ay(m);
     50        ay[0] = ax[0] * ax[0] * ax[1];
    5151
    52         // create f : X -> Y and stop recording
    53         CppAD::ADFun<double> f(X, Y);
     52        // create f : x -> y and stop recording
     53        CppAD::ADFun<double> f(ax, ay);
    5454
    5555        // use first order reverse mode to evaluate derivative of y[0]
    56         // and use the values in X for the independent variables.
     56        // and use the values in x for the independent variables.
    5757        CPPAD_TESTVECTOR(double) w(m), dw(n);
    5858        w[0] = 1.;
    5959        dw   = f.Reverse(1, w);
    60         ok  &= NearEqual(dw[0] , 2.*X[0]*X[1], eps99, eps99);
    61         ok  &= NearEqual(dw[1] ,    X[0]*X[0], eps99, eps99);
     60        ok  &= NearEqual(dw[0] , 2.*ax[0]*ax[1], eps99, eps99);
     61        ok  &= NearEqual(dw[1] ,    ax[0]*ax[0], eps99, eps99);
    6262
    6363        // use zero order forward mode to evaluate y at x = (3, 4)
  • trunk/makefile.am

    r3980 r3987  
    152152        cppad/core/hash_code.hpp \
    153153        cppad/core/hessian.hpp \
     154        cppad/core/hold_reverse_memory.hpp \
    154155        cppad/core/identical.hpp \
    155156        cppad/core/independent.hpp \
     
    290291        cppad/local/sparse_list.hpp \
    291292        cppad/local/sparse_pack.hpp \
     293        cppad/local/sparse_sizevec.hpp \
    292294        cppad/local/sparse_unary_op.hpp \
    293295        cppad/local/sqrt_op.hpp \
  • trunk/omh/appendix/whats_new/whats_new_12.omh

    r3950 r3987  
    255255$head 11-21$$
    256256$list number$$
    257 Fix the version number in link to the
    258 $cref/current download files/download/Current Version/$$.
     257Fix the
     258$cref/version/download/Version/$$ number in link to the
     259current download files.
    259260$lnext
    260261Change the
  • trunk/omh/appendix/whats_new/whats_new_15.omh

    r3921 r3987  
    8181$head 12-31$$
    8282The $cref download$$ instructions were modified to have more mention of
    83 using $cref/git/download/Current Version/Git/$$ and less mention of
    84 $cref/subversion/download/Current Version/Subversion/$$.
     83using $cref/git/download/Source Code Control/Git/$$ and less mention of
     84$cref/subversion/download/Source Code Control/Subversion/$$.
    8585
    8686$head 12-29$$
  • trunk/omh/appendix/whats_new/whats_new_17.omh

    r3980 r3987  
    5050        subsparsity
    5151        subgraph
     52        optimizer
    5253$$
    5354
     
    5758Speed tests no longer automatically compile in release mode; see
    5859$cref/debug_which/speed/debug_which/$$
     60
     61$head 12-01$$
     62The $cref hold_reverse_memory$$ option was added.
     63
     64$head 11-30$$
     65Edit the $cref download$$ instructions.
     66
     67$head 11-23$$
     68The $code ADFun$$ function $cref/optimizer/optimize/$$
     69was not handling hash code collisions properly.
     70To be specific, only the arguments
     71that were variables where checked for a complete match.
     72The arguments that are constants need to also be checked.
     73This has been fixed.
    5974
    6075$head 11-20$$
  • trunk/omh/example_list.omh

    r3980 r3987  
    184184$rref hessian.cpp$$
    185185$rref hes_times_dir.cpp$$
     186$rref hold_reverse_memory.cpp$$
    186187$rref independent.cpp$$
    187188$rref index_sort.cpp$$
  • trunk/omh/install/autotools.omh

    r3950 r3987  
    6868You must first obtain a copy of the CppAD distribution directory
    6969using the $cref download$$ instructions.
    70 The install instructions below correspond to the
    71 $cref/current version/download/Current Version/$$.
    7270We refer to the corresponding
    7371$cref/distribution directory/download/Distribution Directory/$$ as
  • trunk/omh/install/download.omh

    r3980 r3987  
    1313$escape $$
    1414$spell
     15        yyyy
     16        mm
     17        dd
    1518        vcdir
    1619        vcvarsall
    1720        Microsoft
    18         yyyy
    1921        mkdir
    2022        cmake
     
    5254
    5355$head Distribution Directory$$
    54 We refer to the CppAD source directory created by the download instruction
     56We refer to the CppAD source directory created by the download instructions
    5557below as the distribution directory.
    5658To be specific, the distribution directory contains the file
    5759$code cppad/cppad.hpp$$.
    5860
     61$head Version$$
     62A CppAD $icode version$$ number has the following fields:
     63$icode yyyy$$ is four decimal digits denoting a year,
     64$icode mm$$ is two decimal digits denoting a month,
     65and $icode dd$$ is two decimal digits denoting a day.
     66For example $icode%version% = 20160101%$$ corresponds to January 1, 2016.
     67
     68$head Release$$
     69Special versions corresponding to the beginning of each year
     70have $icode mm$$ and $icode dd$$ equal to zero.
     71These version numbers are combined with release numbers denoted by
     72$icode rel$$.
     73Higher release numbers correspond to more bug fixes.
     74For example
     75$icode%version%.%rel% = 20160000.0%$$ corresponds to the first release
     76of the version for 2016,
     77$code 20160000.1$$ corresponds to the first bug fix for 2016.
     78
     79$head License$$
     80We use $icode lic$$ to denote the licence corresponding to an archived
     81version of CppAD.
     82The GNU General Public License is denoted by $icode%lic% = gpl%$$
     83and the Eclipse Public License is denoted by $icode%lic% = epl%$$.
     84
     85
    5986$head Compressed Archives$$
    60 These files have been archived using $code tar$$ and compressed using
    61 $code gzip$$.
    62 We use $icode version$$ to denote the year, month, and day,
    63 corresponding to a version of the CppAD API.
    64 For example $code 20160101$$ corresponds to January 1, 2016.
    65 We use $icode rel$$ to denote the release number.
    66 Higher release numbers corresponding to more bug fixes.
    67 We use $icode lic$$ to denote the licence corresponding to a compressed
    68 archive which can be either $code epl$$ or $code gpl$$
    69 ($code gpl$$ denotes the GNU General Public License and
    70 $code epl$$ denotes the Eclipse Public License).
    71 The compressed archives names have one of the following formats:
     87The Coin compressed archives have the
     88documentation built into them.
     89If you downloading an old version using another method; see
     90$cref/building documentation/download/Building Documentation/$$.
     91
     92
     93$subhead Coin$$
     94The compressed archive names on the
     95$href%http://www.coin-or.org/download/source/CppAD/%Coin download page%$$
     96have one of the following formats:
    7297$codei%
    7398        cppad-%version%.%rel%.%lic%.tgz
    74         cppad-%version%.%rel%.tgz
    7599        cppad-%version%.%lic%.tgz
    76100%$$
     
    88112%$$
    89113
    90 
    91 $head Current Version$$
    92 
    93 $subhead Compressed Archives$$
    94 $table
    95 $bold version$$ $pre  $$ $cnext $bold license$$ $pre  $$ $cnext $bold link$$
    96 $rnext
    97 current  $cnext EPL $cnext $href%
    98 http://www.coin-or.org/download/source/CppAD/cppad-20171122.epl.tgz%
    99 cppad-20171122.epl.tgz%$$
    100 $rnext
    101 current  $cnext GPL $cnext $href%
    102 http://www.coin-or.org/download/source/CppAD/cppad-20171122.gpl.tgz%
    103 cppad-20171122.gpl.tgz%$$
    104 $tend
     114$subhead Github$$
     115The compressed archive names on the
     116$href%https://github.com/coin-or/CppAD/releases%Github download page%$$
     117have the format
     118$codei%
     119        cppad-%version%.%rel%.tgz
     120%$$
     121These archives correspond to the Eclipse Public License.
     122
     123
     124$head Source Code Control$$
     125These methods only provide the Eclipse Public License
     126version of CppAD.
     127
     128$subhead Git$$
     129CppAD source code development is current done using $code git$$
     130You can a git clone of the current version using the command
     131$codei%
     132    git clone https://github.com/coin-or/CppAD.git cppad.git
     133%$$
     134This procedure requires that
     135the $href|https://en.wikipedia.org/wiki/Git_%28software%29|git|$$
     136is installed on your system.
    105137
    106138$subhead Subversion$$
    107 The archives above correspond to the current subversion
    108 $href%https://projects.coin-or.org/CppAD/browser/trunk%trunk%$$.
    109 You can obtain a subversion copy of the current version using the command
     139A subversion copy of the source code is kept on the Coin web site.
     140You can obtain this subversion copy using the command
    110141$codei%
    111142        svn checkout https://projects.coin-or.org/svn/CppAD/trunk cppad.svn/trunk
     
    115146is installed on your system.
    116147
    117 $subhead Git$$
    118 The archives above correspond to the current git
    119 $href%https://github.com/bradbell/cppad%master%$$.
    120 You can a git clone of the current version using the command
    121 $codei%
    122     git clone https://github.com/coin-or/CppAD.git cppad.git
    123 %$$
    124 This procedure requires that
    125 the $href|https://en.wikipedia.org/wiki/Git_%28software%29|git|$$
    126 is installed on your system.
    127 
    128 
    129 $head Release Versions$$
    130 
    131 $subhead Coin$$
    132 Release versions have the $icode rel$$ field in the compressed archive name.
    133 The release version on the
    134 $href%http://www.coin-or.org/download/source/CppAD/%Coin download page%$$
    135 have the format
    136 $codei%
    137         cppad-%version%.%rel%.%lic%.tgz
    138 %$$
    139 
    140 $subhead github$$
    141 The release versions on the
    142 $href%https://github.com/coin-or/CppAD/releases%github download page%$$
    143 have the format
    144 $codei%
    145         cppad-%version%.%rel%.tgz
    146 %$$
    147148
    148149$head Monthly Versions$$
     
    155156        cppad-%yyyy%0101.%lic%.tgz
    156157%$$
    157 where the license code $icode lic$$
    158 is $code gpl$$ or $code epl$$
    159 and $icode yyyy$$ is the current year.
    160 
    161 $head Daily Versions$$
    162 You can use the git version of the repository to obtain the version
    163 corresponding to a specific day as follows:
    164 $codei%
    165         git clone https://github.com/coin-or/CppAD.git cppad.git
    166         cd cppad.git
    167         git checkout --quiet %hash_id%
    168 %$$
    169 where $icode hash_id$$ is the SHA-1 hash code for the version
    170 of the repository for the day of interest.
    171 Note that a list of these $icode hash_id$$ values can be found at the
    172 CppAD github
    173 $href%https://github.com/coin-or/CppAD/commits/master%commits/master%$$.
    174 page.
    175158
    176159$head Windows File Extraction and Testing$$
     
    229212$head Install Instructions$$
    230213The $cref install$$ instructions on this web site correspond to the
    231 $cref/current version/download/Current Version/$$ of CppAD.
     214current version of CppAD.
    232215If you are using an old version of CppAD
    233216these instructions may work.
     
    236219the $code doc$$ subdirectory of the distribution directory.
    237220If there is no such documentation, you can build it; see
    238 $cref/building documentation
    239         /download
    240         /No Documentation
    241         /Building Documentation
    242 /$$.
    243 
    244 $head No Documentation$$
    245 Some of the download methods do not include documentation.
    246 To be specific, the
    247 $cref/subversion/download/Current Version/Subversion/$$ method,
    248 $cref/git/download/Current Version/Git/$$ method,
    249 $cref/daily version/download/Daily Versions/$$ method, and the
    250 $cref/github release version/download/Release Versions/github/$$ method.
    251 In addition, these methods only provide the
    252 $href%http://opensource.org/licenses/EPL-1.0%EPL licensed%$$
    253 version of CppAD.
    254 
    255 $subhead Building Documentation$$
     221$cref/building documentation/download/Building Documentation/$$.
     222
     223$head Building Documentation$$
    256224If you are using one of these download methods,
    257225you can build the documentation to get the corresponding install instructions.
  • trunk/test_more/general/local/vector_set.cpp

    r3932 r3987  
    2121        size_t n_set = 4;
    2222        size_t end   = 5;
    23         vec_set.resize(n_set, end);
    24         //
     23        //
     24        // set size of vec_set
     25        vec_set.resize(n_set, end);
    2526        ok &= end == vec_set.end();
    2627        ok &= n_set == vec_set.n_set();
     28        //
     29        // test resizing to zero
     30        vec_set.resize(0, 0);
     31        ok &= 0 == vec_set.n_set();
     32        ok &= 0 == vec_set.end();
     33        //
     34        // set size of vec_set
     35        vec_set.resize(n_set, end);
     36        ok &= end == vec_set.end();
     37        ok &= n_set == vec_set.n_set();
     38
    2739        //
    2840        // add the element i+1 to set i
     
    108120        }
    109121        //
    110         // assignment from other
     122        // assignment of one set from other
    111123        size_t target = 0;
    112124        size_t source = 1;
     
    123135        ok &= vec_set.is_element(target, right+1);
    124136        //
     137        // now use assignment for entire vector of sets
     138        vec_set = other_vec;
     139        ok &= ! vec_set.is_element(0, 0);
     140        ok &= ! vec_set.is_element(0, 1);
     141        for(size_t i = 1; i < n_set; i++)
     142        {       ok &= ! vec_set.is_element(i, i);
     143                ok &=   vec_set.is_element(i, i+1);
     144        }
    125145        return ok;
    126146}
     
    173193}
    174194
     195template<class VectorSet>
     196bool test_vector_union(void)
     197{       bool ok = true;
     198        //
     199        VectorSet vec_set;
     200        size_t n_set = 3;
     201        size_t end   = 5;
     202        vec_set.resize(n_set, end);
     203        //
     204        // set[1] = {1, 2}
     205        vec_set.add_element(1, 1);
     206        vec_set.add_element(1, 2);
     207        //
     208        // set[1] = {1, 2} union {2, 4} = {1, 2, 4}
     209        size_t target = 1;
     210        size_t left   = 1;
     211        CppAD::local::pod_vector<size_t> right(3);
     212        right[0] = 2;
     213        right[1] = 4;
     214        right[2] = 4; // repeated element
     215        vec_set.binary_union(target, left, right);
     216        //
     217        typename VectorSet::const_iterator itr1(vec_set, target);
     218        ok &= *itr1     == 1;
     219        ok &= *(++itr1) == 2;
     220        ok &= *(++itr1) == 4;
     221        ok &= *(++itr1) == end;
     222        //
     223        // check case where right is a subset of left
     224        target = 0;
     225        left   = 1;
     226        vec_set.binary_union(target, left, right);
     227        //
     228        typename VectorSet::const_iterator itr2(vec_set, target);
     229        ok &= *itr2     == 1;
     230        ok &= *(++itr2) == 2;
     231        ok &= *(++itr2) == 4;
     232        ok &= *(++itr2) == end;
     233        //
     234        return ok;
     235}
     236
    175237} // END empty namespace
    176238
    177239bool vector_set(void)
    178240{       bool ok = true;
     241
    179242        ok     &= test_no_other<CppAD::local::sparse_pack>();
    180243        ok     &= test_no_other<CppAD::local::sparse_list>();
     244        ok     &= test_no_other<CppAD::local::sparse_sizevec>();
    181245        //
    182246        ok     &= test_yes_other<CppAD::local::sparse_pack>();
    183247        ok     &= test_yes_other<CppAD::local::sparse_list>();
     248        ok     &= test_yes_other<CppAD::local::sparse_sizevec>();
    184249        //
    185250        ok     &= test_intersection<CppAD::local::sparse_pack>();
    186251        ok     &= test_intersection<CppAD::local::sparse_list>();
    187         //
    188         return ok;
    189 }
     252        ok     &= test_intersection<CppAD::local::sparse_sizevec>();
     253        //
     254        ok     &= test_vector_union<CppAD::local::sparse_pack>();
     255        ok     &= test_vector_union<CppAD::local::sparse_list>();
     256        ok     &= test_vector_union<CppAD::local::sparse_sizevec>();
     257        //
     258        return ok;
     259}
  • trunk/test_more/general/optimize.cpp

    r3969 r3987  
    19701970                else
    19711971                        ok &= f.number_skip() == 0;
     1972                //
     1973                return ok;
     1974        }
     1975
     1976        // Test case where only varaible arguments were being checked for
     1977        // a complete match once hash_codes were equal.
     1978        // (*bug fixed 2017-11-23)
     1979        bool only_check_variables_when_hash_codes_match(void)
     1980        {       bool ok = true;
     1981                using CppAD::AD;
     1982                using CppAD::vector;
     1983                //
     1984                double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
     1985                //
     1986                // length of the data vector z
     1987                size_t nz = 9999;
     1988                //
     1989                // factor for last term
     1990                double factor = 1e+5;
     1991                //
     1992                // z starts at -1.0 and ends at 1.0
     1993                vector<double> z(nz);
     1994                for(size_t i = 0; i < nz; i++)
     1995                        z[i] = -1.0 + 2.0 * double(i) / double(nz - 1);
     1996                //
     1997                // f(x) = sum from i=0 to nz-1 of (x - z[i])^2
     1998                vector< AD<double> > ax(1), ay(1);
     1999                ax[0] = 0.0;
     2000                CppAD::Independent(ax);
     2001                AD<double> asum = 0.0;
     2002                for(size_t i = 0; i < nz; i++)
     2003                {       AD<double> aterm = z[i] - ax[0];
     2004                        if( i == nz - 1 )
     2005                                asum += factor * aterm;
     2006                        else
     2007                                asum += aterm / factor;
     2008                }
     2009                ay[0] = asum;
     2010                CppAD::ADFun<double> f(ax, ay);
     2011                //
     2012                // value of x where we are computing derivative
     2013                vector<double> x(1), y_before(1), y_after(1);
     2014                x[0]     = .1;
     2015                y_before = f.Forward(0, x);
     2016                f.optimize();
     2017                y_after  = f.Forward(0, x);
     2018                //
     2019                ok &= CppAD::NearEqual(y_before[0], y_after[0], eps99, eps99);
    19722020                //
    19732021                return ok;
     
    20522100                ok     &= cond_exp_if_false_used_after();
    20532101        }
     2102
     2103        // not using conditional_skip or atomic functions
     2104        ok &= only_check_variables_when_hash_codes_match();
     2105
    20542106        //
    20552107        CppAD::user_atomic<double>::clear();
  • trunk/test_more/general/subgraph.cpp

    r3980 r3987  
    1919        typedef CPPAD_TESTVECTOR(AD<double>) avector;
    2020
     21        // ========================================================================
    2122        // algorithm that will be checkpointed
    2223        void g_algo(const avector& u, avector& v)
     
    2728        // will be a pointer to atomic version of g_algo
    2829        CppAD::checkpoint<double>* atom_g = CPPAD_NULL;
    29 
     30        // ------------------------------------------------------------------------
    3031        // record function
    3132        void record_function(
     
    8182                return;
    8283        }
    83 
    84         // =======================================================================
     84        // ------------------------------------------------------------------------
    8585        bool compare_subgraph_sparsity(
    8686                CppAD::sparse_rc<svector> subgraph  ,
     
    120120
    121121        }
    122         bool subgraph_sparsity(bool optimize)
     122        // ------------------------------------------------------------------------
     123        bool test_subgraph_sparsity(bool optimize)
    123124        {       bool ok = true;
    124125
     
    180181                return ok;
    181182        }
    182         // =======================================================================
     183        // ------------------------------------------------------------------------
    183184        bool compare_subgraph_reverse(
    184185                const CPPAD_TESTVECTOR(size_t)&  col   ,
     
    205206                return ok;
    206207        }
    207 
    208         bool subgraph_reverse(bool optimize)
     208        // ------------------------------------------------------------------------
     209        bool test_subgraph_reverse(bool optimize)
    209210        {       bool ok = true;
    210211
     
    279280                ok &= compare_subgraph_reverse(col, dw, check);
    280281                //
     282                // derivative of y[7] (x[4] is not selected)
     283                for(size_t j = 0; j < n;  ++j)
     284                        check[j] = 1.0;
     285                check[4] = 0.0;
     286                ell = 7;
     287                f.subgraph_reverse(q, ell, col, dw);
     288                ok &= compare_subgraph_reverse(col, dw, check);
     289                //
    281290                return ok;
    282291        }
     
    285294bool subgraph(void)
    286295{       bool ok       = true;
    287         bool optimize = true;
    288         ok           &= subgraph_sparsity(optimize);
    289         ok           &= subgraph_reverse(optimize);
    290         optimize      = false;
    291         ok           &= subgraph_sparsity(optimize);
    292         ok           &= subgraph_reverse(optimize);
     296        bool optimize = false;
     297        ok           &= test_subgraph_sparsity(optimize);
     298        ok           &= test_subgraph_reverse(optimize);
     299        optimize      = true;
     300        ok           &= test_subgraph_sparsity(optimize);
     301        ok           &= test_subgraph_reverse(optimize);
    293302        //
    294303        ok           &= atom_g != CPPAD_NULL;
Note: See TracChangeset for help on using the changeset viewer.