Changeset 3713


Ignore:
Timestamp:
Aug 28, 2015 9:01:09 AM (5 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: fc86286a32cd87ded0475c12f6a8ea5388bc0ccd
end hash code: 630f51c9e1a0037b2302ab026d1f2867b9490e91

commit 630f51c9e1a0037b2302ab026d1f2867b9490e91
Author: Brad Bell <bradbell@…>
Date: Fri Aug 28 05:49:06 2015 -0700

Make checkpoint rev_sparse_jac bool case more like set case.


checkpoint.hpp: fix formating in documentation, set n, m in normal way.
checkpoint.cpp: extend test from set to both bool and set cases.

commit 4f295ecc0efcaead27b701c5e7265ebb6c9e29ba
Author: Brad Bell <bradbell@…>
Date: Thu Aug 27 09:21:25 2015 -0700

automatic freeing of sparsity patterns during forward mode calculations.

Location:
trunk
Files:
3 edited

Legend:

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

    r3712 r3713  
    4242$head Syntax$$
    4343$codei%checkpoint<%Base%> %atom_fun%(%name%, %algo%, %ax%, %ay%)
    44 %sv% = atom_fun%.size_var()
     44%sv% = %atom_fun%.size_var()
    4545%atom_fun%.option(%option_value%)
    4646%algo%(%ax%, %ay%)
     
    7575$lnext
    7676This object $icode atom_fun$$ must not be destructed for as long
    77 as any $code CppAD::ADFun<%Base%>$$ object use this atomic operation.
     77as any $codei%ADFun<%Base%>%$$ object uses its atomic operation.
    7878$lnext
    7979This class is implemented as a derived class of
     
    346346                bool ok  = true;
    347347                //
    348                 // repeat it every time forward zero is used.
     348                if( vx.size() == 0 )
     349                {       // during user forward mode
     350                        if( entire_jac_sparse_.n_set() == 0 )
     351                                entire_jac_sparse_.resize(0,0);
     352                        if( entire_hes_sparse_.n_set() == 0 )
     353                                entire_hes_sparse_.resize(0,0);
     354                }
    349355                if( vx.size() > 0 )
    350                 {       // Compute Jacobian sparsity pattern.
     356                {       // during user recording using this checkpoint function
     357                        if( entire_jac_sparse_.n_set() == 0 )
     358                                set_entire_jac_sparse();
    351359                        assert( entire_jac_sparse_.n_set() == m );
    352360                        assert( entire_jac_sparse_.end()   == n );
     361                        //
    353362                        for(size_t i = 0; i < m; i++)
    354363                        {       vy[i] = false;
     
    383392                      vector<Base>&       px ,
    384393                const vector<Base>&       py )
    385         {
     394        {       size_t n = f_.Domain();
     395                size_t m = f_.Range();
     396                CPPAD_ASSERT_UNKNOWN( n == tx.size() / (q+1) );
     397                CPPAD_ASSERT_UNKNOWN( m == ty.size() / (q+1) );
    386398                CPPAD_ASSERT_UNKNOWN( f_.size_var() > 0 );
    387399                CPPAD_ASSERT_UNKNOWN( tx.size() % (q+1) == 0 );
     
    393405                f_.Forward(q, tx);
    394406# else
    395                 size_t n = tx.size() / (q+1);
    396                 size_t m = ty.size() / (q+1);
    397407                CPPAD_ASSERT_UNKNOWN( px.size() == n * (q+1) );
    398408                CPPAD_ASSERT_UNKNOWN( py.size() == m * (q+1) );
     
    426436                const vector< std::set<size_t> >&       r  ,
    427437                      vector< std::set<size_t> >&       s  )
    428         {       assert( entire_jac_sparse_.n_set() != 0 );
    429                 assert( r.size() == f_.Domain() );
    430                 assert( s.size() == f_.Range() );
     438        {       // during user sparsity calculations
     439                size_t m = f_.Range();
     440                size_t n = f_.Domain();
     441                if( entire_jac_sparse_.n_set() == 0 )
     442                        set_entire_jac_sparse();
     443                assert( entire_jac_sparse_.n_set() == m );
     444                assert( entire_jac_sparse_.end()   == n );
     445                assert( r.size() == n );
     446                assert( s.size() == m );
    431447
    432448                bool ok = true;
    433                 size_t m = f_.Range();
    434                 size_t n = f_.Domain();
    435449                for(size_t i = 0; i < m; i++)
    436450                        s[i].clear();
     
    464478                const vector<bool>&                     r  ,
    465479                      vector<bool>&                     s  )
    466         {       assert( r.size() == f_.Domain() * q );
    467                 assert( s.size() == f_.Range() * q );
     480        {       // during user sparsity calculations
     481                size_t m = f_.Range();
     482                size_t n = f_.Domain();
     483                if( entire_jac_sparse_.n_set() == 0 )
     484                        set_entire_jac_sparse();
     485                assert( entire_jac_sparse_.n_set() == m );
     486                assert( entire_jac_sparse_.end()   == n );
     487                assert( r.size() == n * q );
     488                assert( s.size() == m * q );
     489                //
    468490                bool ok = true;
    469                 size_t m = f_.Range();
    470                 size_t n = f_.Domain();
    471491                for(size_t i = 0; i < m; i++)
    472492                {       for(size_t k = 0; k < q; k++)
    473493                                s[i * q + k] = false;
    474494                }
    475 
    476495                // sparsity for  s = entire_jac_sparse_ * r
    477496                for(size_t i = 0; i < m; i++)
     
    497516                const vector< std::set<size_t> >&       rt ,
    498517                      vector< std::set<size_t> >&       st )
    499         {       assert( rt.size() == f_.Range() );
    500                 assert( st.size() == f_.Domain() );
     518        {       // during user sparsity calculations
     519                size_t m = f_.Range();
     520                size_t n = f_.Domain();
     521                if( entire_jac_sparse_.n_set() == 0 )
     522                        set_entire_jac_sparse();
     523                assert( entire_jac_sparse_.n_set() == m );
     524                assert( entire_jac_sparse_.end()   == n );
     525                assert( rt.size() == m );
     526                assert( st.size() == n );
     527                //
    501528                bool ok  = true;
    502529                //
    503                 size_t m = f_.Range();
    504                 size_t n = f_.Domain();
    505530                for(size_t j = 0; j < n; j++)
    506531                        st[j].clear();
    507 
     532                //
    508533                // sparsity for  s = r * entire_jac_sparse_
    509534                // s^T = entire_jac_sparse_^T * r^T
     
    539564                const vector<bool>&                     rt ,
    540565                      vector<bool>&                     st )
    541         {       assert( rt.size() == f_.Range() * q );
    542                 assert( st.size() == f_.Domain() * q );
     566        {       // during user sparsity calculations
     567                size_t m = f_.Range();
     568                size_t n = f_.Domain();
     569                if( entire_jac_sparse_.n_set() == 0 )
     570                        set_entire_jac_sparse();
     571                assert( entire_jac_sparse_.n_set() == m );
     572                assert( entire_jac_sparse_.end()   == n );
     573                assert( rt.size() == m * q );
     574                assert( st.size() == n * q );
    543575                bool ok  = true;
    544576                //
    545                 size_t n = f_.Domain();
    546                 size_t m = f_.Range();
    547577                for(size_t j = 0; j < n; j++)
    548578                {       for(size_t k = 0; k < q; k++)
    549579                                st[j * q + k] = false;
    550580                }
    551 
     581                //
    552582                // sparsity for  s = r * entire_jac_sparse_
    553583                // s^T = entire_jac_sparse_^T * r^T
    554                 for(size_t k = 0; k < q; k++)
    555                 {       // compute row k of the return pattern s
    556                         for(size_t i = 0; i < m; i++)
    557                         {       if( rt[i * q + k] )
    558                                 {       entire_jac_sparse_.begin(i);
     584                for(size_t i = 0; i < m; i++)
     585                {       // i is the row index in r^T
     586                        for(size_t k = 0; k < q; k++)
     587                        {       // k is column index in r^T
     588                                if( rt[i * q + k] )
     589                                {       // i is column index in entire_sparse_jac^T
     590                                        entire_jac_sparse_.begin(i);
    559591                                        size_t j = entire_jac_sparse_.next_element();
    560592                                        while( j < n )
  • trunk/omh/whats_new/whats_new_15.omh

    r3712 r3713  
    6161assist you in learning about changes between various versions of CppAD.
    6262
     63$head 08-28$$
     64Free $cref checkpoint$$ function sparsity patters during
     65$cref forward$$ operations that use its atomic operation.
     66(They kept between sparsity calculations because they do not change.)
     67
    6368$head 08-26$$
    6469Fix a bug in $cref RevSparseJac$$ when used to compute sparsity pattern
  • trunk/test_more/checkpoint.cpp

    r3712 r3713  
    160160                ADFun<double> h(ax, ay);
    161161
    162                 // compute sparsity pattern h_1(x) = x[1] + x[2]
    163                 CppAD::vector< std::set<size_t> > r(1), s(1);
    164                 r[0].insert(1);
    165                 s = h.RevSparseJac(1, r);
     162                for(size_t k = 0; k < 2; k++)
     163                {       if( k == 0 )
     164                                h_check.option(CppAD::atomic_base<double>::bool_sparsity_enum);
     165                        else
     166                                h_check.option(CppAD::atomic_base<double>::set_sparsity_enum);
    166167
    167                 // check result
    168                 ok &= s[0] == std::set<size_t>{1, 2};
     168                        // compute sparsity pattern h_1(x) = x[1] + x[2]
     169                        CppAD::vector< std::set<size_t> > r(1), s(1);
     170                        r[0].insert(1);
     171                        s = h.RevSparseJac(1, r);
     172
     173                        // check result
     174                        ok &= s[0] == std::set<size_t>{1, 2};
     175                }
    169176
    170177                return ok;
Note: See TracChangeset for help on using the changeset viewer.