vec<Scalar>::vec(size_t length)
{
length_ = length;
pointer_ = CPPAD_TRACK_NEW_VEC(length, pointer_);
handle_ = CPPAD_TRACK_NEW_VEC(length, handle_);
for(size_t i = 0; i < length_; i++)
handle_[i] = pointer_ + i;
return;
}
vec<Scalar>::vec(const vec& v)
{
length_ = v.length_;
pointer_ = CPPAD_TRACK_NEW_VEC(length_, pointer_);
handle_ = CPPAD_TRACK_NEW_VEC(length_, handle_);
for(size_t i = 0; i < length_; i++)
{ handle_[i] = pointer_ + i;
pointer_[i] = v[i];
}
}
void vec<Scalar>::resize(size_t length)
{
if( handle_ != 0 )
CPPAD_TRACK_DEL_VEC(handle_);
if( pointer_ != 0 )
CPPAD_TRACK_DEL_VEC(pointer_);
pointer_ = CPPAD_TRACK_NEW_VEC(length, pointer_);
handle_ = CPPAD_TRACK_NEW_VEC(length, handle_);
length_ = length;
for(size_t i = 0; i < length_; i++)
handle_[i] = pointer_ + i;
}
// ========================================================================
// class vec<double>
//
// constructor from a python array
vec<double>::vec(array& boost_array)
{ // get array info
PyArrayObject* py_array_p=reinterpret_cast<PyArrayObject*>(boost_array.ptr());
npy_intp* dims_ptr = PyArray_DIMS(py_array_p);
int length = dims_ptr[0];
// check array info
PYCPPAD_ASSERT(
PyArray_NDIM(py_array_p) == 1 ,
"array is not a vector"
);
PYCPPAD_ASSERT(
length >= 0 ,
"array length is <= zero"
);
// set private data
length_ = static_cast<size_t>( length );
if( PyArray_TYPE(py_array_p) == NPY_DOUBLE )
{ pointer_ = static_cast<double*>(
PyArray_DATA(py_array_p)
);
allocated_ = false;
}
else if( PyArray_TYPE(py_array_p) == NPY_INT )
{ pointer_ = CPPAD_TRACK_NEW_VEC(length, pointer_);
int* data = static_cast<int*>(
PyArray_DATA(py_array_p)
);
for(size_t i = 0; i < length_; i++)
pointer_[i] = static_cast<double>( data[i] );
allocated_ = true;
}
else if( PyArray_TYPE(py_array_p) == NPY_LONG )
{ pointer_ = CPPAD_TRACK_NEW_VEC(length, pointer_);
long* data = static_cast<long*>(
PyArray_DATA(py_array_p)
);
for(size_t i = 0; i < length_; i++)
pointer_[i] = static_cast<double>( data[i] );
allocated_ = true;
}
else PYCPPAD_ASSERT(
0,
"expected an array with int or float elements"
);
return;
}
// copy constructor
vec<double>::vec(const vec& v)
{ length_ = v.length_;
pointer_ = CPPAD_TRACK_NEW_VEC(length_, pointer_);
allocated_ = true;
for(size_t i = 0; i < length_; i++)
pointer_[i] = v[i];
}
// constructor from size
vec<double>::vec(size_t length)
{ // set private data
length_ = length;
pointer_ = CPPAD_TRACK_NEW_VEC(length, pointer_);
allocated_ = true;
return;
}
vec<Scalar>::vec(array& boost_array)
{
// get array info
PyArrayObject* py_array_p=reinterpret_cast<PyArrayObject*>(boost_array.ptr());
npy_intp* dims_ptr = PyArray_DIMS(py_array_p);
int length = dims_ptr[0];
// check array info
PYCPPAD_ASSERT(
PyArray_NDIM(py_array_p) == 1 ,
"array is not a vector"
);
PYCPPAD_ASSERT(
PyArray_TYPE(py_array_p) == NPY_OBJECT ,
"expected array elements of type object"
);
PYCPPAD_ASSERT(
length >= 0 ,
"array length is <= zero"
);
// pointer to object
object *obj_ptr = static_cast<object*>(
PyArray_DATA(py_array_p)
);
// set private data
length_ = static_cast<size_t>(length);
pointer_ = 0;
handle_ = CPPAD_TRACK_NEW_VEC(length_, handle_);
for(size_t i = 0; i < length_; i++) handle_[i] =
& extract<Scalar&>(obj_ptr[i])();
return;
}
// resize
void vec<double>::resize(size_t length)
{ if( allocated_ )
CPPAD_TRACK_DEL_VEC(pointer_);
pointer_ = CPPAD_TRACK_NEW_VEC(length, pointer_);
length_ = length;
allocated_ = true;
}
bool track_new_del(void)
{ bool ok = true;
// initial count
size_t count = CPPAD_TRACK_COUNT();
// allocate an array of lenght 5
double *ptr = CPPAD_NULL;
size_t newlen = 5;
ptr = CPPAD_TRACK_NEW_VEC(newlen, ptr);
// copy data into the array
size_t ncopy = newlen;
size_t i;
for(i = 0; i < ncopy; i++)
ptr[i] = double(i);
// extend the buffer to be lenght 10
newlen = 10;
ptr = CPPAD_TRACK_EXTEND(newlen, ncopy, ptr);
// copy data into the new part of the array
for(i = ncopy; i < newlen; i++)
ptr[i] = double(i);
// check the values in the array
for(i = 0; i < newlen; i++)
ok &= (ptr[i] == double(i));
// free the memory allocated since previous call to TrackCount
CPPAD_TRACK_DEL_VEC(ptr);
// check for memory leak
ok &= (count == CPPAD_TRACK_COUNT());
return ok;
}
bool link_poly(
size_t size ,
size_t repeat ,
CppAD::vector<double> &a , // coefficients of polynomial
CppAD::vector<double> &z , // polynomial argument value
CppAD::vector<double> &ddp ) // second derivative w.r.t z
{
// -----------------------------------------------------
// setup
int tag = 0; // tape identifier
int keep = 1; // keep forward mode results in buffer
int m = 1; // number of dependent variables
int n = 1; // number of independent variables
int d = 2; // order of the derivative
double f; // function value
int i; // temporary index
// choose a vector of polynomial coefficients
CppAD::uniform_01(size, a);
// AD copy of the polynomial coefficients
std::vector<adouble> A(size);
for(i = 0; i < int(size); i++)
A[i] = a[i];
// domain and range space AD values
adouble Z, P;
// allocate arguments to hos_forward
double *x0 = 0;
x0 = CPPAD_TRACK_NEW_VEC(n, x0);
double *y0 = 0;
y0 = CPPAD_TRACK_NEW_VEC(m, y0);
double **x = 0;
x = CPPAD_TRACK_NEW_VEC(n, x);
double **y = 0;
y = CPPAD_TRACK_NEW_VEC(m, y);
for(i = 0; i < n; i++)
{ x[i] = 0;
x[i] = CPPAD_TRACK_NEW_VEC(d, x[i]);
}
for(i = 0; i < m; i++)
{ y[i] = 0;
y[i] = CPPAD_TRACK_NEW_VEC(d, y[i]);
}
// Taylor coefficient for argument
x[0][0] = 1.; // first order
x[0][1] = 0.; // second order
extern bool global_retape;
if( global_retape ) while(repeat--)
{ // choose an argument value
CppAD::uniform_01(1, z);
// declare independent variables
trace_on(tag, keep);
Z <<= z[0];
// AD computation of the function value
P = CppAD::Poly(0, A, Z);
// create function object f : Z -> P
P >>= f;
trace_off();
// get the next argument value
CppAD::uniform_01(1, z);
x0[0] = z[0];
// evaluate the polynomial at the new argument value
hos_forward(tag, m, n, d, keep, x0, x, y0, y);
// second derivative is twice second order Taylor coef
ddp[0] = 2. * y[0][1];
}
else
{
size_t forward_sweep(
bool print,
size_t d,
size_t n,
size_t numvar,
player<Base> *Rec,
size_t J,
Base *Taylor
)
{ CPPAD_ASSERT_UNKNOWN( J >= d + 1 );
// op code for current instruction
OpCode op;
// index for current instruction
size_t i_op;
// next variables
size_t i_var;
# if CPPAD_USE_FORWARD0SWEEP
CPPAD_ASSERT_UNKNOWN( d > 0 );
# else
size_t* non_const_arg;
# endif
const size_t *arg = 0;
size_t i;
// initialize the comparision operator (ComOp) counter
size_t compareCount = 0;
// if this is an order zero calculation, initialize vector indices
size_t *VectorInd = CPPAD_NULL; // address for each element
bool *VectorVar = CPPAD_NULL; // is element a variable
i = Rec->num_rec_vecad_ind();
if( i > 0 )
{ VectorInd = CPPAD_TRACK_NEW_VEC(i, VectorInd);
VectorVar = CPPAD_TRACK_NEW_VEC(i, VectorVar);
while(i--)
{ VectorInd[i] = Rec->GetVecInd(i);
VectorVar[i] = false;
}
}
// check numvar argument
CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
// length of the parameter vector (used by CppAD assert macros)
const size_t num_par = Rec->num_rec_par();
// length of the text vector (used by CppAD assert macros)
const size_t num_text = Rec->num_rec_text();
// pointer to the beginning of the parameter vector
const Base* parameter = 0;
if( num_par > 0 )
parameter = Rec->GetPar();
// pointer to the beginning of the text vector
const char* text = 0;
if( num_text > 0 )
text = Rec->GetTxt(0);
// skip the BeginOp at the beginning of the recording
Rec->start_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD_SWEEP_TRACE
std::cout << std::endl;
# endif
while(op != EndOp)
{
// this op
Rec->next_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( (i_op > n) | (op == InvOp) );
CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
// action depends on the operator
switch( op )
{
case AbsOp:
forward_abs_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AddvvOp:
forward_addvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case AddpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_addpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case AcosOp:
// variables: sqrt(1 - x * x), acos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_acos_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AsinOp:
// results: sqrt(1 - x * x), asin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_asin_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AtanOp:
// results: 1 + x * x, atan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_atan_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case CSumOp:
// CSumOp has a variable number of arguments and
// next_forward thinks it one has one argument.
// we must inform next_forward of this special case.
Rec->forward_csum(op, arg, i_op, i_var);
forward_csum_op(
d, i_var, arg, num_par, parameter, J, Taylor
);
break;
// -------------------------------------------------
case CExpOp:
forward_cond_op(
d, i_var, arg, num_par, parameter, J, Taylor
);
break;
// ---------------------------------------------------
case ComOp:
# if ! USE_FORWARD0SWEEP
if( d == 0 ) forward_comp_op_0(
compareCount, arg, num_par, parameter, J, Taylor
);
# endif
break;
// ---------------------------------------------------
case CosOp:
// variables: sin(x), cos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cos_op(d, i_var, arg[0], J, Taylor);
break;
// ---------------------------------------------------
case CoshOp:
// variables: sinh(x), cosh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cosh_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case DisOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
forward_dis_op_0(i_var, arg, J, Taylor);
else
# endif
{ Taylor[ i_var * J + d] = Base(0);
}
break;
// -------------------------------------------------
case DivvvOp:
forward_divvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case DivpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_divpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case DivvpOp:
CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
forward_divvp_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case EndOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 0);
break;
// -------------------------------------------------
case ExpOp:
forward_exp_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case InvOp:
CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
break;
// -------------------------------------------------
case LdpOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ non_const_arg = Rec->forward_non_const_arg();
forward_load_p_op_0(
i_var,
non_const_arg,
num_par,
parameter,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
else
# endif
{ forward_load_op( op, d, i_var, arg, J, Taylor);
}
break;
// -------------------------------------------------
case LdvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ non_const_arg = Rec->forward_non_const_arg();
forward_load_v_op_0(
i_var,
non_const_arg,
num_par,
parameter,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
else
# endif
{ forward_load_op( op, d, i_var, arg, J, Taylor);
}
break;
// -------------------------------------------------
case LogOp:
forward_log_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case MulvvOp:
forward_mulvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case MulpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_mulpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case ParOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 ) forward_par_op_0(
i_var, arg, num_par, parameter, J, Taylor
);
else
# endif
{ Taylor[ i_var * J + d] = Base(0);
}
break;
// -------------------------------------------------
case PowvpOp:
CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
forward_powvp_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PowpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_powpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PowvvOp:
forward_powvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PripOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( print && ( d == 0 ) ) forward_prip_0(
arg, num_text, text, num_par, parameter
);
# endif
break;
// -------------------------------------------------
case PrivOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( print && ( d == 0 ) ) forward_priv_0(
i_var, arg, num_text, text, J, Taylor
);
# endif
break;
// -------------------------------------------------
case SinOp:
// variables: cos(x), sin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sin_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SinhOp:
// variables: cosh(x), sinh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sinh_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SqrtOp:
forward_sqrt_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case StppOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_pp_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case StpvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_pv_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case StvpOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_vp_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case StvvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_vv_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case SubvvOp:
forward_subvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case SubpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_subpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case SubvpOp:
CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
forward_subvp_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
default:
CPPAD_ASSERT_UNKNOWN(0);
}
# if CPPAD_FORWARD_SWEEP_TRACE
size_t i_tmp = i_var;
Base* Z_tmp = Taylor + J * i_var;
printOp(
std::cout,
Rec,
i_tmp,
op,
arg,
d + 1,
Z_tmp,
0,
(Base *) CPPAD_NULL
);
}
std::cout << std::endl;
# else
}
bool link_sparse_hessian(
size_t repeat ,
CppAD::vector<double> &x_arg ,
CppAD::vector<size_t> &i ,
CppAD::vector<size_t> &j ,
CppAD::vector<double> &h )
{
// -----------------------------------------------------
// setup
size_t k, m;
size_t order = 0; // derivative order corresponding to function
size_t tag = 0; // tape identifier
size_t keep = 1; // keep forward mode results in buffer
size_t n = x_arg.size(); // number of independent variables
size_t ell = i.size(); // number of indices in i and j
double f; // function value
typedef CppAD::vector<double> DblVector;
typedef CppAD::vector<adouble> ADVector;
typedef CppAD::vector<size_t> SizeVector;
ADVector X(n); // AD domain space vector
double *x; // double domain space vector
double **H; // Hessian
ADVector Y(1); // AD range space value
DblVector tmp(2 * ell); // double temporary vector
x = 0;
x = CPPAD_TRACK_NEW_VEC(n, x);
H = 0;
H = CPPAD_TRACK_NEW_VEC(n, H);
for(k = 0; k < n; k++)
{ H[k] = 0;
H[k] = CPPAD_TRACK_NEW_VEC(n, H[k]);
}
// choose a value for x
CppAD::uniform_01(n, x);
for(k = 0; k < n; k++)
x_arg[k] = x[k];
// ------------------------------------------------------
while(repeat--)
{
// get the next set of indices
CppAD::uniform_01(2 * ell, tmp);
for(k = 0; k < ell; k++)
{ i[k] = size_t( n * tmp[k] );
i[k] = std::min(n-1, i[k]);
//
j[k] = size_t( n * tmp[k + ell] );
j[k] = std::min(n-1, j[k]);
}
// declare independent variables
trace_on(tag, keep);
for(k = 0; k < n; k++)
X[k] <<= x[k];
// AD computation of f(x)
CppAD::sparse_evaluate(X, i, j, order, Y);
// create function object f : X -> Y
Y[0] >>= f;
trace_off();
// evaluate and return the hessian of f
hessian(int(tag), int(n), x, H);
}
for(k = 0; k < n; k++)
{ for(m = 0; m <= k; m++)
{ h[ k * n + m] = H[k][m];
h[ m * n + k] = H[k][m];
}
CPPAD_TRACK_DEL_VEC(H[k]);
}
CPPAD_TRACK_DEL_VEC(H);
CPPAD_TRACK_DEL_VEC(x);
return true;
}
VectorBase ADFun<Base>::Reverse(size_t p, const VectorBase &w) const
{ // temporary indices
size_t i, j, k;
// number of independent variables
size_t n = ind_taddr_.size();
// number of dependent variables
size_t m = dep_taddr_.size();
Base *Partial = CPPAD_NULL;
Partial = CPPAD_TRACK_NEW_VEC(total_num_var_ * p, Partial);
// update maximum memory requirement
// memoryMax = std::max( memoryMax,
// Memory() + total_num_var_ * p * sizeof(Base)
// );
// check VectorBase is Simple Vector class with Base type elements
CheckSimpleVector<Base, VectorBase>();
CPPAD_ASSERT_KNOWN(
w.size() == m,
"Argument w to Reverse does not have length equal to\n"
"the dimension of the range for the corresponding ADFun."
);
CPPAD_ASSERT_KNOWN(
p > 0,
"The first argument to Reverse must be greater than zero."
);
CPPAD_ASSERT_KNOWN(
taylor_per_var_ >= p,
"Less that p taylor_ coefficients are currently stored"
" in this ADFun object."
);
// initialize entire Partial matrix to zero
for(i = 0; i < total_num_var_; i++)
for(j = 0; j < p; j++)
Partial[i * p + j] = Base(0);
// set the dependent variable direction
// (use += because two dependent variables can point to same location)
for(i = 0; i < m; i++)
{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < total_num_var_ );
Partial[dep_taddr_[i] * p + p - 1] += w[i];
}
// evaluate the derivatives
ReverseSweep(
p - 1,
total_num_var_,
&play_,
taylor_col_dim_,
taylor_,
p,
Partial
);
// return the derivative values
VectorBase value(n * p);
for(j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < total_num_var_ );
// independent variable taddr equals its operator taddr
CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == InvOp );
// by the Reverse Identity Theorem
// partial of y^{(k)} w.r.t. u^{(0)} is equal to
// partial of y^{(p-1)} w.r.t. u^{(p - 1 - k)}
for(k = 0; k < p; k++)
value[j * p + k ] =
Partial[ind_taddr_[j] * p + p - 1 - k];
}
// done with the Partial array
CPPAD_TRACK_DEL_VEC(Partial);
return value;
}
void RevHesSweep(
size_t n,
size_t numvar,
player<Base> *play,
Vector_set& for_jac_sparse, // should be const
bool* RevJac,
Vector_set& rev_hes_sparse
)
{
OpCode op;
size_t i_op;
size_t i_var;
const size_t *arg = 0;
// length of the parameter vector (used by CppAD assert macros)
const size_t num_par = play->num_rec_par();
size_t i, j, k;
// check numvar argument
CPPAD_ASSERT_UNKNOWN( play->num_rec_var() == numvar );
CPPAD_ASSERT_UNKNOWN( for_jac_sparse.n_set() == numvar );
CPPAD_ASSERT_UNKNOWN( rev_hes_sparse.n_set() == numvar );
CPPAD_ASSERT_UNKNOWN( numvar > 0 );
// upper limit exclusive for set elements
size_t limit = rev_hes_sparse.end();
CPPAD_ASSERT_UNKNOWN( rev_hes_sparse.end() == limit );
// check number of sets match
CPPAD_ASSERT_UNKNOWN(
for_jac_sparse.n_set() == rev_hes_sparse.n_set()
);
// vecad_sparsity contains a sparsity pattern for each VecAD object.
// vecad_ind maps a VecAD index (beginning of the VecAD object)
// to the index for the corresponding set in vecad_sparsity.
size_t num_vecad_ind = play->num_rec_vecad_ind();
size_t num_vecad_vec = play->num_rec_vecad_vec();
Vector_set vecad_sparse;
vecad_sparse.resize(num_vecad_vec, limit);
size_t* vecad_ind = CPPAD_NULL;
bool* vecad_jac = CPPAD_NULL;
if( num_vecad_vec > 0 )
{ size_t length;
vecad_ind = CPPAD_TRACK_NEW_VEC(num_vecad_ind, vecad_ind);
vecad_jac = CPPAD_TRACK_NEW_VEC(num_vecad_vec, vecad_jac);
j = 0;
for(i = 0; i < num_vecad_vec; i++)
{ // length of this VecAD
length = play->GetVecInd(j);
// set vecad_ind to proper index for this VecAD
vecad_ind[j] = i;
// make all other values for this vector invalid
for(k = 1; k <= length; k++)
vecad_ind[j+k] = num_vecad_vec;
// start of next VecAD
j += length + 1;
// initialize this vector's reverse jacobian value
vecad_jac[i] = false;
}
CPPAD_ASSERT_UNKNOWN( j == play->num_rec_vecad_ind() );
}
// Initialize
play->start_reverse(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == EndOp );
# if CPPAD_REV_HES_SWEEP_TRACE
std::cout << std::endl;
CppAD::vectorBool zf_value(limit);
CppAD::vectorBool zh_value(limit);
# endif
while(op != BeginOp)
{
// next op
play->next_reverse(op, arg, i_op, i_var);
# ifndef NDEBUG
if( i_op <= n )
{ CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
}
else CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
# endif
// rest of information depends on the case
switch( op )
{
case AbsOp:
CPPAD_ASSERT_NARG_NRES(op, 1, 1)
reverse_sparse_hessian_linear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case AddvvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_addsub_op(
i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case AddpvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_linear_unary_op(
i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case AcosOp:
// acos(x) and sqrt(1 - x * x) are computed in pairs
// but i_var + 1 should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case AsinOp:
// asin(x) and sqrt(1 - x * x) are computed in pairs
// but i_var + 1 should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case AtanOp:
// atan(x) and 1 + x * x must be computed in pairs
// but i_var + 1 should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case BeginOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 1)
break;
// -------------------------------------------------
case CSumOp:
// CSumOp has a variable number of arguments and
// next_reverse thinks it one has one argument.
// We must inform next_reverse of this special case.
play->reverse_csum(op, arg, i_op, i_var);
reverse_sparse_hessian_csum_op(
i_var, arg, RevJac, rev_hes_sparse
);
break;
// -------------------------------------------------
case CExpOp:
reverse_sparse_hessian_cond_op(
i_var, arg, num_par, RevJac, rev_hes_sparse
);
break;
// ---------------------------------------------------
case ComOp:
CPPAD_ASSERT_NARG_NRES(op, 4, 0)
CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
break;
// --------------------------------------------------
case CosOp:
// cosine and sine must come in pairs
// but i_var should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// ---------------------------------------------------
case CoshOp:
// hyperbolic cosine and sine must come in pairs
// but i_var should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case DisOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
break;
// -------------------------------------------------
case DivvvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_div_op(
i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case DivpvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case DivvpOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_linear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case ExpOp:
CPPAD_ASSERT_NARG_NRES(op, 1, 1)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case InvOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 1)
// Z is already defined
break;
// -------------------------------------------------
case LdpOp:
reverse_sparse_hessian_load_op(
op,
i_var,
arg,
num_vecad_ind,
vecad_ind,
rev_hes_sparse,
vecad_sparse,
RevJac,
vecad_jac
);
break;
// -------------------------------------------------
case LdvOp:
reverse_sparse_hessian_load_op(
op,
i_var,
arg,
num_vecad_ind,
vecad_ind,
rev_hes_sparse,
vecad_sparse,
RevJac,
vecad_jac
);
break;
// -------------------------------------------------
case LogOp:
CPPAD_ASSERT_NARG_NRES(op, 1, 1)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case MulvvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_mul_op(
i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case MulpvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_linear_unary_op(
i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case ParOp:
CPPAD_ASSERT_NARG_NRES(op, 1, 1)
break;
// -------------------------------------------------
case PowpvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 3)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case PowvpOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 3)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case PowvvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 3)
reverse_sparse_hessian_pow_op(
i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case PripOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 0);
break;
// -------------------------------------------------
case PrivOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 0);
break;
// -------------------------------------------------
case SinOp:
// sine and cosine must come in pairs
// but i_var should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case SinhOp:
// sine and cosine must come in pairs
// but i_var should only be used here
CPPAD_ASSERT_NARG_NRES(op, 1, 2)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case SqrtOp:
CPPAD_ASSERT_NARG_NRES(op, 1, 1)
reverse_sparse_hessian_nonlinear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case StppOp:
// sparsity cannot propagate through a parameter
CPPAD_ASSERT_NARG_NRES(op, 3, 0)
break;
// -------------------------------------------------
case StpvOp:
reverse_sparse_hessian_store_op(
op,
arg,
num_vecad_ind,
vecad_ind,
rev_hes_sparse,
vecad_sparse,
RevJac,
vecad_jac
);
break;
// -------------------------------------------------
case StvpOp:
// sparsity cannot propagate through a parameter
CPPAD_ASSERT_NARG_NRES(op, 3, 0)
break;
// -------------------------------------------------
case StvvOp:
reverse_sparse_hessian_store_op(
op,
arg,
num_vecad_ind,
vecad_ind,
rev_hes_sparse,
vecad_sparse,
RevJac,
vecad_jac
);
break;
// -------------------------------------------------
case SubvvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_addsub_op(
i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case SubpvOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_linear_unary_op(
i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
case SubvpOp:
CPPAD_ASSERT_NARG_NRES(op, 2, 1)
reverse_sparse_hessian_linear_unary_op(
i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
);
break;
// -------------------------------------------------
default:
CPPAD_ASSERT_UNKNOWN(0);
}
# if CPPAD_REV_HES_SWEEP_TRACE
for(j = 0; j < limit; j++)
{ zf_value[j] = false;
zh_value[j] = false;
}
for_jac_sparse.begin(i_var);;
j = for_jac_sparse.next_element();;
while( j < limit )
{ zf_value[j] = true;
j = for_jac_sparse.next_element();
}
rev_hes_sparse.begin(i_var);;
j = rev_hes_sparse.next_element();;
while( j < limit )
{ zh_value[j] = true;
j = rev_hes_sparse.next_element();
}
// should also print RevJac[i_var], but printOp does not
// yet allow for this.
printOp(
std::cout,
play,
i_var,
op,
arg,
1,
&zf_value,
1,
&zh_value
);
# endif
}
// values corresponding to BeginOp
CPPAD_ASSERT_UNKNOWN( i_op == 0 );
CPPAD_ASSERT_UNKNOWN( i_var == 0 );
if( vecad_jac != CPPAD_NULL )
CPPAD_TRACK_DEL_VEC(vecad_jac);
if( vecad_ind != CPPAD_NULL )
CPPAD_TRACK_DEL_VEC(vecad_ind);
return;
}