Ginkgo Generated from develop branch based on develop. Ginkgo version 1.8.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
ic.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_FACTORIZATION_IC_HPP_
6#define GKO_PUBLIC_CORE_FACTORIZATION_IC_HPP_
7
8
9#include <memory>
10
11
12#include <ginkgo/core/base/composition.hpp>
13#include <ginkgo/core/base/lin_op.hpp>
14#include <ginkgo/core/base/types.hpp>
15#include <ginkgo/core/matrix/csr.hpp>
16
17
18namespace gko {
24namespace factorization {
25
26
41template <typename ValueType = gko::default_precision,
42 typename IndexType = gko::int32>
43class Ic : public Composition<ValueType> {
44public:
45 using value_type = ValueType;
46 using index_type = IndexType;
48
49 std::shared_ptr<const matrix_type> get_l_factor() const
50 {
51 // Can be `static_cast` since the type is guaranteed in this class
52 return std::static_pointer_cast<const matrix_type>(
53 this->get_operators()[0]);
54 }
55
56 std::shared_ptr<const matrix_type> get_lt_factor() const
57 {
58 if (this->get_operators().size() == 2) {
59 // Can be `static_cast` since the type is guaranteed in this class
60 return std::static_pointer_cast<const matrix_type>(
61 this->get_operators()[1]);
62 } else {
63 return std::static_pointer_cast<const matrix_type>(
64 share(get_l_factor()->conj_transpose()));
65 }
66 }
67
68 // Remove the possibility of calling `create`, which was enabled by
69 // `Composition`
70 template <typename... Args>
71 static std::unique_ptr<Composition<ValueType>> create(Args&&... args) =
72 delete;
73
75 {
80 std::shared_ptr<typename matrix_type::strategy_type>
81 GKO_FACTORY_PARAMETER_SCALAR(l_strategy, nullptr);
82
93 bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
94
100 bool GKO_FACTORY_PARAMETER_SCALAR(both_factors, true);
101 };
104
105protected:
106 Ic(const Factory* factory, std::shared_ptr<const gko::LinOp> system_matrix)
107 : Composition<ValueType>{factory->get_executor()},
108 parameters_{factory->get_parameters()}
109 {
110 if (parameters_.l_strategy == nullptr) {
111 parameters_.l_strategy =
112 std::make_shared<typename matrix_type::classical>();
113 }
114 generate(system_matrix, parameters_.skip_sorting,
115 parameters_.both_factors)
116 ->move_to(this);
117 }
118
119 std::unique_ptr<Composition<ValueType>> generate(
120 const std::shared_ptr<const LinOp>& system_matrix, bool skip_sorting,
121 bool both_factors) const;
122};
123
124
125} // namespace factorization
126} // namespace gko
127
128
129#endif // GKO_PUBLIC_CORE_FACTORIZATION_IC_HPP_
The Composition class can be used to compose linear operators op1, op2, ..., opn and obtain the opera...
Definition composition.hpp:41
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
Definition ic.hpp:102
Represents an incomplete Cholesky factorization (IC(0)) of a sparse matrix.
Definition ic.hpp:43
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:117
#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
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)
Creates a scalar factory parameter in the factory parameters structure.
Definition abstract_factory.hpp:445
#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
#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
The Ginkgo namespace.
Definition abstract_factory.hpp:20
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:775
std::int32_t int32
32-bit signed integral type.
Definition types.hpp:109
double default_precision
Precision used if no precision is explicitly specified.
Definition types.hpp:177
detail::shared_type< OwningPointer > share(OwningPointer &&p)
Marks the object pointed to by p as shared.
Definition utils_helper.hpp:226
std::shared_ptr< typename matrix_type::strategy_type > l_strategy
Strategy which will be used by the L matrix.
Definition ic.hpp:81
bool skip_sorting
The system_matrix, which will be given to this factory, must be sorted (first by row,...
Definition ic.hpp:93
bool both_factors
true will generate both L and L^H, false will only generate the L factor, resulting in a Composition ...
Definition ic.hpp:100