1 # ifndef CPPAD_LOCAL_REV_HES_SWEEP_HPP
2 # define CPPAD_LOCAL_REV_HES_SWEEP_HPP
15 namespace CppAD {
namespace local {
27 # define CPPAD_REV_HES_SWEEP_TRACE 0
94 template <
class Base,
class Vector_set>
99 const Vector_set& for_jac_sparse,
101 Vector_set& rev_hes_sparse
108 const addr_t* arg = CPPAD_NULL;
122 size_t limit = rev_hes_sparse.end();
127 for_jac_sparse.n_set() == rev_hes_sparse.n_set()
135 Vector_set vecad_sparse;
138 if( num_vecad_vec > 0 )
140 vecad_sparse.
resize(num_vecad_vec, limit);
141 vecad_ind.
extend(num_vecad_ind);
142 vecad_jac.
extend(num_vecad_vec);
144 for(i = 0; i < num_vecad_vec; i++)
150 for(k = 1; k <= length; k++)
151 vecad_ind[j+k] = num_vecad_vec;
155 vecad_jac[i] =
false;
170 size_t user_old=0, user_m=0, user_n=0, user_i=0, user_j=0;
177 const Base* parameter = CPPAD_NULL;
179 parameter = play->
GetPar();
185 # if CPPAD_REV_HES_SWEEP_TRACE
186 std::cout << std::endl;
190 bool more_operators =
true;
191 while(more_operators)
203 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
211 i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
219 i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
228 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
233 # if CPPAD_USE_CPLUSPLUS_2011
238 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
248 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
253 # if CPPAD_USE_CPLUSPLUS_2011
258 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
268 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
273 # if CPPAD_USE_CPLUSPLUS_2011
278 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
286 more_operators =
false;
296 i_var, arg, RevJac, rev_hes_sparse
303 i_var, arg, num_par, RevJac, rev_hes_sparse
312 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
321 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
335 i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
343 i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
351 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
361 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
369 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
374 # if CPPAD_USE_CPLUSPLUS_2011
378 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
437 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
442 # if CPPAD_USE_CPLUSPLUS_2011
446 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
455 i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
463 i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
477 i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
485 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
493 i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
513 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
522 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
530 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
578 i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
586 i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
594 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
603 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
612 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
623 user_atom = play->
get_user_info(op, arg, user_old, user_m, user_n);
639 user_x, user_ix, user_iy,
640 for_jac_sparse, RevJac, rev_hes_sparse
655 user_x[user_j] = parameter[arg[0]];
674 user_ix[user_j] = arg[0];
703 user_iy[user_i] = i_var;
713 i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
721 i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
729 i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
738 # if CPPAD_REV_HES_SWEEP_TRACE
739 for(j = 0; j < limit; j++)
740 { zf_value[j] =
false;
743 typename Vector_set::const_iterator itr_jac(for_jac_sparse, i_var);
746 { zf_value[j] =
true;
749 typename Vector_set::const_iterator itr_hes(rev_hes_sparse, i_var);
752 { zh_value[j] =
true;
772 std::cout << std::endl;
774 std::cout << std::endl;
787 # undef CPPAD_REV_HES_SWEEP_TRACE
void resize(size_t n)
resize the vector (existing elements preserved when n <= capacity_).
size_t num_par_rec(void) const
Fetch number of parameters in the recording.
size_t extend(size_t n)
Increase the number of elements the end of this vector (existing elements are always preserved)...
void printOpResult(std::ostream &os, size_t nfz, const Value *fz, size_t nrz, const Value *rz)
Prints the result values correspnding to an operator.
size_t num_vec_ind_rec(void) const
Fetch number of VecAD indices in the recording.
CPPAD_TAPE_ADDR_TYPE addr_t
static Float quiet_NaN(void)
not a number
next UsrrpOp (UsrrvOp) is a parameter (variable) result
void reverse_sparse_hessian_addsub_op(size_t i_z, const addr_t *arg, bool *jac_reverse, const Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for add and subtract operators.
size_t NumArg(OpCode op)
Number of arguments for a specified operator.
Class used to store and play back an operation sequence recording.
size_t GetVecInd(size_t i) const
Fetch a VecAD index from the recording.
void resize(size_t n)
change the number of elements in this vector.
size_t NumRes(OpCode op)
Number of variables resulting from the specified operation.
next UserOp marks end of a user atomic call
atomic_base< Base > * get_user_info(const OpCode op, const addr_t *op_arg, size_t &user_old, size_t &user_m, size_t &user_n) const
unpack extra information corresponding to a UserOp
void reverse_sparse_hessian_nonlinear_unary_op(size_t i_z, size_t i_x, bool *rev_jacobian, const Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for non-linear unary operators.
void rev_hes_sweep(const local::player< Base > *play, size_t n, size_t numvar, const Vector_set &for_jac_sparse, bool *RevJac, Vector_set &rev_hes_sparse)
Given the forward Jacobian sparsity pattern for all the variables, and the reverse Jacobian sparsity ...
virtual void set_old(size_t id)
Set value of id (used by deprecated old_atomic class)
OpCode
Type used to distinguish different AD< Base > atomic operations.
next UserOp marks beginning of a user atomic call
void get_op_info(size_t op_index, OpCode &op, const addr_t *&op_arg, size_t &var_index) const
fetch the information corresponding to an operator
void reverse_sparse_hessian_cond_op(size_t i_z, const addr_t *arg, size_t num_par, bool *jac_reverse, Vector_set &hes_sparsity)
Compute reverse Hessian sparsity patterns for op = CExpOp.
size_t num_vecad_vec_rec(void) const
Fetch number of VecAD vectors in the recording.
Type * data(void)
current data pointer is no longer valid after any of the following: extend, erase, operator=, and ~pod_vector. Take extreem care when using this function.
void reverse_sparse_hessian_linear_unary_op(size_t i_z, size_t i_x, bool *rev_jacobian, const Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for linear unary operators.
next UsrapOp (UsravOp) is a parameter (variable) argument
void reverse_sparse_hessian_pow_op(size_t i_z, const addr_t *arg, bool *jac_reverse, const Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for power function.
virtual bool rev_sparse_hes(const vector< bool > &vx, const vector< bool > &s, vector< bool > &t, size_t q, const vector< std::set< size_t > > &r, const vector< std::set< size_t > > &u, vector< std::set< size_t > > &v, const vector< Base > &x)
Link from reverse Hessian sparsity sweep to base_atomic.
void reverse_sparse_hessian_load_op(OpCode op, size_t i_z, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity, bool *var_jacobian, bool *vecad_jacobian)
Reverse mode Hessian sparsity operations for LdpOp and LdvOp.
void reverse_sparse_hessian_mul_op(size_t i_z, const addr_t *arg, bool *jac_reverse, const Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for multiplication operator.
#define CPPAD_ASSERT_UNKNOWN(exp)
Check that exp is true, if not terminate execution.
void reverse_sparse_hessian_csum_op(size_t i_z, const addr_t *arg, bool *rev_jacobian, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for CSumOp operator.
void reverse_sparse_hessian_div_op(size_t i_z, const addr_t *arg, bool *jac_reverse, const Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity)
Reverse mode Hessian sparsity pattern for division operator.
size_t num_op_rec(void) const
Fetch number of operators in the recording.
void printOp(std::ostream &os, const local::player< Base > *play, size_t i_op, size_t i_var, OpCode op, const addr_t *ind)
Prints a single operator and its operands.
#define CPPAD_ASSERT_NARG_NRES(op, n_arg, n_res)
Check that operator op has the specified number of of arguments and results.
Base GetPar(size_t i) const
Fetch a parameter from the recording.
size_t num_var_rec(void) const
Fetch number of variables in the recording.
void reverse_sparse_hessian_store_op(OpCode op, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity, bool *var_jacobian, bool *vecad_jacobian)
Reverse mode sparsity operations for StpvOp and StvvOp.