gko::matrix::Coo#

Coordinate format. Stores nonzeros as (row, col, value) triplets in parallel arrays. Cheap to assemble and convert from, but typically converted into CSR for performance-critical operations.

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

Inherits from

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

  • public ConvertibleTo<Coo<next_precision<default_precision>, int32>>

  • public ConvertibleTo<Coo<next_precision<default_precision, 2>, int32>>

  • public ConvertibleTo<Coo<next_precision<default_precision, 3>, int32>>

  • public ConvertibleTo<Csr<default_precision, int32>>

  • public ConvertibleTo<Dense<default_precision>>

  • public gko::DiagonalExtractable<default_precision>

  • public gko::ReadableFromMatrixData<default_precision, int32>

  • public gko::WritableToMatrixData<default_precision, int32>

  • public gko::Transposable

  • public gko::EnableAbsoluteComputation<remove_complex<Coo<default_precision, int32>>>

COO stores a matrix in the coordinate matrix format.

The nonzero elements are stored in an array row-wise (but not necessarily sorted by column index within a row). Two extra arrays contain the row and column indexes of each nonzero element of the matrix.

Template Parameters:

  • ValueType – precision of matrix elements

  • 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

virtual std::unique_ptr<Diagonal<ValueType>> extract_diagonal(
) const override#

Extracts the diagonal entries of the matrix into a vector.

Parameters:

diag – the vector into which the diagonal will be written

virtual std::unique_ptr<absolute_type> compute_absolute(
) const override#

Gets the AbsoluteLinOp

Returns:

a pointer to the new absolute object

virtual void compute_absolute_inplace() override#

Compute absolute inplace on each element.

inline value_type *get_values() noexcept#

Returns the values of the matrix.

Returns:

the values of the matrix.

inline const value_type *get_const_values() const noexcept#

Returns the values 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 values of the matrix.

inline index_type *get_col_idxs() noexcept#

Returns the column indexes of the matrix.

Returns:

the column indexes of the matrix.

inline const index_type *get_const_col_idxs() const noexcept#

Returns the column indexes 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 indexes of the matrix.

inline index_type *get_row_idxs() noexcept#

Returns the row indexes of the matrix.

Returns:

the row indexes of the matrix.

inline const index_type *get_const_row_idxs() const noexcept#

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.

inline size_type get_num_stored_elements() const noexcept#

Returns the number of elements explicitly stored in the matrix.

Returns:

the number of elements explicitly stored in the matrix

device_view get_device_view()#

Returns a non-owning device view of this matrix.

Returns:

a device view of this matrix.

const_device_view get_const_device_view() const#

Returns a non-owning const device view of this matrix.

Returns:

a const device view of this matrix.

void apply2(ptr_param<const LinOp> b, ptr_param<LinOp> x)#

Applies Coo matrix axpy to a vector (or a sequence of vectors).

Performs the operation x = Coo * b + x

Parameters:

  • b – the input vector(s) on which the operator is applied

  • x – the output vector(s) where the result is stored

Returns:

this

void apply2(
ptr_param<const LinOp> alpha,
ptr_param<const LinOp> b,
ptr_param<LinOp> x,
)#

Performs the operation x = alpha * Coo * b + x.

Parameters:

  • alpha – scaling of the result of Coo * b

  • b – vector(s) on which the operator is applied

  • x – output vector(s)

Returns:

this

Public Static Functions

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

Creates an uninitialized COO matrix of the specified size.

Parameters:

  • exec – Executor associated to the matrix

  • size – size of the matrix

  • num_nonzeros – number of nonzeros

Returns:

A smart pointer to the newly created matrix.

static std::unique_ptr<Coo> create(
std::shared_ptr<const Executor> exec,
const dim<2> &size,
array<value_type> values,
array<index_type> col_idxs,
array<index_type> row_idxs,
)#

Creates a COO matrix from already allocated (and initialized) row index, column index and value arrays.

Note

If one of row_idxs, col_idxs or values is not an rvalue, not an array of IndexType, IndexType and ValueType, 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.

Parameters:

  • exec – Executor associated to the matrix

  • size – size of the matrix

  • values – array of matrix values

  • col_idxs – array of column indexes

  • row_idxs – array of row pointers

Returns:

A smart pointer to the 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.

template<typename InputValueType, typename InputColumnIndexType, typename InputRowIndexType>
static inline std::unique_ptr<Coo> create(
std::shared_ptr<const Executor> exec,
const dim<2> &size,
std::initializer_list<InputValueType> values,
std::initializer_list<InputColumnIndexType> col_idxs,
std::initializer_list<InputRowIndexType> row_idxs,
)#

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

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

static std::unique_ptr<const Coo> create_const(
std::shared_ptr<const Executor> exec,
const dim<2> &size,
gko::detail::const_array_view<ValueType> &&values,
gko::detail::const_array_view<IndexType> &&col_idxs,
gko::detail::const_array_view<IndexType> &&row_idxs,
)#

Creates a constant (immutable) Coo matrix from a set of 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 index array of the matrix

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.