factorization.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_FACTORIZATION_FACTORIZATION_HPP_
#define GKO_PUBLIC_CORE_FACTORIZATION_FACTORIZATION_HPP_
 
 
#include <ginkgo/core/base/composition.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/matrix/csr.hpp>
#include <ginkgo/core/matrix/diagonal.hpp>
 
 
namespace gko {
namespace experimental {
namespace factorization {
 
 
enum class storage_type {
    empty,
    composition,
    /*
     * The two factors are stored as a single matrix containing L + U - I, where
     * L has an implicit unit diagonal.
     */
    combined_lu,
    /*
     * The factorization L * D * U is stored as L + D + U - 2I, where
     * L and U have implicit unit diagonals.
     */
    combined_ldu,
    symm_composition,
    /*
     * The factorization L * L^H is symmetric and stored as a single matrix
     * containing L + L^H - diag(L).
     */
    symm_combined_cholesky,
    /*
     * The factorization is symmetric and stored as a single matrix containing
     * L + D + L^H - 2 * diag(L), where L and L^H have an implicit unit
     * diagonal.
     */
    symm_combined_ldl,
};
 
 
template <typename ValueType, typename IndexType>
class Factorization : public EnableLinOp<Factorization<ValueType, IndexType>> {
    friend class EnablePolymorphicObject<Factorization, LinOp>;
 
public:
    using value_type = ValueType;
    using index_type = IndexType;
    using matrix_type = matrix::Csr<ValueType, IndexType>;
    using diag_type = matrix::Diagonal<ValueType>;
    using composition_type = Composition<ValueType>;
 
    std::unique_ptr<Factorization> unpack() const;
 
    storage_type get_storage_type() const;
 
    std::shared_ptr<const matrix_type> get_lower_factor() const;
 
    std::shared_ptr<const diag_type> get_diagonal() const;
 
    std::shared_ptr<const matrix_type> get_upper_factor() const;
 
    std::shared_ptr<const matrix_type> get_combined() const;
 
    Factorization(const Factorization&);
 
    Factorization(Factorization&&);
 
    Factorization& operator=(const Factorization&);
 
    Factorization& operator=(Factorization&&);
 
    static std::unique_ptr<Factorization> create_from_composition(
        std::unique_ptr<composition_type> composition);
 
    static std::unique_ptr<Factorization> create_from_symm_composition(
        std::unique_ptr<composition_type> composition);
 
    static std::unique_ptr<Factorization> create_from_combined_lu(
        std::unique_ptr<matrix_type> matrix);
 
    static std::unique_ptr<Factorization> create_from_combined_ldu(
        std::unique_ptr<matrix_type> matrix);
 
    static std::unique_ptr<Factorization> create_from_combined_cholesky(
        std::unique_ptr<matrix_type> matrix);
 
    static std::unique_ptr<Factorization> create_from_combined_ldl(
        std::unique_ptr<matrix_type> matrix);
 
protected:
    explicit Factorization(std::shared_ptr<const Executor> exec);
 
    Factorization(std::unique_ptr<Composition<ValueType>> factors,
                  storage_type type);
 
    void apply_impl(const LinOp* b, LinOp* x) const override;
 
    void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
                    LinOp* x) const override;
 
private:
    storage_type storage_type_;
    std::unique_ptr<Composition<ValueType>> factors_;
};
 
 
}  // namespace factorization
}  // namespace experimental
}  // namespace gko
 
#endif  // GKO_PUBLIC_CORE_FACTORIZATION_FACTORIZATION_HPP_