Ginkgo Generated from branch based on main. Ginkgo version 1.9.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
composition.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_BASE_COMPOSITION_HPP_
6#define GKO_PUBLIC_CORE_BASE_COMPOSITION_HPP_
7
8
9#include <type_traits>
10#include <vector>
11
12#include <ginkgo/core/base/executor.hpp>
13#include <ginkgo/core/base/lin_op.hpp>
14
15
16namespace gko {
17
18
38template <typename ValueType = default_precision>
39class Composition : public EnableLinOp<Composition<ValueType>>,
40 public EnableCreateMethod<Composition<ValueType>>,
41 public Transposable {
43 friend class EnableCreateMethod<Composition>;
44
45public:
46 using value_type = ValueType;
48
54 const std::vector<std::shared_ptr<const LinOp>>& get_operators()
55 const noexcept
56 {
57 return operators_;
58 }
59
60 std::unique_ptr<LinOp> transpose() const override;
61
62 std::unique_ptr<LinOp> conj_transpose() const override;
63
69
77
83
90
91protected:
92 void add_operators() {}
93
94 template <typename... Rest>
95 void add_operators(std::shared_ptr<const LinOp> oper, Rest&&... rest)
96 {
97 if (!operators_.empty()) {
98 GKO_ASSERT_CONFORMANT(this, oper);
99 }
100 auto exec = this->get_executor();
101 operators_.push_back(std::move(oper));
102 if (operators_.back()->get_executor() != exec) {
103 operators_.back() = gko::clone(exec, operators_.back());
104 }
105 this->set_size(dim<2>{operators_.front()->get_size()[0],
106 operators_.back()->get_size()[1]});
107 add_operators(std::forward<Rest>(rest)...);
108 }
109
115 explicit Composition(std::shared_ptr<const Executor> exec)
116 : EnableLinOp<Composition>(exec), storage_{exec}
117 {}
118
128 template <typename Iterator,
129 typename = std::void_t<
130 typename std::iterator_traits<Iterator>::iterator_category>>
131 explicit Composition(Iterator begin, Iterator end)
132 : EnableLinOp<Composition>([&] {
133 if (begin == end) {
134 throw OutOfBoundsError(__FILE__, __LINE__, 1, 0);
135 }
136 return (*begin)->get_executor();
137 }()),
138 storage_{this->get_executor()}
139 {
140 for (auto it = begin; it != end; ++it) {
141 add_operators(*it);
142 }
143 }
144
153 template <typename... Rest>
154 explicit Composition(std::shared_ptr<const LinOp> oper, Rest&&... rest)
155 : Composition(oper->get_executor())
156 {
157 add_operators(std::move(oper), std::forward<Rest>(rest)...);
158 }
159
160 void apply_impl(const LinOp* b, LinOp* x) const override;
161
162 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
163 LinOp* x) const override;
164
165private:
166 std::vector<std::shared_ptr<const LinOp>> operators_;
167 mutable array<ValueType> storage_;
168};
169
170
177template <typename ValueType = default_precision>
179public:
180 using value_type = ValueType;
186 std::shared_ptr<Composition<ValueType>> get_composition() const
187 {
188 return composition_;
189 }
190
203 std::shared_ptr<const LinOp> get_operator_at(size_type index) const
204 {
205 if (composition_ == nullptr) {
206 return nullptr;
207 } else {
208 return composition_->get_operators().at(index);
209 }
210 }
211
212protected:
216 template <typename... LinOp>
217 void set_composition(LinOp&&... linop)
218 {
219 composition_ =
220 Composition<ValueType>::create(std::forward<LinOp>(linop)...);
221 }
222
223private:
224 std::shared_ptr<Composition<ValueType>> composition_;
225};
226
227
228} // namespace gko
229
230
231#endif // GKO_PUBLIC_CORE_BASE_COMPOSITION_HPP_
The Composition class can be used to compose linear operators op1, op2, ..., opn and obtain the opera...
Definition composition.hpp:41
Composition & operator=(const Composition &)
Copy-assigns a Composition.
Composition(Composition &&)
Move-constructs a Composition.
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
Composition(const Composition &)
Copy-constructs a Composition.
Composition & operator=(Composition &&)
Move-assigns a Composition.
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
const std::vector< std::shared_ptr< const LinOp > > & get_operators() const noexcept
Returns a list of operators of the composition.
Definition composition.hpp:54
This mixin implements a static create() method on ConcreteType that dynamically allocates the memory,...
Definition polymorphic_object.hpp:747
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:662
Definition lin_op.hpp:117
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:234
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:433
The UseComposition class can be used to store the composition information in LinOp.
Definition composition.hpp:178
std::shared_ptr< const LinOp > get_operator_at(size_type index) const
Returns the operator at index-th position of composition.
Definition composition.hpp:203
std::shared_ptr< Composition< ValueType > > get_composition() const
Returns the composition operators.
Definition composition.hpp:186
The Ginkgo namespace.
Definition abstract_factory.hpp:20
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:89
detail::cloned_type< Pointer > clone(const Pointer &p)
Creates a unique clone of the object pointed to by p.
Definition utils_helper.hpp:173
@ array
The matrix should be written as dense matrix in column-major order.