Ginkgo Generated from branch based on main. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
ell.hpp
1// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_MATRIX_ELL_HPP_
6#define GKO_PUBLIC_CORE_MATRIX_ELL_HPP_
7
8
9#include <ginkgo/core/base/array.hpp>
10#include <ginkgo/core/base/lin_op.hpp>
11
12
13namespace gko {
14namespace matrix {
15
16
17template <typename ValueType>
18class Dense;
19
20template <typename ValueType, typename IndexType>
21class Coo;
22
23template <typename ValueType, typename IndexType>
24class Csr;
25
26template <typename ValueType, typename IndexType>
27class Hybrid;
28
29
51template <typename ValueType = default_precision, typename IndexType = int32>
52class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
53 public ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>,
54#if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16
55 public ConvertibleTo<Ell<next_precision<ValueType, 2>, IndexType>>,
56#endif
57#if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16
58 public ConvertibleTo<Ell<next_precision<ValueType, 3>, IndexType>>,
59#endif
60 public ConvertibleTo<Dense<ValueType>>,
61 public ConvertibleTo<Csr<ValueType, IndexType>>,
62 public DiagonalExtractable<ValueType>,
63 public ReadableFromMatrixData<ValueType, IndexType>,
64 public WritableToMatrixData<ValueType, IndexType>,
66 remove_complex<Ell<ValueType, IndexType>>> {
67 friend class EnablePolymorphicObject<Ell, LinOp>;
68 friend class Dense<ValueType>;
69 friend class Coo<ValueType, IndexType>;
70 friend class Csr<ValueType, IndexType>;
71 friend class Ell<to_complex<ValueType>, IndexType>;
72 friend class Ell<previous_precision<ValueType>, IndexType>;
73 friend class Hybrid<ValueType, IndexType>;
74
75public:
76 using EnableLinOp<Ell>::convert_to;
77 using EnableLinOp<Ell>::move_to;
78 using ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>::convert_to;
79 using ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>::move_to;
80 using ConvertibleTo<Dense<ValueType>>::convert_to;
81 using ConvertibleTo<Dense<ValueType>>::move_to;
84 using ReadableFromMatrixData<ValueType, IndexType>::read;
85
86 using value_type = ValueType;
87 using index_type = IndexType;
88 using mat_data = matrix_data<ValueType, IndexType>;
89 using device_mat_data = device_matrix_data<ValueType, IndexType>;
90 using absolute_type = remove_complex<Ell>;
91
92 void convert_to(
93 Ell<next_precision<ValueType>, IndexType>* result) const override;
94
95 void move_to(Ell<next_precision<ValueType>, IndexType>* result) override;
96
97#if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16
98 friend class Ell<previous_precision<ValueType, 2>, IndexType>;
99 using ConvertibleTo<
100 Ell<next_precision<ValueType, 2>, IndexType>>::convert_to;
101 using ConvertibleTo<Ell<next_precision<ValueType, 2>, IndexType>>::move_to;
102
103 void convert_to(
104 Ell<next_precision<ValueType, 2>, IndexType>* result) const override;
105
106 void move_to(Ell<next_precision<ValueType, 2>, IndexType>* result) override;
107#endif
108
109#if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16
110 friend class Ell<previous_precision<ValueType, 3>, IndexType>;
111 using ConvertibleTo<
112 Ell<next_precision<ValueType, 3>, IndexType>>::convert_to;
113 using ConvertibleTo<Ell<next_precision<ValueType, 3>, IndexType>>::move_to;
114
115 void convert_to(
116 Ell<next_precision<ValueType, 3>, IndexType>* result) const override;
117
118 void move_to(Ell<next_precision<ValueType, 3>, IndexType>* result) override;
119#endif
120
121 void convert_to(Dense<ValueType>* other) const override;
122
123 void move_to(Dense<ValueType>* other) override;
124
125 void convert_to(Csr<ValueType, IndexType>* other) const override;
126
127 void move_to(Csr<ValueType, IndexType>* other) override;
128
129 void read(const mat_data& data) override;
130
131 void read(const device_mat_data& data) override;
132
133 void read(device_mat_data&& data) override;
134
135 void write(mat_data& data) const override;
136
137 std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
138
139 std::unique_ptr<absolute_type> compute_absolute() const override;
140
142
148 value_type* get_values() noexcept { return values_.get_data(); }
149
157 const value_type* get_const_values() const noexcept
158 {
159 return values_.get_const_data();
160 }
161
167 index_type* get_col_idxs() noexcept { return col_idxs_.get_data(); }
168
176 const index_type* get_const_col_idxs() const noexcept
177 {
178 return col_idxs_.get_const_data();
179 }
180
187 {
188 return num_stored_elements_per_row_;
189 }
190
196 size_type get_stride() const noexcept { return stride_; }
197
204 {
205 return values_.get_size();
206 }
207
218 value_type& val_at(size_type row, size_type idx) noexcept
219 {
220 return values_.get_data()[this->linearize_index(row, idx)];
221 }
222
226 value_type val_at(size_type row, size_type idx) const noexcept
227 {
228 return values_.get_const_data()[this->linearize_index(row, idx)];
229 }
230
241 index_type& col_at(size_type row, size_type idx) noexcept
242 {
243 return this->get_col_idxs()[this->linearize_index(row, idx)];
244 }
245
249 index_type col_at(size_type row, size_type idx) const noexcept
250 {
251 return this->get_const_col_idxs()[this->linearize_index(row, idx)];
252 }
253
265 static std::unique_ptr<Ell> create(
266 std::shared_ptr<const Executor> exec, const dim<2>& size = {},
267 size_type num_stored_elements_per_row = 0, size_type stride = 0);
268
288 static std::unique_ptr<Ell> create(std::shared_ptr<const Executor> exec,
289 const dim<2>& size,
290 array<value_type> values,
291 array<index_type> col_idxs,
292 size_type num_stored_elements_per_row,
293 size_type stride);
294
300 template <typename InputValueType, typename InputColumnIndexType>
301 GKO_DEPRECATED(
302 "explicitly construct the gko::array argument instead of passing "
303 "initializer lists")
304 static std::unique_ptr<Ell> create(
305 std::shared_ptr<const Executor> exec, const dim<2>& size,
306 std::initializer_list<InputValueType> values,
307 std::initializer_list<InputColumnIndexType> col_idxs,
308 size_type num_stored_elements_per_row, size_type stride)
309 {
310 return create(exec, size, array<value_type>{exec, std::move(values)},
311 array<index_type>{exec, std::move(col_idxs)},
312 num_stored_elements_per_row, stride);
313 }
314
328 static std::unique_ptr<const Ell> create_const(
329 std::shared_ptr<const Executor> exec, const dim<2>& size,
330 gko::detail::const_array_view<ValueType>&& values,
331 gko::detail::const_array_view<IndexType>&& col_idxs,
332 size_type num_stored_elements_per_row, size_type stride);
333
339 Ell& operator=(const Ell&);
340
347
352 Ell(const Ell&);
353
359
360protected:
361 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size = {},
362 size_type num_stored_elements_per_row = 0, size_type stride = 0);
363
364 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size,
365 array<value_type> values, array<index_type> col_idxs,
366 size_type num_stored_elements_per_row, size_type stride);
367
377 void resize(dim<2> new_size, size_type max_row_nnz);
378
379 void apply_impl(const LinOp* b, LinOp* x) const override;
380
381 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
382 LinOp* x) const override;
383
384 size_type linearize_index(size_type row, size_type col) const noexcept
385 {
386 return row + stride_ * col;
387 }
388
389private:
390 size_type num_stored_elements_per_row_;
391 size_type stride_;
392 array<value_type> values_;
393 array<index_type> col_idxs_;
394};
395
396
397} // namespace matrix
398} // namespace gko
399
400
401#endif // GKO_PUBLIC_CORE_MATRIX_ELL_HPP_
ConvertibleTo interface is used to mark that the implementer can be converted to the object of Result...
Definition polymorphic_object.hpp:479
The diagonal of a LinOp implementing this interface can be extracted.
Definition lin_op.hpp:743
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:794
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:668
The first step in using the Ginkgo library consists of creating an executor.
Definition executor.hpp:615
Definition lin_op.hpp:117
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:605
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:660
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:166
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:36
COO stores a matrix in the coordinate matrix format.
Definition coo.hpp:65
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:126
Dense is a matrix format which explicitly stores all values of the matrix.
Definition dense.hpp:120
value_type & val_at(size_type row, size_type idx) noexcept
Returns the idx-th non-zero element of the row-th row .
Definition ell.hpp:218
size_type get_num_stored_elements_per_row() const noexcept
Returns the number of stored elements per row.
Definition ell.hpp:186
size_type get_stride() const noexcept
Returns the stride of the matrix.
Definition ell.hpp:196
static std::unique_ptr< Ell > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size={}, size_type num_stored_elements_per_row=0, size_type stride=0)
Creates an uninitialized Ell matrix of the specified size.
index_type col_at(size_type row, size_type idx) const noexcept
Returns the idx-th column index of the row-th row .
Definition ell.hpp:249
value_type * get_values() noexcept
Returns the values of the matrix.
Definition ell.hpp:148
value_type val_at(size_type row, size_type idx) const noexcept
Returns the idx-th non-zero element of the row-th row .
Definition ell.hpp:226
Ell & operator=(Ell &&)
Move-assigns an Ell matrix.
void compute_absolute_inplace() override
Compute absolute inplace on each element.
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.
index_type * get_col_idxs() noexcept
Returns the column indexes of the matrix.
Definition ell.hpp:167
Ell(Ell &&)
Move-constructs an Ell matrix.
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
Ell(const Ell &)
Copy-constructs an Ell matrix.
static std::unique_ptr< Ell > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size, array< value_type > values, array< index_type > col_idxs, size_type num_stored_elements_per_row, size_type stride)
Creates an ELL matrix from already allocated (and initialized) column index and value arrays.
const index_type * get_const_col_idxs() const noexcept
Returns the column indexes of the matrix.
Definition ell.hpp:176
static std::unique_ptr< const Ell > 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, size_type num_stored_elements_per_row, size_type stride)
Creates a constant (immutable) Ell matrix from a set of constant arrays.
Ell & operator=(const Ell &)
Copy-assigns an Ell matrix.
const value_type * get_const_values() const noexcept
Returns the values of the matrix.
Definition ell.hpp:157
index_type & col_at(size_type row, size_type idx) noexcept
Returns the idx-th column index of the row-th row .
Definition ell.hpp:241
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition ell.hpp:203
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition hybrid.hpp:57
The matrix namespace.
Definition dense_cache.hpp:24
The Ginkgo namespace.
Definition abstract_factory.hpp:20
typename detail::remove_complex_s< T >::type remove_complex
Obtain the type which removed the complex of complex/scalar type or the template parameter of class b...
Definition math.hpp:264
typename detail::to_complex_s< T >::type to_complex
Obtain the type which adds the complex of complex/scalar type or the template parameter of class by a...
Definition math.hpp:283
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:90
typename detail::find_precision_impl< T, -step >::type previous_precision
Obtains the previous move type of T in the singly-linked precision corresponding bfloat16/half.
Definition math.hpp:473
typename detail::find_precision_impl< T, step >::type next_precision
Obtains the next move type of T in the singly-linked precision corresponding bfloat16/half.
Definition math.hpp:466
STL namespace.
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:26
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:126