gko::matrix::SparsityCsr#

Sparsity pattern only — CSR row pointers and column indices, no values. Used wherever an algorithm needs the structure of a matrix but not its numerical entries: reordering, fill-in analysis, graph algorithms, and the sparsity-reuse path for repeated SpGEMM.

template<typename ValueType = default_precision, typename IndexType = int32>
class SparsityCsr #

Inherits from

  • public gko::EnableLinOp<SparsityCsr<default_precision, int32>>

  • public ConvertibleTo<Csr<default_precision, int32>>

  • public ConvertibleTo<Dense<default_precision>>

  • public gko::ReadableFromMatrixData<default_precision, int32>

  • public gko::WritableToMatrixData<default_precision, int32>

  • public gko::Transposable

SparsityCsr is a matrix format which stores only the sparsity pattern of a sparse matrix by compressing each row of the matrix (compressed sparse row format).

The values of the nonzero elements are stored as a value array of length 1. All the values in the matrix are equal to this value. By default, this value is set to 1.0. A row pointer array also stores the linearized starting index of each row. An additional column index array is used to identify the column where a nonzero is present.

Template Parameters:

  • ValueType – precision of vectors in apply

  • IndexType – precision of matrix indexes

Public Functions

virtual std::unique_ptr<LinOp> transpose() const override#

Returns a LinOp representing the transpose of the Transposable object.

Returns:

a pointer to the new transposed object

virtual std::unique_ptr<LinOp> conj_transpose() const override#

Returns a LinOp representing the conjugate transpose of the Transposable object.

Returns:

a pointer to the new conjugate transposed object

std::unique_ptr<SparsityCsr> to_adjacency_matrix() const#

Transforms the sparsity matrix to an adjacency matrix. As the adjacency matrix has to be square, the input SparsityCsr matrix for this function to work has to be square.

Note

The adjacency matrix in this case is the sparsity pattern but with the diagonal ones removed. This is mainly used for the reordering/partitioning as taken in by graph libraries such as METIS.

void sort_by_column_index()#

Sorts each row by column index

inline index_type *get_col_idxs() noexcept#

Returns the column indices of the matrix.

Returns:

the column indices of the matrix.

inline const index_type *get_const_col_idxs() const noexcept#

Returns the column indices of the matrix.

Note

This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

Returns:

the column indices of the matrix.

inline index_type *get_row_ptrs() noexcept#

Returns the row pointers of the matrix.

Returns:

the row pointers of the matrix.

inline const index_type *get_const_row_ptrs() const noexcept#

Returns the row pointers of the matrix.

Note

This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

Returns:

the row pointers of the matrix.

inline value_type *get_value() noexcept#

Returns the value stored in the matrix.

Returns:

the value of the matrix.

inline const value_type *get_const_value() const noexcept#

Returns the value stored in the matrix.

Note

This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

Returns:

the value of the matrix.

inline size_type get_num_nonzeros() const noexcept#

Returns the number of elements explicitly stored in the matrix.

Returns:

the number of elements explicitly stored in the matrix

SparsityCsr &operator=(const SparsityCsr&)#

Copy-assigns a SparsityCsr matrix. Preserves executor, copies everything else.

SparsityCsr &operator=(SparsityCsr&&)#

Move-assigns a SparsityCsr matrix. Preserves executor, moves the data and leaves the moved-from object in an empty state (0x0 LinOp with unchanged executor, no nonzeros and valid row pointers).

SparsityCsr(const SparsityCsr&)#

Copy-constructs a SparsityCsr matrix. Inherits executor, strategy and data.

SparsityCsr(SparsityCsr&&)#

Move-constructs a SparsityCsr matrix. Inherits executor, moves the data and leaves the moved-from object in an empty state (0x0 LinOp with unchanged executor, no nonzeros and valid row pointers).

Public Static Functions

static std::unique_ptr<SparsityCsr> create(
std::shared_ptr<const Executor> exec,
const dim<2> &size = dim<2>{},
size_type num_nonzeros = {},
)#

Creates an uninitialized SparsityCsr matrix of the specified size.

Parameters:

  • exec – Executor associated to the matrix

  • size – size of the matrix

  • num_nonzeros – number of nonzeros

static std::unique_ptr<SparsityCsr> create(
std::shared_ptr<const Executor> exec,
const dim<2> &size,
array<index_type> col_idxs,
array<index_type> row_ptrs,
value_type value = one<ValueType>(),
)#

Creates a SparsityCsr matrix from already allocated (and initialized) row pointer and column index arrays.

Note

If one of row_ptrs or col_idxs is not an rvalue, not an array of IndexType and IndexType respectively, or is on the wrong executor, an internal copy of that array will be created, and the original array data will not be used in the matrix.

Template Parameters:

  • ColIdxsArray – type of col_idxs array

  • RowPtrsArray – type of row_ptrs array

Parameters:

  • exec – Executor associated to the matrix

  • size – size of the matrix

  • col_idxs – array of column indexes

  • row_ptrs – array of row pointers

  • value – value stored. (same value for all matrix elements)

template<typename ColIndexType, typename RowPtrType>
static inline std::unique_ptr<SparsityCsr> create(
std::shared_ptr<const Executor> exec,
const dim<2> &size,
std::initializer_list<ColIndexType> col_idxs,
std::initializer_list<RowPtrType> row_ptrs,
value_type value = one<ValueType>(),
)#

create(std::shared_ptr<constExecutor>, const dim<2>&, array<index_type>, array<index_type>,value_type)

create(std::shared_ptr<constExecutor>, const dim<2>&, array<index_type>, array<index_type>,value_type)

static std::unique_ptr<SparsityCsr> create(
std::shared_ptr<const Executor> exec,
std::shared_ptr<const LinOp> matrix,
)#

Creates a Sparsity matrix from an existing matrix. Uses the copy_and_convert_to functionality.

Parameters:

  • exec – Executor associated to the matrix

  • matrix – The input matrix

static inline std::unique_ptr<const SparsityCsr> create_const(
std::shared_ptr<const Executor> exec,
const dim<2> &size,
gko::detail::const_array_view<IndexType> &&col_idxs,
gko::detail::const_array_view<IndexType> &&row_ptrs,
ValueType value = one<ValueType>(),
)#

Creates a constant (immutable) SparsityCsr matrix from constant arrays.

Parameters:

  • exec – the executor to create the matrix on

  • size – the dimensions of the matrix

  • values – the value array of the matrix

  • col_idxs – the column index array of the matrix

  • row_ptrs – the row pointer array of the matrix

  • strategy – the strategy the matrix uses for SpMV operations

Returns:

A smart pointer to the constant matrix wrapping the input arrays (if they reside on the same executor as the matrix) or a copy of these arrays on the correct executor.