Changeset 3990


Ignore:
Timestamp:
Dec 5, 2017 2:48:42 PM (22 months ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 64a62c68cb15d7edb1dec17315b5043b177abd71
end hash code: c1a6c692c3d1881075fef3b4e30a4ea9afb2efb0

commit c1a6c692c3d1881075fef3b4e30a4ea9afb2efb0
Author: Brad Bell <bradbell@…>
Date: Tue Dec 5 12:17:36 2017 -0700

sparse_list.hpp: separate cases to avoid extra work during add_element.

commit dd90babfa8a67388ebe6d2346e92253d85efe74c
Author: Brad Bell <bradbell@…>
Date: Tue Dec 5 07:27:24 2017 -0700

whats_new_17.omh: user's view of recent changes.

commit 734611c85487d6c011f7046c9c6bc08499b29c06
Author: Brad Bell <bradbell@…>
Date: Tue Dec 5 07:09:49 2017 -0700

sparse_list.hpp: remove garbage collection (now that we are re-using data).

commit e43137cc11bccd2cde284006e37bd3ceb763976b
Author: Brad Bell <bradbell@…>
Date: Tue Dec 5 06:38:13 2017 -0700

sparse_list.hpp: used data_not_used_ to get new data indices.

commit 831107c819c726462a5ad558ff0fd32ac537bf19
Author: Brad Bell <bradbell@…>
Date: Tue Dec 5 05:09:48 2017 -0700

Advance to cppad-20171205.

commit e66edaf862a087d08d113955dd8afbc0ae837ecd
Author: Brad Bell <bradbell@…>
Date: Tue Dec 5 05:09:07 2017 -0700

sparse_list.hpp: add data_not_used_ list (not yet using it).

commit 2735329267744ffe385d1d9a36e1f42c4a3f07a3
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 18:02:16 2017 -0700

sparse_list.hpp: better name for data not being used.

commit 5e9aa8541805b3d20712c958fa01dfad3106a989
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 06:26:23 2017 -0700

TMB tests suggest holding onto memory used subgraph_reverse partial calculations.

commit 237848e83bf854cd23e16c337cdf5c80cc96c8bc
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 06:23:08 2017 -0700

Back out the hold_reverse_memory option.

commit 7978595dbdbaf83716ab77226fcda767729870ee
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 05:24:34 2017 -0700

sparse_list.hpp: Change data_used -> number_used, data_not_used -> number_not_used.

commit 9b146fba0573362e35dcf727d2b075d9f188ef52
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 05:14:10 2017 -0700

for_sparse_hes.hpp: a minor white space edit.

commit 87af59a5040e0534d8484dfe1bf7a06ee5e4afa6
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 04:27:58 2017 -0700

Add comments about why not changing add_element -> post_element.
for_sparse_jac.hpp: use local indices, change add_element -> post_element.

commit b1367372f9b7773bb41c291d625e86a0f4c90751
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 03:03:56 2017 -0700

Advance to cppad-20171204.

commit a78a5a856f4e108c3d6bd4ab7e8c9ad8fbbb31c4
Author: Brad Bell <bradbell@…>
Date: Mon Dec 4 03:01:55 2017 -0700

rev_sparse_jac.hpp: use local indices, change add_element -> post_element.

commit 343da08c22fd2ab95264d88a4e92b42beed9d425
Author: Brad Bell <bradbell@…>
Date: Sun Dec 3 21:45:40 2017 -0700

rev_sparse_hes.hpp: convert add_element -> post_element.

commit a77c313a9d4f7baf6c77a1c2e4986559c5fa96b3
Author: Brad Bell <bradbell@…>
Date: Sun Dec 3 21:20:29 2017 -0700

color_symmetric.hpp: use vector_of_sets concept.

commit d317642dd174005b6880ed6f78bc549710ac7e8a
Author: Brad Bell <bradbell@…>
Date: Sun Dec 3 21:18:05 2017 -0700

color_symmetric.hpp: change indices to be local variables.

commit 3689d4a2acb517eb7586fd23e5634f662d567cbe
Author: Brad Bell <bradbell@…>
Date: Sun Dec 3 20:52:50 2017 -0700

color_general.hpp: convert add_element -> post_element.

commit 8d95c6b2c99697321c3b7b8aeba98f923beb6308
Author: Brad Bell <bradbell@…>
Date: Sun Dec 3 20:32:08 2017 -0700

color_general.hpp: use locally defined indices, vector_of_sets concept.

commit 8897122158e795cce3c5c40c60cfc8ee071f0ec6
Author: Brad Bell <bradbell@…>
Date: Sun Dec 3 19:50:04 2017 -0700

sparse_internal.hpp: convert add_element -> post_element.

Location:
trunk
Files:
2 deleted
27 edited

Legend:

Unmodified
Added
Removed
  • trunk/CMakeLists.txt

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

    r3989 r3990  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.69 for cppad 20171203.
     3# Generated by GNU Autoconf 2.69 for cppad 20171205.
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    580580PACKAGE_NAME='cppad'
    581581PACKAGE_TARNAME='cppad'
    582 PACKAGE_VERSION='20171203'
    583 PACKAGE_STRING='cppad 20171203'
     582PACKAGE_VERSION='20171205'
     583PACKAGE_STRING='cppad 20171205'
    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 20171203 to adapt to many kinds of systems.
     1377\`configure' configures cppad 20171205 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 20171203:";;
     1447     short | recursive ) echo "Configuration of cppad 20171205:";;
    14481448   esac
    14491449  cat <<\_ACEOF
     
    15791579if $ac_init_version; then
    15801580  cat <<\_ACEOF
    1581 cppad configure 20171203
     1581cppad configure 20171205
    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 20171203, which was
     1954It was created by cppad $as_me 20171205, 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='20171203'
     2844 VERSION='20171205'
    28452845
    28462846
     
    78257825# values after options handling.
    78267826ac_log="
    7827 This file was extended by cppad $as_me 20171203, which was
     7827This file was extended by cppad $as_me 20171205, 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 20171203
     7884cppad config.status 20171205
    78857885configured by $0, generated by GNU Autoconf 2.69,
    78867886  with options \\"\$ac_cs_config\\"
  • trunk/configure.ac

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

    r3987 r3990  
    4444        example/abs_normal/abs_normal.omh%
    4545        cppad/core/fun_check.hpp%
    46         cppad/core/check_for_nan.hpp%
    47         cppad/core/hold_reverse_memory.hpp
     46        cppad/core/check_for_nan.hpp
    4847%$$
    4948
     
    7574        bool has_been_optimized_;
    7675
    77         /// Hold onto memory used for reverse mode calculations; i.e., partial_
    78         bool hold_reverse_memory_;
    79 
    8076        /// Check for nan's and report message to user (default value is true).
    8177        bool check_for_nan_;
     
    119115        local::pod_vector<Base> taylor_;
    120116
    121         /// memory used for reverse mode calculations
    122         local::pod_vector<Base> partial_;
     117        /// Memory used for subgraph reverse mode calculations.
     118        /// Declared here to avoid reallocation for each call to subgraph_reverse.
     119        /// Not in subgraph_info_ because it depends on Base.
     120        local::pod_vector<Base> subgraph_partial_;
    123121
    124122        /// which operations can be conditionally skipped
     
    305303        { }
    306304
    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 
    313305        /// set check_for_nan
    314306        void check_for_nan(bool value);
  • trunk/cppad/core/checkpoint.hpp

    r3855 r3990  
    1 // $Id$
    21# ifndef CPPAD_CORE_CHECKPOINT_HPP
    32# define CPPAD_CORE_CHECKPOINT_HPP
    43
    54/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    76
    87CppAD is distributed under multiple licenses. This distribution is under
     
    278277                        identity.resize(n, n);
    279278                        for(size_t j = 0; j < n; j++)
     279                        {       // use add_element because only adding one element per set
    280280                                identity.add_element(j, j);
     281                        }
    281282                        f_.ForSparseJacCheckpoint(
    282283                                n, identity, transpose, dependency, jac_sparse_set_
     
    288289                        identity.resize(m, m);
    289290                        for(size_t i = 0; i < m; i++)
     291                        {       // use add_element because only adding one element per set
    290292                                identity.add_element(i, i);
     293                        }
    291294                        f_.RevSparseJacCheckpoint(
    292295                                m, identity, transpose, dependency, jac_sparse_set_
     
    345348                identity.resize(n, n);
    346349                for(size_t j = 0; j < n; j++)
     350                {       // use add_element because only adding one element per set
    347351                        identity.add_element(j, j);
     352                }
    348353
    349354                // compute sparsity pattern for H(x) = sum_i f_i(x)^{(2)}
  • trunk/cppad/core/for_hes_sparsity.hpp

    r3978 r3990  
    188188                for(size_t j = 0; j < n; j++) if( select_domain[j] )
    189189                {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < n + 1 );
     190                        // use add_element when only adding one element per set
    190191                        internal_for_jac.add_element( ind_taddr_[j] , ind_taddr_[j] );
    191192                }
     
    203204                for(size_t i = 0; i < m; i++) if( select_range[i] )
    204205                {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
     206                        // use add_element when only adding one element per set
    205207                        internal_rev_jac.add_element( dep_taddr_[i] , 0 );
    206208                }
     
    239241                for(size_t j = 0; j < n; j++) if( select_domain[j] )
    240242                {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < n + 1 );
     243                        // use add_element when only adding one element per set
    241244                        internal_for_jac.add_element( ind_taddr_[j] , ind_taddr_[j] );
    242245                }
     
    255258                for(size_t i = 0; i < m; i++) if( select_range[i] )
    256259                {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
     260                        // use add_element when only adding one element per set
    257261                        internal_rev_jac.add_element( dep_taddr_[i] , 0 );
    258262                }
  • trunk/cppad/core/for_sparse_hes.hpp

    r3978 r3990  
    211211                CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[i] ) == local::InvOp );
    212212                //
     213                // Use add_element when only adding one element per set is added.
    213214                if( r[i] )
    214215                        for_jac_pattern.add_element( ind_taddr_[i], ind_taddr_[i] );
     
    228229        for(size_t i = 0; i < m; i++)
    229230        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
     231                //
     232                // Use add_element when only adding one element per set is added.
    230233                if( s[i] )
    231234                        rev_jac_pattern.add_element( dep_taddr_[i], 0);
     
    332335                CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[i] ) == local::InvOp );
    333336                //
     337                // Use add_element when only adding one element per set is added.
    334338                for_jac_pattern.add_element( ind_taddr_[i], ind_taddr_[i] );
    335339        }
     
    355359                );
    356360                CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
     361                //
     362                // Use add_element when only adding one element per set is added.
    357363                rev_jac_pattern.add_element( dep_taddr_[i], 0);
    358364        }
     
    493499        vector<bool>&                 r         ,
    494500        vector<bool>&                 s         ,
    495         local::sparse_list&                  h         )
     501        local::sparse_list&           h         )
    496502{
    497503        size_t n = Domain();
     
    547553                while( i < q )
    548554                {       if( transpose )
    549                                 h.add_element(j,  i);
    550                         else    h.add_element(i, j);
     555                                h.post_element(j,  i);
     556                        else    h.post_element(i, j);
    551557                        i = *(++itr);
    552558                }
    553559        }
     560        // process posts
     561        for(size_t i = 0; i < n; ++i)
     562                h.process_post(i);
    554563}
    555564# endif
  • trunk/cppad/core/for_sparse_jac.hpp

    r3977 r3990  
    272272        s.resize( m * q );
    273273
    274         // temporary indices
    275         size_t i, j;
    276         //
    277274        CPPAD_ASSERT_KNOWN(
    278275                q > 0,
     
    289286
    290287        // set values corresponding to independent variables
    291         for(i = 0; i < n; i++)
     288        for(size_t i = 0; i < n; i++)
    292289        {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[i] < num_var_tape_ );
    293290                // ind_taddr_[i] is operator taddr for i-th independent variable
     
    296293                // set bits that are true
    297294                if( transpose )
    298                 {       for(j = 0; j < q; j++) if( r[ j * n + i ] )
    299                                 for_jac_sparse_pack_.add_element( ind_taddr_[i], j);
     295                {       for(size_t j = 0; j < q; j++) if( r[ j * n + i ] )
     296                                for_jac_sparse_pack_.post_element( ind_taddr_[i], j);
    300297                }
    301298                else
    302                 {       for(j = 0; j < q; j++) if( r[ i * q + j ] )
    303                                 for_jac_sparse_pack_.add_element( ind_taddr_[i], j);
    304                 }
    305         }
     299                {       for(size_t j = 0; j < q; j++) if( r[ i * q + j ] )
     300                                for_jac_sparse_pack_.post_element( ind_taddr_[i], j);
     301                }
     302        }
     303        // process posts
     304        for(size_t j = 0; j < n; j++)
     305                for_jac_sparse_pack_.process_post( ind_taddr_[j] );
    306306
    307307        // evaluate the sparsity patterns
     
    316316        // return values corresponding to dependent variables
    317317        CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == m * q );
    318         for(i = 0; i < m; i++)
     318        for(size_t i = 0; i < m; i++)
    319319        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
    320320
    321321                // extract the result from for_jac_sparse_pack_
    322322                if( transpose )
    323                 {       for(j = 0; j < q; j++)
     323                {       for(size_t j = 0; j < q; j++)
    324324                                s[ j * m + i ] = false;
    325325                }
    326326                else
    327                 {       for(j = 0; j < q; j++)
     327                {       for(size_t j = 0; j < q; j++)
    328328                                s[ i * q + j ] = false;
    329329                }
    330330                CPPAD_ASSERT_UNKNOWN( for_jac_sparse_pack_.end() == q );
    331                 local::sparse_pack::const_iterator itr(for_jac_sparse_pack_, dep_taddr_[i] );
    332                 j = *itr;
     331                local::sparse_pack::const_iterator
     332                        itr(for_jac_sparse_pack_, dep_taddr_[i] );
     333                size_t j = *itr;
    333334                while( j < q )
    334335                {       if( transpose )
     
    388389        else    s.resize( m );
    389390
    390         // temporary indices
    391         size_t i, j;
     391        // temporary iterator
    392392        std::set<size_t>::const_iterator itr_1;
    393         //
     393
    394394        CPPAD_ASSERT_KNOWN(
    395395                q > 0,
     
    410410        // set values corresponding to independent variables
    411411        if( transpose )
    412         {       for(i = 0; i < q; i++)
     412        {       for(size_t i = 0; i < q; i++)
    413413                {       // add the elements that are present
    414414                        itr_1 = r[i].begin();
    415415                        while( itr_1 != r[i].end() )
    416                         {       j = *itr_1++;
     416                        {       size_t j = *itr_1++;
    417417                                CPPAD_ASSERT_KNOWN(
    418418                                j < n,
     
    422422                                CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < num_var_tape_ );
    423423                                // operator for j-th independent variable
    424                                 CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == local::InvOp );
    425                                 for_jac_sparse_set_.add_element( ind_taddr_[j], i);
     424                                CPPAD_ASSERT_UNKNOWN(
     425                                        play_.GetOp( ind_taddr_[j] ) == local::InvOp
     426                                );
     427                                for_jac_sparse_set_.post_element( ind_taddr_[j], i);
    426428                        }
    427429                }
    428430        }
    429431        else
    430         {       for(i = 0; i < n; i++)
     432        {       for(size_t i = 0; i < n; i++)
    431433                {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[i] < num_var_tape_ );
    432434                        // ind_taddr_[i] is operator taddr for i-th independent variable
     
    436438                        itr_1 = r[i].begin();
    437439                        while( itr_1 != r[i].end() )
    438                         {       j = *itr_1++;
     440                        {       size_t j = *itr_1++;
    439441                                CPPAD_ASSERT_KNOWN(
    440442                                        j < q,
     
    442444                                        "has value greater than or equal q."
    443445                                );
    444                                 for_jac_sparse_set_.add_element( ind_taddr_[i], j);
     446                                for_jac_sparse_set_.post_element( ind_taddr_[i], j);
    445447                        }
    446448                }
    447449        }
     450        // process posts
     451        for(size_t j = 0; j < n; j++)
     452                for_jac_sparse_set_.process_post( ind_taddr_[j] );
     453
    448454        // evaluate the sparsity patterns
    449455        local::for_jac_sweep(
     
    458464        CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == m || transpose );
    459465        CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == q || ! transpose );
    460         for(i = 0; i < m; i++)
     466        for(size_t i = 0; i < m; i++)
    461467        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
    462468
     
    464470                // and add corresponding elements to sets in s
    465471                CPPAD_ASSERT_UNKNOWN( for_jac_sparse_set_.end() == q );
    466                 local::sparse_list::const_iterator itr_2(for_jac_sparse_set_, dep_taddr_[i] );
    467                 j = *itr_2;
     472                local::sparse_list::const_iterator
     473                        itr_2(for_jac_sparse_set_, dep_taddr_[i] );
     474                size_t j = *itr_2;
    468475                while( j < q )
    469476                {       if( transpose )
     
    675682                        size_t j = *itr;
    676683                        while( j < n )
    677                         {       for_jac_sparse_set_.add_element( ind_taddr_[j], i );
     684                        {       for_jac_sparse_set_.post_element( ind_taddr_[j], i );
    678685                                j = *(++itr);
    679686                        }
     
    685692                        size_t i = *itr;
    686693                        while( i < q )
    687                         {       for_jac_sparse_set_.add_element( ind_taddr_[j], i );
     694                        {       for_jac_sparse_set_.post_element( ind_taddr_[j], i );
    688695                                i = *(++itr);
    689696                        }
    690697                }
    691698        }
     699        // process posts
     700        for(size_t j = 0; j < n; j++)
     701                for_jac_sparse_set_.process_post( ind_taddr_[j] );
    692702
    693703        // evaluate the sparsity pattern for all variables
     
    712722                // extract the result from for_jac_sparse_set_
    713723                CPPAD_ASSERT_UNKNOWN( for_jac_sparse_set_.end() == q );
    714                 local::sparse_list::const_iterator itr(for_jac_sparse_set_, dep_taddr_[i] );
     724                local::sparse_list::const_iterator
     725                        itr(for_jac_sparse_set_, dep_taddr_[i] );
    715726                size_t j = *itr;
    716727                while( j < q )
    717728                {       if( transpose )
    718                                 s.add_element(j, i);
     729                                s.post_element(j, i);
    719730                        else
    720                                 s.add_element(i, j);
     731                                s.post_element(i, j);
    721732                        j  = *(++itr);
    722733                }
    723734        }
     735        // process posts
     736        for(size_t i = 0; i < s.n_set(); ++i)
     737                s.process_post(i);
    724738
    725739}
  • trunk/cppad/core/fun_construct.hpp

    r3987 r3990  
    245245ADFun<Base>::ADFun(void) :
    246246has_been_optimized_(false),
    247 hold_reverse_memory_(false),
    248247check_for_nan_(true) ,
    249248compare_change_count_(1),
     
    282281        // size_t objects
    283282        has_been_optimized_        = f.has_been_optimized_;
    284         hold_reverse_memory_       = f.hold_reverse_memory_;
    285283        check_for_nan_             = f.check_for_nan_;
    286284        compare_change_count_      = f.compare_change_count_;
     
    422420
    423421        // ad_fun.hpp member values not set by dependent
    424         hold_reverse_memory_ = false;
    425422        check_for_nan_       = true;
    426423
  • trunk/cppad/core/rev_sparse_hes.hpp

    r3978 r3990  
    554554        vector<bool>&                 s         ,
    555555        bool                          transpose ,
    556         local::sparse_list&                  h         )
     556        local::sparse_list&           h         )
    557557{       size_t n = Domain();
    558558        size_t m = Range();
     
    608608                while( i < q )
    609609                {       if( transpose )
    610                                 h.add_element(j,  i);
    611                         else    h.add_element(i, j);
     610                                h.post_element(j,  i);
     611                        else    h.post_element(i, j);
    612612                        i = *(++itr);
    613613                }
    614614        }
     615        for(size_t i = 0; i < h.n_set(); ++i)
     616                h.process_post(i);
    615617}
    616618
  • trunk/cppad/core/rev_sparse_jac.hpp

    r3977 r3990  
    224224        s.resize( q * n );
    225225
    226         // temporary indices
    227         size_t i, j;
    228 
    229226        // check VectorSet is Simple Vector class with bool elements
    230227        CheckSimpleVector<bool, VectorSet>();
     
    245242
    246243        // The sparsity pattern corresponding to the dependent variables
    247         for(i = 0; i < m; i++)
     244        for(size_t i = 0; i < m; i++)
    248245        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
    249246                if( transpose )
    250                 {       for(j = 0; j < q; j++) if( r[ i * q + j ] )
    251                                 var_sparsity.add_element( dep_taddr_[i], j );
     247                {       for(size_t j = 0; j < q; j++) if( r[ i * q + j ] )
     248                                var_sparsity.post_element( dep_taddr_[i], j );
    252249                }
    253250                else
    254                 {       for(j = 0; j < q; j++) if( r[ j * m + i ] )
    255                                 var_sparsity.add_element( dep_taddr_[i], j );
    256                 }
    257         }
     251                {       for(size_t j = 0; j < q; j++) if( r[ j * m + i ] )
     252                                var_sparsity.post_element( dep_taddr_[i], j );
     253                }
     254        }
     255        // process posts
     256        for(size_t i = 0; i < m; i++)
     257                var_sparsity.process_post( dep_taddr_[i] );
    258258
    259259        // evaluate the sparsity patterns
     
    268268        // return values corresponding to dependent variables
    269269        CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == q * n );
    270         for(j = 0; j < n; j++)
     270        for(size_t j = 0; j < n; j++)
    271271        {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] == (j+1) );
    272272
     
    276276                // extract the result from var_sparsity
    277277                if( transpose )
    278                 {       for(i = 0; i < q; i++)
     278                {       for(size_t i = 0; i < q; i++)
    279279                                s[ j * q + i ] = false;
    280280                }
    281281                else
    282                 {       for(i = 0; i < q; i++)
     282                {       for(size_t i = 0; i < q; i++)
    283283                                s[ i * n + j ] = false;
    284284                }
    285285                CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == q );
    286286                local::sparse_pack::const_iterator itr(var_sparsity, j+1);
    287                 i = *itr;
     287                size_t i = *itr;
    288288                while( i < q )
    289289                {       if( transpose )
     
    337337
    338338        // temporary indices
    339         size_t i, j;
    340339        std::set<size_t>::const_iterator itr_1;
    341340
     
    368367        // The sparsity pattern corresponding to the dependent variables
    369368        if( transpose )
    370         {       for(i = 0; i < m; i++)
     369        {       for(size_t i = 0; i < m; i++)
    371370                {       itr_1 = r[i].begin();
    372371                        while(itr_1 != r[i].end())
    373                         {       j = *itr_1++;
     372                        {       size_t j = *itr_1++;
    374373                                CPPAD_ASSERT_KNOWN(
    375374                                j < q,
     
    378377                                );
    379378                                CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
    380                                 var_sparsity.add_element( dep_taddr_[i], j );
     379                                var_sparsity.post_element( dep_taddr_[i], j );
    381380                        }
    382381                }
    383382        }
    384383        else
    385         {       for(i = 0; i < q; i++)
     384        {       for(size_t i = 0; i < q; i++)
    386385                {       itr_1 = r[i].begin();
    387386                        while(itr_1 != r[i].end())
    388                         {       j = *itr_1++;
     387                        {       size_t j = *itr_1++;
    389388                                CPPAD_ASSERT_KNOWN(
    390389                                j < m,
     
    393392                                );
    394393                                CPPAD_ASSERT_UNKNOWN( dep_taddr_[j] < num_var_tape_ );
    395                                 var_sparsity.add_element( dep_taddr_[j], i );
     394                                var_sparsity.post_element( dep_taddr_[j], i );
    396395                        }
    397396                }
    398397        }
     398        // process posts
     399        for(size_t i = 0; i < m; i++)
     400                var_sparsity.process_post( dep_taddr_[i] );
     401
    399402        // evaluate the sparsity patterns
    400403        local::rev_jac_sweep(
     
    409412        CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == q || transpose );
    410413        CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == n || ! transpose );
    411         for(j = 0; j < n; j++)
     414        for(size_t j = 0; j < n; j++)
    412415        {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] == (j+1) );
    413416
     
    417420                CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == q );
    418421                local::sparse_list::const_iterator itr_2(var_sparsity, j+1);
    419                 i = *itr_2;
     422                size_t i = *itr_2;
    420423                while( i < q )
    421424                {       if( transpose )
     
    570573                        size_t j = *itr;
    571574                        while( j < q )
    572                         {       var_sparsity.add_element( dep_taddr_[i], j );
     575                        {       var_sparsity.post_element( dep_taddr_[i], j );
    573576                                j = *(++itr);
    574577                        }
     
    580583                        size_t i = *itr;
    581584                        while( i < m )
    582                         {       var_sparsity.add_element( dep_taddr_[i], j );
     585                        {       var_sparsity.post_element( dep_taddr_[i], j );
    583586                                i = *(++itr);
    584587                        }
    585588                }
    586589        }
     590        // process posts
     591        for(size_t i = 0; i < m; i++)
     592                var_sparsity.process_post( dep_taddr_[i] );
    587593
    588594        // evaluate the sparsity pattern for all variables
     
    614620                while( i < q )
    615621                {       if( transpose )
    616                                 s.add_element(j, i);
     622                                s.post_element(j, i);
    617623                        else
    618                                 s.add_element(i, j);
     624                                s.post_element(i, j);
    619625                        i  = *(++itr);
    620626                }
    621627        }
     628        // process posts
     629        for(size_t i = 0; i < s.n_set(); i++)
     630                s.process_post(i);
    622631
    623632}
  • trunk/cppad/core/reverse.hpp

    r3987 r3990  
    1515# include <algorithm>
    1616# include <cppad/local/pod_vector.hpp>
    17 # include <cppad/core/hold_reverse_memory.hpp>
    1817
    1918namespace CppAD { // BEGIN_CPPAD_NAMESPACE
     
    134133        );
    135134
    136         // initialize entire partial matrix to zero
    137         partial_.resize(num_var_tape_ * q);
     135        // initialize entire Partial matrix to zero
     136        local::pod_vector<Base> Partial(num_var_tape_ * q);
    138137        for(i = 0; i < num_var_tape_; i++)
    139138                for(j = 0; j < q; j++)
    140                         partial_[i * q + j] = zero;
     139                        Partial[i * q + j] = zero;
    141140
    142141        // set the dependent variable direction
     
    145144        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_  );
    146145                if( size_t(w.size()) == m )
    147                         partial_[dep_taddr_[i] * q + q - 1] += w[i];
     146                        Partial[dep_taddr_[i] * q + q - 1] += w[i];
    148147                else
    149148                {       for(k = 0; k < q; k++)
    150149                                // ? should use += here, first make test to demonstrate bug
    151                                 partial_[ dep_taddr_[i] * q + k ] = w[i * q + k ];
     150                                Partial[ dep_taddr_[i] * q + k ] = w[i * q + k ];
    152151                }
    153152        }
     
    164163                taylor_.data(),
    165164                q,
    166                 partial_.data(),
     165                Partial.data(),
    167166                cskip_op_.data(),
    168167                load_op_,
     
    184183                {       for(k = 0; k < q; k++)
    185184                                value[j * q + k ] =
    186                                         partial_[ind_taddr_[j] * q + q - 1 - k];
     185                                        Partial[ind_taddr_[j] * q + q - 1 - k];
    187186                }
    188187                else
    189188                {       for(k = 0; k < q; k++)
    190189                                value[j * q + k ] =
    191                                         partial_[ind_taddr_[j] * q + k];
     190                                        Partial[ind_taddr_[j] * q + k];
    192191                }
    193192        }
     
    197196        );
    198197
    199         // check hold_reverse_memory
    200         if( ! hold_reverse_memory_ )
    201                 partial_.clear();
    202 
    203198        return value;
    204199}
  • trunk/cppad/core/subgraph_reverse.hpp

    r3987 r3990  
    314314        */
    315315
    316         // initialize partial matrix to zero on subgraph
     316        // initialize subgraph_partial_ matrix to zero on subgraph
    317317        Base zero(0);
    318         partial_.resize(num_var_tape_ * q);
     318        subgraph_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                                        subgraph_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        subgraph_partial_[ dep_taddr_[ell] * q + q - 1] = Base(1);
    346346
    347347        // evaluate the derivatives
     
    357357                taylor_.data(),
    358358                q,
    359                 partial_.data(),
     359                subgraph_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 ] = subgraph_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 
    404399        return;
    405400}
  • trunk/cppad/local/color_general.hpp

    r3969 r3990  
    3030
    3131\tparam VectorSet
    32 is an unspecified type with the exception that it must support the
    33 operations under pattern and the following operations where
    34 p is a VectorSet object:
    35 \n
    36 <code>VectorSet p</code>
    37 Constructs a new vector of sets object.
    38 \n
    39 <code>p.resize(ns, ne)</code>
    40 resizes \c p to \c ns sets with elements between zero \c ne.
    41 All of the \c ns sets are initially empty.
    42 \n
    43 <code>p.add_element(s, e)</code>
    44 add element \c e to set with index \c s.
     32is vector_of_sets class.
    4533
    4634\param pattern [in]
    4735Is a representation of the sparsity pattern for the matrix.
    48 \n
    49 <code>m = pattern.n_set()</code>
    50 \n
    51 sets \c m to the number of rows in the sparse matrix.
    52 All of the row indices are less than this value.
    53 \n
    54 <code>n = pattern.end()</code>
    55 \n
    56 sets \c n to the number of columns in the sparse matrix.
    57 All of the column indices are less than this value.
    58 \n
    59 <code>VectorSet::const_iterator itr(pattern, i)</code>
    60 constructs an iterator that starts iterating over
    61 columns in the i-th row of the sparsity pattern.
    62 \n
    63 <code>j = *itr</code>
    64 Sets j to the next possibly non-zero column.
    65 \n
    66 <code>++itr</code>
    67 Advances to the next possibly non-zero column.
    6836
    6937\param row [in]
     
    10775        const VectorSize&       col     ,
    10876        CppAD::vector<size_t>&  color   )
    109 {       size_t i, j, k, ell, r;
    110 
     77{
    11178        size_t K = row.size();
    11279        size_t m = pattern.n_set();
     
    12188        // initialize rows that appear
    12289        CppAD::vector<bool> row_appear(m);
    123         for(i = 0; i < m; i++)
     90        for(size_t i = 0; i < m; i++)
    12491                        row_appear[i] = false;
    12592
     
    12895        c2r_appear.resize(n, m);
    12996        r2c_appear.resize(m, n);
    130         for(k = 0;  k < K; k++)
     97        for(size_t k = 0;  k < K; k++)
    13198        {       CPPAD_ASSERT_UNKNOWN( pattern.is_element(row[k], col[k]) );
    13299                row_appear[ row[k] ] = true;
    133                 c2r_appear.add_element(col[k], row[k]);
    134                 r2c_appear.add_element(row[k], col[k]);
    135         }
     100                c2r_appear.post_element(col[k], row[k]);
     101                r2c_appear.post_element(row[k], col[k]);
     102        }
     103        // process posts
     104        for(size_t j = 0; j < n; ++j)
     105                c2r_appear.process_post(j);
     106        for(size_t i = 0; i < m; ++i)
     107                r2c_appear.process_post(i);
    136108
    137109        // for each column, which rows are non-zero and do not appear
    138110        VectorSet not_appear;
    139111        not_appear.resize(n, m);
    140         for(i = 0; i < m; i++)
     112        for(size_t i = 0; i < m; i++)
    141113        {       typename VectorSet::const_iterator pattern_itr(pattern, i);
    142                 j = *pattern_itr;
     114                size_t j = *pattern_itr;
    143115                while( j != pattern.end() )
    144116                {       if( ! c2r_appear.is_element(j , i) )
    145                                 not_appear.add_element(j, i);
    146                         j = *(++pattern_itr);
    147                 }
    148         }
     117                                not_appear.post_element(j, i);
     118                        j = *(++pattern_itr);
     119                }
     120        }
     121        // process posts
     122        for(size_t j = 0; j < n; ++j)
     123                not_appear.process_post(j);
    149124
    150125        // initial coloring
    151126        color.resize(m);
    152         ell = 0;
    153         for(i = 0; i < m; i++)
     127        size_t ell = 0;
     128        for(size_t i = 0; i < m; i++)
    154129        {       if( row_appear[i] )
    155130                        color[i] = ell++;
     
    166141        */
    167142        CppAD::vector<bool> forbidden(m);
    168         for(i = 1; i < m; i++) // for each row that appears
     143        for(size_t i = 1; i < m; i++) // for each row that appears
    169144        if( color[i] < m )
    170145        {
     
    179154                // for each column that is non-zero for this row
    180155                typename VectorSet::const_iterator pattern_itr(pattern, i);
    181                 j = *pattern_itr;
     156                size_t j = *pattern_itr;
    182157                while( j != pattern.end() )
    183158                {       // for each row that appears with this column
    184159                        typename VectorSet::const_iterator c2r_itr(c2r_appear, j);
    185                         r = *c2r_itr;
     160                        size_t r = *c2r_itr;
    186161                        while( r != c2r_appear.end() )
    187162                        {       // if this is not the same row, forbid its color
     
    204179                        // (the appear rows have already been checked above).
    205180                        typename VectorSet::const_iterator not_itr(not_appear, j);
    206                         r = *not_itr;
     181                        size_t r = *not_itr;
    207182                        while( r != not_appear.end() )
    208183                        {       // if this is not the same row, forbid its color
     
    238213        const VectorSize&       col     ,
    239214        CppAD::vector<size_t>&  color   )
    240 {       size_t i, j, k;
     215{
    241216        size_t m = pattern.n_set();
    242217        size_t n = pattern.end();
     
    245220        CppAD::vector<size_t> n_nonzero(m);
    246221        size_t n_nonzero_total = 0;
    247         for(i = 0; i < m; i++)
     222        for(size_t i = 0; i < m; i++)
    248223        {       n_nonzero[i] = 0;
    249224                typename VectorSet::const_iterator pattern_itr(pattern, i);
    250                 j = *pattern_itr;
     225                size_t j = *pattern_itr;
    251226                while( j != pattern.end() )
    252227                {       n_nonzero[i]++;
     
    260235        CppAD::vector<unsigned int>  adolc_memory(m + n_nonzero_total);
    261236        size_t i_memory = 0;
    262         for(i = 0; i < m; i++)
     237        for(size_t i = 0; i < m; i++)
    263238        {       adolc_pattern[i]    = adolc_memory.data() + i_memory;
    264239                CPPAD_ASSERT_KNOWN(
     
    268243                adolc_pattern[i][0] = static_cast<unsigned int>( n_nonzero[i] );
    269244                typename VectorSet::const_iterator pattern_itr(pattern, i);
    270                 j = *pattern_itr;
    271                 k = 1;
     245                size_t j = *pattern_itr;
     246                size_t k = 1;
    272247                while(j != pattern.end() )
    273248                {
  • trunk/cppad/local/color_symmetric.hpp

    r3969 r3990  
    3030
    3131\tparam VectorSet
    32 is an unspecified type with the exception that it must support the
    33 operations under pattern and the following operations where
    34 p is a VectorSet object:
    35 \n
    36 <code>VectorSet p</code>
    37 Constructs a new vector of sets object.
    38 \n
    39 <code>p.resize(ns, ne)</code>
    40 resizes \c p to ns sets with elements between zero and \c ne.
    41 All of the sets are initially empty.
    42 \n
    43 <code>p.add_element(s, e)</code>
    44 add element \c e to set with index \c s.
     32is a vector_of_sets class.
    4533
    4634\param pattern [in]
    4735Is a representation of the sparsity pattern for the matrix.
    48 \n
    49 <code>m = pattern.n_set()</code>
    50 \n
    51 sets m to the number of rows (and columns) in the sparse matrix.
    52 All of the row indices are less than this value.
    53 \n
    54 <code>n = pattern.end()</code>
    55 \n
    56 sets n to the number of columns in the sparse matrix
    57 (which must be equal to the number of rows).
    58 All of the column indices are less than this value.
    59 \n
    60 <code>VectorSet::const_iterator itr(pattern, i)</code>
    61 constructs an iterator that starts iterating over
    62 columns in the i-th row of the sparsity pattern.
    63 \n
    64 <code>j = *itr</code>
    65 Sets j to the next possibly non-zero column.
    66 \n
    67 <code>++itr</code>
    68 Advances to the next possibly non-zero column.
    69 \n
    7036
    7137\param row [in/out]
     
    11884        CppAD::vector<size_t>&  col       ,
    11985        CppAD::vector<size_t>&  color     )
    120 {       size_t o1, o2, i1, i2, j1, j2, k1, c1, c2;
    121 
     86{
    12287        size_t K = row.size();
    12388        size_t m = pattern.n_set();
     
    12994        CppAD::vector< std::set<size_t> > pair_needed(m);
    13095        std::set<size_t>::iterator itr1, itr2;
    131         for(k1 = 0;  k1 < K; k1++)
     96        for(size_t k1 = 0;  k1 < K; k1++)
    13297        {       CPPAD_ASSERT_UNKNOWN( pattern.is_element(row[k1], col[k1]) );
    13398                pair_needed[ row[k1] ].insert( col[k1] );
     
    137102        // order the rows decending by number of pairs needed
    138103        CppAD::vector<size_t> key(m), order2row(m);
    139         for(i1 = 0; i1 < m; i1++)
     104        for(size_t i1 = 0; i1 < m; i1++)
    140105        {       CPPAD_ASSERT_UNKNOWN( pair_needed[i1].size() <= m );
    141106                key[i1] = m - pair_needed[i1].size();
     
    145110        // mapping from order index to row index
    146111        CppAD::vector<size_t> row2order(m);
    147         for(o1 = 0; o1 < m; o1++)
     112        for(size_t o1 = 0; o1 < m; o1++)
    148113                row2order[ order2row[o1] ] = o1;
    149114
    150115        // initial coloring
    151116        color.resize(m);
    152         c1 = 0;
    153         for(o1 = 0; o1 < m; o1++)
    154         {       i1 = order2row[o1];
     117        size_t c1 = 0;
     118        for(size_t o1 = 0; o1 < m; o1++)
     119        {       size_t i1 = order2row[o1];
    155120                if( pair_needed[i1].empty() )
    156121                        color[i1] = m;
     
    163128
    164129        // must start with row zero so that we remove results computed for it
    165         for(o1 = 0; o1 < m; o1++) // for each row that appears (in order)
     130        for(size_t o1 = 0; o1 < m; o1++) // for each row that appears (in order)
    166131        if( color[ order2row[o1] ] < m )
    167         {       i1 = order2row[o1];
     132        {       size_t i1 = order2row[o1];
    168133                c1 = color[i1];
    169134
    170135                // initial all colors as ok for this row
    171136                // (value of forbidden for c > c1 does not matter)
    172                 for(c2 = 0; c2 <= c1; c2++)
     137                for(size_t c2 = 0; c2 <= c1; c2++)
    173138                        forbidden[c2] = false;
    174139
     
    179144                while( itr1 != pair_needed[i1].end() )
    180145                {       // entry (i1, j1) is needed for this row
    181                         j1 = *itr1;
     146                        size_t j1 = *itr1;
    182147
    183148                        // Forbid rows i2 != i1 that have non-zero sparsity at (i2, j1).
    184149                        // Note that this is the same as non-zero sparsity at (j1, i2)
    185150                        typename VectorSet::const_iterator pattern_itr(pattern, j1);
    186                         i2 = *pattern_itr;
     151                        size_t i2 = *pattern_itr;
    187152                        while( i2 != pattern.end() )
    188                         {       c2 = color[i2];
     153                        {       size_t c2 = color[i2];
    189154                                if( c2 < c1 )
    190155                                        forbidden[c2] = true;
     
    195160                // -----------------------------------------------------
    196161                // Forbid grouping with rows that this row would destroy results for
    197                 for(o2 = 0; o2 < o1; o2++)
    198                 {       i2 = order2row[o2];
    199                         c2 = color[i2];
     162                for(size_t o2 = 0; o2 < o1; o2++)
     163                {       size_t i2 = order2row[o2];
     164                        size_t c2 = color[i2];
    200165                        itr2 = pair_needed[i2].begin();
    201166                        while( itr2 != pair_needed[i2].end() )
    202                         {       j2 = *itr2;
     167                        {       size_t j2 = *itr2;
    203168                                // row i2 needs pair (i2, j2).
    204169                                // Forbid grouping with i1 if (i1, j2) has non-zero sparsity
     
    210175
    211176                // pick the color with smallest index
    212                 c2 = 0;
     177                size_t c2 = 0;
    213178                while( forbidden[c2] )
    214179                {       c2++;
     
    220185                itr1 = pair_needed[i1].begin();
    221186                while( itr1 != pair_needed[i1].end() )
    222                 {       j1 = *itr1;
     187                {       size_t j1 = *itr1;
    223188                        if( row2order[j1] > o1 )
    224189                        {       itr2 = pair_needed[j1].find(i1);
     
    234199
    235200        // determine which sparsity entries need to be reflected
    236         for(k1 = 0; k1 < row.size(); k1++)
    237         {       i1   = row[k1];
    238                 j1   = col[k1];
     201        for(size_t k1 = 0; k1 < row.size(); k1++)
     202        {       size_t i1   = row[k1];
     203                size_t j1   = col[k1];
    239204                itr1 = pair_needed[i1].find(j1);
    240205                if( itr1 == pair_needed[i1].end() )
     
    320285
    321286        // determine which sparsity entries need to be reflected
    322         size_t i1, i2, j1, j2, k1, k2;
    323         for(k1 = 0; k1 < row.size(); k1++)
    324         {       i1 = row[k1];
    325                 j1 = col[k1];
     287        for(size_t k1 = 0; k1 < row.size(); k1++)
     288        {       size_t i1 = row[k1];
     289                size_t j1 = col[k1];
    326290                bool reflect = false;
    327                 for(i2 = 0; i2 < m; i2++) if( (i1 != i2) & (color[i1]==color[i2]) )
    328                 {       for(k2 = 1; k2 <= adolc_pattern[i2][0]; k2++)
    329                         {       j2 = adolc_pattern[i2][k2];
     291                for(size_t i2 = 0; i2 < m; i2++)
     292                if( (i1 != i2) & (color[i1]==color[i2]) )
     293                {       for(size_t k2 = 1; k2 <= adolc_pattern[i2][0]; k2++)
     294                        {       size_t j2 = adolc_pattern[i2][k2];
    330295                                reflect |= (j1 == j2);
    331296                        }
  • trunk/cppad/local/sparse_internal.hpp

    r3989 r3990  
    108108        const sparse_rc<SizeVector>&  pattern_in       )
    109109{
     110        size_t nr = internal_index.size();
    110111# ifndef NDEBUG
    111         size_t nr = internal_index.size();
    112112        size_t nc = internal_pattern.end();
    113113        if( transpose )
     
    138138                bool ignore  = zero_empty && i_var == 0;
    139139                if( ! ignore )
    140                         internal_pattern.add_element( internal_index[r], c );
    141         }
     140                        internal_pattern.post_element( internal_index[r], c );
     141        }
     142        // process posts
     143        for(size_t i = 0; i < nr; ++i)
     144                internal_pattern.process_post( internal_index[i] );
    142145}
    143146template <class InternalSparsity>
     
    169172                                bool ignore  = zero_empty && i_var == 0;
    170173                                if( ! ignore )
    171                                         internal_pattern.add_element( i_var, j);
     174                                        internal_pattern.post_element( i_var, j);
    172175                        }
    173176                }
    174177        }
     178        // process posts
     179        for(size_t i = 0; i < nr; ++i)
     180                internal_pattern.process_post( internal_index[i] );
    175181        return;
    176182}
     
    203209                                bool ignore  = zero_empty && i_var == 0;
    204210                                if( ! ignore )
    205                                         internal_pattern.add_element( i_var, j);
     211                                        internal_pattern.post_element( i_var, j);
    206212                        }
    207213                }
    208214        }
     215        // process posts
     216        for(size_t i = 0; i < nr; ++i)
     217                internal_pattern.process_post( internal_index[i] );
    209218        return;
    210219}
     
    236245                                bool ignore  = zero_empty && i_var == 0;
    237246                                if( ! ignore )
    238                                         internal_pattern.add_element( i_var, j);
     247                                        internal_pattern.post_element( i_var, j);
    239248                                ++itr;
    240249                        }
     
    252261                                bool ignore  = zero_empty && i_var == 0;
    253262                                if( ! ignore )
    254                                         internal_pattern.add_element( i_var, j);
     263                                        internal_pattern.post_element( i_var, j);
    255264                                ++itr;
    256265                        }
    257266                }
    258267        }
     268        // process posts
     269        for(size_t i = 0; i < nr; ++i)
     270                internal_pattern.process_post( internal_index[i] );
    259271        return;
    260272}
  • trunk/cppad/local/sparse_list.hpp

    r3989 r3990  
    5353        size_t end_;
    5454
    55         /// number of elements in data_ that have been allocated
    56         /// and are no longer being used.
     55        /// number of elements in data_ that are not being used.
     56        size_t number_not_used_;
     57
     58        /// list of elements of data_ that are not being used.
    5759        size_t data_not_used_;
    5860
     
    126128        // -----------------------------------------------------------------
    127129        /*!
    128         drop a set and its postings.
     130        drop a set and its postings (no longer being used).
    129131
    130132        \param i
     
    141143        the value post_[i] will be set to zero.
    142144
     145        \par data_not_used_
     146        the eleemmnts of data_ that are dropped are added to this list.
     147
    143148        \return
    144         is the number of elements of data_ that will be lost when the set is
    145         dropped. This is non-zero when the initial reference count is one.
     149        is the additional number of elements of data_ that are not used.
     150        This is non-zero when the initial reference count is one.
    146151        */
    147152        size_t drop(size_t i)
    148         {       // inialize counter
    149                 size_t count = 0;
    150 
    151                 // count posted elements that will be dropped
    152                 size_t next = post_[i];
    153                 while( data_[next].value != end_ )
    154                 {       ++count;
    155                         next = data_[next].next;
    156                 }
    157 
    158                 // drop posted elements
    159                 post_[i] = 0;
     153        {       // inialize count of addition elements not being used.
     154                size_t number_drop = 0;
     155
     156                // the elements in the post list will no longer be used
     157                size_t post = post_[i];
     158                if( post != 0 )
     159                {       // drop this posting
     160                        post_[i]    = 0;
     161                        //
     162                        // count elements in this posting
     163                        ++number_drop;
     164                        size_t previous = post;
     165                        size_t next     = data_[previous].next;
     166                        while( next != 0 )
     167                        {       previous = next;
     168                                next     = data_[previous].next;
     169                                ++number_drop;
     170                        }
     171                        //
     172                        // add the posting elements to data_not_used_
     173                        data_[previous].next = data_not_used_;
     174                        data_not_used_       = post;
     175                }
    160176
    161177                // check for empty set
    162178                size_t start = start_[i];
    163179                if( start == 0 )
    164                         return count;
     180                        return number_drop;
    165181
    166182                // decrement reference counter
    167                 CPPAD_ASSERT_UNKNOWN( data_[start].value == reference_count(i) );
     183                CPPAD_ASSERT_UNKNOWN( data_[start].value > 0 );
    168184                data_[start].value--;
    169185
     
    171187                start_[i] = 0;
    172188
    173                 // nothing else lost unless new reference count is zero
     189                // If new reference count is positive, the list corresponding to
     190                // start is still being used.
    174191                if( data_[start].value > 0 )
    175                         return count;
    176 
    177                 // count reference counter and elements in the set
    178                 ++count;
    179                 next = start;            // reference counter
    180                 next = data_[next].next; // first element of the set
    181                 while( data_[next].value != end_ )
    182                 {       ++count;
    183                         next = data_[next].next;
    184                 }
    185 
    186                 return count;
     192                        return number_drop;
     193
     194                //
     195                // count elements representing this set
     196                ++number_drop;
     197                size_t previous = start;
     198                size_t next     = data_[previous].next;
     199                while( next != 0 )
     200                {       previous = next;
     201                        next     = data_[previous].next;
     202                        ++number_drop;
     203                }
     204                //
     205                // add representing this set to data_not_used_
     206                data_[previous].next = data_not_used_;
     207                data_not_used_       = start;
     208                //
     209                return number_drop;
     210        }
     211        // -----------------------------------------------------------------
     212        /*!
     213        get a new data_ element for use.
     214
     215        \par number_not_used_
     216        if this is non-zero, it is decremented by one.
     217
     218        \par data_not_used_
     219        if this list is non-empty, one element is removed from it.
     220
     221        \return
     222        is the index in data_ of the new element.
     223        */
     224        size_t get_data_index(void)
     225        {       size_t index;
     226                if( data_not_used_ > 0 )
     227                {       CPPAD_ASSERT_UNKNOWN( number_not_used_ > 0 );
     228                        --number_not_used_;
     229                        index          = data_not_used_;
     230                        data_not_used_ = data_[index].next;
     231                }
     232                else
     233                {       index = data_.extend(1);
     234                }
     235                return index;
    187236        }
    188237        // -----------------------------------------------------------------
     
    201250                if( n_set == 0 )
    202251                {       CPPAD_ASSERT_UNKNOWN( end_ == 0 );
     252                        CPPAD_ASSERT_UNKNOWN( number_not_used_ == 0 );
    203253                        CPPAD_ASSERT_UNKNOWN( data_not_used_ == 0 );
    204254                        CPPAD_ASSERT_UNKNOWN( data_.size() == 0 );
     
    215265                        ref_count[i] = reference_count(i);
    216266                // -----------------------------------------------------------
     267                // number of entries in data used by sets and posts
     268                size_t number_used_by_sets = 1;
     269                // -----------------------------------------------------------
    217270                // count the number of entries in data_ that are used by sets
    218                 // (data_[0] is used by all the sets)
    219                 size_t data_used_by_sets = 1;
    220271                for(size_t i = 0; i < n_set; i++)
    221272                {       size_t start = start_[i];
     
    238289
    239290                                        // number of data entries used for this set
    240                                         data_used_by_sets += number_elements(i) + 1;
     291                                        number_used_by_sets += number_elements(i) + 1;
    241292                                        /*
    242293                                        number of elements checks that value < end_
     
    249300                // ------------------------------------------------------------------
    250301                // count the number of entries in data_ that are used by posts
    251                 size_t data_used_by_posts = 0;
     302                size_t number_used_by_posts = 0;
    252303                for(size_t i = 0; i < n_set; i++)
    253304                {       size_t post = post_[i];
     
    258309                                //
    259310                                while( value < end_ )
    260                                 {       ++data_used_by_posts;
     311                                {       ++number_used_by_posts;
    261312                                        value = data_[next].value;
    262313                                        next  = data_[next].next;
     
    265316                }
    266317                // ------------------------------------------------------------------
    267                 size_t data_used = data_used_by_sets + data_used_by_posts;
     318                // count number of entries in data_not_used_
     319                size_t count = 0;
     320                size_t next = data_not_used_;
     321                while( next != 0 )
     322                {       ++count;
     323                        next = data_[next].next;
     324                }
     325                CPPAD_ASSERT_UNKNOWN( number_not_used_ == count );
     326                // ------------------------------------------------------------------
     327                size_t number_used = number_used_by_sets + number_used_by_posts;
    268328                CPPAD_ASSERT_UNKNOWN(
    269                         data_used + data_not_used_ == data_.size()
     329                        number_used + number_not_used_ == data_.size()
    270330                );
    271331                return;
     
    359419                // neither is a subset
    360420                return 0;
    361         }
    362         // -----------------------------------------------------------------
    363         /*!
    364         Does garbage collection when indicated.
    365 
    366         This routine should be called when more entries are not being used.
    367         If a significant propotion are not being used, the data structure
    368         will be compacted.
    369 
    370         The size of data_ should equal the number of entries used by the sets
    371         plus the number of entries that are not being used data_not_used_.
    372         Note that data_[0] never gets used.
    373         */
    374         void collect_garbage(void)
    375         {       if( data_not_used_ < data_.size() / 2 +  100)
    376                         return;
    377                 check_data_structure();
    378                 //
    379                 // number of sets including empty ones
    380                 size_t n_set  = start_.size();
    381                 //
    382                 // copy the sets to a temporary version of data_
    383                 pod_vector<pair_size_t> data_tmp(1);
    384                 data_tmp[0].value = end_;
    385                 data_tmp[0].next  = 0;
    386                 //
    387                 pod_vector<size_t> start_tmp(n_set);
    388                 for(size_t i = 0; i < n_set; i++)
    389                 {       size_t start    = start_[i];
    390                         if( start == 0 )
    391                                 start_tmp[i] = 0;
    392                         else
    393                         {       // check if this linked list has already been copied
    394                                 if( data_[start].next == 0 )
    395                                 {       // starting address in data_tmp has been stored here
    396                                         start_tmp[i] = data_[start].value;
    397                                 }
    398                                 else
    399                                 {       size_t count              = data_[start].value;
    400                                         size_t next               = data_[start].next;
    401                                         //
    402                                         size_t tmp_start          = data_tmp.extend(2);
    403                                         size_t next_tmp           = tmp_start + 1;
    404                                         start_tmp[i]              = tmp_start;
    405                                         data_tmp[tmp_start].value = count;
    406                                         data_tmp[tmp_start].next  = next_tmp;
    407                                         //
    408                                         CPPAD_ASSERT_UNKNOWN( next != 0 );
    409                                         while( next != 0 )
    410                                         {       CPPAD_ASSERT_UNKNOWN( data_[next].value < end_ );
    411                                                 data_tmp[next_tmp].value = data_[next].value;
    412                                                 //
    413                                                 next                      = data_[next].next;
    414                                                 if( next == 0 )
    415                                                         data_tmp[next_tmp].next = 0;
    416                                                 else
    417                                                 {       // data_tmp[next_tmp].next  = data_tmp.extend(1);
    418                                                         // does not seem to work ?
    419                                                         size_t tmp               = data_tmp.extend(1);
    420                                                         data_tmp[next_tmp].next  = tmp;
    421                                                         next_tmp                 = tmp;
    422                                                 }
    423                                         }
    424                                         //
    425                                         // store the starting address here
    426                                         data_[start].value = tmp_start;
    427                                         //
    428                                         // flag that indicates this link list already copied
    429                                         data_[start].next = 0;
    430                                 }
    431                         }
    432                 }
    433 
    434                 // swap the tmp and old data vectors
    435                 start_.swap(start_tmp);
    436                 data_.swap(data_tmp);
    437 
    438                 // all of the elements are used, including data_[0] which is used
    439                 // by all the lists.
    440                 data_not_used_ = 0;
    441         }
    442         // -----------------------------------------------------------------
    443         /*!
    444         Make a separate copy of the shared list
    445 
    446         \param i
    447         is the index, in the vector of sets, for this set.
    448         */
    449         void separate_copy(size_t i)
    450         {       size_t ref_count = reference_count(i);
    451                 if( ref_count <= 1 )
    452                         return;
    453                 //
    454                 size_t start = start_[i];
    455                 size_t next  = data_[start].next;
    456                 size_t value = data_[next].value;
    457                 //
    458                 // new version of list
    459                 size_t start_new   = data_.extend(2);
    460                 size_t next_new    = start_new + 1;
    461                 //
    462                 // reference counter for new version of list
    463                 data_[start_new].value = 1;
    464                 data_[start_new].next  = next_new;
    465                 //
    466                 CPPAD_ASSERT_UNKNOWN( next != 0 )
    467                 while( next != 0 )
    468                 {       data_[next_new].value  = value;
    469                         next                   = data_[next].next;
    470                         if( next == 0 )
    471                                 data_[next_new].next = 0;
    472                         else
    473                         {       value                  = data_[next].value;
    474                                 data_[next_new].next   = data_.extend(1);
    475                                 next_new               = data_[next_new].next;
    476                         }
    477                 }
    478                 //
    479                 // decrement reference count
    480                 CPPAD_ASSERT_UNKNOWN( data_[start].value == ref_count );
    481                 data_[start].value--;
    482                 //
    483                 // starting point for new list
    484                 start_[i] = start_new;
    485                 //
    486                 return;
    487421        }
    488422        // -----------------------------------------------------------------
     
    569503                // -------------------------------------------------------------------
    570504
    571                 // number of elements that will be deleted by removing old version
    572                 // of target
    573                 size_t number_delete = drop(target);
    574 
    575505                // start new version of target
    576                 size_t start        = data_.extend(1);
    577                 start_[target]      = start;
     506                size_t start        = get_data_index();
    578507                data_[start].value  = 1; // reference count
    579508                //
     
    610539                        }
    611540                        // place to put new element
    612                         size_t current_target       = data_.extend(1);
     541                        size_t current_target       = get_data_index();
    613542                        data_[previous_target].next = current_target;
    614543                        //
     
    646575                data_[previous_target].next = 0;
    647576
    648                 // adjust data_not_used_
    649                 data_not_used_ += number_delete;
    650                 collect_garbage();
     577                // adjust number_not_used_
     578                size_t number_drop = drop(target);
     579                number_not_used_  += number_drop;
     580
     581                // set the new start value for target
     582                start_[target] = start;
     583
     584                return;
    651585        }
    652586// ===========================================================================
     
    659593        */
    660594        sparse_list(void) :
    661         end_(0)            ,
    662         data_not_used_(0)  ,
    663         data_(0)           ,
    664         start_(0)          ,
     595        end_(0)              ,
     596        number_not_used_(0)  ,
     597        data_not_used_(0)    ,
     598        data_(0)             ,
     599        start_(0)            ,
    665600        post_(0)
    666601        { }
     
    693628        */
    694629        void operator=(const sparse_list& other)
    695         {       end_           = other.end_;
    696                 data_not_used_ = other.data_not_used_;
    697                 data_          = other.data_;
    698                 start_         = other.start_;
    699                 post_          = other.post_;
     630        {       end_             = other.end_;
     631                number_not_used_ = other.number_not_used_;
     632                data_not_used_   = other.data_not_used_;
     633                data_            = other.data_;
     634                start_           = other.start_;
     635                post_            = other.post_;
    700636        }
    701637        // -----------------------------------------------------------------
     
    727663                        start_.clear();
    728664                        post_.clear();
    729                         data_not_used_  = 0;
    730                         end_            = 0;
     665                        number_not_used_  = 0;
     666                        data_not_used_    = 0;
     667                        end_              = 0;
    731668                        //
    732669                        return;
     
    744681                // last element, marks the end for all lists
    745682                data_.resize(1);
    746                 data_[0].value  = end_;
    747                 data_[0].next   = 0;
    748                 //
    749                 data_not_used_  = 0;
     683                data_[0].value    = end_;
     684                data_[0].next     = 0;
     685                //
     686                number_not_used_  = 0;
     687                data_not_used_    = 0;
    750688        }
    751689        // -----------------------------------------------------------------
     
    803741                // put element at the front of this list
    804742                size_t next         = post_[i];
    805                 size_t post         = data_.extend(1);
     743                size_t post         = get_data_index();
    806744                post_[i]            = post;
    807745                data_[post].value   = element;
     
    825763                size_t post = post_[i];
    826764                //
    827                 // done with this posting
    828                 post_[i] = 0;
    829                 //
    830765                // check if there are no elements to process
    831766                if( post == 0 )
     
    833768                //
    834769                // check if there is only one element to process
    835                 size_t value = data_[post].value;
    836770                size_t next  = data_[post].next;
    837771                if( next == 0 )
    838                 {       add_element(i, value);
    839                         // only lost the one posting element
    840                         ++data_not_used_;
    841                         collect_garbage();
     772                {       // done with this posting
     773                        size_t value     = data_[post].value;
     774                        post_[i]         = 0;
     775                        data_[post].next = data_not_used_;
     776                        data_not_used_   = post;
     777                        ++number_not_used_;
     778                        //
     779                        add_element(i, value);
     780                        //
    842781                        return;
    843782                }
     
    845784                // copy the elements that need to be processed into temporary
    846785                temporary_.resize(0);
    847                 while( value != end_ )
    848                 {       temporary_.push_back(value);
    849                         value = data_[next].value;
    850                         next  = data_[next].next;
    851                 }
     786                size_t previous  = post;
     787                size_t value     = data_[previous].value;
     788                CPPAD_ASSERT_UNKNOWN( value < end_ );
     789                temporary_.push_back(value);
     790                while( next != 0 )
     791                {       previous = next;
     792                        value    = data_[previous].value;
     793                        CPPAD_ASSERT_UNKNOWN( value < end_ );
     794                        temporary_.push_back(value);
     795                        next     = data_[previous].next;
     796                }
     797                size_t number_post = temporary_.size();
     798                //
     799                // done with this posting
     800                post_[i]              = 0;
     801                data_[previous].next  = data_not_used_;
     802                data_not_used_        = post;
     803                number_not_used_     += number_post;;
    852804                //
    853805                // sort temporary_
    854                 size_t number_post = temporary_.size();
    855806                CPPAD_ASSERT_UNKNOWN( number_post > 1 );
    856807                std::sort( temporary_.data(), temporary_.data() + number_post);
     
    858809                // add the elements to the set
    859810                binary_union(i, i, temporary_);
    860                 //
    861                 // adjust data not used_
    862                 data_not_used_ += number_post;
    863                 collect_garbage();
    864811                //
    865812                return;
     
    879826                CPPAD_ASSERT_UNKNOWN( element < end_ );
    880827
    881                 // check if element is already in the set
    882                 if( is_element(i, element) )
    883                         return;
    884 
    885828                // check for case where starting set is empty
    886829                size_t start = start_[i];
    887830                if( start == 0 )
    888                 {       start              = data_.extend(2);
     831                {       start              = get_data_index();
    889832                        start_[i]          = start;
    890833                        data_[start].value = 1; // reference count
    891834                        //
    892                         size_t next        = start + 1;
     835                        size_t next        = get_data_index();
    893836                        data_[start].next  = next;
    894837                        //
     
    897840                        return;
    898841                }
    899                 // make sure that we have a separate copy of this set
    900                 separate_copy(i);
    901                 //
    902                 // start of set with this index (after separate_copy)
     842                //
     843                // start of set with this index
    903844                size_t previous = start_[i];
    904                 //
    905                 // check reference count for this list
    906                 CPPAD_ASSERT_UNKNOWN( data_[previous].value == 1 );
    907845                //
    908846                // first entry in this set
     
    916854                        value = data_[next].value;
    917855                }
    918                 CPPAD_ASSERT_UNKNOWN( element < value )
    919                 //
    920                 size_t insert         = data_.extend(1);
    921                 data_[insert].next    = next;
    922                 data_[previous].next  = insert;
    923                 data_[insert].value   = element;
     856                //
     857                // check for case where element is in the set
     858                if( value == element )
     859                        return;
     860                //
     861                //
     862                // check for case where this is the only reference to this set
     863                CPPAD_ASSERT_UNKNOWN( element < value );
     864                if( data_[start].value == 1 )
     865                {       size_t insert         = get_data_index();
     866                        data_[insert].next    = next;
     867                        data_[insert].value   = element;
     868                        data_[previous].next  = insert;
     869                        //
     870                        return;
     871                }
     872                //
     873                // must make a separate copy with new element inserted
     874                CPPAD_ASSERT_UNKNOWN( data_[start].value > 1 );
     875                data_[start].value--;   // reverence counter for old list
     876                //
     877                size_t start_new       = get_data_index();
     878                data_[start_new].value = 1;         // reference counter for new list
     879                size_t previous_new    = start_new;
     880                //
     881                // start of old set with this index
     882                previous  = start_[i];
     883                //
     884                // first entry in old set
     885                next    = data_[previous].next;
     886                value   = data_[next].value;
     887                //
     888                // locate place to insert this element
     889                while( value < element )
     890                {       // copy to new list
     891                        size_t next_new          = get_data_index();
     892                        data_[previous_new].next = next_new;
     893                        data_[next_new].value    = value;
     894                        previous_new             = next_new;
     895                        //
     896                        // get next value
     897                        previous = next;
     898                        next     = data_[next].next;
     899                        value = data_[next].value;
     900                }
     901                CPPAD_ASSERT_UNKNOWN( element < value );
     902                //
     903                // insert the element
     904                size_t next_new          = get_data_index();
     905                data_[previous_new].next = next_new;
     906                data_[next_new].value    = element;
     907                previous_new             = next_new;
     908                //
     909                // copy rest of the old set
     910                while( value < end_ )
     911                {       // copy to new list
     912                        next_new                 = get_data_index();
     913                        data_[previous_new].next = next_new;
     914                        data_[next_new].value    = value;
     915                        previous_new             = next_new;
     916                        //
     917                        // get next value
     918                        previous = next;
     919                        next     = data_[next].next;
     920                        value = data_[next].value;
     921                }
     922                CPPAD_ASSERT_UNKNOWN( next == 0 );
     923                data_[previous_new].next = 0;
     924                //
     925                // hook up new list
     926                start_[i] = start_new;
     927                return;
    924928        }
    925929        // -----------------------------------------------------------------
     
    956960        is the index of the set we are setting to the empty set.
    957961
    958         \par data_not_used_
    959         increments this value by number of data_ elements that are lost
    960         (unlinked) by this operation.
     962        \par number_not_used_
     963        increments this value by additional number of data_ elements that are
     964        no longer being used.
    961965        */
    962966        void clear(size_t target)
    963967        {       CPPAD_ASSERT_UNKNOWN( target < start_.size() );
    964968
    965                 // drop t he set and postings
    966                 size_t number_delete = drop(target);
    967 
    968                 // adjust data_not_used_
    969                 data_not_used_ += number_delete;
    970                 collect_garbage();
     969                // adjust number_not_used_
     970                size_t number_drop = drop(target);
     971                number_not_used_  += number_drop;
     972
     973                return;
    971974        }
    972975        // -----------------------------------------------------------------
     
    985988        sparse_list object). This must have the same value for end_.
    986989
    987         \par data_not_used_
    988         increments this value by number of elements lost.
     990        \par number_not_used_
     991        increments this value by additional number of elements not being used.
    989992        */
    990993        void assignment(
     
    10021005                        return;
    10031006
    1004                 // number of list elements that will be deleted by this operation
    1005                 size_t number_delete = drop(this_target);
     1007                // set depending on cases below
     1008                size_t this_start;
    10061009
    10071010                // If this and other are the same, use another reference to same list
    10081011                size_t other_start = other.start_[other_source];
    10091012                if( this == &other )
    1010                 {       start_[this_target] = other_start;
     1013                {       this_start = other_start;
    10111014                        if( other_start != 0 )
    10121015                        {       data_[other_start].value++; // increment reference count
     
    10151018                }
    10161019                else if( other_start  == 0 )
    1017                 {       // the target list is empty
    1018                         start_[this_target] = 0;
     1020                {       this_start = 0;
    10191021                }
    10201022                else
    10211023                {       // make a copy of the other list in this sparse_list
    1022                         size_t this_start = data_.extend(2);
    1023                         size_t this_next  = this_start + 1;
    1024                         start_[this_target]     = this_start;
     1024                        this_start        = get_data_index();
     1025                        size_t this_next  = get_data_index();
    10251026                        data_[this_start].value = 1; // reference count
    10261027                        data_[this_start].next  = this_next;
     
    10341035                                        data_[this_next].next = 0;
    10351036                                else
    1036                                 {       size_t tmp = data_.extend(1);
     1037                                {       size_t tmp = get_data_index();
    10371038                                        data_[this_next].next = tmp;
    10381039                                        this_next             = tmp;
     
    10411042                }
    10421043
    1043                 // adjust data_not_used_
    1044                 data_not_used_ += number_delete;
    1045                 collect_garbage();
     1044                // adjust number_not_used_
     1045                size_t number_drop = drop(this_target);
     1046                number_not_used_  += number_drop;
     1047
     1048                // set the new start value for this_target
     1049                start_[this_target] = this_start;
     1050
     1051                return;
    10461052        }
    10471053        // -----------------------------------------------------------------
     
    11011107                size_t start_right   = other.start_[other_right];
    11021108
    1103                 // number of list elements that will be deleted by this operation
    1104                 size_t number_delete = drop(this_target);
    1105 
    11061109                // start the new list
    1107                 size_t start        = data_.extend(1);
     1110                size_t start        = get_data_index();
    11081111                size_t next         = start;
    1109                 start_[this_target] = start;
    11101112                data_[start].value  = 1; // reference count
    11111113
     
    11261128                        }
    11271129                        if( value_left < value_right )
    1128                         {       size_t tmp        = data_.extend(1);
     1130                        {       size_t tmp        = get_data_index();
    11291131                                data_[next].next  = tmp;
    11301132                                next              = tmp;
     
    11361138                        else
    11371139                        {       CPPAD_ASSERT_UNKNOWN( value_right < value_left )
    1138                                 size_t tmp        = data_.extend(1);
     1140                                size_t tmp        = get_data_index();
    11391141                                data_[next].next  = tmp;
    11401142                                next              = tmp;
     
    11471149                data_[next].next = 0;
    11481150
    1149                 // adjust data_not_used_
    1150                 data_not_used_ += number_delete;
    1151                 collect_garbage();
     1151                // adjust number_not_used_
     1152                size_t number_drop = drop(this_target);
     1153                number_not_used_  += number_drop;
     1154
     1155                // set the new start value for this_target
     1156                start_[this_target] = start;
     1157
     1158                return;
    11521159        }
    11531160        // -----------------------------------------------------------------
     
    12071214                size_t start_right   = other.start_[other_right];
    12081215
    1209                 // number of list elements that will be deleted by this operation
    1210                 size_t number_delete = drop(this_target);
    1211 
    12121216                // start the new list as emptyh
    12131217                size_t start        = 0;
    12141218                size_t next         = start;
    1215                 start_[this_target] = start;
    12161219
    12171220                // next for left and right lists
     
    12281231                        {       if( start == 0 )
    12291232                                {       // this is the first element in the intersection
    1230                                         start               = data_.extend(1);
     1233                                        start               = get_data_index();
    12311234                                        next                = start;
    12321235                                        start_[this_target] = start;
     
    12341237                                        CPPAD_ASSERT_UNKNOWN( start > 0 );
    12351238                                }
    1236                                 size_t tmp        = data_.extend(1);
     1239                                size_t tmp        = get_data_index();
    12371240                                data_[next].next  = tmp;
    12381241                                next              = tmp;
     
    12601263                }
    12611264
    1262                 // adjust data_not_used_
    1263                 data_not_used_ += number_delete;
    1264                 collect_garbage();
     1265                // adjust number_not_used_
     1266                size_t number_drop = drop(this_target);
     1267                number_not_used_  += number_drop;
     1268
     1269                // set new start for this_target
     1270                start_[this_target] = start;
     1271
     1272                return;
    12651273        }
    12661274        // -----------------------------------------------------------------
  • trunk/doc.omh

    r3989 r3990  
    9191$comment bin/version assumes that : follows cppad version number here$$
    9292$section
    93 cppad-20171203: A Package for Differentiation of C++ Algorithms
     93cppad-20171205: 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

    r3987 r3990  
    8080        hessian.cpp
    8181        hes_times_dir.cpp
    82         hold_reverse_memory.cpp
    8382        independent.cpp
    8483        integer.cpp
  • trunk/example/general/general.cpp

    r3987 r3990  
    9898extern bool Hessian(void);
    9999extern bool HesTimesDir(void);
    100 extern bool hold_reverse_memory(void);
    101100extern bool Independent(void);
    102101extern bool Integer(void);
     
    210209        Run( Hessian,           "Hessian"          );
    211210        Run( HesTimesDir,       "HesTimesDir"      );
    212         Run( hold_reverse_memory, "hold_reverse_memory" );
    213211        Run( Independent,       "Independent"      );
    214212        Run( Integer,           "Integer"          );
  • trunk/example/general/makefile.am

    r3987 r3990  
    124124        hessian.cpp \
    125125        hes_times_dir.cpp \
    126         hold_reverse_memory.cpp \
    127126        independent.cpp \
    128127        integer.cpp \
  • trunk/example/general/makefile.in

    r3988 r3990  
    123123        forward_dir.cpp forward_order.cpp fun_assign.cpp fun_check.cpp \
    124124        hes_lagrangian.cpp hes_lu_det.cpp hes_minor_det.cpp \
    125         hessian.cpp hes_times_dir.cpp hold_reverse_memory.cpp \
    126         independent.cpp integer.cpp interface2c.cpp interp_onetape.cpp \
    127         interp_retape.cpp jac_lu_det.cpp jac_minor_det.cpp \
    128         jacobian.cpp log10.cpp log1p.cpp log.cpp lu_ratio.cpp \
    129         lu_vec_ad.cpp lu_vec_ad.hpp lu_vec_ad_ok.cpp mul.cpp \
    130         mul_eq.cpp mul_level.cpp mul_level_ode.cpp near_equal_ext.cpp \
    131         number_skip.cpp numeric_type.cpp num_limits.cpp ode_stiff.cpp \
    132         ode_taylor.cpp opt_val_hes.cpp par_var.cpp poly.cpp pow.cpp \
    133         pow_int.cpp print_for.cpp reverse_checkpoint.cpp \
    134         reverse_one.cpp reverse_three.cpp reverse_two.cpp rev_one.cpp \
    135         rev_two.cpp rosen_34.cpp runge45_2.cpp seq_property.cpp \
    136         sign.cpp sin.cpp sinh.cpp sqrt.cpp stack_machine.cpp sub.cpp \
    137         sub_eq.cpp tan.cpp tanh.cpp tape_index.cpp unary_minus.cpp \
    138         unary_plus.cpp value.cpp var2par.cpp vec_ad.cpp
     125        hessian.cpp hes_times_dir.cpp independent.cpp integer.cpp \
     126        interface2c.cpp interp_onetape.cpp interp_retape.cpp \
     127        jac_lu_det.cpp jac_minor_det.cpp jacobian.cpp log10.cpp \
     128        log1p.cpp log.cpp lu_ratio.cpp lu_vec_ad.cpp lu_vec_ad.hpp \
     129        lu_vec_ad_ok.cpp mul.cpp mul_eq.cpp mul_level.cpp \
     130        mul_level_ode.cpp near_equal_ext.cpp number_skip.cpp \
     131        numeric_type.cpp num_limits.cpp ode_stiff.cpp ode_taylor.cpp \
     132        opt_val_hes.cpp par_var.cpp poly.cpp pow.cpp pow_int.cpp \
     133        print_for.cpp reverse_checkpoint.cpp reverse_one.cpp \
     134        reverse_three.cpp reverse_two.cpp rev_one.cpp rev_two.cpp \
     135        rosen_34.cpp runge45_2.cpp seq_property.cpp sign.cpp sin.cpp \
     136        sinh.cpp sqrt.cpp stack_machine.cpp sub.cpp sub_eq.cpp tan.cpp \
     137        tanh.cpp tape_index.cpp unary_minus.cpp unary_plus.cpp \
     138        value.cpp var2par.cpp vec_ad.cpp
    139139@CppAD_ADOLC_TRUE@am__objects_1 = mul_level_adolc.$(OBJEXT) \
    140140@CppAD_ADOLC_TRUE@      mul_level_adolc_ode.$(OBJEXT)
     
    157157        fun_check.$(OBJEXT) hes_lagrangian.$(OBJEXT) \
    158158        hes_lu_det.$(OBJEXT) hes_minor_det.$(OBJEXT) hessian.$(OBJEXT) \
    159         hes_times_dir.$(OBJEXT) hold_reverse_memory.$(OBJEXT) \
    160         independent.$(OBJEXT) integer.$(OBJEXT) interface2c.$(OBJEXT) \
     159        hes_times_dir.$(OBJEXT) independent.$(OBJEXT) \
     160        integer.$(OBJEXT) interface2c.$(OBJEXT) \
    161161        interp_onetape.$(OBJEXT) interp_retape.$(OBJEXT) \
    162162        jac_lu_det.$(OBJEXT) jac_minor_det.$(OBJEXT) \
     
    286286CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
    287287CYGPATH_W = @CYGPATH_W@
    288 
    289288# -----------------------------------------------------------------------------
    290289# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     
    536535        hessian.cpp \
    537536        hes_times_dir.cpp \
    538         hold_reverse_memory.cpp \
    539537        independent.cpp \
    540538        integer.cpp \
     
    697695@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hes_times_dir.Po@am__quote@
    698696@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hessian.Po@am__quote@
    699 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hold_reverse_memory.Po@am__quote@
    700697@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/independent.Po@am__quote@
    701698@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/integer.Po@am__quote@
     
    10061003.PRECIOUS: makefile
    10071004
     1005git show b9584032fdcedfe3234b3ad9d93c8a277f84f6f7:example/general/makefile.am
    10081006
    10091007test: check
  • trunk/example/sparse/sparse.cpp

    r3980 r3990  
    6262
    6363        // external compiled tests
    64         Run( subgraph_jac_rev,         " subgraph_jac_rev" );
     64        Run( subgraph_jac_rev,          "subgraph_jac_rev" );
    6565        Run( subgraph_sparsity,         "subgraph_sparsity" );
    6666        Run( sub_sparse_hes,            "sub_sparse_hes" );
  • trunk/makefile.am

    r3987 r3990  
    152152        cppad/core/hash_code.hpp \
    153153        cppad/core/hessian.hpp \
    154         cppad/core/hold_reverse_memory.hpp \
    155154        cppad/core/identical.hpp \
    156155        cppad/core/independent.hpp \
  • trunk/makefile.in

    r3988 r3990  
    411411top_builddir = @top_builddir@
    412412top_srcdir = @top_srcdir@
    413 
    414413# -----------------------------------------------------------------------------
    415414# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     
    548547        cppad/core/hash_code.hpp \
    549548        cppad/core/hessian.hpp \
    550         cppad/core/hold_reverse_memory.hpp \
    551549        cppad/core/identical.hpp \
    552550        cppad/core/independent.hpp \
     
    13821380.PRECIOUS: makefile
    13831381
     1382git show b9584032fdcedfe3234b3ad9d93c8a277f84f6f7:makefile.am
    13841383$(top_srcdir)/cppad/configure.hpp: cppad/configure.hpp
    13851384        cp cppad/configure.hpp $(top_srcdir)/cppad/configure.hpp
  • trunk/omh/appendix/whats_new/whats_new_17.omh

    r3987 r3990  
    5959$cref/debug_which/speed/debug_which/$$
    6060
     61$head 12-05$$
     62The internal data object used to represent sparsity patterns as
     63vectors of integers was improved;
     64see $cref/internal_bool/for_jac_sparsity/internal_bool/$$
     65in $code for_jac_sparsity$$ and other
     66$cref/preferred sparsity pattern/sparsity_pattern/Preferred Sparsity Patterns/$$
     67routines.
     68
     69$head 12-04$$
     70Back out the $code hold_reverse_memory$$ option.
     71
    6172$head 12-01$$
    62 The $cref hold_reverse_memory$$ option was added.
     73The $code hold_reverse_memory$$ option was added.
    6374
    6475$head 11-30$$
  • trunk/omh/example_list.omh

    r3987 r3990  
    184184$rref hessian.cpp$$
    185185$rref hes_times_dir.cpp$$
    186 $rref hold_reverse_memory.cpp$$
    187186$rref independent.cpp$$
    188187$rref index_sort.cpp$$
Note: See TracChangeset for help on using the changeset viewer.