Ginkgo  Generated from pipelines/1589998975 branch based on develop. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
triangular.hpp
1 // SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2 //
3 // SPDX-License-Identifier: BSD-3-Clause
4 
5 #ifndef GKO_PUBLIC_CORE_SOLVER_TRIANGULAR_HPP_
6 #define GKO_PUBLIC_CORE_SOLVER_TRIANGULAR_HPP_
7 
8 
9 #include <memory>
10 #include <utility>
11 
12 #include <ginkgo/core/base/abstract_factory.hpp>
13 #include <ginkgo/core/base/array.hpp>
14 #include <ginkgo/core/base/dim.hpp>
15 #include <ginkgo/core/base/exception_helpers.hpp>
16 #include <ginkgo/core/base/lin_op.hpp>
17 #include <ginkgo/core/base/polymorphic_object.hpp>
18 #include <ginkgo/core/base/types.hpp>
19 #include <ginkgo/core/base/utils.hpp>
20 #include <ginkgo/core/config/config.hpp>
21 #include <ginkgo/core/config/registry.hpp>
22 #include <ginkgo/core/log/logger.hpp>
23 #include <ginkgo/core/matrix/csr.hpp>
24 #include <ginkgo/core/matrix/identity.hpp>
25 #include <ginkgo/core/solver/solver_base.hpp>
26 
27 
28 namespace gko {
29 namespace solver {
30 
31 
32 struct SolveStruct;
33 
34 
40 enum class trisolve_algorithm { sparselib, syncfree };
41 
42 
43 template <typename ValueType, typename IndexType>
44 class UpperTrs;
45 
46 
64 template <typename ValueType = default_precision, typename IndexType = int32>
65 class LowerTrs : public EnableLinOp<LowerTrs<ValueType, IndexType>>,
66  public EnableSolverBase<LowerTrs<ValueType, IndexType>,
67  matrix::Csr<ValueType, IndexType>>,
68  public Transposable {
69  friend class EnableLinOp<LowerTrs>;
70  friend class EnablePolymorphicObject<LowerTrs, LinOp>;
71  friend class UpperTrs<ValueType, IndexType>;
72 
73 public:
74  using value_type = ValueType;
75  using index_type = IndexType;
76  using transposed_type = UpperTrs<ValueType, IndexType>;
77 
78  std::unique_ptr<LinOp> transpose() const override;
79 
80  std::unique_ptr<LinOp> conj_transpose() const override;
81 
82  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
83  {
90  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
91 
96  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
97 
104  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
105  algorithm, trisolve_algorithm::sparselib);
106  };
107  GKO_ENABLE_LIN_OP_FACTORY(LowerTrs, parameters, Factory);
108  GKO_ENABLE_BUILD_METHOD(Factory);
109 
123  static parameters_type parse(
124  const config::pnode& config, const config::registry& context,
125  const config::type_descriptor& td_for_child =
126  config::make_type_descriptor<ValueType, IndexType>());
127 
133  LowerTrs(const LowerTrs&);
134 
141  LowerTrs(LowerTrs&&);
142 
148  LowerTrs& operator=(const LowerTrs&);
149 
155  LowerTrs& operator=(LowerTrs&&);
156 
157 protected:
158  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
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 
169  void generate();
170 
171  explicit LowerTrs(std::shared_ptr<const Executor> exec)
172  : EnableLinOp<LowerTrs>(std::move(exec))
173  {}
174 
175  explicit LowerTrs(const Factory* factory,
176  std::shared_ptr<const LinOp> system_matrix)
177  : EnableLinOp<LowerTrs>(factory->get_executor(),
178  gko::transpose(system_matrix->get_size())),
179  EnableSolverBase<LowerTrs<ValueType, IndexType>, CsrMatrix>{
180  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
181  system_matrix)},
182  parameters_{factory->get_parameters()}
183  {
184  this->generate();
185  }
186 
187 private:
188  std::shared_ptr<solver::SolveStruct> solve_struct_;
189 };
190 
191 
192 template <typename ValueType, typename IndexType>
193 struct workspace_traits<LowerTrs<ValueType, IndexType>> {
194  using Solver = LowerTrs<ValueType, IndexType>;
195  // number of vectors used by this workspace
196  static int num_vectors(const Solver&);
197  // number of arrays used by this workspace
198  static int num_arrays(const Solver&);
199  // array containing the num_vectors names for the workspace vectors
200  static std::vector<std::string> op_names(const Solver&);
201  // array containing the num_arrays names for the workspace vectors
202  static std::vector<std::string> array_names(const Solver&);
203  // array containing all varying scalar vectors (independent of problem size)
204  static std::vector<int> scalars(const Solver&);
205  // array containing all varying vectors (dependent on problem size)
206  static std::vector<int> vectors(const Solver&);
207 
208  // transposed input vector
209  constexpr static int transposed_b = 0;
210  // transposed output vector
211  constexpr static int transposed_x = 1;
212 };
213 
214 
232 template <typename ValueType = default_precision, typename IndexType = int32>
233 class UpperTrs : public EnableLinOp<UpperTrs<ValueType, IndexType>>,
234  public EnableSolverBase<UpperTrs<ValueType, IndexType>,
235  matrix::Csr<ValueType, IndexType>>,
236  public Transposable {
237  friend class EnableLinOp<UpperTrs>;
238  friend class EnablePolymorphicObject<UpperTrs, LinOp>;
239  friend class LowerTrs<ValueType, IndexType>;
240 
241 public:
242  using value_type = ValueType;
243  using index_type = IndexType;
244  using transposed_type = LowerTrs<ValueType, IndexType>;
245 
246  std::unique_ptr<LinOp> transpose() const override;
247 
248  std::unique_ptr<LinOp> conj_transpose() const override;
249 
250  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
251  {
258  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
259 
264  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
265 
272  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
273  algorithm, trisolve_algorithm::sparselib);
274  };
275  GKO_ENABLE_LIN_OP_FACTORY(UpperTrs, parameters, Factory);
276  GKO_ENABLE_BUILD_METHOD(Factory);
277 
291  static parameters_type parse(
292  const config::pnode& config, const config::registry& context,
293  const config::type_descriptor& td_for_child =
294  config::make_type_descriptor<ValueType, IndexType>());
295 
301  UpperTrs(const UpperTrs&);
302 
309  UpperTrs(UpperTrs&&);
310 
316  UpperTrs& operator=(const UpperTrs&);
317 
323  UpperTrs& operator=(UpperTrs&&);
324 
325 protected:
326  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
327 
328  void apply_impl(const LinOp* b, LinOp* x) const override;
329 
330  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
331  LinOp* x) const override;
332 
337  void generate();
338 
339  explicit UpperTrs(std::shared_ptr<const Executor> exec)
340  : EnableLinOp<UpperTrs>(std::move(exec))
341  {}
342 
343  explicit UpperTrs(const Factory* factory,
344  std::shared_ptr<const LinOp> system_matrix)
345  : EnableLinOp<UpperTrs>(factory->get_executor(),
346  gko::transpose(system_matrix->get_size())),
347  EnableSolverBase<UpperTrs<ValueType, IndexType>, CsrMatrix>{
348  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
349  system_matrix)},
350  parameters_{factory->get_parameters()}
351  {
352  this->generate();
353  }
354 
355 private:
356  std::shared_ptr<solver::SolveStruct> solve_struct_;
357 };
358 
359 
360 template <typename ValueType, typename IndexType>
361 struct workspace_traits<UpperTrs<ValueType, IndexType>> {
362  using Solver = UpperTrs<ValueType, IndexType>;
363  // number of vectors used by this workspace
364  static int num_vectors(const Solver&);
365  // number of arrays used by this workspace
366  static int num_arrays(const Solver&);
367  // array containing the num_vectors names for the workspace vectors
368  static std::vector<std::string> op_names(const Solver&);
369  // array containing the num_arrays names for the workspace vectors
370  static std::vector<std::string> array_names(const Solver&);
371  // array containing all varying scalar vectors (independent of problem size)
372  static std::vector<int> scalars(const Solver&);
373  // array containing all varying vectors (dependent on problem size)
374  static std::vector<int> vectors(const Solver&);
375 
376  // transposed input vector
377  constexpr static int transposed_b = 0;
378  // transposed output vector
379  constexpr static int transposed_x = 1;
380 };
381 
382 
383 } // namespace solver
384 } // namespace gko
385 
386 
387 #endif // GKO_PUBLIC_CORE_SOLVER_TRIANGULAR_HPP_
gko::solver::UpperTrs::UpperTrs
UpperTrs(const UpperTrs &)
Copy-assigns a triangular solver.
gko::matrix::Csr
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition: matrix.hpp:28
gko::config::pnode
pnode describes a tree of properties.
Definition: property_tree.hpp:28
gko::log::profile_event_category::solver
Solver events.
gko::LinOp
Definition: lin_op.hpp:117
gko::solver::LowerTrs::Factory
Definition: triangular.hpp:107
gko::Transposable
Linear operators which support transposition should implement the Transposable interface.
Definition: lin_op.hpp:433
gko::size_type
std::size_t size_type
Integral type used for allocation quantities.
Definition: types.hpp:89
gko::solver::LowerTrs::conj_transpose
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
GKO_FACTORY_PARAMETER_SCALAR
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)
Creates a scalar factory parameter in the factory parameters structure.
Definition: abstract_factory.hpp:445
gko::config::type_descriptor
This class describes the value and index types to be used when building a Ginkgo type from a configur...
Definition: type_descriptor.hpp:39
gko::solver::LowerTrs
LowerTrs is the triangular solver which solves the system L x = b, when L is a lower triangular matri...
Definition: triangular.hpp:65
gko
The Ginkgo namespace.
Definition: abstract_factory.hpp:20
gko::solver::LowerTrs::operator=
LowerTrs & operator=(const LowerTrs &)
Copy-constructs a triangular solver.
GKO_ENABLE_LIN_OP_FACTORY
#define GKO_ENABLE_LIN_OP_FACTORY(_lin_op, _parameters_name, _factory_name)
This macro will generate a default implementation of a LinOpFactory for the LinOp subclass it is defi...
Definition: lin_op.hpp:1017
gko::solver::UpperTrs::Factory
Definition: triangular.hpp:275
gko::solver::LowerTrs::transpose
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
gko::solver::UpperTrs::conj_transpose
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
gko::solver::UpperTrs::transpose
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
gko::solver::LowerTrs::parse
static parameters_type parse(const config::pnode &config, const config::registry &context, const config::type_descriptor &td_for_child=config::make_type_descriptor< ValueType, IndexType >())
Create the parameters from the property_tree.
gko::solver::UpperTrs::operator=
UpperTrs & operator=(const UpperTrs &)
Copy-constructs a triangular solver.
gko::solver::LowerTrs::LowerTrs
LowerTrs(const LowerTrs &)
Copy-assigns a triangular solver.
gko::solver::EnableSolverBase
A LinOp deriving from this CRTP class stores a system matrix.
Definition: solver_base.hpp:541
gko::solver::trisolve_algorithm
trisolve_algorithm
A helper for algorithm selection in the triangular solvers.
Definition: triangular.hpp:40
gko::config::registry
This class stores additional context for creating Ginkgo objects from configuration files.
Definition: registry.hpp:167
GKO_ENABLE_BUILD_METHOD
#define GKO_ENABLE_BUILD_METHOD(_factory_name)
Defines a build method for the factory, simplifying its construction by removing the repetitive typin...
Definition: abstract_factory.hpp:394
GKO_CREATE_FACTORY_PARAMETERS
#define GKO_CREATE_FACTORY_PARAMETERS(_parameters_name, _factory_name)
This Macro will generate a new type containing the parameters for the factory _factory_name.
Definition: abstract_factory.hpp:280
gko::PolymorphicObject::get_executor
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition: polymorphic_object.hpp:243
gko::solver::workspace_traits
Traits class providing information on the type and location of workspace vectors inside a solver.
Definition: solver_base.hpp:238
gko::LinOp::get_size
const dim< 2 > & get_size() const noexcept
Returns the size of the operator.
Definition: lin_op.hpp:210
gko::solver::UpperTrs
UpperTrs is the triangular solver which solves the system U x = b, when U is an upper triangular matr...
Definition: triangular.hpp:44
gko::EnableLinOp
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition: lin_op.hpp:877
gko::EnablePolymorphicObject
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition: polymorphic_object.hpp:667
gko::solver::UpperTrs::parse
static parameters_type parse(const config::pnode &config, const config::registry &context, const config::type_descriptor &td_for_child=config::make_type_descriptor< ValueType, IndexType >())
Create the parameters from the property_tree.
Generated by   doxygen 1.8.16