nullspace_projection.hpp

// SPDX-FileCopyrightText: 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_PRECONDITIONER_NULLSPACE_PROJECTION_HPP_
#define GKO_PUBLIC_CORE_PRECONDITIONER_NULLSPACE_PROJECTION_HPP_
 
 
#include <memory>
 
#include <ginkgo/core/base/abstract_factory.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/polymorphic_object.hpp>
#include <ginkgo/core/config/property_tree.hpp>
#include <ginkgo/core/config/registry.hpp>
#include <ginkgo/core/config/type_descriptor.hpp>
#include <ginkgo/core/solver/nullspace.hpp>
 
 
namespace gko {
namespace preconditioner {
 
 
template <typename ValueType = default_precision>
class NullspaceProjection
    : public LinOp,
      public EnableCloneable<NullspaceProjection<ValueType>>,
      public Transposable {
    friend class EnableCloneable<NullspaceProjection>;
    GKO_ASSERT_SUPPORTED_VALUE_TYPE;
 
public:
    using EnableCloneable<NullspaceProjection>::convert_to;
    using EnableCloneable<NullspaceProjection>::move_to;
 
    using value_type = ValueType;
 
    std::shared_ptr<const LinOp> get_preconditioner() const;
 
    std::shared_ptr<const solver::Nullspace<ValueType>> get_nullspace() const;
 
    std::shared_ptr<const solver::Nullspace<ValueType>> get_left_nullspace()
        const;
 
    std::unique_ptr<LinOp> transpose() const override;
 
    std::unique_ptr<LinOp> conj_transpose() const override;
 
    NullspaceProjection& operator=(const NullspaceProjection& other);
 
    NullspaceProjection& operator=(NullspaceProjection&& other);
 
    NullspaceProjection(const NullspaceProjection& other);
 
    NullspaceProjection(NullspaceProjection&& other);
 
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        std::shared_ptr<const LinOpFactory> GKO_DEFERRED_FACTORY_PARAMETER(
            preconditioner);
 
        std::shared_ptr<const LinOp> GKO_FACTORY_PARAMETER_SCALAR(
            generated_preconditioner, nullptr);
 
        std::shared_ptr<const LinOp> GKO_FACTORY_PARAMETER_SCALAR(nullspace,
                                                                  nullptr);
 
        std::shared_ptr<const LinOp> GKO_FACTORY_PARAMETER_SCALAR(
            left_nullspace, nullptr);
    };
    GKO_ENABLE_LIN_OP_FACTORY(NullspaceProjection, 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>());
 
protected:
    explicit NullspaceProjection(std::shared_ptr<const Executor> exec);
 
    NullspaceProjection(const Factory* factory,
                        std::shared_ptr<const LinOp> system_matrix);
 
    NullspaceProjection(
        std::shared_ptr<const Executor> exec, dim<2> size,
        std::shared_ptr<const LinOp> preconditioner,
        std::shared_ptr<const solver::Nullspace<ValueType>> nullspace,
        std::shared_ptr<const solver::Nullspace<ValueType>> left_nullspace);
 
    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:
    // a vector of the same kind as the input, which is not copied along with
    // the object
    struct vector_cache {
        vector_cache() = default;
        vector_cache(const vector_cache&) {}
        vector_cache(vector_cache&&) noexcept {}
        vector_cache& operator=(const vector_cache&) { return *this; }
        vector_cache& operator=(vector_cache&&) noexcept { return *this; }
 
        mutable std::unique_ptr<LinOp> vec;
    };
 
    std::shared_ptr<const LinOp> preconditioner_;
    std::shared_ptr<const solver::Nullspace<ValueType>> nullspace_;
    std::shared_ptr<const solver::Nullspace<ValueType>> left_nullspace_;
    vector_cache projected_input_;
    vector_cache result_;
};
 
 
}  // namespace preconditioner
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_PRECONDITIONER_NULLSPACE_PROJECTION_HPP_