void RevSparseJacSet(
size_t p ,
const VectorSet& s ,
VectorSet& r ,
size_t total_num_var ,
CppAD::vector<size_t>& dep_taddr ,
CppAD::vector<size_t>& ind_taddr ,
CppAD::player<Base>& play )
{
// temporary indices
size_t i, j;
std::set<size_t>::const_iterator itr;
// check VectorSet is Simple Vector class with sets for elements
static std::set<size_t> two, three;
if( two.empty() )
{ two.insert(2);
three.insert(3);
}
CPPAD_ASSERT_UNKNOWN( two.size() == 1 );
CPPAD_ASSERT_UNKNOWN( three.size() == 1 );
CheckSimpleVector<std::set<size_t>, VectorSet>(two, three);
// range and domain dimensions for F
size_t m = dep_taddr.size();
size_t n = ind_taddr.size();
CPPAD_ASSERT_KNOWN(
p > 0,
"RevSparseJac: p (first argument) is not greater than zero"
);
CPPAD_ASSERT_KNOWN(
s.size() == p,
"RevSparseJac: s (second argument) length is not equal to "
"p (first argument)."
);
// vector of sets that will hold the results
sparse_set var_sparsity;
var_sparsity.resize(total_num_var, p);
// The sparsity pattern corresponding to the dependent variables
for(i = 0; i < p; i++)
{ itr = s[i].begin();
while(itr != s[i].end())
{ j = *itr++;
CPPAD_ASSERT_KNOWN(
j < m,
"RevSparseJac: an element of the set s[i] "
"has value greater than or equal m."
);
CPPAD_ASSERT_UNKNOWN( dep_taddr[j] < total_num_var );
var_sparsity.add_element( dep_taddr[j], i );
}
}
// evaluate the sparsity patterns
RevJacSweep(
n,
total_num_var,
&play,
var_sparsity
);
// return values corresponding to dependent variables
CPPAD_ASSERT_UNKNOWN( r.size() == p );
for(j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] == (j+1) );
// ind_taddr[j] is operator taddr for j-th independent variable
CPPAD_ASSERT_UNKNOWN( play.GetOp( ind_taddr[j] ) == InvOp );
// extract result from rev_hes_sparsity
// and add corresponding elements to sets in r
CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == p );
var_sparsity.begin(j+1);
i = var_sparsity.next_element();
while( i < p )
{ r[i].insert(j);
i = var_sparsity.next_element();
}
}
}
void RevSparseJacBool(
size_t p ,
const VectorSet& s ,
VectorSet& r ,
size_t total_num_var ,
CppAD::vector<size_t>& dep_taddr ,
CppAD::vector<size_t>& ind_taddr ,
CppAD::player<Base>& play )
{
// temporary indices
size_t i, j;
// check VectorSet is Simple Vector class with bool elements
CheckSimpleVector<bool, VectorSet>();
// range and domain dimensions for F
size_t m = dep_taddr.size();
size_t n = ind_taddr.size();
CPPAD_ASSERT_KNOWN(
p > 0,
"RevSparseJac: p (first argument) is not greater than zero"
);
CPPAD_ASSERT_KNOWN(
s.size() == p * m,
"RevSparseJac: s (second argument) length is not equal to\n"
"p (first argument) times range dimension for ADFun object."
);
// vector of sets that will hold the results
sparse_pack var_sparsity;
var_sparsity.resize(total_num_var, p);
// The sparsity pattern corresponding to the dependent variables
for(i = 0; i < m; i++)
{ CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < total_num_var );
for(j = 0; j < p; j++) if( s[ i * m + j ] )
var_sparsity.add_element( dep_taddr[i], j );
}
// evaluate the sparsity patterns
RevJacSweep(
n,
total_num_var,
&play,
var_sparsity
);
// return values corresponding to dependent variables
CPPAD_ASSERT_UNKNOWN( r.size() == p * n );
for(j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] == (j+1) );
// ind_taddr[j] is operator taddr for j-th independent variable
CPPAD_ASSERT_UNKNOWN( play.GetOp( ind_taddr[j] ) == InvOp );
// extract the result from var_sparsity
for(i = 0; i < p; i++)
r[ i * n + j ] = false;
CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == p );
var_sparsity.begin(j+1);
i = var_sparsity.next_element();
while( i < p )
{ r[ i * n + j ] = true;
i = var_sparsity.next_element();
}
}
}
void RevSparseJacSet(
bool transpose ,
bool dependency ,
size_t q ,
const VectorSet& r ,
VectorSet& s ,
size_t total_num_var ,
CppAD::vector<size_t>& dep_taddr ,
CppAD::vector<size_t>& ind_taddr ,
CppAD::player<Base>& play )
{
// temporary indices
size_t i, j;
std::set<size_t>::const_iterator itr;
// check VectorSet is Simple Vector class with sets for elements
CheckSimpleVector<std::set<size_t>, VectorSet>(
one_element_std_set<size_t>(), two_element_std_set<size_t>()
);
// domain dimensions for F
size_t n = ind_taddr.size();
size_t m = dep_taddr.size();
CPPAD_ASSERT_KNOWN(
q > 0,
"RevSparseJac: q is not greater than zero"
);
CPPAD_ASSERT_KNOWN(
size_t(r.size()) == q || transpose,
"RevSparseJac: size of r is not equal to q and transpose is false."
);
CPPAD_ASSERT_KNOWN(
size_t(r.size()) == m || ! transpose,
"RevSparseJac: size of r is not equal to m and transpose is true."
);
// vector of lists that will hold the results
CPPAD_INTERNAL_SPARSE_SET var_sparsity;
var_sparsity.resize(total_num_var, q);
// The sparsity pattern corresponding to the dependent variables
if( transpose )
{ for(i = 0; i < m; i++)
{ itr = r[i].begin();
while(itr != r[i].end())
{ j = *itr++;
CPPAD_ASSERT_KNOWN(
j < q,
"RevSparseJac: transpose is true and element of the set\n"
"r[i] has value greater than or equal q."
);
CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < total_num_var );
var_sparsity.add_element( dep_taddr[i], j );
}
}
}
else
{ for(i = 0; i < q; i++)
{ itr = r[i].begin();
while(itr != r[i].end())
{ j = *itr++;
CPPAD_ASSERT_KNOWN(
j < m,
"RevSparseJac: transpose is false and element of the set\n"
"r[i] has value greater than or equal range dimension."
);
CPPAD_ASSERT_UNKNOWN( dep_taddr[j] < total_num_var );
var_sparsity.add_element( dep_taddr[j], i );
}
}
}
// evaluate the sparsity patterns
RevJacSweep(
dependency,
n,
total_num_var,
&play,
var_sparsity
);
// return values corresponding to dependent variables
CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == q || transpose );
CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == n || ! transpose );
for(j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] == (j+1) );
// ind_taddr[j] is operator taddr for j-th independent variable
CPPAD_ASSERT_UNKNOWN( play.GetOp( ind_taddr[j] ) == InvOp );
CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == q );
var_sparsity.begin(j+1);
i = var_sparsity.next_element();
while( i < q )
{ if( transpose )
s[j].insert(i);
else s[i].insert(j);
i = var_sparsity.next_element();
}
}
}
void ADFun<Base>::RevSparseJacCheckpoint(
size_t q ,
CPPAD_INTERNAL_SPARSE_SET& r ,
bool transpose ,
bool dependency ,
CPPAD_INTERNAL_SPARSE_SET& s )
{ size_t n = Domain();
size_t m = Range();
# ifndef NDEBUG
if( transpose )
{ CPPAD_ASSERT_UNKNOWN( r.n_set() == m );
CPPAD_ASSERT_UNKNOWN( r.end() == q );
}
else
{ CPPAD_ASSERT_UNKNOWN( r.n_set() == q );
CPPAD_ASSERT_UNKNOWN( r.end() == m );
}
for(size_t i = 0; i < m; i++)
CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
# endif
// holds reverse Jacobian sparsity pattern for all variables
CPPAD_INTERNAL_SPARSE_SET var_sparsity;
var_sparsity.resize(num_var_tape_, q);
// set sparsity pattern for dependent variables
if( transpose )
{ for(size_t i = 0; i < m; i++)
{ r.begin(i);
size_t j = r.next_element();
while( j < q )
{ var_sparsity.add_element( dep_taddr_[i], j );
j = r.next_element();
}
}
}
else
{ for(size_t j = 0; j < q; j++)
{ r.begin(j);
size_t i = r.next_element();
while( i < m )
{ var_sparsity.add_element( dep_taddr_[i], j );
i = r.next_element();
}
}
}
// evaluate the sparsity pattern for all variables
RevJacSweep(
dependency,
n,
num_var_tape_,
&play_,
var_sparsity
);
// dimension the return value
if( transpose )
s.resize(n, m);
else
s.resize(m, n);
// return values corresponding to independent variables
for(size_t j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] == (j+1) );
// ind_taddr_[j] is operator taddr for j-th independent variable
CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == InvOp );
// extract the result from var_sparsity
CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == q );
var_sparsity.begin(j+1);
size_t i = var_sparsity.next_element();
while( i < q )
{ if( transpose )
s.add_element(j, i);
else
s.add_element(i, j);
i = var_sparsity.next_element();
}
}
}
void RevSparseJacBool(
bool transpose ,
bool dependency ,
size_t q ,
const VectorSet& r ,
VectorSet& s ,
size_t total_num_var ,
CppAD::vector<size_t>& dep_taddr ,
CppAD::vector<size_t>& ind_taddr ,
CppAD::player<Base>& play )
{
// temporary indices
size_t i, j;
// check VectorSet is Simple Vector class with bool elements
CheckSimpleVector<bool, VectorSet>();
// range and domain dimensions for F
size_t m = dep_taddr.size();
size_t n = ind_taddr.size();
CPPAD_ASSERT_KNOWN(
q > 0,
"RevSparseJac: q is not greater than zero"
);
CPPAD_ASSERT_KNOWN(
size_t(r.size()) == q * m,
"RevSparseJac: size of r is not equal to\n"
"q times range dimension for ADFun object."
);
// vector of sets that will hold the results
sparse_pack var_sparsity;
var_sparsity.resize(total_num_var, q);
// The sparsity pattern corresponding to the dependent variables
for(i = 0; i < m; i++)
{ CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < total_num_var );
if( transpose )
{ for(j = 0; j < q; j++) if( r[ j * m + i ] )
var_sparsity.add_element( dep_taddr[i], j );
}
else
{ for(j = 0; j < q; j++) if( r[ i * q + j ] )
var_sparsity.add_element( dep_taddr[i], j );
}
}
// evaluate the sparsity patterns
RevJacSweep(
dependency,
n,
total_num_var,
&play,
var_sparsity
);
// return values corresponding to dependent variables
CPPAD_ASSERT_UNKNOWN( size_t(s.size()) == q * n );
for(j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] == (j+1) );
// ind_taddr[j] is operator taddr for j-th independent variable
CPPAD_ASSERT_UNKNOWN( play.GetOp( ind_taddr[j] ) == InvOp );
// extract the result from var_sparsity
if( transpose )
{ for(i = 0; i < q; i++)
s[ j * q + i ] = false;
}
else
{ for(i = 0; i < q; i++)
s[ i * n + j ] = false;
}
CPPAD_ASSERT_UNKNOWN( var_sparsity.end() == q );
var_sparsity.begin(j+1);
i = var_sparsity.next_element();
while( i < q )
{ if( transpose )
s[ j * q + i ] = true;
else s[ i * n + j ] = true;
i = var_sparsity.next_element();
}
}
}