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
coo.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_COO_HPP_
34#define GKO_PUBLIC_CORE_MATRIX_COO_HPP_
35
36
37#include <ginkgo/core/base/array.hpp>
38#include <ginkgo/core/base/lin_op.hpp>
39
40
41namespace gko {
47namespace matrix {
48
49
50template <typename ValueType, typename IndexType>
51class Csr;
52
53template <typename ValueType>
54class Dense;
55
56template <typename ValueType, typename IndexType>
58
59template <typename ValueType, typename IndexType>
60class Hybrid;
61
62
77template <typename ValueType = default_precision, typename IndexType = int32>
78class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
79 public EnableCreateMethod<Coo<ValueType, IndexType>>,
80 public ConvertibleTo<Coo<next_precision<ValueType>, IndexType>>,
81 public ConvertibleTo<Csr<ValueType, IndexType>>,
82 public ConvertibleTo<Dense<ValueType>>,
83 public DiagonalExtractable<ValueType>,
84 public ReadableFromMatrixData<ValueType, IndexType>,
85 public WritableToMatrixData<ValueType, IndexType>,
87 remove_complex<Coo<ValueType, IndexType>>> {
88 friend class EnableCreateMethod<Coo>;
89 friend class EnablePolymorphicObject<Coo, LinOp>;
90 friend class Csr<ValueType, IndexType>;
91 friend class Dense<ValueType>;
92 friend class CooBuilder<ValueType, IndexType>;
93 friend class Coo<to_complex<ValueType>, IndexType>;
94 friend class Hybrid<ValueType, IndexType>;
95
96public:
97 using EnableLinOp<Coo>::convert_to;
98 using EnableLinOp<Coo>::move_to;
99 using ConvertibleTo<Coo<next_precision<ValueType>, IndexType>>::convert_to;
100 using ConvertibleTo<Coo<next_precision<ValueType>, IndexType>>::move_to;
101 using ConvertibleTo<Csr<ValueType, IndexType>>::convert_to;
103 using ConvertibleTo<Dense<ValueType>>::convert_to;
104 using ConvertibleTo<Dense<ValueType>>::move_to;
105 using ReadableFromMatrixData<ValueType, IndexType>::read;
106
107 using value_type = ValueType;
108 using index_type = IndexType;
111 using absolute_type = remove_complex<Coo>;
112
113 friend class Coo<next_precision<ValueType>, IndexType>;
114
115 void convert_to(
116 Coo<next_precision<ValueType>, IndexType>* result) const override;
117
118 void move_to(Coo<next_precision<ValueType>, IndexType>* result) override;
119
120 void convert_to(Csr<ValueType, IndexType>* other) const override;
121
122 void move_to(Csr<ValueType, IndexType>* other) override;
123
124 void convert_to(Dense<ValueType>* other) const override;
125
126 void move_to(Dense<ValueType>* other) override;
127
128 void read(const mat_data& data) override;
129
130 void read(const device_mat_data& data) override;
131
132 void read(device_mat_data&& data) override;
133
134 void write(mat_data& data) const override;
135
136 std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
137
138 std::unique_ptr<absolute_type> compute_absolute() const override;
139
141
147 value_type* get_values() noexcept { return values_.get_data(); }
148
156 const value_type* get_const_values() const noexcept
157 {
158 return values_.get_const_data();
159 }
160
166 index_type* get_col_idxs() noexcept { return col_idxs_.get_data(); }
167
176 {
177 return col_idxs_.get_const_data();
178 }
179
185 index_type* get_row_idxs() noexcept { return row_idxs_.get_data(); }
186
195 {
196 return row_idxs_.get_const_data();
197 }
198
205 {
206 return values_.get_num_elems();
207 }
208
220 {
221 this->validate_application_parameters(b.get(), x.get());
222 auto exec = this->get_executor();
223 this->apply2_impl(make_temporary_clone(exec, b).get(),
224 make_temporary_clone(exec, x).get());
225 return this;
226 }
227
232 {
233 this->validate_application_parameters(b.get(), x.get());
234 auto exec = this->get_executor();
235 this->apply2_impl(make_temporary_clone(exec, b).get(),
236 make_temporary_clone(exec, x).get());
237 return this;
238 }
239
251 {
252 this->validate_application_parameters(b.get(), x.get());
253 GKO_ASSERT_EQUAL_DIMENSIONS(alpha, dim<2>(1, 1));
254 auto exec = this->get_executor();
255 this->apply2_impl(make_temporary_clone(exec, alpha).get(),
256 make_temporary_clone(exec, b).get(),
257 make_temporary_clone(exec, x).get());
258 return this;
259 }
260
265 ptr_param<LinOp> x) const
266 {
267 this->validate_application_parameters(b.get(), x.get());
268 GKO_ASSERT_EQUAL_DIMENSIONS(alpha, dim<2>(1, 1));
269 auto exec = this->get_executor();
270 this->apply2_impl(make_temporary_clone(exec, alpha).get(),
271 make_temporary_clone(exec, b).get(),
272 make_temporary_clone(exec, x).get());
273 return this;
274 }
275
288 static std::unique_ptr<const Coo> create_const(
289 std::shared_ptr<const Executor> exec, const dim<2>& size,
290 gko::detail::const_array_view<ValueType>&& values,
291 gko::detail::const_array_view<IndexType>&& col_idxs,
292 gko::detail::const_array_view<IndexType>&& row_idxs)
293 {
294 // cast const-ness away, but return a const object afterwards,
295 // so we can ensure that no modifications take place.
296 return std::unique_ptr<const Coo>(new Coo{
297 exec, size, gko::detail::array_const_cast(std::move(values)),
298 gko::detail::array_const_cast(std::move(col_idxs)),
299 gko::detail::array_const_cast(std::move(row_idxs))});
300 }
301
302protected:
310 Coo(std::shared_ptr<const Executor> exec, const dim<2>& size = dim<2>{},
312 : EnableLinOp<Coo>(exec, size),
313 values_(exec, num_nonzeros),
314 col_idxs_(exec, num_nonzeros),
315 row_idxs_(exec, num_nonzeros)
316 {}
317
338 template <typename ValuesArray, typename ColIdxsArray,
339 typename RowIdxsArray>
340 Coo(std::shared_ptr<const Executor> exec, const dim<2>& size,
341 ValuesArray&& values, ColIdxsArray&& col_idxs, RowIdxsArray&& row_idxs)
342 : EnableLinOp<Coo>(exec, size),
343 values_{exec, std::forward<ValuesArray>(values)},
344 col_idxs_{exec, std::forward<ColIdxsArray>(col_idxs)},
345 row_idxs_{exec, std::forward<RowIdxsArray>(row_idxs)}
346 {
347 GKO_ASSERT_EQ(values_.get_num_elems(), col_idxs_.get_num_elems());
348 GKO_ASSERT_EQ(values_.get_num_elems(), row_idxs_.get_num_elems());
349 }
350
358 void resize(dim<2> new_size, size_type nnz);
359
360 void apply_impl(const LinOp* b, LinOp* x) const override;
361
362 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
363 LinOp* x) const override;
364
365 void apply2_impl(const LinOp* b, LinOp* x) const;
366
367 void apply2_impl(const LinOp* alpha, const LinOp* b, LinOp* x) const;
368
369private:
370 array<value_type> values_;
371 array<index_type> col_idxs_;
372 array<index_type> row_idxs_;
373};
374
375
376} // namespace matrix
377} // namespace gko
378
379
380#endif // GKO_PUBLIC_CORE_MATRIX_COO_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
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:263
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
Definition coo.hpp:57
COO stores a matrix in the coordinate matrix format.
Definition coo.hpp:87
index_type * get_col_idxs() noexcept
Returns the column indexes of the matrix.
Definition coo.hpp:166
const index_type * get_const_col_idxs() const noexcept
Returns the column indexes of the matrix.
Definition coo.hpp:175
void read(const device_mat_data &data) override
Reads a matrix from a device_matrix_data structure.
static std::unique_ptr< const Coo > 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, gko::detail::const_array_view< IndexType > &&row_idxs)
Creates a constant (immutable) Coo matrix from a set of constant arrays.
Definition coo.hpp:288
void read(device_mat_data &&data) override
Reads a matrix from a device_matrix_data structure.
const LinOp * apply2(ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Definition coo.hpp:264
LinOp * apply2(ptr_param< const LinOp > b, ptr_param< LinOp > x)
Applies Coo matrix axpy to a vector (or a sequence of vectors).
Definition coo.hpp:219
LinOp * apply2(ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< LinOp > x)
Performs the operation x = alpha * Coo * b + x.
Definition coo.hpp:249
void compute_absolute_inplace() override
Compute absolute inplace on each element.
const value_type * get_const_values() const noexcept
Returns the values of the matrix.
Definition coo.hpp:156
void read(const mat_data &data) override
Reads a matrix from a matrix_data structure.
const index_type * get_const_row_idxs() const noexcept
Definition coo.hpp:194
const LinOp * apply2(ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Definition coo.hpp:231
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
void write(mat_data &data) const override
Writes a matrix to a matrix_data structure.
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition coo.hpp:204
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.
index_type * get_row_idxs() noexcept
Returns the row indexes of the matrix.
Definition coo.hpp:185
value_type * get_values() noexcept
Returns the values of the matrix.
Definition coo.hpp:147
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
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition hybrid.hpp:81
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:71
T * get() const
Definition utils_helper.hpp:105
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
detail::temporary_clone< detail::pointee< Ptr > > make_temporary_clone(std::shared_ptr< const Executor > exec, Ptr &&ptr)
Creates a temporary_clone.
Definition temporary_clone.hpp:207
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