Changeset 3709


Ignore:
Timestamp:
Aug 18, 2015 4:22:12 PM (5 years ago)
Author:
bradbell
Message:

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

commit 85ef072f288db37cb6516d5688c8d11f8ec6774c
Author: Brad Bell <bradbell@…>
Date: Tue Aug 18 13:20:57 2015 -0700

Cacahe sparsity results in checkpoint functions so not recalcuated many times.

Location:
trunk
Files:
6 edited

Legend:

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

    r3708 r3709  
    155155                bool               set_type  ,
    156156                bool               transpose ,
     157                bool               dependency,
    157158                size_t             q         ,
    158159                const VectorSet&   r         ,
     
    165166                const std::set<size_t>&  set_type  ,
    166167                bool                     transpose ,
     168                bool                     dependency,
    167169                size_t                   q         ,
    168170                const VectorSet&         r         ,
     
    308310        template <typename VectorSet>
    309311        VectorSet ForSparseJac(
    310                 size_t q, const VectorSet &r, bool transpose = false
     312                size_t q, const VectorSet &r, bool transpose = false,
     313                bool dependency = false
    311314        );
    312315        // reverse mode Jacobian sparsity
  • trunk/cppad/local/checkpoint.hpp

    r3708 r3709  
    180180private:
    181181        ADFun<Base> f_;
     182        //
     183        // sparsity for f(x)^{(1)} (set by constructor)
     184        vector< std::set<size_t> > entire_jac_sparse_;
     185        //
     186        // sparsity for sum_i f_i(x)^{(2)}
     187        vector< std::set<size_t> > entire_hes_sparse_;
    182188public:
    183189        /*!
     
    219225                // 2DO: add a debugging mode that checks for changes and aborts
    220226                f_.compare_change_count(0);
     227                //
     228                // set sparsity for entire Jacobian once and for all
     229                assert( entire_jac_sparse_.size() == 0 );
     230                bool transpose  = false;
     231                bool dependency = true;
     232                size_t n = f_.Domain();
     233                size_t m = f_.Range();
     234                // It is not clear if forward or reverse is best in sparse case,
     235                // so use the best choice for the dense case (which this may be).
     236                if( n <= m )
     237                {       vector< std::set<size_t> > identity(n);
     238                        for(size_t j = 0; j < n; j++)
     239                                identity[j].insert(j);
     240                        entire_jac_sparse_ = f_.ForSparseJac(
     241                                n, identity, transpose, dependency
     242                        );
     243                        // drop the forward sparsity results from f_
     244                        f_.size_forward_set(0);
     245                }
     246                else
     247                {       vector< std::set<size_t> > identity(m);
     248                        for(size_t i = 0; i < m; i++)
     249                                identity[i].insert(i);
     250                        entire_jac_sparse_ = f_.RevSparseJac(
     251                                m, identity, transpose, dependency
     252                        );
     253                }
     254                CPPAD_ASSERT_UNKNOWN( f_.size_forward_set() == 0 );
     255                CPPAD_ASSERT_UNKNOWN( f_.size_forward_bool() == 0 );
    221256        }
    222257        /*!
     
    273308                // 2DO: test both forward and reverse vy information
    274309                if( vx.size() > 0 )
    275                 {       //Compute Jacobian sparsity pattern.
    276                         vector< std::set<size_t> > s(m);
    277                         if( n <= m )
    278                         {       vector< std::set<size_t> > r(n);
    279                                 for(j = 0; j < n; j++)
    280                                         r[j].insert(j);
    281                                 s = f_.ForSparseJac(n, r);
    282                         }
    283                         else
    284                         {       vector< std::set<size_t> > r(m);
    285                                 for(i = 0; i < m; i++)
    286                                         r[i].insert(i);
    287                                 s = f_.RevSparseJac(m, r);
    288                         }
    289                         std::set<size_t>::const_iterator itr;
     310                {       // Compute Jacobian sparsity pattern.
     311                        assert( entire_jac_sparse_.size() > 0 );
    290312                        for(i = 0; i < m; i++)
    291313                        {       vy[i] = false;
    292                                 for(itr = s[i].begin(); itr != s[i].end(); itr++)
     314                                std::set<size_t>::const_iterator itr;
     315                                const std::set<size_t>& s_i( entire_jac_sparse_[i] );
     316                                for(itr = s_i.begin(); itr != s_i.end(); itr++)
    293317                                {       j = *itr;
    294318                                        assert( j < n );
     
    302326                // no longer need the Taylor coefficients in f_
    303327                // (have to reconstruct them every time)
     328                // Hold onto sparsity pattern because it is always good.
    304329                size_t c = 0;
    305330                size_t r = 0;
     
    353378        }
    354379        /*!
    355         Link from user_atomic to forward sparse Jacobian
     380        Link from user_atomic to forward sparse Jacobian sets
    356381
    357382        \copydetails atomic_base::for_sparse_jac
     
    361386                const vector< std::set<size_t> >&       r  ,
    362387                      vector< std::set<size_t> >&       s  )
    363         {
     388        {       assert( entire_jac_sparse_.size() != 0 );
     389                assert( r.size() == f_.Domain() );
     390                assert( s.size() == f_.Range() );
     391
    364392                bool ok = true;
    365                 s = f_.ForSparseJac(q, r);
    366 
    367                 // no longer need the forward mode sparsity pattern
    368                 // (have to reconstruct them every time)
    369                 f_.size_forward_set(0);
     393                size_t m = f_.Range();
     394                for(size_t i = 0; i < m; i++)
     395                        s[i].clear();
     396
     397                // sparsity for  s = entire_jac_sparse_ * r
     398                for(size_t i = 0; i < m; i++)
     399                {       // compute row i of the return pattern
     400                        std::set<size_t>::const_iterator itr_i;
     401                        const std::set<size_t>& jac_i( entire_jac_sparse_[i] );
     402                        for(itr_i = jac_i.begin(); itr_i != jac_i.end(); itr_i++)
     403                        {       size_t j = *itr_i;
     404                                assert( j < f_.Domain() );
     405                                std::set<size_t>::const_iterator itr_j;
     406                                const std::set<size_t>& r_j( r[j] );
     407                                for(itr_j = r_j.begin(); itr_j != r_j.end(); itr_j++)
     408                                {       size_t k = *itr_j;
     409                                        assert( k < q );
     410                                        s[i].insert(k);
     411                                }
     412                        }
     413                }
    370414
    371415                return ok;
    372416        }
    373417        /*!
    374         Link from user_atomic to forward sparse Jacobian
     418        Link from user_atomic to forward sparse Jacobian bools
    375419
    376420        \copydetails atomic_base::for_sparse_jac
     
    380424                const vector<bool>&                     r  ,
    381425                      vector<bool>&                     s  )
    382         {
     426        {       assert( r.size() == f_.Domain() * q );
     427                assert( s.size() == f_.Range() * q );
    383428                bool ok = true;
    384                 s = f_.ForSparseJac(q, r);
    385 
    386                 // no longer need the forward mode sparsity pattern
    387                 // (have to reconstruct them every time)
    388                 f_.size_forward_bool(0);
     429                size_t m = f_.Range();
     430                for(size_t i = 0; i < m; i++)
     431                {       for(size_t k = 0; k < q; k++)
     432                                s[i * q + k] = false;
     433                }
     434
     435                // sparsity for  s = entire_jac_sparse_ * r
     436                for(size_t i = 0; i < m; i++)
     437                {       // compute row i of the return pattern
     438                        std::set<size_t>::const_iterator itr_i;
     439                        const std::set<size_t>& jac_i( entire_jac_sparse_[i] );
     440                        for(itr_i = jac_i.begin(); itr_i != jac_i.end(); itr_i++)
     441                        {       size_t j = *itr_i;
     442                                assert( j < f_.Domain() );
     443                                for(size_t k = 0; k < q; k++)
     444                                        s[i * q + k] |= r[j * q + k ];
     445                        }
     446                }
    389447
    390448                return ok;
    391449        }
    392450        /*!
    393         Link from user_atomic to forward sparse Jacobian
     451        Link from user_atomic to reverse Jacobian sets
    394452
    395453        \copydetails atomic_base::rev_sparse_jac
     
    399457                const vector< std::set<size_t> >&       rt ,
    400458                      vector< std::set<size_t> >&       st )
    401         {
     459        {       assert( rt.size() == f_.Range() );
     460                assert( st.size() == f_.Domain() );
    402461                bool ok  = true;
    403 
    404                 // compute rt
    405                 // 2DO: remove need for dependency all the time. It is only really
    406                 // necessary when optimizer calls this member function.
    407                 bool transpose = true;
    408                 bool dependency = true;
    409                 st = f_.RevSparseJac(q, rt, transpose, dependency);
     462                //
     463                size_t n = f_.Domain();
     464                for(size_t j = 0; j < n; j++)
     465                        st[j].clear();
     466
     467                // sparsity for  s = r * entire_jac_sparse_
     468                // s^T = entire_jac_sparse_^T * r^T
     469                for(size_t k = 0; k < q; k++)
     470                {       // compute row k of the return pattern s
     471                        std::set<size_t>::const_iterator itr_k;
     472                        const std::set<size_t>& r_k( rt[k] );
     473                        for(itr_k = r_k.begin(); itr_k != r_k.end(); itr_k++)
     474                        {       size_t i = *itr_k;
     475                                assert( i < f_.Range() );
     476                                std::set<size_t>::const_iterator itr_i;
     477                                const std::set<size_t>& jac_i( entire_jac_sparse_[i] );
     478                                for(itr_i = jac_i.begin(); itr_i != jac_i.end(); itr_i++)
     479                                {       size_t j = *itr_i;
     480                                        assert( j < n );
     481                                        st[j].insert(k);
     482                                }
     483                        }
     484                }
    410485
    411486                return ok;
    412487        }
    413488        /*!
    414         Link from user_atomic to forward sparse Jacobian
     489        Link from user_atomic to reverse sparse Jacobian sets
    415490
    416491        \copydetails atomic_base::rev_sparse_jac
     
    420495                const vector<bool>&                     rt ,
    421496                      vector<bool>&                     st )
    422         {
     497        {       assert( rt.size() == f_.Range() * q );
     498                assert( st.size() == f_.Domain() * q );
    423499                bool ok  = true;
    424 
    425                 // compute rt
    426                 bool transpose  = true;
    427                 bool dependency = true;
    428                 // 2DO: remove need for dependency all the time. It is only really
    429                 // necessary when optimizer calls this member function.
    430                 st = f_.RevSparseJac(q, rt, transpose, dependency);
     500                //
     501                size_t n = f_.Domain();
     502                size_t m = f_.Range();
     503                for(size_t j = 0; j < n; j++)
     504                {       for(size_t k = 0; k < q; k++)
     505                                st[j * q + k] = false;
     506                }
     507
     508                // sparsity for  s = r * entire_jac_sparse_
     509                // s^T = entire_jac_sparse_^T * r^T
     510                for(size_t k = 0; k < q; k++)
     511                {       // compute row k of the return pattern s
     512                        for(size_t i = 0; i < m; i++)
     513                        {       if( rt[i * q + k] )
     514                                {       std::set<size_t>::const_iterator itr_i;
     515                                        const std::set<size_t>& jac_i( entire_jac_sparse_[i] );
     516                                        for(itr_i = jac_i.begin(); itr_i != jac_i.end(); itr_i++)
     517                                        {       size_t j = *itr_i;
     518                                                assert( j < n );
     519                                                st[j * q + k ] = true;
     520                                        }
     521                                }
     522                        }
     523                }
    431524
    432525                return ok;
    433526        }
    434527        /*!
    435         Link from user_atomic to forward sparse Jacobian
     528        Link from user_atomic to reverse sparse Hessian sets
    436529
    437530        \copydetails atomic_base::rev_sparse_hes
     
    445538                const vector< std::set<size_t> >&       u  ,
    446539                      vector< std::set<size_t> >&       v  )
    447         {       size_t n       = v.size();
    448                 size_t m       = u.size();
    449                 CPPAD_ASSERT_UNKNOWN( r.size() == v.size() );
    450                 CPPAD_ASSERT_UNKNOWN( s.size() == m );
    451                 CPPAD_ASSERT_UNKNOWN( t.size() == n );
     540        {       size_t n = f_.Domain();
     541                size_t m = f_.Range();
     542                CPPAD_ASSERT_UNKNOWN( vx.size() == n );
     543                CPPAD_ASSERT_UNKNOWN(  s.size() == m );
     544                CPPAD_ASSERT_UNKNOWN(  t.size() == n );
     545                CPPAD_ASSERT_UNKNOWN(  r.size() == n );
     546                CPPAD_ASSERT_UNKNOWN(  u.size() == m );
     547                CPPAD_ASSERT_UNKNOWN(  v.size() == n );
     548                //
    452549                bool ok        = true;
    453                 bool transpose = true;
    454                 std::set<size_t>::const_iterator itr;
     550
     551                // make sure entire_hes_sparse_ is set
     552                if( entire_hes_sparse_.size() == 0 )
     553                {
     554                        // set version of sparsity for vector of all ones
     555                        vector< std::set<size_t> > all_one(1);
     556                        CPPAD_ASSERT_UNKNOWN( all_one[0].empty() );
     557                        for(size_t i = 0; i < m; i++)
     558                                all_one[0].insert(i);
     559
     560                        // set version of sparsity for n by n idendity matrix
     561                        vector< std::set<size_t> > identity(n);
     562                        for(size_t j = 0; j < n; j++)
     563                                identity[j].insert(j);
     564
     565                        // compute sparsity pattern for H(x) = sum_i f_i(x)^{(2)}
     566                        bool transpose  = false;
     567                        bool dependency = false;
     568                        f_.ForSparseJac(n, identity, transpose, dependency);
     569                        entire_hes_sparse_ = f_.RevSparseHes(n, all_one, transpose);
     570
     571                        // drop the forward sparsity results from f_
     572                        f_.size_forward_set(0);
     573                }
    455574
    456575                // compute sparsity pattern for T(x) = S(x) * f'(x)
     
    466585
    467586                // compute sparsity pattern for A(x) = f'(x)^T * U(x)
     587                bool transpose = true;
    468588                vector< std::set<size_t> > a(n);
    469589                a = f_.RevSparseJac(q, u, transpose);
    470590
    471                 // set version of s
    472                 vector< std::set<size_t> > set_s(1);
    473                 CPPAD_ASSERT_UNKNOWN( set_s[0].empty() );
    474                 size_t i;
    475                 for(i = 0; i < m; i++)
    476                         if( s[i] )
    477                                 set_s[0].insert(i);
    478 
    479                 // compute sparsity pattern for H(x) = (S(x) * F)''(x) * R
    480                 // (store it in v)
    481                 f_.ForSparseJac(q, r);
    482                 v = f_.RevSparseHes(q, set_s, transpose);
    483 
     591                // Need sparsity pattern for H(x) = (S(x) * f(x))''(x) * R,
     592                // but use less efficient sparsity for  f(x)''(x) * R so that
     593                // entire_hes_sparse_ can be used every time this is needed.
     594                for(size_t i = 0; i < n; i++)
     595                {       v[i].clear();
     596                        std::set<size_t>::const_iterator itr_i;
     597                        const std::set<size_t>& hes_i( entire_hes_sparse_[i] );
     598                        for(itr_i = hes_i.begin(); itr_i != hes_i.end(); itr_i++)
     599                        {       size_t j = *itr_i;
     600                                assert( j < n );
     601                                std::set<size_t>::const_iterator itr_j;
     602                                const std::set<size_t>& r_j( r[j] );
     603                                for(itr_j = r_j.begin(); itr_j != r_j.end(); itr_j++)
     604                                {       size_t k = *itr_j;
     605                                        v[i].insert(k);
     606                                }
     607                        }
     608                }
    484609                // compute sparsity pattern for V(x) = A(x) + H(x)
    485                 for(i = 0; i < n; i++)
     610                std::set<size_t>::const_iterator itr;
     611                for(size_t i = 0; i < n; i++)
    486612                {       for(itr = a[i].begin(); itr != a[i].end(); itr++)
    487613                        {       size_t j = *itr;
     
    491617                }
    492618
    493                 // no longer need the forward mode sparsity pattern
    494                 // (have to reconstruct them every time)
    495                 f_.size_forward_set(0);
    496 
    497619                return ok;
    498620        }
    499621        /*!
    500         Link from user_atomic to forward sparse Jacobian
     622        Link from user_atomic to reverse sparse Hessian  bools
    501623
    502624        \copydetails atomic_base::rev_sparse_hes
     
    510632                const vector<bool>&                     u  ,
    511633                      vector<bool>&                     v  )
    512         {
    513                 CPPAD_ASSERT_UNKNOWN( r.size() == v.size() );
    514                 CPPAD_ASSERT_UNKNOWN( s.size() == u.size() / q );
    515                 CPPAD_ASSERT_UNKNOWN( t.size() == v.size() / q );
    516                 size_t n       = t.size();
     634        {       size_t n = f_.Domain();
     635                size_t m = f_.Range();
     636                CPPAD_ASSERT_UNKNOWN( vx.size() == n );
     637                CPPAD_ASSERT_UNKNOWN(  s.size() == m );
     638                CPPAD_ASSERT_UNKNOWN(  t.size() == n );
     639                CPPAD_ASSERT_UNKNOWN(  r.size() == n * q );
     640                CPPAD_ASSERT_UNKNOWN(  u.size() == m * q );
     641                CPPAD_ASSERT_UNKNOWN(  v.size() == n * q );
     642                //
    517643                bool ok        = true;
    518                 bool transpose = true;
    519                 std::set<size_t>::const_iterator itr;
    520                 size_t i, j;
     644
     645                // make sure entire_hes_sparse_ is set
     646                if( entire_hes_sparse_.size() == 0 )
     647                {
     648                        // set version of sparsity for vector of all ones
     649                        vector< std::set<size_t> > all_one(1);
     650                        CPPAD_ASSERT_UNKNOWN( all_one[0].empty() );
     651                        for(size_t i = 0; i < m; i++)
     652                                all_one[0].insert(i);
     653
     654                        // set version of sparsity for n by n idendity matrix
     655                        vector< std::set<size_t> > identity(n);
     656                        for(size_t j = 0; j < n; j++)
     657                                identity[j].insert(j);
     658
     659                        // compute sparsity pattern for H(x) = sum_i f_i(x)^{(2)}
     660                        bool transpose  = false;
     661                        bool dependency = false;
     662                        f_.ForSparseJac(n, identity, transpose, dependency);
     663                        entire_hes_sparse_ = f_.RevSparseHes(n, all_one, transpose);
     664
     665                        // drop the forward sparsity results from f_
     666                        f_.size_forward_set(0);
     667                }
    521668
    522669                // compute sparsity pattern for T(x) = S(x) * f'(x)
    523670                t = f_.RevSparseJac(1, s);
    524671# ifndef NDEBUG
    525                 for(j = 0; j < n; j++)
     672                for(size_t j = 0; j < n; j++)
    526673                        CPPAD_ASSERT_UNKNOWN( vx[j] || ! t[j] )
    527674# endif
     
    532679
    533680                // compute sparsity pattern for A(x) = f'(x)^T * U(x)
     681                bool transpose = true;
    534682                vector<bool> a(n * q);
    535683                a = f_.RevSparseJac(q, u, transpose);
    536684
    537                 // compute sparsity pattern for H(x) =(S(x) * F)''(x) * R
    538                 // (store it in v)
    539                 f_.ForSparseJac(q, r);
    540                 v = f_.RevSparseHes(q, s, transpose);
     685                // Need sparsity pattern for H(x) = (S(x) * f(x))''(x) * R,
     686                // but use less efficient sparsity for  f(x)''(x) * R so that
     687                // entire_hes_sparse_ can be used every time this is needed.
     688                for(size_t i = 0; i < n; i++)
     689                {       for(size_t k = 0; k < q; k++)
     690                                v[i * q + k] = false;
     691                        std::set<size_t>::const_iterator itr_i;
     692                        const std::set<size_t>& hes_i( entire_hes_sparse_[i] );
     693                        for(itr_i = hes_i.begin(); itr_i != hes_i.end(); itr_i++)
     694                        {       size_t j = *itr_i;
     695                                assert( j < n );
     696                                for(size_t k = 0; k < q; k++)
     697                                        v[i * q + k] |= r[ j * q + k ];
     698                        }
     699                }
    541700
    542701                // compute sparsity pattern for V(x) = A(x) + H(x)
    543                 for(i = 0; i < n; i++)
    544                 {       for(j = 0; j < q; j++)
    545                                 v[ i * q + j ] |= a[ i * q + j];
    546                 }
    547 
    548                 // no longer need the forward mode sparsity pattern
    549                 // (have to reconstruct them every time)
    550                 f_.size_forward_set(0);
     702                for(size_t i = 0; i < n; i++)
     703                {       for(size_t k = 0; k < q; k++)
     704                                v[ i * q + k ] |= a[ i * q + k];
     705                }
    551706
    552707                return ok;
  • trunk/cppad/local/cond_op.hpp

    r3708 r3709  
    951951<!-- end sparse_conditional_exp_op -->
    952952
     953\param dependency
     954Are the derivatives with respect to left and right of the expression below
     955considered to be non-zero:
     956\code
     957        CondExpRel(left, right, if_true, if_false)
     958\endcode
     959This is used by the optimizer to obtain the correct dependency relations.
     960
    953961\param sparsity
    954962\b Input:
     
    972980template <class Vector_set>
    973981inline void forward_sparse_jacobian_cond_op(
     982        bool               dependency    ,
    974983        size_t             i_z           ,
    975984        const addr_t*      arg           ,
     
    989998        }
    990999# endif
     1000        sparsity.clear(i_z);
     1001        if( dependency )
     1002        {       if( arg[1] & 1 )
     1003                        sparsity.binary_union(i_z, i_z, arg[2], sparsity);
     1004                if( arg[1] & 2 )
     1005                        sparsity.binary_union(i_z, i_z, arg[3], sparsity);
     1006        }
    9911007        if( arg[1] & 4 )
    992         {
    993                 if( arg[1] & 8 )
    994                 {
    995                         sparsity.binary_union(i_z, arg[4], arg[5], sparsity);
    996                 }
    997                 else
    998                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
    999                         sparsity.assignment(i_z, arg[4], sparsity);
    1000                 }
    1001         }
    1002         else
    1003         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
    1004                 if( arg[1] & 8 )
    1005                 {
    1006                         sparsity.assignment(i_z, arg[5], sparsity);
    1007                 }
    1008                 else
    1009                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
    1010                         sparsity.clear(i_z);
    1011                 }
    1012         }
     1008                sparsity.binary_union(i_z, i_z, arg[4], sparsity);
     1009        if( arg[1] & 8 )
     1010                sparsity.binary_union(i_z, i_z, arg[5], sparsity);
    10131011        return;
    10141012}
     
    11431141        if( dependency )
    11441142        {       if( arg[1] & 1 )
    1145                 {
    11461143                        sparsity.binary_union(arg[2], arg[2], i_z, sparsity);
    1147                 }
    11481144                if( arg[1] & 2 )
    1149                 {
    11501145                        sparsity.binary_union(arg[3], arg[3], i_z, sparsity);
    1151                 }
    11521146        }
    11531147        // --------------------------------------------------------------------
    11541148        if( arg[1] & 4 )
    1155         {
    11561149                sparsity.binary_union(arg[4], arg[4], i_z, sparsity);
    1157         }
    11581150        if( arg[1] & 8 )
    1159         {
    11601151                sparsity.binary_union(arg[5], arg[5], i_z, sparsity);
    1161         }
    11621152        return;
    11631153}
  • trunk/cppad/local/for_jac_sweep.hpp

    r3685 r3709  
    6363\c sparse_pack, \c sparse_set, or \c sparse_list.
    6464
     65\param dependency
     66Are the derivatives with respect to left and right of the expression below
     67considered to be non-zero:
     68\code
     69        CondExpRel(left, right, if_true, if_false)
     70\endcode
     71This is used by the optimizer to obtain the correct dependency relations.
     72
    6573\param n
    6674is the number of independent variables on the tape.
     
    100108template <class Base, class Vector_set>
    101109void ForJacSweep(
     110        bool                  dependency   ,
    102111        size_t                n            ,
    103112        size_t                numvar       ,
     
    304313                        case CExpOp:
    305314                        forward_sparse_jacobian_cond_op(
    306                                 i_var, arg, num_par, var_sparsity
     315                                dependency, i_var, arg, num_par, var_sparsity
    307316                        );
    308317                        break;
  • trunk/cppad/local/for_sparse_jac.hpp

    r3651 r3709  
    2525        proportional
    2626        VecAD
     27        CondExpRel
     28        optimizer
    2729$$
    2830
     
    126128The default value $code false$$ is used when $icode transpose$$ is not present.
    127129
     130$head dependency$$
     131The argument $icode dependency$$ has prototype
     132$codei%
     133        bool %dependency%
     134%$$
     135If $icode dependency$$ is true,
     136the derivatives with respect to left and right of the
     137$cref CondExp$$ below are considered to be non-zero:
     138$codei%
     139        %CondExp%Rel%(%left%, %right%, %if_true%, %if_false%)
     140%$$
     141This is used by the
     142$cref/optimizer/optimize/$$ with $cref checkpoint$$ functions
     143to obtain the correct dependency relations.
     144The default value $icode%dependency% = false%$$ is used when
     145$icode dependency$$ is not present.
     146
    128147
    129148$head r$$
     
    233252\param transpose
    234253are the sparsity patterns transposed.
     254
     255\param dependency
     256Are the derivatives with respect to left and right of the expression below
     257considered to be non-zero:
     258\code
     259    CondExpRel(left, right, if_true, if_false)
     260\endcode
     261This is used by the optimizer to obtain the correct dependency relations.
    235262
    236263\param q
     
    277304void ForSparseJacBool(
    278305        bool                   transpose        ,
     306        bool                   dependency       ,
    279307        size_t                 q                ,
    280308        const VectorSet&       r                ,
     
    325353        // evaluate the sparsity patterns
    326354        ForJacSweep(
     355                dependency,
    327356                n,
    328357                total_num_var,
     
    374403see \c SparseJacBool.
    375404
     405\param dependency
     406see \c SparseJacBool.
     407
    376408\param q
    377409see \c SparseJacBool.
     
    402434void ForSparseJacSet(
    403435        bool                        transpose        ,
     436        bool                        dependency       ,
    404437        size_t                      q                ,
    405438        const VectorSet&            r                ,
     
    475508        // evaluate the sparsity patterns
    476509        ForJacSweep(
     510                dependency,
    477511                n,
    478512                total_num_var,
     
    512546
    513547\param transpose
    514 See \c ForSparseJac(q, r).
     548See \c ForSparseJac(q, r, transpose, dependency).
     549
     550\param dependency
     551See \c ForSparseJac(q, r, transpose, dependency).
    515552
    516553\param q
    517 See \c ForSparseJac(q, r).
     554See \c ForSparseJac(q, r, transpose, dependency).
    518555
    519556\param r
    520 See \c ForSparseJac(q, r).
     557See \c ForSparseJac(q, r, transpose, dependency).
    521558
    522559\param s
     
    529566        bool                set_type      ,
    530567        bool                transpose     ,
     568        bool                dependency    ,
    531569        size_t              q             ,
    532570        const VectorSet&    r             ,
     
    543581        ForSparseJacBool(
    544582                transpose        ,
     583                dependency       ,
    545584                q                ,
    546585                r                ,
     
    567606
    568607\param transpose
    569 See \c ForSparseJac(q, r).
     608See \c ForSparseJac(q, r, transpose, dependency).
     609
     610\param dependency
     611See \c ForSparseJac(q, r, transpose, dependency).
    570612
    571613\param q
    572 See \c ForSparseJac(q, r).
     614See \c ForSparseJac(q, r, transpose, dependency).
    573615
    574616\param r
    575 See \c ForSparseJac(q, r).
     617See \c ForSparseJac(q, r, transpose, dependency).
    576618
    577619\param s
     
    583625        const std::set<size_t>&    set_type      ,
    584626        bool                       transpose     ,
     627        bool                       dependency    ,
    585628        size_t                     q             ,
    586629        const VectorSet&           r             ,
     
    601644        CppAD::ForSparseJacSet(
    602645                transpose        ,
     646                dependency       ,
    603647                q                ,
    604648                r                ,
     
    618662The C++ source code corresponding to this operation is
    619663\verbatim
    620         s = f.ForSparseJac(q, r)
     664        s = f.ForSparseJac(q, r, transpose, dependency)
    621665\endverbatim
    622666
     
    636680\param transpose
    637681are sparsity patterns for \f$ R \f$ and \f$ S(x) \f$ transposed.
     682
     683\param dependency
     684Are the derivatives with respect to left and right of the expression below
     685considered to be non-zero:
     686\code
     687        CondExpRel(left, right, if_true, if_false)
     688\endcode
     689This is used by the optimizer to obtain the correct dependency relations.
    638690
    639691\return
     
    683735        size_t             q             ,
    684736        const VectorSet&   r             ,
    685         bool               transpose     )
     737        bool               transpose     ,
     738        bool               dependency    )
    686739{       VectorSet s;
    687740        typedef typename VectorSet::value_type Set_type;
     
    694747                Set_type()  ,
    695748                transpose   ,
     749                dependency  ,
    696750                q           ,
    697751                r           ,
  • trunk/omh/whats_new/whats_new_15.omh

    r3708 r3709  
    6363$head 08-17$$
    6464$list number$$
     65Do some optimization of the
     66$cref checkpoint$$ feature so that sparsity patterns are
     67stored and not recalculated.
     68$lnext
    6569Fix a warning (introduced on 08-11) where the $code CppAD::vector$$
    6670$cref/data/CppAD_vector/data/$$ function was being shadowed by
Note: See TracChangeset for help on using the changeset viewer.