|
Scalar | coeff (Index row, Index col) const |
|
Scalar & | coeffRef (Index row, Index col) |
|
template<typename DupFunctor > |
void | collapseDuplicates (DupFunctor dup_func=DupFunctor()) |
|
Index | cols () const |
|
void | conservativeResize (Index rows, Index cols) |
|
Storage & | data () |
|
const Storage & | data () const |
|
DiagonalReturnType | diagonal () |
|
const ConstDiagonalReturnType | diagonal () const |
|
void | finalize () |
|
StorageIndex * | innerIndexPtr () |
|
const StorageIndex * | innerIndexPtr () const |
|
StorageIndex * | innerNonZeroPtr () |
|
const StorageIndex * | innerNonZeroPtr () const |
|
Index | innerSize () const |
|
Scalar & | insert (Index row, Index col) |
|
Scalar & | insertBack (Index row, Index col) |
|
Scalar & | insertBackByOuterInner (Index outer, Index inner) |
|
Scalar & | insertBackByOuterInnerUnordered (Index outer, Index inner) |
|
EIGEN_STRONG_INLINE Scalar & | insertBackUncompressed (Index row, Index col) |
|
Scalar & | insertByOuterInner (Index j, Index i) |
|
bool | isCompressed () const |
|
void | makeCompressed () |
|
Index | nonZeros () const |
|
template<typename OtherDerived > |
SparseMatrix & | operator= (const EigenBase< OtherDerived > &other) |
|
template<typename Lhs , typename Rhs > |
SparseMatrix & | operator= (const Product< Lhs, Rhs, AliasFreeProduct > &other) |
|
template<typename Lhs , typename Rhs > |
SparseMatrix< Scalar, _Options, _StorageIndex > & | operator= (const Product< Lhs, Rhs, AliasFreeProduct > &src) |
|
SparseMatrix & | operator= (const SparseMatrix &other) |
|
template<typename OtherDerived > |
EIGEN_DONT_INLINE SparseMatrix & | operator= (const SparseMatrixBase< OtherDerived > &other) |
|
template<typename OtherDerived > |
EIGEN_DONT_INLINE SparseMatrix< Scalar, _Options, _StorageIndex > & | operator= (const SparseMatrixBase< OtherDerived > &other) |
|
StorageIndex * | outerIndexPtr () |
|
const StorageIndex * | outerIndexPtr () const |
|
Index | outerSize () const |
|
template<typename KeepFunc > |
void | prune (const KeepFunc &keep=KeepFunc()) |
|
void | prune (const Scalar &reference, const RealScalar &epsilon=NumTraits< RealScalar >::dummy_precision()) |
|
template<class SizesType > |
void | reserve (const SizesType &reserveSizes, const typename SizesType::value_type &enableif=typename SizesType::value_type()) |
|
void | reserve (Index reserveSize) |
|
void | resize (Index rows, Index cols) |
|
void | resizeNonZeros (Index size) |
|
Index | rows () const |
|
template<typename InputIterators > |
void | setFromTriplets (const InputIterators &begin, const InputIterators &end) |
|
template<typename InputIterators , typename DupFunctor > |
void | setFromTriplets (const InputIterators &begin, const InputIterators &end, DupFunctor dup_func) |
|
void | setIdentity () |
|
void | setZero () |
|
| SparseMatrix () |
|
template<typename OtherDerived > |
| SparseMatrix (const DiagonalBase< OtherDerived > &other) |
| Copy constructor with in-place evaluation. More...
|
|
template<typename OtherDerived > |
| SparseMatrix (const ReturnByValue< OtherDerived > &other) |
| Copy constructor with in-place evaluation. More...
|
|
| SparseMatrix (const SparseMatrix &other) |
|
template<typename OtherDerived > |
| SparseMatrix (const SparseMatrixBase< OtherDerived > &other) |
|
template<typename OtherDerived , unsigned int UpLo> |
| SparseMatrix (const SparseSelfAdjointView< OtherDerived, UpLo > &other) |
|
| SparseMatrix (Index rows, Index cols) |
|
void | startVec (Index outer) |
|
Scalar | sum () const |
|
void | sumupDuplicates () |
|
void | swap (SparseMatrix &other) |
|
void | uncompress () |
|
Scalar * | valuePtr () |
|
const Scalar * | valuePtr () const |
|
| ~SparseMatrix () |
|
Map< Array< Scalar, Dynamic, 1 > > | coeffs () |
|
const Map< const Array< Scalar, Dynamic, 1 > > | coeffs () const |
|
StorageIndex * | innerIndexPtr () |
|
const StorageIndex * | innerIndexPtr () const |
|
StorageIndex * | innerNonZeroPtr () |
|
const StorageIndex * | innerNonZeroPtr () const |
|
bool | isCompressed () const |
|
Index | nonZeros () const |
|
Derived & | operator= (const Derived &other) |
|
Derived & | operator= (const Derived &other) |
|
Derived & | operator= (const EigenBase< OtherDerived > &other) |
|
Derived & | operator= (const ReturnByValue< OtherDerived > &other) |
|
Derived & | operator= (const SparseMatrixBase< OtherDerived > &other) |
|
StorageIndex * | outerIndexPtr () |
|
const StorageIndex * | outerIndexPtr () const |
|
Scalar * | valuePtr () |
|
const Scalar * | valuePtr () const |
|
template<typename _Scalar, int _Options, typename _StorageIndex>
class Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >
A versatible sparse matrix representation.
This class implements a more versatile variants of the common compressed row/column storage format. Each colmun's (resp. row) non zeros are stored as a pair of value with associated row (resp. colmiun) index. All the non zeros are stored in a single large buffer. Unlike the compressed format, there might be extra space in between the nonzeros of two successive colmuns (resp. rows) such that insertion of new non-zero can be done with limited memory reallocation and copies.
A call to the function makeCompressed() turns the matrix into the standard compressed format compatible with many library.
More details on this storage sceheme are given in the manual pages.
- Template Parameters
-
_Scalar | the scalar type, i.e. the type of the coefficients |
_Options | Union of bit flags controlling the storage scheme. Currently the only possibility is ColMajor or RowMajor. The default is 0 which means column-major. |
_StorageIndex | the type of the indices. It has to be a signed type (e.g., short, int, std::ptrdiff_t). Default is int . |
- Warning
- In Eigen 3.2, the undocumented type
SparseMatrix::Index
was improperly defined as the storage index type (e.g., int), whereas it is now (starting from Eigen 3.3) deprecated and always defined as Eigen::Index. Codes making use of SparseMatrix::Index
, might thus likely have to be changed to use SparseMatrix::StorageIndex
instead.
This class can be extended with the help of the plugin mechanism described on the page Extending MatrixBase (and other classes) by defining the preprocessor symbol EIGEN_SPARSEMATRIX_PLUGIN
.
Definition at line 96 of file SparseMatrix.h.
template<typename _Scalar , int _Options, typename _StorageIndex >
- Returns
- a non-const reference to the value of the matrix at position i, j
If the element does not exist then it is inserted via the insert(Index,Index) function which itself turns the matrix into a non compressed form if that was not the case.
This is a O(log(nnz_j)) operation (binary search) plus the cost of insert(Index,Index) function if the element does not already exist.
Definition at line 208 of file SparseMatrix.h.
template<typename _Scalar , int _Options, typename _StorageIndex >
- Returns
- a reference to a novel non zero coefficient with coordinates row x col. The non zero coefficient must not already exist.
If the matrix *this
is in compressed mode, then *this
is turned into uncompressed mode while reserving room for 2 x this->innerSize() non zeros if reserve(Index) has not been called earlier. In this case, the insertion procedure is optimized for a sequential insertion mode where elements are assumed to be inserted by increasing outer-indices.
If that's not the case, then it is strongly recommended to either use a triplet-list to assemble the matrix, or to first call reserve(const SizesType &) to reserve the appropriate number of non-zero elements per inner vector.
Assuming memory has been appropriately reserved, this function performs a sorted insertion in O(1) if the elements of each inner vector are inserted in increasing inner index order, and in O(nnz_j) for a random insertion.
Definition at line 1244 of file SparseMatrix.h.
template<typename Scalar , int _Options, typename _StorageIndex >
template<typename InputIterators >
void Eigen::SparseMatrix< Scalar, _Options, _StorageIndex >::setFromTriplets |
( |
const InputIterators & |
begin, |
|
|
const InputIterators & |
end |
|
) |
| |
Fill the matrix *this
with the list of triplets defined by the iterator range begin - end.
A triplet is a tuple (i,j,value) defining a non-zero element. The input list of triplets does not have to be sorted, and can contains duplicated elements. In any case, the result is a sorted and compressed sparse matrix where the duplicates have been summed up. This is a O(n) operation, with n the number of triplet elements. The initial contents of *this
is destroyed. The matrix *this
must be properly resized beforehand using the SparseMatrix(Index,Index) constructor, or the resize(Index,Index) method. The sizes are not extracted from the triplet list.
The InputIterators value_type must provide the following interface:
See for instance the Eigen::Triplet template class.
Here is a typical usage example:
typedef Triplet<double>
T;
std::vector<T> tripletList;
tripletList.reserve(estimation_of_entries);
for(...)
{
tripletList.push_back(
T(
i,
j,v_ij));
}
m.setFromTriplets(tripletList.begin(), tripletList.end());
- Warning
- The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather be explicitly stored into a std::vector for instance.
Definition at line 1108 of file SparseMatrix.h.
template<typename Scalar , int _Options, typename _StorageIndex >
template<typename InputIterators , typename DupFunctor >
void Eigen::SparseMatrix< Scalar, _Options, _StorageIndex >::setFromTriplets |
( |
const InputIterators & |
begin, |
|
|
const InputIterators & |
end, |
|
|
DupFunctor |
dup_func |
|
) |
| |
The same as setFromTriplets but when duplicates are met the functor dup_func is applied:
value = dup_func(OldValue, NewValue)
Here is a C++11 example keeping the latest entry only:
mat.setFromTriplets(triplets.begin(), triplets.end(), [] (
const Scalar&,
const Scalar &
b) { return b; });
Definition at line 1124 of file SparseMatrix.h.