Ginkgo: ginkgo/core/factorization/par_ict.hpp Source File

| Ginkgo Generated from branch based on main. Ginkgo version 1.11.0 A numerical linear algebra library targeting many-core architectures

Loading...
Searching...
No Matches
par_ict.hpp
1// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
6#define GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
7
8
9#include <memory>
10
11#include <ginkgo/core/base/composition.hpp>
12#include <ginkgo/core/base/lin_op.hpp>
13#include <ginkgo/core/base/types.hpp>
14#include <ginkgo/core/config/config.hpp>
15#include <ginkgo/core/config/registry.hpp>
16#include <ginkgo/core/matrix/csr.hpp>
17
18
19namespace gko {
25namespace factorization {
26
27
68template <typename ValueType = default_precision, typename IndexType = int32>
69 class ParIct : public Composition<ValueType> {
70 GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
71
72public:
73 using value_type = ValueType;
74 using index_type = IndexType;
75 using matrix_type = matrix::Csr<ValueType, IndexType>;
76
77 std::shared_ptr<const matrix_type> get_l_factor() const
78 {
79 // Can be `static_cast` since the type is guaranteed in this class
80 return std::static_pointer_cast<const matrix_type>(
81 this->get_operators()[0]);
82 }
83
84 std::shared_ptr<const matrix_type> get_lt_factor() const
85 {
86 // Can be `static_cast` since the type is guaranteed in this class
87 return std::static_pointer_cast<const matrix_type>(
88 this->get_operators()[1]);
89 }
90
91 // Remove the possibility of calling `create`, which was enabled by
92 // `Composition`
93 template <typename... Args>
94 static std::unique_ptr<Composition<ValueType>> create(Args&&... args) =
95 delete;
96
97 GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
98 {
103 size_type GKO_FACTORY_PARAMETER_SCALAR(iterations, 5);
104
122 bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
123
138 bool GKO_FACTORY_PARAMETER_SCALAR(approximate_select, true);
139
157 bool GKO_FACTORY_PARAMETER_SCALAR(deterministic_sample, false);
158
171 double GKO_FACTORY_PARAMETER_SCALAR(fill_in_limit, 2.0);
172
177 std::shared_ptr<typename matrix_type::strategy_type>
178 GKO_FACTORY_PARAMETER_SCALAR(l_strategy, nullptr);
179
184 std::shared_ptr<typename matrix_type::strategy_type>
185 GKO_FACTORY_PARAMETER_SCALAR(lt_strategy, nullptr);
186 };
187 GKO_ENABLE_LIN_OP_FACTORY(ParIct, parameters, Factory);
188 GKO_ENABLE_BUILD_METHOD(Factory);
189
203 static parameters_type parse(
204 const config::pnode& config, const config::registry& context,
205 const config::type_descriptor& td_for_child =
206 config::make_type_descriptor<ValueType, IndexType>());
207
208protected:
209 explicit ParIct(const Factory* factory,
210 std::shared_ptr<const LinOp> system_matrix)
211 : Composition<ValueType>(factory->get_executor()),
212 parameters_{factory->get_parameters()}
213 {
214 if (parameters_.l_strategy == nullptr) {
215 parameters_.l_strategy =
216 std::make_shared<typename matrix_type::classical>();
217 }
218 if (parameters_.lt_strategy == nullptr) {
219 parameters_.lt_strategy =
220 std::make_shared<typename matrix_type::classical>();
221 }
222 generate_l_lt(std::move(system_matrix))->move_to(this);
223 }
224
237 std::unique_ptr<Composition<ValueType>> generate_l_lt(
238 const std::shared_ptr<const LinOp>& system_matrix) const;
239};
240
241
242} // namespace factorization
243} // namespace gko
244
245
246#endif // GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
gko::Composition< default_precision >::Composition
Composition(const Composition &)
gko::Composition< default_precision >::get_operators
const std::vector< std::shared_ptr< const LinOp > > & get_operators() const noexcept
Definition composition.hpp:55
gko::config::pnode
pnode describes a tree of properties.
Definition property_tree.hpp:28
gko::config::registry
This class stores additional context for creating Ginkgo objects from configuration files.
Definition registry.hpp:167
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::factorization::ParIct::Factory
Definition par_ict.hpp:187
gko::factorization::ParIct::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::matrix::Csr
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:126
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_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_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_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::factorization
The Factorization namespace.
Definition ic.hpp:26
gko
The Ginkgo namespace.
Definition abstract_factory.hpp:20
gko::size_type
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:90
gko::factorization::ParIct::parameters_type
Definition par_ict.hpp:98
gko::factorization::ParIct::parameters_type::approximate_select
bool approximate_select
true means the candidate selection will use an inexact selection algorithm.
Definition par_ict.hpp:138
gko::factorization::ParIct::parameters_type::skip_sorting
bool skip_sorting
true means it is known that the matrix given to this factory will be sorted first by row,...
Definition par_ict.hpp:122
gko::factorization::ParIct::parameters_type::l_strategy
std::shared_ptr< typename matrix_type::strategy_type > l_strategy
Strategy which will be used by the L matrix.
Definition par_ict.hpp:178
gko::factorization::ParIct::parameters_type::iterations
size_type iterations
The number of total iterations of ParICT that will be executed.
Definition par_ict.hpp:103
gko::factorization::ParIct::parameters_type::deterministic_sample
bool deterministic_sample
true means the sample used for the selection algorithm will be chosen deterministically.
Definition par_ict.hpp:157
gko::factorization::ParIct::parameters_type::fill_in_limit
double fill_in_limit
the amount of fill-in that is allowed in L compared to the lower triangle of A.
Definition par_ict.hpp:171
gko::factorization::ParIct::parameters_type::lt_strategy
std::shared_ptr< typename matrix_type::strategy_type > lt_strategy
Strategy which will be used by the L^T matrix.
Definition par_ict.hpp:185