Ginkgo  Generated from pipelines/2662685947 branch based on develop. Ginkgo version 2.0.0
A numerical linear algebra library targeting many-core architectures
triangular.hpp
1 // SPDX-FileCopyrightText: 2017 - 2026 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 LinOp,
66  public EnableSolverBase<LowerTrs<ValueType, IndexType>,
67  matrix::Csr<ValueType, IndexType>>,
68  public Transposable {
69  friend class UpperTrs<ValueType, IndexType>;
70  GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
71 
72 public:
73  using value_type = ValueType;
74  using index_type = IndexType;
75  using transposed_type = UpperTrs<ValueType, IndexType>;
76 
77  std::unique_ptr<LinOp> transpose() const override;
78 
79  std::unique_ptr<LinOp> conj_transpose() const override;
80 
81  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
82  {
89  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
90 
95  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
96 
103  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
104  algorithm, trisolve_algorithm::sparselib);
105  };
106  GKO_ENABLE_LIN_OP_FACTORY(LowerTrs, parameters, Factory);
107  GKO_ENABLE_BUILD_METHOD(Factory);
108 
122  static parameters_type parse(
123  const config::pnode& config, const config::registry& context,
124  const config::type_descriptor& td_for_child =
125  config::make_type_descriptor<ValueType, IndexType>());
126 
132  LowerTrs(const LowerTrs&);
133 
140  LowerTrs(LowerTrs&&);
141 
147  LowerTrs& operator=(const LowerTrs&);
148 
154  LowerTrs& operator=(LowerTrs&&);
155 
156 protected:
157  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
158 
159  void apply_impl(const LinOp* b, LinOp* x) const override;
160 
161  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
162  LinOp* x) const override;
163 
168  void generate();
169 
170  explicit LowerTrs(std::shared_ptr<const Executor> exec)
171  : LinOp(std::move(exec))
172  {}
173 
174  explicit LowerTrs(const Factory* factory,
175  std::shared_ptr<const LinOp> system_matrix)
176  : LinOp(factory->get_executor(),
177  gko::transpose(system_matrix->get_size())),
178  EnableSolverBase<LowerTrs<ValueType, IndexType>, CsrMatrix>{
179  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
180  system_matrix)},
181  parameters_{factory->get_parameters()}
182  {
183  this->generate();
184  }
185 
186 private:
187  std::shared_ptr<solver::SolveStruct> solve_struct_;
188 };
189 
190 
191 template <typename ValueType, typename IndexType>
192 struct workspace_traits<LowerTrs<ValueType, IndexType>> {
193  using Solver = LowerTrs<ValueType, IndexType>;
194  // number of vectors used by this workspace
195  static int num_vectors(const Solver&);
196  // number of arrays used by this workspace
197  static int num_arrays(const Solver&);
198  // array containing the num_vectors names for the workspace vectors
199  static std::vector<std::string> op_names(const Solver&);
200  // array containing the num_arrays names for the workspace vectors
201  static std::vector<std::string> array_names(const Solver&);
202  // array containing all varying scalar vectors (independent of problem size)
203  static std::vector<int> scalars(const Solver&);
204  // array containing all varying vectors (dependent on problem size)
205  static std::vector<int> vectors(const Solver&);
206 
207  // transposed input vector
208  constexpr static int transposed_b = 0;
209  // transposed output vector
210  constexpr static int transposed_x = 1;
211 };
212 
213 
231 template <typename ValueType = default_precision, typename IndexType = int32>
232 class UpperTrs : public LinOp,
233  public EnableSolverBase<UpperTrs<ValueType, IndexType>,
234  matrix::Csr<ValueType, IndexType>>,
235  public Transposable {
236  friend class LowerTrs<ValueType, IndexType>;
237  GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
238 
239 public:
240  using value_type = ValueType;
241  using index_type = IndexType;
242  using transposed_type = LowerTrs<ValueType, IndexType>;
243 
244  std::unique_ptr<LinOp> transpose() const override;
245 
246  std::unique_ptr<LinOp> conj_transpose() const override;
247 
248  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
249  {
256  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
257 
262  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
263 
270  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
271  algorithm, trisolve_algorithm::sparselib);
272  };
273  GKO_ENABLE_LIN_OP_FACTORY(UpperTrs, parameters, Factory);
274  GKO_ENABLE_BUILD_METHOD(Factory);
275 
289  static parameters_type parse(
290  const config::pnode& config, const config::registry& context,
291  const config::type_descriptor& td_for_child =
292  config::make_type_descriptor<ValueType, IndexType>());
293 
299  UpperTrs(const UpperTrs&);
300 
307  UpperTrs(UpperTrs&&);
308 
314  UpperTrs& operator=(const UpperTrs&);
315 
321  UpperTrs& operator=(UpperTrs&&);
322 
323 protected:
324  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
325 
326  void apply_impl(const LinOp* b, LinOp* x) const override;
327 
328  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
329  LinOp* x) const override;
330 
335  void generate();
336 
337  explicit UpperTrs(std::shared_ptr<const Executor> exec)
338  : LinOp(std::move(exec))
339  {}
340 
341  explicit UpperTrs(const Factory* factory,
342  std::shared_ptr<const LinOp> system_matrix)
343  : LinOp(factory->get_executor(),
344  gko::transpose(system_matrix->get_size())),
345  EnableSolverBase<UpperTrs<ValueType, IndexType>, CsrMatrix>{
346  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
347  system_matrix)},
348  parameters_{factory->get_parameters()}
349  {
350  this->generate();
351  }
352 
353 private:
354  std::shared_ptr<solver::SolveStruct> solve_struct_;
355 };
356 
357 
358 template <typename ValueType, typename IndexType>
359 struct workspace_traits<UpperTrs<ValueType, IndexType>> {
360  using Solver = UpperTrs<ValueType, IndexType>;
361  // number of vectors used by this workspace
362  static int num_vectors(const Solver&);
363  // number of arrays used by this workspace
364  static int num_arrays(const Solver&);
365  // array containing the num_vectors names for the workspace vectors
366  static std::vector<std::string> op_names(const Solver&);
367  // array containing the num_arrays names for the workspace vectors
368  static std::vector<std::string> array_names(const Solver&);
369  // array containing all varying scalar vectors (independent of problem size)
370  static std::vector<int> scalars(const Solver&);
371  // array containing all varying vectors (dependent on problem size)
372  static std::vector<int> vectors(const Solver&);
373 
374  // transposed input vector
375  constexpr static int transposed_b = 0;
376  // transposed output vector
377  constexpr static int transposed_x = 1;
378 };
379 
380 
381 } // namespace solver
382 } // namespace gko
383 
384 
385 #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:106
gko::Transposable
Linear operators which support transposition should implement the Transposable interface.
Definition: lin_op.hpp:392
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:437
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:900
gko::solver::UpperTrs::Factory
Definition: triangular.hpp:273
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:386
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:272
gko::PolymorphicObject::get_executor
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition: polymorphic_object.hpp:62
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:169
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::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