Ginkgo Generated from branch based on master. Ginkgo version 1.8.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
ell.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 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 public ConvertibleTo<Dense<ValueType>>,
55 public ConvertibleTo<Csr<ValueType, IndexType>>,
56 public DiagonalExtractable<ValueType>,
57 public ReadableFromMatrixData<ValueType, IndexType>,
58 public WritableToMatrixData<ValueType, IndexType>,
60 remove_complex<Ell<ValueType, IndexType>>> {
61 friend class EnablePolymorphicObject<Ell, LinOp>;
62 friend class Dense<ValueType>;
63 friend class Coo<ValueType, IndexType>;
64 friend class Csr<ValueType, IndexType>;
65 friend class Ell<to_complex<ValueType>, IndexType>;
66 friend class Ell<next_precision<ValueType>, IndexType>;
67 friend class Hybrid<ValueType, IndexType>;
68
69public:
70 using EnableLinOp<Ell>::convert_to;
71 using EnableLinOp<Ell>::move_to;
72 using ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>::convert_to;
73 using ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>::move_to;
74 using ConvertibleTo<Dense<ValueType>>::convert_to;
75 using ConvertibleTo<Dense<ValueType>>::move_to;
78 using ReadableFromMatrixData<ValueType, IndexType>::read;
79
80 using value_type = ValueType;
81 using index_type = IndexType;
84 using absolute_type = remove_complex<Ell>;
85
86 void convert_to(
87 Ell<next_precision<ValueType>, IndexType>* result) const override;
88
89 void move_to(Ell<next_precision<ValueType>, IndexType>* result) override;
90
91 void convert_to(Dense<ValueType>* other) const override;
92
93 void move_to(Dense<ValueType>* other) override;
94
95 void convert_to(Csr<ValueType, IndexType>* other) const override;
96
97 void move_to(Csr<ValueType, IndexType>* other) override;
98
99 void read(const mat_data& data) override;
100
101 void read(const device_mat_data& data) override;
102
103 void read(device_mat_data&& data) override;
104
105 void write(mat_data& data) const override;
106
107 std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
108
109 std::unique_ptr<absolute_type> compute_absolute() const override;
110
112
118 value_type* get_values() noexcept { return values_.get_data(); }
119
127 const value_type* get_const_values() const noexcept
128 {
129 return values_.get_const_data();
130 }
131
137 index_type* get_col_idxs() noexcept { return col_idxs_.get_data(); }
138
146 const index_type* get_const_col_idxs() const noexcept
147 {
148 return col_idxs_.get_const_data();
149 }
150
157 {
158 return num_stored_elements_per_row_;
159 }
160
166 size_type get_stride() const noexcept { return stride_; }
167
174 {
175 return values_.get_size();
176 }
177
188 value_type& val_at(size_type row, size_type idx) noexcept
189 {
190 return values_.get_data()[this->linearize_index(row, idx)];
191 }
192
196 value_type val_at(size_type row, size_type idx) const noexcept
197 {
198 return values_.get_const_data()[this->linearize_index(row, idx)];
199 }
200
211 index_type& col_at(size_type row, size_type idx) noexcept
212 {
213 return this->get_col_idxs()[this->linearize_index(row, idx)];
214 }
215
219 index_type col_at(size_type row, size_type idx) const noexcept
220 {
221 return this->get_const_col_idxs()[this->linearize_index(row, idx)];
222 }
223
235 static std::unique_ptr<Ell> create(
236 std::shared_ptr<const Executor> exec, const dim<2>& size = {},
237 size_type num_stored_elements_per_row = 0, size_type stride = 0);
238
258 static std::unique_ptr<Ell> create(std::shared_ptr<const Executor> exec,
259 const dim<2>& size,
260 array<value_type> values,
261 array<index_type> col_idxs,
262 size_type num_stored_elements_per_row,
263 size_type stride);
264
270 template <typename InputValueType, typename InputColumnIndexType>
271 GKO_DEPRECATED(
272 "explicitly construct the gko::array argument instead of passing "
273 "initializer lists")
274 static std::unique_ptr<Ell> create(
275 std::shared_ptr<const Executor> exec, const dim<2>& size,
276 std::initializer_list<InputValueType> values,
277 std::initializer_list<InputColumnIndexType> col_idxs,
278 size_type num_stored_elements_per_row, size_type stride)
279 {
280 return create(exec, size, array<value_type>{exec, std::move(values)},
281 array<index_type>{exec, std::move(col_idxs)},
282 num_stored_elements_per_row, stride);
283 }
284
298 static std::unique_ptr<const Ell> create_const(
299 std::shared_ptr<const Executor> exec, const dim<2>& size,
300 gko::detail::const_array_view<ValueType>&& values,
301 gko::detail::const_array_view<IndexType>&& col_idxs,
302 size_type num_stored_elements_per_row, size_type stride);
303
309 Ell& operator=(const Ell&);
310
317
322 Ell(const Ell&);
323
329
330protected:
331 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size = {},
332 size_type num_stored_elements_per_row = 0, size_type stride = 0);
333
334 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size,
335 array<value_type> values, array<index_type> col_idxs,
336 size_type num_stored_elements_per_row, size_type stride);
337
347 void resize(dim<2> new_size, size_type max_row_nnz);
348
349 void apply_impl(const LinOp* b, LinOp* x) const override;
350
351 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
352 LinOp* x) const override;
353
354 size_type linearize_index(size_type row, size_type col) const noexcept
355 {
356 return row + stride_ * col;
357 }
358
359private:
360 size_type num_stored_elements_per_row_;
361 size_type stride_;
362 array<value_type> values_;
363 array<index_type> col_idxs_;
364};
365
366
367} // namespace matrix
368} // namespace gko
369
370
371#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:471
The diagonal of a LinOp implementing this interface can be extracted.
Definition lin_op.hpp:744
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:795
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:880
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:663
The first step in using the Ginkgo library consists of creating an executor.
Definition executor.hpp:616
Definition lin_op.hpp:118
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:606
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:661
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition logger.hpp:25
value_type * get_data() noexcept
Returns a pointer to the block of memory used to store the elements of the array.
Definition array.hpp:674
const value_type * get_const_data() const noexcept
Returns a constant pointer to the block of memory used to store the elements of the array.
Definition array.hpp:683
size_type get_size() const noexcept
Returns the number of elements in the array.
Definition array.hpp:657
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 ell.hpp:21
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition sparsity_csr.hpp:22
Dense is a matrix format which explicitly stores all values of the matrix.
Definition sparsity_csr.hpp:26
ELL is a matrix format where stride with explicit zeros is used such that all rows have the same numb...
Definition ell.hpp:60
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:188
size_type get_num_stored_elements_per_row() const noexcept
Returns the number of stored elements per row.
Definition ell.hpp:156
size_type get_stride() const noexcept
Returns the stride of the matrix.
Definition ell.hpp:166
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:219
value_type * get_values() noexcept
Returns the values of the matrix.
Definition ell.hpp:118
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:196
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:137
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:146
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:127
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:211
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition ell.hpp:173
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition hybrid.hpp:52
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:326
typename detail::next_precision_impl< T >::type next_precision
Obtains the next type in the singly-linked precision list.
Definition math.hpp:462
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:345
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:86
std::unique_ptr< MatrixType > read(StreamType &&is, MatrixArgs &&... args)
Reads a matrix stored in matrix market format from an input stream.
Definition mtx_io.hpp:160
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:27
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:127