General sparsity class. More...
#include <sparsity.hpp>
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:
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
Every DM, SX and MX carries a pattern, obtained with sparsity(), and a symbolic or numeric matrix can be created from one, e.g. SX.sym("x", sp) or DM(sp, 1). Entries outside the pattern are structural zeros: they are never stored and never computed with. The row indices within a column are strictly increasing.
Patterns are immutable and cached: constructing a pattern that already exists returns a reference to the cached object, so equal patterns are cheap to compare. The in-place methods (resize, enlarge, erase, append, add_nz, ...) rebind the object to a new pattern rather than modify the shared one. Use is_equal or the == operator to compare patterns; object identity is not meaningful in the target languages.
A default-constructed Sparsity is a null object (is_null() is true): it carries no pattern and most methods raise an error on it. It is used as "no pattern" sentinel, e.g. as the result of a coloring that exceeds its cutoff. Empty patterns are allowed: a 0-by-n or n-by-0 pattern has no nonzeros, is dense, and is_empty() is true for it.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
>>> DM(sp, 1)
DM(
[[1, 00, 00, 1],
[00, 00, 1, 00],
[1, 00, 00, 00]])
>>> sp
Sparsity(3x4,4nz)
>>> sp.size1(), sp.size2(), sp.nnz(), sp.numel()
(3, 4, 4, 12)
>>> sp.colind(), sp.row()
([0, 2, 2, 3, 4], [0, 2, 1, 0])
>>> sp == Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
True
>>> SX.sym("x", sp)
SX(
[[x_0, 00, 00, x_3],
[00, 00, x_2, 00],
[x_1, 00, 00, 00]])
>>> Sparsity.dense(0, 3), Sparsity().is_null()
(Sparsity(0x3), True)
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
>> DM(sp, 1)
[[1, 00, 00, 1],
[00, 00, 1, 00],
[1, 00, 00, 00]]
>> sp
3x4,4nz
>> fprintf('%d %d %d %d\n', sp.size1(), sp.size2(), sp.nnz(), sp.numel())
3 4 4 12
>> sp.colind(), sp.row()
0 2 2 3 4
0 2 1 0
>> sp == Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
1
>> SX.sym('x', sp)
[[x_0, 00, 00, x_3],
[00, 00, x_2, 00],
[x_1, 00, 00, 00]]
>> Sparsity.dense(0, 3), Sparsity().is_null()
0x3
1
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
julia> ca.DM(sp, 1)
DM(
[[1, 00, 00, 1],
[00, 00, 1, 00],
[1, 00, 00, 00]])
julia> sp
Sparsity(3x4,4nz)
julia> ca.size1(sp), ca.size2(sp), ca.nnz(sp), ca.numel(sp)
(3, 4, 4, 12)
julia> ca.colind(sp), ca.row(sp)
([0, 2, 2, 3, 4], [0, 2, 1, 0])
julia> ca.is_equal(sp, ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]))
true
julia> ca.SX.sym("x", sp)
SX(
[[x_0, 00, 00, x_3],
[00, 00, x_2, 00],
[x_1, 00, 00, 00]])
julia> ca.Sparsity.dense(0, 3), ca.is_null(ca.Sparsity())
(0x3, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_b9
Definition at line 197 of file sparsity.hpp.
Public Types | |
| typedef SparsityInterface< Sparsity > | B |
| Base class. More... | |
| typedef std::unordered_multimap< std::size_t, WeakRef > | CachingMap |
| using | internal_base_type = SharedObjectInternal |
| using | base_type = SharedObject |
Public Member Functions | |
| Sparsity (casadi_int dummy=0) | |
| Default constructor: a null object that holds no pattern. More... | |
| Sparsity (casadi_int nrow, casadi_int ncol) | |
| Pattern of the given shape 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 compressed column storage vectors. More... | |
| Sparsity (const std::pair< casadi_int, casadi_int > &rc) | |
| Pattern with all structural zeros, shape given as a pair (nrow, ncol) 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 |
| Recover the permutation vector p from the pattern of a permutation matrix. More... | |
| Sparsity | get_diag (std::vector< casadi_int > &mapping) const |
| Pattern of the diagonal of a matrix, or of the diagonal matrix built from a vector. More... | |
| std::vector< casadi_int > | compress (bool canonical=true) const |
| Compact single-vector representation of the 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 whether two sparsity patterns differ (negation of is_equal) More... | |
| bool | is_stacked (const Sparsity &y, casadi_int n) const |
Check whether the pattern is n copies of y placed side by side. 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 |
| The pattern as a dictionary with entries nrow, ncol, colind and row. More... | |
| void | to_file (const std::string &filename, const std::string &format_hint="") const |
| Write the pattern to a file. More... | |
| void | serialize (std::ostream &stream) const |
| Serialize. More... | |
| std::string | serialize () const |
| Serialize the pattern to a string. 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 |
| Row index of every nonzero, in nonzero (column-major) order. More... | |
| std::vector< casadi_int > | get_colind () const |
| Column offsets of the compressed column storage. More... | |
| casadi_int | colind (casadi_int cc) const |
Index of the first nonzero of column cc. More... | |
| casadi_int | row (casadi_int el) const |
Row index of nonzero el. More... | |
| std::vector< casadi_int > | get_col () const |
| Column index of every nonzero, in nonzero (column-major) order. More... | |
| void | resize (casadi_int nrow, casadi_int ncol) |
| Change the shape in place, keeping the nonzeros that still fit. More... | |
| casadi_int | add_nz (casadi_int rr, casadi_int cc) |
| Nonzero index of entry (rr, cc), inserting the entry into the pattern if needed. More... | |
| casadi_int | get_nz (casadi_int rr, casadi_int cc) const |
| Nonzero index of entry (rr, cc), or -1 if it is a structural zero. More... | |
| bool | has_nz (casadi_int rr, casadi_int cc) const |
| Check whether entry (rr, cc) is a structural nonzero. More... | |
| std::vector< casadi_int > | get_nz (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc) const |
Nonzero indices of the block of entries with rows rr and columns cc. More... | |
| void | get_nz (std::vector< casadi_int > &indices) const |
| Map flat (column-major) element indices to nonzero indices. More... | |
| std::vector< casadi_int > | get_lower () const |
| Nonzero indices of the entries in the lower triangular part (row >= col) More... | |
| std::vector< casadi_int > | get_upper () const |
| Nonzero indices of the entries in the upper triangular part (row <= col) More... | |
| void | get_ccs (std::vector< casadi_int > &colind, std::vector< casadi_int > &row) const |
| The pattern in compressed column storage: the colind and row vectors. More... | |
| void | get_crs (std::vector< casadi_int > &rowind, std::vector< casadi_int > &col) const |
| The pattern in compressed row storage: the rowind and col vectors. More... | |
| void | get_triplet (std::vector< casadi_int > &row, std::vector< casadi_int > &col) const |
| The pattern in sparse triplet format: the row and column of every nonzero. More... | |
| Sparsity | sub (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, std::vector< casadi_int > &mapping, bool ind1=false) const |
Pattern of the submatrix with rows rr and columns cc. More... | |
| Sparsity | sub (const std::vector< casadi_int > &rr, const Sparsity &sp, std::vector< casadi_int > &mapping, bool ind1=false) const |
| Pattern of a set of elements, arranged according to a given pattern. More... | |
| Sparsity | T () const |
| Transposed pattern. More... | |
| Sparsity | transpose (std::vector< casadi_int > &mapping, bool invert_mapping=false) const |
| Transposed pattern together with the reordering of the nonzeros. More... | |
| bool | is_transpose (const Sparsity &y) const |
Check whether y is the transpose of this pattern. More... | |
| bool | is_reshape (const Sparsity &y) const |
Check whether y is a reshape of this pattern. 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 |
Check whether every nonzero of this pattern is also a nonzero of rhs. More... | |
| Sparsity | sparsity_cast_mod (const Sparsity &X, const Sparsity &Y) const |
| Propagate a subset of a pattern through a sparsity cast. More... | |
| Sparsity | pattern_inverse () const |
| Complement of the pattern: structural zeros become nonzeros and vice versa. 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 the pattern in place by inserting empty rows and columns. More... | |
| void | enlargeRows (casadi_int nrow, const std::vector< casadi_int > &rr, bool ind1=false) |
| Enlarge the pattern in place by inserting empty rows. More... | |
| void | enlargeColumns (casadi_int ncol, const std::vector< casadi_int > &cc, bool ind1=false) |
| Enlarge the pattern in place by inserting empty columns. More... | |
| Sparsity | makeDense (std::vector< casadi_int > &mapping) const |
| Dense pattern of the same shape, with the flat index of every nonzero. More... | |
| std::vector< casadi_int > | erase (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, bool ind1=false) |
Turn the entries with rows rr and columns cc into structural zeros, in place. More... | |
| std::vector< casadi_int > | erase (const std::vector< casadi_int > &rr, bool ind1=false) |
Turn the entries with flat (column-major) indices rr into structural zeros. More... | |
| void | append (const Sparsity &sp) |
| Append a pattern below this one, in place (vertical concatenation) More... | |
| void | appendColumns (const Sparsity &sp) |
| Append a pattern to the right of this one, in place (horizontal concatenation) More... | |
| bool | is_scalar (bool scalar_and_dense=false) const |
| Check whether the pattern is 1-by-1. More... | |
| bool | is_dense () const |
| Check whether every entry is a structural nonzero, i.e. nnz() == numel() More... | |
| bool | is_row () const |
| Check whether the pattern is a row vector, i.e. size1() == 1. More... | |
| bool | is_column () const |
| Check whether the pattern is a column vector, i.e. size2() == 1. More... | |
| bool | is_vector () const |
| Check whether the pattern is a row or a column vector. More... | |
| bool | is_diag () const |
| Check whether the pattern is square with exactly the full diagonal as nonzeros. More... | |
| bool | is_square () const |
| Check whether the number of rows equals the number of columns. More... | |
| bool | is_symmetric () const |
| Check whether the pattern equals its transpose. More... | |
| bool | is_triu (bool strictly=false) const |
| Check whether all nonzeros are on or above the diagonal (row <= col) More... | |
| bool | is_tril (bool strictly=false) const |
| Check whether all nonzeros are on or below the diagonal (row >= col) More... | |
| bool | is_singular () const |
| Check whether a square pattern is structurally singular. More... | |
| bool | is_permutation () const |
| Check whether the pattern is that of a permutation matrix. More... | |
| bool | is_selection (bool allow_empty=false) const |
| Check whether the pattern is that of a selection matrix. More... | |
| bool | is_orthonormal (bool allow_empty=false) const |
| Check whether every row and every column has at most one nonzero. More... | |
| bool | is_orthonormal_rows (bool allow_empty=false) const |
| Check whether the rows are orthonormal: one nonzero per row, at most one per column. More... | |
| bool | is_orthonormal_columns (bool allow_empty=false) const |
| Check whether the columns are orthonormal (see is_orthonormal_rows) More... | |
| bool | rowsSequential (bool strictly=true) const |
| Check whether the row indices are increasing within every column. More... | |
| void | removeDuplicates (std::vector< casadi_int > &mapping) |
| Remove duplicate entries, in place. More... | |
| std::vector< casadi_int > | etree (bool ata=false) const |
| Elimination tree of the pattern. More... | |
| Sparsity | ldl (std::vector< casadi_int > &p, bool amd=true) const |
| Symbolic LDL factorization of a symmetric pattern. 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 > &SWIG_INOUT1(xi), std::vector< casadi_int > &SWIG_INOUT2(pstack), const std::vector< casadi_int > &pinv, std::vector< bool > &SWIG_INOUT3(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 |
| Strongly connected components of the directed graph of a square 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 |
| Block triangular form (BTF) through the Dulmage-Mendelsohn decomposition. More... | |
| std::vector< casadi_int > | amd () const |
| Approximate minimum degree (AMD) ordering of a symmetric pattern. 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 |
| Flat (column-major) element index of every nonzero. 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 |
| Unidirectional (column) coloring for compressed Jacobian evaluation. More... | |
| Sparsity | star_coloring_new (std::vector< casadi_int > &which_color, const Dict &opts=Dict()) const |
| Star coloring of a symmetric pattern, with the color that recovers each nonzero. More... | |
| Sparsity | star_coloring (casadi_int ordering=1, casadi_int cutoff=std::numeric_limits< casadi_int >::max()) const |
| Star coloring of a symmetric pattern (greedy distance-2 coloring) More... | |
| Sparsity | star_coloring2 (casadi_int ordering=1, casadi_int cutoff=std::numeric_limits< casadi_int >::max()) const |
| Star coloring of a symmetric pattern with the newer algorithm. More... | |
| std::vector< casadi_int > | largest_first () const |
| Column indices ordered by decreasing number of nonzeros. More... | |
| Sparsity | pmult (const std::vector< casadi_int > &p, bool permute_rows=true, bool permute_columns=true, bool invert_permutation=false) const |
| Permute the rows and/or columns of the pattern. More... | |
| std::string | dim (bool with_nz=false) const |
| Dimensions as a string "nrow x ncol", optionally with the number of nonzeros. More... | |
| std::string | postfix_dim () const |
| Dimension string to append to a name, as used when printing symbolic primitives. More... | |
| std::string | repr_el (casadi_int k) const |
Describe the position of nonzero k as a string. More... | |
| void | spy (std::ostream &stream=casadi::uout()) const |
| Print a textual picture of the pattern. More... | |
| void | spy_matlab (const std::string &mfile) const |
| Write a MATLAB/Octave script that builds the pattern as a sparse matrix and calls spy. More... | |
| void | export_code (const std::string &lang, std::ostream &stream=casadi::uout(), const Dict &options=Dict()) const |
| Write code that reconstructs the pattern in another language. More... | |
| std::size_t | hash () const |
| Hash of the pattern (dimensions, colind and row) 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... | |
| 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... | |
| bool | is_equal (const Sparsity &y) const |
| Check whether two sparsity patterns are identical. More... | |
| bool | is_equal (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &colind, const std::vector< casadi_int > &row) const |
| Check whether two sparsity patterns are identical. More... | |
| bool | is_equal (casadi_int nrow, casadi_int ncol, const casadi_int *colind, const casadi_int *row) const |
| Check whether two sparsity patterns are identical. More... | |
| bool | operator== (const Sparsity &y) const |
| Check whether two sparsity patterns are identical. More... | |
Size and element counting | |
| casadi_int | size1 () const |
| Number of rows. More... | |
| casadi_int | rows () const |
| Number of rows, Octave-style alias of size1. More... | |
| casadi_int | size2 () const |
| Number of columns. More... | |
| casadi_int | columns () const |
| Number of columns, Octave-style alias of size2. More... | |
| casadi_int | numel () const |
| Total number of entries, structural zeros included, i.e. size1()*size2() More... | |
| double | density () const |
| Percentage of nonzeros: 100*nnz()/numel() More... | |
| bool | is_empty (bool both=false) const |
| Check whether the pattern has a zero dimension. More... | |
| casadi_int | nnz () const |
| Number of structural nonzeros. More... | |
| casadi_int | nnz_upper (bool strictly=false) const |
| Number of nonzeros in the upper triangular part, i.e. entries (i, j) with i <= j. More... | |
| casadi_int | nnz_lower (bool strictly=false) const |
| Number of nonzeros in the lower triangular part, i.e. entries (i, j) with i >= j. More... | |
| casadi_int | nnz_diag () const |
| Number of nonzeros on the main diagonal, i.e. entries (i, i) More... | |
| casadi_int | bw_upper () const |
| Upper half-bandwidth: the largest j - i over all nonzeros (i, j) with j > i. More... | |
| casadi_int | bw_lower () const |
| Lower half-bandwidth: the largest i - j over all nonzeros (i, j) with i > j. More... | |
| std::pair< casadi_int, casadi_int > | size () const |
| Shape as a pair (number of rows, number of columns) More... | |
| casadi_int | size (casadi_int axis) const |
| Size along one dimension. More... | |
| Sparsity | combine (const Sparsity &y, bool f0x_is_zero, bool function0_is_zero, std::vector< unsigned char > &mapping) const |
| Combine two patterns of the same shape, as the result of a binary operation. More... | |
| Sparsity | combine (const Sparsity &y, bool f0x_is_zero, bool function0_is_zero) const |
| Combine two patterns of the same shape, as the result of a binary operation. More... | |
| Sparsity | unite (const Sparsity &y, std::vector< unsigned char > &mapping) const |
| Union of two sparsity patterns of the same shape (also available as the + operator) More... | |
| Sparsity | unite (const Sparsity &y) const |
| Union of two sparsity patterns of the same shape (also available as the + operator) More... | |
| Sparsity | operator+ (const Sparsity &b) const |
| Union of two sparsity patterns of the same shape (also available as the + operator) More... | |
| Sparsity | intersect (const Sparsity &y, std::vector< unsigned char > &mapping) const |
| Intersection of two sparsity patterns of the same shape (also the * operator) More... | |
| Sparsity | intersect (const Sparsity &y) const |
| Intersection of two sparsity patterns of the same shape (also the * operator) More... | |
| Sparsity | operator* (const Sparsity &b) const |
| Intersection of two sparsity patterns of the same shape (also the * operator) More... | |
Static Public Member Functions | |
| static Sparsity | create (SparsityInternal *node) |
| Create from node. More... | |
| static Sparsity | upper (casadi_int n) |
| Create an 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 a 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) |
Create the pattern of a block: all entries (i, j) with i in row and j in col. More... | |
| static Sparsity | nonzeros (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &nz, bool ind1=SWIG_IND1) |
| Create a sparsity pattern from the flat (column-major) index of every nonzero. More... | |
| static Sparsity | permutation (const std::vector< casadi_int > &p, bool invert=false) |
| Construct the pattern of a permutation matrix P from a permutation vector p. More... | |
| static Sparsity | from_file (const std::string &filename, const std::string &format_hint="") |
| Read a pattern from a file written by to_file (Matrix Market pattern format) More... | |
| static Sparsity | deserialize (std::istream &stream) |
| Build a Sparsity from a serialized stream. More... | |
| static Sparsity | deserialize (const std::string &s) |
| Build a Sparsity from a string produced by serialize() 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 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) |
| Pattern of a KKT system [H + I1, J'; J, I2]. More... | |
| static std::string | file_format (const std::string &filename, const std::string &format_hint, const std::set< std::string > &file_formats) |
| static Sparsity | scalar (bool dense_scalar=true) |
| Create a 1-by-1 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 pattern of a unit vector: a column of length n with one nonzero. More... | |
| static Sparsity | diag (casadi_int nrow) |
| Create a diagonal sparsity pattern. More... | |
| static Sparsity | diag (casadi_int nrow, casadi_int ncol) |
| Create a diagonal sparsity pattern. More... | |
| static Sparsity | diag (const std::pair< casadi_int, casadi_int > &rc) |
| Create a 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 from the (row, col) index of every nonzero. 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 from the (row, col) index of every nonzero. More... | |
| static Sparsity | compressed (const std::vector< casadi_int > &v, bool order_rows=false) |
| Create from the compact single-vector representation of a pattern. More... | |
| static Sparsity | compressed (const casadi_int *v, bool order_rows=false) |
| Create from the compact single-vector representation of a pattern. More... | |
| static Sparsity | horzcat (const std::vector< Sparsity > &sp) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | vertcat (const std::vector< Sparsity > &sp) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | blockcat (const std::vector< std::vector< Sparsity > > &v) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | diagcat (const std::vector< Sparsity > &v) |
| Accessed by SparsityInterface. More... | |
| static std::vector< Sparsity > | horzsplit (const Sparsity &x, const std::vector< casadi_int > &offset) |
| Accessed by SparsityInterface. More... | |
| static std::vector< Sparsity > | vertsplit (const Sparsity &x, const std::vector< casadi_int > &offset) |
| Accessed by SparsityInterface. More... | |
| static std::vector< Sparsity > | diagsplit (const Sparsity &x, const std::vector< casadi_int > &offset1, const std::vector< casadi_int > &offset2) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | mtimes (const Sparsity &x, const Sparsity &y, const std::string &blas="reference") |
| Accessed by SparsityInterface. More... | |
| static Sparsity | mac (const Sparsity &x, const Sparsity &y, const Sparsity &z, const std::string &="reference") |
| Accessed by SparsityInterface. More... | |
| static Sparsity | reshape (const Sparsity &x, casadi_int nrow, casadi_int ncol) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | reshape (const Sparsity &x, const Sparsity &sp) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | sparsity_cast (const Sparsity &x, const Sparsity &sp) |
| Accessed by SparsityInterface. More... | |
| static casadi_int | sprank (const Sparsity &x) |
| Accessed by SparsityInterface. More... | |
| static casadi_int | norm_0_mul (const Sparsity &x, const Sparsity &A) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | kron (const Sparsity &a, const Sparsity &b) |
| Accessed by SparsityInterface. 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) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | tril (const Sparsity &x, bool includeDiagonal=true) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | sum2 (const Sparsity &x) |
| Accessed by SparsityInterface. More... | |
| static Sparsity | sum1 (const Sparsity &x) |
| Accessed by SparsityInterface. More... | |
Static Public Attributes | |
| static std::set< std::string > | file_formats = {"mtx"} |
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 SparsityInterface<Sparsity> casadi::Sparsity::B |
Definition at line 399 of file sparsity.hpp.
|
inherited |
Definition at line 103 of file shared_object.hpp.
| typedef std::unordered_multimap<std::size_t, WeakRef> casadi::Sparsity::CachingMap |
Definition at line 4620 of file sparsity.hpp.
|
inherited |
Definition at line 102 of file shared_object.hpp.
|
explicit |
is_null() is true for the result and most other methods raise an error on it. A null Sparsity is the "no pattern" sentinel used by e.g. uni_coloring (as default for AT) and returned by the colorings when the cutoff is exceeded.
| dummy | Must be 0 (any other value raises an error) |
>>> sp = Sparsity()
>>> sp.is_null(), sp
(True, Sparsity(NULL))
>>> try: sp.nnz()
... except Exception as e: print("error")
error
>> sp = Sparsity();
>> sp.is_null(), sp
1
NULL
>> try, sp.nnz(); catch e, disp('error'); end
error
julia> sp = ca.Sparsity();
julia> ca.is_null(sp), sp
(true, NULL)
julia> try
ca.nnz(sp)
catch e
println("error")
end
error
Extra doc: https://github.com/casadi/casadi/wiki/L_2nj
Definition at line 68 of file sparsity.cpp.
Referenced by band(), banded(), blockcat(), compressed(), dense(), deserialize(), diag(), diagcat(), enlargeColumns(), enlargeRows(), horzcat(), horzsplit(), kkt(), kron(), kron_contract(), ldl(), lower(), permutation(), triplet(), unit(), upper(), and vertcat().
| casadi::Sparsity::Sparsity | ( | casadi_int | nrow, |
| casadi_int | ncol | ||
| ) |
| nrow | Number of rows, nonnegative |
| ncol | Number of columns, nonnegative |
>>> sp = Sparsity(2, 3) >>> sp, sp.nnz(), sp.is_dense() (Sparsity(2x3,0nz), 0, False) >>> Sparsity(0, 0), Sparsity(0, 0).is_dense() (Sparsity(0x0), True) >>> DM(Sparsity(2, 2), 1) DM( [[00, 00], [00, 00]])
>> sp = Sparsity(2, 3); >> sp, sp.nnz(), sp.is_dense() 2x3,0nz 0 0 >> Sparsity(0, 0), Sparsity(0, 0).is_dense() 0x0 1 >> DM(Sparsity(2, 2), 1) [[00, 00], [00, 00]]
julia> sp = ca.Sparsity(2, 3) Sparsity(2x3,0nz) julia> ca.nnz(sp), ca.is_dense(sp) (0, false) julia> ca.Sparsity(0, 0), ca.is_dense(ca.Sparsity(0, 0)) (0x0, true) julia> ca.DM(ca.Sparsity(2, 2), 1) DM( [[00, 00], [00, 00]])
Extra doc: https://github.com/casadi/casadi/wiki/L_ba
Definition at line 78 of file sparsity.cpp.
References colind(), row(), and casadi::str().
| 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 |
||
| ) |
| nrow | Number of rows |
| ncol | Number of columns |
| colind | Column offsets, length ncol+1, colind[0] == 0, nondecreasing |
| row | Row index of each nonzero, length colind[ncol], each in [0, nrow), strictly increasing within a column |
| order_rows | If true, row indices that are not sorted within a column are sorted (duplicates merged) instead of raising an error |
An invalid colind or an out-of-range row index raises an error. A pattern with colind[ncol] == nrow*ncol is the dense pattern.
>>> sp = Sparsity(3, 2, [0, 2, 3], [0, 2, 1])
>>> DM(sp, 1)
DM(
[[1, 00],
[00, 1],
[1, 00]])
>>> Sparsity(2, 2, [0, 2, 4], [0, 1, 0, 1]).is_dense()
True
>>> try: Sparsity(3, 2, [0, 2, 3], [2, 0, 1])
... except Exception as e: print("not sorted")
not sorted
>>> Sparsity(3, 2, [0, 2, 3], [2, 0, 1], True).row()
[0, 2, 1]
>> sp = Sparsity(3, 2, [0, 2, 3], [0, 2, 1]);
>> DM(sp, 1)
[[1, 00],
[00, 1],
[1, 00]]
>> Sparsity(2, 2, [0, 2, 4], [0, 1, 0, 1]).is_dense()
1
>> try, Sparsity(3, 2, [0, 2, 3], [2, 0, 1]); catch e, disp('not sorted'); end
not sorted
>> Sparsity(3, 2, [0, 2, 3], [2, 0, 1], true).row()
0 2 1
julia> sp = ca.Sparsity(3, 2, [0, 2, 3], [0, 2, 1]);
julia> ca.DM(sp, 1)
DM(
[[1, 00],
[00, 1],
[1, 00]])
julia> ca.is_dense(ca.Sparsity(2, 2, [0, 2, 4], [0, 1, 0, 1]))
true
julia> try
ca.Sparsity(3, 2, [0, 2, 3], [2, 0, 1])
catch e
println("not sorted")
end
not sorted
julia> ca.row(ca.Sparsity(3, 2, [0, 2, 3], [2, 0, 1], true))
3-element Vector{Int64}:
0
2
1
Extra doc: https://github.com/casadi/casadi/wiki/L_2nk
Definition at line 92 of file sparsity.cpp.
References colind(), row(), and casadi::str().
|
explicit |
Extra doc: https://github.com/casadi/casadi/wiki/L_bb
Definition at line 85 of file sparsity.cpp.
References colind(), row(), and casadi::str().
| 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.
References colind(), dense(), row(), and casadi::str().
|
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.
| void casadi::Sparsity::add | ( | DataType * | data, |
| const DataType * | val_data, | ||
| const Sparsity & | val_sp | ||
| ) | const |
Definition at line 6187 of file sparsity.hpp.
References colind(), dim(), is_empty(), nnz(), row(), size1(), and size2().
| 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
| casadi_int casadi::Sparsity::add_nz | ( | casadi_int | rr, |
| casadi_int | cc | ||
| ) |
Returns the position of the entry among the nonzeros. If the entry is a structural zero, the object is rebound to a pattern that includes it (nonzero indices after it shift by one). Negative indices count from the end. An index out of bounds raises an error.
>>> sp = Sparsity(3, 3)
>>> sp.add_nz(1, 1), sp.add_nz(0, 0), sp.add_nz(1, 1), sp
(0, 0, 1, Sparsity(3x3,2nz))
>>> DM(sp, 1)
DM(
[[1, 00, 00],
[00, 1, 00],
[00, 00, 00]])
>>> try: sp.add_nz(3, 0)
... except Exception as e: print("out of bounds")
out of bounds
>> sp = Sparsity(3, 3);
>> [sp.add_nz(1, 1), sp.add_nz(0, 0), sp.add_nz(1, 1)], sp
0 0 1
3x3,2nz
>> DM(sp, 1)
[[1, 00, 00],
[00, 1, 00],
[00, 00, 00]]
>> try, sp.add_nz(3, 0); catch e, disp('out of bounds'); end
out of bounds
julia> sp = ca.Sparsity(3, 3);
julia> ca.add_nz(sp, 1, 1), ca.add_nz(sp, 0, 0), ca.add_nz(sp, 1, 1)
(0, 0, 1)
julia> ca.DM(sp, 1)
DM(
[[1, 00, 00],
[00, 1, 00],
[00, 00, 00]])
julia> try
ca.add_nz(sp, 3, 0)
catch e
println("out of bounds")
end
out of bounds
Extra doc: https://github.com/casadi/casadi/wiki/L_ce
Definition at line 196 of file sparsity.cpp.
References colind(), get_colind(), get_row(), is_dense(), nnz(), row(), size1(), and size2().
| std::vector< casadi_int > casadi::Sparsity::amd | ( | ) | const |
Fill-reducing ordering p to apply to a symmetric linear system before factorization: factorize A[p, p] instead of A. The pattern must be symmetric, otherwise an error is raised; for an unsymmetric A, order the pattern of A^T*A (as qr_sparse does). Used by ldl and qr_sparse when their amd argument is true.
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
>>> Sparsity.banded(4, 1).amd(), Sparsity.dense(3, 3).amd(), Sparsity(0, 0).amd()
([3, 2, 0, 1], [0, 1, 2], [])
>>> try: Sparsity.upper(3).amd()
... except Exception as e: print("not symmetric")
not symmetric
>> Sparsity.banded(4, 1).amd(), Sparsity.dense(3, 3).amd()
3 2 0 1
0 1 2
>> isempty(Sparsity(0, 0).amd())
1
>> try, Sparsity.upper(3).amd(); catch e, disp('not symmetric'); end
not symmetric
julia> ca.amd(ca.Sparsity.banded(4, 1)), ca.amd(ca.Sparsity.dense(3, 3))
([3, 2, 0, 1], [0, 1, 2])
julia> ca.amd(ca.Sparsity(0, 0))
Int64[]
julia> try
ca.amd(ca.Sparsity.upper(3))
catch e
println("not symmetric")
end
not symmetric
Extra doc: https://github.com/casadi/casadi/wiki/L_d8
Definition at line 719 of file sparsity.cpp.
Referenced by casadi::LinsolLdl::init(), ldl(), and qr_sparse().
| void casadi::Sparsity::append | ( | const Sparsity & | sp | ) |
The number of columns must match, otherwise an error is raised; a 0-by-0 pattern on either side is ignored. Equivalent to rebinding to vertcat(self, sp); only cheap when both are column vectors.
>>> sp = Sparsity.dense(2, 2); sp.append(Sparsity.diag(2)); print(DM(sp, 1))
[[1, 1],
[1, 1],
[1, 00],
[00, 1]]
>>> sp = Sparsity(0, 0); sp.append(Sparsity.diag(2)); print(sp)
2x2,2nz
>>> try: Sparsity.dense(2, 2).append(Sparsity.dense(2, 3))
... except Exception as e: print("column mismatch")
column mismatch
>> sp = Sparsity.dense(2, 2); sp.append(Sparsity.diag(2)); disp(DM(sp, 1))
[[1, 1],
[1, 1],
[1, 00],
[00, 1]]
>> sp = Sparsity(0, 0); sp.append(Sparsity.diag(2)); disp(sp)
2x2,2nz
>> try, sp.append(Sparsity.dense(2, 3)); catch e, disp('column mismatch'); end
column mismatch
julia> sp = ca.Sparsity.dense(2, 2); ca.append(sp, ca.Sparsity.diag(2)); ca.DM(sp, 1)
DM(
[[1, 1],
[1, 1],
[1, 00],
[00, 1]])
julia> sp = ca.Sparsity(0, 0); ca.append(sp, ca.Sparsity.diag(2)); print(sp)
2x2,2nz
julia> try
ca.append(ca.Sparsity.dense(2, 2), ca.Sparsity.dense(2, 3))
catch e
println("column mismatch")
end
column mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_2o6
Definition at line 473 of file sparsity.cpp.
References casadi::SparsityInternal::_appendVector(), dim(), is_column(), size1(), size2(), and vertcat().
| void casadi::Sparsity::appendColumns | ( | const Sparsity & | sp | ) |
The number of rows must match, otherwise an error is raised; a 0-by-0 pattern on either side is ignored. Equivalent to rebinding to horzcat(self, sp).
>>> sp = Sparsity.dense(2, 2); sp.appendColumns(Sparsity.diag(2)); print(DM(sp, 1))
[[1, 1, 1, 00],
[1, 1, 00, 1]]
>>> try: Sparsity.dense(2, 2).appendColumns(Sparsity.dense(3, 2))
... except Exception as e: print("row mismatch")
row mismatch
>> sp = Sparsity.dense(2, 2); sp.appendColumns(Sparsity.diag(2)); disp(DM(sp, 1))
[[1, 1, 1, 00],
[1, 1, 00, 1]]
>> try, sp.appendColumns(Sparsity.dense(3, 2)); catch e, disp('row mismatch'); end
row mismatch
julia> sp = ca.Sparsity.dense(2, 2); ca.appendColumns(sp, ca.Sparsity.diag(2)); ca.DM(sp, 1)
DM(
[[1, 1, 1, 00],
[1, 1, 00, 1]])
julia> try
ca.appendColumns(ca.Sparsity.dense(2, 2), ca.Sparsity.dense(3, 2))
catch e
println("row mismatch")
end
row mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_2o7
Definition at line 502 of file sparsity.cpp.
References casadi::SparsityInternal::_appendColumns(), dim(), size1(), and size2().
Referenced by casadi::Sqpmethod::init().
|
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.
|
static |
The nonzeros are the entries (i+p, i): band(n, 0) equals diag(n), band(n, 1) is the first subdiagonal and band(n, -1) the first superdiagonal.
| n | Size of the square pattern |
| p | Offset of the band from the diagonal, positive below the diagonal and negative above it; |p| must be smaller than n, otherwise an error is raised |
>>> DM(Sparsity.band(4, 1), 1) DM( [[00, 00, 00, 00], [1, 00, 00, 00], [00, 1, 00, 00], [00, 00, 1, 00]]) >>> DM(Sparsity.band(4, -2), 1) DM( [[00, 00, 1, 00], [00, 00, 00, 1], [00, 00, 00, 00], [00, 00, 00, 00]]) >>> Sparsity.band(4, 0) == Sparsity.diag(4) True
>> DM(Sparsity.band(4, 1), 1) [[00, 00, 00, 00], [1, 00, 00, 00], [00, 1, 00, 00], [00, 00, 1, 00]] >> DM(Sparsity.band(4, -2), 1) [[00, 00, 1, 00], [00, 00, 00, 1], [00, 00, 00, 00], [00, 00, 00, 00]] >> Sparsity.band(4, 0) == Sparsity.diag(4) 1
julia> ca.DM(ca.Sparsity.band(4, 1), 1) DM( [[00, 00, 00, 00], [1, 00, 00, 00], [00, 1, 00, 00], [00, 00, 1, 00]]) julia> ca.DM(ca.Sparsity.band(4, -2), 1) DM( [[00, 00, 1, 00], [00, 00, 00, 1], [00, 00, 00, 00], [00, 00, 00, 00]]) julia> ca.is_equal(ca.Sparsity.band(4, 0), ca.Sparsity.diag(4)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_bj
Definition at line 1099 of file sparsity.cpp.
References colind(), casadi::SparsityInterface< Sparsity >::offset(), row(), and Sparsity().
Referenced by banded(), and casadi::SlicotDple::init_mem().
|
static |
Union of band(n, k) for all k in [-p, p]: banded(n, 0) equals diag(n) and banded(n, 1) is tridiagonal.
| n | Size of the square pattern |
| p | Half-bandwidth; p >= n gives a dense pattern and a negative p an all-zero pattern |
>>> DM(Sparsity.banded(4, 1), 1) DM( [[1, 1, 00, 00], [1, 1, 1, 00], [00, 1, 1, 1], [00, 00, 1, 1]]) >>> Sparsity.banded(4, 1).bw_upper(), Sparsity.banded(4, 1).bw_lower() (1, 1)
>> DM(Sparsity.banded(4, 1), 1) [[1, 1, 00, 00], [1, 1, 1, 00], [00, 1, 1, 1], [00, 00, 1, 1]] >> [Sparsity.banded(4, 1).bw_upper(), Sparsity.banded(4, 1).bw_lower()] 1 1
julia> ca.DM(ca.Sparsity.banded(4, 1), 1) DM( [[1, 1, 00, 00], [1, 1, 1, 00], [00, 1, 1, 1], [00, 00, 1, 1]]) julia> ca.bw_upper(ca.Sparsity.banded(4, 1)), ca.bw_lower(ca.Sparsity.banded(4, 1)) (1, 1)
Extra doc: https://github.com/casadi/casadi/wiki/L_bk
Definition at line 1124 of file sparsity.cpp.
References band(), and Sparsity().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1688 of file sparsity.cpp.
References horzcat(), Sparsity(), and vertcat().
Referenced by kkt().
| void casadi::Sparsity::bor | ( | DataType * | data, |
| const DataType * | val_data, | ||
| const Sparsity & | val_sp | ||
| ) | const |
Definition at line 6267 of file sparsity.hpp.
References colind(), dim(), is_empty(), nnz(), row(), size1(), and size2().
| 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().
| 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 |
Computes a row permutation and a column permutation that bring the pattern into block upper triangular form, see Direct Methods for Sparse Linear Systems by Davis (2006). The pattern may be rectangular.
Only structure is used: the distance of entries to the diagonal plays no role, so a randomly permuted block-diagonal matrix is not necessarily brought back to block diagonal form, and the row and column permutations differ in general, which destroys symmetry. The result is cached in the pattern.
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
>>> B = Sparsity.triplet(3, 3, [0, 0, 1, 2], [0, 2, 1, 2]) >>> DM(B, 1) DM( [[1, 00, 1], [00, 1, 00], [00, 00, 1]]) >>> nb, rowperm, colperm, rowblock, colblock, crb, ccb = B.btf() >>> nb, rowperm, colperm, rowblock, colblock (3, [2, 0, 1], [2, 0, 1], [0, 1, 2, 3], [0, 1, 2, 3]) >>> crb, ccb ([0, 0, 0, 3, 3], [0, 0, 3, 3, 3]) >>> DM(B, 1)[rowperm, colperm] DM( [[1, 00, 00], [1, 1, 00], [00, 00, 1]]) >>> sprank(Sparsity.nonzeros(3, 3, [0, 1, 2])), sprank(Sparsity.diag(3)) (1, 3)
>> B = Sparsity.triplet(3, 3, [0, 0, 1, 2], [0, 2, 1, 2]); >> DM(B, 1) [[1, 00, 1], [00, 1, 00], [00, 00, 1]] >> [nb, rowperm, colperm, rowblock, colblock, crb, ccb] = B.btf(); >> nb, rowperm, colperm, rowblock, colblock 3 2 0 1 2 0 1 0 1 2 3 0 1 2 3 >> crb, ccb 0 0 0 3 3 0 0 3 3 3 >> Bf = DM(B, 1); disp(Bf(rowperm + 1, colperm + 1)) [[1, 00, 00], [1, 1, 00], [00, 00, 1]] >> [sprank(Sparsity.nonzeros(3, 3, [1, 2, 3])), sprank(Sparsity.diag(3))] 1 3
julia> B = ca.Sparsity.triplet(3, 3, [0, 0, 1, 2], [0, 2, 1, 2]); julia> ca.DM(B, 1) DM( [[1, 00, 1], [00, 1, 00], [00, 00, 1]]) julia> ca.btf(B) (3, [2, 0, 1], [2, 0, 1], [0, 1, 2, 3], [0, 1, 2, 3], [0, 0, 0, 3, 3], [0, 0, 3, 3, 3]) julia> ca.sprank(ca.Sparsity.nonzeros(3, 3, [0, 1, 2])), ca.sprank(ca.Sparsity.diag(3)) (1, 3)
Extra doc: https://github.com/casadi/casadi/wiki/L_d7
Definition at line 723 of file sparsity.cpp.
Referenced by casadi::SymbolicQr::det(), casadi::SymbolicQr::init(), and sprank().
| casadi_int casadi::Sparsity::bw_lower | ( | ) | const |
Zero for a diagonal, upper triangular or all-zero pattern.
>>> Sparsity.banded(5, 2).bw_lower(), Sparsity.band(5, 2).bw_lower() (2, 2) >>> Sparsity.band(5, -2).bw_lower() 0 >>> Sparsity.dense(5, 2).bw_lower() 4
>> [Sparsity.banded(5, 2).bw_lower(), Sparsity.band(5, 2).bw_lower()] 2 2 >> Sparsity.band(5, -2).bw_lower() 0 >> Sparsity.dense(5, 2).bw_lower() 4
julia> ca.bw_lower(ca.Sparsity.banded(5, 2)), ca.bw_lower(ca.Sparsity.band(5, 2)) (2, 2) julia> ca.bw_lower(ca.Sparsity.band(5, -2)) 0 julia> ca.bw_lower(ca.Sparsity.dense(5, 2)) 4
Extra doc: https://github.com/casadi/casadi/wiki/L_by
Definition at line 1420 of file sparsity.cpp.
| casadi_int casadi::Sparsity::bw_upper | ( | ) | const |
Zero for a diagonal, lower triangular or all-zero pattern.
>>> Sparsity.banded(5, 2).bw_upper(), Sparsity.band(5, -2).bw_upper() (2, 2) >>> Sparsity.band(5, 2).bw_upper(), Sparsity.diag(3).bw_upper() (0, 0) >>> Sparsity(3, 3).bw_upper(), Sparsity.dense(2, 5).bw_upper() (0, 4)
>> [Sparsity.banded(5, 2).bw_upper(), Sparsity.band(5, -2).bw_upper()] 2 2 >> [Sparsity.band(5, 2).bw_upper(), Sparsity.diag(3).bw_upper()] 0 0 >> [Sparsity(3, 3).bw_upper(), Sparsity.dense(2, 5).bw_upper()] 0 4
julia> ca.bw_upper(ca.Sparsity.banded(5, 2)), ca.bw_upper(ca.Sparsity.band(5, -2)) (2, 2) julia> ca.bw_upper(ca.Sparsity.band(5, 2)), ca.bw_upper(ca.Sparsity.diag(3)) (0, 0) julia> ca.bw_upper(ca.Sparsity(3, 3)), ca.bw_upper(ca.Sparsity.dense(2, 5)) (0, 4)
Extra doc: https://github.com/casadi/casadi/wiki/L_bx
Definition at line 1416 of file sparsity.cpp.
|
inherited |
Extra doc: https://github.com/casadi/casadi/wiki/L_au
Definition at line 31 of file shared_object.cpp.
Referenced by casadi::FmuFunction::check_mem_count(), casadi::MXFunction::export_code_body(), and casadi::BlazingSplineFunction::merge().
| const casadi_int * casadi::Sparsity::colind | ( | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_c8
Definition at line 170 of file sparsity.cpp.
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::ConoptInterface::ConoptInterface(), 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::ConoptInterface::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::ConoptInterface::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().
| casadi_int casadi::Sparsity::colind | ( | casadi_int | cc | ) | const |
| cc | Column, in [0, size2()]; colind(size2()) equals nnz(). An index out of range raises an error. |
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
>>> sp.row(1), sp.colind(1), sp.colind(4)
(2, 2, 4)
>>> try: sp.row(4)
... except Exception as e: print("out of range")
out of range
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
>> [sp.row(1), sp.colind(1), sp.colind(4)]
2 2 4
>> try, sp.row(4); catch e, disp('out of range'); end
out of range
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
julia> ca.row(sp, 1), ca.colind(sp, 1), ca.colind(sp, 4)
(2, 2, 4)
julia> try
ca.row(sp, 4)
catch e
println("out of range")
end
out of range
Extra doc: https://github.com/casadi/casadi/wiki/L_cb
Definition at line 182 of file sparsity.cpp.
References colind(), size2(), and casadi::str().
|
inline |
Definition at line 1549 of file sparsity.hpp.
| Sparsity casadi::Sparsity::combine | ( | const Sparsity & | y, |
| bool | f0x_is_zero, | ||
| bool | function0_is_zero | ||
| ) | const |
Models the pattern of f(x, y) applied elementwise, where y has this pattern's shape. An entry is kept in the result when both arguments are nonzero; an entry where only y is nonzero is kept unless f0x_is_zero (f(0, y) == 0) and an entry where only x is nonzero is kept unless function0_is_zero (f(x, 0) == 0). So combine(y, False, False) is the union (unite) and combine(y, True, True) is the intersection (intersect). A shape mismatch raises an error.
The C++ overload with mapping returns, per nonzero of the union, bit 1 if the first argument is nonzero, bit 2 if the second is and bit 4 if the entry was dropped from the result.
| y | Pattern with the same shape |
| f0x_is_zero | True if entries where only y is nonzero are structural zeros |
| function0_is_zero | True if entries where only this pattern is nonzero are structural zeros |
>>> a = Sparsity.diag(2) >>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]) >>> a.combine(b, False, False) == a + b, a.combine(b, True, True) == a * b (True, True) >>> DM(a.combine(b, True, False), 1) DM( [[1, 00], [00, 1]]) >>> DM(a.combine(b, False, True), 1) DM( [[00, 1], [00, 1]])
>> a = Sparsity.diag(2); >> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]); >> a.combine(b, false, false) == a + b, a.combine(b, true, true) == a .* b 1 1 >> DM(a.combine(b, true, false), 1) [[1, 00], [00, 1]] >> DM(a.combine(b, false, true), 1) [[00, 1], [00, 1]]
julia> a = ca.Sparsity.diag(2); julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]); julia> ca.is_equal(ca.combine(a, b, false, false), ca.unite(a, b)) true julia> ca.DM(ca.combine(a, b, true, false), 1) DM( [[1, 00], [00, 1]]) julia> ca.DM(ca.combine(a, b, false, true), 1) DM( [[00, 1], [00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cl
Definition at line 406 of file sparsity.cpp.
References casadi::SparsityInternal::combine().
| Sparsity casadi::Sparsity::combine | ( | const Sparsity & | y, |
| bool | f0x_is_zero, | ||
| bool | function0_is_zero, | ||
| std::vector< unsigned char > & | mapping | ||
| ) | const |
Models the pattern of f(x, y) applied elementwise, where y has this pattern's shape. An entry is kept in the result when both arguments are nonzero; an entry where only y is nonzero is kept unless f0x_is_zero (f(0, y) == 0) and an entry where only x is nonzero is kept unless function0_is_zero (f(x, 0) == 0). So combine(y, False, False) is the union (unite) and combine(y, True, True) is the intersection (intersect). A shape mismatch raises an error.
The C++ overload with mapping returns, per nonzero of the union, bit 1 if the first argument is nonzero, bit 2 if the second is and bit 4 if the entry was dropped from the result.
| y | Pattern with the same shape |
| f0x_is_zero | True if entries where only y is nonzero are structural zeros |
| function0_is_zero | True if entries where only this pattern is nonzero are structural zeros |
>>> a = Sparsity.diag(2) >>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]) >>> a.combine(b, False, False) == a + b, a.combine(b, True, True) == a * b (True, True) >>> DM(a.combine(b, True, False), 1) DM( [[1, 00], [00, 1]]) >>> DM(a.combine(b, False, True), 1) DM( [[00, 1], [00, 1]])
>> a = Sparsity.diag(2); >> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]); >> a.combine(b, false, false) == a + b, a.combine(b, true, true) == a .* b 1 1 >> DM(a.combine(b, true, false), 1) [[1, 00], [00, 1]] >> DM(a.combine(b, false, true), 1) [[00, 1], [00, 1]]
julia> a = ca.Sparsity.diag(2); julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]); julia> ca.is_equal(ca.combine(a, b, false, false), ca.unite(a, b)) true julia> ca.DM(ca.combine(a, b, true, false), 1) DM( [[1, 00], [00, 1]]) julia> ca.DM(ca.combine(a, b, false, true), 1) DM( [[00, 1], [00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cl
Definition at line 400 of file sparsity.cpp.
References casadi::SparsityInternal::combine().
Referenced by casadi::MXNode::get_binary().
| std::vector< casadi_int > casadi::Sparsity::compress | ( | bool | canonical = true | ) | const |
Returns [nrow, ncol, colind..., row...], the layout accepted by compressed() and used for sparsity patterns in generated C code. With canonical false, a dense pattern is abbreviated to [nrow, ncol, 1] (an abbreviation that compressed() given a vector does not accept).
>>> Sparsity.diag(2).compress() [2, 2, 0, 1, 2, 0, 1] >>> Sparsity.dense(2, 2).compress() [2, 2, 0, 2, 4, 0, 1, 0, 1] >>> Sparsity.dense(2, 2).compress(False) [2, 2, 1] >>> Sparsity(0, 2).compress() [0, 2, 0, 0, 0]
>> Sparsity.diag(2).compress() 2 2 0 1 2 0 1 >> Sparsity.dense(2, 2).compress() 2 2 0 2 4 0 1 0 1 >> Sparsity.dense(2, 2).compress(false) 2 2 1 >> Sparsity(0, 2).compress() 0 2 0 0 0
julia> println(ca.compress(ca.Sparsity.diag(2))) [2, 2, 0, 1, 2, 0, 1] julia> println(ca.compress(ca.Sparsity.dense(2, 2))) [2, 2, 0, 2, 4, 0, 1, 0, 1] julia> println(ca.compress(ca.Sparsity.dense(2, 2), false)) [2, 2, 1] julia> println(ca.compress(ca.Sparsity(0, 2))) [0, 2, 0, 0, 0]
Extra doc: https://github.com/casadi/casadi/wiki/L_2nn
Definition at line 1335 of file sparsity.cpp.
References is_dense(), size1(), and size2().
Referenced by casadi::CodeGenerator::add_sparsity(), and serialize().
|
static |
The vector is laid out as [nrow, ncol, colind (ncol+1 entries), row (colind[ncol] entries)]. This is the format returned by compress() and used by generated C code (casadi_int arrays). When colind[ncol] equals nrow*ncol the row entries may be omitted (a dense pattern). An inconsistent vector raises an error.
| v | Compact representation |
| order_rows | If true, unsorted row indices within a column are sorted instead of raising an error |
>>> sp = Sparsity.compressed([3, 2, 0, 1, 2, 0, 2]) >>> DM(sp, 1) DM( [[1, 00], [00, 00], [00, 1]]) >>> Sparsity.compressed(sp.compress()) == sp True >>> Sparsity.compressed([2, 2, 0, 2, 4]) Sparsity(2x2)
>> sp = Sparsity.compressed([3, 2, 0, 1, 2, 0, 2]); >> DM(sp, 1) [[1, 00], [00, 00], [00, 1]] >> Sparsity.compressed(sp.compress()) == sp 1 >> Sparsity.compressed([2, 2, 0, 2, 4]) 2x2
julia> sp = ca.Sparsity.compressed([3, 2, 0, 1, 2, 0, 2]); julia> ca.DM(sp, 1) DM( [[1, 00], [00, 00], [00, 1]]) julia> ca.is_equal(ca.Sparsity.compressed(ca.compress(sp)), sp) true julia> ca.Sparsity.compressed([2, 2, 0, 2, 4]) Sparsity(2x2)
Extra doc: https://github.com/casadi/casadi/wiki/L_2nl
Definition at line 1372 of file sparsity.cpp.
References colind(), dense(), nnz(), row(), and Sparsity().
|
static |
The vector is laid out as [nrow, ncol, colind (ncol+1 entries), row (colind[ncol] entries)]. This is the format returned by compress() and used by generated C code (casadi_int arrays). When colind[ncol] equals nrow*ncol the row entries may be omitted (a dense pattern). An inconsistent vector raises an error.
| v | Compact representation |
| order_rows | If true, unsorted row indices within a column are sorted instead of raising an error |
>>> sp = Sparsity.compressed([3, 2, 0, 1, 2, 0, 2]) >>> DM(sp, 1) DM( [[1, 00], [00, 00], [00, 1]]) >>> Sparsity.compressed(sp.compress()) == sp True >>> Sparsity.compressed([2, 2, 0, 2, 4]) Sparsity(2x2)
>> sp = Sparsity.compressed([3, 2, 0, 1, 2, 0, 2]); >> DM(sp, 1) [[1, 00], [00, 00], [00, 1]] >> Sparsity.compressed(sp.compress()) == sp 1 >> Sparsity.compressed([2, 2, 0, 2, 4]) 2x2
julia> sp = ca.Sparsity.compressed([3, 2, 0, 1, 2, 0, 2]); julia> ca.DM(sp, 1) DM( [[1, 00], [00, 00], [00, 1]]) julia> ca.is_equal(ca.Sparsity.compressed(ca.compress(sp)), sp) true julia> ca.Sparsity.compressed([2, 2, 0, 2, 4]) Sparsity(2x2)
Extra doc: https://github.com/casadi/casadi/wiki/L_2nl
Definition at line 1355 of file sparsity.cpp.
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().
|
protectedinherited |
Definition at line 133 of file generic_shared_impl.hpp.
|
protectedinherited |
Definition at line 132 of file generic_shared_impl.hpp.
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_bc
Definition at line 72 of file sparsity.cpp.
References casadi::GenericShared< Shared, Internal >::own().
|
inherited |
Definition at line 112 of file generic_shared_impl.hpp.
|
static |
All nrow*ncol entries are nonzeros, stored column by column. This is the pattern of every matrix created without an explicit sparsity, e.g. SX.sym("x", 2, 3).
| nrow | Number of rows, nonnegative |
| ncol | Number of columns, nonnegative; default 1 (a dense column vector) |
The shape can also be given as a single pair (nrow, ncol).
>>> sp = Sparsity.dense(2, 3) >>> sp, sp.nnz(), sp.is_dense() (Sparsity(2x3), 6, True) >>> sp.colind(), sp.row() ([0, 2, 4, 6], [0, 1, 0, 1, 0, 1]) >>> Sparsity.dense(3), Sparsity.dense((2, 3)) (Sparsity(3x1), Sparsity(2x3)) >>> Sparsity.dense(0, 3).nnz(), Sparsity.dense(0, 3).is_dense() (0, True)
>> sp = Sparsity.dense(2, 3); >> sp, sp.nnz(), sp.is_dense() 2x3 6 1 >> sp.colind(), sp.row() 0 2 4 6 0 1 0 1 0 1 >> Sparsity.dense(3), Sparsity.dense([2, 3]) 3x1 2x3 >> Sparsity.dense(0, 3).nnz(), Sparsity.dense(0, 3).is_dense() 0 1
julia> sp = ca.Sparsity.dense(2, 3) Sparsity(2x3) julia> ca.nnz(sp), ca.is_dense(sp) (6, true) julia> ca.colind(sp), ca.row(sp) ([0, 2, 4, 6], [0, 1, 0, 1, 0, 1]) julia> ca.Sparsity.dense(3), ca.Sparsity.dense(2, 3) (3x1, 2x3) julia> ca.nnz(ca.Sparsity.dense(0, 3)), ca.is_dense(ca.Sparsity.dense(0, 3)) (0, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_be
Definition at line 1041 of file sparsity.cpp.
References colind(), row(), Sparsity(), and casadi::str().
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::RuntimeIntegrator::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::RuntimeIntegrator::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().
|
inlinestatic |
All nrow*ncol entries are nonzeros, stored column by column. This is the pattern of every matrix created without an explicit sparsity, e.g. SX.sym("x", 2, 3).
| nrow | Number of rows, nonnegative |
| ncol | Number of columns, nonnegative; default 1 (a dense column vector) |
The shape can also be given as a single pair (nrow, ncol).
>>> sp = Sparsity.dense(2, 3) >>> sp, sp.nnz(), sp.is_dense() (Sparsity(2x3), 6, True) >>> sp.colind(), sp.row() ([0, 2, 4, 6], [0, 1, 0, 1, 0, 1]) >>> Sparsity.dense(3), Sparsity.dense((2, 3)) (Sparsity(3x1), Sparsity(2x3)) >>> Sparsity.dense(0, 3).nnz(), Sparsity.dense(0, 3).is_dense() (0, True)
>> sp = Sparsity.dense(2, 3); >> sp, sp.nnz(), sp.is_dense() 2x3 6 1 >> sp.colind(), sp.row() 0 2 4 6 0 1 0 1 0 1 >> Sparsity.dense(3), Sparsity.dense([2, 3]) 3x1 2x3 >> Sparsity.dense(0, 3).nnz(), Sparsity.dense(0, 3).is_dense() 0 1
julia> sp = ca.Sparsity.dense(2, 3) Sparsity(2x3) julia> ca.nnz(sp), ca.is_dense(sp) (6, true) julia> ca.colind(sp), ca.row(sp) ([0, 2, 4, 6], [0, 1, 0, 1, 0, 1]) julia> ca.Sparsity.dense(3), ca.Sparsity.dense(2, 3) (3x1, 2x3) julia> ca.nnz(ca.Sparsity.dense(0, 3)), ca.is_dense(ca.Sparsity.dense(0, 3)) (0, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_be
Definition at line 521 of file sparsity.hpp.
| double casadi::Sparsity::density | ( | ) | const |
Computed in floating point, so it does not overflow for large shapes. An empty pattern (numel() == 0) is dense and gives 100.
>>> Sparsity.diag(4).density(), Sparsity.dense(2, 2).density() (25.0, 100.0) >>> Sparsity(0, 3).density() 100.0
>> fprintf('%g %g\n', Sparsity.diag(4).density(), Sparsity.dense(2, 2).density())
25 100
>> Sparsity(0, 3).density()
100
julia> ca.density(ca.Sparsity.diag(4)), ca.density(ca.Sparsity.dense(2, 2)) (25.0, 100.0) julia> ca.density(ca.Sparsity(0, 3)) 100.0
Extra doc: https://github.com/casadi/casadi/wiki/L_br
Definition at line 136 of file sparsity.cpp.
References nnz(), numel(), 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().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_c4
Definition at line 2109 of file sparsity.cpp.
References deserialize().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_c6
Definition at line 2093 of file sparsity.cpp.
References compressed(), Sparsity(), and casadi::DeserializingStream::unpack().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_c3
Definition at line 2080 of file sparsity.cpp.
Referenced by deserialize().
| casadi_int casadi::Sparsity::dfs | ( | casadi_int | j, |
| casadi_int | top, | ||
| std::vector< casadi_int > & | SWIG_INOUT1xi, | ||
| std::vector< casadi_int > & | SWIG_INOUT2pstack, | ||
| const std::vector< casadi_int > & | pinv, | ||
| std::vector< bool > & | SWIG_INOUT3marked | ||
| ) | const |
Low-level building block of scc (cs_dfs in CSparse). Starting from column j, it visits the columns reachable through the nonzeros and writes them, in reverse finishing order, into xi below position top. See Direct Methods for Sparse Linear Systems by Davis (2006).
| j | Start node (column) |
| top | Current top of the output stack in xi |
| xi | Output stack, length at least size2(); the visited nodes are stored in xi[new_top:top] |
| pstack | Work vector, length at least size2() |
| pinv | Inverse row permutation, or an empty vector for none |
| marked | Visited flags per node, updated in place |
>>> Sparsity.banded(3, 1).dfs(0, 3, [0, 0, 0], [0, 0, 0], [], [False] * 3) (0, [0, 1, 2], [1, 4, 5], [True, True, True])
>> sp = Sparsity.banded(3, 1); xi = [0, 0, 0]; pstack = [0, 0, 0]; >> [top, xi, pstack, marked] = sp.dfs(0, 3, xi, pstack, [], [false, false, false]); >> top, xi, pstack, marked 0 0 1 2 1 4 5 1 1 1
julia> ca.dfs(ca.Sparsity.banded(3, 1), 0, 3, [0, 0, 0], [0, 0, 0], [], [false, false, false]) (0, [0, 1, 2], [1, 4, 5], Bool[1, 1, 1])
Extra doc: https://github.com/casadi/casadi/wiki/L_d5
Definition at line 707 of file sparsity.cpp.
Referenced by casadi::SparsityInternal::scc().
|
inlinestatic |
The nonzeros are the entries (i, i) for i < min(nrow, ncol); a rectangular diagonal pattern is allowed. The shape can be given as one integer (square), as two integers or as a pair.
>>> DM(Sparsity.diag(3), 1) DM( [[1, 00, 00], [00, 1, 00], [00, 00, 1]]) >>> DM(Sparsity.diag(2, 4), 1) DM( [[1, 00, 00, 00], [00, 1, 00, 00]]) >>> Sparsity.diag((4, 2)).nnz(), Sparsity.diag(0).nnz() (2, 0)
>> DM(Sparsity.diag(3), 1) [[1, 00, 00], [00, 1, 00], [00, 00, 1]] >> DM(Sparsity.diag(2, 4), 1) [[1, 00, 00, 00], [00, 1, 00, 00]] >> Sparsity.diag([4, 2]).nnz(), Sparsity.diag(0).nnz() 2 0
julia> ca.DM(ca.Sparsity.diag(3), 1) DM( [[1, 00, 00], [00, 1, 00], [00, 00, 1]]) julia> ca.DM(ca.Sparsity.diag(2, 4), 1) DM( [[1, 00, 00, 00], [00, 1, 00, 00]]) julia> ca.nnz(ca.Sparsity.diag(4, 2)), ca.nnz(ca.Sparsity.diag(0)) (2, 0)
Extra doc: https://github.com/casadi/casadi/wiki/L_bi
Definition at line 723 of file sparsity.hpp.
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().
|
static |
The nonzeros are the entries (i, i) for i < min(nrow, ncol); a rectangular diagonal pattern is allowed. The shape can be given as one integer (square), as two integers or as a pair.
>>> DM(Sparsity.diag(3), 1) DM( [[1, 00, 00], [00, 1, 00], [00, 00, 1]]) >>> DM(Sparsity.diag(2, 4), 1) DM( [[1, 00, 00, 00], [00, 1, 00, 00]]) >>> Sparsity.diag((4, 2)).nnz(), Sparsity.diag(0).nnz() (2, 0)
>> DM(Sparsity.diag(3), 1) [[1, 00, 00], [00, 1, 00], [00, 00, 1]] >> DM(Sparsity.diag(2, 4), 1) [[1, 00, 00, 00], [00, 1, 00, 00]] >> Sparsity.diag([4, 2]).nnz(), Sparsity.diag(0).nnz() 2 0
julia> ca.DM(ca.Sparsity.diag(3), 1) DM( [[1, 00, 00], [00, 1, 00], [00, 00, 1]]) julia> ca.DM(ca.Sparsity.diag(2, 4), 1) DM( [[1, 00, 00, 00], [00, 1, 00, 00]]) julia> ca.nnz(ca.Sparsity.diag(4, 2)), ca.nnz(ca.Sparsity.diag(0)) (2, 0)
Extra doc: https://github.com/casadi/casadi/wiki/L_bi
Definition at line 573 of file sparsity.cpp.
References colind(), casadi::range(), row(), Sparsity(), and casadi::str().
|
inlinestatic |
The nonzeros are the entries (i, i) for i < min(nrow, ncol); a rectangular diagonal pattern is allowed. The shape can be given as one integer (square), as two integers or as a pair.
>>> DM(Sparsity.diag(3), 1) DM( [[1, 00, 00], [00, 1, 00], [00, 00, 1]]) >>> DM(Sparsity.diag(2, 4), 1) DM( [[1, 00, 00, 00], [00, 1, 00, 00]]) >>> Sparsity.diag((4, 2)).nnz(), Sparsity.diag(0).nnz() (2, 0)
>> DM(Sparsity.diag(3), 1) [[1, 00, 00], [00, 1, 00], [00, 00, 1]] >> DM(Sparsity.diag(2, 4), 1) [[1, 00, 00, 00], [00, 1, 00, 00]] >> Sparsity.diag([4, 2]).nnz(), Sparsity.diag(0).nnz() 2 0
julia> ca.DM(ca.Sparsity.diag(3), 1) DM( [[1, 00, 00], [00, 1, 00], [00, 00, 1]]) julia> ca.DM(ca.Sparsity.diag(2, 4), 1) DM( [[1, 00, 00, 00], [00, 1, 00, 00]]) julia> ca.nnz(ca.Sparsity.diag(4, 2)), ca.nnz(ca.Sparsity.diag(0)) (2, 0)
Extra doc: https://github.com/casadi/casadi/wiki/L_bi
Definition at line 725 of file sparsity.hpp.
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1609 of file sparsity.cpp.
References colind(), row(), and Sparsity().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1696 of file sparsity.cpp.
References casadi::check_offset(), nnz(), size1(), size2(), and casadi::GenericMatrix< MatType >::zeros().
| std::string casadi::Sparsity::dim | ( | bool | with_nz = false | ) | const |
| with_nz | If true, append ",<nnz>nz" |
This is the string printed for a Sparsity: with the nonzero count when the pattern is not dense.
>>> sp = Sparsity.diag(2, 3)
>>> sp.dim(), sp.dim(True)
('2x3', '2x3,2nz')
>>> Sparsity.dense(2, 2).dim(), Sparsity.dense(2, 2).dim(True)
('2x2', '2x2,4nz')
>>> sp
Sparsity(2x3,2nz)
>> sp = Sparsity.diag(2, 3); >> sp.dim(), sp.dim(true) 2x3 2x3,2nz >> Sparsity.dense(2, 2).dim(), Sparsity.dense(2, 2).dim(true) 2x2 2x2,4nz >> sp 2x3,2nz
julia> sp = ca.Sparsity.diag(2, 3);
julia> ca.dim(sp), ca.dim(sp, true)
("2x3", "2x3,2nz")
julia> ca.dim(ca.Sparsity.dense(2, 2)), ca.dim(ca.Sparsity.dense(2, 2), true)
("2x2", "2x2,4nz")
julia> sp
Sparsity(2x3,2nz)
Extra doc: https://github.com/casadi/casadi/wiki/L_2oa
Definition at line 595 of file sparsity.cpp.
Referenced by add(), append(), appendColumns(), bor(), casadi::Conic::Conic(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), get_nz(), casadi::Dple::init(), casadi::Nlpsol::init(), is_singular(), casadi::MXNode::join_primitives_gen(), mtimes(), casadi::mul_bvec_fwd(), mul_sparsityR(), norm_0_mul(), postfix_dim(), casadi::FunctionInternal::print_canonical(), casadi::MX::project(), scc(), and set().
|
inherited |
Definition at line 35 of file shared_object.cpp.
References casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().
Referenced by casadi::WeakRefInternal::disp(), casadi::Nlpsol::disp_more(), and casadi::CsparseInterface::nfact().
| 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 |
||
| ) |
The existing nonzeros are kept and scattered: row i of the old pattern becomes row rr[i] and column j becomes column cc[j] of the new nrow-by-ncol pattern, so that B[rr, cc] has the old pattern. The new rows and columns are structural zeros. Nonzero indices are unchanged. The object is rebound to the new pattern.
| nrow | New number of rows |
| ncol | New number of columns |
| rr | New row of every old row: length size1(), strictly increasing, entries in [0, nrow); negative entries count from the end |
| cc | New column of every old column: length size2(), strictly increasing, entries in [0, ncol) |
| ind1 | If true, indices are one-based |
A wrong length or an index out of range raises an error.
>>> sp = Sparsity.dense(2, 2)
>>> sp.enlarge(4, 3, [0, 3], [1, 2])
>>> DM(sp, 1)
DM(
[[00, 1, 1],
[00, 00, 00],
[00, 00, 00],
[00, 1, 1]])
>>> try: Sparsity.dense(2, 2).enlarge(4, 3, [0], [1, 2])
... except Exception as e: print("wrong length")
wrong length
>> sp = Sparsity.dense(2, 2);
>> sp.enlarge(4, 3, [0, 3], [1, 2]);
>> DM(sp, 1)
[[00, 1, 1],
[00, 00, 00],
[00, 00, 00],
[00, 1, 1]]
>> try, Sparsity.dense(2, 2).enlarge(4, 3, 0, [1, 2]); catch e, disp('wrong length'); end
wrong length
julia> sp = ca.Sparsity.dense(2, 2);
julia> ca.enlarge(sp, 4, 3, [0, 3], [1, 2])
julia> ca.DM(sp, 1)
DM(
[[00, 1, 1],
[00, 00, 00],
[00, 00, 00],
[00, 1, 1]])
julia> try
ca.enlarge(ca.Sparsity.dense(2, 2), 4, 3, [0], [1, 2])
catch e
println("wrong length")
end
wrong length
Extra doc: https://github.com/casadi/casadi/wiki/L_cr
Definition at line 547 of file sparsity.cpp.
References enlargeColumns(), and enlargeRows().
Referenced by casadi::MX::enlarge(), and casadi::Sqpmethod::init().
| void casadi::Sparsity::enlargeColumns | ( | casadi_int | ncol, |
| const std::vector< casadi_int > & | cc, | ||
| bool | ind1 = false |
||
| ) |
Same as enlarge with the rows left unchanged.
| ncol | New number of columns |
| cc | New column of every old column, length size2(), strictly increasing |
| ind1 | If true, indices are one-based |
>>> sp = Sparsity.dense(2, 2); sp.enlargeColumns(3, [0, 2]); print(DM(sp, 1)) [[1, 00, 1], [1, 00, 1]]
>> sp = Sparsity.dense(2, 2); sp.enlargeColumns(3, [0, 2]); disp(DM(sp, 1)) [[1, 00, 1], [1, 00, 1]]
julia> sp = ca.Sparsity.dense(2, 2); ca.enlargeColumns(sp, 3, [0, 2]); ca.DM(sp, 1) DM( [[1, 00, 1], [1, 00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_ct
Definition at line 553 of file sparsity.cpp.
References size1(), size2(), Sparsity(), and casadi::str().
Referenced by enlarge(), and casadi::FunctionInternal::from_compact().
| void casadi::Sparsity::enlargeRows | ( | casadi_int | nrow, |
| const std::vector< casadi_int > & | rr, | ||
| bool | ind1 = false |
||
| ) |
Same as enlarge with the columns left unchanged.
| nrow | New number of rows |
| rr | New row of every old row, length size1(), strictly increasing |
| ind1 | If true, indices are one-based |
>>> sp = Sparsity.dense(2, 2); sp.enlargeRows(3, [0, 2]); print(DM(sp, 1)) [[1, 1], [00, 00], [1, 1]]
>> sp = Sparsity.dense(2, 2); sp.enlargeRows(3, [0, 2]); disp(DM(sp, 1)) [[1, 1], [00, 00], [1, 1]]
julia> sp = ca.Sparsity.dense(2, 2); ca.enlargeRows(sp, 3, [0, 2]); ca.DM(sp, 1) DM( [[1, 1], [00, 00], [1, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cs
Definition at line 563 of file sparsity.cpp.
References size1(), size2(), Sparsity(), and casadi::str().
Referenced by enlarge(), and casadi::FunctionInternal::from_compact().
| std::vector< casadi_int > casadi::Sparsity::erase | ( | const std::vector< casadi_int > & | rr, |
| bool | ind1 = false |
||
| ) |
The shape is unchanged. Indices may be unsorted and negative; out of range raises an error. The object is rebound to the new pattern.
| rr | Flat element indices, in [0, numel()) |
| ind1 | If true, indices are one-based |
>>> sp = Sparsity.dense(3, 3)
>>> sp.erase([0, 4, 8]), sp
([1, 2, 3, 5, 6, 7], Sparsity(3x3,6nz))
>>> DM(sp, 1)
DM(
[[00, 1, 1],
[1, 00, 1],
[1, 1, 00]])
>>> try: Sparsity.dense(3, 3).erase([9])
... except Exception as e: print("out of range")
out of range
>> sp = Sparsity.dense(3, 3);
>> sp.erase([0, 4, 8]), sp
1 2 3 5 6 7
3x3,6nz
>> DM(sp, 1)
[[00, 1, 1],
[1, 00, 1],
[1, 1, 00]]
>> try, Sparsity.dense(3, 3).erase(9); catch e, disp('out of range'); end
out of range
julia> sp = ca.Sparsity.dense(3, 3);
julia> println(ca.erase(sp, [0, 4, 8]))
[1, 2, 3, 5, 6, 7]
julia> ca.DM(sp, 1)
DM(
[[00, 1, 1],
[1, 00, 1],
[1, 1, 00]])
julia> try
ca.erase(ca.Sparsity.dense(3, 3), [9])
catch e
println("out of range")
end
out of range
Extra doc: https://github.com/casadi/casadi/wiki/L_cw
Definition at line 348 of file sparsity.cpp.
| std::vector< casadi_int > casadi::Sparsity::erase | ( | const std::vector< casadi_int > & | rr, |
| const std::vector< casadi_int > & | cc, | ||
| bool | ind1 = false |
||
| ) |
The shape is unchanged: only the nonzeros in the block rr x cc are removed. An entry is removed when its row is in rr and its column is in cc, so an empty rr or cc removes nothing. Indices may be unsorted and negative (counting from the end); out of range raises an error. The object is rebound to the new pattern.
| rr | Rows of the block to clear |
| cc | Columns of the block to clear |
| ind1 | If true, indices are one-based |
>>> sp = Sparsity.dense(3, 3) >>> mapping = sp.erase([0, 2], [1]) >>> DM(sp, 1), mapping (DM( [[1, 00, 1], [1, 1, 1], [1, 00, 1]]), [0, 1, 2, 4, 6, 7, 8])
>> sp = Sparsity.dense(3, 3); >> mapping = sp.erase([0, 2], 1); >> DM(sp, 1), mapping [[1, 00, 1], [1, 1, 1], [1, 00, 1]] 0 1 2 4 6 7 8
julia> sp = ca.Sparsity.dense(3, 3); julia> mapping = ca.erase(sp, [0, 2], [1]); julia> println(mapping) [0, 1, 2, 4, 6, 7, 8] julia> ca.DM(sp, 1) DM( [[1, 00, 1], [1, 1, 1], [1, 00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cv
Definition at line 341 of file sparsity.cpp.
Referenced by casadi::MX::erase(), and casadi::FmuFunction::init().
| std::vector< casadi_int > casadi::Sparsity::etree | ( | bool | ata = false | ) | const |
Returns, for every column, the index of its parent in the elimination tree, or -1 for a root. See Direct Methods for Sparse Linear Systems by Davis (2006). With ata false the result matches MATLAB's etree(A) with zero-based indices (the pattern is treated as symmetric, only the upper triangular part is used); with ata true it matches etree(A, 'col'), the tree of A'*A.
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
>>> Sparsity.banded(4, 1).etree(), Sparsity.diag(4).etree() ([1, 2, 3, -1], [-1, -1, -1, -1]) >>> Sparsity.dense(2, 3).etree(True) [1, 2, -1]
>> Sparsity.banded(4, 1).etree(), Sparsity.diag(4).etree() 1 2 3 -1 -1 -1 -1 -1 >> Sparsity.dense(2, 3).etree(true) 1 2 -1
julia> ca.etree(ca.Sparsity.banded(4, 1)), ca.etree(ca.Sparsity.diag(4)) ([1, 2, 3, -1], [-1, -1, -1, -1]) julia> println(ca.etree(ca.Sparsity.dense(2, 3), true)) [1, 2, -1]
Extra doc: https://github.com/casadi/casadi/wiki/L_d2
Definition at line 625 of file sparsity.cpp.
References casadi::SparsityInternal::etree(), casadi::get_ptr(), size1(), and size2().
| void casadi::Sparsity::export_code | ( | const std::string & | lang, |
| std::ostream & | stream = casadi::uout(), |
||
| const Dict & | options = Dict() |
||
| ) | const |
Only "matlab" is supported: the code defines the dimensions, one-based column and row indices and the nonzero values of a sparse matrix. The code is written to the standard output or to the given stream.
| lang | Target language, must be "matlab" |
| options | Dictionary with
|
An unknown option raises an error.
>>> Sparsity.diag(2, 3).export_code("matlab")
sp_m = 2;
sp_n = 3;
sp_j = [1, 2];
sp_i = [1, 2];
sp_v = ones(size(sp_i));
sp = sparse(sp_i, sp_j, sp_v, sp_m, sp_n);
>>> opts = {"name": "A", "as_matrix": False, "nonzeros": ["1.5", "2"]}
>>> Sparsity.diag(2).export_code("matlab", opts)
A_m = 2;
A_n = 2;
A_j = [1, 2];
A_i = [1, 2];
A_v = [1.5, 2];
>>> try: Sparsity.diag(2).export_code("python")
... except Exception as e: print("unsupported language")
unsupported language
>> Sparsity.diag(2, 3).export_code('matlab');
sp_m = 2;
sp_n = 3;
sp_j = [1, 2];
sp_i = [1, 2];
sp_v = ones(size(sp_i));
sp = sparse(sp_i, sp_j, sp_v, sp_m, sp_n);
>> opts = struct('name', 'A', 'as_matrix', false, 'nonzeros', {{'1.5', '2'}});
>> Sparsity.diag(2).export_code('matlab', opts);
A_m = 2;
A_n = 2;
A_j = [1, 2];
A_i = [1, 2];
A_v = [1.5, 2];
>> try, Sparsity.diag(2).export_code('python'); catch e, disp('unsupported language'); end
unsupported language
julia> ca.export_code(ca.Sparsity.diag(2, 3), "matlab")
sp_m = 2;
sp_n = 3;
sp_j = [1, 2];
sp_i = [1, 2];
sp_v = ones(size(sp_i));
sp = sparse(sp_i, sp_j, sp_v, sp_m, sp_n);
julia> opts = Dict("name" => "A", "as_matrix" => false, "nonzeros" => ["1.5", "2"]);
julia> ca.export_code(ca.Sparsity.diag(2), "matlab", opts)
A_m = 2;
A_n = 2;
A_j = [1, 2];
A_i = [1, 2];
A_v = [1.5, 2];
julia> try
ca.export_code(ca.Sparsity.diag(2), "python")
catch e
println("unsupported language")
end
unsupported language
Extra doc: https://github.com/casadi/casadi/wiki/L_dj
Definition at line 802 of file sparsity.cpp.
Referenced by casadi::XFunction< DerivedType, MatType, NodeType >::export_code(), casadi::MXFunction::export_code_body(), and casadi::Linsol::nfact().
|
static |
Definition at line 1984 of file sparsity.cpp.
References file_formats, casadi::filename(), and casadi::str().
Referenced by from_file(), and to_file().
| std::vector< casadi_int > casadi::Sparsity::find | ( | bool | ind1 = SWIG_IND1 | ) | const |
Returns, in nonzero order, the position each nonzero would have in a dense column-major matrix of the same shape: row + col*size1(). Indexing a dense matrix A of this shape with the result picks the entries that are nonzeros of the pattern. Inverse of nonzeros(). For a dense pattern this is 0, ..., numel()-1.
| ind1 | If true, the indices are one-based |
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.find(), sp.find(True) ([0, 2, 7, 9], [1, 3, 8, 10]) >>> Sparsity.dense(2, 2).find(), Sparsity(2, 2).find(), Sparsity(0, 3).find() ([0, 1, 2, 3], [], [])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> sp.find(), sp.find(false) 1 3 8 10 0 2 7 9 >> Sparsity.dense(2, 2).find() 1 2 3 4 >> [isempty(Sparsity(2, 2).find()), isempty(Sparsity(0, 3).find())] 1 1
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.find(sp), ca.find(sp, true) ([0, 2, 7, 9], [1, 3, 8, 10]) julia> println(ca.find(ca.Sparsity.dense(2, 2))) [0, 1, 2, 3] julia> ca.find(ca.Sparsity(2, 2)), ca.find(ca.Sparsity(0, 3)) (Int64[], Int64[])
Extra doc: https://github.com/casadi/casadi/wiki/L_da
Definition at line 747 of file sparsity.cpp.
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().
| void casadi::Sparsity::find | ( | std::vector< casadi_int > & | loc, |
| bool | ind1 = false |
||
| ) | const |
Definition at line 753 of file sparsity.cpp.
|
static |
| filename | Path of the file to read; a missing file raises an error |
| format_hint | Format name, e.g. "mtx", when the extension does not tell |
Extra doc: https://github.com/casadi/casadi/wiki/L_2nt
Definition at line 2021 of file sparsity.cpp.
References file_format(), file_formats, casadi::filename(), casadi::Filesystem::ifstream_ptr(), nnz(), row(), size1(), size2(), and triplet().
| SparsityInternal * casadi::Sparsity::get | ( | ) | const |
Definition at line 2115 of file sparsity.cpp.
References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().
Referenced by casadi::SparsityInternal::is_equal(), casadi::SparsityInternal::maxtrans(), and operator*().
| void casadi::Sparsity::get_ccs | ( | std::vector< casadi_int > & | colind, |
| std::vector< casadi_int > & | row | ||
| ) | const |
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> colind, row = sp.get_ccs() >>> colind, row ([0, 2, 2, 3, 4], [0, 2, 1, 0])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> [colind, row] = sp.get_ccs(); disp(colind), disp(row) 0 2 2 3 4 0 2 1 0
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> colind, row = ca.get_ccs(sp); julia> colind, row ([0, 2, 2, 3, 4], [0, 2, 1, 0])
Extra doc: https://github.com/casadi/casadi/wiki/L_2ny
Definition at line 378 of file sparsity.cpp.
References colind(), get_colind(), get_row(), and row().
Referenced by get_crs().
| std::vector< casadi_int > casadi::Sparsity::get_col | ( | ) | const |
Length nnz(). Together with get_row() this gives the pattern in sparse triplet format.
Extra doc: https://github.com/casadi/casadi/wiki/L_cd
Definition at line 370 of file sparsity.cpp.
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().
| std::vector< casadi_int > casadi::Sparsity::get_colind | ( | ) | const |
Length size2()+1: entry j is the index of the first nonzero of column j and the last entry equals nnz(). In the target languages this method is called colind(), the same name as the single-column accessor.
Extra doc: https://github.com/casadi/casadi/wiki/L_ca
Definition at line 366 of file sparsity.cpp.
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().
| void casadi::Sparsity::get_crs | ( | std::vector< casadi_int > & | rowind, |
| std::vector< casadi_int > & | col | ||
| ) | const |
Equivalent to the compressed column storage of the transpose. Note that the resulting order of the nonzeros (row-major) differs from the storage order of the pattern.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> rowind, col = sp.get_crs() >>> rowind, col ([0, 2, 3, 4], [0, 3, 2, 0])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> [rowind, col] = sp.get_crs(); disp(rowind), disp(col) 0 2 3 4 0 3 2 0
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> rowind, col = ca.get_crs(sp); julia> rowind, col ([0, 2, 3, 4], [0, 3, 2, 0])
Extra doc: https://github.com/casadi/casadi/wiki/L_2nz
Definition at line 383 of file sparsity.cpp.
| Sparsity casadi::Sparsity::get_diag | ( | std::vector< casadi_int > & | mapping | ) | const |
If the pattern is not a vector, the result is the min(nrow, ncol)-by-1 pattern of the main diagonal: it has a nonzero for every diagonal entry (i, i) present in the pattern. If the pattern is a row or column vector of length n, the result is the n-by-n pattern with the vector entries on the diagonal.
>>> sp, mapping = Sparsity.banded(3, 1).get_diag() >>> sp, mapping (Sparsity(3x1), [0, 3, 6]) >>> sp, mapping = Sparsity.unit(3, 1).get_diag() >>> DM(sp, 1), mapping (DM( [[00, 00, 00], [00, 1, 00], [00, 00, 00]]), [0]) >>> sp, mapping = Sparsity(2, 3).get_diag() >>> sp, mapping (Sparsity(2x1,0nz), [])
>> [sp, mapping] = Sparsity.banded(3, 1).get_diag(); disp(sp), disp(mapping) 3x1 0 3 6 >> [sp, mapping] = Sparsity.unit(3, 1).get_diag(); disp(DM(sp, 1)), disp(mapping) [[00, 00, 00], [00, 1, 00], [00, 00, 00]] 0 >> [sp, mapping] = Sparsity(2, 3).get_diag(); disp(sp), disp(isempty(mapping)) 2x1,0nz 1
julia> ca.get_diag(ca.Sparsity.banded(3, 1)) (3x1, [0, 3, 6]) julia> ca.get_diag(ca.Sparsity.unit(3, 1)) (3x3,1nz, [0]) julia> ca.get_diag(ca.Sparsity(2, 3)) (2x1,0nz, Int64[])
Extra doc: https://github.com/casadi/casadi/wiki/L_2nm
Definition at line 621 of file sparsity.cpp.
References casadi::SparsityInternal::get_diag().
Referenced by casadi::MX::diag().
| std::vector< casadi_int > casadi::Sparsity::get_lower | ( | ) | const |
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.get_lower(), sp.get_upper() ([0, 1], [0, 2, 3]) >>> Sparsity.dense(2, 2).get_lower(), Sparsity.dense(2, 2).get_upper() ([0, 1, 3], [0, 2, 3])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> sp.get_lower(), sp.get_upper() 0 1 0 2 3 >> Sparsity.dense(2, 2).get_lower(), Sparsity.dense(2, 2).get_upper() 0 1 3 0 2 3
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.get_lower(sp), ca.get_upper(sp) ([0, 1], [0, 2, 3]) julia> ca.get_lower(ca.Sparsity.dense(2, 2)), ca.get_upper(ca.Sparsity.dense(2, 2)) ([0, 1, 3], [0, 2, 3])
Extra doc: https://github.com/casadi/casadi/wiki/L_2nw
Definition at line 1016 of file sparsity.cpp.
| casadi_int casadi::Sparsity::get_nz | ( | casadi_int | rr, |
| casadi_int | cc | ||
| ) | const |
Negative indices count from the end. An index out of bounds raises an error. For a dense pattern the result is rr + cc*size1(). The returned index addresses the nonzeros() vector of a matrix with this pattern.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
>>> sp.get_nz(0, 0), sp.get_nz(2, 0), sp.get_nz(1, 0), sp.get_nz(-1, 0)
(0, 1, -1, 1)
>>> try: sp.get_nz(3, 0)
... except Exception as e: print("out of bounds")
out of bounds
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
>> [sp.get_nz(0, 0), sp.get_nz(2, 0), sp.get_nz(1, 0), sp.get_nz(-1, 0)]
0 1 -1 1
>> try, sp.get_nz(3, 0); catch e, disp('out of bounds'); end
out of bounds
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
julia> ca.get_nz(sp, 0, 0), ca.get_nz(sp, 2, 0), ca.get_nz(sp, 1, 0), ca.get_nz(sp, -1, 0)
(0, 1, -1, 1)
julia> try
ca.get_nz(sp, 3, 0)
catch e
println("out of bounds")
end
out of bounds
Extra doc: https://github.com/casadi/casadi/wiki/L_cf
Definition at line 248 of file sparsity.cpp.
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().
| std::vector< casadi_int > casadi::Sparsity::get_nz | ( | const std::vector< casadi_int > & | rr, |
| const std::vector< casadi_int > & | cc | ||
| ) | const |
Returns one index per (row, column) combination, in column-major order over the block (all rows of the first column first); -1 marks a structural zero. Indices must be in range (no negative indices); otherwise an error is raised.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.get_nz([0, 2], [0, 3]) [0, 1, 3, -1]
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> sp.get_nz([0, 2], [0, 3]) 0 1 3 -1
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> println(ca.get_nz(sp, [0, 2], [0, 3])) [0, 1, 3, -1]
Extra doc: https://github.com/casadi/casadi/wiki/L_cg
Definition at line 266 of file sparsity.cpp.
| void casadi::Sparsity::get_nz | ( | std::vector< casadi_int > & | indices | ) | const |
Each entry of indices is replaced by the nonzero index of that element, or by -1 if the element is a structural zero. Entries that are already negative are left alone. The indices need not be sorted. An index of numel() or more raises an error.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.get_nz([0, 2, 4, 9, 1]) [0, 1, -1, 3, -1] >>> Sparsity.dense(2, 2).get_nz([3, 0]) [3, 0]
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> sp.get_nz([0, 2, 4, 9, 1]) 0 1 -1 3 -1 >> Sparsity.dense(2, 2).get_nz([3, 0]) 3 0
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
julia> ca.get_nz(sp, [0, 2, 4, 9, 1])
5-element Vector{Int64}:
0
1
-1
3
-1
julia> ca.get_nz(ca.Sparsity.dense(2, 2), [3, 0])
2-element Vector{Int64}:
3
0
Extra doc: https://github.com/casadi/casadi/wiki/L_ch
Definition at line 757 of file sparsity.cpp.
References dim(), numel(), and casadi::str().
| std::vector< casadi_int > casadi::Sparsity::get_row | ( | ) | const |
Length nnz(). Together with get_colind() this is the compressed column storage of the pattern; together with get_col() it is the triplet form. In the target languages this method is called row(), the same name as the single-element accessor.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> DM(sp, 1) DM( [[1, 00, 00, 1], [00, 00, 1, 00], [1, 00, 00, 00]]) >>> sp.row(), sp.colind(), sp.get_col() ([0, 2, 1, 0], [0, 2, 2, 3, 4], [0, 0, 2, 3]) >>> Sparsity.dense(2, 2).row(), Sparsity(2, 2).colind() ([0, 1, 0, 1], [0, 0, 0]) >>> Sparsity(0, 2).colind(), Sparsity(2, 0).colind() ([0, 0, 0], [0])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> DM(sp, 1) [[1, 00, 00, 1], [00, 00, 1, 00], [1, 00, 00, 00]] >> sp.row(), sp.colind(), sp.get_col() 0 2 1 0 0 2 2 3 4 0 0 2 3 >> Sparsity.dense(2, 2).row(), Sparsity(2, 2).colind() 0 1 0 1 0 0 0 >> Sparsity(0, 2).colind(), Sparsity(2, 0).colind() 0 0 0 0
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.row(sp), ca.colind(sp), ca.get_col(sp) ([0, 2, 1, 0], [0, 2, 2, 3, 4], [0, 0, 2, 3]) julia> ca.row(ca.Sparsity.dense(2, 2)), ca.colind(ca.Sparsity(2, 2)) ([0, 1, 0, 1], [0, 0, 0]) julia> ca.colind(ca.Sparsity(0, 2)), ca.colind(ca.Sparsity(2, 0)) ([0, 0, 0], [0])
Extra doc: https://github.com/casadi/casadi/wiki/L_c9
Definition at line 374 of file sparsity.cpp.
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().
|
inlineinherited |
Definition at line 91 of file shared_object.hpp.
| void casadi::Sparsity::get_triplet | ( | std::vector< casadi_int > & | row, |
| std::vector< casadi_int > & | col | ||
| ) | const |
Inverse of triplet(): Sparsity.triplet(nrow, ncol, row, col) rebuilds the pattern.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> row, col = sp.get_triplet() >>> row, col ([0, 2, 1, 0], [0, 0, 2, 3])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> [row, col] = sp.get_triplet(); disp(row), disp(col) 0 2 1 0 0 0 2 3
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> row, col = ca.get_triplet(sp); julia> row, col ([0, 2, 1, 0], [0, 0, 2, 3])
Extra doc: https://github.com/casadi/casadi/wiki/L_2o0
Definition at line 387 of file sparsity.cpp.
References get_col(), get_row(), and row().
Referenced by casadi::PiqpInterface::solve(), and casadi::ProxqpInterface::solve().
| std::vector< casadi_int > casadi::Sparsity::get_upper | ( | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_2nx
Definition at line 1020 of file sparsity.cpp.
|
static |
Definition at line 527 of file sparsity.cpp.
|
inherited |
Definition at line 102 of file generic_shared_impl.hpp.
|
static |
Definition at line 542 of file sparsity.cpp.
|
static |
Definition at line 532 of file sparsity.cpp.
|
static |
Definition at line 537 of file sparsity.cpp.
| bool casadi::Sparsity::has_nz | ( | casadi_int | rr, |
| casadi_int | cc | ||
| ) | const |
Same index rules as get_nz.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.has_nz(2, 0), sp.has_nz(1, 0) (True, False)
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> [sp.has_nz(2, 0), sp.has_nz(1, 0)] 1 0
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.has_nz(sp, 2, 0), ca.has_nz(sp, 1, 0) (true, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_2nv
Definition at line 243 of file sparsity.cpp.
References get_nz().
| std::size_t casadi::Sparsity::hash | ( | ) | const |
Equal patterns have equal hashes; the hash is used for the pattern cache. In Python, Sparsity objects are not hashable with the built-in hash(); use this method.
>>> sp = Sparsity.diag(2, 3) >>> sp.hash() == Sparsity.diag(2, 3).hash(), sp.hash() == Sparsity.dense(2, 3).hash() (True, False)
>> sp = Sparsity.diag(2, 3); >> class(sp.hash()) uint64 >> [sp.hash() == Sparsity.diag(2, 3).hash(), sp.hash() == Sparsity.dense(2, 3).hash()] 1 0
julia> sp = ca.Sparsity.diag(2, 3); julia> ca.hash(sp) == ca.hash(ca.Sparsity.diag(2, 3)), ca.hash(sp) == ca.hash(ca.Sparsity.dense(2, 3)) (true, false) julia> sp == ca.Sparsity.diag(2, 3), hash(sp) == hash(ca.Sparsity.diag(2, 3)) (true, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_2oc
Definition at line 824 of file sparsity.cpp.
Referenced by casadi::get_const().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1424 of file sparsity.cpp.
References nnz(), size1(), Sparsity(), and triplet().
Referenced by blockcat().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1636 of file sparsity.cpp.
References casadi::check_offset(), colind(), casadi::SparsityInterface< Sparsity >::offset(), row(), size1(), size2(), and Sparsity().
Referenced by vertsplit().
| Dict casadi::Sparsity::info | ( | ) | const |
An empty dictionary for a null object.
>>> Sparsity.diag(2, 3).info()
{'colind': [0, 1, 2, 2], 'ncol': 3, 'nrow': 2, 'row': [0, 1]}
>>> Sparsity().info()
{}
>> s = Sparsity.diag(2, 3).info(); disp(s) colind: [0 1 2 2] ncol: 3 nrow: 2 row: [0 1] >> isempty(fieldnames(Sparsity().info())) 1
julia> ca.info(ca.Sparsity.diag(2, 3))
Dict{String, Any} with 4 entries:
"nrow" => 2
"colind" => [0, 1, 2, 2]
"ncol" => 3
"row" => [0, 1]
julia> ca.info(ca.Sparsity())
Dict{String, Any}()
Extra doc: https://github.com/casadi/casadi/wiki/L_2nr
Definition at line 1977 of file sparsity.cpp.
References get_colind(), get_row(), casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), size1(), and size2().
The pattern of the elementwise product x * y for matrices with these patterns. A shape mismatch raises an error. In MATLAB this is the .* operator; * and mtimes give the pattern of the matrix product.
>>> a = Sparsity.diag(2) >>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]) >>> DM(a.intersect(b), 1) DM( [[00, 00], [00, 1]])
>> a = Sparsity.diag(2); >> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]); >> DM(a.intersect(b), 1) [[00, 00], [00, 1]]
julia> a = ca.Sparsity.diag(2); julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]); julia> ca.DM(ca.intersect(a, b), 1) DM( [[00, 00], [00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cn
Definition at line 424 of file sparsity.cpp.
References casadi::SparsityInternal::combine().
| Sparsity casadi::Sparsity::intersect | ( | const Sparsity & | y, |
| std::vector< unsigned char > & | mapping | ||
| ) | const |
The pattern of the elementwise product x * y for matrices with these patterns. A shape mismatch raises an error. In MATLAB this is the .* operator; * and mtimes give the pattern of the matrix product.
>>> a = Sparsity.diag(2) >>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]) >>> DM(a.intersect(b), 1) DM( [[00, 00], [00, 1]])
>> a = Sparsity.diag(2); >> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]); >> DM(a.intersect(b), 1) [[00, 00], [00, 1]]
julia> a = ca.Sparsity.diag(2); julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]); julia> ca.DM(ca.intersect(a, b), 1) DM( [[00, 00], [00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cn
Definition at line 419 of file sparsity.cpp.
References casadi::SparsityInternal::combine().
Referenced by casadi::MXNode::get_dot(), casadi::Project::get_nzref(), operator*(), and casadi::MX::project().
| bool casadi::Sparsity::is_column | ( | ) | const |
>>> Sparsity.dense(3, 1).is_column(), Sparsity.dense(1, 3).is_column() (True, False) >>> Sparsity(1, 1).is_column() True
>> [Sparsity.dense(3, 1).is_column(), Sparsity.dense(1, 3).is_column()] 1 0 >> Sparsity(1, 1).is_column() 1
julia> ca.is_column(ca.Sparsity.dense(3, 1)), ca.is_column(ca.Sparsity.dense(1, 3)) (true, false) julia> ca.is_column(ca.Sparsity(1, 1)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_cy
Definition at line 287 of file sparsity.cpp.
Referenced by append(), casadi::Rootfinder::init(), casadi::GenericMatrix< MatType >::is_column(), postfix_dim(), casadi::Matrix< Scalar >::print_default(), and casadi::Matrix< Scalar >::print_vector().
| 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. The index sets are returned in either case (the nonempty rows and columns); a pattern without nonzeros is compactible.
>>> ok, row, col = Sparsity.rowcol([0, 2], [0, 2], 3, 3).is_compactible() >>> ok, row, col (True, [0, 2], [0, 2]) >>> ok, row, col = Sparsity.diag(3).is_compactible() >>> ok, row, col (False, [0, 1, 2], [0, 1, 2])
>> [ok, row, col] = Sparsity.rowcol([0, 2], [0, 2], 3, 3).is_compactible(); >> ok, row, col 1 0 2 0 2 >> [ok, row, col] = Sparsity.diag(3).is_compactible(); disp(ok), disp(row), disp(col) 0 0 1 2 0 1 2
julia> ca.is_compactible(ca.Sparsity.rowcol([0, 2], [0, 2], 3, 3)) (true, [0, 2], [0, 2]) julia> ca.is_compactible(ca.Sparsity.diag(3)) (false, [0, 1, 2], [0, 1, 2])
Extra doc: https://github.com/casadi/casadi/wiki/L_2gf
Definition at line 819 of file sparsity.cpp.
References row().
Referenced by casadi::PseudoDenseMultiplication::try_create().
| bool casadi::Sparsity::is_dense | ( | ) | const |
An empty pattern (a zero dimension) is dense. Note that a DM built from a nested list is dense even if it holds numerical zeros.
>>> Sparsity.dense(2, 3).is_dense(), Sparsity.diag(3).is_dense() (True, False) >>> Sparsity(0, 3).is_dense(), Sparsity(1, 1).is_dense() (True, False) >>> DM([[1, 0], [0, 1]]).sparsity().is_dense() True
>> [Sparsity.dense(2, 3).is_dense(), Sparsity.diag(3).is_dense()] 1 0 >> [Sparsity(0, 3).is_dense(), Sparsity(1, 1).is_dense()] 1 0 >> sparsity(DM([1, 0; 0, 1])).is_dense() 1
julia> ca.is_dense(ca.Sparsity.dense(2, 3)), ca.is_dense(ca.Sparsity.diag(3)) (true, false) julia> ca.is_dense(ca.Sparsity(0, 3)), ca.is_dense(ca.Sparsity(1, 1)) (true, false) julia> ca.is_dense(ca.sparsity(ca.DM([1 0; 0 1]))) true
Extra doc: https://github.com/casadi/casadi/wiki/L_2o9
Definition at line 275 of file sparsity.cpp.
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().
| bool casadi::Sparsity::is_diag | ( | ) | const |
True only for Sparsity.diag(n) (including n == 0); a rectangular diagonal pattern, an all-zero square pattern or a pattern with off-diagonal entries is not diagonal.
>>> Sparsity.diag(3).is_diag(), Sparsity.diag(2, 3).is_diag() (True, False) >>> Sparsity.dense(1, 1).is_diag(), Sparsity(2, 2).is_diag() (True, False) >>> Sparsity(0, 0).is_diag(), Sparsity.dense(2, 2).is_diag() (True, False)
>> [Sparsity.diag(3).is_diag(), Sparsity.diag(2, 3).is_diag()] 1 0 >> [Sparsity.dense(1, 1).is_diag(), Sparsity(2, 2).is_diag()] 1 0 >> [Sparsity(0, 0).is_diag(), Sparsity.dense(2, 2).is_diag()] 1 0
julia> ca.is_diag(ca.Sparsity.diag(3)), ca.is_diag(ca.Sparsity.diag(2, 3)) (true, false) julia> ca.is_diag(ca.Sparsity.dense(1, 1)), ca.is_diag(ca.Sparsity(2, 2)) (true, false) julia> ca.is_diag(ca.Sparsity(0, 0)), ca.is_diag(ca.Sparsity.dense(2, 2)) (true, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_247
Definition at line 279 of file sparsity.cpp.
Referenced by casadi::SparsityInternal::_mtimes().
| bool casadi::Sparsity::is_empty | ( | bool | both = false | ) | const |
| both | If false (default), true when the number of rows or the number of columns is zero; if true, only when both are zero |
A pattern without nonzeros but with positive dimensions is not empty.
>>> Sparsity(0, 3).is_empty(), Sparsity(0, 3).is_empty(True) (True, False) >>> Sparsity(0, 0).is_empty(True) True >>> Sparsity(3, 3).is_empty(), Sparsity(3, 3).nnz() (False, 0)
>> Sparsity(0, 3).is_empty(), Sparsity(0, 3).is_empty(true) 1 0 >> Sparsity(0, 0).is_empty(true) 1 >> Sparsity(3, 3).is_empty(), Sparsity(3, 3).nnz() 0 0
julia> ca.is_empty(ca.Sparsity(0, 3)), ca.is_empty(ca.Sparsity(0, 3), true) (true, false) julia> ca.is_empty(ca.Sparsity(0, 0), true) true julia> ca.is_empty(ca.Sparsity(3, 3)), ca.nnz(ca.Sparsity(3, 3)) (false, 0)
Extra doc: https://github.com/casadi/casadi/wiki/L_bs
Definition at line 146 of file sparsity.cpp.
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().
| bool casadi::Sparsity::is_equal | ( | casadi_int | nrow, |
| casadi_int | ncol, | ||
| const casadi_int * | colind, | ||
| const casadi_int * | row | ||
| ) | const |
True when the dimensions and the nonzero positions coincide. This is the comparison behind the == operator. Shared (cached) patterns are detected in constant time; otherwise colind and row are compared. The second overload compares against a pattern given in compressed column storage vectors.
>>> a = Sparsity.diag(2) >>> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2), a != Sparsity.dense(2, 2) (True, True, True) >>> a.is_equal(2, 2, [0, 1, 2], [0, 1]) True >>> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) False >>> Sparsity(2, 2) == Sparsity.dense(2, 2) False
>> a = Sparsity.diag(2); >> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2) 1 1 >> a ~= Sparsity.dense(2, 2) 1 >> a.is_equal(2, 2, [0, 1, 2], [0, 1]) 1 >> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) 0 >> Sparsity(2, 2) == Sparsity.dense(2, 2) 0
julia> a = ca.Sparsity.diag(2); julia> ca.is_equal(a, ca.Sparsity.diag(2)), !ca.is_equal(a, ca.Sparsity.dense(2, 2)) (true, true) julia> ca.is_equal(a, 2, 2, [0, 1, 2], [0, 1]) true julia> ca.is_equal(ca.Sparsity.dense(2, 2), ca.Sparsity.dense(2, 3)) false julia> ca.is_equal(ca.Sparsity(2, 2), ca.Sparsity.dense(2, 2)) false
Extra doc: https://github.com/casadi/casadi/wiki/L_2no
Definition at line 455 of file sparsity.cpp.
| bool casadi::Sparsity::is_equal | ( | casadi_int | nrow, |
| casadi_int | ncol, | ||
| const std::vector< casadi_int > & | colind, | ||
| const std::vector< casadi_int > & | row | ||
| ) | const |
True when the dimensions and the nonzero positions coincide. This is the comparison behind the == operator. Shared (cached) patterns are detected in constant time; otherwise colind and row are compared. The second overload compares against a pattern given in compressed column storage vectors.
>>> a = Sparsity.diag(2) >>> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2), a != Sparsity.dense(2, 2) (True, True, True) >>> a.is_equal(2, 2, [0, 1, 2], [0, 1]) True >>> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) False >>> Sparsity(2, 2) == Sparsity.dense(2, 2) False
>> a = Sparsity.diag(2); >> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2) 1 1 >> a ~= Sparsity.dense(2, 2) 1 >> a.is_equal(2, 2, [0, 1, 2], [0, 1]) 1 >> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) 0 >> Sparsity(2, 2) == Sparsity.dense(2, 2) 0
julia> a = ca.Sparsity.diag(2); julia> ca.is_equal(a, ca.Sparsity.diag(2)), !ca.is_equal(a, ca.Sparsity.dense(2, 2)) (true, true) julia> ca.is_equal(a, 2, 2, [0, 1, 2], [0, 1]) true julia> ca.is_equal(ca.Sparsity.dense(2, 2), ca.Sparsity.dense(2, 3)) false julia> ca.is_equal(ca.Sparsity(2, 2), ca.Sparsity.dense(2, 2)) false
Extra doc: https://github.com/casadi/casadi/wiki/L_2no
Definition at line 450 of file sparsity.cpp.
| bool casadi::Sparsity::is_equal | ( | const Sparsity & | y | ) | const |
True when the dimensions and the nonzero positions coincide. This is the comparison behind the == operator. Shared (cached) patterns are detected in constant time; otherwise colind and row are compared. The second overload compares against a pattern given in compressed column storage vectors.
>>> a = Sparsity.diag(2) >>> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2), a != Sparsity.dense(2, 2) (True, True, True) >>> a.is_equal(2, 2, [0, 1, 2], [0, 1]) True >>> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) False >>> Sparsity(2, 2) == Sparsity.dense(2, 2) False
>> a = Sparsity.diag(2); >> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2) 1 1 >> a ~= Sparsity.dense(2, 2) 1 >> a.is_equal(2, 2, [0, 1, 2], [0, 1]) 1 >> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) 0 >> Sparsity(2, 2) == Sparsity.dense(2, 2) 0
julia> a = ca.Sparsity.diag(2); julia> ca.is_equal(a, ca.Sparsity.diag(2)), !ca.is_equal(a, ca.Sparsity.dense(2, 2)) (true, true) julia> ca.is_equal(a, 2, 2, [0, 1, 2], [0, 1]) true julia> ca.is_equal(ca.Sparsity.dense(2, 2), ca.Sparsity.dense(2, 3)) false julia> ca.is_equal(ca.Sparsity(2, 2), ca.Sparsity.dense(2, 2)) false
Extra doc: https://github.com/casadi/casadi/wiki/L_2no
Definition at line 446 of file sparsity.cpp.
|
inherited |
Definition at line 116 of file generic_shared_impl.hpp.
| bool casadi::Sparsity::is_orthonormal | ( | bool | allow_empty = false | ) | const |
Without allow_empty the pattern must also be square with exactly one nonzero per row and column (a permutation pattern). With allow_empty, rows and columns without nonzeros are disregarded and the shape may be rectangular.
| allow_empty | Disregard empty rows and columns in the analysis |
>>> Sparsity.diag(3).is_orthonormal() True >>> Sparsity.triplet(3, 3, [0, 1], [0, 1]).is_orthonormal() False >>> Sparsity.triplet(3, 3, [0, 1], [0, 1]).is_orthonormal(True) True >>> Sparsity.triplet(3, 3, [0, 0], [0, 1]).is_orthonormal(True) False >>> Sparsity.diag(2, 3).is_orthonormal(), Sparsity.diag(2, 3).is_orthonormal(True) (False, True)
>> Sparsity.diag(3).is_orthonormal() 1 >> Sparsity.triplet(3, 3, [0, 1], [0, 1]).is_orthonormal() 0 >> Sparsity.triplet(3, 3, [0, 1], [0, 1]).is_orthonormal(true) 1 >> Sparsity.triplet(3, 3, [0, 0], [0, 1]).is_orthonormal(true) 0 >> [Sparsity.diag(2, 3).is_orthonormal(), Sparsity.diag(2, 3).is_orthonormal(true)] 0 1
julia> ca.is_orthonormal(ca.Sparsity.diag(3)) true julia> ca.is_orthonormal(ca.Sparsity.triplet(3, 3, [0, 1], [0, 1])) false julia> ca.is_orthonormal(ca.Sparsity.triplet(3, 3, [0, 1], [0, 1]), true) true julia> ca.is_orthonormal(ca.Sparsity.triplet(3, 3, [0, 0], [0, 1]), true) false julia> sp = ca.Sparsity.diag(2, 3); julia> ca.is_orthonormal(sp), ca.is_orthonormal(sp, true) (false, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_24f
Definition at line 307 of file sparsity.cpp.
Referenced by casadi::MX::solve().
| bool casadi::Sparsity::is_orthonormal_columns | ( | bool | allow_empty = false | ) | const |
Without allow_empty the pattern must have at most as many columns as rows and exactly one nonzero per column. With allow_empty, columns without nonzeros are disregarded.
| allow_empty | Disregard empty columns in the analysis |
Extra doc: https://github.com/casadi/casadi/wiki/L_24h
Definition at line 315 of file sparsity.cpp.
| bool casadi::Sparsity::is_orthonormal_rows | ( | bool | allow_empty = false | ) | const |
Without allow_empty the pattern must have at most as many rows as columns and exactly one nonzero per row. With allow_empty, rows without nonzeros are disregarded.
| allow_empty | Disregard empty rows in the analysis |
>>> sp = Sparsity.diag(2, 3) >>> sp.is_orthonormal_rows(), sp.is_orthonormal_columns() (True, False) >>> sp.T.is_orthonormal_rows(), sp.T.is_orthonormal_columns() (False, True)
>> sp = Sparsity.diag(2, 3); >> [sp.is_orthonormal_rows(), sp.is_orthonormal_columns()] 1 0 >> [sp.T.is_orthonormal_rows(), sp.T.is_orthonormal_columns()] 0 1
julia> sp = ca.Sparsity.diag(2, 3); julia> ca.is_orthonormal_rows(sp), ca.is_orthonormal_columns(sp) (true, false) julia> ca.is_orthonormal_rows(ca.T(sp)), ca.is_orthonormal_columns(ca.T(sp)) (false, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_24g
Definition at line 311 of file sparsity.cpp.
| bool casadi::Sparsity::is_permutation | ( | ) | const |
A square pattern with exactly one nonzero in every row and every column, so that multiplying a dense vector permutes its entries. Equivalent to is_orthonormal().
>>> Sparsity.permutation([1, 2, 0]).is_permutation() True >>> Sparsity.diag(3).is_permutation() True >>> Sparsity.dense(2, 2).is_permutation(), Sparsity.diag(2, 3).is_permutation() (False, False)
>> Sparsity.permutation([1, 2, 0]).is_permutation() 1 >> Sparsity.diag(3).is_permutation() 1 >> [Sparsity.dense(2, 2).is_permutation(), Sparsity.diag(2, 3).is_permutation()] 0 0
julia> ca.is_permutation(ca.Sparsity.permutation([1, 2, 0])) true julia> ca.is_permutation(ca.Sparsity.diag(3)) true julia> ca.is_permutation(ca.Sparsity.dense(2, 2)), ca.is_permutation(ca.Sparsity.diag(2, 3)) (false, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_24d
Definition at line 299 of file sparsity.cpp.
Referenced by permutation_vector().
| bool casadi::Sparsity::is_reshape | ( | const Sparsity & | y | ) | const |
True when both have the same number of elements and the same flat (column-major) nonzero positions, i.e. reshape(A, y.size()) has pattern y.
>>> Sparsity.dense(2, 3).is_reshape(Sparsity.dense(6, 1)) True >>> Sparsity.diag(2).is_reshape(Sparsity.nonzeros(4, 1, [0, 3])) True >>> Sparsity.diag(2).is_reshape(Sparsity.nonzeros(4, 1, [0, 2])) False
>> Sparsity.dense(2, 3).is_reshape(Sparsity.dense(6, 1)) 1 >> Sparsity.diag(2).is_reshape(Sparsity.nonzeros(4, 1, [1, 4])) 1 >> Sparsity.diag(2).is_reshape(Sparsity.nonzeros(4, 1, [1, 3])) 0
julia> ca.is_reshape(ca.Sparsity.dense(2, 3), ca.Sparsity.dense(6, 1)) true julia> ca.is_reshape(ca.Sparsity.diag(2), ca.Sparsity.nonzeros(4, 1, [0, 3])) true julia> ca.is_reshape(ca.Sparsity.diag(2), ca.Sparsity.nonzeros(4, 1, [0, 2])) false
Extra doc: https://github.com/casadi/casadi/wiki/L_2o3
Definition at line 815 of file sparsity.cpp.
Referenced by casadi::MXNode::get_reshape(), casadi::SparsityCast::get_reshape(), casadi::MX::MX(), casadi::MX::reshape(), and reshape().
| bool casadi::Sparsity::is_row | ( | ) | const |
The number of columns (including zero) and the nonzeros play no role.
>>> Sparsity.dense(1, 3).is_row(), Sparsity.dense(3, 1).is_row() (True, False) >>> Sparsity(1, 0).is_row() True
>> [Sparsity.dense(1, 3).is_row(), Sparsity.dense(3, 1).is_row()] 1 0 >> Sparsity(1, 0).is_row() 1
julia> ca.is_row(ca.Sparsity.dense(1, 3)), ca.is_row(ca.Sparsity.dense(3, 1)) (true, false) julia> ca.is_row(ca.Sparsity(1, 0)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_cx
Definition at line 283 of file sparsity.cpp.
Referenced by casadi::GenericMatrix< MatType >::is_row().
| bool casadi::Sparsity::is_scalar | ( | bool | scalar_and_dense = false | ) | const |
| scalar_and_dense | If true, additionally require the single entry to be a nonzero (a 1-by-1 pattern with zero nonzeros is a structural zero) |
>>> Sparsity.dense(1, 1).is_scalar(), Sparsity(1, 1).is_scalar() (True, True) >>> Sparsity(1, 1).is_scalar(True), Sparsity.dense(2, 1).is_scalar() (False, False)
>> [Sparsity.dense(1, 1).is_scalar(), Sparsity(1, 1).is_scalar()] 1 1 >> [Sparsity(1, 1).is_scalar(true), Sparsity.dense(2, 1).is_scalar()] 0 0
julia> ca.is_scalar(ca.Sparsity.dense(1, 1)), ca.is_scalar(ca.Sparsity(1, 1)) (true, true) julia> ca.is_scalar(ca.Sparsity(1, 1), true), ca.is_scalar(ca.Sparsity.dense(2, 1)) (false, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_2o8
Definition at line 271 of file sparsity.cpp.
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().
| bool casadi::Sparsity::is_selection | ( | bool | allow_empty = false | ) | const |
A selection matrix S picks a subset of the entries of a dense vector: S @ v is a vector of distinct entries of v. The pattern has at most one nonzero per column and exactly one per row. Equivalent to is_orthonormal_rows(allow_empty).
| allow_empty | If true, rows without nonzeros are allowed (the result may contain structural zeros) |
>>> S = Sparsity.triplet(2, 3, [0, 1], [2, 0]) >>> DM(S, 1) @ DM([10, 20, 30]) DM([30, 10]) >>> S.is_selection(), Sparsity.triplet(2, 3, [0], [2]).is_selection() (True, False) >>> Sparsity.triplet(2, 3, [0], [2]).is_selection(True) True >>> Sparsity.diag(3, 2).is_selection() False
>> S = Sparsity.triplet(2, 3, [0, 1], [2, 0]); >> DM(S, 1) * DM([10; 20; 30]) [30, 10] >> [S.is_selection(), Sparsity.triplet(2, 3, 0, 2).is_selection()] 1 0 >> Sparsity.triplet(2, 3, 0, 2).is_selection(true) 1 >> Sparsity.diag(3, 2).is_selection() 0
julia> S = ca.Sparsity.triplet(2, 3, [0, 1], [2, 0]); julia> ca.DM(S, 1) * ca.DM([10, 20, 30]) DM([30, 10]) julia> ca.is_selection(S), ca.is_selection(ca.Sparsity.triplet(2, 3, [0], [2])) (true, false) julia> ca.is_selection(ca.Sparsity.triplet(2, 3, [0], [2]), true) true julia> ca.is_selection(ca.Sparsity.diag(3, 2)) false
Extra doc: https://github.com/casadi/casadi/wiki/L_24e
Definition at line 303 of file sparsity.cpp.
| bool casadi::Sparsity::is_singular | ( | ) | const |
True when the structural rank (sprank) is smaller than the size, i.e. no choice of nonzero values can make a matrix with this pattern invertible. A non-square pattern raises an error.
>>> Sparsity.diag(3).is_singular(), Sparsity(3, 3).is_singular()
(False, True)
>>> Sparsity.nonzeros(3, 3, [0, 1, 2]).is_singular(), Sparsity(0, 0).is_singular()
(True, False)
>>> try: Sparsity.dense(2, 3).is_singular()
... except Exception as e: print("not square")
not square
>> [Sparsity.diag(3).is_singular(), Sparsity(3, 3).is_singular()]
0 1
>> [Sparsity.nonzeros(3, 3, [1, 2, 3]).is_singular(), Sparsity(0, 0).is_singular()]
1 0
>> try, Sparsity.dense(2, 3).is_singular(); catch e, disp('not square'); end
not square
julia> ca.is_singular(ca.Sparsity.diag(3)), ca.is_singular(ca.Sparsity(3, 3))
(false, true)
julia> ca.is_singular(ca.Sparsity.nonzeros(3, 3, [0, 1, 2]))
true
julia> ca.is_singular(ca.Sparsity(0, 0))
false
julia> try
ca.is_singular(ca.Sparsity.dense(2, 3))
catch e
println("not square")
end
not square
Extra doc: https://github.com/casadi/casadi/wiki/L_24c
Definition at line 1329 of file sparsity.cpp.
References dim(), is_square(), size2(), and sprank().
Referenced by casadi::Integrator::init(), casadi::Rootfinder::init(), and casadi::CsparseInterface::nfact().
| bool casadi::Sparsity::is_square | ( | ) | const |
>>> Sparsity.dense(2, 2).is_square(), Sparsity.dense(2, 3).is_square() (True, False) >>> Sparsity(0, 0).is_square() True
>> [Sparsity.dense(2, 2).is_square(), Sparsity.dense(2, 3).is_square()] 1 0 >> Sparsity(0, 0).is_square() 1
julia> ca.is_square(ca.Sparsity.dense(2, 2)), ca.is_square(ca.Sparsity.dense(2, 3)) (true, false) julia> ca.is_square(ca.Sparsity(0, 0)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_248
Definition at line 295 of file sparsity.cpp.
Referenced by casadi::Expm::Expm(), is_singular(), casadi::GenericMatrix< MatType >::is_square(), kkt(), scc(), and casadi::Convexify::setup().
| bool casadi::Sparsity::is_stacked | ( | const Sparsity & | y, |
| casadi_int | n | ||
| ) | const |
True when this pattern equals horzcat(y, ..., y) with n repetitions, i.e. the pattern of repmat(y, 1, n). The patterns are compared structurally, so a dense pattern of the right shape does not count as a stack of a sparse one.
>>> sp = horzcat(Sparsity.diag(2), Sparsity.diag(2), Sparsity.diag(2)) >>> sp.is_stacked(Sparsity.diag(2), 3), sp.is_stacked(Sparsity.diag(2), 2) (True, False) >>> Sparsity.dense(2, 6).is_stacked(Sparsity.diag(2), 3) False
>> sp = [Sparsity.diag(2), Sparsity.diag(2), Sparsity.diag(2)]; >> sp.is_stacked(Sparsity.diag(2), 3), sp.is_stacked(Sparsity.diag(2), 2) 1 0 >> Sparsity.dense(2, 6).is_stacked(Sparsity.diag(2), 3) 0
julia> sp = ca.repmat(ca.Sparsity.diag(2), 1, 3) Sparsity(2x6,6nz) julia> ca.is_stacked(sp, ca.Sparsity.diag(2), 3), ca.is_stacked(sp, ca.Sparsity.diag(2), 2) (true, false) julia> ca.is_stacked(ca.Sparsity.dense(2, 6), ca.Sparsity.diag(2), 3) false
Extra doc: https://github.com/casadi/casadi/wiki/L_2np
Definition at line 442 of file sparsity.cpp.
| bool casadi::Sparsity::is_subset | ( | const Sparsity & | rhs | ) | const |
Both patterns must have the same shape, otherwise an error is raised. A pattern is a subset of itself and an all-zero pattern is a subset of any pattern of its shape.
>>> Sparsity.diag(3).is_subset(Sparsity.dense(3, 3)) True >>> Sparsity.dense(3, 3).is_subset(Sparsity.diag(3)) False >>> Sparsity(3, 3).is_subset(Sparsity.diag(3)) True >>> Sparsity.diag(3).is_subset(Sparsity.diag(3)) True
>> Sparsity.diag(3).is_subset(Sparsity.dense(3, 3)) 1 >> Sparsity.dense(3, 3).is_subset(Sparsity.diag(3)) 0 >> Sparsity(3, 3).is_subset(Sparsity.diag(3)) 1 >> Sparsity.diag(3).is_subset(Sparsity.diag(3)) 1
julia> ca.is_subset(ca.Sparsity.diag(3), ca.Sparsity.dense(3, 3)) true julia> ca.is_subset(ca.Sparsity.dense(3, 3), ca.Sparsity.diag(3)) false julia> ca.is_subset(ca.Sparsity(3, 3), ca.Sparsity.diag(3)) true julia> ca.is_subset(ca.Sparsity.diag(3), ca.Sparsity.diag(3)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_2o4
Definition at line 428 of file sparsity.cpp.
Referenced by casadi::SparsityCast::ad_reverse(), and casadi::Project::get_project().
| bool casadi::Sparsity::is_symmetric | ( | ) | const |
Structural symmetry only: (i, j) is a nonzero if and only if (j, i) is. Required by amd, ldl and the star colorings. A rectangular pattern is never symmetric.
>>> Sparsity.banded(3, 1).is_symmetric(), Sparsity.upper(3).is_symmetric() (True, False) >>> Sparsity(3, 3).is_symmetric(), Sparsity.dense(2, 3).is_symmetric() (True, False)
>> [Sparsity.banded(3, 1).is_symmetric(), Sparsity.upper(3).is_symmetric()] 1 0 >> [Sparsity(3, 3).is_symmetric(), Sparsity.dense(2, 3).is_symmetric()] 1 0
julia> ca.is_symmetric(ca.Sparsity.banded(3, 1)), ca.is_symmetric(ca.Sparsity.upper(3)) (true, false) julia> ca.is_symmetric(ca.Sparsity(3, 3)), ca.is_symmetric(ca.Sparsity.dense(2, 3)) (true, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_249
Definition at line 319 of file sparsity.cpp.
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().
| bool casadi::Sparsity::is_transpose | ( | const Sparsity & | y | ) | const |
>>> Sparsity.band(3, 1).is_transpose(Sparsity.band(3, -1)) True >>> Sparsity.band(3, 1).is_transpose(Sparsity.band(3, 1)) False >>> Sparsity.dense(2, 3).is_transpose(Sparsity.dense(3, 2)) True
>> Sparsity.band(3, 1).is_transpose(Sparsity.band(3, -1)) 1 >> Sparsity.band(3, 1).is_transpose(Sparsity.band(3, 1)) 0 >> Sparsity.dense(2, 3).is_transpose(Sparsity.dense(3, 2)) 1
julia> ca.is_transpose(ca.Sparsity.band(3, 1), ca.Sparsity.band(3, -1)) true julia> ca.is_transpose(ca.Sparsity.band(3, 1), ca.Sparsity.band(3, 1)) false julia> ca.is_transpose(ca.Sparsity.dense(2, 3), ca.Sparsity.dense(3, 2)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_2o2
Definition at line 811 of file sparsity.cpp.
| bool casadi::Sparsity::is_tril | ( | bool | strictly = false | ) | const |
| strictly | If true, require row > col (no diagonal entries) |
>>> Sparsity.lower(3).is_tril(), Sparsity.lower(3).is_tril(True) (True, False) >>> Sparsity.band(3, 1).is_tril(True), Sparsity.diag(3).is_tril() (True, True) >>> Sparsity.dense(3, 1).is_tril(), Sparsity.dense(1, 3).is_tril() (True, False)
>> [Sparsity.lower(3).is_tril(), Sparsity.lower(3).is_tril(true)] 1 0 >> [Sparsity.band(3, 1).is_tril(true), Sparsity.diag(3).is_tril()] 1 1 >> [Sparsity.dense(3, 1).is_tril(), Sparsity.dense(1, 3).is_tril()] 1 0
julia> ca.is_tril(ca.Sparsity.lower(3)), ca.is_tril(ca.Sparsity.lower(3), true) (true, false) julia> ca.is_tril(ca.Sparsity.band(3, 1), true), ca.is_tril(ca.Sparsity.diag(3)) (true, true) julia> ca.is_tril(ca.Sparsity.dense(3, 1)), ca.is_tril(ca.Sparsity.dense(1, 3)) (true, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_24b
Definition at line 323 of file sparsity.cpp.
Referenced by casadi::MadmpecInterface::init(), casadi::MadnlpInterface::init(), casadi::GenericMatrix< MatType >::is_tril(), and casadi::Convexify::setup().
| bool casadi::Sparsity::is_triu | ( | bool | strictly = false | ) | const |
| strictly | If true, require row < col (no diagonal entries) |
Defined for any shape; a pattern without nonzeros is upper triangular.
>>> Sparsity.upper(3).is_triu(), Sparsity.upper(3).is_triu(True) (True, False) >>> Sparsity.band(3, -1).is_triu(True), Sparsity(3, 3).is_triu() (True, True) >>> Sparsity.dense(1, 3).is_triu(), Sparsity.dense(3, 1).is_triu() (True, False)
>> [Sparsity.upper(3).is_triu(), Sparsity.upper(3).is_triu(true)] 1 0 >> [Sparsity.band(3, -1).is_triu(true), Sparsity(3, 3).is_triu()] 1 1 >> [Sparsity.dense(1, 3).is_triu(), Sparsity.dense(3, 1).is_triu()] 1 0
julia> ca.is_triu(ca.Sparsity.upper(3)), ca.is_triu(ca.Sparsity.upper(3), true) (true, false) julia> ca.is_triu(ca.Sparsity.band(3, -1), true), ca.is_triu(ca.Sparsity(3, 3)) (true, true) julia> ca.is_triu(ca.Sparsity.dense(1, 3)), ca.is_triu(ca.Sparsity.dense(3, 1)) (true, false)
Extra doc: https://github.com/casadi/casadi/wiki/L_24a
Definition at line 327 of file sparsity.cpp.
Referenced by casadi::IpoptInterface::init(), casadi::GenericMatrix< MatType >::is_triu(), and casadi::Convexify::setup().
| bool casadi::Sparsity::is_vector | ( | ) | const |
A 1-by-1 pattern is a vector; a 0-by-3 pattern is not.
>>> Sparsity.dense(3, 1).is_vector(), Sparsity.dense(1, 3).is_vector() (True, True) >>> Sparsity.dense(1, 1).is_vector(), Sparsity.dense(2, 2).is_vector() (True, False) >>> Sparsity(0, 3).is_vector() False
>> [Sparsity.dense(3, 1).is_vector(), Sparsity.dense(1, 3).is_vector()] 1 1 >> [Sparsity.dense(1, 1).is_vector(), Sparsity.dense(2, 2).is_vector()] 1 0 >> Sparsity(0, 3).is_vector() 0
julia> ca.is_vector(ca.Sparsity.dense(3, 1)), ca.is_vector(ca.Sparsity.dense(1, 3)) (true, true) julia> ca.is_vector(ca.Sparsity.dense(1, 1)), ca.is_vector(ca.Sparsity.dense(2, 2)) (true, false) julia> ca.is_vector(ca.Sparsity(0, 3)) false
Extra doc: https://github.com/casadi/casadi/wiki/L_cz
Definition at line 291 of file sparsity.cpp.
Referenced by casadi::FunctionInternal::check_mat(), casadi::Integrator::init(), casadi::GenericMatrix< MatType >::is_vector(), casadi::Integrator::map2oracle(), and casadi::Call::projectArg().
|
static |
Block pattern of the KKT matrix of an NLP with Hessian H (square, n-by-n) and constraint Jacobian J (m-by-n), where I1 and I2 are the n-by-n and m-by-m diagonal patterns that are included on request. Shape (n+m)-by-(n+m).
| H | Hessian pattern, must be square |
| J | Jacobian pattern, its number of columns must equal the size of H |
| with_x_diag | Add the diagonal to the H block |
| with_lam_g_diag | Make the lower right block diagonal instead of all-zero |
>>> DM(Sparsity.kkt(Sparsity.diag(2), Sparsity.dense(1, 2)), 1)
DM(
[[1, 00, 1],
[00, 1, 1],
[1, 1, 1]])
>>> DM(Sparsity.kkt(Sparsity(2, 2), Sparsity.dense(1, 2), False, False), 1)
DM(
[[00, 00, 1],
[00, 00, 1],
[1, 1, 00]])
>>> try: Sparsity.kkt(Sparsity.diag(2), Sparsity.dense(1, 3))
... except Exception as e: print("dimension mismatch")
dimension mismatch
>> DM(Sparsity.kkt(Sparsity.diag(2), Sparsity.dense(1, 2)), 1)
[[1, 00, 1],
[00, 1, 1],
[1, 1, 1]]
>> DM(Sparsity.kkt(Sparsity(2, 2), Sparsity.dense(1, 2), false, false), 1)
[[00, 00, 1],
[00, 00, 1],
[1, 1, 00]]
>> J = Sparsity.dense(1, 3);
>> try, Sparsity.kkt(Sparsity.diag(2), J); catch e, disp('dimension mismatch'); end
dimension mismatch
julia> ca.DM(ca.Sparsity.kkt(ca.Sparsity.diag(2), ca.Sparsity.dense(1, 2)), 1)
DM(
[[1, 00, 1],
[00, 1, 1],
[1, 1, 1]])
julia> ca.DM(ca.Sparsity.kkt(ca.Sparsity(2, 2), ca.Sparsity.dense(1, 2), false, false), 1)
DM(
[[00, 00, 1],
[00, 00, 1],
[1, 1, 00]])
julia> try
ca.Sparsity.kkt(ca.Sparsity.diag(2), ca.Sparsity.dense(1, 3))
catch e
println("dimension mismatch")
end
dimension mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_dk
Definition at line 2058 of file sparsity.cpp.
References blockcat(), diag(), is_square(), size(), size1(), size2(), Sparsity(), and T().
Referenced by casadi::Ipqp::init(), and casadi::Qrqp::init().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1466 of file sparsity.cpp.
References colind(), dense(), casadi::get_ptr(), is_dense(), nnz(), row(), size1(), size2(), and Sparsity().
Referenced by casadi::MXNode::get_kron(), and casadi::Kron::Kron().
|
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 1510 of file sparsity.cpp.
References colind(), row(), size1(), size2(), and Sparsity().
Referenced by casadi::MXNode::get_kron_contract(), and casadi::KronContract::KronContract().
| std::vector< casadi_int > casadi::Sparsity::largest_first | ( | ) | const |
Columns with the same number of nonzeros keep their relative order. Used as the ordering of the star colorings.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.largest_first(), Sparsity.diag(3).largest_first() ([0, 2, 3, 1], [0, 1, 2])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> sp.largest_first(), Sparsity.diag(3).largest_first() 0 2 3 1 0 1 2
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.largest_first(sp), ca.largest_first(ca.Sparsity.diag(3)) ([0, 2, 3, 1], [0, 1, 2])
Extra doc: https://github.com/casadi/casadi/wiki/L_de
Definition at line 789 of file sparsity.cpp.
| Sparsity casadi::Sparsity::ldl | ( | std::vector< casadi_int > & | p, |
| bool | amd = true |
||
| ) | const |
Computes the pattern of the factor in A[p, p] = L*D*L^T, where L is unit lower triangular. Returns the pattern of the strictly upper triangular L^T (the unit diagonal is not stored) and the ordering p. A non-symmetric pattern raises an error. The numerical counterpart is ldl() applied to a matrix.
| amd | If true (default), a fill-reducing AMD ordering is computed and returned in p; if false, p is the identity |
>>> Lt, p = Sparsity.banded(4, 1).ldl(False)
>>> DM(Lt, 1), p
(DM(
[[00, 1, 00, 00],
[00, 00, 1, 00],
[00, 00, 00, 1],
[00, 00, 00, 00]]), [0, 1, 2, 3])
>>> A = Sparsity.nonzeros(4, 4, [0, 3, 5, 10, 12, 15])
>>> Lt, p = A.ldl()
>>> Lt.nnz(), p
(1, [1, 2, 0, 3])
>>> try: Sparsity.upper(3).ldl()
... except Exception as e: print("not symmetric")
not symmetric
>> [Lt, p] = Sparsity.banded(4, 1).ldl(false);
>> DM(Lt, 1), p
[[00, 1, 00, 00],
[00, 00, 1, 00],
[00, 00, 00, 1],
[00, 00, 00, 00]]
0 1 2 3
>> A = Sparsity.nonzeros(4, 4, [1, 4, 6, 11, 13, 16]);
>> [Lt, p] = A.ldl(); disp(Lt.nnz()), disp(p)
1
1 2 0 3
>> try, Sparsity.upper(3).ldl(); catch e, disp('not symmetric'); end
not symmetric
julia> ca.ldl(ca.Sparsity.banded(4, 1), false)
(4x4,3nz, [0, 1, 2, 3])
julia> A = ca.Sparsity.nonzeros(4, 4, [0, 3, 5, 10, 12, 15]);
julia> ca.nnz(first(ca.ldl(A)))
1
julia> try
ca.ldl(ca.Sparsity.upper(3))
catch e
println("not symmetric")
end
not symmetric
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 631 of file sparsity.cpp.
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().
|
static |
Column j contains the rows j, ..., n-1, so the diagonal is included and the pattern has n*(n+1)/2 nonzeros.
| n | Size of the square pattern, nonnegative |
>>> DM(Sparsity.lower(3), 1)
DM(
[[1, 00, 00],
[1, 1, 00],
[1, 1, 1]])
>>> SX.sym("x", Sparsity.lower(2))
SX(
[[x_0, 00],
[x_1, x_2]])
>> DM(Sparsity.lower(3), 1)
[[1, 00, 00],
[1, 1, 00],
[1, 1, 1]]
>> SX.sym('x', Sparsity.lower(2))
[[x_0, 00],
[x_1, x_2]]
julia> ca.DM(ca.Sparsity.lower(3), 1)
DM(
[[1, 00, 00],
[1, 1, 00],
[1, 1, 1]])
julia> ca.SX.sym("x", ca.Sparsity.lower(2))
SX(
[[x_0, 00],
[x_1, x_2]])
Extra doc: https://github.com/casadi/casadi/wiki/L_bh
Definition at line 1078 of file sparsity.cpp.
References colind(), row(), and Sparsity().
Referenced by casadi::OptiNode::parameter(), casadi::Convexify::setup(), and casadi::OptiNode::variable().
|
inlinestatic |
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 3435 of file sparsity.hpp.
| Sparsity casadi::Sparsity::makeDense | ( | std::vector< casadi_int > & | mapping | ) | const |
>>> sp = Sparsity.triplet(3, 2, [0, 2], [0, 1]) >>> dense, mapping = sp.makeDense() >>> dense, mapping (Sparsity(3x2), [0, 5])
>> sp = Sparsity.triplet(3, 2, [0, 2], [0, 1]); >> [dense, mapping] = sp.makeDense(); disp(dense), disp(mapping) 3x2 0 5
julia> sp = ca.Sparsity.triplet(3, 2, [0, 2], [0, 1]); julia> ca.makeDense(sp) (3x2, [0, 5])
Extra doc: https://github.com/casadi/casadi/wiki/L_cu
Definition at line 591 of file sparsity.cpp.
References casadi::SparsityInternal::makeDense().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 432 of file sparsity.cpp.
References casadi::SparsityInternal::_mtimes(), dim(), size1(), and size2().
Referenced by casadi::MX::mtimes(), qr_sparse(), sum1(), and sum2().
|
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 1880 of file sparsity.cpp.
Referenced by casadi::Multiplication::eval_activity().
|
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 1873 of file sparsity.cpp.
Referenced by casadi::Multiplication::sp_forward().
|
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 1887 of file sparsity.cpp.
References casadi::casadi_fill(), colind(), dim(), row(), size1(), and size2().
Referenced by casadi::Multiplication::sp_reverse().
| casadi_int casadi::Sparsity::nnz | ( | ) | const |
Equals colind[size2()] and the length of the row vector. Zero for an empty pattern and for a pattern created with Sparsity(nrow, ncol).
Extra doc: https://github.com/casadi/casadi/wiki/L_bt
Definition at line 150 of file sparsity.cpp.
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::ConoptInterface::ConoptInterface(), casadi::ConstantFile::ConstantFile(), casadi::ConstantMX::create(), density(), diagsplit(), 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::ConoptInterface::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::ConoptInterface::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(), repr_el(), 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::ConoptInterface::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().
| casadi_int casadi::Sparsity::nnz_diag | ( | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_bw
Definition at line 362 of file sparsity.cpp.
| casadi_int casadi::Sparsity::nnz_lower | ( | bool | strictly = false | ) | const |
| strictly | If true, exclude the diagonal (count i > j only) |
Extra doc: https://github.com/casadi/casadi/wiki/L_bv
Definition at line 354 of file sparsity.cpp.
Referenced by casadi::WorhpInterface::set_work().
| casadi_int casadi::Sparsity::nnz_upper | ( | bool | strictly = false | ) | const |
| strictly | If true, exclude the diagonal (count i < j only) |
Defined for any shape, not only square patterns.
>>> sp = Sparsity.dense(3, 3) >>> sp.nnz_upper(), sp.nnz_upper(True), sp.nnz_lower(), sp.nnz_lower(True) (6, 3, 6, 3) >>> sp.nnz_diag() 3 >>> sp = Sparsity.dense(2, 4) >>> sp.nnz_upper(), sp.nnz_lower(), sp.nnz_diag() (7, 3, 2) >>> Sparsity.lower(3).nnz_upper(), Sparsity.lower(3).nnz_upper(True) (3, 0)
>> sp = Sparsity.dense(3, 3); >> [sp.nnz_upper(), sp.nnz_upper(true), sp.nnz_lower(), sp.nnz_lower(true)] 6 3 6 3 >> sp.nnz_diag() 3 >> sp = Sparsity.dense(2, 4); >> [sp.nnz_upper(), sp.nnz_lower(), sp.nnz_diag()] 7 3 2 >> [Sparsity.lower(3).nnz_upper(), Sparsity.lower(3).nnz_upper(true)] 3 0
julia> sp = ca.Sparsity.dense(3, 3); julia> ca.nnz_upper(sp), ca.nnz_upper(sp, true), ca.nnz_lower(sp), ca.nnz_lower(sp, true) (6, 3, 6, 3) julia> ca.nnz_diag(sp) 3 julia> sp = ca.Sparsity.dense(2, 4); julia> ca.nnz_upper(sp), ca.nnz_lower(sp), ca.nnz_diag(sp) (7, 3, 2) julia> ca.nnz_upper(ca.Sparsity.lower(3)), ca.nnz_upper(ca.Sparsity.lower(3), true) (3, 0)
Extra doc: https://github.com/casadi/casadi/wiki/L_bu
Definition at line 358 of file sparsity.cpp.
Referenced by casadi::OsqpInterface::codegen_init_mem(), casadi::OoqpInterface::init(), casadi::OsqpInterface::init(), casadi::MumpsInterface::init_mem(), and casadi::OsqpInterface::init_mem().
|
static |
Inverse of find(): Sparsity.nonzeros(sp.size1(), sp.size2(), sp.find()) equals sp. Duplicates are merged.
| nrow | Number of rows, must be positive |
| ncol | Number of columns |
| nz | Flat indices, each in [0, nrow*ncol); an index out of range raises an error |
| ind1 | If true, the indices are one-based |
>>> DM(Sparsity.nonzeros(3, 2, [0, 4]), 1) DM( [[1, 00], [00, 1], [00, 00]]) >>> sp = Sparsity.banded(3, 1) >>> Sparsity.nonzeros(3, 3, sp.find()) == sp True >>> Sparsity.nonzeros(3, 2, [1, 5], True) == Sparsity.nonzeros(3, 2, [0, 4]) True
>> DM(Sparsity.nonzeros(3, 2, [1, 5]), 1) [[1, 00], [00, 1], [00, 00]] >> sp = Sparsity.banded(3, 1); >> Sparsity.nonzeros(3, 3, sp.find()) == sp 1 >> Sparsity.nonzeros(3, 2, [0, 4], false) == Sparsity.nonzeros(3, 2, [1, 5]) 1
julia> ca.DM(ca.Sparsity.nonzeros(3, 2, [0, 4]), 1) DM( [[1, 00], [00, 1], [00, 00]]) julia> sp = ca.Sparsity.banded(3, 1); julia> ca.is_equal(ca.Sparsity.nonzeros(3, 3, ca.find(sp)), sp) true julia> sp1 = ca.Sparsity.nonzeros(3, 2, [1, 5], true); julia> ca.is_equal(sp1, ca.Sparsity.nonzeros(3, 2, [0, 4])) true
Extra doc: https://github.com/casadi/casadi/wiki/L_23g
Definition at line 1315 of file sparsity.cpp.
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1744 of file sparsity.cpp.
References colind(), dim(), casadi::get_ptr(), nnz(), row(), size1(), and size2().
Referenced by casadi::GenericMatrix< MatType >::norm_0_mul().
| casadi_int casadi::Sparsity::numel | ( | ) | const |
The product may overflow for very large shapes; nnz() never exceeds it.
>>> sp = Sparsity.diag(2, 3) >>> sp.numel(), sp.nnz(), Sparsity(0, 3).numel() (6, 2, 0)
>> sp = Sparsity.diag(2, 3);
>> fprintf('%d %d %d\n', sp.numel(), sp.nnz(), Sparsity(0, 3).numel())
6 2 0
julia> sp = ca.Sparsity.diag(2, 3); julia> ca.numel(sp), ca.nnz(sp), ca.numel(ca.Sparsity(0, 3)) (6, 2, 0)
Extra doc: https://github.com/casadi/casadi/wiki/L_bq
Definition at line 132 of file sparsity.cpp.
Referenced by density(), get_nz(), casadi::FunctionInternal::get_sparsity_out(), casadi::Nlpsol::init(), casadi::Matrix< Scalar >::print_default(), and casadi::reduce_index_gen().
| 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 1740 of file sparsity.cpp.
| casadi::Sparsity::operator const std::vector< casadi_int > & | ( | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_bo
Definition at line 1344 of file sparsity.cpp.
| casadi::Sparsity::operator SparsityStruct | ( | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_bp
Definition at line 1348 of file sparsity.cpp.
|
inline |
Definition at line 1443 of file sparsity.hpp.
References casadi::is_equal().
| const SparsityInternal & casadi::Sparsity::operator* | ( | ) | const |
The pattern of the elementwise product x * y for matrices with these patterns. A shape mismatch raises an error. In MATLAB this is the .* operator; * and mtimes give the pattern of the matrix product.
>>> a = Sparsity.diag(2) >>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]) >>> DM(a.intersect(b), 1) DM( [[00, 00], [00, 1]])
>> a = Sparsity.diag(2); >> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]); >> DM(a.intersect(b), 1) [[00, 00], [00, 1]]
julia> a = ca.Sparsity.diag(2); julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]); julia> ca.DM(ca.intersect(a, b), 1) DM( [[00, 00], [00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_cn
Definition at line 464 of file sparsity.cpp.
References intersect().
The pattern of x + y for matrices with these patterns. A shape mismatch raises an error.
>>> a = Sparsity.diag(2)
>>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1])
>>> DM(a.unite(b), 1)
DM(
[[1, 1],
[00, 1]])
>>> a + b == a.unite(b), a * b == a.intersect(b)
(True, True)
>>> try: a + Sparsity.dense(3, 3)
... except Exception as e: print("dimension mismatch")
dimension mismatch
>> a = Sparsity.diag(2);
>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]);
>> DM(a.unite(b), 1)
[[1, 1],
[00, 1]]
>> a + b == a.unite(b), a .* b == a.intersect(b)
1
1
>> try, a + Sparsity.dense(3, 3); catch e, disp('dimension mismatch'); end
dimension mismatch
julia> a = ca.Sparsity.diag(2);
julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]);
julia> ca.DM(ca.unite(a, b), 1)
DM(
[[1, 1],
[00, 1]])
julia> try
ca.unite(a, ca.Sparsity.dense(3, 3))
catch e
println("dimension mismatch")
end
dimension mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_cm
Definition at line 460 of file sparsity.cpp.
References unite().
| const SparsityInternal * casadi::Sparsity::operator-> | ( | ) | const |
Definition at line 112 of file sparsity.cpp.
References casadi::GenericShared< SharedObject, SharedObjectInternal >::operator->().
|
inline |
True when the dimensions and the nonzero positions coincide. This is the comparison behind the == operator. Shared (cached) patterns are detected in constant time; otherwise colind and row are compared. The second overload compares against a pattern given in compressed column storage vectors.
>>> a = Sparsity.diag(2) >>> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2), a != Sparsity.dense(2, 2) (True, True, True) >>> a.is_equal(2, 2, [0, 1, 2], [0, 1]) True >>> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) False >>> Sparsity(2, 2) == Sparsity.dense(2, 2) False
>> a = Sparsity.diag(2); >> a.is_equal(Sparsity.diag(2)), a == Sparsity.diag(2) 1 1 >> a ~= Sparsity.dense(2, 2) 1 >> a.is_equal(2, 2, [0, 1, 2], [0, 1]) 1 >> Sparsity.dense(2, 2) == Sparsity.dense(2, 3) 0 >> Sparsity(2, 2) == Sparsity.dense(2, 2) 0
julia> a = ca.Sparsity.diag(2); julia> ca.is_equal(a, ca.Sparsity.diag(2)), !ca.is_equal(a, ca.Sparsity.dense(2, 2)) (true, true) julia> ca.is_equal(a, 2, 2, [0, 1, 2], [0, 1]) true julia> ca.is_equal(ca.Sparsity.dense(2, 2), ca.Sparsity.dense(2, 3)) false julia> ca.is_equal(ca.Sparsity(2, 2), ca.Sparsity.dense(2, 2)) false
Extra doc: https://github.com/casadi/casadi/wiki/L_2no
Definition at line 1439 of file sparsity.hpp.
References casadi::is_equal().
|
inherited |
Assign the node to a node class pointer (or null)
Definition at line 89 of file generic_shared_impl.hpp.
| Sparsity casadi::Sparsity::pattern_inverse | ( | ) | const |
The result has the same shape; a dense pattern becomes all-zero and an all-zero pattern becomes dense.
>>> DM(Sparsity.diag(2).pattern_inverse(), 1) DM( [[00, 1], [1, 00]]) >>> Sparsity.dense(2, 2).pattern_inverse(), Sparsity(2, 2).pattern_inverse() (Sparsity(2x2,0nz), Sparsity(2x2))
>> DM(Sparsity.diag(2).pattern_inverse(), 1) [[00, 1], [1, 00]] >> Sparsity.dense(2, 2).pattern_inverse(), Sparsity(2, 2).pattern_inverse() 2x2,0nz 2x2
julia> ca.DM(ca.pattern_inverse(ca.Sparsity.diag(2)), 1) DM( [[00, 1], [1, 00]]) julia> ca.pattern_inverse(ca.Sparsity.dense(2, 2)), ca.pattern_inverse(ca.Sparsity(2, 2)) (2x2,0nz, 2x2)
Extra doc: https://github.com/casadi/casadi/wiki/L_2o5
Definition at line 469 of file sparsity.cpp.
References casadi::SparsityInternal::pattern_inverse().
Referenced by casadi::HpipmInterface::init(), and casadi::HpmpcInterface::init().
|
static |
P is square with one nonzero per row and column, placed such that multiplying a column vector v from the left gives the same result as indexing it: P @ v == v[p]. The inverse of a permutation matrix is its transpose, so invert true returns the transpose pattern, for which P @ v puts v[i] at position p[i].
| p | Permutation vector: every integer in [0, len(p)) exactly once; anything else raises an error |
| invert | If true, build the inverse (transposed) permutation |
>>> P = Sparsity.permutation([2, 0, 1])
>>> DM(P, 1)
DM(
[[00, 00, 1],
[1, 00, 00],
[00, 1, 00]])
>>> DM(P, 1) @ DM([10, 20, 30])
DM([30, 10, 20])
>>> DM(Sparsity.permutation([2, 0, 1], True), 1) @ DM([10, 20, 30])
DM([20, 30, 10])
>>> Sparsity.permutation([2, 0, 1], True) == P.T
True
>>> try: Sparsity.permutation([0, 0, 1])
... except Exception as e: print("not a permutation")
not a permutation
>> P = Sparsity.permutation([2, 0, 1]);
>> DM(P, 1)
[[00, 00, 1],
[1, 00, 00],
[00, 1, 00]]
>> DM(P, 1) * DM([10; 20; 30])
[30, 10, 20]
>> DM(Sparsity.permutation([2, 0, 1], true), 1) * DM([10; 20; 30])
[20, 30, 10]
>> Sparsity.permutation([2, 0, 1], true) == P.T
1
>> try, Sparsity.permutation([0, 0, 1]); catch e, disp('not a permutation'); end
not a permutation
julia> P = ca.Sparsity.permutation([2, 0, 1]);
julia> ca.DM(P, 1)
DM(
[[00, 00, 1],
[1, 00, 00],
[00, 1, 00]])
julia> ca.DM(P, 1) * ca.DM([10, 20, 30])
DM([30, 10, 20])
julia> ca.DM(ca.Sparsity.permutation([2, 0, 1], true), 1) * ca.DM([10, 20, 30])
DM([20, 30, 10])
julia> ca.is_equal(ca.Sparsity.permutation([2, 0, 1], true), ca.T(P))
true
julia> try
ca.Sparsity.permutation([0, 0, 1])
catch e
println("not a permutation")
end
not a permutation
Extra doc: https://github.com/casadi/casadi/wiki/L_244
Definition at line 1396 of file sparsity.cpp.
References colind(), casadi::invert_permutation(), casadi::is_permutation(), casadi::range(), and Sparsity().
| const std::vector< casadi_int > casadi::Sparsity::permutation_vector | ( | bool | invert = false | ) | const |
Inverse of permutation(): Sparsity.permutation(p).permutation_vector() returns p. Raises an error if is_permutation() is false.
| invert | If true, return the inverse permutation instead |
>>> Sparsity.permutation([2, 0, 1]).permutation_vector()
[2, 0, 1]
>>> Sparsity.permutation([2, 0, 1]).permutation_vector(True)
[1, 2, 0]
>>> try: Sparsity.dense(2, 2).permutation_vector()
... except Exception as e: print("not a permutation matrix")
not a permutation matrix
>> Sparsity.permutation([2, 0, 1]).permutation_vector()
2 0 1
>> Sparsity.permutation([2, 0, 1]).permutation_vector(true)
1 2 0
>> try, Sparsity.dense(2, 2).permutation_vector(); catch e, disp('not a permutation'); end
not a permutation
julia> ca.permutation_vector(ca.Sparsity.permutation([2, 0, 1]))
3-element Vector{Int64}:
2
0
1
julia> ca.permutation_vector(ca.Sparsity.permutation([2, 0, 1]), true)
3-element Vector{Int64}:
1
2
0
julia> try
ca.permutation_vector(ca.Sparsity.dense(2, 2))
catch e
println("not a permutation matrix")
end
not a permutation matrix
Extra doc: https://github.com/casadi/casadi/wiki/L_245
Definition at line 1407 of file sparsity.cpp.
References get_row(), casadi::invert_permutation(), and is_permutation().
Referenced by casadi::MXNode::get_mac().
| Sparsity casadi::Sparsity::pmult | ( | const std::vector< casadi_int > & | p, |
| bool | permute_rows = true, |
||
| bool | permute_columns = true, |
||
| bool | invert_permutation = false |
||
| ) | const |
Nonzero (i, j) moves to (p[i], p[j]) when both rows and columns are permuted, to (p[i], j) for rows only and to (i, p[j]) for columns only. In matrix terms this is P^T*A*P, P^T*A or A*P with P the matrix of Sparsity.permutation(p). With invert_permutation the inverse of p is used instead, so that pmult(p, True, True, True) is the pattern of A[p, p].
| p | Permutation vector; its length must equal the number of rows (if permute_rows) and the number of columns (if permute_columns) |
| permute_rows | Permute the rows |
| permute_columns | Permute the columns |
| invert_permutation | Use the inverse permutation |
>>> A = Sparsity.triplet(3, 3, [0, 1, 2, 0], [1, 2, 0, 0]) >>> DM(A, 1) DM( [[1, 1, 00], [00, 00, 1], [1, 00, 00]]) >>> p = [2, 0, 1] >>> DM(A.pmult(p), 1) DM( [[00, 1, 00], [00, 00, 1], [1, 00, 1]]) >>> P = DM(Sparsity.permutation(p), 1) >>> A.pmult(p) == (P.T @ DM(A, 1) @ P).sparsity() True >>> A.pmult(p, True, True, True) == A.sub(p, p)[0] True >>> DM(A.pmult(p, True, False), 1) DM( [[00, 00, 1], [1, 00, 00], [1, 1, 00]])
>> A = Sparsity.triplet(3, 3, [0, 1, 2, 0], [1, 2, 0, 0]); >> DM(A, 1) [[1, 1, 00], [00, 00, 1], [1, 00, 00]] >> p = [2, 0, 1]; >> DM(A.pmult(p), 1) [[00, 1, 00], [00, 00, 1], [1, 00, 1]] >> P = DM(Sparsity.permutation(p), 1); >> A.pmult(p) == sparsity(P' * DM(A, 1) * P) 1 >> [sub, mapping] = A.sub(p, p); disp(A.pmult(p, true, true, true) == sub) 1 >> DM(A.pmult(p, true, false), 1) [[00, 00, 1], [1, 00, 00], [1, 1, 00]]
julia> A = ca.Sparsity.triplet(3, 3, [0, 1, 2, 0], [1, 2, 0, 0]); julia> ca.DM(A, 1) DM( [[1, 1, 00], [00, 00, 1], [1, 00, 00]]) julia> p = [2, 0, 1]; julia> ca.DM(ca.pmult(A, p), 1) DM( [[00, 1, 00], [00, 00, 1], [1, 00, 1]]) julia> P = ca.DM(ca.Sparsity.permutation(p), 1); julia> ca.is_equal(ca.pmult(A, p), ca.sparsity(P' * ca.DM(A, 1) * P)) true julia> ca.is_equal(ca.pmult(A, p, true, true, true), first(ca.sub(A, p, p))) true julia> ca.DM(ca.pmult(A, p, true, false), 1) DM( [[00, 00, 1], [1, 00, 00], [1, 1, 00]])
Extra doc: https://github.com/casadi/casadi/wiki/L_df
Definition at line 793 of file sparsity.cpp.
References casadi::invert_permutation(), and casadi::SparsityInternal::pmult().
Referenced by casadi::SparsityInternal::star_coloring(), and casadi::SparsityInternal::star_coloring2().
| std::string casadi::Sparsity::postfix_dim | ( | ) | const |
Rules:
>>> repr(Sparsity.dense(1, 1).postfix_dim()), repr(Sparsity(0, 0).postfix_dim())
("''", "'[]'")
>>> Sparsity.dense(5).postfix_dim(), Sparsity.dense(5, 10).postfix_dim()
('[5]', '[5x10]')
>>> Sparsity.diag(5, 10).postfix_dim(), Sparsity(1, 1).postfix_dim()
('[5x10,5nz]', '[1x1,0nz]')
>>> Sparsity.dense(1, 5).postfix_dim(), Sparsity(0, 3).postfix_dim()
('[1x5]', '[0x3]')
>> fprintf('"%s" "%s"\n', Sparsity.dense(1, 1).postfix_dim(), Sparsity(0, 0).postfix_dim())
"" "[]"
>> Sparsity.dense(5).postfix_dim(), Sparsity.dense(5, 10).postfix_dim()
[5]
[5x10]
>> Sparsity.diag(5, 10).postfix_dim(), Sparsity(1, 1).postfix_dim()
[5x10,5nz]
[1x1,0nz]
>> Sparsity.dense(1, 5).postfix_dim(), Sparsity(0, 3).postfix_dim()
[1x5]
[0x3]
julia> ca.postfix_dim(ca.Sparsity.dense(1, 1)), ca.postfix_dim(ca.Sparsity(0, 0))
("", "[]")
julia> ca.postfix_dim(ca.Sparsity.dense(5)), ca.postfix_dim(ca.Sparsity.dense(5, 10))
("[5]", "[5x10]")
julia> ca.postfix_dim(ca.Sparsity.diag(5, 10)), ca.postfix_dim(ca.Sparsity(1, 1))
("[5x10,5nz]", "[1x1,0nz]")
julia> ca.postfix_dim(ca.Sparsity.dense(1, 5)), ca.postfix_dim(ca.Sparsity(0, 3))
("[1x5]", "[0x3]")
Extra doc: https://github.com/casadi/casadi/wiki/L_dg
Definition at line 599 of file sparsity.cpp.
References dim(), is_column(), is_dense(), is_empty(), is_scalar(), size1(), and casadi::str().
|
inherited |
Print the pointer to the internal class
Definition at line 43 of file shared_object.cpp.
References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().
| void casadi::Sparsity::qr_sparse | ( | Sparsity & | V, |
| Sparsity & | R, | ||
| std::vector< casadi_int > & | prinv, | ||
| std::vector< casadi_int > & | pc, | ||
| bool | amd = true |
||
| ) | const |
Computes the patterns of V (the Householder vectors, a compact representation of Q) and R for the factorization of this pattern with its columns permuted by pc, plus the row permutation prinv used by the numerical factorization (qr_sparse on a matrix) and solution. V and R may have more rows than the pattern (the matrix is extended with zero rows when it has fewer rows than columns in the structural sense).
| amd | If true (default), the columns are reordered with the AMD ordering of A^T*A, returned in pc; if false, pc is the identity |
>>> V, R, prinv, pc = Sparsity.dense(3, 2).qr_sparse() >>> V, R, prinv, pc (Sparsity(3x2,5nz), Sparsity(3x2,3nz), [0, 1, 2], [0, 1]) >>> V, R, prinv, pc = Sparsity.banded(4, 1).qr_sparse(False) >>> V, R, prinv, pc (Sparsity(4x4,7nz), Sparsity(4x4,9nz), [0, 1, 2, 3], [0, 1, 2, 3])
>> [V, R, prinv, pc] = Sparsity.dense(3, 2).qr_sparse(); >> V, R, prinv, pc 3x2,5nz 3x2,3nz 0 1 2 0 1 >> [V, R, prinv, pc] = Sparsity.banded(4, 1).qr_sparse(false); >> V, R, prinv, pc 4x4,7nz 4x4,9nz 0 1 2 3 0 1 2 3
julia> V, R, prinv, pc = ca.qr_sparse(ca.Sparsity.dense(3, 2)); julia> V, R, prinv, pc (3x2,5nz, 3x2,3nz, [0, 1, 2], [0, 1]) julia> V, R, prinv, pc = ca.qr_sparse(ca.Sparsity.banded(4, 1), false); julia> V, R, prinv, pc (4x4,7nz, 4x4,9nz, [0, 1, 2, 3], [0, 1, 2, 3])
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 663 of file sparsity.cpp.
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().
| void casadi::Sparsity::removeDuplicates | ( | std::vector< casadi_int > & | mapping | ) |
Patterns created through the public interface have no duplicates, so this is a no-op for them. The entries of mapping (one per nonzero) corresponding to the removed duplicates are removed as well.
| mapping | Vector of length nnz(), filtered in the same way as the nonzeros |
>>> sp = Sparsity.banded(3, 1) >>> m = sp.removeDuplicates([0, 1, 2, 3, 4, 5, 6]) >>> m, sp ([0, 1, 2, 3, 4, 5, 6], Sparsity(3x3,7nz))
>> sp = Sparsity.banded(3, 1); >> m = sp.removeDuplicates([0, 1, 2, 3, 4, 5, 6]); >> m, sp 0 1 2 3 4 5 6 3x3,7nz
julia> sp = ca.Sparsity.banded(3, 1); julia> m = ca.removeDuplicates(sp, [0, 1, 2, 3, 4, 5, 6]); julia> m, sp ([0, 1, 2, 3, 4, 5, 6], 3x3,7nz)
Extra doc: https://github.com/casadi/casadi/wiki/L_d1
Definition at line 743 of file sparsity.cpp.
| std::string casadi::Sparsity::repr_el | ( | casadi_int | k | ) | const |
Gives "(row i, col j)", prefixed with "nonzero index k " when the pattern is not dense. Indices follow the global start_index option (zero-based by default). k must be in [0, nnz()); it is not checked.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> sp.repr_el(1) 'nonzero index 1 (row 2, col 0)' >>> Sparsity.dense(2, 2).repr_el(3) '(row 1, col 1)'
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> sp.repr_el(1) nonzero index 2 (row 3, col 1) >> Sparsity.dense(2, 2).repr_el(3) (row 2, col 2)
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.repr_el(sp, 1) "nonzero index 1 (row 2, col 0)" julia> ca.repr_el(ca.Sparsity.dense(2, 2), 3) "(row 1, col 1)"
Extra doc: https://github.com/casadi/casadi/wiki/L_2ob
Definition at line 615 of file sparsity.cpp.
References nnz(), and casadi::str().
Referenced by casadi::OracleFunction::calc_function().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 262 of file sparsity.cpp.
References casadi::SparsityInternal::_reshape().
Referenced by casadi::MX::reshape().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 252 of file sparsity.cpp.
References is_reshape().
| void casadi::Sparsity::resize | ( | casadi_int | nrow, |
| casadi_int | ncol | ||
| ) |
Nonzeros with row >= nrow or column >= ncol are dropped; growing adds structural zeros. Unlike reshape, the (row, col) position of the kept nonzeros is unchanged. The object is rebound to the new pattern; other references to the old pattern are unaffected.
| nrow | New number of rows, nonnegative |
| ncol | New number of columns, nonnegative |
>>> sp = Sparsity.dense(3, 3); sp.resize(2, 2); print(sp) 2x2 >>> sp.resize(4, 4); print(DM(sp, 1)) [[1, 1, 00, 00], [1, 1, 00, 00], [00, 00, 00, 00], [00, 00, 00, 00]] >>> sp.resize(0, 2); print(sp) 0x2
>> sp = Sparsity.dense(3, 3); sp.resize(2, 2); disp(sp) 2x2 >> sp.resize(4, 4); disp(DM(sp, 1)) [[1, 1, 00, 00], [1, 1, 00, 00], [00, 00, 00, 00], [00, 00, 00, 00]] >> sp.resize(0, 2); disp(sp) 0x2
julia> sp = ca.Sparsity.dense(3, 3); ca.resize(sp, 2, 2); sp Sparsity(2x2) julia> ca.resize(sp, 4, 4); ca.DM(sp, 1) DM( [[1, 1, 00, 00], [1, 1, 00, 00], [00, 00, 00, 00], [00, 00, 00, 00]]) julia> ca.resize(sp, 0, 2); sp Sparsity(0x2)
Extra doc: https://github.com/casadi/casadi/wiki/L_2nu
Definition at line 190 of file sparsity.cpp.
References size1(), and size2().
Referenced by casadi::SparsityInternal::combineGen1(), casadi::SparsityInternal::dmperm(), and casadi::SparsityInternal::pmult().
| 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 166 of file sparsity.cpp.
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::ConoptInterface::ConoptInterface(), 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::ConoptInterface::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::ConoptInterface::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().
| casadi_int casadi::Sparsity::row | ( | casadi_int | el | ) | const |
| el | Nonzero index, in [0, nnz()); out of range raises an error |
Extra doc: https://github.com/casadi/casadi/wiki/L_cc
Definition at line 174 of file sparsity.cpp.
References nnz(), row(), and casadi::str().
|
static |
Every combination of a row index and a column index becomes a nonzero; the block need not be contiguous. Duplicate indices are merged.
| row | Row indices, each in [0, nrow) |
| col | Column indices, each in [0, ncol) |
| nrow | Number of rows of the pattern |
| ncol | Number of columns of the pattern |
>>> DM(Sparsity.rowcol([0, 2], [1, 2], 3, 4), 1) DM( [[00, 1, 1, 00], [00, 00, 00, 00], [00, 1, 1, 00]]) >>> Sparsity.rowcol([], [1], 3, 4).nnz() 0
>> DM(Sparsity.rowcol([0, 2], [1, 2], 3, 4), 1) [[00, 1, 1, 00], [00, 00, 00, 00], [00, 1, 1, 00]] >> Sparsity.rowcol([], [1], 3, 4).nnz() 0
julia> ca.DM(ca.Sparsity.rowcol([0, 2], [1, 2], 3, 4), 1) DM( [[00, 1, 1, 00], [00, 00, 00, 00], [00, 1, 1, 00]]) julia> ca.nnz(ca.Sparsity.rowcol([], [1], 3, 4)) 0
Extra doc: https://github.com/casadi/casadi/wiki/L_bl
Definition at line 1141 of file sparsity.cpp.
|
inline |
Definition at line 1543 of file sparsity.hpp.
| bool casadi::Sparsity::rowsSequential | ( | bool | strictly = true | ) | const |
A pattern constructed through the public interface always satisfies this: row indices are sorted and unique within a column.
| strictly | If true (default), duplicate rows within a column are not allowed |
>>> Sparsity.banded(3, 1).rowsSequential() True >>> Sparsity.dense(2, 2).rowsSequential(False) True
>> Sparsity.banded(3, 1).rowsSequential() 1 >> Sparsity.dense(2, 2).rowsSequential(false) 1
julia> ca.rowsSequential(ca.Sparsity.banded(3, 1)) true julia> ca.rowsSequential(ca.Sparsity.dense(2, 2), false) true
Extra doc: https://github.com/casadi/casadi/wiki/L_d0
Definition at line 739 of file sparsity.cpp.
|
inlinestatic |
| dense_scalar | If true (default), the single entry is a nonzero; if false, the pattern is 1-by-1 with zero nonzeros (a structurally zero scalar) |
>>> Sparsity.scalar(), Sparsity.scalar().nnz() (Sparsity(1x1), 1) >>> Sparsity.scalar(False), Sparsity.scalar(False).nnz() (Sparsity(1x1,0nz), 0) >>> Sparsity.scalar() == Sparsity.dense(1, 1) True
>> Sparsity.scalar(), Sparsity.scalar().nnz() 1x1 1 >> Sparsity.scalar(false), Sparsity.scalar(false).nnz() 1x1,0nz 0 >> Sparsity.scalar() == Sparsity.dense(1, 1) 1
julia> ca.Sparsity.scalar(), ca.nnz(ca.Sparsity.scalar()) (1x1, 1) julia> ca.Sparsity.scalar(false), ca.nnz(ca.Sparsity.scalar(false)) (1x1,0nz, 0) julia> ca.is_equal(ca.Sparsity.scalar(), ca.Sparsity.dense(1, 1)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_bd
Definition at line 454 of file sparsity.hpp.
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().
| casadi_int casadi::Sparsity::scc | ( | std::vector< casadi_int > & | index, |
| std::vector< casadi_int > & | offset | ||
| ) | const |
Node j is the j-th row/column and nonzero (i, j) is an edge from j to i. See Direct Methods for Sparse Linear Systems by Davis (2006).
The components are ordered so that the symmetric permutation A[index, index] is block upper triangular with n diagonal blocks; for a symmetric pattern it is block diagonal, with the block boundaries given by offset.
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
>>> A = Sparsity.nonzeros(4, 4, [0, 2, 5, 7, 10, 13, 15]) >>> DM(A, 1) DM( [[1, 00, 00, 00], [00, 1, 00, 1], [1, 00, 1, 00], [00, 1, 00, 1]]) >>> n, index, offset = A.scc() >>> n, index, offset (3, [2, 0, 1, 3], [0, 1, 2, 4]) >>> DM(A, 1)[index, index] DM( [[1, 1, 00, 00], [00, 1, 00, 00], [00, 00, 1, 1], [00, 00, 1, 1]]) >>> Sparsity.diag(3).scc(), Sparsity.dense(3, 3).scc(), Sparsity(0, 0).scc() ((3, [0, 1, 2], [0, 1, 2, 3]), (1, [0, 1, 2], [0, 3]), (0, [], [0]))
>> A = Sparsity.nonzeros(4, 4, [1, 3, 6, 8, 11, 14, 16]); >> DM(A, 1) [[1, 00, 00, 00], [00, 1, 00, 1], [1, 00, 1, 00], [00, 1, 00, 1]] >> [n, index, offset] = A.scc(); disp(n), disp(index), disp(offset) 3 2 0 1 3 0 1 2 4 >> Af = DM(A, 1); disp(Af(index + 1, index + 1)) [[1, 1, 00, 00], [00, 1, 00, 00], [00, 00, 1, 1], [00, 00, 1, 1]] >> [n, index, offset] = Sparsity.diag(3).scc(); disp(n), disp(index), disp(offset) 3 0 1 2 0 1 2 3 >> [n, index, offset] = Sparsity.dense(3, 3).scc(); disp(n), disp(index), disp(offset) 1 0 1 2 0 3 >> [n, index, offset] = Sparsity(0, 0).scc(); disp(n), disp(isempty(index)), disp(offset) 0 1 0
julia> A = ca.Sparsity.nonzeros(4, 4, [0, 2, 5, 7, 10, 13, 15]); julia> ca.DM(A, 1) DM( [[1, 00, 00, 00], [00, 1, 00, 1], [1, 00, 1, 00], [00, 1, 00, 1]]) julia> ca.scc(A) (3, [2, 0, 1, 3], [0, 1, 2, 4]) julia> ca.scc(ca.Sparsity.diag(3)), ca.scc(ca.Sparsity.dense(3, 3)) ((3, [0, 1, 2], [0, 1, 2, 3]), (1, [0, 1, 2], [0, 3])) julia> ca.scc(ca.Sparsity(0, 0)) (0, Int64[], [0])
Extra doc: https://github.com/casadi/casadi/wiki/L_d6
Definition at line 714 of file sparsity.cpp.
References dim(), is_square(), and casadi::SparsityInterface< Sparsity >::offset().
Referenced by casadi::Conic::sdp_to_socp_init(), and casadi::Convexify::setup().
| std::string casadi::Sparsity::serialize | ( | ) | const |
The string can be stored and turned back into an equal pattern with deserialize(). A null object serializes and deserializes as a null object. Pickling in Python uses this mechanism.
>>> s = Sparsity.diag(2, 3).serialize()
>>> type(s).__name__, Sparsity.deserialize(s) == Sparsity.diag(2, 3)
('str', True)
>>> Sparsity.deserialize(Sparsity().serialize()).is_null()
True
>>> import pickle
>>> pickle.loads(pickle.dumps(Sparsity.diag(2, 3)))
Sparsity(2x3,2nz)
>> s = Sparsity.diag(2, 3).serialize(); >> class(s), Sparsity.deserialize(s) == Sparsity.diag(2, 3) char 1 >> Sparsity.deserialize(Sparsity().serialize()).is_null() 1
julia> s = ca.serialize(ca.Sparsity.diag(2, 3)); julia> typeof(s), ca.is_equal(ca.Sparsity.deserialize(s), ca.Sparsity.diag(2, 3)) (String, true) julia> ca.is_null(ca.Sparsity.deserialize(ca.serialize(ca.Sparsity()))) true
Extra doc: https://github.com/casadi/casadi/wiki/L_c2
Definition at line 2103 of file sparsity.cpp.
Referenced by serialize().
| void casadi::Sparsity::serialize | ( | SerializingStream & | s | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_c5
Definition at line 2085 of file sparsity.cpp.
References compress(), casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), and casadi::SerializingStream::pack().
| void casadi::Sparsity::serialize | ( | std::ostream & | stream | ) | const |
Extra doc: https://github.com/casadi/casadi/wiki/L_c1
Definition at line 2075 of file sparsity.cpp.
References serialize().
| void casadi::Sparsity::set | ( | DataType * | data, |
| const DataType * | val_data, | ||
| const Sparsity & | val_sp | ||
| ) | const |
Definition at line 6096 of file sparsity.hpp.
References colind(), dim(), is_empty(), nnz(), row(), size1(), and size2().
| 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().
| std::pair< casadi_int, casadi_int > casadi::Sparsity::size | ( | ) | const |
>>> sp = Sparsity.diag(2, 3) >>> sp.size(), sp.size(1), sp.size(2), sp.shape ((2, 3), 2, 3, (2, 3))
>> sp = Sparsity.diag(2, 3);
>> size(sp), sp.size(1), sp.size(2)
2 3
2
3
>> [m, n] = size(sp); fprintf('%d %d\n', m, n)
2 3
julia> sp = ca.Sparsity.diag(2, 3); julia> ca.size(sp), ca.size(sp, 1), ca.size(sp, 2) ((2, 3), 2, 3)
Extra doc: https://github.com/casadi/casadi/wiki/L_bz
Definition at line 154 of file sparsity.cpp.
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(), casadi::MXNode::to_matrix(), and casadi::OnnxFunction::wrap_derivative().
| casadi_int casadi::Sparsity::size | ( | casadi_int | axis | ) | const |
| axis | 1 for the number of rows, 2 for the number of columns; any other value raises an error |
Extra doc: https://github.com/casadi/casadi/wiki/L_c0
Definition at line 158 of file sparsity.cpp.
| casadi_int casadi::Sparsity::size1 | ( | ) | const |
>>> sp = Sparsity.diag(2, 3) >>> sp.size1(), sp.rows(), sp.size2(), sp.columns() (2, 2, 3, 3)
>> sp = Sparsity.diag(2, 3);
>> fprintf('%d %d %d %d\n', sp.size1(), sp.rows(), sp.size2(), sp.columns())
2 2 3 3
julia> sp = ca.Sparsity.diag(2, 3); julia> ca.size1(sp), ca.rows(sp), ca.size2(sp), ca.columns(sp) (2, 2, 3, 3)
Extra doc: https://github.com/casadi/casadi/wiki/L_2nq
Definition at line 124 of file sparsity.cpp.
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::conic_kkt_res(), 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().
| casadi_int casadi::Sparsity::size2 | ( | ) | const |
Definition at line 128 of file sparsity.cpp.
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::conic_kkt_res(), 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::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().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 257 of file sparsity.cpp.
References nnz().
X and Y have the same number of nonzeros and sparsity_cast(X, Y) maps nonzero k of X to nonzero k of Y. Given that this pattern is a subset of X, the result is the subset of Y made of the nonzeros of Y whose counterpart in X is in this pattern.
>>> X = Sparsity.diag(4) >>> Y = Sparsity.dense(2, 2) >>> x = Sparsity.nonzeros(4, 4, [0, 10, 15]) >>> DM(x.sparsity_cast_mod(X, Y), 1) DM( [[1, 1], [00, 1]])
>> X = Sparsity.diag(4); >> Y = Sparsity.dense(2, 2); >> x = Sparsity.nonzeros(4, 4, [1, 11, 16]); >> DM(x.sparsity_cast_mod(X, Y), 1) [[1, 1], [00, 1]]
julia> X = ca.Sparsity.diag(4); julia> Y = ca.Sparsity.dense(2, 2); julia> x = ca.Sparsity.nonzeros(4, 4, [0, 10, 15]); julia> ca.DM(ca.sparsity_cast_mod(x, X, Y), 1) DM( [[1, 1], [00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_246
Definition at line 1940 of file sparsity.cpp.
References casadi::X, and casadi::Y.
Referenced by casadi::SparsityCast::ad_forward(), casadi::SparsityCast::ad_reverse(), and casadi::SparsityCast::eval_mx().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1734 of file sparsity.cpp.
References btf().
Referenced by is_singular(), and casadi::GenericMatrix< MatType >::sprank().
Extra doc: https://github.com/casadi/casadi/wiki/L_d9
Definition at line 735 of file sparsity.cpp.
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().
| void casadi::Sparsity::spy | ( | std::ostream & | stream = casadi::uout() | ) | const |
Writes one line per row, with "*" for a structural nonzero and "." for a structural zero, to the standard output (or the given stream). Large patterns produce nrow lines of ncol characters.
Extra doc: https://github.com/casadi/casadi/wiki/L_dh
Definition at line 807 of file sparsity.cpp.
| void casadi::Sparsity::spy_matlab | ( | const std::string & | mfile | ) | const |
The file is overwritten. The script defines a sparse matrix A of ones with this pattern (see export_code) and ends with spy(A).
| mfile | Path of the .m file to write |
>>> import os, tempfile >>> d = tempfile.mkdtemp() >>> f = os.path.join(d, "show_pattern.m") >>> Sparsity.diag(2, 3).spy_matlab(f) >>> print(open(f).read()) % This function was automatically generated by CasADi A_m = 2; A_n = 3; A_j = [1, 2]; A_i = [1, 2]; A_v = ones(size(A_i)); A = sparse(A_i, A_j, A_v, A_m, A_n); spy(A); >>> os.remove(f); os.rmdir(d)
>> f = [tempname '.m']; >> Sparsity.diag(2, 3).spy_matlab(f); >> fileread(f) % This function was automatically generated by CasADi A_m = 2; A_n = 3; A_j = [1, 2]; A_i = [1, 2]; A_v = ones(size(A_i)); A = sparse(A_i, A_j, A_v, A_m, A_n); spy(A); >> delete(f);
julia> d = mktempdir(); julia> f = joinpath(d, "show_pattern.m"); julia> ca.spy_matlab(ca.Sparsity.diag(2, 3), f) julia> print(read(f, String)) % This function was automatically generated by CasADi A_m = 2; A_n = 3; A_j = [1, 2]; A_i = [1, 2]; A_v = ones(size(A_i)); A = sparse(A_i, A_j, A_v, A_m, A_n); spy(A); julia> rm(d, recursive=true)
Extra doc: https://github.com/casadi/casadi/wiki/L_di
Definition at line 798 of file sparsity.cpp.
| Sparsity casadi::Sparsity::star_coloring | ( | casadi_int | ordering = 1, |
| casadi_int | cutoff = std::numeric_limits<casadi_int>::max() |
||
| ) | const |
Algorithm 4.1 in Gebremedhin, Manne and Pothen, What Color Is Your Jacobian?, SIAM Rev. 47(4), 2006. Exploits symmetry so that fewer colors than uni_coloring are needed to recover all nonzeros of a Hessian. A non-symmetric pattern raises an error.
| ordering | 0 for the natural column order, 1 (default) to color in largest_first() order |
| cutoff | If more than this many colors are needed, a null Sparsity is returned |
>>> H = Sparsity.banded(4, 1) >>> DM(H.star_coloring(), 1) DM( [[00, 1, 00], [1, 00, 00], [00, 1, 00], [00, 00, 1]]) >>> Sparsity.diag(5).star_coloring() Sparsity(5x1) >>> Sparsity.dense(4, 4).star_coloring(1, 2).is_null() True
>> H = Sparsity.banded(4, 1); >> DM(H.star_coloring(), 1) [[00, 1, 00], [1, 00, 00], [00, 1, 00], [00, 00, 1]] >> Sparsity.diag(5).star_coloring() 5x1 >> Sparsity.dense(4, 4).star_coloring(1, 2).is_null() 1
julia> H = ca.Sparsity.banded(4, 1); julia> ca.DM(ca.star_coloring(H, 1, 1000), 1) DM( [[00, 1, 00], [1, 00, 00], [00, 1, 00], [00, 00, 1]]) julia> ca.star_coloring(ca.Sparsity.diag(5), 1, 1000) Sparsity(5x1) julia> ca.is_null(ca.star_coloring(ca.Sparsity.dense(4, 4), 0, 2)) true
Extra doc: https://github.com/casadi/casadi/wiki/L_dc
Definition at line 781 of file sparsity.cpp.
References casadi::SparsityInternal::star_coloring().
Referenced by casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FunctionInternal::get_partition(), and casadi::SparsityInternal::star_coloring().
| Sparsity casadi::Sparsity::star_coloring2 | ( | casadi_int | ordering = 1, |
| casadi_int | cutoff = std::numeric_limits<casadi_int>::max() |
||
| ) | const |
Algorithm 4.1 in Gebremedhin, Tarafdar, Manne and Pothen, New Acyclic and Star Coloring Algorithms with Application to Computing Hessians, SIAM J. Sci. Comput. 29(3), 2007. Same arguments and return value as star_coloring.
>>> H = Sparsity.banded(4, 1) >>> DM(H.star_coloring2(), 1) DM( [[00, 1, 00], [1, 00, 00], [00, 1, 00], [00, 00, 1]])
>> H = Sparsity.banded(4, 1); >> DM(H.star_coloring2(), 1) [[00, 1, 00], [1, 00, 00], [00, 1, 00], [00, 00, 1]]
julia> H = ca.Sparsity.banded(4, 1); julia> ca.DM(ca.star_coloring2(H, 1, 1000), 1) DM( [[00, 1, 00], [1, 00, 00], [00, 1, 00], [00, 00, 1]])
Extra doc: https://github.com/casadi/casadi/wiki/L_dd
Definition at line 785 of file sparsity.cpp.
References casadi::SparsityInternal::star_coloring2().
Referenced by casadi::SparsityInternal::star_coloring2().
| Sparsity casadi::Sparsity::star_coloring_new | ( | std::vector< casadi_int > & | which_color, |
| const Dict & | opts = Dict() |
||
| ) | const |
Front end to star_coloring and star_coloring2 for compressed Hessian evaluation. A non-symmetric pattern raises an error.
| opts | Options: "new_algo" (bool, default false) selects star_coloring2 instead of star_coloring; "largest_first" (bool, default true) selects the largest-first ordering; "cutoff" (int) returns a null pattern when more colors are needed |
>>> H = Sparsity.banded(4, 1)
>>> coloring, which_color = H.star_coloring_new()
>>> DM(coloring, 1)
DM(
[[00, 1, 00],
[1, 00, 00],
[00, 1, 00],
[00, 00, 1]])
>>> for k in range(H.nnz()): print(H.row()[k], H.get_col()[k], which_color[k])
0 0 1
1 0 -1
0 1 0
1 1 0
2 1 0
1 2 -1
2 2 1
3 2 1
2 3 -1
3 3 2
>>> try: Sparsity.upper(3).star_coloring_new()
... except Exception as e: print("not symmetric")
not symmetric
>> H = Sparsity.banded(4, 1);
>> [coloring, which_color] = H.star_coloring_new();
>> DM(coloring, 1)
[[00, 1, 00],
[1, 00, 00],
[00, 1, 00],
[00, 00, 1]]
>> [H.row(); H.get_col(); which_color]'
0 0 1
1 0 -1
0 1 0
1 1 0
2 1 0
1 2 -1
2 2 1
3 2 1
2 3 -1
3 3 2
>> try, Sparsity.upper(3).star_coloring_new(); catch e, disp('not symmetric'); end
not symmetric
julia> H = ca.Sparsity.banded(4, 1);
julia> ca.star_coloring_new(H)
(4x3,4nz, [1, -1, 0, 0, 0, -1, 1, 1, -1, 2])
julia> try
ca.star_coloring_new(ca.Sparsity.upper(3))
catch e
println("not symmetric")
end
not symmetric
Extra doc: https://github.com/casadi/casadi/wiki/L_2jz
Definition at line 772 of file sparsity.cpp.
References casadi::SparsityInternal::star_coloring_new().
Referenced by casadi::FmuFunction::init().
| Sparsity casadi::Sparsity::sub | ( | const std::vector< casadi_int > & | rr, |
| const Sparsity & | sp, | ||
| std::vector< casadi_int > & | mapping, | ||
| bool | ind1 = false |
||
| ) | const |
rr lists one flat (column-major) element index per nonzero of sp. The result has the shape of sp and keeps the nonzeros of sp whose element in this pattern is a structural nonzero. This is the sparsity counterpart of indexing a matrix with a Sparsity or with a list of element indices.
| rr | Flat element indices, length sp.nnz(); negative indices count from the end, out of range raises an error |
| sp | Pattern that lays out the result |
| ind1 | If true, indices are one-based |
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
>>> sub, mapping = sp.sub([0, 2, 9], Sparsity.dense(3, 1))
>>> sub, mapping
(Sparsity(3x1), [0, 1, 3])
>>> sub, mapping = sp.sub([0, 1, 2, 3], Sparsity.dense(2, 2))
>>> DM(sub, 1), mapping
(DM(
[[1, 1],
[00, 00]]), [0, 1])
>>> try: sp.sub([0, 2], Sparsity.dense(3, 1))
... except Exception as e: print("length mismatch")
length mismatch
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
>> [sub, mapping] = sp.sub([0, 2, 9], Sparsity.dense(3, 1)); disp(sub), disp(mapping)
3x1
0 1 3
>> [sub, mapping] = sp.sub([0, 1, 2, 3], Sparsity.dense(2, 2));
>> DM(sub, 1), mapping
[[1, 1],
[00, 00]]
0 1
>> try, sp.sub([0, 2], Sparsity.dense(3, 1)); catch e, disp('length mismatch'); end
length mismatch
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
julia> ca.sub(sp, [0, 2, 9], ca.Sparsity.dense(3, 1))
(3x1, [0, 1, 3])
julia> ca.sub(sp, [0, 1, 2, 3], ca.Sparsity.dense(2, 2))
(2x2,2nz, [0, 1])
julia> try
ca.sub(sp, [0, 2], ca.Sparsity.dense(3, 1))
catch e
println("length mismatch")
end
length mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_cj
Definition at line 331 of file sparsity.cpp.
References casadi::SparsityInternal::sub().
| 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 |
This is the sparsity counterpart of slicing a matrix as A[rr, cc]. Indices may repeat and may be negative (counting from the end); an index out of range raises an error.
| rr | Row indices of the submatrix |
| cc | Column indices of the submatrix |
| ind1 | If true, indices are one-based |
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3])
>>> sub, mapping = sp.sub([0, 2], [0, 3])
>>> DM(sub, 1), mapping
(DM(
[[1, 1],
[1, 00]]), [0, 1, 3])
>>> sub, mapping = sp.sub([-1], [0])
>>> sub, mapping
(Sparsity(1x1), [1])
>>> sub, mapping = sp.sub([0, 0], [0])
>>> sub, mapping
(Sparsity(2x1), [0, 0])
>>> try: sp.sub([3], [0])
... except Exception as e: print("out of range")
out of range
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
>> [sub, mapping] = sp.sub([0, 2], [0, 3]); disp(DM(sub, 1)), disp(mapping)
[[1, 1],
[1, 00]]
0 1 3
>> [sub, mapping] = sp.sub(-1, 0); disp(sub), disp(mapping)
1x1
1
>> [sub, mapping] = sp.sub([0, 0], 0); disp(sub), disp(mapping)
2x1
0 0
>> try, sp.sub(3, 0); catch e, disp('out of range'); end
out of range
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]);
julia> ca.sub(sp, [0, 2], [0, 3])
(2x2,3nz, [0, 1, 3])
julia> ca.sub(sp, [-1], [0])
(1x1, [1])
julia> ca.sub(sp, [0, 0], [0])
(2x1, [0, 0])
julia> try
ca.sub(sp, [3], [0])
catch e
println("out of range")
end
out of range
Extra doc: https://github.com/casadi/casadi/wiki/L_ci
Definition at line 336 of file sparsity.cpp.
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().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1730 of file sparsity.cpp.
References dense(), mtimes(), and size1().
Referenced by casadi::SparsityInternal::is_compactible().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1726 of file sparsity.cpp.
References dense(), mtimes(), and size2().
Referenced by casadi::SparsityInternal::is_compactible().
|
inherited |
Definition at line 105 of file generic_shared_impl.hpp.
| Sparsity casadi::Sparsity::T | ( | ) | const |
In Python, T is a property (sp.T); the method transpose() also returns the nonzero reordering.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> DM(sp.T, 1) DM( [[1, 00, 1], [00, 00, 00], [00, 1, 00], [1, 00, 00]]) >>> sp.T.colind(), sp.T.row() ([0, 2, 3, 4], [0, 3, 2, 0]) >>> Sparsity.dense(2, 3).T, Sparsity(0, 3).T (Sparsity(3x2), Sparsity(3x0))
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> DM(sp.T, 1) [[1, 00, 1], [00, 00, 00], [00, 1, 00], [1, 00, 00]] >> sp.T.colind(), sp.T.row() 0 2 3 4 0 3 2 0 >> Sparsity.dense(2, 3).T, Sparsity(0, 3).T 3x2 3x0
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.DM(ca.T(sp), 1) DM( [[1, 00, 1], [00, 00, 00], [00, 1, 00], [1, 00, 00]]) julia> ca.colind(ca.T(sp)), ca.row(ca.T(sp)) ([0, 2, 3, 4], [0, 3, 2, 0]) julia> ca.T(ca.Sparsity.dense(2, 3)), ca.T(ca.Sparsity(0, 3)) (3x2, 3x0)
Extra doc: https://github.com/casadi/casadi/wiki/L_2o1
Definition at line 396 of file sparsity.cpp.
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::Matrix< Scalar >::get_nz(), casadi::MX::get_nz(), casadi::FunctionInternal::get_partition(), casadi::FmuFunction::get_sparsity_out(), casadi::Onnx::import_symbolic(), 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().
|
static |
Definition at line 120 of file sparsity.cpp.
| void casadi::Sparsity::to_file | ( | const std::string & | filename, |
| const std::string & | format_hint = "" |
||
| ) | const |
The only supported format is Matrix Market ("mtx", coordinate pattern general), with one-based (row, col) pairs. The format is taken from the file extension unless format_hint is given; an unknown format raises an error. The file is overwritten.
| filename | Path of the file to write |
| format_hint | Format name, e.g. "mtx", when the extension does not tell |
>>> import os, tempfile
>>> d = tempfile.mkdtemp()
>>> f = os.path.join(d, "pattern.mtx")
>>> sp = Sparsity.triplet(3, 2, [0, 2, 1], [0, 0, 1])
>>> sp.to_file(f)
>>> print(open(f).read())
%%MatrixMarket matrix coordinate pattern general
3 2 3
1 1
3 1
2 2
>>> print(Sparsity.from_file(f) == sp)
True
>>> os.remove(f); os.rmdir(d)
>>> try: sp.to_file("pattern.txt")
... except Exception as e: print("unknown extension")
unknown extension
>> f = [tempname '.mtx'];
>> sp = Sparsity.triplet(3, 2, [0, 2, 1], [0, 0, 1]);
>> sp.to_file(f);
>> fileread(f)
%%MatrixMarket matrix coordinate pattern general
3 2 3
1 1
3 1
2 2
>> Sparsity.from_file(f) == sp
1
>> delete(f);
>> try, sp.to_file('pattern.txt'); catch e, disp('unknown extension'); end
unknown extension
julia> d = mktempdir();
julia> f = joinpath(d, "pattern.mtx");
julia> sp = ca.Sparsity.triplet(3, 2, [0, 2, 1], [0, 0, 1]);
julia> ca.to_file(sp, f)
julia> print(read(f, String))
%%MatrixMarket matrix coordinate pattern general
3 2 3
1 1
3 1
2 2
julia> ca.is_equal(ca.Sparsity.from_file(f), sp)
true
julia> rm(d, recursive=true)
julia> try
ca.to_file(sp, "pattern.txt")
catch e
println("unknown extension")
end
unknown extension
Extra doc: https://github.com/casadi/casadi/wiki/L_2ns
Definition at line 2002 of file sparsity.cpp.
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().
| Sparsity casadi::Sparsity::transpose | ( | std::vector< casadi_int > & | mapping, |
| bool | invert_mapping = false |
||
| ) | const |
| invert_mapping | Direction of the mapping |
invert_mapping true, mapping[k] is the nonzero of the transpose that original nonzero k becomes.
>>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]) >>> spT, mapping = sp.transpose() >>> spT, mapping (Sparsity(4x3,4nz), [0, 3, 2, 1])
>> sp = Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); >> [spT, mapping] = sp.transpose(); disp(spT), disp(mapping) 4x3,4nz 0 3 2 1
julia> sp = ca.Sparsity.triplet(3, 4, [0, 2, 1, 0], [0, 0, 2, 3]); julia> ca.transpose(sp, false) (4x3,4nz, [0, 3, 2, 1])
Extra doc: https://github.com/casadi/casadi/wiki/L_ck
Definition at line 392 of file sparsity.cpp.
References casadi::SparsityInternal::transpose().
Referenced by casadi::XFunction< DerivedType, MatType, NodeType >::jac(), and casadi::Conic::sdp_to_socp_init().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1008 of file sparsity.cpp.
References casadi::SparsityInternal::_tril().
Referenced by casadi::Convexify::setup(), and casadi::GenericMatrix< MatType >::tril().
|
static |
The entries may be given in any order; duplicates are merged. An index out of range or vectors of different length raise an error.
| nrow | Number of rows |
| ncol | Number of columns |
| row | Row index of each entry, in [0, nrow) |
| col | Column index of each entry, in [0, ncol), same length as row |
| invert_mapping | Selects the direction of the returned mapping (see below) |
The overload with invert_mapping additionally returns a mapping between the given entries and the nonzeros of the result (which are in column-major order). With invert_mapping false, mapping[k] is the position in the input of nonzero k (length nnz(); for duplicates the first occurrence). With invert_mapping true, mapping[i] is the nonzero index of input entry i (length of the input).
>>> DM(Sparsity.triplet(3, 3, [0, 2, 1], [0, 0, 2]), 1)
DM(
[[1, 00, 00],
[00, 00, 1],
[1, 00, 00]])
>>> Sparsity.triplet(2, 2, [0, 0, 1], [0, 0, 1]).nnz()
2
>>> sp, mapping = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], False)
>>> mapping
[1, 2, 0]
>>> sp, mapping = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], True)
>>> mapping
[2, 0, 1]
>>> try: Sparsity.triplet(2, 2, [0, 2], [0, 0])
... except Exception as e: print("out of bounds")
out of bounds
>> DM(Sparsity.triplet(3, 3, [0, 2, 1], [0, 0, 2]), 1)
[[1, 00, 00],
[00, 00, 1],
[1, 00, 00]]
>> Sparsity.triplet(2, 2, [0, 0, 1], [0, 0, 1]).nnz()
2
>> [sp, mapping] = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], false); disp(mapping)
1 2 0
>> [sp, mapping] = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], true); disp(mapping)
2 0 1
>> try, Sparsity.triplet(2, 2, [0, 2], [0, 0]); catch e, disp('out of bounds'); end
out of bounds
julia> ca.DM(ca.Sparsity.triplet(3, 3, [0, 2, 1], [0, 0, 2]), 1)
DM(
[[1, 00, 00],
[00, 00, 1],
[1, 00, 00]])
julia> ca.nnz(ca.Sparsity.triplet(2, 2, [0, 0, 1], [0, 0, 1]))
2
julia> sp, mapping = ca.Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], false);
julia> mapping
3-element Vector{Int64}:
1
2
0
julia> sp, mapping = ca.Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], true);
julia> mapping
3-element Vector{Int64}:
2
0
1
julia> try
ca.Sparsity.triplet(2, 2, [0, 2], [0, 0])
catch e
println("out of bounds")
end
out of bounds
Extra doc: https://github.com/casadi/casadi/wiki/L_bm
Definition at line 1309 of file sparsity.cpp.
|
static |
The entries may be given in any order; duplicates are merged. An index out of range or vectors of different length raise an error.
| nrow | Number of rows |
| ncol | Number of columns |
| row | Row index of each entry, in [0, nrow) |
| col | Column index of each entry, in [0, ncol), same length as row |
| invert_mapping | Selects the direction of the returned mapping (see below) |
The overload with invert_mapping additionally returns a mapping between the given entries and the nonzeros of the result (which are in column-major order). With invert_mapping false, mapping[k] is the position in the input of nonzero k (length nnz(); for duplicates the first occurrence). With invert_mapping true, mapping[i] is the nonzero index of input entry i (length of the input).
>>> DM(Sparsity.triplet(3, 3, [0, 2, 1], [0, 0, 2]), 1)
DM(
[[1, 00, 00],
[00, 00, 1],
[1, 00, 00]])
>>> Sparsity.triplet(2, 2, [0, 0, 1], [0, 0, 1]).nnz()
2
>>> sp, mapping = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], False)
>>> mapping
[1, 2, 0]
>>> sp, mapping = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], True)
>>> mapping
[2, 0, 1]
>>> try: Sparsity.triplet(2, 2, [0, 2], [0, 0])
... except Exception as e: print("out of bounds")
out of bounds
>> DM(Sparsity.triplet(3, 3, [0, 2, 1], [0, 0, 2]), 1)
[[1, 00, 00],
[00, 00, 1],
[1, 00, 00]]
>> Sparsity.triplet(2, 2, [0, 0, 1], [0, 0, 1]).nnz()
2
>> [sp, mapping] = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], false); disp(mapping)
1 2 0
>> [sp, mapping] = Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], true); disp(mapping)
2 0 1
>> try, Sparsity.triplet(2, 2, [0, 2], [0, 0]); catch e, disp('out of bounds'); end
out of bounds
julia> ca.DM(ca.Sparsity.triplet(3, 3, [0, 2, 1], [0, 0, 2]), 1)
DM(
[[1, 00, 00],
[00, 00, 1],
[1, 00, 00]])
julia> ca.nnz(ca.Sparsity.triplet(2, 2, [0, 0, 1], [0, 0, 1]))
2
julia> sp, mapping = ca.Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], false);
julia> mapping
3-element Vector{Int64}:
1
2
0
julia> sp, mapping = ca.Sparsity.triplet(3, 3, [2, 0, 1], [1, 0, 0], true);
julia> mapping
3-element Vector{Int64}:
2
0
1
julia> try
ca.Sparsity.triplet(2, 2, [0, 2], [0, 0])
catch e
println("out of bounds")
end
out of bounds
Extra doc: https://github.com/casadi/casadi/wiki/L_bm
Definition at line 1157 of file sparsity.cpp.
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().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1012 of file sparsity.cpp.
References casadi::SparsityInternal::_triu().
Referenced by casadi::OsqpInterface::codegen_init_mem(), casadi::OsqpInterface::init_mem(), casadi::Convexify::setup(), and casadi::GenericMatrix< MatType >::triu().
|
inlinestatic |
Definition at line 5925 of file sparsity.hpp.
| Sparsity casadi::Sparsity::uni_coloring | ( | const Sparsity & | AT = Sparsity(), |
| casadi_int | cutoff = std::numeric_limits<casadi_int>::max() |
||
| ) | const |
Greedy distance-2 coloring (Algorithm 3.1 in Gebremedhin, Manne and Pothen, What Color Is Your Jacobian?, SIAM Rev. 47(4), 2006): columns that have no row in common may share a color, so that one directional derivative per color recovers all nonzeros. This is the coloring used for forward-mode Jacobians (and, applied to the transpose, for reverse mode).
| AT | The transpose of this pattern, if already available; a null Sparsity (default) computes it |
| cutoff | If more than this many colors are needed, a null Sparsity is returned instead |
>>> A = Sparsity.triplet(3, 4, [0, 1, 2, 0], [0, 1, 2, 3]) >>> DM(A, 1) DM( [[1, 00, 00, 1], [00, 1, 00, 00], [00, 00, 1, 00]]) >>> c = A.uni_coloring() >>> DM(c, 1) DM( [[1, 00], [1, 00], [1, 00], [00, 1]]) >>> c.size2(), [c.row()[c.colind()[j]:c.colind()[j + 1]] for j in range(c.size2())] (2, [[0, 1, 2], [3]]) >>> A.uni_coloring(Sparsity(), 1).is_null() True >>> Sparsity.dense(3, 3).uni_coloring(), Sparsity.diag(3).uni_coloring() (Sparsity(3x3,3nz), Sparsity(3x1))
>> A = Sparsity.triplet(3, 4, [0, 1, 2, 0], [0, 1, 2, 3]); >> DM(A, 1) [[1, 00, 00, 1], [00, 1, 00, 00], [00, 00, 1, 00]] >> c = A.uni_coloring(); >> DM(c, 1) [[1, 00], [1, 00], [1, 00], [00, 1]] >> disp(c.size2()), ci = c.colind(); r = c.row(); 2 >> for j = 1:c.size2(), disp(r(ci(j) + 1:ci(j + 1))), end 0 1 2 3 >> A.uni_coloring(Sparsity(), 1).is_null() 1 >> Sparsity.dense(3, 3).uni_coloring(), Sparsity.diag(3).uni_coloring() 3x3,3nz 3x1
julia> A = ca.Sparsity.triplet(3, 4, [0, 1, 2, 0], [0, 1, 2, 3]); julia> ca.DM(A, 1) DM( [[1, 00, 00, 1], [00, 1, 00, 00], [00, 00, 1, 00]]) julia> c = ca.uni_coloring(A, ca.Sparsity(), 1000); julia> ca.DM(c, 1) DM( [[1, 00], [1, 00], [1, 00], [00, 1]]) julia> ca.size2(c), [ca.row(c)[ca.colind(c)[j]+1:ca.colind(c)[j+1]] for j in 1:ca.size2(c)] (2, [[0, 1, 2], [3]]) julia> ca.is_null(ca.uni_coloring(A, ca.Sparsity(), 1)) true julia> ca.uni_coloring(ca.Sparsity.dense(3, 3), ca.Sparsity(), 1000) Sparsity(3x3,3nz) julia> ca.uni_coloring(ca.Sparsity.diag(3), ca.Sparsity(), 1000) Sparsity(3x1)
Extra doc: https://github.com/casadi/casadi/wiki/L_db
Definition at line 764 of file sparsity.cpp.
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().
|
static |
| n | Length of the column vector |
| el | Row of the nonzero, in [0, n); an index outside this range raises an error |
>>> DM(Sparsity.unit(4, 1), 1) DM([00, 1, 00, 00]) >>> Sparsity.unit(4, 1).row() [1]
>> DM(Sparsity.unit(4, 1), 1) [00, 1, 00, 00] >> Sparsity.unit(4, 1).row() 1
julia> ca.DM(ca.Sparsity.unit(4, 1), 1)
DM([00, 1, 00, 00])
julia> ca.row(ca.Sparsity.unit(4, 1))
1-element Vector{Int64}:
1
Extra doc: https://github.com/casadi/casadi/wiki/L_bf
Definition at line 1134 of file sparsity.cpp.
References colind(), row(), and Sparsity().
Referenced by casadi::SuperscsInterface::init().
The pattern of x + y for matrices with these patterns. A shape mismatch raises an error.
>>> a = Sparsity.diag(2)
>>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1])
>>> DM(a.unite(b), 1)
DM(
[[1, 1],
[00, 1]])
>>> a + b == a.unite(b), a * b == a.intersect(b)
(True, True)
>>> try: a + Sparsity.dense(3, 3)
... except Exception as e: print("dimension mismatch")
dimension mismatch
>> a = Sparsity.diag(2);
>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]);
>> DM(a.unite(b), 1)
[[1, 1],
[00, 1]]
>> a + b == a.unite(b), a .* b == a.intersect(b)
1
1
>> try, a + Sparsity.dense(3, 3); catch e, disp('dimension mismatch'); end
dimension mismatch
julia> a = ca.Sparsity.diag(2);
julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]);
julia> ca.DM(ca.unite(a, b), 1)
DM(
[[1, 1],
[00, 1]])
julia> try
ca.unite(a, ca.Sparsity.dense(3, 3))
catch e
println("dimension mismatch")
end
dimension mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_cm
Definition at line 415 of file sparsity.cpp.
References casadi::SparsityInternal::combine().
| Sparsity casadi::Sparsity::unite | ( | const Sparsity & | y, |
| std::vector< unsigned char > & | mapping | ||
| ) | const |
The pattern of x + y for matrices with these patterns. A shape mismatch raises an error.
>>> a = Sparsity.diag(2)
>>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1])
>>> DM(a.unite(b), 1)
DM(
[[1, 1],
[00, 1]])
>>> a + b == a.unite(b), a * b == a.intersect(b)
(True, True)
>>> try: a + Sparsity.dense(3, 3)
... except Exception as e: print("dimension mismatch")
dimension mismatch
>> a = Sparsity.diag(2);
>> b = Sparsity.triplet(2, 2, [0, 1], [1, 1]);
>> DM(a.unite(b), 1)
[[1, 1],
[00, 1]]
>> a + b == a.unite(b), a .* b == a.intersect(b)
1
1
>> try, a + Sparsity.dense(3, 3); catch e, disp('dimension mismatch'); end
dimension mismatch
julia> a = ca.Sparsity.diag(2);
julia> b = ca.Sparsity.triplet(2, 2, [0, 1], [1, 1]);
julia> ca.DM(ca.unite(a, b), 1)
DM(
[[1, 1],
[00, 1]])
julia> try
ca.unite(a, ca.Sparsity.dense(3, 3))
catch e
println("dimension mismatch")
end
dimension mismatch
Extra doc: https://github.com/casadi/casadi/wiki/L_cm
Definition at line 411 of file sparsity.cpp.
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().
|
static |
Column j contains the rows 0, ..., j, so the diagonal is included and the pattern has n*(n+1)/2 nonzeros.
| n | Size of the square pattern, nonnegative |
>>> DM(Sparsity.upper(3), 1) DM( [[1, 1, 1], [00, 1, 1], [00, 00, 1]]) >>> Sparsity.upper(3).nnz(), Sparsity.upper(3).is_triu() (6, True)
>> DM(Sparsity.upper(3), 1) [[1, 1, 1], [00, 1, 1], [00, 00, 1]] >> Sparsity.upper(3).nnz(), Sparsity.upper(3).is_triu() 6 1
julia> ca.DM(ca.Sparsity.upper(3), 1) DM( [[1, 1, 1], [00, 1, 1], [00, 00, 1]]) julia> ca.nnz(ca.Sparsity.upper(3)), ca.is_triu(ca.Sparsity.upper(3)) (6, true)
Extra doc: https://github.com/casadi/casadi/wiki/L_bg
Definition at line 1057 of file sparsity.cpp.
References colind(), row(), and Sparsity().
Referenced by casadi::Convexify::setup().
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1567 of file sparsity.cpp.
References nnz(), size2(), Sparsity(), and triplet().
Referenced by append(), and blockcat().
|
static |
Extra doc: https://github.com/casadi/casadi/wiki/L_cq
Definition at line 1679 of file sparsity.cpp.
References horzsplit(), casadi::SparsityInterface< Sparsity >::offset(), and T().
|
inherited |
Extra doc: https://github.com/casadi/casadi/wiki/L_aw
Definition at line 130 of file generic_shared_impl.hpp.
|
static |
Definition at line 6068 of file sparsity.hpp.
Referenced by file_format(), from_file(), and to_file().