casadi::Sparsity Class Reference

General sparsity class. More...

#include <sparsity.hpp>

Detailed Description

The storage format is a compressed column storage (CCS) format.
In this format, the structural non-zero elements are stored in column-major order, starting from the upper left corner of the matrix and ending in the lower right corner.

In addition to the dimension (size1(), size2()), (i.e. the number of rows and the number of columns respectively), there are also two vectors of integers:

1. "colind" [length size2()+1], which contains the index to the first non-zero element on or after the corresponding column. All the non-zero elements of a particular column i are thus the elements with index el that fulfills: colind[i] <= el < colind[i+1].
2. "row" [same length as the number of non-zero elements, nnz()] The rows for each of the structural non-zeros.

Note that with this format, it is cheap to loop over all the non-zero elements of a particular column, at constant time per element, but expensive to jump to access a location (i, j).

If the matrix is dense, i.e. length(row) == size1()*size2(), the format reduces to standard dense column major format, which allows access to an arbitrary element in constant time.

Since the object is reference counted (it inherits from SharedObject), several matrices are allowed to share the same sparsity pattern.

The implementations of methods marked as such in this class has been taken from the CSparse package and modified to fit CasADi data structures and separation of sparsity pattern calculation and numerical evaluation. These functions are Copyright(c) Timothy A. Davis, 2006-2009 and licensed as a derivative work under the GNU LGPL

See also

Matrix

Author

Joel Andersson

Date

2010-2015

Extra doc: https://github.com/casadi/casadi/wiki/L_b9

Definition at line 103 of file sparsity.hpp.

Inheritance diagram for casadi::Sparsity:

Collaboration diagram for casadi::Sparsity:

Public Types
typedef SparsityInterface< Sparsity >	B
	Base class. More...
using	internal_base_type = SharedObjectInternal
using	base_type = SharedObject

Public Member Functions
	Sparsity (casadi_int dummy=0)
	Default constructor. More...
	Sparsity (casadi_int nrow, casadi_int ncol)
	Pattern with all structural zeros. More...
	Sparsity (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &colind, const std::vector< casadi_int > &row, bool order_rows=false)
	Construct from sparsity pattern vectors given in compressed column storage format. More...
	Sparsity (const std::pair< casadi_int, casadi_int > &rc)
	Create a sparse matrix with all structural zeros. More...
	Sparsity (casadi_int nrow, casadi_int ncol, const casadi_int *colind, const casadi_int *row, bool order_rows=false)
	Construct from sparsity pattern vectors given in compressed column storage format. More...
SparsityInternal *	get () const
const std::vector< casadi_int >	permutation_vector (bool invert=false) const
	Construct permutation vector from permutation matrix. More...
Sparsity	get_diag (std::vector< casadi_int > &mapping) const
std::vector< casadi_int >	compress (bool canonical=true) const
	Compress a sparsity pattern. More...
const SparsityInternal *	operator-> () const
	Access a member function or object. More...
const SparsityInternal &	operator* () const
	Reference to internal structure. More...
bool	operator!= (const Sparsity &y) const
	Check if two sparsity patterns are difference. More...
bool	is_stacked (const Sparsity &y, casadi_int n) const
	Check if pattern is horizontal repeat of another. More...
	operator const casadi_int * () const
	Implicit or explicit type conversion to C representation. More...
	operator const std::vector< casadi_int > & () const
	Implicit or explicit type conversion to compact representation. More...
	operator SparsityStruct () const
	Implicit or explicit type conversion to C representation. More...
Dict	info () const
void	to_file (const std::string &filename, const std::string &format_hint="") const
void	serialize (std::ostream &stream) const
	Serialize. More...
std::string	serialize () const
	Serialize. More...
void	serialize (SerializingStream &s) const
	Serialize an object. More...
const casadi_int *	row () const
	Get a reference to row-vector,. More...
const casadi_int *	colind () const
	Get a reference to the colindex of all column element (see class description) More...
std::vector< casadi_int >	get_row () const
	Get the row for each non-zero entry. More...
std::vector< casadi_int >	get_colind () const
	Get the column index for each column. More...
casadi_int	colind (casadi_int cc) const
	Get a reference to the colindex of column cc (see class description) More...
casadi_int	row (casadi_int el) const
	Get the row of a non-zero element. More...
std::vector< casadi_int >	get_col () const
	Get the column for each non-zero entry. More...
void	resize (casadi_int nrow, casadi_int ncol)
	Resize. More...
casadi_int	add_nz (casadi_int rr, casadi_int cc)
	Get the index of a non-zero element. More...
casadi_int	get_nz (casadi_int rr, casadi_int cc) const
	Get the index of an existing non-zero element. More...
bool	has_nz (casadi_int rr, casadi_int cc) const
	Returns true if the pattern has a non-zero at location rr, cc. More...
std::vector< casadi_int >	get_nz (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc) const
	Get a set of non-zero element. More...
void	get_nz (std::vector< casadi_int > &indices) const
	Get the nonzero index for a set of elements. More...
std::vector< casadi_int >	get_lower () const
	Get nonzeros in lower triangular part. More...
std::vector< casadi_int >	get_upper () const
	Get nonzeros in upper triangular part. More...
void	get_ccs (std::vector< casadi_int > &colind, std::vector< casadi_int > &row) const
	Get the sparsity in compressed column storage (CCS) format. More...
void	get_crs (std::vector< casadi_int > &rowind, std::vector< casadi_int > &col) const
	Get the sparsity in compressed row storage (CRS) format. More...
void	get_triplet (std::vector< casadi_int > &row, std::vector< casadi_int > &col) const
	Get the sparsity in sparse triplet format. More...
Sparsity	sub (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, std::vector< casadi_int > &mapping, bool ind1=false) const
	Get a submatrix. More...
Sparsity	sub (const std::vector< casadi_int > &rr, const Sparsity &sp, std::vector< casadi_int > &mapping, bool ind1=false) const
	Get a set of elements. More...
Sparsity	T () const
	Transpose the matrix. More...
Sparsity	transpose (std::vector< casadi_int > &mapping, bool invert_mapping=false) const
	Transpose the matrix and get the reordering of the non-zero entries. More...
bool	is_transpose (const Sparsity &y) const
	Check if the sparsity is the transpose of another. More...
bool	is_reshape (const Sparsity &y) const
	Check if the sparsity is a reshape of another. More...
bool	is_compactible (std::vector< casadi_int > &row, std::vector< casadi_int > &col) const
	Check if the nonzero pattern is the Cartesian product of a row and a column subset. More...
bool	is_subset (const Sparsity &rhs) const
	Is subset? More...
Sparsity	sparsity_cast_mod (const Sparsity &X, const Sparsity &Y) const
	Propagates subset according to sparsity cast. More...
Sparsity	pattern_inverse () const
	Take the inverse of a sparsity pattern; flip zeros and non-zeros. More...
template<typename DataType >
void	set (DataType *data, const DataType *val_data, const Sparsity &val_sp) const
template<typename DataType >
void	add (DataType *data, const DataType *val_data, const Sparsity &val_sp) const
template<typename DataType >
void	bor (DataType *data, const DataType *val_data, const Sparsity &val_sp) const
std::string	class_name () const
	Get class name. More...
void	disp (std::ostream &stream, bool more=false) const
	Print a description of the object. More...
std::string	get_str (bool more=false) const
	Get string representation. More...
void	print_ptr (std::ostream &stream=casadi::uout()) const
void	own (SharedObjectInternal *node)
void	assign (SharedObjectInternal *node)
	Assign the node to a node class pointer without reference counting. More...
casadi_int	getCount () const
	Get the reference count. More...
void	swap (GenericShared &other)
	Swap content with another instance. More...
std::string	debug_repr () const
bool	is_null () const
	Is a null pointer? More...
casadi_int	__hash__ () const
	Returns a number that is unique for a given Node. More...
GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...
Check if two sparsity patterns are identical
bool	is_equal (const Sparsity &y) const
bool	is_equal (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &colind, const std::vector< casadi_int > &row) const
bool	is_equal (casadi_int nrow, casadi_int ncol, const casadi_int *colind, const casadi_int *row) const
bool	operator== (const Sparsity &y) const
Size and element counting
casadi_int	size1 () const
	Get the number of rows. More...
casadi_int	rows () const
	Get the number of rows, Octave-style syntax. More...
casadi_int	size2 () const
	Get the number of columns. More...
casadi_int	columns () const
	Get the number of columns, Octave-style syntax. More...
casadi_int	numel () const
	The total number of elements, including structural zeros, i.e. size2()*size1() More...
double	density () const
	The percentage of nonzero. More...
bool	is_empty (bool both=false) const
	Check if the sparsity is empty. More...
casadi_int	nnz () const
	Get the number of (structural) non-zeros. More...
casadi_int	nnz_upper (bool strictly=false) const
	Number of non-zeros in the upper triangular half,. More...
casadi_int	nnz_lower (bool strictly=false) const
	Number of non-zeros in the lower triangular half,. More...
casadi_int	nnz_diag () const
	Number of non-zeros on the diagonal, i.e. the number of elements (i, j) with j==i. More...
casadi_int	bw_upper () const
	Upper half-bandwidth. More...
casadi_int	bw_lower () const
	Lower half-bandwidth. More...
std::pair< casadi_int, casadi_int >	size () const
	Get the shape. More...
casadi_int	size (casadi_int axis) const
	Get the size along a particular dimensions. More...
Sparsity	combine (const Sparsity &y, bool f0x_is_zero, bool function0_is_zero, std::vector< unsigned char > &mapping) const
	Combine two sparsity patterns. More...
Sparsity	combine (const Sparsity &y, bool f0x_is_zero, bool function0_is_zero) const
	Combine two sparsity patterns. More...
Sparsity	unite (const Sparsity &y, std::vector< unsigned char > &mapping) const
	Union of two sparsity patterns. More...
Sparsity	unite (const Sparsity &y) const
	Union of two sparsity patterns. More...
Sparsity	operator+ (const Sparsity &b) const
	Union of two sparsity patterns. More...
Sparsity	intersect (const Sparsity &y, std::vector< unsigned char > &mapping) const
	Intersection of two sparsity patterns. More...
Sparsity	intersect (const Sparsity &y) const
	Intersection of two sparsity patterns. More...
Sparsity	operator* (const Sparsity &b) const
	Intersection of two sparsity patterns. More...

Static Public Member Functions
static Sparsity	create (SparsityInternal *node)
	Create from node. More...
static Sparsity	upper (casadi_int n)
	Create a upper triangular square sparsity pattern *. More...
static Sparsity	lower (casadi_int n)
	Create a lower triangular square sparsity pattern *. More...
static Sparsity	band (casadi_int n, casadi_int p)
	Create a single band in a square sparsity pattern. More...
static Sparsity	banded (casadi_int n, casadi_int p)
	Create banded square sparsity pattern. More...
static Sparsity	rowcol (const std::vector< casadi_int > &row, const std::vector< casadi_int > &col, casadi_int nrow, casadi_int ncol)
	Construct a block sparsity pattern from (row, col) vectors. More...
static Sparsity	nonzeros (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &nz, bool ind1=SWIG_IND1)
	Create a sparsity from nonzeros. More...
static Sparsity	permutation (const std::vector< casadi_int > &p, bool invert=false)
	Construct a permutation matrix P from a permutation vector p. More...
static Sparsity	from_file (const std::string &filename, const std::string &format_hint="")
static Sparsity	deserialize (std::istream &stream)
	Build Sparsity from serialization. More...
static Sparsity	deserialize (const std::string &s)
	Build Sparsity from serialization. More...
static Sparsity	deserialize (DeserializingStream &s)
	Deserialize. More...
static void	mul_sparsityF (const bvec_t *x, const Sparsity &x_sp, const bvec_t *y, const Sparsity &y_sp, bvec_t *z, const Sparsity &z_sp, bvec_t *w)
	Propagate sparsity using 0-1 logic through a matrix product,. More...
static void	mul_activityF (const bvec_t *x, const Sparsity &x_sp, const bvec_t *y, const Sparsity &y_sp, bvec_t *z, const Sparsity &z_sp, bvec_t *w)
	Propagate signal activity through a matrix product, forward mode. More...
static void	mul_sparsityR (bvec_t *x, const Sparsity &x_sp, bvec_t *y, const Sparsity &y_sp, bvec_t *z, const Sparsity &z_sp, bvec_t *w)
	Propagate sparsity using 0-1 logic through a matrix product,. More...
static Sparsity	scalar (bool dense_scalar=true)
	Create a scalar sparsity pattern *. More...
static Sparsity	dense (casadi_int nrow, casadi_int ncol=1)
	Create a dense rectangular sparsity pattern *. More...
static Sparsity	dense (const std::pair< casadi_int, casadi_int > &rc)
	Create a dense rectangular sparsity pattern *. More...
static Sparsity	unit (casadi_int n, casadi_int el)
	Create the sparsity pattern for a unit vector of length n and a nonzero on. More...
static Sparsity	diag (casadi_int nrow)
	Create diagonal sparsity pattern *. More...
static Sparsity	diag (casadi_int nrow, casadi_int ncol)
	Create diagonal sparsity pattern *. More...
static Sparsity	diag (const std::pair< casadi_int, casadi_int > &rc)
	Create diagonal sparsity pattern *. More...
static Sparsity	triplet (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &row, const std::vector< casadi_int > &col, std::vector< casadi_int > &mapping, bool invert_mapping)
	Create a sparsity pattern given the nonzeros in sparse triplet form *. More...
static Sparsity	triplet (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &row, const std::vector< casadi_int > &col)
	Create a sparsity pattern given the nonzeros in sparse triplet form *. More...
static Sparsity	compressed (const std::vector< casadi_int > &v, bool order_rows=false)
static Sparsity	compressed (const casadi_int *v, bool order_rows=false)

Protected Member Functions
void	count_up ()
void	count_down ()

Static Private Member Functions
static std::vector< Sparsity >	diagsplit (const Sparsity &x, const std::vector< casadi_int > &output_offset)
static std::vector< Sparsity >	diagsplit (const Sparsity &x, casadi_int incr)
static std::vector< Sparsity >	diagsplit (const Sparsity &x, casadi_int incr1, casadi_int incr2)
static Sparsity	mtimes (const std::vector< Sparsity > &args, const std::string &blas="reference")
static std::vector< Sparsity >	horzsplit (const Sparsity &x, casadi_int incr)
static std::vector< Sparsity >	vertsplit (const Sparsity &x, casadi_int incr)
typedef std::unordered_multimap< std::size_t, WeakRef >	CachingMap
	Enlarge matrix. More...
static std::set< std::string >	file_formats = {"mtx"}
	Enlarge matrix. More...
void	enlarge (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, bool ind1=false)
	Enlarge matrix. More...
void	enlargeRows (casadi_int nrow, const std::vector< casadi_int > &rr, bool ind1=false)
	Enlarge the matrix along the first dimension (i.e. insert rows) More...
void	enlargeColumns (casadi_int ncol, const std::vector< casadi_int > &cc, bool ind1=false)
	Enlarge the matrix along the second dimension (i.e. insert columns) More...
Sparsity	makeDense (std::vector< casadi_int > &mapping) const
	Make a patten dense. More...
std::vector< casadi_int >	erase (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, bool ind1=false)
	Erase rows and/or columns of a matrix. More...
std::vector< casadi_int >	erase (const std::vector< casadi_int > &rr, bool ind1=false)
	Erase elements of a matrix. More...
void	append (const Sparsity &sp)
	Append another sparsity patten vertically (NOTE: only efficient if vector) More...
void	appendColumns (const Sparsity &sp)
	Append another sparsity patten horizontally. More...
bool	is_scalar (bool scalar_and_dense=false) const
	Is scalar? More...
bool	is_dense () const
	Is dense? More...
bool	is_row () const
	Check if the pattern is a row vector (i.e. size1()==1) More...
bool	is_column () const
	Check if the pattern is a column vector (i.e. size2()==1) More...
bool	is_vector () const
	Check if the pattern is a row or column vector. More...
bool	is_diag () const
	Is diagonal? More...
bool	is_square () const
	Is square? More...
bool	is_symmetric () const
	Is symmetric? More...
bool	is_triu (bool strictly=false) const
	Is upper triangular? More...
bool	is_tril (bool strictly=false) const
	Is lower triangular? More...
bool	is_singular () const
	Check whether the sparsity-pattern indicates structural singularity. More...
bool	is_permutation () const
	Is this a permutation matrix? More...
bool	is_selection (bool allow_empty=false) const
	Is this a selection matrix? More...
bool	is_orthonormal (bool allow_empty=false) const
	Are both rows and columns orthonormal ? More...
bool	is_orthonormal_rows (bool allow_empty=false) const
	Are the rows of the pattern orthonormal ? More...
bool	is_orthonormal_columns (bool allow_empty=false) const
	Are the columns of the pattern orthonormal ? More...
bool	rowsSequential (bool strictly=true) const
	Do the rows appear sequentially on each column. More...
void	removeDuplicates (std::vector< casadi_int > &mapping)
	Remove duplicate entries. More...
std::vector< casadi_int >	etree (bool ata=false) const
	Calculate the elimination tree. More...
Sparsity	ldl (std::vector< casadi_int > &p, bool amd=true) const
	Symbolic LDL factorization. More...
void	qr_sparse (Sparsity &V, Sparsity &R, std::vector< casadi_int > &prinv, std::vector< casadi_int > &pc, bool amd=true) const
	Symbolic QR factorization. More...
casadi_int	dfs (casadi_int j, casadi_int top, std::vector< casadi_int > &xi, std::vector< casadi_int > &pstack, const std::vector< casadi_int > &pinv, std::vector< bool > &marked) const
	Depth-first search on the adjacency graph of the sparsity. More...
casadi_int	scc (std::vector< casadi_int > &index, std::vector< casadi_int > &offset) const
	Find the strongly connected components of the bigraph defined by the sparsity pattern. More...
casadi_int	btf (std::vector< casadi_int > &rowperm, std::vector< casadi_int > &colperm, std::vector< casadi_int > &rowblock, std::vector< casadi_int > &colblock, std::vector< casadi_int > &coarse_rowblock, std::vector< casadi_int > &coarse_colblock) const
	Calculate the block triangular form (BTF) More...
std::vector< casadi_int >	amd () const
	Approximate minimal degree preordering. More...
void	spsolve (bvec_t *X, bvec_t *B, bool tr) const
	Propagate sparsity through a linear solve. More...
std::vector< casadi_int >	find (bool ind1=SWIG_IND1) const
	Get the location of all non-zero elements as they would appear in a Dense matrix. More...
void	find (std::vector< casadi_int > &loc, bool ind1=false) const
	Get the location of all nonzero elements (inplace version) More...
Sparsity	uni_coloring (const Sparsity &AT=Sparsity(), casadi_int cutoff=std::numeric_limits< casadi_int >::max()) const
	Perform a unidirectional coloring: A greedy distance-2 coloring algorithm. More...
Sparsity	star_coloring_new (std::vector< casadi_int > &which_color, const Dict &opts=Dict()) const
	Perform a star coloring of a symmetric matrix: More...
Sparsity	star_coloring (casadi_int ordering=1, casadi_int cutoff=std::numeric_limits< casadi_int >::max()) const
	Perform a star coloring of a symmetric matrix: More...
Sparsity	star_coloring2 (casadi_int ordering=1, casadi_int cutoff=std::numeric_limits< casadi_int >::max()) const
	Perform a star coloring of a symmetric matrix: More...
std::vector< casadi_int >	largest_first () const
	Order the columns by decreasing degree. More...
Sparsity	pmult (const std::vector< casadi_int > &p, bool permute_rows=true, bool permute_columns=true, bool invert_permutation=false) const
	Permute rows and/or columns. More...
std::string	dim (bool with_nz=false) const
	Get the dimension as a string. More...
std::string	postfix_dim () const
	Dimension string as a postfix to a name. More...
std::string	repr_el (casadi_int k) const
	Describe the nonzero location k as a string. More...
void	spy (std::ostream &stream=casadi::uout()) const
	Print a textual representation of sparsity. More...
void	spy_matlab (const std::string &mfile) const
	Generate a script for Matlab or Octave which visualizes. More...
void	export_code (const std::string &lang, std::ostream &stream=casadi::uout(), const Dict &options=Dict()) const
	Export matrix in specific language. More...
std::size_t	hash () const
	Enlarge matrix. More...
template<typename T >
void	set (T *data, const T *val_data, const Sparsity &val_sp) const
	Assign the nonzero entries of one sparsity pattern to the nonzero. More...
template<typename T >
void	add (T *data, const T *val_data, const Sparsity &val_sp) const
	Add the nonzero entries of one sparsity pattern to the nonzero entries. More...
template<typename T >
void	bor (T *data, const T *val_data, const Sparsity &val_sp) const
	Bitwise or of the nonzero entries of one sparsity pattern and the nonzero. More...
static Sparsity	horzcat (const std::vector< Sparsity > &sp)
	Accessed by SparsityInterface. More...
static Sparsity	vertcat (const std::vector< Sparsity > &sp)
	Enlarge matrix. More...
static Sparsity	blockcat (const std::vector< std::vector< Sparsity > > &v)
	Enlarge matrix. More...
static Sparsity	diagcat (const std::vector< Sparsity > &v)
	Enlarge matrix. More...
static std::vector< Sparsity >	horzsplit (const Sparsity &x, const std::vector< casadi_int > &offset)
	Enlarge matrix. More...
static std::vector< Sparsity >	vertsplit (const Sparsity &x, const std::vector< casadi_int > &offset)
	Enlarge matrix. More...
static std::vector< Sparsity >	diagsplit (const Sparsity &x, const std::vector< casadi_int > &offset1, const std::vector< casadi_int > &offset2)
	Enlarge matrix. More...
static Sparsity	mtimes (const Sparsity &x, const Sparsity &y, const std::string &blas="reference")
	Enlarge matrix. More...
static Sparsity	mac (const Sparsity &x, const Sparsity &y, const Sparsity &z, const std::string &="reference")
	Enlarge matrix. More...
static Sparsity	reshape (const Sparsity &x, casadi_int nrow, casadi_int ncol)
	Enlarge matrix. More...
static Sparsity	reshape (const Sparsity &x, const Sparsity &sp)
	Enlarge matrix. More...
static Sparsity	sparsity_cast (const Sparsity &x, const Sparsity &sp)
	Enlarge matrix. More...
static casadi_int	sprank (const Sparsity &x)
	Enlarge matrix. More...
static casadi_int	norm_0_mul (const Sparsity &x, const Sparsity &A)
	Enlarge matrix. More...
static Sparsity	kron (const Sparsity &a, const Sparsity &b)
	Enlarge matrix. More...
static Sparsity	kron_contract (const Sparsity &sp_m, const Sparsity &sp_x, bool inner)
	Output sparsity of casadi::KronContract. More...
static Sparsity	triu (const Sparsity &x, bool includeDiagonal=true)
	Enlarge matrix. More...
static Sparsity	tril (const Sparsity &x, bool includeDiagonal=true)
	Enlarge matrix. More...
static Sparsity	sum2 (const Sparsity &x)
	Enlarge matrix. More...
static Sparsity	sum1 (const Sparsity &x)
	Enlarge matrix. More...
static CachingMap &	getCache ()
	Cached sparsity patterns. More...
static const Sparsity &	getScalar ()
	(Dense) scalar More...
static const Sparsity &	getScalarSparse ()
	(Sparse) scalar More...
static const Sparsity &	getEmpty ()
	Empty zero-by-zero. More...
static std::string	type_name ()
	Readable name of the public class. More...
static bool	test_cast (const SharedObjectInternal *ptr)
	Check if a particular cast is allowed. More...
static Sparsity	kkt (const Sparsity &H, const Sparsity &J, bool with_x_diag=true, bool with_lam_g_diag=true)
	Get KKT system sparsity. More...
static std::string	file_format (const std::string &filename, const std::string &format_hint, const std::set< std::string > &file_formats)
	Enlarge matrix. More...

Member Typedef Documentation

B

typedef SparsityInterface<Sparsity> casadi::Sparsity::B

Definition at line 138 of file sparsity.hpp.

base_type

using casadi::SharedObject::base_type = SharedObject

inherited

Definition at line 103 of file shared_object.hpp.

CachingMap

typedef std::unordered_multimap<std::size_t, WeakRef> casadi::Sparsity::CachingMap

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 924 of file sparsity.hpp.

internal_base_type

using casadi::SharedObject::internal_base_type = SharedObjectInternal

inherited

Definition at line 102 of file shared_object.hpp.

Constructor & Destructor Documentation

Sparsity() [1/5]

casadi::Sparsity::Sparsity ( casadi_int  dummy = 0 )

explicit

Definition at line 68 of file sparsity.cpp.

                                     {
    casadi_assert_dev(dummy==0);
  }

Referenced by band(), banded(), compressed(), dense(), deserialize(), diag(), diagcat(), enlargeColumns(), enlargeRows(), horzcat(), horzsplit(), kkt(), kron(), kron_contract(), ldl(), lower(), permutation(), triplet(), unit(), upper(), and vertcat().

Sparsity() [2/5]

casadi::Sparsity::Sparsity	(	casadi_int	nrow,
		casadi_int	ncol
	)

Extra doc: https://github.com/casadi/casadi/wiki/L_ba

Definition at line 78 of file sparsity.cpp.

                                                     {
    casadi_assert_dev(nrow>=0);
    casadi_assert_dev(ncol>=0);
    std::vector<casadi_int> row, colind(ncol+1, 0);
    assign_cached(nrow, ncol, colind, row);
  }

References colind(), and row().

Sparsity() [3/5]

casadi::Sparsity::Sparsity	(	casadi_int	nrow,
		casadi_int	ncol,
		const std::vector< casadi_int > &	colind,
		const std::vector< casadi_int > &	row,
		bool	order_rows = false
	)

Definition at line 92 of file sparsity.cpp.

                                                                        {
    casadi_assert_dev(nrow>=0);
    casadi_assert_dev(ncol>=0);
    assign_cached(nrow, ncol, colind, row, order_rows);
  }

References colind(), and row().

Sparsity() [4/5]

casadi::Sparsity::Sparsity ( const std::pair< casadi_int, casadi_int > &  rc )

explicit

Extra doc: https://github.com/casadi/casadi/wiki/L_bb

Definition at line 85 of file sparsity.cpp.

                                                              {
    casadi_assert_dev(rc.first>=0);
    casadi_assert_dev(rc.second>=0);
    std::vector<casadi_int> row, colind(rc.second+1, 0);
    assign_cached(rc.first, rc.second, colind, row);
  }

References colind(), and row().

Sparsity() [5/5]

casadi::Sparsity::Sparsity	(	casadi_int	nrow,
		casadi_int	ncol,
		const casadi_int *	colind,
		const casadi_int *	row,
		bool	order_rows = false
	)

Definition at line 99 of file sparsity.cpp.

                                                                        {
    casadi_assert_dev(nrow>=0);
    casadi_assert_dev(ncol>=0);
    if (colind==nullptr || colind[ncol]==nrow*ncol) {
      *this = dense(nrow, ncol);
    } else {
      std::vector<casadi_int> colindv(colind, colind+ncol+1);
      std::vector<casadi_int> rowv(row, row+colind[ncol]);
      assign_cached(nrow, ncol, colindv, rowv, order_rows);
    }
  }

References colind(), dense(), and row().

Member Function Documentation

__hash__()

casadi_int casadi::GenericShared< SharedObject , SharedObjectInternal >::__hash__

inherited

If the Object does not point to any node, "0" is returned.

Extra doc: https://github.com/casadi/casadi/wiki/L_av

Definition at line 123 of file generic_shared_impl.hpp.

                                                             {
    return reinterpret_cast<casadi_int>(get());
  }

add() [1/2]

template<typename DataType >

void casadi::Sparsity::add	(	DataType *	data,
		const DataType *	val_data,
		const Sparsity &	val_sp
	)		const

Definition at line 1361 of file sparsity.hpp.

                                                                                           {
    // Get dimensions of this
    const casadi_int sz = nnz();
    const casadi_int sz1 = size1();
    const casadi_int sz2 = size2();
    const casadi_int nel = sz1*sz2;
 
    // Get dimensions of assigning matrix
    const casadi_int val_sz = val_sp.nnz();
    const casadi_int val_sz1 = val_sp.size1();
    const casadi_int val_sz2 = val_sp.size2();
    const casadi_int val_nel = val_sz1*val_sz2;
 
    // Check if sparsity matches
    if (val_sp==*this) {
      for (casadi_int k=0; k<sz; ++k) {
        data[k] += val_data[k];
      }
    } else if (this->is_empty()) {
      // Quick return
      return;
    } else if (val_sp.is_empty()) {
      // Quick return
      return;
    }  else if (val_nel==1) { // if scalar
      if (val_sz!=0) {
        for (casadi_int k=0; k<sz; ++k) {
          data[k] += val_data[0];
        }
      }
    } else {
      // Quick return if empty
      if (nel==0 && val_nel==0) return;
 
      // Make sure that dimension matches
      casadi_assert(sz2==val_sz2 && sz1==val_sz1,
                            "Sparsity::add<DataType>: shape mismatch. lhs is "
                            + dim() + ", while rhs is " + val_sp.dim() + ".");
 
      // Sparsity
      const casadi_int* c = row();
      const casadi_int* rind = colind();
      const casadi_int* v_c = val_sp.row();
      const casadi_int* v_rind = val_sp.colind();
 
      // For all columns
      for (casadi_int i=0; i<sz2; ++i) {
 
        // Nonzero of the assigning matrix
        casadi_int v_el = v_rind[i];
 
        // First nonzero of the following column
        casadi_int v_el_end = v_rind[i+1];
 
        // Next row of the assigning matrix
        casadi_int v_j = v_el<v_el_end ? v_c[v_el] : sz1;
 
        // Assign all nonzeros
        for (casadi_int el=rind[i]; el!=rind[i+1]; ++el) {
 
          //  Get row
          casadi_int j=c[el];
 
          // Forward the assigning nonzero
          while (v_j<j) {
            v_el++;
            v_j = v_el<v_el_end ? v_c[v_el] : sz1;
          }
 
          // Assign nonzero
          if (v_j==j) {
            data[el] += val_data[v_el++];
            v_j = v_el<v_el_end ? v_c[v_el] : sz1;
          }
        }
      }
    }
  }

References colind(), dim(), is_empty(), nnz(), row(), size1(), and size2().

add() [2/2]

template<typename T >

void casadi::Sparsity::add	(	T *	data,
		const T *	val_data,
		const Sparsity &	val_sp
	)		const

of another sparsity pattern

Extra doc: https://github.com/casadi/casadi/wiki/L_dm

add_nz()

casadi_int casadi::Sparsity::add_nz	(	casadi_int	rr,
		casadi_int	cc
	)

Add the element if it does not exist and copy object if it's not unique

Extra doc: https://github.com/casadi/casadi/wiki/L_ce

Definition at line 194 of file sparsity.cpp.

                                                          {
    // If negative index, count from the back
    if (rr<0) rr += size1();
    if (cc<0) cc += size2();
 
    // Check consistency
    casadi_assert(rr>=0 && rr<size1(), "Row index out of bounds");
    casadi_assert(cc>=0 && cc<size2(), "Column index out of bounds");
 
    // Quick return if matrix is dense
    if (is_dense()) return rr+cc*size1();
 
    // Get sparsity pattern
    casadi_int size1=this->size1(), size2=this->size2(), nnz=this->nnz();
    const casadi_int *colind = this->colind(), *row = this->row();
 
    // Quick return if we are adding an element to the end
    if (colind[cc]==nnz || (colind[cc+1]==nnz && row[nnz-1]<rr)) {
      std::vector<casadi_int> rowv(nnz+1);
      std::copy(row, row+nnz, rowv.begin());
      rowv[nnz] = rr;
      std::vector<casadi_int> colindv(colind, colind+size2+1);
      for (casadi_int c=cc; c<size2; ++c) colindv[c+1]++;
      assign_cached(size1, size2, colindv, rowv);
      return rowv.size()-1;
    }
 
    // go to the place where the element should be
    casadi_int ind;
    for (ind=colind[cc]; ind<colind[cc+1]; ++ind) { // better: loop from the back to the front
      if (row[ind] == rr) {
        return ind; // element exists
      } else if (row[ind] > rr) {
        break;                // break at the place where the element should be added
      }
    }
 
    // insert the element
    std::vector<casadi_int> rowv = get_row(), colindv = get_colind();
    rowv.insert(rowv.begin()+ind, rr);
    for (casadi_int c=cc+1; c<size2+1; ++c) colindv[c]++;
 
    // Return the location of the new element
    assign_cached(size1, size2, colindv, rowv);
    return ind;
  }

References colind(), get_colind(), get_row(), is_dense(), nnz(), row(), size1(), and size2().

amd()

std::vector< casadi_int > casadi::Sparsity::amd

(

)

const

Fill-reducing ordering applied to the sparsity pattern of a linear system prior to factorization. The system must be symmetric, for an unsymmetric matrix A, first form the square of the pattern, A'*A.

The implementation is a modified version of cs_amd in CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL

Extra doc: https://github.com/casadi/casadi/wiki/L_d8

Definition at line 709 of file sparsity.cpp.

                                            {
    return (*this)->amd();
  }

Referenced by casadi::LinsolLdl::init(), ldl(), and qr_sparse().

append()

void casadi::Sparsity::append

(

const Sparsity &

sp

)

Definition at line 471 of file sparsity.cpp.

                                          {
    if (sp.size1()==0 && sp.size2()==0) {
      // Appending pattern is empty
      return;
    } else if (size1()==0 && size2()==0) {
      // This is empty
      *this = sp;
    } else {
      casadi_assert(size2()==sp.size2(),
                            "Sparsity::append: Dimension mismatch. "
                            "You attempt to append a shape " + sp.dim()
                            + " to a shape " + dim()
                            + ". The number of columns must match.");
      if (sp.size1()==0) {
        // No rows to add
        return;
      } else if (size1()==0) {
        // No rows before
        *this = sp;
      } else if (is_column()) {
        // Append to vector (inefficient)
        *this = (*this)->_appendVector(*sp);
      } else {
        // Append to matrix (inefficient)
        *this = vertcat({*this, sp});
      }
    }
  }

References casadi::SparsityInternal::_appendVector(), dim(), is_column(), size1(), size2(), and vertcat().

appendColumns()

void casadi::Sparsity::appendColumns

(

const Sparsity &

sp

)

Definition at line 500 of file sparsity.cpp.

                                                 {
    if (sp.size1()==0 && sp.size2()==0) {
      // Appending pattern is empty
      return;
    } else if (size1()==0 && size2()==0) {
      // This is empty
      *this = sp;
    } else {
      casadi_assert(size1()==sp.size1(),
                            "Sparsity::appendColumns: Dimension mismatch. You attempt to "
                            "append a shape " + sp.dim() + " to a shape "
                            + dim() + ". The number of rows must match.");
      if (sp.size2()==0) {
        // No columns to add
        return;
      } else if (size2()==0) {
        // No columns before
        *this = sp;
      } else {
        // Append to matrix (expensive)
        *this = (*this)->_appendColumns(*sp);
      }
    }
  }

References casadi::SparsityInternal::_appendColumns(), dim(), size1(), and size2().

Referenced by casadi::Sqpmethod::init().

assign()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::assign ( Internal *  node )

inherited

improper use will cause memory leaks!

Extra doc: https://github.com/casadi/casadi/wiki/L_at

Definition at line 96 of file generic_shared_impl.hpp.

                                                              {
    node = node_;
  }

band()

Sparsity casadi::Sparsity::band ( casadi_int  n, casadi_int  p  )

static

band(n, 0) is equivalent to diag(n)
band(n, -1) has a band below the diagonal

Parameters

p

indicate

Extra doc: https://github.com/casadi/casadi/wiki/L_bj

Definition at line 1086 of file sparsity.cpp.

                                                    {
    casadi_assert(n>=0, "Sparsity::band expects a positive integer as argument");
    casadi_assert((p<0? -p : p)<n,
                          "Sparsity::band: position of band schould be smaller then size argument");
 
    casadi_int nc = n-(p<0? -p : p);
 
    std::vector< casadi_int >          row(nc);
 
    casadi_int offset = std::max(p, casadi_int(0));
    for (casadi_int i=0;i<nc;i++) {
      row[i]=i+offset;
    }
 
    std::vector< casadi_int >          colind(n+1);
 
    offset = std::min(p, casadi_int(0));
    for (casadi_int i=0;i<n+1;i++) {
      colind[i] = std::max(std::min(i+offset, nc), casadi_int(0));
    }
 
    return Sparsity(n, n, colind, row);
 
  }

References colind(), casadi::SparsityInterface< Sparsity >::offset(), row(), and Sparsity().

Referenced by banded(), and casadi::SlicotDple::init_mem().

banded()

Sparsity casadi::Sparsity::banded ( casadi_int  n, casadi_int  p  )

static

banded(n, 0) is equivalent to diag(n)
banded(n, 1) is tri-diagonal matrix
Extra doc: https://github.com/casadi/casadi/wiki/L_bk

Definition at line 1111 of file sparsity.cpp.

                                                      {
    // This is not an efficient implementation
    Sparsity ret = Sparsity(n, n);
    for (casadi_int i=-p;i<=p;++i) {
      ret = ret + Sparsity::band(n, i);
    }
    return ret;
  }

References band(), and Sparsity().

blockcat()

Sparsity casadi::Sparsity::blockcat ( const std::vector< std::vector< Sparsity > > &  v )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1678 of file sparsity.cpp.

                                                                         {
    std::vector< Sparsity > ret;
    for (casadi_int i=0; i<v.size(); ++i)
      ret.push_back(horzcat(v[i]));
    return vertcat(ret);
  }

References horzcat(), and vertcat().

Referenced by kkt().

bor() [1/2]

template<typename DataType >

void casadi::Sparsity::bor	(	DataType *	data,
		const DataType *	val_data,
		const Sparsity &	val_sp
	)		const

Definition at line 1441 of file sparsity.hpp.

                                                                                           {
    // Get dimensions of this
    const casadi_int sz = nnz();
    const casadi_int sz1 = size1();
    const casadi_int sz2 = size2();
    const casadi_int nel = sz1*sz2;
 
    // Get dimensions of assigning matrix
    const casadi_int val_sz = val_sp.nnz();
    const casadi_int val_sz1 = val_sp.size1();
    const casadi_int val_sz2 = val_sp.size2();
    const casadi_int val_nel = val_sz1*val_sz2;
 
    // Check if sparsity matches
    if (val_sp==*this) {
      for (casadi_int k=0; k<sz; ++k) {
        data[k] |= val_data[k];
      }
    } else if (this->is_empty()) {
      // Quick return
      return;
    } else if (val_sp.is_empty()) {
      // Quick return
      return;
    }  else if (val_nel==1) { // if scalar
      if (val_sz!=0) {
        for (casadi_int k=0; k<sz; ++k) {
          data[k] |= val_data[0];
        }
      }
    } else {
      // Quick return if empty
      if (nel==0 && val_nel==0) return;
 
      // Make sure that dimension matches
      casadi_assert(sz2==val_sz2 && sz1==val_sz1,
                            "Sparsity::add<DataType>: shape mismatch. lhs is "
                            + dim() + ", while rhs is " + val_sp.dim() + ".");
 
      // Sparsity
      const casadi_int* c = row();
      const casadi_int* rind = colind();
      const casadi_int* v_c = val_sp.row();
      const casadi_int* v_rind = val_sp.colind();
 
      // For all columns
      for (casadi_int i=0; i<sz2; ++i) {
 
        // Nonzero of the assigning matrix
        casadi_int v_el = v_rind[i];
 
        // First nonzero of the following column
        casadi_int v_el_end = v_rind[i+1];
 
        // Next row of the assigning matrix
        casadi_int v_j = v_el<v_el_end ? v_c[v_el] : sz1;
 
        // Assign all nonzeros
        for (casadi_int el=rind[i]; el!=rind[i+1]; ++el) {
 
          //  Get row
          casadi_int j=c[el];
 
          // Forward the assigning nonzero
          while (v_j<j) {
            v_el++;
            v_j = v_el<v_el_end ? v_c[v_el] : sz1;
          }
 
          // Assign nonzero
          if (v_j==j) {
            data[el] |= val_data[v_el++];
            v_j = v_el<v_el_end ? v_c[v_el] : sz1;
          }
        }
      }
    }
  }

References colind(), dim(), is_empty(), nnz(), row(), size1(), and size2().

bor() [2/2]

template<typename T >

void casadi::Sparsity::bor	(	T *	data,
		const T *	val_data,
		const Sparsity &	val_sp
	)		const

entries of another sparsity pattern

Extra doc: https://github.com/casadi/casadi/wiki/L_dn

Referenced by casadi::Project::sp_reverse().

btf()

casadi_int casadi::Sparsity::btf	(	std::vector< casadi_int > &	rowperm,
		std::vector< casadi_int > &	colperm,
		std::vector< casadi_int > &	rowblock,
		std::vector< casadi_int > &	colblock,
		std::vector< casadi_int > &	coarse_rowblock,
		std::vector< casadi_int > &	coarse_colblock
	)		const

See Direct Methods for Sparse Linear Systems by Davis (2006).

The function computes the Dulmage-Mendelsohn decomposition, which allows you to reorder the rows and columns of a matrix to bring it into block triangular form (BTF).

It will not consider the distance of off-diagonal elements to the diagonal: there is no guarantee you will get a block-diagonal matrix if you supply a randomly permuted block-diagonal matrix.

If your matrix is symmetrical, this method is of limited use; permutation can make it non-symmetric.

See also

scc

The implementation is a modified version of cs_dmperm in CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL

Extra doc: https://github.com/casadi/casadi/wiki/L_d7

Examples

matrix/btf.py.

Definition at line 713 of file sparsity.cpp.

                                                                          {
    try {
      return (*this)->btf(rowperm, colperm, rowblock, colblock,
                          coarse_rowblock, coarse_colblock);
    } catch (std::exception &e) {
      CASADI_THROW_ERROR("btf", e.what());
    }
  }

Referenced by casadi::SymbolicQr::det(), casadi::SymbolicQr::init(), and sprank().

bw_lower()

casadi_int casadi::Sparsity::bw_lower

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_by

Definition at line 1404 of file sparsity.cpp.

                                      {
    return (*this)->bw_lower();
  }

bw_upper()

casadi_int casadi::Sparsity::bw_upper

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_bx

Definition at line 1400 of file sparsity.cpp.

                                      {
    return (*this)->bw_upper();
  }

class_name()

std::string casadi::SharedObject::class_name ( ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_au

Definition at line 31 of file shared_object.cpp.

                                           {
    return (*this)->class_name();
  }

Referenced by casadi::FmuFunction::check_mem_count(), casadi::MXFunction::export_code_body(), and casadi::BlazingSplineFunction::merge().

colind() [1/2]

const casadi_int * casadi::Sparsity::colind

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_c8

Definition at line 168 of file sparsity.cpp.

                                           {
    return (*this)->colind();
  }

Referenced by casadi::SparsityInternal::_mtimes(), add(), add_nz(), band(), casadi::SparsityInternal::bfs(), casadi::KinsolInterface::bjac(), bor(), casadi::Blocksqp::calcHessianUpdateExact(), casadi::Blocksqp::calcLagrangeGradient(), casadi::casadi_func_cons_jac(), casadi::GenericMatrix< MatType >::colind(), colind(), casadi::SparsityInternal::combineGen(), compressed(), casadi::construct_nlpsol(), casadi::IndexReduction::dae_struct_detect(), dense(), casadi::detect_simple_bounds_gen(), diag(), diagcat(), casadi::KinsolInterface::djac(), casadi::Transpose::eval_gen(), casadi::BonminUserClass::eval_h(), casadi::IpoptUserClass::eval_h(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::AlpaqaProblem::eval_jac_g(), casadi::BonminUserClass::eval_jac_g(), casadi::IpoptUserClass::eval_jac_g(), casadi::FmuFunction::eval_task(), casadi::FmuFunction::finalize_hessian(), get_ccs(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FunctionInternal::get_sparsity_out(), horzsplit(), casadi::SqicInterface::init(), casadi::Dple::init(), casadi::AmplInterface::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::FatropConicInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::SlicotDple::init(), casadi::SuperscsInterface::init(), casadi::ClarabelInterface::init_dependent(), casadi::HighsInterface::init_dependent(), casadi::MosekInterface::init_dependent(), casadi::XpressInterface::init_dependent(), casadi::CplexInterface::init_mem(), is_equal(), casadi::SparsityInternal::is_equal(), casadi::SparsityInternal::is_stacked(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), kron(), kron_contract(), casadi::kron_sp_gen(), lower(), casadi::mul_bvec_fwd(), mul_sparsityR(), casadi::SparsityInternal::multiply(), norm_0_mul(), permutation(), casadi::FunctionInternal::print_canonical(), casadi::Matrix< Scalar >::print_dense(), casadi::Matrix< Scalar >::print_sparse(), casadi::CvodesInterface::psetupF(), casadi::IdasInterface::psetupF(), casadi::Conic::sdp_to_socp_init(), set(), casadi::WorhpInterface::set_work(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::OoqpInterface::solve(), casadi::OsqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SuperscsInterface::solve(), casadi::WorhpInterface::solve(), casadi::Blocksqp::solveQP(), casadi::KronContract::sp_forward(), casadi::Rank1::sp_forward(), casadi::Solve< Tr >::sp_forward(), casadi::Transpose::sp_forward(), casadi::FunctionInternal::sp_forward_block(), casadi::KronContract::sp_reverse(), casadi::Rank1::sp_reverse(), casadi::Solve< Tr >::sp_reverse(), casadi::Transpose::sp_reverse(), casadi::FunctionInternal::sp_reverse(), Sparsity(), casadi::SparsityInternal::star_coloring_new(), casadi::SparsityInternal::uni_coloring(), unit(), casadi::DaeBuilderInternal::update_dependencies(), upper(), and casadi::SnoptInterface::userfun().

colind() [2/2]

casadi_int casadi::Sparsity::colind

(

casadi_int

cc

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cb

Definition at line 180 of file sparsity.cpp.

                                                 {
    if (cc<0 || cc>size2()) {
      throw std::out_of_range("Sparsity::colind: Index "
        + str(cc) + " out of range [0," + str(size2()) + "]");
    }
    return colind()[cc];
  }

References colind(), size2(), and casadi::str().

columns()

casadi_int casadi::Sparsity::columns ( ) const

inline

Definition at line 340 of file sparsity.hpp.

{return size2();}

combine() [1/2]

Sparsity casadi::Sparsity::combine	(	const Sparsity &	y,
		bool	f0x_is_zero,
		bool	function0_is_zero
	)		const

Returns the new sparsity pattern as well as a mapping with the same length as the number of non-zero elements The mapping matrix contains the arguments for each nonzero, the first bit indicates if the first argument is nonzero, the second bit indicates if the second argument is nonzero (note that none of, one of or both of the arguments can be nonzero)

Extra doc: https://github.com/casadi/casadi/wiki/L_cl

Definition at line 404 of file sparsity.cpp.

                                                            {
    return (*this)->combine(y, f0x_is_zero, fx0_is_zero);
  }

References casadi::SparsityInternal::combine().

combine() [2/2]

Sparsity casadi::Sparsity::combine	(	const Sparsity &	y,
		bool	f0x_is_zero,
		bool	function0_is_zero,
		std::vector< unsigned char > &	mapping
	)		const

Returns the new sparsity pattern as well as a mapping with the same length as the number of non-zero elements The mapping matrix contains the arguments for each nonzero, the first bit indicates if the first argument is nonzero, the second bit indicates if the second argument is nonzero (note that none of, one of or both of the arguments can be nonzero)

Extra doc: https://github.com/casadi/casadi/wiki/L_cl

Definition at line 398 of file sparsity.cpp.

                                                                             {
    return (*this)->combine(y, f0x_is_zero, fx0_is_zero, mapping);
  }

References casadi::SparsityInternal::combine().

Referenced by casadi::MXNode::get_binary().

compress()

std::vector< casadi_int > casadi::Sparsity::compress

(

bool

canonical = true

)

const

Definition at line 1321 of file sparsity.cpp.

                                                               {
    if (canonical) {
      // fallback
    } else if (is_dense()) {
      return {size1(), size2(), 1};
    }
    return (*this)->sp();
  }

References is_dense(), size1(), and size2().

Referenced by casadi::CodeGenerator::add_sparsity(), and serialize().

compressed() [1/2]

Sparsity casadi::Sparsity::compressed ( const casadi_int *  v, bool  order_rows = false  )

static

Create from a single vector containing the pattern in compressed column storage format: The format: The first two entries are the number of rows (nrow) and columns (ncol) The next ncol+1 entries are the column offsets (colind). Note that the last element, colind[ncol], gives the number of nonzeros The last colind[ncol] entries are the row indices

Definition at line 1356 of file sparsity.cpp.

                                                                    {
    casadi_assert_dev(v!=nullptr);
 
    // Get sparsity pattern
    casadi_int nrow = v[0];
    casadi_int ncol = v[1];
    const casadi_int *colind = v+2;
    if (colind[0]==1) {
      // Dense matrix - deviation from canonical form
      return Sparsity::dense(nrow, ncol);
    }
    casadi_int nnz = colind[ncol];
    if (nrow*ncol == nnz) {
      // Dense matrix
      return Sparsity::dense(nrow, ncol);
    } else {
      // Sparse matrix
      const casadi_int *row = v + 2 + ncol+1;
      return Sparsity(nrow, ncol,
                      std::vector<casadi_int>(colind, colind+ncol+1),
                      std::vector<casadi_int>(row, row+nnz), order_rows);
    }
  }

References colind(), dense(), nnz(), row(), and Sparsity().

compressed() [2/2]

Sparsity casadi::Sparsity::compressed ( const std::vector< casadi_int > &  v, bool  order_rows = false  )

static

Create from a single vector containing the pattern in compressed column storage format: The format: The first two entries are the number of rows (nrow) and columns (ncol) The next ncol+1 entries are the column offsets (colind). Note that the last element, colind[ncol], gives the number of nonzeros The last colind[ncol] entries are the row indices

Definition at line 1341 of file sparsity.cpp.

                                                                               {
    // Check consistency
    casadi_assert_dev(v.size() >= 2);
    casadi_int nrow = v[0];
    casadi_int ncol = v[1];
    casadi_assert_dev(v.size() >= 2 + ncol+1);
    casadi_int nnz = v[2 + ncol];
    bool dense = v.size() == 2 + ncol+1 && nrow*ncol==nnz;
    bool sparse = v.size() == 2 + ncol+1 + nnz;
    casadi_assert_dev(dense || sparse);
 
    // Call array version
    return compressed(&v.front(), order_rows);
  }

References dense(), nnz(), and size().

Referenced by deserialize(), casadi::GenericExternal::get_jac_sparsity(), casadi::GenericExternal::get_sparsity_in(), casadi::GenericExternal::get_sparsity_out(), and qr_sparse().

count_down()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::count_down

protectedinherited

Definition at line 133 of file generic_shared_impl.hpp.

                                                   {
#ifdef WITH_EXTRA_CHECKS
    casadi_assert_dev(Function::call_depth_==0);
#endif // WITH_EXTRA_CHECKS
    if (!node) return;
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    GenericWeakRef<Shared, Internal>* weak_ref =
      node->weak_ref_.load(std::memory_order_acquire);
#else
    GenericWeakRef<Shared, Internal>* weak_ref = node->weak_ref_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
    if (weak_ref) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // get_mutex() returns a shared_ptr copy, so the mutex outlives this lock
      // even if delete node (below) destroys the WeakRefInternal holding it
      auto mutex = weak_ref->get_mutex();
      // Avoid triggering a delete while a weak_ref.shared_if_alive is being called
      std::lock_guard<std::mutex> lock(*mutex);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
      if (--static_cast<Internal*>(node)->count == 0) {
        delete node;
        node = nullptr;
      }
    } else {
      if (--static_cast<Internal*>(node)->count == 0) {
        delete node;
        node = nullptr;
      }
    }
  }

count_up()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::count_up

protectedinherited

Definition at line 132 of file generic_shared_impl.hpp.

                                                 {
#ifdef WITH_EXTRA_CHECKS
    casadi_assert_dev(Function::call_depth_==0);
#endif // WITH_EXTRA_CHECKS
 
    if (node) static_cast<Internal*>(node)->count++;
 
  }

create()

Sparsity casadi::Sparsity::create ( SparsityInternal *  node )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bc

Definition at line 72 of file sparsity.cpp.

                                                  {
    Sparsity ret;
    ret.own(node);
    return ret;
  }

References casadi::GenericShared< Shared, Internal >::own().

debug_repr()

std::string casadi::GenericShared< SharedObject , SharedObjectInternal >::debug_repr

inherited

Definition at line 112 of file generic_shared_impl.hpp.

                                                              {
    if (node) {
        return node->debug_repr(node);
    } else {
        return "NULL";
    }
  }

dense() [1/2]

Sparsity casadi::Sparsity::dense ( casadi_int  nrow, casadi_int  ncol = 1  )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_be

Definition at line 1028 of file sparsity.cpp.

                                                           {
    casadi_assert_dev(nrow>=0);
    casadi_assert_dev(ncol>=0);
    // Column offset
    std::vector<casadi_int> colind(ncol+1);
    for (casadi_int cc=0; cc<ncol+1; ++cc) colind[cc] = cc*nrow;
 
    // Row
    std::vector<casadi_int> row(ncol*nrow);
    for (casadi_int cc=0; cc<ncol; ++cc)
      for (casadi_int rr=0; rr<nrow; ++rr)
        row[rr+cc*nrow] = rr;
 
    return Sparsity(nrow, ncol, colind, row);
  }

References colind(), row(), and Sparsity().

Referenced by casadi::Constant< Value >::_get_binary(), casadi::SparsityInternal::_mtimes(), casadi::BSpline::BSpline(), casadi::BSplineParametric::BSplineParametric(), compressed(), casadi::GetNonzerosParam::create(), casadi::Matrix< Scalar >::densify(), casadi::MX::densify(), casadi::Determinant::Determinant(), casadi::OnnxFunction::get_forward(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::OnnxFunction::get_jacobian(), casadi::MXNode::get_mac(), casadi::Nlpsol::get_reverse(), casadi::OnnxFunction::get_reverse(), casadi::BlazingSplineFunction::get_sparsity_in(), casadi::Expm::get_sparsity_in(), casadi::FmuFunction::get_sparsity_in(), casadi::Integrator::get_sparsity_in(), casadi::Interpolant::get_sparsity_in(), casadi::BlazingSplineFunction::get_sparsity_out(), casadi::Conic::get_sparsity_out(), casadi::FmuFunction::get_sparsity_out(), casadi::Integrator::get_sparsity_out(), casadi::Interpolant::get_sparsity_out(), casadi::Nlpsol::get_sparsity_out(), casadi::MX::inf(), casadi::SqicInterface::init(), casadi::Dple::init(), casadi::Blocksqp::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Qrsqp::init(), casadi::Sqpmethod::init(), casadi::SlicotDple::init_mem(), casadi::Inverse::Inverse(), casadi::FunctionInternal::jac_sparsity(), kron(), casadi::Onnx::load(), casadi::LogSumExp::LogSumExp(), casadi::SparsityInternal::makeDense(), casadi::MX::MX(), casadi::MX::nan(), casadi::GenericMatrix< MatType >::ones(), casadi::SparsityInternal::pattern_inverse(), casadi::Convexify::setup(), casadi::MX::solve(), Sparsity(), sum1(), sum2(), casadi::GenericMatrix< MatType >::sym(), casadi::SymbolicMX::SymbolicMX(), casadi::OnnxFunction::tensor_sparsity(), and casadi::GenericMatrix< MatType >::zeros().

dense() [2/2]

static Sparsity casadi::Sparsity::dense ( const std::pair< casadi_int, casadi_int > &  rc )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_be

Definition at line 162 of file sparsity.hpp.

                                                                     {
      return dense(rc.first, rc.second);
    }

density()

double casadi::Sparsity::density

(

)

const

Equivalent to (100.0 * nnz())/numel(), but avoids overflow

Extra doc: https://github.com/casadi/casadi/wiki/L_br

Definition at line 136 of file sparsity.cpp.

                                 {
    double r = 100;
    r *= static_cast<double>(nnz());
    r /= static_cast<double>(size1());
    r /= static_cast<double>(size2());
    return r;
  }

References nnz(), size1(), and size2().

Referenced by casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm().

deserialize() [1/3]

Sparsity casadi::Sparsity::deserialize ( const std::string &  s )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_c4

Definition at line 2103 of file sparsity.cpp.

                                                   {
    std::stringstream ss;
    ss << s;
    return deserialize(ss);
  }

References deserialize().

deserialize() [2/3]

Sparsity casadi::Sparsity::deserialize ( DeserializingStream &  s )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_c6

Definition at line 2087 of file sparsity.cpp.

                                                       {
    std::vector<casadi_int> i;
    s.unpack("SparsityInternal::compressed", i);
    if (i.empty()) {
      return Sparsity();
    } else {
      return Sparsity::compressed(i);
    }
  }

References compressed(), Sparsity(), and casadi::DeserializingStream::unpack().

deserialize() [3/3]

Sparsity casadi::Sparsity::deserialize ( std::istream &  stream )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_c3

Definition at line 2074 of file sparsity.cpp.

                                                   {
    DeserializingStream s(stream);
    return Sparsity::deserialize(s);
  }

Referenced by deserialize().

dfs()

casadi_int casadi::Sparsity::dfs	(	casadi_int	j,
		casadi_int	top,
		std::vector< casadi_int > &	xi,
		std::vector< casadi_int > &	pstack,
		const std::vector< casadi_int > &	pinv,
		std::vector< bool > &	marked
	)		const

See Direct Methods for Sparse Linear Systems by Davis (2006).

Extra doc: https://github.com/casadi/casadi/wiki/L_d5

Definition at line 698 of file sparsity.cpp.

                                                           {
    return (*this)->dfs(j, top, xi, pstack, pinv, marked);
  }

Referenced by casadi::SparsityInternal::scc().

diag() [1/3]

static Sparsity casadi::Sparsity::diag ( casadi_int  nrow )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_bi

Definition at line 190 of file sparsity.hpp.

{ return diag(nrow, nrow);}

References diag().

Referenced by casadi::SolveUnity< Tr >::A_sp(), casadi::OsqpInterface::codegen_init_mem(), diag(), casadi::Factory< MatType >::get_output(), casadi::Blocksqp::init(), casadi::SundialsInterface::init(), casadi::SuperscsInterface::init(), casadi::Sqpmethod::init(), casadi::OsqpInterface::init_mem(), casadi::SlicotDple::init_mem(), kkt(), casadi::Convexify::setup(), casadi::Integrator::sp_jac_dae(), and casadi::Integrator::sp_jac_rdae().

diag() [2/3]

Sparsity casadi::Sparsity::diag ( casadi_int  nrow, casadi_int  ncol  )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bi

Definition at line 569 of file sparsity.cpp.

                                                          {
    // Smallest dimension
    casadi_int n = std::min(nrow, ncol);
 
    // Column offset
    std::vector<casadi_int> colind(ncol+1, n);
    for (casadi_int cc=0; cc<n; ++cc) colind[cc] = cc;
 
    // Row
    std::vector<casadi_int> row = range(n);
 
    // Create pattern from vectors
    return Sparsity(nrow, ncol, colind, row);
  }

References colind(), casadi::range(), row(), and Sparsity().

diag() [3/3]

static Sparsity casadi::Sparsity::diag ( const std::pair< casadi_int, casadi_int > &  rc )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_bi

Definition at line 192 of file sparsity.hpp.

                                                                    {
      return diag(rc.first, rc.second);
    }

diagcat()

Sparsity casadi::Sparsity::diagcat ( const std::vector< Sparsity > &  v )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1593 of file sparsity.cpp.

                                                           {
    casadi_int n = 0;
    casadi_int m = 0;
 
    std::vector<casadi_int> colind(1, 0);
    std::vector<casadi_int> row;
 
    casadi_int nz = 0;
    for (casadi_int i=0;i<v.size();++i) {
      const casadi_int* colind_ = v[i].colind();
      casadi_int ncol = v[i].size2();
      const casadi_int* row_ = v[i].row();
      casadi_int sz = v[i].nnz();
      for (casadi_int k=1; k<ncol+1; ++k) {
        colind.push_back(colind_[k]+nz);
      }
      for (casadi_int k=0; k<sz; ++k) {
        row.push_back(row_[k]+m);
      }
      n+= v[i].size2();
      m+= v[i].size1();
      nz+= v[i].nnz();
    }
 
    return Sparsity(m, n, colind, row);
  }

References colind(), row(), and Sparsity().

diagsplit()

std::vector< Sparsity > casadi::Sparsity::diagsplit ( const Sparsity &  x, const std::vector< casadi_int > &  offset1, const std::vector< casadi_int > &  offset2  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1685 of file sparsity.cpp.

                                                                                  {
    // Consistency check
    casadi_assert_dev(!offset1.empty());
    casadi_assert_dev(offset1.front()==0);
    casadi_assert(offset1.back()==x.size1(),
                          "diagsplit(Sparsity, offset1, offset2): Last elements of offset1 "
                          "(" + str(offset1.back()) + ") must equal the number of rows "
                          "(" + str(x.size1()) + ")");
    casadi_assert(offset2.back()==x.size2(),
                          "diagsplit(Sparsity, offset1, offset2): Last elements of offset2 "
                          "(" + str(offset2.back()) + ") must equal the number of rows "
                          "(" + str(x.size2()) + ")");
    casadi_assert_dev(is_monotone(offset1));
    casadi_assert_dev(is_monotone(offset2));
    casadi_assert_dev(offset1.size()==offset2.size());
 
    // Number of outputs
    casadi_int n = offset1.size()-1;
 
    // Return value
    std::vector<Sparsity> ret;
 
    // Caveat: this is a very silly implementation
    IM x2 = IM::zeros(x);
 
    for (casadi_int i=0; i<n; ++i) {
      ret.push_back(x2(Slice(offset1[i], offset1[i+1]),
                       Slice(offset2[i], offset2[i+1])).sparsity());
    }
 
    return ret;
  }

References casadi::is_monotone(), size1(), size2(), casadi::str(), and casadi::GenericMatrix< MatType >::zeros().

dim()

std::string casadi::Sparsity::dim

(

bool

with_nz = false

)

const

Definition at line 588 of file sparsity.cpp.

                                            {
    return (*this)->dim(with_nz);
  }

Referenced by add(), append(), appendColumns(), bor(), casadi::Conic::Conic(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::Dple::init(), casadi::Nlpsol::init(), is_singular(), mtimes(), casadi::mul_bvec_fwd(), mul_sparsityR(), norm_0_mul(), postfix_dim(), casadi::FunctionInternal::print_canonical(), casadi::MX::project(), and set().

disp()

void casadi::SharedObject::disp ( std::ostream &  stream, bool  more = false  ) const

inherited

Definition at line 35 of file shared_object.cpp.

                                                             {
    if (is_null()) {
      stream << "NULL";
    } else {
      (*this)->disp(stream, more);
    }
  }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().

Referenced by casadi::Nlpsol::disp_more(), and casadi::CsparseInterface::nfact().

enlarge()

void casadi::Sparsity::enlarge	(	casadi_int	nrow,
		casadi_int	ncol,
		const std::vector< casadi_int > &	rr,
		const std::vector< casadi_int > &	cc,
		bool	ind1 = false
	)

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 545 of file sparsity.cpp.

                                                                     {
    enlargeColumns(ncol, cc, ind1);
    enlargeRows(nrow, rr, ind1);
  }

References enlargeColumns(), and enlargeRows().

Referenced by casadi::MX::enlarge(), and casadi::Sqpmethod::init().

enlargeColumns()

void casadi::Sparsity::enlargeColumns	(	casadi_int	ncol,
		const std::vector< casadi_int > &	cc,
		bool	ind1 = false
	)

Extra doc: https://github.com/casadi/casadi/wiki/L_ct

Definition at line 551 of file sparsity.cpp.

                                                                                           {
    casadi_assert_dev(cc.size() == size2());
    if (cc.empty()) {
      *this = Sparsity(size1(), ncol);
    } else {
      *this = (*this)->_enlargeColumns(ncol, cc, ind1);
    }
  }

References size1(), size2(), and Sparsity().

Referenced by enlarge(), and casadi::FunctionInternal::from_compact().

enlargeRows()

void casadi::Sparsity::enlargeRows	(	casadi_int	nrow,
		const std::vector< casadi_int > &	rr,
		bool	ind1 = false
	)

Extra doc: https://github.com/casadi/casadi/wiki/L_cs

Definition at line 560 of file sparsity.cpp.

                                                                                        {
    casadi_assert_dev(rr.size() == size1());
    if (rr.empty()) {
      *this = Sparsity(nrow, size2());
    } else {
      *this = (*this)->_enlargeRows(nrow, rr, ind1);
    }
  }

References size1(), size2(), and Sparsity().

Referenced by enlarge(), and casadi::FunctionInternal::from_compact().

erase() [1/2]

std::vector< casadi_int > casadi::Sparsity::erase	(	const std::vector< casadi_int > &	rr,
		bool	ind1 = false
	)

Extra doc: https://github.com/casadi/casadi/wiki/L_cw

Definition at line 346 of file sparsity.cpp.

                                                                                  {
    std::vector<casadi_int> mapping;
    *this = (*this)->_erase(rr, ind1, mapping);
    return mapping;
  }

erase() [2/2]

std::vector< casadi_int > casadi::Sparsity::erase	(	const std::vector< casadi_int > &	rr,
		const std::vector< casadi_int > &	cc,
		bool	ind1 = false
	)

Extra doc: https://github.com/casadi/casadi/wiki/L_cv

Definition at line 339 of file sparsity.cpp.

                                                                              {
    std::vector<casadi_int> mapping;
    *this = (*this)->_erase(rr, cc, ind1, mapping);
    return mapping;
  }

Referenced by casadi::MX::erase(), and casadi::FmuFunction::init().

etree()

std::vector< casadi_int > casadi::Sparsity::etree

(

bool

ata = false

)

const

See Direct Methods for Sparse Linear Systems by Davis (2006). If the parameter ata is false, the algorithm is equivalent to MATLAB's etree(A), except that the indices are zero-based. If ata is true, the algorithm is equivalent to MATLAB's etree(A, 'col').

The implementation is a modified version of cs_etree in CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL

Extra doc: https://github.com/casadi/casadi/wiki/L_d2

Definition at line 616 of file sparsity.cpp.

                                                      {
    std::vector<casadi_int> parent(size2()), w(size1() + size2());
    SparsityInternal::etree(*this, get_ptr(parent), get_ptr(w), ata);
    return parent;
  }

References casadi::SparsityInternal::etree(), casadi::get_ptr(), size1(), and size2().

export_code()

void casadi::Sparsity::export_code	(	const std::string &	lang,
		std::ostream &	stream = casadi::uout(),
		const Dict &	options = Dict()
	)		const

lang: only 'matlab' supported for now

 * options:
 *   inline: Indicates if you want everything on a single line (default: False)
 *   name: Name of exported variable (default: 'sp')
 *   as_matrix: Matlab does not have a sparsity object. (default: false)
*               With this option true, a numeric matrix will be constructed
 * 

Extra doc: https://github.com/casadi/casadi/wiki/L_dj

Definition at line 789 of file sparsity.cpp.

                                 {
    (*this)->export_code(lang, stream, options);
  }

Referenced by casadi::XFunction< DerivedType, MatType, NodeType >::export_code(), casadi::MXFunction::export_code_body(), and casadi::Linsol::nfact().

file_format()

std::string casadi::Sparsity::file_format ( const std::string &  filename, const std::string &  format_hint, const std::set< std::string > &  file_formats  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1978 of file sparsity.cpp.

                                                                           {
    if (format_hint.empty()) {
      std::string extension = filename.substr(filename.rfind(".")+1);
      auto it = file_formats.find(extension);
      casadi_assert(it!=file_formats.end(),
        "Extension '" + extension + "' not recognised. "
        "Valid options: " + str(file_formats) + ".");
      return extension;
    } else {
      auto it = file_formats.find(format_hint);
      casadi_assert(it!=file_formats.end(),
        "File format hint '" + format_hint + "' not recognised. "
        "Valid options: " + str(file_formats) + ".");
      return format_hint;
    }
 
  }

References file_formats, casadi::filename(), and casadi::str().

Referenced by from_file(), and to_file().

find() [1/2]

std::vector< casadi_int > casadi::Sparsity::find

(

bool

ind1 = SWIG_IND1

)

const

A : DenseMatrix 4 x 3 B : SparseMatrix 4 x 3 , 5 structural non-zeros

k = A.find() A[k] will contain the elements of A that are non-zero in B

Inverse of nonzeros.

Extra doc: https://github.com/casadi/casadi/wiki/L_da

Definition at line 737 of file sparsity.cpp.

                                                      {
    std::vector<casadi_int> loc;
    find(loc, ind1);
    return loc;
  }

Referenced by casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_forward(), casadi::GetNonzeros::ad_reverse(), casadi::SetNonzeros< Add >::ad_reverse(), casadi::GetNonzeros::eval_mx(), casadi::SetNonzeros< Add >::eval_mx(), casadi::Matrix< Scalar >::set(), and casadi::MX::set().

find() [2/2]

void casadi::Sparsity::find	(	std::vector< casadi_int > &	loc,
		bool	ind1 = false
	)		const

Definition at line 743 of file sparsity.cpp.

                                                                 {
    (*this)->find(loc, ind1);
  }

from_file()

Sparsity casadi::Sparsity::from_file ( const std::string &  filename, const std::string &  format_hint = ""  )

static

Definition at line 2015 of file sparsity.cpp.

                                                                                      {
    std::string format = file_format(filename, format_hint, file_formats);
    auto in_ptr = Filesystem::ifstream_ptr(filename);
    std::istream& in = *in_ptr;
    if (format=="mtx") {
      std::string line;
      std::vector<casadi_int> row, col;
      casadi_int size1, size2, nnz;
      int line_num = 0;
      while (std::getline(in, line)) {
        if (line_num==0) {
          if (!line.empty() && line.back()=='\r') line.pop_back();
          casadi_assert(line=="%%MatrixMarket matrix coordinate pattern general", "Wrong header");
          line_num = 1;
        } else if (line_num==1) {
          std::stringstream stream(line);
          stream >> size1;
          stream >> size2;
          stream >> nnz;
          row.reserve(nnz);
          col.reserve(nnz);
          line_num = 2;
        } else {
          std::stringstream stream(line);
          casadi_int r, c;
          stream >> r;
          stream >> c;
          row.push_back(r-1);
          col.push_back(c-1);
        }
      }
      return triplet(size1, size2, row, col);
    } else {
      casadi_error("Unknown format '" + format + "'");
    }
  }

References file_format(), file_formats, casadi::filename(), casadi::Filesystem::ifstream_ptr(), nnz(), row(), size1(), size2(), and triplet().

get()

SparsityInternal * casadi::Sparsity::get

(

)

const

Definition at line 2109 of file sparsity.cpp.

                                        {
    return static_cast<SparsityInternal*>(SharedObject::get());
  }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().

Referenced by casadi::SparsityInternal::is_equal(), casadi::SparsityInternal::maxtrans(), and operator*().

get_ccs()

void casadi::Sparsity::get_ccs	(	std::vector< casadi_int > &	colind,
		std::vector< casadi_int > &	row
	)		const

Definition at line 376 of file sparsity.cpp.

                                                                                        {
    colind = get_colind();
    row = get_row();
  }

References colind(), get_colind(), get_row(), and row().

Referenced by get_crs().

get_col()

std::vector< casadi_int > casadi::Sparsity::get_col

(

)

const

Together with the row-vector, this vector gives the sparsity of the matrix in sparse triplet format, i.e. the column and row for each non-zero elements

Extra doc: https://github.com/casadi/casadi/wiki/L_cd

Definition at line 368 of file sparsity.cpp.

                                                {
    return (*this)->get_col();
  }

Referenced by casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_forward(), casadi::GetNonzeros::ad_reverse(), casadi::SetNonzeros< Add >::ad_reverse(), casadi::GetNonzeros::eval_mx(), casadi::SetNonzeros< Add >::eval_mx(), get_triplet(), casadi::DaeBuilderInternal::hess_sparsity(), casadi::SnoptInterface::init(), casadi::SparsityInternal::is_compactible(), casadi::MX::set(), casadi::KnitroInterface::solve(), to_file(), and casadi::UnoInterface::UnoInterface().

get_colind()

std::vector< casadi_int > casadi::Sparsity::get_colind

(

)

const

Together with the row-vector, one obtains the sparsity pattern in the column compressed format.

Extra doc: https://github.com/casadi/casadi/wiki/L_ca

Definition at line 364 of file sparsity.cpp.

                                                   {
    return (*this)->get_colind();
  }

Referenced by add_nz(), casadi::OsqpInterface::codegen_body(), casadi::OsqpInterface::codegen_init_mem(), get_ccs(), casadi::GenericMatrix< MatType >::get_colind(), info(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::OsqpInterface::init_mem(), and casadi::SuperscsInterface::init_mem().

get_crs()

void casadi::Sparsity::get_crs	(	std::vector< casadi_int > &	rowind,
		std::vector< casadi_int > &	col
	)		const

Definition at line 381 of file sparsity.cpp.

                                                                                        {
    T().get_ccs(rowind, col);
  }

References get_ccs(), and T().

get_diag()

Sparsity casadi::Sparsity::get_diag

(

std::vector< casadi_int > &

mapping

)

const

Get the diagonal of the matrix/create a diagonal matrix (mapping will contain the nonzero mapping) When the input is square, the diagonal elements are returned. If the input is vector-like, a diagonal matrix is constructed with it.

Definition at line 612 of file sparsity.cpp.

                                                                  {
    return (*this)->get_diag(mapping);
  }

References casadi::SparsityInternal::get_diag().

Referenced by casadi::MX::diag().

get_lower()

std::vector< casadi_int > casadi::Sparsity::get_lower

(

)

const

Definition at line 1003 of file sparsity.cpp.

                                                  {
    return (*this)->get_lower();
  }

get_nz() [1/3]

casadi_int casadi::Sparsity::get_nz	(	casadi_int	rr,
		casadi_int	cc
	)		const

return -1 if the element does not exist

Extra doc: https://github.com/casadi/casadi/wiki/L_cf

Definition at line 246 of file sparsity.cpp.

                                                                {
    return (*this)->get_nz(rr, cc);
  }

Referenced by casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_forward(), casadi::GetNonzeros::ad_reverse(), casadi::SetNonzeros< Add >::eval_mx(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), has_nz(), and casadi::MX::set().

get_nz() [2/3]

std::vector< casadi_int > casadi::Sparsity::get_nz	(	const std::vector< casadi_int > &	rr,
		const std::vector< casadi_int > &	cc
	)		const

return -1 if the element does not exist

Extra doc: https://github.com/casadi/casadi/wiki/L_cg

Definition at line 264 of file sparsity.cpp.

                                             {
    return (*this)->get_nz(rr, cc);
  }

get_nz() [3/3]

void casadi::Sparsity::get_nz

(

std::vector< casadi_int > &

indices

)

const

The index vector is used both for input and outputs and must be sorted by increasing nonzero index, i.e. column-wise. Elements not found in the sparsity pattern are set to -1.

Extra doc: https://github.com/casadi/casadi/wiki/L_ch

Definition at line 747 of file sparsity.cpp.

                                                            {
    (*this)->get_nz(indices);
  }

get_row()

std::vector< casadi_int > casadi::Sparsity::get_row

(

)

const

Together with the column-vector, this vector gives the sparsity of the matrix in sparse triplet format, and together with the colind vector, one obtains the sparsity in column compressed format.

Extra doc: https://github.com/casadi/casadi/wiki/L_c9

Definition at line 372 of file sparsity.cpp.

                                                {
    return (*this)->get_row();
  }

Referenced by add_nz(), casadi::OsqpInterface::codegen_init_mem(), get_ccs(), casadi::GenericMatrix< MatType >::get_row(), get_triplet(), casadi::DaeBuilderInternal::hess_sparsity(), info(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::OsqpInterface::init_mem(), casadi::SuperscsInterface::init_mem(), casadi::SparsityInternal::is_compactible(), permutation_vector(), casadi::MX::set(), casadi::KnitroInterface::solve(), to_file(), and casadi::UnoInterface::UnoInterface().

get_str()

std::string casadi::SharedObject::get_str ( bool  more = false ) const

inlineinherited

Definition at line 91 of file shared_object.hpp.

                                               {
        std::stringstream ss;
        disp(ss, more);
        return ss.str();
      }

get_triplet()

void casadi::Sparsity::get_triplet	(	std::vector< casadi_int > &	row,
		std::vector< casadi_int > &	col
	)		const

Definition at line 385 of file sparsity.cpp.

                                                                                         {
    row = get_row();
    col = get_col();
  }

References get_col(), get_row(), and row().

Referenced by casadi::PiqpInterface::solve(), and casadi::ProxqpInterface::solve().

get_upper()

std::vector< casadi_int > casadi::Sparsity::get_upper

(

)

const

Definition at line 1007 of file sparsity.cpp.

                                                  {
    return (*this)->get_upper();
  }

getCache()

Sparsity::CachingMap & casadi::Sparsity::getCache ( )

static

Definition at line 525 of file sparsity.cpp.

                                         {
    static CachingMap ret;
    return ret;
  }

getCount()

casadi_int casadi::GenericShared< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 102 of file generic_shared_impl.hpp.

                                                             {
    return (*this)->getCount();
  }

getEmpty()

const Sparsity & casadi::Sparsity::getEmpty ( )

static

Definition at line 540 of file sparsity.cpp.

                                     {
    static EmptySparsity ret;
    return ret;
  }

getScalar()

const Sparsity & casadi::Sparsity::getScalar ( )

static

Definition at line 530 of file sparsity.cpp.

                                      {
    static ScalarSparsity ret;
    return ret;
  }

getScalarSparse()

const Sparsity & casadi::Sparsity::getScalarSparse ( )

static

Definition at line 535 of file sparsity.cpp.

                                            {
    static ScalarSparseSparsity ret;
    return ret;
  }

has_nz()

bool casadi::Sparsity::has_nz	(	casadi_int	rr,
		casadi_int	cc
	)		const

Definition at line 241 of file sparsity.cpp.

                                                          {
    return get_nz(rr, cc)!=-1;
  }

References get_nz().

hash()

std::size_t casadi::Sparsity::hash

(

)

const

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 811 of file sparsity.cpp.

                                 {
    return (*this)->hash();
  }

Referenced by casadi::get_const().

horzcat()

Sparsity casadi::Sparsity::horzcat ( const std::vector< Sparsity > &  sp )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_cq

Definition at line 1408 of file sparsity.cpp.

                                                           {
    // Quick return if possible
    if (sp.empty()) return Sparsity(1, 0);
    if (sp.size()==1) return sp.front();
 
    // Count total nnz
    casadi_int nnz_total = 0;
    for (casadi_int i=0; i<sp.size(); ++i) nnz_total += sp[i].nnz();
 
    // Construct from vectors (triplet format)
    std::vector<casadi_int> ret_row, ret_col;
    ret_row.reserve(nnz_total);
    ret_col.reserve(nnz_total);
    casadi_int ret_ncol = 0;
    casadi_int ret_nrow = 0;
    for (casadi_int i=0; i<sp.size() && ret_nrow==0; ++i)
      ret_nrow = sp[i].size1();
 
    // Append all patterns
    for (std::vector<Sparsity>::const_iterator i=sp.begin(); i!=sp.end(); ++i) {
      // Get sparsity pattern
      casadi_int sp_nrow = i->size1();
      casadi_int sp_ncol = i->size2();
      const casadi_int* sp_colind = i->colind();
      const casadi_int* sp_row = i->row();
      casadi_assert(sp_nrow==ret_nrow || sp_nrow==0,
                            "Sparsity::horzcat: Mismatching number of rows");
 
      // Add entries to pattern
      for (casadi_int cc=0; cc<sp_ncol; ++cc) {
        for (casadi_int k=sp_colind[cc]; k<sp_colind[cc+1]; ++k) {
          ret_row.push_back(sp_row[k]);
          ret_col.push_back(cc + ret_ncol);
        }
      }
 
      // Update offset
      ret_ncol += sp_ncol;
    }
    return Sparsity::triplet(ret_nrow, ret_ncol, ret_row, ret_col);
  }

References nnz(), size1(), Sparsity(), and triplet().

Referenced by blockcat().

horzsplit()

std::vector< Sparsity > casadi::Sparsity::horzsplit ( const Sparsity &  x, const std::vector< casadi_int > &  offset  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1620 of file sparsity.cpp.

                                           {
    // Consistency check
    casadi_assert_dev(!offset.empty());
    casadi_assert_dev(offset.front()==0);
    casadi_assert(offset.back()==x.size2(),
                          "horzsplit(Sparsity, std::vector<casadi_int>): Last elements of offset "
                          "(" + str(offset.back()) + ") must equal the number of columns "
                          "(" + str(x.size2()) + ")");
    casadi_assert_dev(is_monotone(offset));
 
    // Number of outputs
    casadi_int n = offset.size()-1;
 
    // Get the sparsity of the input
    const casadi_int* colind_x = x.colind();
    const casadi_int* row_x = x.row();
 
    // Allocate result
    std::vector<Sparsity> ret;
    ret.reserve(n);
 
    // Sparsity pattern as CCS vectors
    std::vector<casadi_int> colind, row;
    casadi_int ncol, nrow = x.size1();
 
    // Get the sparsity patterns of the outputs
    for (casadi_int i=0; i<n; ++i) {
      casadi_int first_col = offset[i];
      casadi_int last_col = offset[i+1];
      ncol = last_col - first_col;
 
      // Construct the sparsity pattern
      colind.resize(ncol+1);
      std::copy(colind_x+first_col, colind_x+last_col+1, colind.begin());
      for (std::vector<casadi_int>::iterator it=colind.begin()+1; it!=colind.end(); ++it)
        *it -= colind[0];
      colind[0] = 0;
      row.resize(colind.back());
      std::copy(row_x+colind_x[first_col], row_x+colind_x[last_col], row.begin());
 
      // Append to the list
      ret.push_back(Sparsity(nrow, ncol, colind, row));
    }
 
    // Return (RVO)
    return ret;
  }

References colind(), casadi::is_monotone(), casadi::SparsityInterface< Sparsity >::offset(), row(), size1(), size2(), Sparsity(), and casadi::str().

Referenced by vertsplit().

info()

Dict casadi::Sparsity::info

(

)

const

Obtain information about sparsity

Definition at line 1971 of file sparsity.cpp.

                            {
    if (is_null()) return Dict();
    return {{"nrow", size1()}, {"ncol", size2()}, {"colind", get_colind()}, {"row", get_row()}};
  }

References get_colind(), get_row(), casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), size1(), and size2().

intersect() [1/2]

Sparsity casadi::Sparsity::intersect

(

const Sparsity &

y

)

const

Returns the new sparsity pattern as well as a mapping with the same length as the number of non-zero elements The value is 1 if the non-zero comes from the first (i.e. this) object, 2 if it is from the second and 3 (i.e. 1 | 2) if from both

Extra doc: https://github.com/casadi/casadi/wiki/L_cn

Definition at line 422 of file sparsity.cpp.

                                                      {
    return (*this)->combine(y, true, true);
  }

References casadi::SparsityInternal::combine().

intersect() [2/2]

Sparsity casadi::Sparsity::intersect	(	const Sparsity &	y,
		std::vector< unsigned char > &	mapping
	)		const

Returns the new sparsity pattern as well as a mapping with the same length as the number of non-zero elements The value is 1 if the non-zero comes from the first (i.e. this) object, 2 if it is from the second and 3 (i.e. 1 | 2) if from both

Extra doc: https://github.com/casadi/casadi/wiki/L_cn

Definition at line 417 of file sparsity.cpp.

                                                                                  {
    return (*this)->combine(y, true, true, mapping);
  }

References casadi::SparsityInternal::combine().

Referenced by casadi::MXNode::get_dot(), casadi::Project::get_nzref(), operator*(), and casadi::MX::project().

is_column()

bool casadi::Sparsity::is_column

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cy

Definition at line 285 of file sparsity.cpp.

                                 {
    return (*this)->is_column();
  }

Referenced by append(), casadi::Rootfinder::init(), casadi::GenericMatrix< MatType >::is_column(), postfix_dim(), casadi::Matrix< Scalar >::print_default(), and casadi::Matrix< Scalar >::print_vector().

is_compactible()

bool casadi::Sparsity::is_compactible	(	std::vector< casadi_int > &	row,
		std::vector< casadi_int > &	col
	)		const

If true, returns the (sorted) row and column index sets such that nz(i, j) <-> i in row and j in col. The nonzero buffer of a compactible matrix in CCS is laid out exactly as a column-major dense row.size() x col.size() matrix, so it can be consumed by dense kernels without gather/scatter.

Extra doc: https://github.com/casadi/casadi/wiki/L_2gf

Definition at line 806 of file sparsity.cpp.

                                                                  {
    return (*this)->is_compactible(row, col);
  }

References row().

Referenced by casadi::PseudoDenseMultiplication::try_create().

is_dense()

bool casadi::Sparsity::is_dense

(

)

const

Definition at line 273 of file sparsity.cpp.

                                {
    return (*this)->is_dense();
  }

Referenced by casadi::SparsityInternal::_mtimes(), add_nz(), compress(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::AlpaqaProblem::eval_jac_g(), casadi::XFunction< DerivedType, MatType, NodeType >::export_code(), casadi::AlpaqaProblem::get_hess_L_num_nonzeros(), casadi::AlpaqaProblem::get_hess_ψ_num_nonzeros(), casadi::AlpaqaProblem::get_jac_g_num_nonzeros(), casadi::MXNode::get_project(), casadi::Constant< Value >::get_project(), casadi::Integrator::init(), casadi::Rootfinder::init(), casadi::GenericMatrix< MatType >::is_dense(), casadi::Function::jac_sparsity(), kron(), casadi::Onnx::load(), casadi::Integrator::map2oracle(), postfix_dim(), casadi::FunctionInternal::print_canonical(), and casadi::Scpgen::regularize().

is_diag()

bool casadi::Sparsity::is_diag

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_247

Definition at line 277 of file sparsity.cpp.

                               {
    return (*this)->is_diag();
  }

Referenced by casadi::SparsityInternal::_mtimes().

is_empty()

bool casadi::Sparsity::is_empty

(

bool

both = false

)

const

A sparsity is considered empty if one of the dimensions is zero (or optionally both dimensions)

Extra doc: https://github.com/casadi/casadi/wiki/L_bs

Definition at line 144 of file sparsity.cpp.

                                         {
    return (*this)->is_empty(both);
  }

Referenced by casadi::SparsityInternal::_mtimes(), add(), bor(), casadi::FunctionInternal::check_mat(), casadi::ConstantMX::create(), casadi::MXNode::get_mmax(), casadi::MXNode::get_mmin(), casadi::ZeroByZero::get_reshape(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::GenericMatrix< MatType >::is_empty(), casadi::Integrator::map2oracle(), postfix_dim(), casadi::Matrix< Scalar >::print_default(), casadi::Call::projectArg(), and set().

is_equal() [1/3]

bool casadi::Sparsity::is_equal	(	casadi_int	nrow,
		casadi_int	ncol,
		const casadi_int *	colind,
		const casadi_int *	row
	)		const

Definition at line 453 of file sparsity.cpp.

                                                             {
    return (*this)->is_equal(nrow, ncol, colind, row);
  }

References colind(), and row().

is_equal() [2/3]

bool casadi::Sparsity::is_equal	(	casadi_int	nrow,
		casadi_int	ncol,
		const std::vector< casadi_int > &	colind,
		const std::vector< casadi_int > &	row
	)		const

Definition at line 448 of file sparsity.cpp.

                                                                 {
    return (*this)->is_equal(nrow, ncol, colind, row);
  }

References colind(), and row().

is_equal() [3/3]

bool casadi::Sparsity::is_equal

(

const Sparsity &

y

)

const

Definition at line 444 of file sparsity.cpp.

                                                 {
    return (*this)->is_equal(y);
  }

is_null()

bool casadi::GenericShared< SharedObject , SharedObjectInternal >::is_null

inherited

Definition at line 116 of file generic_shared_impl.hpp.

                                                      {
    return node==nullptr;
  }

is_orthonormal()

bool casadi::Sparsity::is_orthonormal

(

bool

allow_empty = false

)

const

Parameters

[in]

allow_empty

Disregard empty rows and columns in the analysis

Extra doc: https://github.com/casadi/casadi/wiki/L_24f

Definition at line 305 of file sparsity.cpp.

                                                      {
    return (*this)->is_orthonormal(allow_empty);
  }

Referenced by casadi::MX::solve().

is_orthonormal_columns()

bool casadi::Sparsity::is_orthonormal_columns

(

bool

allow_empty = false

)

const

Parameters

[in]

allow_empty

Disregard empty columns in the analysis

Extra doc: https://github.com/casadi/casadi/wiki/L_24h

Definition at line 313 of file sparsity.cpp.

                                                              {
    return (*this)->is_orthonormal_columns(allow_empty);
  }

is_orthonormal_rows()

bool casadi::Sparsity::is_orthonormal_rows

(

bool

allow_empty = false

)

const

Parameters

[in]

allow_empty

Disregard empty rows in the analysis

Extra doc: https://github.com/casadi/casadi/wiki/L_24g

Definition at line 309 of file sparsity.cpp.

                                                           {
    return (*this)->is_orthonormal_rows(allow_empty);
  }

is_permutation()

bool casadi::Sparsity::is_permutation

(

)

const

A Matrix P is permutation matrix if right multiplication with a dense vector v leads to a vector with the same elements, but permuted.

Implies square

Equivalent to is_orthonormal(false)

Extra doc: https://github.com/casadi/casadi/wiki/L_24d

Definition at line 297 of file sparsity.cpp.

                                      {
    return (*this)->is_permutation();
  }

Referenced by permutation_vector().

is_reshape()

bool casadi::Sparsity::is_reshape

(

const Sparsity &

y

)

const

Definition at line 802 of file sparsity.cpp.

                                                   {
    return (*this)->is_reshape(*y);
  }

Referenced by casadi::MXNode::get_reshape(), casadi::SparsityCast::get_reshape(), casadi::MX::MX(), casadi::MX::reshape(), and reshape().

is_row()

bool casadi::Sparsity::is_row

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cx

Definition at line 281 of file sparsity.cpp.

                              {
    return (*this)->is_row();
  }

Referenced by casadi::GenericMatrix< MatType >::is_row().

is_scalar()

bool casadi::Sparsity::is_scalar

(

bool

scalar_and_dense = false

)

const

Definition at line 269 of file sparsity.cpp.

                                                      {
    return (*this)->is_scalar(scalar_and_dense);
  }

Referenced by casadi::SparsityInternal::_mtimes(), casadi::Matrix< Scalar >::_sym(), casadi::FunctionInternal::check_mat(), casadi::Integrator::init(), casadi::Integrator::map2oracle(), postfix_dim(), and casadi::FunctionInternal::print_canonical().

is_selection()

bool casadi::Sparsity::is_selection

(

bool

allow_empty = false

)

const

A Matrix S is selection matrix if right multiplication with a dense vector leads to a vector with a subset of the elements of the original vector

Parameters

[in]

allow_empty

Allow the resultant vector to have structural zeros

Equivalent to is_orthonormal_rows(allow_empty)

Extra doc: https://github.com/casadi/casadi/wiki/L_24e

Definition at line 301 of file sparsity.cpp.

                                                    {
    return (*this)->is_selection(allow_empty);
  }

is_singular()

bool casadi::Sparsity::is_singular

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_24c

Definition at line 1315 of file sparsity.cpp.

                                   {
    casadi_assert(is_square(),
      "is_singular: only defined for square matrices, but got " + dim());
    return sprank(*this)!=size2();
  }

References dim(), is_square(), size2(), and sprank().

Referenced by casadi::Integrator::init(), casadi::Rootfinder::init(), and casadi::CsparseInterface::nfact().

is_square()

bool casadi::Sparsity::is_square

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_248

Definition at line 293 of file sparsity.cpp.

                                 {
    return (*this)->is_square();
  }

Referenced by casadi::Expm::Expm(), is_singular(), casadi::GenericMatrix< MatType >::is_square(), kkt(), and casadi::Convexify::setup().

is_stacked()

bool casadi::Sparsity::is_stacked	(	const Sparsity &	y,
		casadi_int	n
	)		const

Definition at line 440 of file sparsity.cpp.

                                                                 {
    return (*this)->is_stacked(y, n);
  }

is_subset()

bool casadi::Sparsity::is_subset

(

const Sparsity &

rhs

)

const

Definition at line 426 of file sparsity.cpp.

                                                    {
    return (*this)->is_subset(rhs);
  }

Referenced by casadi::SparsityCast::ad_reverse(), and casadi::Project::get_project().

is_symmetric()

bool casadi::Sparsity::is_symmetric

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_249

Definition at line 317 of file sparsity.cpp.

                                    {
    return (*this)->is_symmetric();
  }

Referenced by casadi::Conic::Conic(), casadi::Dple::init(), casadi::FatropInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Sqpmethod::init(), casadi::FunctionInternal::jac_sparsity(), ldl(), and casadi::Convexify::setup().

is_transpose()

bool casadi::Sparsity::is_transpose

(

const Sparsity &

y

)

const

Definition at line 798 of file sparsity.cpp.

                                                     {
    return (*this)->is_transpose(*y);
  }

is_tril()

bool casadi::Sparsity::is_tril

(

bool

strictly = false

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_24b

Definition at line 321 of file sparsity.cpp.

                                            {
    return (*this)->is_tril(strictly);
  }

Referenced by casadi::MadmpecInterface::init(), casadi::MadnlpInterface::init(), casadi::GenericMatrix< MatType >::is_tril(), and casadi::Convexify::setup().

is_triu()

bool casadi::Sparsity::is_triu

(

bool

strictly = false

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_24a

Definition at line 325 of file sparsity.cpp.

                                            {
    return (*this)->is_triu(strictly);
  }

Referenced by casadi::IpoptInterface::init(), casadi::GenericMatrix< MatType >::is_triu(), and casadi::Convexify::setup().

is_vector()

bool casadi::Sparsity::is_vector

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cz

Definition at line 289 of file sparsity.cpp.

                                 {
    return (*this)->is_vector();
  }

Referenced by casadi::FunctionInternal::check_mat(), casadi::Integrator::init(), casadi::GenericMatrix< MatType >::is_vector(), casadi::Integrator::map2oracle(), and casadi::Call::projectArg().

kkt()

Sparsity casadi::Sparsity::kkt ( const Sparsity &  H, const Sparsity &  J, bool  with_x_diag = true, bool  with_lam_g_diag = true  )

static

[H + I1, J'; J, I2] where I1 and I2 are optional

Extra doc: https://github.com/casadi/casadi/wiki/L_dk

Definition at line 2052 of file sparsity.cpp.

                                                                 {
    // Consistency check
    casadi_assert(H.is_square(), "H must be square");
    casadi_assert(H.size1() == J.size2(), "Dimension mismatch");
 
    // Add diagonal to H recursively
    if (with_x_diag) return kkt(H + diag(H.size()), J, false, with_lam_g_diag);
 
    // Lower right entry
    int ng = J.size1();
    Sparsity B = with_lam_g_diag ? diag(ng, ng) : Sparsity(ng, ng);
 
    // Concatenate
    return blockcat({{H, J.T()}, {J, B}});
  }

References blockcat(), diag(), is_square(), size(), size1(), size2(), Sparsity(), and T().

Referenced by casadi::Ipqp::init(), and casadi::Qrqp::init().

kron()

Sparsity casadi::Sparsity::kron ( const Sparsity &  a, const Sparsity &  b  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1450 of file sparsity.cpp.

                                                              {
    casadi_int a_ncol = a.size2();
    casadi_int b_ncol = b.size2();
    casadi_int a_nrow = a.size1();
    casadi_int b_nrow = b.size1();
    if (a.is_dense() && b.is_dense()) return Sparsity::dense(a_nrow*b_nrow, a_ncol*b_ncol);
 
    const casadi_int* a_colind = a.colind();
    const casadi_int* a_row = a.row();
    const casadi_int* b_colind = b.colind();
    const casadi_int* b_row = b.row();
 
    std::vector<casadi_int> r_colind(a_ncol*b_ncol+1, 0);
    std::vector<casadi_int> r_row(a.nnz()*b.nnz());
 
    casadi_int* r_colind_ptr = get_ptr(r_colind);
    casadi_int* r_row_ptr = get_ptr(r_row);
 
    casadi_int i=0;
    casadi_int j=0;
    // Loop over the columns
    for (casadi_int a_cc=0; a_cc<a_ncol; ++a_cc) {
      casadi_int a_start = a_colind[a_cc];
      casadi_int a_stop  = a_colind[a_cc+1];
      // Loop over the columns
      for (casadi_int b_cc=0; b_cc<b_ncol; ++b_cc) {
        casadi_int b_start = b_colind[b_cc];
        casadi_int b_stop  = b_colind[b_cc+1];
        // Loop over existing nonzeros
        for (casadi_int a_el=a_start; a_el<a_stop; ++a_el) {
          casadi_int a_r = a_row[a_el];
          // Loop over existing nonzeros
          for (casadi_int b_el=b_start; b_el<b_stop; ++b_el) {
            casadi_int b_r = b_row[b_el];
            r_row_ptr[i++] = a_r*b_nrow+b_r;
          }
        }
        j+=1;
        r_colind_ptr[j] = r_colind_ptr[j-1] + (b_stop-b_start)*(a_stop-a_start);
      }
    }
    return Sparsity(a_nrow*b_nrow, a_ncol*b_ncol, r_colind, r_row);
  }

References colind(), dense(), casadi::get_ptr(), is_dense(), nnz(), row(), size1(), size2(), and Sparsity().

Referenced by casadi::MXNode::get_kron(), and casadi::Kron::Kron().

kron_contract()

Sparsity casadi::Sparsity::kron_contract ( const Sparsity &  sp_m, const Sparsity &  sp_x, bool  inner  )

static

Given an (mA*mB, nA*nB) pattern sp_m and an (xrow, xcol) pattern sp_x, computes the output sparsity. Both modes share the same (yrow, ycol) = sp_m.size() / sp_x.size() shape; what differs is which axis pair indexes the output:

• inner = true: (i, j) ∈ y iff ∃ (r, s) ∈ sp_x with (i*xrow + r, j*xcol + s) ∈ sp_m; output indexed by the outer block of M.

• inner = false: (r, s) ∈ y iff ∃ (i, j) ∈ sp_x with (i*yrow + r, j*ycol + s) ∈ sp_m; output indexed by the inner block of M.

  Extra doc: https://github.com/casadi/casadi/wiki/L_2hn

Definition at line 1494 of file sparsity.cpp.

                                                                                         {
    casadi_int xrow = sp_x.size1();
    casadi_int xcol = sp_x.size2();
    casadi_assert(xrow > 0 && xcol > 0,
        "Sparsity::kron_contract: sp_x must be nonempty");
    casadi_assert(sp_m.size1() % xrow == 0 && sp_m.size2() % xcol == 0,
        "Sparsity::kron_contract: sp_m dims must be multiples of sp_x dims");
    casadi_int yrow = sp_m.size1() / xrow;
    casadi_int ycol = sp_m.size2() / xcol;
    // Block-split factor of M's row/col indices. Inner: M_row=i*xrow+r, so
    // split_r=xrow. Outer: M_row=i*yrow+r, so split_r=yrow. Same for cols.
    casadi_int split_r = inner ? xrow : yrow;
    casadi_int split_c = inner ? xcol : ycol;
    // Densify x's pattern into a dense lookup
    std::vector<bool> x_dense(xrow * xcol, false);
    const casadi_int* x_colind = sp_x.colind();
    const casadi_int* x_row    = sp_x.row();
    for (casadi_int cc = 0; cc < xcol; ++cc) {
      for (casadi_int el = x_colind[cc]; el < x_colind[cc+1]; ++el) {
        x_dense[cc*xrow + x_row[el]] = true;
      }
    }
    // Walk m's CSC. For each (outer, inner) decomposition of m's row/col,
    // the (y, x) assignment swaps with `inner`.
    std::vector<bool> y_dense(yrow * ycol, false);
    const casadi_int* m_colind = sp_m.colind();
    const casadi_int* m_row    = sp_m.row();
    casadi_int outer_c_count = sp_m.size2() / split_c;  // ycol if inner, xcol otherwise
    for (casadi_int outer_c = 0; outer_c < outer_c_count; ++outer_c) {
      for (casadi_int inner_c = 0; inner_c < split_c; ++inner_c) {
        casadi_int cc = outer_c*split_c + inner_c;
        casadi_int y_c = inner ? outer_c : inner_c;
        casadi_int x_c = inner ? inner_c : outer_c;
        for (casadi_int el = m_colind[cc]; el < m_colind[cc+1]; ++el) {
          casadi_int rr = m_row[el];
          casadi_int outer_r = rr / split_r;
          casadi_int inner_r = rr % split_r;
          casadi_int y_r = inner ? outer_r : inner_r;
          casadi_int x_r = inner ? inner_r : outer_r;
          if (x_dense[x_c*xrow + x_r]) {
            y_dense[y_c*yrow + y_r] = true;
          }
        }
      }
    }
    // Build CSC from y_dense
    std::vector<casadi_int> y_colind(ycol + 1, 0);
    std::vector<casadi_int> y_row;
    for (casadi_int j = 0; j < ycol; ++j) {
      for (casadi_int i = 0; i < yrow; ++i) {
        if (y_dense[j*yrow + i]) y_row.push_back(i);
      }
      y_colind[j+1] = y_row.size();
    }
    return Sparsity(yrow, ycol, y_colind, y_row);
  }

References colind(), row(), size1(), size2(), and Sparsity().

Referenced by casadi::MXNode::get_kron_contract(), and casadi::KronContract::KronContract().

largest_first()

std::vector< casadi_int > casadi::Sparsity::largest_first

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_de

Definition at line 776 of file sparsity.cpp.

                                                      {
    return (*this)->largest_first();
  }

ldl()

Sparsity casadi::Sparsity::ldl	(	std::vector< casadi_int > &	p,
		bool	amd = true
	)		const

Returns the sparsity pattern of L^T

The implementation is a modified version of LDL Copyright(c) Timothy A. Davis, 2005-2013 Licensed as a derivative work under the GNU LGPL

Extra doc: https://github.com/casadi/casadi/wiki/L_d3

Definition at line 622 of file sparsity.cpp.

                                                                 {
    casadi_assert(is_symmetric(),
                 "LDL factorization requires a symmetric matrix");
    // Recursive call if AMD
    if (amd) {
      // Get AMD reordering
      p = this->amd();
      // Permute sparsity pattern
      std::vector<casadi_int> tmp;
      Sparsity Aperm = sub(p, p, tmp);
      // Call recursively
      return Aperm.ldl(tmp, false);
    }
    // Dimension
    casadi_int n=size1();
    // Natural ordering
    p = range(n);
    // Work vector
    std::vector<casadi_int> w(3*n);
    // Elimination tree
    std::vector<casadi_int> parent(n);
    // Calculate colind in L (strictly lower entries only)
    std::vector<casadi_int> L_colind(1+n);
    SparsityInternal::ldl_colind(*this, get_ptr(parent), get_ptr(L_colind), get_ptr(w));
    // Get rows in L (strictly lower entries only)
    std::vector<casadi_int> L_row(L_colind.back());
    SparsityInternal::ldl_row(*this, get_ptr(parent), get_ptr(L_colind), get_ptr(L_row),
                    get_ptr(w));
    // Sparsity of L^T
    return Sparsity(n, n, L_colind, L_row, true).T();
  }

References amd(), casadi::get_ptr(), is_symmetric(), ldl(), casadi::SparsityInternal::ldl_colind(), casadi::SparsityInternal::ldl_row(), casadi::range(), size1(), Sparsity(), and sub().

Referenced by casadi::SuperscsInterface::init(), casadi::LinsolLdl::init(), and ldl().

lower()

Sparsity casadi::Sparsity::lower ( casadi_int  n )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bh

Definition at line 1065 of file sparsity.cpp.

                                       {
    casadi_assert(n>=0, "Sparsity::lower expects a positive integer as argument");
    casadi_int nrow=n, ncol=n;
    std::vector<casadi_int> colind, row;
    colind.reserve(ncol+1);
    row.reserve((n*(n+1))/2);
 
    // Loop over columns
    colind.push_back(0);
    for (casadi_int cc=0; cc<ncol; ++cc) {
      // Loop over rows for the lower triangular half
      for (casadi_int rr=cc; rr<nrow; ++rr) {
        row.push_back(rr);
      }
      colind.push_back(row.size());
    }
 
    // Return the pattern
    return Sparsity(nrow, ncol, colind, row);
  }

References colind(), row(), and Sparsity().

Referenced by casadi::Convexify::setup(), and casadi::OptiNode::variable().

mac()

static Sparsity casadi::Sparsity::mac ( const Sparsity &  x, const Sparsity &  y, const Sparsity &  z, const std::string &  = "reference"  )

inlinestatic

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 730 of file sparsity.hpp.

                                                          { return z;}

makeDense()

Sparsity casadi::Sparsity::makeDense

(

std::vector< casadi_int > &

mapping

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cu

Definition at line 584 of file sparsity.cpp.

                                                                   {
    return (*this)->makeDense(mapping);
  }

References casadi::SparsityInternal::makeDense().

mtimes()

Sparsity casadi::Sparsity::mtimes ( const Sparsity &  x, const Sparsity &  y, const std::string &  blas = "reference"  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 430 of file sparsity.cpp.

                                                {
    // Check matching dimensions
    casadi_assert(x.size2()==y.size1(),
      "Matrix product with incompatible dimensions. Lhs is "
      + x.dim() + " and rhs is " + y.dim() + ".");
 
    return x->_mtimes(y);
  }

References casadi::SparsityInternal::_mtimes(), dim(), size1(), and size2().

Referenced by casadi::MX::mtimes(), qr_sparse(), sum1(), and sum2().

mul_activityF()

void casadi::Sparsity::mul_activityF ( const bvec_t *  x, const Sparsity &  x_sp, const bvec_t *  y, const Sparsity &  y_sp, bvec_t *  z, const Sparsity &  z_sp, bvec_t *  w  )

static

Like mul_sparsityF, but combines the two factors of each term with AND rather than OR (an inactive factor annihilates that term), so an output is active only where some term has both factors active. No memory allocation; work vector w.

Extra doc: https://github.com/casadi/casadi/wiki/L_2in

Definition at line 1874 of file sparsity.cpp.

                                          {
    mul_bvec_fwd<true>(x, x_sp, y, y_sp, z, z_sp, w);
  }

Referenced by casadi::Multiplication::eval_activity().

mul_sparsityF()

void casadi::Sparsity::mul_sparsityF ( const bvec_t *  x, const Sparsity &  x_sp, const bvec_t *  y, const Sparsity &  y_sp, bvec_t *  z, const Sparsity &  z_sp, bvec_t *  w  )

static

no memory allocation: z = mul(x, y) with work vector Forward mode.

Extra doc: https://github.com/casadi/casadi/wiki/L_co

Definition at line 1867 of file sparsity.cpp.

                                          {
    mul_bvec_fwd<false>(x, x_sp, y, y_sp, z, z_sp, w);
  }

Referenced by casadi::Multiplication::sp_forward().

mul_sparsityR()

void casadi::Sparsity::mul_sparsityR ( bvec_t *  x, const Sparsity &  x_sp, bvec_t *  y, const Sparsity &  y_sp, bvec_t *  z, const Sparsity &  z_sp, bvec_t *  w  )

static

no memory allocation: z = mul(x, y) with work vector Reverse mode.

Extra doc: https://github.com/casadi/casadi/wiki/L_cp

Definition at line 1881 of file sparsity.cpp.

                                          {
    // Assert dimensions
    casadi_assert(z_sp.size1()==x_sp.size1() && x_sp.size2()==y_sp.size1()
                          && y_sp.size2()==z_sp.size2(),
                          "Dimension error. Got x=" + x_sp.dim() + ", y=" + y_sp.dim()
                          + " and z=" + z_sp.dim() + ".");
 
    // Direct access to the arrays
    const casadi_int* y_colind = y_sp.colind();
    const casadi_int* y_row = y_sp.row();
    const casadi_int* x_colind = x_sp.colind();
    const casadi_int* x_row = x_sp.row();
    const casadi_int* z_colind = z_sp.colind();
    const casadi_int* z_row = z_sp.row();
 
    // Clear residual work vector data from preceding operations (not necessary
    // for data from this method if conditional clear code is made unconditional
    // in loop)
    casadi_int nrow = z_sp.size1();
    casadi_fill(w, nrow, static_cast<bvec_t>(0));
 
    // Loop over the columns of y and z
    casadi_int ncol = z_sp.size2();
    for (casadi_int cc=0; cc<ncol; ++cc) {
      // Get the dense column of z
      for (casadi_int kk=z_colind[cc]; kk<z_colind[cc+1]; ++kk) {
        w[z_row[kk]] = z[kk];
      }
 
      // Loop over the nonzeros of y
      for (casadi_int kk=y_colind[cc]; kk<y_colind[cc+1]; ++kk) {
        casadi_int rr = y_row[kk];
 
        // Loop over corresponding columns of x
        bvec_t yy = 0;
        for (casadi_int kk1=x_colind[rr]; kk1<x_colind[rr+1]; ++kk1) {
          yy |= w[x_row[kk1]];
          x[kk1] |= w[x_row[kk1]];
        }
        y[kk] |= yy;
      }
 
      // Get the sparse column of z, clear work vector for next column
      for (casadi_int kk=z_colind[cc]; kk<z_colind[cc+1]; ++kk) {
        z[kk] = w[z_row[kk]];
        w[z_row[kk]] = 0;
      }
    }
  }

References casadi::casadi_fill(), colind(), dim(), row(), size1(), and size2().

Referenced by casadi::Multiplication::sp_reverse().

nnz()

casadi_int casadi::Sparsity::nnz

(

)

const

See also

numel()

Extra doc: https://github.com/casadi/casadi/wiki/L_bt

Definition at line 148 of file sparsity.cpp.

                                 {
    return (*this)->nnz();
  }

Referenced by casadi::Matrix< Scalar >::_sym(), casadi::MX::_sym(), casadi::SetNonzeros< Add >::ad_forward(), casadi::GetNonzeros::ad_reverse(), casadi::SetNonzeros< Add >::ad_reverse(), add(), add_nz(), bor(), casadi::Switch::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::OsqpInterface::codegen_init_mem(), casadi::Sqpmethod::codegen_solve_elastic_mode(), casadi::SparsityInternal::combineGen1(), compressed(), casadi::ConstantFile::ConstantFile(), casadi::ConstantMX::create(), density(), casadi::FmuFunction::eval(), casadi::Switch::eval(), casadi::HorzRepsum::eval_gen(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::AlpaqaProblem::eval_jac_g(), casadi::Scpgen::eval_mat(), casadi::SetNonzeros< Add >::eval_mx(), casadi::Switch::eval_sx(), casadi::LinsolQr::finalize(), from_file(), casadi::LinsolLdl::generate(), casadi::HorzRepsum::generate(), casadi::UnaryMX::generate(), casadi::CodeGenerator::generate_dump(), casadi::LinsolQr::generate_factorize(), casadi::get_const(), casadi::AlpaqaProblem::get_hess_L_num_nonzeros(), casadi::AlpaqaProblem::get_hess_ψ_num_nonzeros(), casadi::AlpaqaProblem::get_jac_g_num_nonzeros(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::BonminInterface::get_nlp_info(), casadi::IpoptInterface::get_nlp_info(), casadi::Call::get_output(), casadi::MultipleOutput::get_output(), casadi::MXNode::get_project(), casadi::MXNode::get_sparsity_cast(), casadi::FunctionInternal::get_sparsity_out(), horzcat(), casadi::FmuFunction::init(), casadi::Switch::init(), casadi::AmplInterface::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::CbcInterface::init(), casadi::ClpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::IpoptInterface::init(), casadi::MosekInterface::init(), casadi::OsqpInterface::init(), casadi::PiqpInterface::init(), casadi::SLEQPInterface::init(), casadi::SnoptInterface::init(), casadi::KinsolInterface::init(), casadi::SundialsInterface::init(), casadi::SuperscsInterface::init(), casadi::XpressInterface::init(), casadi::FastNewton::init(), casadi::Feasiblesqpmethod::init(), casadi::Ipqp::init(), casadi::Newton::init(), casadi::Qrqp::init(), casadi::Qrsqp::init(), casadi::Scpgen::init(), casadi::Sqpmethod::init(), casadi::ClarabelInterface::init_dependent(), casadi::HighsInterface::init_dependent(), casadi::MosekInterface::init_dependent(), casadi::XpressInterface::init_dependent(), casadi::Blocksqp::init_mem(), casadi::CbcInterface::init_mem(), casadi::ClpInterface::init_mem(), casadi::CplexInterface::init_mem(), casadi::HpmpcInterface::init_mem(), casadi::OsqpInterface::init_mem(), casadi::PiqpInterface::init_mem(), casadi::ProxqpInterface::init_mem(), casadi::QpoasesInterface::init_mem(), casadi::SuperscsInterface::init_mem(), casadi::LinsolLdl::init_mem(), casadi::LinsolQr::init_mem(), casadi::Lsqr::init_mem(), kron(), casadi::MosekInterface::MosekInterface(), casadi::MX::MX(), casadi::LinsolQr::nfact(), norm_0_mul(), casadi::FunctionInternal::print_canonical(), casadi::Matrix< Scalar >::print_default(), casadi::Matrix< Scalar >::print_dense(), casadi::MXFunction::print_res(), casadi::Matrix< Scalar >::print_sparse(), casadi::Matrix< Scalar >::print_vector(), casadi::CodeGenerator::project(), casadi::QpoasesInterface::qpoases_init(), casadi::Reshape::Reshape(), row(), set(), casadi::MadmpecInterface::set_ccopt_prob(), casadi::FatropInterface::set_fatrop_prob(), casadi::IpoptInterface::set_ipopt_prob(), casadi::MadnlpInterface::set_madnlp_prob(), casadi::Blocksqp::set_work(), casadi::BonminInterface::set_work(), casadi::IpoptInterface::set_work(), casadi::SLEQPInterface::set_work(), casadi::SnoptInterface::set_work(), casadi::KinsolInterface::set_work(), casadi::SundialsInterface::set_work(), casadi::WorhpInterface::set_work(), casadi::FastNewton::set_work(), casadi::Newton::set_work(), casadi::Qrsqp::set_work(), casadi::Scpgen::set_work(), casadi::Convexify::setup(), casadi::CplexInterface::solve(), casadi::PiqpInterface::solve(), casadi::ProxqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SuperscsInterface::solve(), casadi::Ipqp::solve(), casadi::KnitroInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_elastic_mode(), casadi::MXNode::sp_forward(), casadi::HorzRepsum::sp_forward(), casadi::Split::sp_forward(), casadi::FunctionInternal::sp_forward_block(), casadi::MXNode::sp_reverse(), casadi::HorzRepmat::sp_reverse(), casadi::HorzRepsum::sp_reverse(), casadi::Split::sp_reverse(), casadi::FunctionInternal::sp_reverse(), casadi::MX::sparsity_cast(), sparsity_cast(), casadi::SparsityCast::SparsityCast(), to_file(), vertcat(), and casadi::XpressInterface::XpressInterface().

nnz_diag()

casadi_int casadi::Sparsity::nnz_diag

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_bw

Definition at line 360 of file sparsity.cpp.

                                      {
    return (*this)->nnz_diag();
  }

nnz_lower()

casadi_int casadi::Sparsity::nnz_lower

(

bool

strictly = false

)

const

i.e. the number of elements (i, j) with j<=i

Extra doc: https://github.com/casadi/casadi/wiki/L_bv

Definition at line 352 of file sparsity.cpp.

                                                    {
    return (*this)->nnz_lower(strictly);
  }

Referenced by casadi::WorhpInterface::set_work().

nnz_upper()

casadi_int casadi::Sparsity::nnz_upper

(

bool

strictly = false

)

const

i.e. the number of elements (i, j) with j>=i

Extra doc: https://github.com/casadi/casadi/wiki/L_bu

Definition at line 356 of file sparsity.cpp.

                                                    {
    return (*this)->nnz_upper(strictly);
  }

Referenced by casadi::OsqpInterface::codegen_init_mem(), casadi::OoqpInterface::init(), casadi::OsqpInterface::init(), casadi::MumpsInterface::init_mem(), and casadi::OsqpInterface::init_mem().

nonzeros()

Sparsity casadi::Sparsity::nonzeros ( casadi_int  nrow, casadi_int  ncol, const std::vector< casadi_int > &  nz, bool  ind1 = SWIG_IND1  )

static

Inverse of find()

Extra doc: https://github.com/casadi/casadi/wiki/L_23g

Definition at line 1301 of file sparsity.cpp.

                                                  {
    casadi_assert(nrow>0, "nrow must be >0.");
    std::vector<casadi_int> row(nz.size());
    std::vector<casadi_int> col(nz.size());
    for (casadi_int i=0;i<nz.size();++i) {
      casadi_int k = nz[i];
      k-= ind1;
      row[i] = k % nrow;
      col[i] = k / nrow;
    }
    return triplet(nrow, ncol, row, col);
  }

References row(), and triplet().

norm_0_mul()

casadi_int casadi::Sparsity::norm_0_mul ( const Sparsity &  x, const Sparsity &  A  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1738 of file sparsity.cpp.

                                                                      {
    // Implementation borrowed from Scipy's sparsetools/csr.h
    casadi_assert(A.size1()==x.size2(), "Dimension error. Got " + x.dim()
                          + " times " + A.dim() + ".");
 
    casadi_int n_row = A.size2();
    casadi_int n_col = x.size1();
 
    // Allocate work vectors
    std::vector<bool> Bwork(n_col);
    std::vector<casadi_int> Iwork(n_row+1+n_col);
 
    const casadi_int* Aj = A.row();
    const casadi_int* Ap = A.colind();
    const casadi_int* Bj = x.row();
    const casadi_int* Bp = x.colind();
    casadi_int *Cp = get_ptr(Iwork);
    casadi_int *mask = Cp+n_row+1;
 
    // Pass 1
    // method that uses O(n) temp storage
    std::fill(mask, mask+n_col, -1);
 
    Cp[0] = 0;
    casadi_int nnz = 0;
    for (casadi_int i = 0; i < n_row; i++) {
      casadi_int row_nnz = 0;
      for (casadi_int jj = Ap[i]; jj < Ap[i+1]; jj++) {
        casadi_int j = Aj[jj];
        for (casadi_int kk = Bp[j]; kk < Bp[j+1]; kk++) {
          casadi_int k = Bj[kk];
          if (mask[k] != i) {
            mask[k] = i;
            row_nnz++;
          }
        }
      }
      casadi_int next_nnz = nnz + row_nnz;
      nnz = next_nnz;
      Cp[i+1] = nnz;
    }
 
    // Pass 2
    casadi_int *next = get_ptr(Iwork) + n_row+1;
    std::fill(next, next+n_col, -1);
    std::vector<bool> & sums = Bwork;
    std::fill(sums.begin(), sums.end(), false);
    nnz = 0;
    Cp[0] = 0;
    for (casadi_int i = 0; i < n_row; i++) {
      casadi_int head   = -2;
      casadi_int length =  0;
      casadi_int jj_start = Ap[i];
      casadi_int jj_end   = Ap[i+1];
      for (casadi_int jj = jj_start; jj < jj_end; jj++) {
        casadi_int j = Aj[jj];
        casadi_int kk_start = Bp[j];
        casadi_int kk_end   = Bp[j+1];
        for (casadi_int kk = kk_start; kk < kk_end; kk++) {
          casadi_int k = Bj[kk];
          sums[k] = true;
          if (next[k] == -1) {
            next[k] = head;
            head  = k;
            length++;
          }
        }
      }
      for (casadi_int jj = 0; jj < length; jj++) {
        if (sums[head]) {
          nnz++;
        }
        casadi_int temp = head;
        head = next[head];
        next[temp] = -1; //clear arrays
        sums[temp] =  false;
      }
      Cp[i+1] = nnz;
    }
    return nnz;
  }

References colind(), dim(), casadi::get_ptr(), nnz(), row(), size1(), and size2().

Referenced by casadi::GenericMatrix< MatType >::norm_0_mul().

numel()

casadi_int casadi::Sparsity::numel

(

)

const

Beware of overflow

See also

nnz()

Extra doc: https://github.com/casadi/casadi/wiki/L_bq

Definition at line 132 of file sparsity.cpp.

                                   {
    return (*this)->numel();
  }

Referenced by casadi::FunctionInternal::get_sparsity_out(), casadi::Nlpsol::init(), casadi::Matrix< Scalar >::print_default(), and casadi::reduce_index_gen().

operator const casadi_int *()

casadi::Sparsity::operator const casadi_int *

(

)

const

In the C runtime, sparsity patterns are represented as a "const casadi_int*". This enables using the C runtime functions using a natural syntax.

Extra doc: https://github.com/casadi/casadi/wiki/L_bn

Definition at line 1734 of file sparsity.cpp.

                                             {
    return &(*this)->sp().front();
  }

operator const std::vector< casadi_int > &()

casadi::Sparsity::operator const std::vector< casadi_int > &

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_bo

Definition at line 1330 of file sparsity.cpp.

                                                        {
    return (*this)->sp();
  }

operator SparsityStruct()

casadi::Sparsity::operator SparsityStruct

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_bp

Definition at line 1334 of file sparsity.cpp.

                                          {
    const casadi_int* sp = *this;
    casadi_int nrow = sp[0], ncol = sp[1];
    const casadi_int* colind = sp+2, *row = sp+2+ncol+1;
    return SparsityStruct{nrow, ncol, colind, row};
  }

operator!=()

bool casadi::Sparsity::operator!= ( const Sparsity &  y ) const

inline

Definition at line 302 of file sparsity.hpp.

{return !is_equal(y);}

References casadi::is_equal().

operator*() [1/2]

const SparsityInternal & casadi::Sparsity::operator*

(

)

const

Definition at line 116 of file sparsity.cpp.

                                                    {
    return *static_cast<const SparsityInternal*>(get());
  }

References get().

operator*() [2/2]

Sparsity casadi::Sparsity::operator*

(

const Sparsity &

b

)

const

Returns the new sparsity pattern as well as a mapping with the same length as the number of non-zero elements The value is 1 if the non-zero comes from the first (i.e. this) object, 2 if it is from the second and 3 (i.e. 1 | 2) if from both

Extra doc: https://github.com/casadi/casadi/wiki/L_cn

Definition at line 462 of file sparsity.cpp.

                                                      {
    std::vector< unsigned char > mapping;
    return intersect(b, mapping);
  }

References intersect().

operator+()

Sparsity casadi::Sparsity::operator+

(

const Sparsity &

b

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cm

Definition at line 458 of file sparsity.cpp.

                                                      {
    return unite(b);
  }

References unite().

operator->()

const SparsityInternal * casadi::Sparsity::operator->

(

)

const

Definition at line 112 of file sparsity.cpp.

                                                     {
    return static_cast<const SparsityInternal*>(SharedObject::operator->());
  }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::operator->().

operator==()

bool casadi::Sparsity::operator== ( const Sparsity &  y ) const

inline

Definition at line 298 of file sparsity.hpp.

{ return is_equal(y);}

References casadi::is_equal().

own()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::own ( Internal *  node )

inherited

Assign the node to a node class pointer (or null)

Definition at line 89 of file generic_shared_impl.hpp.

                                                           {
    count_down();
    node = node_;
    count_up();
  }

pattern_inverse()

Sparsity casadi::Sparsity::pattern_inverse

(

)

const

Definition at line 467 of file sparsity.cpp.

                                           {
    return (*this)->pattern_inverse();
  }

References casadi::SparsityInternal::pattern_inverse().

Referenced by casadi::HpipmInterface::init(), and casadi::HpmpcInterface::init().

permutation()

Sparsity casadi::Sparsity::permutation ( const std::vector< casadi_int > &  p, bool  invert = false  )

static

Right multiplication of P with a vector leads to the same results as indexing that vector with p

P @ v = v[p]

The inverse of a permutation matrix is equal to its transpose (property of orthonormality)

Extra doc: https://github.com/casadi/casadi/wiki/L_244

Definition at line 1380 of file sparsity.cpp.

                                                                            {
    casadi_assert(casadi::is_permutation(p),
      "Sparsity::permutation supplied list is not a permutation.");
    std::vector<casadi_int> colind = range(p.size()+1);
    if (invert) {
      return Sparsity(p.size(), p.size(), colind, p);
    } else {
      return Sparsity(p.size(), p.size(), colind, invert_permutation(p));
    }
  }

References colind(), casadi::invert_permutation(), casadi::is_permutation(), casadi::range(), and Sparsity().

permutation_vector()

const std::vector< casadi_int > casadi::Sparsity::permutation_vector

(

bool

invert = false

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_245

Definition at line 1391 of file sparsity.cpp.

                                                                            {
    casadi_assert(is_permutation(), "Sparsity::permutation called on non-permutation matrix.");
    if (invert) {
      return get_row();
    } else {
      return invert_permutation(get_row());
    }
  }

References get_row(), casadi::invert_permutation(), and is_permutation().

Referenced by casadi::MXNode::get_mac().

pmult()

Sparsity casadi::Sparsity::pmult	(	const std::vector< casadi_int > &	p,
		bool	permute_rows = true,
		bool	permute_columns = true,
		bool	invert_permutation = false
	)		const

Multiply the sparsity with a permutation matrix from the left and/or from the right P * A * trans(P), A * trans(P) or A * trans(P) with P defined by an index vector containing the row for each col. As an alternative, P can be transposed (inverted).

Extra doc: https://github.com/casadi/casadi/wiki/L_df

Definition at line 780 of file sparsity.cpp.

                                                                                 {
    return (*this)->pmult(p, permute_rows, permute_columns, invert_permutation);
  }

References casadi::invert_permutation(), and casadi::SparsityInternal::pmult().

Referenced by casadi::SparsityInternal::star_coloring(), and casadi::SparsityInternal::star_coloring2().

postfix_dim()

std::string casadi::Sparsity::postfix_dim

(

)

const

Rules:

1. Dense and scalar: ""
2. 0-by-0: "[]"
3. Dense column vector: "[5]"
4. Dense matrix: "[5x10]"

5. Otherwise: "[5x10,3nz]"

   Extra doc: https://github.com/casadi/casadi/wiki/L_dg

Definition at line 592 of file sparsity.cpp.

                                        {
    if (is_dense()) {
      if (is_scalar()) {
        return "";
      } else if (is_empty(true)) {
        return "[]";
      } else if (is_column()) {
        return "[" + str(size1()) + "]";
      } else {
        return "[" + dim(false) + "]";
      }
    } else {
      return "[" + dim(true) + "]";
    }
  }

References dim(), is_column(), is_dense(), is_empty(), is_scalar(), size1(), and casadi::str().

print_ptr()

void casadi::SharedObject::print_ptr ( std::ostream &  stream = casadi::uout() ) const

inherited

Print the pointer to the internal class

Definition at line 43 of file shared_object.cpp.

                                                       {
    stream << get();
  }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().

qr_sparse()

void casadi::Sparsity::qr_sparse	(	Sparsity &	V,
		Sparsity &	R,
		std::vector< casadi_int > &	prinv,
		std::vector< casadi_int > &	pc,
		bool	amd = true
	)		const

Returns the sparsity pattern of V (compact representation of Q) and R as well as vectors needed for the numerical factorization and solution. The implementation is a modified version of CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL

Extra doc: https://github.com/casadi/casadi/wiki/L_d4

Definition at line 654 of file sparsity.cpp.

                                                       {
    // Dimensions
    casadi_int size1=this->size1(), size2=this->size2();
 
    // Recursive call if AMD
    if (amd) {
      // Get AMD reordering
      pc = mtimes(T(), *this).amd();
      // Permute sparsity pattern
      std::vector<casadi_int> tmp;
      Sparsity Aperm = sub(range(size1), pc, tmp);
      // Call recursively
      Aperm.qr_sparse(V, R, prinv, tmp, false);
      return;
    }
 
    // No column permutation
    pc = range(size2);
 
    // Allocate memory
    std::vector<casadi_int> leftmost(size1);
    std::vector<casadi_int> parent(size2);
    prinv.resize(size1 + size2);
    std::vector<casadi_int> iw(size1 + 7*size2 + 1);
 
    // Initialize QP solve
    casadi_int nrow_ext, v_nnz, r_nnz;
    SparsityInternal::qr_init(*this, T(),
                              get_ptr(leftmost), get_ptr(parent), get_ptr(prinv),
                              &nrow_ext, &v_nnz, &r_nnz, get_ptr(iw));
 
    // Calculate sparsities
    std::vector<casadi_int> sp_v(2 + size2 + 1 + v_nnz);
    std::vector<casadi_int> sp_r(2 + size2 + 1 + r_nnz);
    SparsityInternal::qr_sparsities(*this, nrow_ext, get_ptr(sp_v), get_ptr(sp_r),
                                    get_ptr(leftmost), get_ptr(parent), get_ptr(prinv),
                                    get_ptr(iw));
    prinv.resize(nrow_ext);
    V = compressed(sp_v, true);
    R = compressed(sp_r, true);
  }

References amd(), compressed(), casadi::get_ptr(), mtimes(), casadi::SparsityInternal::qr_init(), qr_sparse(), casadi::SparsityInternal::qr_sparsities(), casadi::range(), size1(), size2(), sub(), and T().

Referenced by casadi::FastNewton::init(), casadi::LinsolQr::init(), casadi::Qrqp::init(), and qr_sparse().

removeDuplicates()

void casadi::Sparsity::removeDuplicates

(

std::vector< casadi_int > &

mapping

)

The same indices will be removed from the mapping vector, which must have the same length as the number of nonzeros

Extra doc: https://github.com/casadi/casadi/wiki/L_d1

Definition at line 733 of file sparsity.cpp.

                                                                {
    *this = (*this)->_removeDuplicates(mapping);
  }

repr_el()

std::string casadi::Sparsity::repr_el

(

casadi_int

k

)

const

Definition at line 608 of file sparsity.cpp.

                                                {
    return (*this)->repr_el(k);
  }

Referenced by casadi::OracleFunction::calc_function().

reshape() [1/2]

Sparsity casadi::Sparsity::reshape ( const Sparsity &  x, casadi_int  nrow, casadi_int  ncol  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 260 of file sparsity.cpp.

                                                                                {
    return x->_reshape(nrow, ncol);
  }

References casadi::SparsityInternal::_reshape().

Referenced by casadi::MX::reshape().

reshape() [2/2]

Sparsity casadi::Sparsity::reshape ( const Sparsity &  x, const Sparsity &  sp  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 250 of file sparsity.cpp.

                                                                  {
    casadi_assert_dev(x.is_reshape(sp));
    return sp;
  }

References is_reshape().

resize()

void casadi::Sparsity::resize	(	casadi_int	nrow,
		casadi_int	ncol
	)

Definition at line 188 of file sparsity.cpp.

                                                        {
    if (size1()!=nrow || size2() != ncol) {
      *this = (*this)->_resize(nrow, ncol);
    }
  }

References size1(), and size2().

Referenced by casadi::SparsityInternal::combineGen1(), casadi::SparsityInternal::dmperm(), and casadi::SparsityInternal::pmult().

row() [1/2]

const casadi_int * casadi::Sparsity::row

(

)

const

containing rows for all non-zero elements (see class description)

Extra doc: https://github.com/casadi/casadi/wiki/L_c7

Definition at line 164 of file sparsity.cpp.

                                        {
    return (*this)->row();
  }

Referenced by casadi::SparsityInternal::_mtimes(), casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_forward(), casadi::SetNonzeros< Add >::ad_reverse(), add(), add_nz(), band(), casadi::SparsityInternal::bfs(), casadi::KinsolInterface::bjac(), bor(), casadi::Blocksqp::calcHessianUpdateExact(), casadi::Blocksqp::calcLagrangeGradient(), casadi::casadi_func_cons_jac(), casadi::SparsityInternal::combineGen(), compressed(), casadi::construct_nlpsol(), casadi::IndexReduction::dae_struct_detect(), dense(), casadi::detect_simple_bounds_gen(), diag(), diagcat(), casadi::KinsolInterface::djac(), casadi::BonminUserClass::eval_h(), casadi::IpoptUserClass::eval_h(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::AlpaqaProblem::eval_jac_g(), casadi::BonminUserClass::eval_jac_g(), casadi::IpoptUserClass::eval_jac_g(), casadi::GetNonzeros::eval_mx(), casadi::SetNonzeros< Add >::eval_mx(), casadi::FmuFunction::eval_task(), casadi::FmuFunction::finalize_hessian(), from_file(), get_ccs(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FunctionInternal::get_sparsity_out(), get_triplet(), horzsplit(), casadi::SqicInterface::init(), casadi::FmuFunction::init(), casadi::AmplInterface::init(), casadi::Blocksqp::init(), casadi::FatropConicInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::SuperscsInterface::init(), casadi::ClarabelInterface::init_dependent(), casadi::HighsInterface::init_dependent(), casadi::MosekInterface::init_dependent(), casadi::XpressInterface::init_dependent(), casadi::CplexInterface::init_mem(), is_compactible(), is_equal(), casadi::SparsityInternal::is_equal(), casadi::SparsityInternal::is_stacked(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), kron(), kron_contract(), lower(), casadi::mul_bvec_fwd(), mul_sparsityR(), casadi::SparsityInternal::multiply(), nonzeros(), norm_0_mul(), casadi::FunctionInternal::print_canonical(), casadi::Matrix< Scalar >::print_dense(), casadi::Matrix< Scalar >::print_sparse(), casadi::Matrix< Scalar >::print_vector(), casadi::CvodesInterface::psetupF(), casadi::IdasInterface::psetupF(), casadi::GenericMatrix< MatType >::row(), row(), rowcol(), casadi::Conic::sdp_to_socp_init(), set(), casadi::WorhpInterface::set_work(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::OoqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SuperscsInterface::solve(), casadi::WorhpInterface::solve(), casadi::Blocksqp::solveQP(), casadi::KronContract::sp_forward(), casadi::Rank1::sp_forward(), casadi::Solve< Tr >::sp_forward(), casadi::FunctionInternal::sp_forward_block(), casadi::KronContract::sp_reverse(), casadi::Rank1::sp_reverse(), casadi::Solve< Tr >::sp_reverse(), casadi::FunctionInternal::sp_reverse(), Sparsity(), casadi::SparsityInternal::star_coloring_new(), to_file(), triplet(), casadi::SparsityInternal::uni_coloring(), unit(), casadi::DaeBuilderInternal::update_dependencies(), and upper().

row() [2/2]

casadi_int casadi::Sparsity::row

(

casadi_int

el

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cc

Definition at line 172 of file sparsity.cpp.

                                              {
    if (el<0 || el>=nnz()) {
      throw std::out_of_range("Sparsity::row: Index " + str(el)
        + " out of range [0," + str(nnz()) + ")");
    }
    return row()[el];
  }

References nnz(), row(), and casadi::str().

rowcol()

Sparsity casadi::Sparsity::rowcol ( const std::vector< casadi_int > &  row, const std::vector< casadi_int > &  col, casadi_int  nrow, casadi_int  ncol  )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bl

Definition at line 1127 of file sparsity.cpp.

                                                              {
    std::vector<casadi_int> all_rows, all_cols;
    all_rows.reserve(row.size()*col.size());
    all_cols.reserve(row.size()*col.size());
    for (std::vector<casadi_int>::const_iterator c_it=col.begin(); c_it!=col.end(); ++c_it) {
      casadi_assert(*c_it>=0 && *c_it<ncol, "Sparsity::rowcol: Column index out of bounds");
      for (std::vector<casadi_int>::const_iterator r_it=row.begin(); r_it!=row.end(); ++r_it) {
        casadi_assert(*r_it>=0 && *r_it<nrow, "Sparsity::rowcol: Row index out of bounds");
        all_rows.push_back(*r_it);
        all_cols.push_back(*c_it);
      }
    }
    return Sparsity::triplet(nrow, ncol, all_rows, all_cols);
  }

References row(), and triplet().

rows()

casadi_int casadi::Sparsity::rows ( ) const

inline

Definition at line 334 of file sparsity.hpp.

{return size1();}

rowsSequential()

bool casadi::Sparsity::rowsSequential

(

bool

strictly = true

)

const

Parameters

[in]

strictly

if true, then do not allow multiple entries

Extra doc: https://github.com/casadi/casadi/wiki/L_d0

Definition at line 729 of file sparsity.cpp.

                                                   {
    return (*this)->rowsSequential(strictly);
  }

scalar()

static Sparsity casadi::Sparsity::scalar ( bool  dense_scalar = true )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_bd

Definition at line 153 of file sparsity.hpp.

    { return dense_scalar ? dense(1, 1) : Sparsity(1, 1); }

Referenced by casadi::Bilin::Bilin(), casadi::Call::Call(), casadi::Dot::Dot(), casadi::Find::Find(), casadi::FunctionInternal::get_sparsity_in(), casadi::Switch::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::Conic::get_sparsity_out(), casadi::MMax::MMax(), casadi::MMin::MMin(), casadi::Norm::Norm(), casadi::simpleIntegrator(), and casadi::Split::Split().

scc()

casadi_int casadi::Sparsity::scc	(	std::vector< casadi_int > &	index,
		std::vector< casadi_int > &	offset
	)		const

of a square matrix

See Direct Methods for Sparse Linear Systems by Davis (2006). Returns:

• Number of components
• Offset for each components (length: 1 + number of components)
• Indices for each components, component i has indices index[offset[i]], ..., index[offset[i+1]]

In the case that the matrix is symmetric, the result has a particular interpretation: Given a symmetric matrix A and n = A.scc(p, r)

=> A[p, p] will appear block-diagonal with n blocks and with the indices of the block boundaries to be found in r.

The implementation is a modified version of cs_scc in CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL

Extra doc: https://github.com/casadi/casadi/wiki/L_d6

Examples

matrix/scc.py.

Definition at line 705 of file sparsity.cpp.

                                                                                            {
    return (*this)->scc(index, offset);
  }

References casadi::SparsityInterface< Sparsity >::offset().

Referenced by casadi::Conic::sdp_to_socp_init(), and casadi::Convexify::setup().

serialize() [1/3]

std::string casadi::Sparsity::serialize

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_c2

Definition at line 2097 of file sparsity.cpp.

                                      {
    std::stringstream ss;
    serialize(ss);
    return ss.str();
  }

Referenced by serialize().

serialize() [2/3]

void casadi::Sparsity::serialize

(

SerializingStream &

s

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_c5

Definition at line 2079 of file sparsity.cpp.

                                                     {
    if (is_null()) {
      s.pack("SparsityInternal::compressed", std::vector<casadi_int>{});
    } else {
      s.pack("SparsityInternal::compressed", compress());
    }
  }

References compress(), casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), and casadi::SerializingStream::pack().

serialize() [3/3]

void casadi::Sparsity::serialize

(

std::ostream &

stream

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_c1

Definition at line 2069 of file sparsity.cpp.

                                                   {
    SerializingStream s(stream);
    serialize(s);
  }

References serialize().

set() [1/2]

template<typename DataType >

void casadi::Sparsity::set	(	DataType *	data,
		const DataType *	val_data,
		const Sparsity &	val_sp
	)		const

Definition at line 1270 of file sparsity.hpp.

                                                                                           {
    // Get dimensions of this
    const casadi_int sz = nnz();
    const casadi_int sz1 = size1();
    const casadi_int sz2 = size2();
 
    // Get dimensions of assigning matrix
    const casadi_int val_sz = val_sp.nnz();
    const casadi_int val_sz1 = val_sp.size1();
    const casadi_int val_sz2 = val_sp.size2();
    const casadi_int val_nel = val_sz1*val_sz2;
 
    // Check if sparsity matches
    if (val_sp==*this) {
      std::copy(val_data, val_data+sz, data);
    } else if (this->is_empty()) {
      // Quick return
      return;
    } else if (val_sp.is_empty()) {
      // Quick return
      return;
    } else if (val_nel==1) { // if scalar
      std::fill(data, data+sz, val_sz==0 ? DataType(0) : val_data[0]);
    } else if (sz2==val_sz2 && sz1==val_sz1) {
      // Matching dimensions
      // Sparsity
      const casadi_int* c = row();
      const casadi_int* rind = colind();
      const casadi_int* v_c = val_sp.row();
      const casadi_int* v_rind = val_sp.colind();
 
      // For all columns
      for (casadi_int i=0; i<sz2; ++i) {
 
        // Nonzero of the assigning matrix
        casadi_int v_el = v_rind[i];
 
        // First nonzero of the following column
        casadi_int v_el_end = v_rind[i+1];
 
        // Next row of the assigning matrix
        casadi_int v_j = v_el<v_el_end ? v_c[v_el] : sz1;
 
        // Assign all nonzeros
        for (casadi_int el=rind[i]; el!=rind[i+1]; ++el) {
 
          //  Get row
          casadi_int j=c[el];
 
          // Forward the assigning nonzero
          while (v_j<j) {
            v_el++;
            v_j = v_el<v_el_end ? v_c[v_el] : sz1;
          }
 
          // Assign nonzero
          if (v_j==j) {
            data[el] = val_data[v_el++];
            v_j = v_el<v_el_end ? v_c[v_el] : sz1;
          } else {
            data[el] = 0;
          }
        }
      }
    } else if (sz1==val_sz2 && sz2==val_sz1 && sz2 == 1) {
      // Assign transposed (this is column)
      const casadi_int* v_cind = val_sp.colind();
      const casadi_int* r = row();
      for (casadi_int el=0; el<sz; ++el) {
        casadi_int rr=r[el];
        data[el] = v_cind[rr]==v_cind[rr+1] ? 0 : val_data[v_cind[rr]];
      }
    } else if (sz1==val_sz2 && sz2==val_sz1 && sz1 == 1) {
      // Assign transposed (this is row)
      for (casadi_int el=0; el<sz; ++el) data[el] = 0;
      const casadi_int* cind = colind();
      const casadi_int* v_r = val_sp.row();
      for (casadi_int el=0; el<val_sz; ++el) {
        casadi_int rr=v_r[el];
        if (cind[rr]!=cind[rr+1]) {
          data[cind[rr]] = val_data[el];
        }
      }
    } else {
      // Make sure that dimension matches
      casadi_error("Sparsity::set<DataType>: shape mismatch. lhs is "
                   + dim() + ", while rhs is " + val_sp.dim() + ".");
    }
  }

References colind(), dim(), is_empty(), nnz(), row(), size1(), and size2().

set() [2/2]

template<typename T >

void casadi::Sparsity::set	(	T *	data,
		const T *	val_data,
		const Sparsity &	val_sp
	)		const

entries of another sparsity pattern

Extra doc: https://github.com/casadi/casadi/wiki/L_dl

Referenced by casadi::Project::sp_forward().

size() [1/2]

std::pair< casadi_int, casadi_int > casadi::Sparsity::size

(

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_bz

Definition at line 152 of file sparsity.cpp.

                                                       {
    return (*this)->size();
  }

Referenced by casadi::SparsityInternal::_mtimes(), casadi::GetNonzeros::ad_forward(), casadi::FunctionInternal::check_mat(), casadi::SparsityInternal::combineGen(), compressed(), casadi::GetNonzeros::eval_mx(), casadi::Matrix< Scalar >::get(), casadi::MX::get(), casadi::MXNode::get_binary(), casadi::Expm::get_forward(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::Expm::get_reverse(), casadi::Integrator::init(), kkt(), casadi::Integrator::map2oracle(), casadi::MX::MX(), casadi::MX::project(), casadi::Call::projectArg(), casadi::replace_mat(), casadi::Matrix< Scalar >::set(), casadi::MX::set(), casadi::simpleIntegrator(), and casadi::MXNode::to_matrix().

size() [2/2]

casadi_int casadi::Sparsity::size

(

casadi_int

axis

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_c0

Definition at line 156 of file sparsity.cpp.

                                                 {
    switch (axis) {
    case 1: return size1();
    case 2: return size2();
    }
    casadi_error("Axis must be 1 or 2.");
  }

References size1(), and size2().

size1()

casadi_int casadi::Sparsity::size1

(

)

const

Definition at line 124 of file sparsity.cpp.

                                   {
    return (*this)->size1();
  }

Referenced by casadi::SolveUnity< Tr >::A_sp(), casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_forward(), casadi::SetNonzeros< Add >::ad_reverse(), add(), add_nz(), append(), appendColumns(), casadi::Function::assert_sparsity_out(), bor(), casadi::FunctionInternal::check_mat(), casadi::FastNewton::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::SparsityInternal::combineGen(), compress(), casadi::Conic::Conic(), casadi::IndexReduction::dae_struct_detect(), density(), diagsplit(), enlargeColumns(), enlargeRows(), casadi::FunctionInternal::ensure_stacked(), etree(), casadi::DenseKronContract::eval_kernel(), casadi::DenseSparseKronContract::eval_kernel(), casadi::GetNonzeros::eval_mx(), casadi::SetNonzeros< Add >::eval_mx(), casadi::XFunction< DerivedType, MatType, NodeType >::export_code(), casadi::FmuFunction::finalize_hessian(), casadi::FunctionInternal::from_compact(), from_file(), casadi::DenseKronContract::generate(), casadi::DenseSparseKronContract::generate(), casadi::Expm::get_forward(), casadi::OnnxFunction::get_forward(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::OnnxFunction::get_jacobian(), casadi::FunctionInternal::get_partition(), casadi::Dple::get_reverse(), casadi::Expm::get_reverse(), casadi::OnnxFunction::get_reverse(), casadi::FunctionInternal::get_sparsity_out(), horzcat(), horzsplit(), info(), casadi::Dple::init(), casadi::FmuFunction::init(), casadi::Rootfinder::init(), casadi::Switch::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::SlicotExpm::init(), casadi::FastNewton::init(), casadi::LinsolLdl::init(), casadi::SymbolicQr::init_mem(), casadi::SparsityInternal::is_equal(), casadi::SparsityInternal::is_stacked(), casadi::FunctionInternal::jac_sparsity(), kkt(), kron(), kron_contract(), ldl(), casadi::Onnx::load(), mtimes(), casadi::mul_bvec_fwd(), mul_sparsityR(), casadi::SparsityInternal::multiply(), norm_0_mul(), casadi::Vertcat::off(), casadi::Diagcat::off(), casadi::OptiNode::parameter(), postfix_dim(), casadi::Matrix< Scalar >::print_default(), casadi::Matrix< Scalar >::print_dense(), casadi::Matrix< Scalar >::print_sparse(), casadi::Matrix< Scalar >::print_vector(), casadi::Call::projectArg(), casadi::IdasInterface::psetupF(), qr_sparse(), casadi::replace_mat(), resize(), casadi::Conic::sdp_to_socp_init(), set(), casadi::MadmpecInterface::set_ccopt_prob(), casadi::FatropInterface::set_fatrop_prob(), casadi::IpoptInterface::set_ipopt_prob(), casadi::MadnlpInterface::set_madnlp_prob(), casadi::FastNewton::set_work(), casadi::Convexify::setup(), casadi::simpleIntegrator(), size(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::PiqpInterface::solve(), casadi::ProxqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SuperscsInterface::solve(), casadi::KronContract::sp_forward(), casadi::Solve< Tr >::sp_forward(), casadi::Integrator::sp_jac_aug(), casadi::KronContract::sp_reverse(), casadi::Solve< Tr >::sp_reverse(), sum1(), to_file(), and casadi::OptiNode::variable().

size2()

casadi_int casadi::Sparsity::size2

(

)

const

Definition at line 128 of file sparsity.cpp.

                                   {
    return (*this)->size2();
  }

Referenced by casadi::SparsityInternal::_mtimes(), casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_reverse(), add(), add_nz(), append(), appendColumns(), casadi::Function::assert_sparsity_out(), casadi::KinsolInterface::bjac(), bor(), casadi::casadi_func_cons_jac(), casadi::FunctionInternal::check_mat(), casadi::FastNewton::codegen_body(), casadi::FunctionInternal::codegen_meta(), colind(), casadi::SparsityInternal::combineGen(), compress(), casadi::Conic::Conic(), casadi::IndexReduction::dae_struct_detect(), density(), diagsplit(), casadi::KinsolInterface::djac(), enlargeColumns(), enlargeRows(), casadi::FunctionInternal::ensure_stacked(), etree(), casadi::Transpose::eval_gen(), casadi::BonminUserClass::eval_h(), casadi::IpoptUserClass::eval_h(), casadi::BonminUserClass::eval_jac_g(), casadi::IpoptUserClass::eval_jac_g(), casadi::DenseKronContract::eval_kernel(), casadi::DenseSparseKronContract::eval_kernel(), casadi::GetNonzeros::eval_mx(), casadi::FmuFunction::eval_task(), casadi::XFunction< DerivedType, MatType, NodeType >::export_code(), casadi::FunctionInternal::from_compact(), from_file(), casadi::DenseKronContract::generate(), casadi::DenseSparseKronContract::generate(), casadi::OnnxFunction::get_forward(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::OnnxFunction::get_jacobian(), casadi::FunctionInternal::get_partition(), casadi::OnnxFunction::get_reverse(), casadi::FunctionInternal::get_sparsity_out(), horzsplit(), info(), casadi::Dple::init(), casadi::FmuFunction::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::IpoptInterface::init(), casadi::SuperscsInterface::init(), casadi::FastNewton::init(), casadi::Ipqp::init(), casadi::SymbolicQr::init(), casadi::ClarabelInterface::init_dependent(), casadi::HighsInterface::init_dependent(), casadi::MosekInterface::init_dependent(), casadi::XpressInterface::init_dependent(), casadi::Blocksqp::init_mem(), casadi::CbcInterface::init_mem(), casadi::ClpInterface::init_mem(), casadi::CplexInterface::init_mem(), casadi::QpoasesInterface::init_mem(), casadi::SparsityInternal::is_equal(), is_singular(), casadi::SparsityInternal::is_stacked(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), casadi::FunctionInternal::jac_sparsity(), kkt(), kron(), kron_contract(), casadi::kron_sp_gen(), casadi::Onnx::load(), mtimes(), casadi::mul_bvec_fwd(), mul_sparsityR(), casadi::SparsityInternal::multiply(), norm_0_mul(), casadi::Horzcat::off(), casadi::Diagcat::off(), casadi::OptiNode::parameter(), casadi::FunctionInternal::print_canonical(), casadi::Matrix< Scalar >::print_default(), casadi::Matrix< Scalar >::print_dense(), casadi::Matrix< Scalar >::print_sparse(), casadi::Call::projectArg(), casadi::CvodesInterface::psetupF(), qr_sparse(), casadi::replace_mat(), resize(), casadi::Conic::sdp_to_socp_init(), set(), casadi::FastNewton::set_work(), size(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::PiqpInterface::solve(), casadi::ProxqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::KronContract::sp_forward(), casadi::Rank1::sp_forward(), casadi::Transpose::sp_forward(), casadi::FunctionInternal::sp_forward_block(), casadi::Integrator::sp_jac_aug(), casadi::KronContract::sp_reverse(), casadi::Rank1::sp_reverse(), casadi::Transpose::sp_reverse(), casadi::FunctionInternal::sp_reverse(), casadi::SparsityInternal::star_coloring_new(), sum2(), to_file(), casadi::OptiNode::variable(), and vertcat().

sparsity_cast()

Sparsity casadi::Sparsity::sparsity_cast ( const Sparsity &  x, const Sparsity &  sp  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 255 of file sparsity.cpp.

                                                                        {
    casadi_assert_dev(x.nnz()==sp.nnz());
    return sp;
  }

References nnz().

sparsity_cast_mod()

Sparsity casadi::Sparsity::sparsity_cast_mod	(	const Sparsity &	X,
		const Sparsity &	Y
	)		const

Assumption: 'this' is a subset of X.

Example:

X = [ * . . .; . * . .; . . * .; . . . *] Y = [* *; . . ; * *] x = [ * . . .; . . . .; . . * .; . . . *] returns [* *; . . ; . *]

Extra doc: https://github.com/casadi/casadi/wiki/L_246

Definition at line 1934 of file sparsity.cpp.

                                                                                 {
    const Sparsity& x = *this;
    if (X==x) return Y;
    if (X==Y) return x;
    std::vector<unsigned char> mapping;
    X.unite(x, mapping);
 
 
    const casadi_int* Y_colind = Y.colind();
    const casadi_int* Y_row = Y.row();
    std::vector<casadi_int> y_colind(Y.size2()+1, 0);
    std::vector<casadi_int> y_row;
    y_row.reserve(Y.nnz());
    casadi_assert_dev(Y.nnz()==mapping.size());
 
    casadi_int i = 0;
    // Loop over columns of Y
    for (casadi_int cc=0; cc<Y.size2(); ++cc) {
      y_colind[cc+1] = y_colind[cc];
      // Loop over nonzeros of Y in column cc
      for (casadi_int kk=Y_colind[cc]; kk<Y_colind[cc+1]; ++kk) {
        // Get corresponding map entry
        casadi_int e = mapping[i++];
        if (e==3) {
          // Preserve element
          y_colind[cc+1]++;
          y_row.push_back(Y_row[kk]);
        } else {
          casadi_assert_dev(e==1);
        }
      }
    }
 
    Sparsity ret(Y.size1(), Y.size2(), y_colind, y_row, true);
    return ret;
  }

References casadi::X, and casadi::Y.

Referenced by casadi::SparsityCast::ad_forward(), casadi::SparsityCast::ad_reverse(), and casadi::SparsityCast::eval_mx().

sprank()

casadi_int casadi::Sparsity::sprank ( const Sparsity &  x )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1728 of file sparsity.cpp.

                                               {
    std::vector<casadi_int> rowperm, colperm, rowblock, colblock, coarse_rowblock, coarse_colblock;
    x.btf(rowperm, colperm, rowblock, colblock, coarse_rowblock, coarse_colblock);
    return coarse_colblock.at(3);
  }

References btf().

Referenced by is_singular(), and casadi::GenericMatrix< MatType >::sprank().

spsolve()

void casadi::Sparsity::spsolve	(	bvec_t *	X,
		bvec_t *	B,
		bool	tr
	)		const

Extra doc: https://github.com/casadi/casadi/wiki/L_d9

Definition at line 725 of file sparsity.cpp.

                                                            {
    (*this)->spsolve(X, B, tr);
  }

References casadi::X.

Referenced by casadi::Solve< Tr >::sp_forward(), casadi::Integrator::sp_forward(), casadi::Rootfinder::sp_forward(), casadi::Solve< Tr >::sp_reverse(), casadi::Integrator::sp_reverse(), and casadi::Rootfinder::sp_reverse().

spy()

void casadi::Sparsity::spy

(

std::ostream &

stream = casadi::uout()

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_dh

Definition at line 794 of file sparsity.cpp.

                                             {
    (*this)->spy(stream);
  }

spy_matlab()

void casadi::Sparsity::spy_matlab

(

const std::string &

mfile

)

const

the sparsity using the spy command

Extra doc: https://github.com/casadi/casadi/wiki/L_di

Definition at line 785 of file sparsity.cpp.

                                                        {
    (*this)->spy_matlab(mfile);
  }

star_coloring()

Sparsity casadi::Sparsity::star_coloring	(	casadi_int	ordering = 1,
		casadi_int	cutoff = std::numeric_limits<casadi_int>::max()
	)		const

A greedy distance-2 coloring algorithm Algorithm 4.1 in What Color Is Your Jacobian? Graph Coloring for Computing Derivatives A. H. GEBREMEDHIN, F. MANNE, A. POTHEN SIAM Rev., 47(4), 629–705 (2006)

Ordering options: None (0), largest first (1)

Extra doc: https://github.com/casadi/casadi/wiki/L_dc

Definition at line 768 of file sparsity.cpp.

                                                                               {
    return (*this)->star_coloring(ordering, cutoff);
  }

References casadi::SparsityInternal::star_coloring().

Referenced by casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FunctionInternal::get_partition(), and casadi::SparsityInternal::star_coloring().

star_coloring2()

Sparsity casadi::Sparsity::star_coloring2	(	casadi_int	ordering = 1,
		casadi_int	cutoff = std::numeric_limits<casadi_int>::max()
	)		const

A new greedy distance-2 coloring algorithm Algorithm 4.1 in NEW ACYCLIC AND STAR COLORING ALGORITHMS WITH APPLICATION TO COMPUTING HESSIANS A. H. GEBREMEDHIN, A. TARAFDAR, F. MANNE, A. POTHEN SIAM J. SCI. COMPUT. Vol. 29, No. 3, pp. 1042–1072 (2007)

Ordering options: None (0), largest first (1)

Extra doc: https://github.com/casadi/casadi/wiki/L_dd

Definition at line 772 of file sparsity.cpp.

                                                                                {
    return (*this)->star_coloring2(ordering, cutoff);
  }

References casadi::SparsityInternal::star_coloring2().

Referenced by casadi::SparsityInternal::star_coloring2().

star_coloring_new()

Sparsity casadi::Sparsity::star_coloring_new	(	std::vector< casadi_int > &	which_color,
		const Dict &	opts = Dict()
	)		const

A greedy distance-2 coloring algorithm Algorithm 4.1 in What Color Is Your Jacobian? Graph Coloring for Computing Derivatives A. H. GEBREMEDHIN, F. MANNE, A. POTHEN SIAM Rev., 47(4), 629–705 (2006) or, alternatively (new_algo = true), NEW ACYCLIC AND STAR COLORING ALGORITHMS WITH APPLICATION TO COMPUTING HESSIANS A. H. GEBREMEDHIN, A. TARAFDAR, F. MANNE, A. POTHEN SIAM J. SCI. COMPUT. Vol. 29, No. 3, pp. 1042–1072 (2007)

Extra doc: https://github.com/casadi/casadi/wiki/L_2jz

Definition at line 759 of file sparsity.cpp.

                              {
    try {
      return (*this)->star_coloring_new(which_color, opts);
    } catch (std::exception &e) {
      CASADI_THROW_ERROR("star_coloring_new", e.what());
    }
  }

References casadi::SparsityInternal::star_coloring_new().

Referenced by casadi::FmuFunction::init().

sub() [1/2]

Sparsity casadi::Sparsity::sub	(	const std::vector< casadi_int > &	rr,
		const Sparsity &	sp,
		std::vector< casadi_int > &	mapping,
		bool	ind1 = false
	)		const

Returns the sparsity of the corresponding elements, with a mapping such that submatrix[k] = originalmatrix[mapping[k]]

Extra doc: https://github.com/casadi/casadi/wiki/L_cj

Definition at line 329 of file sparsity.cpp.

                                                                          {
    return (*this)->sub(rr, *sp, mapping, ind1);
  }

References casadi::SparsityInternal::sub().

sub() [2/2]

Sparsity casadi::Sparsity::sub	(	const std::vector< casadi_int > &	rr,
		const std::vector< casadi_int > &	cc,
		std::vector< casadi_int > &	mapping,
		bool	ind1 = false
	)		const

Returns the sparsity of the submatrix, with a mapping such that submatrix[k] = originalmatrix[mapping[k]]

Extra doc: https://github.com/casadi/casadi/wiki/L_ci

Definition at line 334 of file sparsity.cpp.

                                                                          {
    return (*this)->sub(rr, cc, mapping, ind1);
  }

References casadi::SparsityInternal::sub().

Referenced by casadi::Matrix< Scalar >::get(), casadi::MX::get(), casadi::FmuInternal::hess_sparsity(), casadi::LinsolLdl::init(), casadi::FmuInternal::jac_sparsity(), ldl(), qr_sparse(), casadi::Convexify::setup(), casadi::SuperscsInterface::solve(), and casadi::FunctionInternal::to_compact().

sum1()

Sparsity casadi::Sparsity::sum1 ( const Sparsity &  x )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1724 of file sparsity.cpp.

                                           {
    return mtimes(Sparsity::dense(1, x.size1()), x);
  }

References dense(), mtimes(), and size1().

Referenced by casadi::SparsityInternal::is_compactible().

sum2()

Sparsity casadi::Sparsity::sum2 ( const Sparsity &  x )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1720 of file sparsity.cpp.

                                           {
    return mtimes(x, Sparsity::dense(x.size2(), 1));
 
  }

References dense(), mtimes(), and size2().

Referenced by casadi::SparsityInternal::is_compactible().

swap()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::swap ( GenericShared< SharedObject, SharedObjectInternal > &  other )

inherited

Definition at line 105 of file generic_shared_impl.hpp.

                                                                 {
    GenericShared<Shared, Internal> temp = *this;
    *this = other;
    other = temp;
  }

T()

Sparsity casadi::Sparsity::T

(

)

const

Definition at line 394 of file sparsity.cpp.

                             {
    return (*this)->T();
  }

References casadi::SparsityInternal::T().

Referenced by casadi::construct_nlpsol(), casadi::detect_simple_bounds_gen(), casadi::MX::get(), get_crs(), casadi::FmuFunction::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::MX::get_nz(), casadi::FunctionInternal::get_partition(), casadi::FmuFunction::get_sparsity_out(), casadi::FmuFunction::init(), casadi::AmplInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::OoqpInterface::init(), casadi::Qrqp::init(), casadi::Scpgen::init(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), casadi::FunctionInternal::jac_sparsity(), kkt(), qr_sparse(), casadi::Convexify::setup(), casadi::Transpose::Transpose(), uni_coloring(), and vertsplit().

test_cast()

bool casadi::Sparsity::test_cast ( const SharedObjectInternal *  ptr )

static

Definition at line 120 of file sparsity.cpp.

                                                          {
    return dynamic_cast<const SparsityInternal*>(ptr)!=nullptr;
  }

to_file()

void casadi::Sparsity::to_file	(	const std::string &	filename,
		const std::string &	format_hint = ""
	)		const

Export sparsity pattern to file

Supported formats:

• .mtx Matrix Market

Definition at line 1996 of file sparsity.cpp.

                                                                                      {
    std::string format = file_format(filename, format_hint, file_formats);
    auto out_ptr = Filesystem::ofstream_ptr(filename);
    std::ostream& out = *out_ptr;
    if (format=="mtx") {
      out << std::scientific << std::setprecision(std::numeric_limits<double>::digits10 + 1);
      out << "%%MatrixMarket matrix coordinate pattern general" << std::endl;
      out << size1() << " " << size2() << " " << nnz() << std::endl;
      std::vector<casadi_int> row = get_row();
      std::vector<casadi_int> col = get_col();
 
      for (casadi_int k=0;k<row.size();++k) {
        out << row[k]+1 << " " << col[k]+1 << std::endl;
      }
    } else {
      casadi_error("Unknown format '" + format + "'");
    }
  }

References file_format(), file_formats, casadi::filename(), get_col(), get_row(), nnz(), casadi::Filesystem::ofstream_ptr(), row(), size1(), and size2().

Referenced by casadi::FatropInterface::init().

transpose()

Sparsity casadi::Sparsity::transpose	(	std::vector< casadi_int > &	mapping,
		bool	invert_mapping = false
	)		const

Parameters

[out]

mapping

the non-zeros of the original matrix for each non-zero of the new matrix

Extra doc: https://github.com/casadi/casadi/wiki/L_ck

Definition at line 390 of file sparsity.cpp.

                                                                                        {
    return (*this)->transpose(mapping, invert_mapping);
  }

References casadi::SparsityInternal::transpose().

Referenced by casadi::XFunction< DerivedType, MatType, NodeType >::jac(), and casadi::Conic::sdp_to_socp_init().

tril()

Sparsity casadi::Sparsity::tril ( const Sparsity &  x, bool  includeDiagonal = true  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 995 of file sparsity.cpp.

                                                                 {
    return x->_tril(includeDiagonal);
  }

References casadi::SparsityInternal::_tril().

Referenced by casadi::Convexify::setup(), and casadi::GenericMatrix< MatType >::tril().

triplet() [1/2]

Sparsity casadi::Sparsity::triplet ( casadi_int  nrow, casadi_int  ncol, const std::vector< casadi_int > &  row, const std::vector< casadi_int > &  col  )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bm

Definition at line 1295 of file sparsity.cpp.

                                                               {
    std::vector<casadi_int> mapping;
    return Sparsity::triplet(nrow, ncol, row, col, mapping, false);
  }

References row(), and triplet().

triplet() [2/2]

Sparsity casadi::Sparsity::triplet ( casadi_int  nrow, casadi_int  ncol, const std::vector< casadi_int > &  row, const std::vector< casadi_int > &  col, std::vector< casadi_int > &  mapping, bool  invert_mapping  )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bm

Definition at line 1143 of file sparsity.cpp.

                                                  {
    // Assert dimensions
    casadi_assert_dev(nrow>=0);
    casadi_assert_dev(ncol>=0);
    casadi_assert(col.size()==row.size(), "inconsistent lengths");
 
    // Create the return sparsity pattern and access vectors
    std::vector<casadi_int> r_colind(ncol+1, 0);
    std::vector<casadi_int> r_row;
    r_row.reserve(row.size());
 
    // Consistency check and check if elements are already perfectly ordered with no duplicates
    casadi_int last_col=-1, last_row=-1;
    bool perfectly_ordered=true;
    for (casadi_int k=0; k<col.size(); ++k) {
      // Consistency check
      casadi_assert(col[k]>=0 && col[k]<ncol,
        "Column index (" + str(col[k]) + ") out of bounds [0," + str(ncol) + "[");
      casadi_assert(row[k]>=0 && row[k]<nrow,
        "Row index out of bounds (" + str(row[k]) + ") out of bounds [0," + str(nrow) + "[");
 
      // Check if ordering is already perfect
      perfectly_ordered = perfectly_ordered && (col[k]<last_col ||
                                                (col[k]==last_col && row[k]<=last_row));
      last_col = col[k];
      last_row = row[k];
    }
 
    // Quick return if perfectly ordered
    if (perfectly_ordered) {
      // Save rows
      r_row.resize(row.size());
      std::copy(row.begin(), row.end(), r_row.begin());
 
      // Find offset index
      casadi_int el=0;
      for (casadi_int i=0; i<ncol; ++i) {
        while (el<col.size() && col[el]==i) el++;
        r_colind[i+1] = el;
      }
 
      // Identity mapping
      mapping.resize(row.size());
      for (casadi_int k=0; k<row.size(); ++k) mapping[k] = k;
 
      // Quick return
      return Sparsity(nrow, ncol, r_colind, r_row);
    }
 
    // Reuse data
    std::vector<casadi_int>& mapping1 = invert_mapping ? r_row : mapping;
    std::vector<casadi_int>& mapping2 = invert_mapping ? mapping : r_row;
 
    // Make sure that enough memory is allocated to use as a work vector
    mapping1.reserve(std::max(nrow+1, static_cast<casadi_int>(col.size())));
 
    // Number of elements in each row
    std::vector<casadi_int>& rowcount = mapping1; // reuse memory
    rowcount.resize(nrow+1);
    std::fill(rowcount.begin(), rowcount.end(), 0);
    for (std::vector<casadi_int>::const_iterator it=row.begin(); it!=row.end(); ++it) {
      rowcount[*it+1]++;
    }
 
    // Cumsum to get index offset for each row
    for (casadi_int i=0; i<nrow; ++i) {
      rowcount[i+1] += rowcount[i];
    }
 
    // New row for each old row
    mapping2.resize(row.size());
    for (casadi_int k=0; k<row.size(); ++k) {
      mapping2[rowcount[row[k]]++] = k;
    }
 
    // Number of elements in each col
    // reuse memory, r_colind is already the right size
    std::vector<casadi_int>& colcount = r_colind;
                                           // and is filled with zeros
    for (std::vector<casadi_int>::const_iterator it=mapping2.begin(); it!=mapping2.end(); ++it) {
      colcount[col[*it]+1]++;
    }
 
    // Cumsum to get index offset for each col
    for (casadi_int i=0; i<ncol; ++i) {
      colcount[i+1] += colcount[i];
    }
 
    // New col for each old col
    mapping1.resize(col.size());
    for (std::vector<casadi_int>::const_iterator it=mapping2.begin(); it!=mapping2.end(); ++it) {
      mapping1[colcount[col[*it]]++] = *it;
    }
 
    // Current element in the return matrix
    casadi_int r_el = 0;
    r_row.resize(col.size());
 
    // Current nonzero
    std::vector<casadi_int>::const_iterator it=mapping1.begin();
 
    // Loop over columns
    r_colind[0] = 0;
    for (casadi_int i=0; i<ncol; ++i) {
 
      // Previous row (to detect duplicates)
      casadi_int j_prev = -1;
 
      // Loop over nonzero elements of the col
      while (it!=mapping1.end() && col[*it]==i) {
 
        // Get the element
        casadi_int el = *it;
        it++;
 
        // Get the row
        casadi_int j = row[el];
 
        // If not a duplicate, save to return matrix
        if (j!=j_prev)
          r_row[r_el++] = j;
 
        if (invert_mapping) {
          // Save to the inverse mapping
          mapping2[el] = r_el-1;
        } else {
          // If not a duplicate, save to the mapping vector
          if (j!=j_prev)
            mapping1[r_el-1] = el;
        }
 
        // Save row
        j_prev = j;
      }
 
      // Update col offset
      r_colind[i+1] = r_el;
    }
 
    // Resize the row vector
    r_row.resize(r_el);
 
    // Resize mapping matrix
    if (!invert_mapping) {
      mapping1.resize(r_el);
    }
 
    return Sparsity(nrow, ncol, r_colind, r_row);
  }

References row(), Sparsity(), and casadi::str().

Referenced by casadi::SparsityInternal::_mtimes(), casadi::SparsityInternal::_reshape(), casadi::BSpline::dual(), from_file(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::DaeBuilderInternal::hess_sparsity(), horzcat(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), casadi::DaeBuilderInternal::jac_sparsity(), nonzeros(), casadi::SparsityInternal::pmult(), casadi::QpoasesInterface::qpoases_init(), rowcol(), casadi::Matrix< Scalar >::set(), casadi::MX::set(), casadi::SparsityInternal::star_coloring(), casadi::SparsityInternal::sub(), casadi::SparsityInternal::transpose(), triplet(), and vertcat().

triu()

Sparsity casadi::Sparsity::triu ( const Sparsity &  x, bool  includeDiagonal = true  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 999 of file sparsity.cpp.

                                                                 {
    return x->_triu(includeDiagonal);
  }

References casadi::SparsityInternal::_triu().

Referenced by casadi::OsqpInterface::codegen_init_mem(), casadi::OsqpInterface::init_mem(), casadi::Convexify::setup(), and casadi::GenericMatrix< MatType >::triu().

type_name()

static std::string casadi::Sparsity::type_name ( )

inlinestatic

Definition at line 1199 of file sparsity.hpp.

{return "Sparsity";}

uni_coloring()

Sparsity casadi::Sparsity::uni_coloring	(	const Sparsity &	AT = Sparsity(),
		casadi_int	cutoff = std::numeric_limits<casadi_int>::max()
	)		const

(Algorithm 3.1 in A. H. GEBREMEDHIN, F. MANNE, A. POTHEN)

Extra doc: https://github.com/casadi/casadi/wiki/L_db

Examples

matrix/coloring.py.

Definition at line 751 of file sparsity.cpp.

                                                                             {
    if (AT.is_null()) {
      return (*this)->uni_coloring(T(), cutoff);
    } else {
      return (*this)->uni_coloring(AT, cutoff);
    }
  }

References casadi::GenericShared< Shared, Internal >::is_null(), T(), and casadi::SparsityInternal::uni_coloring().

Referenced by casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_partition(), and casadi::FmuFunction::init().

unit()

Sparsity casadi::Sparsity::unit ( casadi_int  n, casadi_int  el  )

static

position el *

Extra doc: https://github.com/casadi/casadi/wiki/L_bf

Definition at line 1120 of file sparsity.cpp.

                                                     {
    std::vector<casadi_int> row(1, el), colind(2);
    colind[0] = 0;
    colind[1] = 1;
    return Sparsity(n, 1, colind, row);
  }

References colind(), row(), and Sparsity().

Referenced by casadi::SuperscsInterface::init().

unite() [1/2]

Sparsity casadi::Sparsity::unite

(

const Sparsity &

y

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_cm

Definition at line 413 of file sparsity.cpp.

                                                  {
    return (*this)->combine(y, false, false);
  }

References casadi::SparsityInternal::combine().

unite() [2/2]

Sparsity casadi::Sparsity::unite	(	const Sparsity &	y,
		std::vector< unsigned char > &	mapping
	)		const

Extra doc: https://github.com/casadi/casadi/wiki/L_cm

Definition at line 409 of file sparsity.cpp.

                                                                                     {
    return (*this)->combine(y, false, false, mapping);
  }

References casadi::SparsityInternal::combine().

Referenced by casadi::SetNonzeros< Add >::ad_forward(), casadi::GetNonzeros::ad_reverse(), casadi::SetNonzeros< Add >::eval_mx(), casadi::Switch::get_sparsity_in(), casadi::Switch::get_sparsity_out(), operator+(), and casadi::MX::unite().

upper()

Sparsity casadi::Sparsity::upper ( casadi_int  n )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_bg

Definition at line 1044 of file sparsity.cpp.

                                       {
    casadi_assert(n>=0, "Sparsity::upper expects a positive integer as argument");
    casadi_int nrow=n, ncol=n;
    std::vector<casadi_int> colind, row;
    colind.reserve(ncol+1);
    row.reserve((n*(n+1))/2);
 
    // Loop over columns
    colind.push_back(0);
    for (casadi_int cc=0; cc<ncol; ++cc) {
      // Loop over rows for the upper triangular half
      for (casadi_int rr=0; rr<=cc; ++rr) {
        row.push_back(rr);
      }
      colind.push_back(row.size());
    }
 
    // Return the pattern
    return Sparsity(nrow, ncol, colind, row);
  }

References colind(), row(), and Sparsity().

Referenced by casadi::Convexify::setup().

vertcat()

Sparsity casadi::Sparsity::vertcat ( const std::vector< Sparsity > &  sp )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1551 of file sparsity.cpp.

                                                           {
    // Quick return if possible
    if (sp.empty()) return Sparsity(0, 1);
    if (sp.size()==1) return sp.front();
 
    // Count total nnz
    casadi_int nnz_total = 0;
    for (casadi_int i=0; i<sp.size(); ++i) nnz_total += sp[i].nnz();
 
    // Construct from vectors (triplet format)
    std::vector<casadi_int> ret_row, ret_col;
    ret_row.reserve(nnz_total);
    ret_col.reserve(nnz_total);
    casadi_int ret_nrow = 0;
    casadi_int ret_ncol = 0;
    for (casadi_int i=0; i<sp.size() && ret_ncol==0; ++i)
      ret_ncol = sp[i].size2();
 
    // Append all patterns
    for (std::vector<Sparsity>::const_iterator i=sp.begin(); i!=sp.end(); ++i) {
      // Get sparsity pattern
      casadi_int sp_nrow = i->size1();
      casadi_int sp_ncol = i->size2();
      const casadi_int* sp_colind = i->colind();
      const casadi_int* sp_row = i->row();
      casadi_assert(sp_ncol==ret_ncol || sp_ncol==0,
                            "Sparsity::vertcat: Mismatching number of columns");
 
      // Add entries to pattern
      for (casadi_int cc=0; cc<sp_ncol; ++cc) {
        for (casadi_int k=sp_colind[cc]; k<sp_colind[cc+1]; ++k) {
          ret_row.push_back(sp_row[k] + ret_nrow);
          ret_col.push_back(cc);
        }
      }
 
      // Update offset
      ret_nrow += sp_nrow;
    }
    return Sparsity::triplet(ret_nrow, ret_ncol, ret_row, ret_col);
  }

References nnz(), size2(), Sparsity(), and triplet().

Referenced by append(), and blockcat().

vertsplit()

std::vector< Sparsity > casadi::Sparsity::vertsplit ( const Sparsity &  x, const std::vector< casadi_int > &  offset  )

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1669 of file sparsity.cpp.

                                           {
    std::vector<Sparsity> ret = horzsplit(x.T(), offset);
    for (std::vector<Sparsity>::iterator it=ret.begin(); it!=ret.end(); ++it) {
      *it = it->T();
    }
    return ret;
  }

References horzsplit(), casadi::SparsityInterface< Sparsity >::offset(), and T().

weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericShared< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_aw

Definition at line 130 of file generic_shared_impl.hpp.

                                                                          {
    return (*this)->weak();
  }

Member Data Documentation

file_formats

std::set< std::string > casadi::Sparsity::file_formats = {"mtx"}

static

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)

A=enlarge(m, n, ii, jj) makes sure that

B[jj, ii] == A

Extra doc: https://github.com/casadi/casadi/wiki/L_cr

Definition at line 1242 of file sparsity.hpp.

Referenced by file_format(), from_file(), and to_file().

---

The documentation for this class was generated from the following files:

• sparsity.hpp
• sparsity.cpp