par_ict.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
#define GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_
 
 
#include <memory>
 
#include <ginkgo/core/base/composition.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/config/config.hpp>
#include <ginkgo/core/config/registry.hpp>
#include <ginkgo/core/matrix/csr.hpp>
 
 
namespace gko {
namespace factorization {
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class ParIct : public Composition<ValueType> {
    GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
 
public:
    using value_type = ValueType;
    using index_type = IndexType;
    using matrix_type = matrix::Csr<ValueType, IndexType>;
 
    std::shared_ptr<const matrix_type> get_l_factor() const
    {
        // Can be `static_cast` since the type is guaranteed in this class
        return std::static_pointer_cast<const matrix_type>(
            this->get_operators()[0]);
    }
 
    std::shared_ptr<const matrix_type> get_lt_factor() const
    {
        // Can be `static_cast` since the type is guaranteed in this class
        return std::static_pointer_cast<const matrix_type>(
            this->get_operators()[1]);
    }
 
    // Remove the possibility of calling `create`, which was enabled by
    // `Composition`
    template <typename... Args>
    static std::unique_ptr<Composition<ValueType>> create(Args&&... args) =
        delete;
 
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        size_type GKO_FACTORY_PARAMETER_SCALAR(iterations, 5);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(approximate_select, true);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(deterministic_sample, false);
 
        double GKO_FACTORY_PARAMETER_SCALAR(fill_in_limit, 2.0);
 
        GKO_DEPRECATED("use matrix::csr::spmv_strategy instead")
        parameters_type& with_l_strategy(
            std::shared_ptr<typename matrix_type::strategy_type> value)
        {
            if (value) {
                this->l_strategy = value->get_enum();
            } else {
                this->l_strategy = matrix::csr::spmv_strategy::classical;
            }
            return *this;
        }
 
        parameters_type& with_l_strategy(matrix::csr::spmv_strategy value)
        {
            this->l_strategy = value;
            return *this;
        }
 
        matrix::csr::spmv_strategy l_strategy{
            matrix::csr::spmv_strategy::classical};
 
        matrix::csr::spmv_strategy GKO_FACTORY_PARAMETER_SCALAR(
            lt_strategy, matrix::csr::spmv_strategy::classical);
    };
    GKO_ENABLE_LIN_OP_FACTORY(ParIct, parameters, Factory);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
    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>());
 
protected:
    explicit ParIct(const Factory* factory,
                    std::shared_ptr<const LinOp> system_matrix)
        : Composition<ValueType>(factory->get_executor()),
          parameters_{factory->get_parameters()}
    {
        auto comp = generate_l_lt(std::move(system_matrix));
        for (auto& op : comp->get_operators()) {
            this->add_operators(op);
        }
    }
 
    std::unique_ptr<Composition<ValueType>> generate_l_lt(
        const std::shared_ptr<const LinOp>& system_matrix) const;
};
 
 
}  // namespace factorization
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_FACTORIZATION_PAR_ICT_HPP_