1 # ifndef CPPAD_LOCAL_SPARSE_INTERNAL_HPP
2 # define CPPAD_LOCAL_SPARSE_INTERNAL_HPP
21 namespace CppAD {
namespace local {
101 template <
class SizeVector,
class InternalSparsity>
107 InternalSparsity& internal_pattern ,
110 size_t nr = internal_index.
size();
112 size_t nc = internal_pattern.end();
121 if( input_empty )
for(
size_t i = 0; i < nr; i++)
122 {
size_t i_var = internal_index[i];
126 const SizeVector& row( pattern_in.
row() );
127 const SizeVector& col( pattern_in.
col() );
128 size_t nnz = row.size();
129 for(
size_t k = 0; k < nnz; k++)
135 size_t i_var = internal_index[r];
138 bool ignore = zero_empty && i_var == 0;
140 internal_pattern.post_element( internal_index[r], c );
143 for(
size_t i = 0; i < nr; ++i)
144 internal_pattern.process_post( internal_index[i] );
146 template <
class InternalSparsity>
152 InternalSparsity& internal_pattern ,
154 {
size_t nr = internal_index.
size();
155 size_t nc = internal_pattern.end();
158 if( input_empty )
for(
size_t i = 0; i < nr; i++)
159 {
size_t i_var = internal_index[i];
163 for(
size_t i = 0; i < nr; i++)
164 {
for(
size_t j = 0; j < nc; j++)
165 {
bool flag = pattern_in[i * nc + j];
167 flag = pattern_in[j * nr + i];
169 {
size_t i_var = internal_index[i];
172 bool ignore = zero_empty && i_var == 0;
174 internal_pattern.post_element( i_var, j);
179 for(
size_t i = 0; i < nr; ++i)
180 internal_pattern.process_post( internal_index[i] );
183 template <
class InternalSparsity>
189 InternalSparsity& internal_pattern ,
191 {
size_t nr = internal_index.
size();
192 size_t nc = internal_pattern.end();
195 if( input_empty )
for(
size_t i = 0; i < nr; i++)
196 {
size_t i_var = internal_index[i];
200 for(
size_t i = 0; i < nr; i++)
201 {
for(
size_t j = 0; j < nc; j++)
202 {
bool flag = pattern_in[i * nc + j];
204 flag = pattern_in[j * nr + i];
206 {
size_t i_var = internal_index[i];
209 bool ignore = zero_empty && i_var == 0;
211 internal_pattern.post_element( i_var, j);
216 for(
size_t i = 0; i < nr; ++i)
217 internal_pattern.process_post( internal_index[i] );
220 template <
class InternalSparsity>
226 InternalSparsity& internal_pattern ,
227 const vector< std::set<size_t> >& pattern_in )
228 {
size_t nr = internal_index.
size();
229 size_t nc = internal_pattern.end();
231 if( input_empty )
for(
size_t i = 0; i < nr; i++)
232 {
size_t i_var = internal_index[i];
238 for(
size_t j = 0; j < nc; j++)
239 { std::set<size_t>::const_iterator itr( pattern_in[j].begin() );
240 while( itr != pattern_in[j].end() )
242 size_t i_var = internal_index[i];
245 bool ignore = zero_empty && i_var == 0;
247 internal_pattern.post_element( i_var, j);
254 for(
size_t i = 0; i < nr; i++)
255 { std::set<size_t>::const_iterator itr( pattern_in[i].begin() );
256 while( itr != pattern_in[i].end() )
258 size_t i_var = internal_index[i];
261 bool ignore = zero_empty && i_var == 0;
263 internal_pattern.post_element( i_var, j);
269 for(
size_t i = 0; i < nr; ++i)
270 internal_pattern.process_post( internal_index[i] );
301 template <
class SizeVector,
class InternalSparsity>
305 const InternalSparsity& internal_pattern ,
307 {
typedef typename InternalSparsity::const_iterator iterator;
309 size_t nr = internal_index.
size();
311 size_t nc = internal_pattern.end();
314 for(
size_t i = 0; i < nr; i++)
316 iterator itr(internal_pattern, internal_index[i]);
325 { pattern_out.
resize(nc, nr, nnz);
328 for(
size_t i = 0; i < nr; i++)
329 { iterator itr(internal_pattern, internal_index[i]);
332 { pattern_out.
set(k++, j, i);
339 pattern_out.
resize(nr, nc, nnz);
342 for(
size_t i = 0; i < nr; i++)
343 { iterator itr(internal_pattern, internal_index[i]);
346 { pattern_out.
set(k++, i, j);
352 template <
class InternalSparsity>
356 const InternalSparsity& internal_pattern ,
358 {
typedef typename InternalSparsity::const_iterator iterator;
360 size_t nr = internal_index.
size();
363 size_t nc = internal_pattern.end();
365 pattern_out.
resize(nr * nc);
366 for(
size_t ij = 0; ij < nr * nc; ij++)
367 pattern_out[ij] =
false;
369 for(
size_t i = 0; i < nr; i++)
371 iterator itr(internal_pattern, internal_index[i]);
375 pattern_out[j * nr + i] =
true;
377 pattern_out[i * nc + j] =
true;
383 template <
class InternalSparsity>
387 const InternalSparsity& internal_pattern ,
389 {
typedef typename InternalSparsity::const_iterator iterator;
391 size_t nr = internal_index.
size();
394 size_t nc = internal_pattern.end();
396 pattern_out.
resize(nr * nc);
397 for(
size_t ij = 0; ij < nr * nc; ij++)
398 pattern_out[ij] =
false;
400 for(
size_t i = 0; i < nr; i++)
402 iterator itr(internal_pattern, internal_index[i]);
406 pattern_out[j * nr + i] =
true;
408 pattern_out[i * nc + j] =
true;
414 template <
class InternalSparsity>
418 const InternalSparsity& internal_pattern ,
419 vector< std::set<size_t> >& pattern_out )
420 {
typedef typename InternalSparsity::const_iterator iterator;
422 size_t nr = internal_index.
size();
425 size_t nc = internal_pattern.end();
428 pattern_out.resize(nc);
430 pattern_out.resize(nr);
431 for(
size_t k = 0; k < pattern_out.size(); k++)
432 pattern_out[k].clear();
434 for(
size_t i = 0; i < nr; i++)
436 iterator itr(internal_pattern, internal_index[i]);
440 pattern_out[j].insert(i);
442 pattern_out[i].insert(j);
Vector of sets of positive integers, each set stored as a singly linked list.
const SizeVector & col(void) const
column indices
Define processor symbols and macros that are used by CppAD.
Vector of sets of positive integers stored as singly linked lists with the element values strictly in...
void get_internal_sparsity(bool transpose, const vector< size_t > &internal_index, const InternalSparsity &internal_pattern, sparse_rc< SizeVector > &pattern_out)
Get sparsity pattern for a sub-set of variables.
Vector of sets of positive integers stored as a packed array of bools.
void resize(size_t n)
change the number of elements in this vector.
size_t nr(void) const
number of rows in matrix
size_t size(void) const
number of elements currently in this vector.
Vector of sets of postivie integers, each set stored as a packed boolean array.
sparsity pattern for a matrix with indices of type size_t
void resize(size_t nr, size_t nc, size_t nnz)
resize
#define CPPAD_ASSERT_UNKNOWN(exp)
Check that exp is true, if not terminate execution.
size_t nc(void) const
number of columns in matrix
void set_internal_sparsity(bool zero_empty, bool input_empty, bool transpose, const vector< size_t > &internal_index, InternalSparsity &internal_pattern, const sparse_rc< SizeVector > &pattern_in)
Update the internal sparsity pattern for a sub-set of rows.
void set(size_t k, size_t r, size_t c)
set row and column for a possibly non-zero element
void resize(size_t n)
change number of elements in this vector
Vector of sets of positive integers stored as size_t vector with the element values strictly increasi...
const SizeVector & row(void) const
row indices
size_t size(void) const
number of elements in this vector
Template structure used obtain the internal sparsity pattern type form the corresponding element type...