cholesky.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <memory>
 
#include <ginkgo/core/base/composition.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/polymorphic_object.hpp>
#include <ginkgo/core/config/config.hpp>
#include <ginkgo/core/config/registry.hpp>
#include <ginkgo/core/factorization/factorization.hpp>
#include <ginkgo/core/matrix/csr.hpp>
#include <ginkgo/core/matrix/sparsity_csr.hpp>
 
 
namespace gko {
namespace experimental {
namespace factorization {
 
 
template <typename ValueType, typename IndexType>
class Cholesky
    : public EnablePolymorphicObject<Cholesky<ValueType, IndexType>,
                                     LinOpFactory>,
      public EnablePolymorphicAssignment<Cholesky<ValueType, IndexType>> {
public:
    struct parameters_type;
    friend class EnablePolymorphicObject<Cholesky, LinOpFactory>;
    friend class enable_parameters_type<parameters_type, Cholesky>;
 
    using value_type = ValueType;
    using index_type = IndexType;
    using matrix_type = matrix::Csr<value_type, index_type>;
    using sparsity_pattern_type = matrix::SparsityCsr<value_type, index_type>;
    using factorization_type = Factorization<value_type, index_type>;
 
    struct parameters_type
        : public enable_parameters_type<parameters_type, Cholesky> {
        std::shared_ptr<const sparsity_pattern_type>
            GKO_FACTORY_PARAMETER_SCALAR(symbolic_factorization, nullptr);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false);
    };
 
    const parameters_type& get_parameters() { return parameters_; }
 
    const parameters_type& get_parameters() const { return parameters_; }
 
    std::unique_ptr<factorization_type> generate(
        std::shared_ptr<const LinOp> system_matrix) const;
 
    static parameters_type build() { return {}; }
 
    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 Cholesky(std::shared_ptr<const Executor> exec,
                      const parameters_type& params = {});
 
    std::unique_ptr<LinOp> generate_impl(
        std::shared_ptr<const LinOp> system_matrix) const override;
 
private:
    parameters_type parameters_;
};
 
 
}  // namespace factorization
}  // namespace experimental
}  // namespace gko