Ginkgo Generated from branch based on master. Ginkgo version 1.7.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
ell.hpp
1/*******************************<GINKGO LICENSE>******************************
2Copyright (c) 2017-2023, the Ginkgo authors
3All rights reserved.
4
5Redistribution and use in source and binary forms, with or without
6modification, are permitted provided that the following conditions
7are met:
8
91. Redistributions of source code must retain the above copyright
10notice, this list of conditions and the following disclaimer.
11
122. Redistributions in binary form must reproduce the above copyright
13notice, this list of conditions and the following disclaimer in the
14documentation and/or other materials provided with the distribution.
15
163. Neither the name of the copyright holder nor the names of its
17contributors may be used to endorse or promote products derived from
18this software without specific prior written permission.
19
20THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
21IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
23PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31******************************<GINKGO LICENSE>*******************************/
32
33#ifndef GKO_PUBLIC_CORE_MATRIX_ELL_HPP_
34#define GKO_PUBLIC_CORE_MATRIX_ELL_HPP_
35
36
37#include <ginkgo/core/base/array.hpp>
38#include <ginkgo/core/base/lin_op.hpp>
39
40
41namespace gko {
42namespace matrix {
43
44
45template <typename ValueType>
46class Dense;
47
48template <typename ValueType, typename IndexType>
49class Coo;
50
51template <typename ValueType, typename IndexType>
52class Csr;
53
54template <typename ValueType, typename IndexType>
55class Hybrid;
56
57
79template <typename ValueType = default_precision, typename IndexType = int32>
80class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
81 public EnableCreateMethod<Ell<ValueType, IndexType>>,
82 public ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>,
83 public ConvertibleTo<Dense<ValueType>>,
84 public ConvertibleTo<Csr<ValueType, IndexType>>,
85 public DiagonalExtractable<ValueType>,
86 public ReadableFromMatrixData<ValueType, IndexType>,
87 public WritableToMatrixData<ValueType, IndexType>,
89 remove_complex<Ell<ValueType, IndexType>>> {
90 friend class EnableCreateMethod<Ell>;
91 friend class EnablePolymorphicObject<Ell, LinOp>;
92 friend class Dense<ValueType>;
93 friend class Coo<ValueType, IndexType>;
94 friend class Csr<ValueType, IndexType>;
95 friend class Ell<to_complex<ValueType>, IndexType>;
96 friend class Ell<next_precision<ValueType>, IndexType>;
97 friend class Hybrid<ValueType, IndexType>;
98
99public:
100 using EnableLinOp<Ell>::convert_to;
101 using EnableLinOp<Ell>::move_to;
102 using ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>::convert_to;
103 using ConvertibleTo<Ell<next_precision<ValueType>, IndexType>>::move_to;
104 using ConvertibleTo<Dense<ValueType>>::convert_to;
105 using ConvertibleTo<Dense<ValueType>>::move_to;
106 using ConvertibleTo<Csr<ValueType, IndexType>>::convert_to;
108 using ReadableFromMatrixData<ValueType, IndexType>::read;
109
110 using value_type = ValueType;
111 using index_type = IndexType;
114 using absolute_type = remove_complex<Ell>;
115
116 void convert_to(
117 Ell<next_precision<ValueType>, IndexType>* result) const override;
118
119 void move_to(Ell<next_precision<ValueType>, IndexType>* result) override;
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
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_num_elems();
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
267 static std::unique_ptr<const Ell> create_const(
268 std::shared_ptr<const Executor> exec, const dim<2>& size,
269 gko::detail::const_array_view<ValueType>&& values,
270 gko::detail::const_array_view<IndexType>&& col_idxs,
272 {
273 // cast const-ness away, but return a const object afterwards,
274 // so we can ensure that no modifications take place.
275 return std::unique_ptr<const Ell>(new Ell{
276 exec, size, gko::detail::array_const_cast(std::move(values)),
277 gko::detail::array_const_cast(std::move(col_idxs)),
279 }
280
286 Ell& operator=(const Ell&);
287
294
299 Ell(const Ell&);
300
306
307protected:
317 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size = dim<2>{})
318 : Ell(std::move(exec), size, size[1])
319 {}
320
330 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size,
332 : Ell(std::move(exec), size, num_stored_elements_per_row, size[0])
333 {}
334
344 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size,
346 : EnableLinOp<Ell>(exec, size),
347 values_(exec, stride * num_stored_elements_per_row),
348 col_idxs_(exec, stride * num_stored_elements_per_row),
349 num_stored_elements_per_row_(num_stored_elements_per_row),
350 stride_(stride)
351 {}
352
353
374 template <typename ValuesArray, typename ColIdxsArray>
375 Ell(std::shared_ptr<const Executor> exec, const dim<2>& size,
376 ValuesArray&& values, ColIdxsArray&& col_idxs,
378 : EnableLinOp<Ell>(exec, size),
379 values_{exec, std::forward<ValuesArray>(values)},
380 col_idxs_{exec, std::forward<ColIdxsArray>(col_idxs)},
381 num_stored_elements_per_row_{num_stored_elements_per_row},
382 stride_{stride}
383 {
384 GKO_ASSERT_EQ(num_stored_elements_per_row_ * stride_,
385 values_.get_num_elems());
386 GKO_ASSERT_EQ(num_stored_elements_per_row_ * stride_,
387 col_idxs_.get_num_elems());
388 }
389
399 void resize(dim<2> new_size, size_type max_row_nnz);
400
401 void apply_impl(const LinOp* b, LinOp* x) const override;
402
403 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
404 LinOp* x) const override;
405
406 size_type linearize_index(size_type row, size_type col) const noexcept
407 {
408 return row + stride_ * col;
409 }
410
411private:
412 array<value_type> values_;
413 array<index_type> col_idxs_;
414 size_type num_stored_elements_per_row_;
415 size_type stride_;
416};
417
418
419} // namespace matrix
420} // namespace gko
421
422
423#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:499
The diagonal of a LinOp implementing this interface can be extracted.
Definition lin_op.hpp:772
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:823
This mixin implements a static create() method on ConcreteType that dynamically allocates the memory,...
Definition polymorphic_object.hpp:776
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:908
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:691
Definition lin_op.hpp:146
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:634
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:689
value_type * get_data() noexcept
Returns a pointer to the block of memory used to store the elements of the array.
Definition array.hpp:646
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:655
size_type get_num_elems() const noexcept
Returns the number of elements in the array.
Definition array.hpp:637
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:63
COO stores a matrix in the coordinate matrix format.
Definition coo.hpp:87
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:146
Dense is a matrix format which explicitly stores all values of the matrix.
Definition dense.hpp:136
ELL is a matrix format where stride with explicit zeros is used such that all rows have the same numb...
Definition ell.hpp:89
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
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
void read(const mat_data &data) override
Reads a matrix from a matrix_data structure.
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.
void read(const device_mat_data &data) override
Reads a matrix from a device_matrix_data structure.
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.
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.
Definition ell.hpp:267
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
void read(device_mat_data &&data) override
Reads a matrix from a device_matrix_data structure.
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition ell.hpp:203
void write(mat_data &data) const override
Writes a matrix to a matrix_data structure.
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition hybrid.hpp:81
The Ginkgo namespace.
Definition abstract_factory.hpp:48
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:803
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:354
typename detail::next_precision_impl< T >::type next_precision
Obtains the next type in the singly-linked precision list.
Definition math.hpp:490
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:373
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:120
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:55
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:155