Default constructor yielding an empty 0 x 0 matrix

Constructs a rows x cols empty matrix

Constructs a sparse matrix from the sparse expression other

Constructs a sparse matrix from the sparse selfadjoint view other

Copy constructor (it performs a deep copy)

Destructor

Returns

the value of the matrix at position i, j This function returns Scalar(0) if the element is an explicit zero

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.

Returns

the number of columns of the matrix

Resizes the matrix to a rows x cols matrix leaving old values untouched.

If the sizes of the matrix are decreased, then the matrix is turned to uncompressed-mode and the storage of the out of bounds coefficients is kept and reserved. Call makeCompressed() to pack the entries and squeeze extra memory.

See also

reserve(), setZero(), makeCompressed()

Returns

a read-write expression of the diagonal coefficients.

Warning

If the diagonal entries are written, then all diagonal entries must already exist, otherwise an assertion will be raised.

Returns

a const expression of the diagonal coefficients.

Returns

a non-const pointer to the array of inner indices. This function is aimed at interoperability with other libraries.

See also

valuePtr(), outerIndexPtr()

Returns

a const pointer to the array of inner indices. This function is aimed at interoperability with other libraries.

See also

valuePtr(), outerIndexPtr()

Returns

a non-const pointer to the array of the number of non zeros of the inner vectors. This function is aimed at interoperability with other libraries.

Warning

it returns the null pointer 0 in compressed mode

Returns

a const pointer to the array of the number of non zeros of the inner vectors. This function is aimed at interoperability with other libraries.

Warning

it returns the null pointer 0 in compressed mode

Returns

the number of rows (resp. columns) of the matrix if the storage order column major (resp. row major)

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.

Returns

whether *this is in compressed form.

Turns the matrix into the compressed format.

Returns

the number of non zero coefficients

Returns

a non-const pointer to the array of the starting positions of the inner vectors. This function is aimed at interoperability with other libraries.

See also

valuePtr(), innerIndexPtr()

Returns

a const pointer to the array of the starting positions of the inner vectors. This function is aimed at interoperability with other libraries.

See also

valuePtr(), innerIndexPtr()

Returns

the number of columns (resp. rows) of the matrix if the storage order column major (resp. row major)

Turns the matrix into compressed format, and suppresses all nonzeros which do not satisfy the predicate keep. The functor type KeepFunc must implement the following function:

bool operator() (const Index& row, const Index& col, const Scalar& value) const;

See also

prune(Scalar,RealScalar)

Suppresses all nonzeros which are much smaller than reference under the tolerance epsilon

Preallocates reserveSize[j] non zeros for each column (resp. row) j.

This function turns the matrix in non-compressed mode.

The type SizesType must expose the following interface:

typedef value_type;
const value_type& operator[](i) const;

for i in the [0,this->outerSize()[ range. Typical choices include std::vector<int>, Eigen::VectorXi, Eigen::VectorXi::Constant, etc.

Preallocates reserveSize non zeros.

Precondition: the matrix must be in compressed mode.

Resizes the matrix to a rows x cols matrix and initializes it to zero.

This function does not free the currently allocated memory. To release as much as memory as possible, call

mat.data().squeeze(); 

after resizing it.

See also

reserve(), setZero()

Returns

the number of rows of the matrix

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:

Scalar value() const; // the value
Scalar row() const;   // the row index i
Scalar col() const;   // the column index j

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));
}
SparseMatrixType m(rows,cols);
m.setFromTriplets(tripletList.begin(), tripletList.end());
// m is ready to go!

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.

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; });

Sets *this to the identity matrix. This function also turns the matrix into compressed mode, and drop any reserved memory.

Removes all non zeros but keep allocated memory

This function does not free the currently allocated memory. To release as much as memory as possible, call

mat.data().squeeze(); 

after resizing it.

See also

resize(Index,Index), data()

Overloaded for performance

Swaps the content of two sparse matrices of the same type. This is a fast operation that simply swaps the underlying pointers and parameters.

Turns the matrix into the uncompressed mode

Returns

a non-const pointer to the array of values. This function is aimed at interoperability with other libraries.

See also

innerIndexPtr(), outerIndexPtr()

Returns

a const pointer to the array of values. This function is aimed at interoperability with other libraries.

See also

innerIndexPtr(), outerIndexPtr()