gko::batch::matrix::Ell#

Batched equal-length-rows matrix. Like the non-batched gko::matrix::Ell, pads every row to the longest row’s nonzero count; in the batched form the column-index array is shared across items so only the per-item values differ.

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

Inherits from

  • public gko::batch::EnableBatchLinOp<Ell<default_precision, int32>>

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

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

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

Ell is a sparse matrix format that stores the same number of nonzeros in each row, enabling coalesced accesses. It is suitable for sparsity patterns that have a similar number of nonzeros in every row. The values are stored in a column-major fashion similar to the monolithic gko::matrix::Ell class.

Similar to the monolithic gko::matrix::Ell class, invalid_index<IndexType> is used as the column index for padded zero entries.

Note

It is also assumed that the sparsity pattern of all the items in the batch is the same and therefore only a single copy of the sparsity pattern is stored.

Note

Currently only IndexType of int32 is supported.

Template Parameters:

  • ValueType – value precision of matrix elements

  • IndexType – index precision of matrix elements

Public Functions

std::unique_ptr<unbatch_type> create_view_for_item(
size_type item_id,
)#

Creates a mutable view (of matrix::Ell type) of one item of the batch::matrix::Ell<value_type> object. Does not perform any deep copies, but only returns a view of the data.

Parameters:

item_id – The index of the batch item

Returns:

a batch::matrix::Ell object with the data from the batch item at the given index.

std::unique_ptr<const unbatch_type> create_const_view_for_item(
size_type item_id,
) const#

Creates a mutable view (of matrix::Ell type) of one item of the batch::matrix::Ell<value_type> object. Does not perform any deep copies, but only returns a view of the data.

Parameters:

item_id – The index of the batch item

Returns:

a batch::matrix::Ell object with the data from the batch item at the given index.

inline value_type *get_values() noexcept#

Returns a pointer to the array of values of the matrix

Returns:

the pointer to the array of values

inline const value_type *get_const_values() const noexcept#

Returns a pointer to the array of 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 pointer to the array of values

inline index_type *get_col_idxs() noexcept#

Returns a pointer to the array of column indices of the matrix

Returns:

the pointer to the array of column indices

inline const index_type *get_const_col_idxs() const noexcept#

Returns a pointer to the array of 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 pointer to the array of column indices

inline index_type get_num_stored_elements_per_row() const noexcept#

Returns the number of elements per row explicitly stored.

Returns:

the number of elements stored in each row of the ELL matrix. Same for each batch item

inline size_type get_num_stored_elements() const noexcept#

Returns the number of elements explicitly stored in the batch matrix, cumulative across all the batch items.

Returns:

the number of elements explicitly stored in the vector, cumulative across all the batch items

inline size_type get_num_elements_per_item() const noexcept#

Returns the number of stored elements in each batch item.

Returns:

the number of stored elements per batch item.

inline index_type *get_col_idxs_for_item(
size_type batch_id,
) noexcept#

Returns a pointer to the array of col_idxs of the matrix. This is shared across all batch items.

Parameters:

batch_id – the id of the batch item.

Returns:

the pointer to the array of col_idxs

inline const index_type *get_const_col_idxs_for_item(
size_type batch_id,
) const noexcept#

Returns a pointer to the array of col_idxs of the matrix. This is shared across all batch items.

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.

Parameters:

batch_id – the id of the batch item.

Returns:

the pointer to the array of col_idxs

inline value_type *get_values_for_item(size_type batch_id) noexcept#

Returns a pointer to the array of values of the matrix for a specific batch item.

Parameters:

batch_id – the id of the batch item.

Returns:

the pointer to the array of values

inline const value_type *get_const_values_for_item(
size_type batch_id,
) const noexcept#

Returns a pointer to the array of values of the matrix for a specific batch item.

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.

Parameters:

batch_id – the id of the batch item.

Returns:

the pointer to the array of values

void apply(
ptr_param<const MultiVector<value_type>> b,
ptr_param<MultiVector<value_type>> x,
)#

Apply the matrix to a multi-vector. Represents the matrix vector multiplication, x = A * b, where x and b are both multi-vectors.

Parameters:

  • b – the multi-vector to be applied to

  • x – the output multi-vector

void apply(
ptr_param<const MultiVector<value_type>> alpha,
ptr_param<const MultiVector<value_type>> b,
ptr_param<const MultiVector<value_type>> beta,
ptr_param<MultiVector<value_type>> x,
)#

Apply the matrix to a multi-vector with a linear combination of the given input vector. Represents the matrix vector multiplication, x = alpha * A

  • b + beta * x, where x and b are both multi-vectors.

Parameters:

  • alpha – the scalar to scale the matrix-vector product with

  • b – the multi-vector to be applied to

  • beta – the scalar to scale the x vector with

  • x – the output multi-vector

void scale(
const array<value_type> &row_scale,
const array<value_type> &col_scale,
)#

Performs in-place row and column scaling for this matrix.

Parameters:

  • row_scale – the row scalars

  • col_scale – the column scalars

void add_scaled_identity(
ptr_param<const MultiVector<value_type>> alpha,
ptr_param<const MultiVector<value_type>> beta,
)#

Performs the operation this = alpha*I + beta*this.

Note

Performs the operation in-place for this batch matrix.

Note

This operation fails in case this matrix does not have all its diagonal entries.

Parameters:

  • alpha – the scalar for identity

  • beta – the scalar to multiply this matrix

Public Static Functions

static std::unique_ptr<Ell> create(
std::shared_ptr<const Executor> exec,
const batch_dim<2> &size = batch_dim<2>{},
const IndexType num_elems_per_row = 0,
)#

Creates an uninitialized Ell matrix of the specified size.

Parameters:

  • exec – Executor associated to the matrix

  • size – size of the matrix

  • num_elems_per_row – the number of elements to be stored in each row

Returns:

A smart pointer to the newly created matrix.

static std::unique_ptr<Ell> create(
std::shared_ptr<const Executor> exec,
const batch_dim<2> &size,
const IndexType num_elems_per_row,
array<value_type> values,
array<index_type> col_idxs,
)#

Creates a Ell matrix from an already allocated (and initialized) array. The column indices array needs to be the same for all batch items.

Note

If values is not an rvalue, not an array of ValueType, or is on the wrong executor, an internal copy 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

  • num_elems_per_row – the number of elements to be stored in each row

  • values – array of matrix values

  • col_idxs – the col_idxs array of a single batch item of the matrix.

Returns:

A smart pointer to the newly created matrix.

template<typename InputValueType, typename ColIndexType>
static inline std::unique_ptr<Ell> create(
std::shared_ptr<const Executor> exec,
const batch_dim<2> &size,
const IndexType num_elems_per_row,
std::initializer_list<InputValueType> values,
std::initializer_list<ColIndexType> col_idxs,
)#

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

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

static std::unique_ptr<const Ell> create_const(
std::shared_ptr<const Executor> exec,
const batch_dim<2> &sizes,
const index_type num_elems_per_row,
gko::detail::const_array_view<value_type> &&values,
gko::detail::const_array_view<index_type> &&col_idxs,
)#

Creates a constant (immutable) batch ell matrix from a constant array. The column indices array needs to be the same for all batch items.

Parameters:

  • exec – the executor to create the matrix on

  • size – the dimensions of the matrix

  • num_elems_per_row – the number of elements to be stored in each row

  • values – the value array of the matrix

  • col_idxs – the col_idxs array of a single batch item of the matrix.

Returns:

A smart pointer to the constant matrix wrapping the input array (if it resides on the same executor as the matrix) or a copy of the array on the correct executor.

Returns:

A smart pointer to the newly created matrix.