Ginkgo  Generated from pipelines/1330831941 branch based on master. Ginkgo version 1.8.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 
13 #include <ginkgo/core/base/abstract_factory.hpp>
14 #include <ginkgo/core/base/array.hpp>
15 #include <ginkgo/core/base/dim.hpp>
16 #include <ginkgo/core/base/exception_helpers.hpp>
17 #include <ginkgo/core/base/lin_op.hpp>
18 #include <ginkgo/core/base/polymorphic_object.hpp>
19 #include <ginkgo/core/base/types.hpp>
20 #include <ginkgo/core/base/utils.hpp>
21 #include <ginkgo/core/config/config.hpp>
22 #include <ginkgo/core/config/registry.hpp>
23 #include <ginkgo/core/log/logger.hpp>
24 #include <ginkgo/core/matrix/csr.hpp>
25 #include <ginkgo/core/matrix/identity.hpp>
26 #include <ginkgo/core/solver/solver_base.hpp>
27 
28 
29 namespace gko {
30 namespace solver {
31 
32 
33 struct SolveStruct;
34 
35 
41 enum class trisolve_algorithm { sparselib, syncfree };
42 
43 
44 template <typename ValueType, typename IndexType>
45 class UpperTrs;
46 
47 
65 template <typename ValueType = default_precision, typename IndexType = int32>
66 class LowerTrs : public EnableLinOp<LowerTrs<ValueType, IndexType>>,
67  public EnableSolverBase<LowerTrs<ValueType, IndexType>,
68  matrix::Csr<ValueType, IndexType>>,
69  public Transposable {
70  friend class EnableLinOp<LowerTrs>;
71  friend class EnablePolymorphicObject<LowerTrs, LinOp>;
72  friend class UpperTrs<ValueType, IndexType>;
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 
242 public:
243  using value_type = ValueType;
244  using index_type = IndexType;
245  using transposed_type = LowerTrs<ValueType, IndexType>;
246 
247  std::unique_ptr<LinOp> transpose() const override;
248 
249  std::unique_ptr<LinOp> conj_transpose() const override;
250 
251  GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
252  {
259  gko::size_type GKO_FACTORY_PARAMETER_SCALAR(num_rhs, 1u);
260 
265  bool GKO_FACTORY_PARAMETER_SCALAR(unit_diagonal, false);
266 
273  trisolve_algorithm GKO_FACTORY_PARAMETER_SCALAR(
274  algorithm, trisolve_algorithm::sparselib);
275  };
276  GKO_ENABLE_LIN_OP_FACTORY(UpperTrs, parameters, Factory);
277  GKO_ENABLE_BUILD_METHOD(Factory);
278 
292  static parameters_type parse(
293  const config::pnode& config, const config::registry& context,
294  const config::type_descriptor& td_for_child =
295  config::make_type_descriptor<ValueType, IndexType>());
296 
302  UpperTrs(const UpperTrs&);
303 
310  UpperTrs(UpperTrs&&);
311 
317  UpperTrs& operator=(const UpperTrs&);
318 
324  UpperTrs& operator=(UpperTrs&&);
325 
326 protected:
327  using CsrMatrix = matrix::Csr<ValueType, IndexType>;
328 
329  void apply_impl(const LinOp* b, LinOp* x) const override;
330 
331  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
332  LinOp* x) const override;
333 
338  void generate();
339 
340  explicit UpperTrs(std::shared_ptr<const Executor> exec)
341  : EnableLinOp<UpperTrs>(std::move(exec))
342  {}
343 
344  explicit UpperTrs(const Factory* factory,
345  std::shared_ptr<const LinOp> system_matrix)
346  : EnableLinOp<UpperTrs>(factory->get_executor(),
347  gko::transpose(system_matrix->get_size())),
348  EnableSolverBase<UpperTrs<ValueType, IndexType>, CsrMatrix>{
349  copy_and_convert_to<CsrMatrix>(factory->get_executor(),
350  system_matrix)},
351  parameters_{factory->get_parameters()}
352  {
353  this->generate();
354  }
355 
356 private:
357  std::shared_ptr<solver::SolveStruct> solve_struct_;
358 };
359 
360 
361 template <typename ValueType, typename IndexType>
362 struct workspace_traits<UpperTrs<ValueType, IndexType>> {
363  using Solver = UpperTrs<ValueType, IndexType>;
364  // number of vectors used by this workspace
365  static int num_vectors(const Solver&);
366  // number of arrays used by this workspace
367  static int num_arrays(const Solver&);
368  // array containing the num_vectors names for the workspace vectors
369  static std::vector<std::string> op_names(const Solver&);
370  // array containing the num_arrays names for the workspace vectors
371  static std::vector<std::string> array_names(const Solver&);
372  // array containing all varying scalar vectors (independent of problem size)
373  static std::vector<int> scalars(const Solver&);
374  // array containing all varying vectors (dependent on problem size)
375  static std::vector<int> vectors(const Solver&);
376 
377  // transposed input vector
378  constexpr static int transposed_b = 0;
379  // transposed output vector
380  constexpr static int transposed_x = 1;
381 };
382 
383 
384 } // namespace solver
385 } // namespace gko
386 
387 
388 #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:27
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:118
gko::solver::LowerTrs::Factory
Definition: triangular.hpp:108
gko::Transposable
Linear operators which support transposition should implement the Transposable interface.
Definition: lin_op.hpp:434
gko::size_type
std::size_t size_type
Integral type used for allocation quantities.
Definition: types.hpp:108
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:37
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:66
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:1018
gko::solver::UpperTrs::Factory
Definition: triangular.hpp:276
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:542
gko::solver::trisolve_algorithm
trisolve_algorithm
A helper for algorithm selection in the triangular solvers.
Definition: triangular.hpp:41
gko::config::registry
This class stores additional context for creating Ginkgo objects from configuration files.
Definition: registry.hpp:168
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:235
gko::solver::workspace_traits
Traits class providing information on the type and location of workspace vectors inside a solver.
Definition: solver_base.hpp:239
gko::LinOp::get_size
const dim< 2 > & get_size() const noexcept
Returns the size of the operator.
Definition: lin_op.hpp:211
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:45
gko::EnableLinOp
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition: lin_op.hpp:878
gko::EnablePolymorphicObject
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition: polymorphic_object.hpp:662
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