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
sellp.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_MATRIX_SELLP_HPP_
6#define GKO_PUBLIC_CORE_MATRIX_SELLP_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
17constexpr int default_slice_size = 64;
18constexpr int default_stride_factor = 1;
19
20
21template <typename ValueType>
22class Dense;
23
24template <typename ValueType, typename IndexType>
25class Csr;
26
42template <typename ValueType = default_precision, typename IndexType = int32>
43class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
44 public ConvertibleTo<Sellp<next_precision<ValueType>, IndexType>>,
45 public ConvertibleTo<Dense<ValueType>>,
46 public ConvertibleTo<Csr<ValueType, IndexType>>,
47 public DiagonalExtractable<ValueType>,
48 public ReadableFromMatrixData<ValueType, IndexType>,
49 public WritableToMatrixData<ValueType, IndexType>,
51 remove_complex<Sellp<ValueType, IndexType>>> {
52 friend class EnablePolymorphicObject<Sellp, LinOp>;
53 friend class Dense<ValueType>;
54 friend class Csr<ValueType, IndexType>;
55 friend class Sellp<to_complex<ValueType>, IndexType>;
56
57public:
58 using EnableLinOp<Sellp>::convert_to;
59 using EnableLinOp<Sellp>::move_to;
60 using ConvertibleTo<
61 Sellp<next_precision<ValueType>, IndexType>>::convert_to;
62 using ConvertibleTo<Sellp<next_precision<ValueType>, IndexType>>::move_to;
63 using ConvertibleTo<Dense<ValueType>>::convert_to;
64 using ConvertibleTo<Dense<ValueType>>::move_to;
67 using ReadableFromMatrixData<ValueType, IndexType>::read;
68
69 using value_type = ValueType;
70 using index_type = IndexType;
73 using absolute_type = remove_complex<Sellp>;
74
75 friend class Sellp<next_precision<ValueType>, IndexType>;
76
77 void convert_to(
78 Sellp<next_precision<ValueType>, IndexType>* result) const override;
79
80 void move_to(Sellp<next_precision<ValueType>, IndexType>* result) override;
81
82 void convert_to(Dense<ValueType>* other) const override;
83
84 void move_to(Dense<ValueType>* other) override;
85
86 void convert_to(Csr<ValueType, IndexType>* other) const override;
87
88 void move_to(Csr<ValueType, IndexType>* other) override;
89
90 void read(const mat_data& data) override;
91
92 void read(const device_mat_data& data) override;
93
94 void read(device_mat_data&& data) override;
95
96 void write(mat_data& data) const override;
97
98 std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
99
100 std::unique_ptr<absolute_type> compute_absolute() const override;
101
103
109 value_type* get_values() noexcept { return values_.get_data(); }
110
118 const value_type* get_const_values() const noexcept
119 {
120 return values_.get_const_data();
121 }
122
128 index_type* get_col_idxs() noexcept { return col_idxs_.get_data(); }
129
137 const index_type* get_const_col_idxs() const noexcept
138 {
139 return col_idxs_.get_const_data();
140 }
141
148 {
149 return slice_lengths_.get_data();
150 }
151
159 const size_type* get_const_slice_lengths() const noexcept
160 {
161 return slice_lengths_.get_const_data();
162 }
163
169 size_type* get_slice_sets() noexcept { return slice_sets_.get_data(); }
170
178 const size_type* get_const_slice_sets() const noexcept
179 {
180 return slice_sets_.get_const_data();
181 }
182
188 size_type get_slice_size() const noexcept { return slice_size_; }
189
195 size_type get_stride_factor() const noexcept { return stride_factor_; }
196
202 size_type get_total_cols() const noexcept
203 {
204 return values_.get_size() / slice_size_;
205 }
206
213 {
214 return values_.get_size();
215 }
216
229 value_type& val_at(size_type row, size_type slice_set,
230 size_type idx) noexcept
231 {
232 return values_.get_data()[this->linearize_index(row, slice_set, idx)];
233 }
234
238 value_type val_at(size_type row, size_type slice_set,
239 size_type idx) const noexcept
240 {
241 return values_
242 .get_const_data()[this->linearize_index(row, slice_set, idx)];
243 }
244
257 index_type& col_at(size_type row, size_type slice_set,
258 size_type idx) noexcept
259 {
260 return this->get_col_idxs()[this->linearize_index(row, slice_set, idx)];
261 }
262
266 index_type col_at(size_type row, size_type slice_set,
267 size_type idx) const noexcept
268 {
269 return this
270 ->get_const_col_idxs()[this->linearize_index(row, slice_set, idx)];
271 }
272
283 static std::unique_ptr<Sellp> create(std::shared_ptr<const Executor> exec,
284 const dim<2>& size = {},
285 size_type total_cols = 0);
286
299 static std::unique_ptr<Sellp> create(std::shared_ptr<const Executor> exec,
300 const dim<2>& size,
301 size_type slice_size,
302 size_type stride_factor,
303 size_type total_cols);
304
310
317
322 Sellp(const Sellp&);
323
330
331protected:
332 Sellp(std::shared_ptr<const Executor> exec, const dim<2>& size = {},
333 size_type total_cols = {});
334
335 Sellp(std::shared_ptr<const Executor> exec, const dim<2>& size,
336 size_type slice_size, size_type stride_factor, size_type total_cols);
337
338 void apply_impl(const LinOp* b, LinOp* x) const override;
339
340 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
341 LinOp* x) const override;
342
343 size_type linearize_index(size_type row, size_type slice_set,
344 size_type col) const noexcept
345 {
346 return (slice_set + col) * slice_size_ + row;
347 }
348
349private:
350 array<value_type> values_;
351 array<index_type> col_idxs_;
352 array<size_type> slice_lengths_;
353 array<size_type> slice_sets_;
354 size_type slice_size_;
355 size_type stride_factor_;
356};
357
358
359} // namespace matrix
360} // namespace gko
361
362
363#endif // GKO_PUBLIC_CORE_MATRIX_SELLP_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
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
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
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
SELL-P is a matrix format similar to ELL format.
Definition sellp.hpp:51
size_type get_slice_size() const noexcept
Returns the size of a slice.
Definition sellp.hpp:188
value_type & val_at(size_type row, size_type slice_set, size_type idx) noexcept
Returns the idx-th non-zero element of the row-th row with slice_set slice set.
Definition sellp.hpp:229
static std::unique_ptr< Sellp > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size, size_type slice_size, size_type stride_factor, size_type total_cols)
Creates an uninitialized Sellp matrix of the specified size.
index_type & col_at(size_type row, size_type slice_set, size_type idx) noexcept
Returns the idx-th column index of the row-th row with slice_set slice set.
Definition sellp.hpp:257
Sellp(const Sellp &)
Copy-assigns a Sellp matrix.
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
value_type * get_values() noexcept
Returns the values of the matrix.
Definition sellp.hpp:109
Sellp & operator=(Sellp &&)
Move-assigns a Sellp matrix.
size_type get_stride_factor() const noexcept
Returns the stride factor(t) of SELL-P.
Definition sellp.hpp:195
const size_type * get_const_slice_sets() const noexcept
Returns the offsets of slices.
Definition sellp.hpp:178
index_type * get_col_idxs() noexcept
Returns the column indexes of the matrix.
Definition sellp.hpp:128
size_type get_total_cols() const noexcept
Returns the total column number.
Definition sellp.hpp:202
index_type col_at(size_type row, size_type slice_set, size_type idx) const noexcept
Returns the idx-th column index of the row-th row with slice_set slice set.
Definition sellp.hpp:266
size_type * get_slice_lengths() noexcept
Returns the lengths(columns) of slices.
Definition sellp.hpp:147
Sellp & operator=(const Sellp &)
Copy-assigns a Sellp matrix.
void compute_absolute_inplace() override
Compute absolute inplace on each element.
static std::unique_ptr< Sellp > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size={}, size_type total_cols=0)
Creates an uninitialized Sellp matrix of the specified size.
size_type * get_slice_sets() noexcept
Returns the offsets of slices.
Definition sellp.hpp:169
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition sellp.hpp:212
value_type val_at(size_type row, size_type slice_set, size_type idx) const noexcept
Returns the idx-th non-zero element of the row-th row with slice_set slice set.
Definition sellp.hpp:238
const index_type * get_const_col_idxs() const noexcept
Returns the column indexes of the matrix.
Definition sellp.hpp:137
Sellp(Sellp &&)
Move-assigns a Sellp matrix.
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.
const size_type * get_const_slice_lengths() const noexcept
Returns the lengths(columns) of slices.
Definition sellp.hpp:159
const value_type * get_const_values() const noexcept
Returns the values of the matrix.
Definition sellp.hpp:118
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