Ginkgo  Generated from pipelines/2171896597 branch based on develop. Ginkgo version 1.11.0
A numerical linear algebra library targeting many-core architectures
triangular.hpp
1 // SPDX-FileCopyrightText: 2017 - 2025 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  GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
73 
74 public:
75  using value_type = ValueType;
76  using index_type = IndexType;
77  using transposed_type = UpperTrs<ValueType, IndexType>;
78 
79  std::unique_ptr<LinOp> transpose() const override;
80 
81  std::unique_ptr<LinOp> conj_transpose() const override;
82 
83  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
84  {
91  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
92 
97  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
98 
105  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
106  algorithm, trisolve_algorithm::sparselib);
107  };
108  GKO_ENABLE_LIN_OP_FACTORY(LowerTrs, parameters, Factory);
109  GKO_ENABLE_BUILD_METHOD(Factory);
110 
124  static parameters_type parse(
125  const config::pnode& config, const config::registry& context,
126  const config::type_descriptor& td_for_child =
127  config::make_type_descriptor<ValueType, IndexType>());
128 
134  LowerTrs(const LowerTrs&);
135 
142  LowerTrs(LowerTrs&&);
143 
149  LowerTrs& operator=(const LowerTrs&);
150 
156  LowerTrs& operator=(LowerTrs&&);
157 
158 protected:
159  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
160 
161  void apply_impl(const LinOp* b, LinOp* x) const override;
162 
163  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
164  LinOp* x) const override;
165 
170  void generate();
171 
172  explicit LowerTrs(std::shared_ptr<const Executor> exec)
173  : EnableLinOp<LowerTrs>(std::move(exec))
174  {}
175 
176  explicit LowerTrs(const Factory* factory,
177  std::shared_ptr<const LinOp> system_matrix)
178  : EnableLinOp<LowerTrs>(factory->get_executor(),
179  gko::transpose(system_matrix->get_size())),
180  EnableSolverBase<LowerTrs<ValueType, IndexType>, CsrMatrix>{
181  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
182  system_matrix)},
183  parameters_{factory->get_parameters()}
184  {
185  this->generate();
186  }
187 
188 private:
189  std::shared_ptr<solver::SolveStruct> solve_struct_;
190 };
191 
192 
193 template <typename ValueType, typename IndexType>
194 struct workspace_traits<LowerTrs<ValueType, IndexType>> {
195  using Solver = LowerTrs<ValueType, IndexType>;
196  // number of vectors used by this workspace
197  static int num_vectors(const Solver&);
198  // number of arrays used by this workspace
199  static int num_arrays(const Solver&);
200  // array containing the num_vectors names for the workspace vectors
201  static std::vector<std::string> op_names(const Solver&);
202  // array containing the num_arrays names for the workspace vectors
203  static std::vector<std::string> array_names(const Solver&);
204  // array containing all varying scalar vectors (independent of problem size)
205  static std::vector<int> scalars(const Solver&);
206  // array containing all varying vectors (dependent on problem size)
207  static std::vector<int> vectors(const Solver&);
208 
209  // transposed input vector
210  constexpr static int transposed_b = 0;
211  // transposed output vector
212  constexpr static int transposed_x = 1;
213 };
214 
215 
233 template <typename ValueType = default_precision, typename IndexType = int32>
234 class UpperTrs : public EnableLinOp<UpperTrs<ValueType, IndexType>>,
235  public EnableSolverBase<UpperTrs<ValueType, IndexType>,
236  matrix::Csr<ValueType, IndexType>>,
237  public Transposable {
238  friend class EnableLinOp<UpperTrs>;
239  friend class EnablePolymorphicObject<UpperTrs, LinOp>;
240  friend class LowerTrs<ValueType, IndexType>;
241  GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
242 
243 public:
244  using value_type = ValueType;
245  using index_type = IndexType;
246  using transposed_type = LowerTrs<ValueType, IndexType>;
247 
248  std::unique_ptr<LinOp> transpose() const override;
249 
250  std::unique_ptr<LinOp> conj_transpose() const override;
251 
252  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
253  {
260  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
261 
266  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
267 
274  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
275  algorithm, trisolve_algorithm::sparselib);
276  };
277  GKO_ENABLE_LIN_OP_FACTORY(UpperTrs, parameters, Factory);
278  GKO_ENABLE_BUILD_METHOD(Factory);
279 
293  static parameters_type parse(
294  const config::pnode& config, const config::registry& context,
295  const config::type_descriptor& td_for_child =
296  config::make_type_descriptor<ValueType, IndexType>());
297 
303  UpperTrs(const UpperTrs&);
304 
311  UpperTrs(UpperTrs&&);
312 
318  UpperTrs& operator=(const UpperTrs&);
319 
325  UpperTrs& operator=(UpperTrs&&);
326 
327 protected:
328  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
329 
330  void apply_impl(const LinOp* b, LinOp* x) const override;
331 
332  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
333  LinOp* x) const override;
334 
339  void generate();
340 
341  explicit UpperTrs(std::shared_ptr<const Executor> exec)
342  : EnableLinOp<UpperTrs>(std::move(exec))
343  {}
344 
345  explicit UpperTrs(const Factory* factory,
346  std::shared_ptr<const LinOp> system_matrix)
347  : EnableLinOp<UpperTrs>(factory->get_executor(),
348  gko::transpose(system_matrix->get_size())),
349  EnableSolverBase<UpperTrs<ValueType, IndexType>, CsrMatrix>{
350  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
351  system_matrix)},
352  parameters_{factory->get_parameters()}
353  {
354  this->generate();
355  }
356 
357 private:
358  std::shared_ptr<solver::SolveStruct> solve_struct_;
359 };
360 
361 
362 template <typename ValueType, typename IndexType>
363 struct workspace_traits<UpperTrs<ValueType, IndexType>> {
364  using Solver = UpperTrs<ValueType, IndexType>;
365  // number of vectors used by this workspace
366  static int num_vectors(const Solver&);
367  // number of arrays used by this workspace
368  static int num_arrays(const Solver&);
369  // array containing the num_vectors names for the workspace vectors
370  static std::vector<std::string> op_names(const Solver&);
371  // array containing the num_arrays names for the workspace vectors
372  static std::vector<std::string> array_names(const Solver&);
373  // array containing all varying scalar vectors (independent of problem size)
374  static std::vector<int> scalars(const Solver&);
375  // array containing all varying vectors (dependent on problem size)
376  static std::vector<int> vectors(const Solver&);
377 
378  // transposed input vector
379  constexpr static int transposed_b = 0;
380  // transposed output vector
381  constexpr static int transposed_x = 1;
382 };
383 
384 
385 } // namespace solver
386 } // namespace gko
387 
388 
389 #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:30
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:108
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:90
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:277
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:556
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