// driver for all of the cases above bool bool_sparsity(void) { bool ok = true; // // record the funcion size_t n = 100; size_t m = n + 1; vector< AD<double> > x(n), y(m); for(size_t j = 0; j < n; j++) x[j] = AD<double>(j+1); CppAD::Independent(x); y = fun(x); ADFun<double> f(x, y); // // run the three example / tests ok &= for_sparse_jac(f); ok &= rev_sparse_jac(f); ok &= rev_sparse_hes(f); return ok; }
bool atomic_base<Base>::rev_sparse_hes( const vector<Base>& x , const local::pod_vector<size_t>& x_index , const local::pod_vector<size_t>& y_index , const InternalSparsity& for_jac_sparsity , bool* rev_jac_flag , InternalSparsity& rev_hes_sparsity ) { CPPAD_ASSERT_UNKNOWN( for_jac_sparsity.end() == rev_hes_sparsity.end() ); size_t q = rev_hes_sparsity.end(); size_t n = x_index.size(); size_t m = y_index.size(); bool ok = false; size_t thread = thread_alloc::thread_num(); allocate_work(thread); bool zero_empty = true; bool input_empty = false; bool transpose = false; // // vx vector<bool> vx(n); for(size_t j = 0; j < n; j++) vx[j] = x_index[j] != 0; // // note that s and t are vectors so transpose does not matter for bool case vector<bool> bool_s( work_[thread]->bool_s ); vector<bool> bool_t( work_[thread]->bool_t ); // bool_s.resize(m); bool_t.resize(n); // for(size_t i = 0; i < m; i++) { if( y_index[i] > 0 ) bool_s[i] = rev_jac_flag[ y_index[i] ]; } // std::string msg = ": atomic_base.rev_sparse_hes: returned false"; if( sparsity_ == pack_sparsity_enum ) { vectorBool& pack_r( work_[thread]->pack_r ); vectorBool& pack_u( work_[thread]->pack_u ); vectorBool& pack_v( work_[thread]->pack_h ); // pack_v.resize(n * q); // local::get_internal_sparsity( transpose, x_index, for_jac_sparsity, pack_r ); local::get_internal_sparsity( transpose, y_index, rev_hes_sparsity, pack_u ); // ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v, x); if( ! ok ) ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v); if( ! ok ) { msg = afun_name() + msg + " sparsity = pack_sparsity_enum"; CPPAD_ASSERT_KNOWN(false, msg.c_str()); } local::set_internal_sparsity(zero_empty, input_empty, transpose, x_index, rev_hes_sparsity, pack_v ); } else if( sparsity_ == bool_sparsity_enum ) { vector<bool>& bool_r( work_[thread]->bool_r ); vector<bool>& bool_u( work_[thread]->bool_u ); vector<bool>& bool_v( work_[thread]->bool_h ); // bool_v.resize(n * q); // local::get_internal_sparsity( transpose, x_index, for_jac_sparsity, bool_r ); local::get_internal_sparsity( transpose, y_index, rev_hes_sparsity, bool_u ); // ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v, x); if( ! ok ) ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v); if( ! ok ) { msg = afun_name() + msg + " sparsity = bool_sparsity_enum"; CPPAD_ASSERT_KNOWN(false, msg.c_str()); } local::set_internal_sparsity(zero_empty, input_empty, transpose, x_index, rev_hes_sparsity, bool_v ); } else { CPPAD_ASSERT_UNKNOWN( sparsity_ == set_sparsity_enum ); vector< std::set<size_t> >& set_r( work_[thread]->set_r ); vector< std::set<size_t> >& set_u( work_[thread]->set_u ); vector< std::set<size_t> >& set_v( work_[thread]->set_h ); // set_v.resize(n); // local::get_internal_sparsity( transpose, x_index, for_jac_sparsity, set_r ); local::get_internal_sparsity( transpose, y_index, rev_hes_sparsity, set_u ); // ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v, x); if( ! ok ) ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v); if( ! ok ) { msg = afun_name() + msg + " sparsity = set_sparsity_enum"; CPPAD_ASSERT_KNOWN(false, msg.c_str()); } local::set_internal_sparsity(zero_empty, input_empty, transpose, x_index, rev_hes_sparsity, set_v ); } for(size_t j = 0; j < n; j++) { if( x_index[j] > 0 ) rev_jac_flag[ x_index[j] ] |= bool_t[j]; } return ok; }