rcm.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_REORDER_RCM_HPP_
#define GKO_PUBLIC_CORE_REORDER_RCM_HPP_
 
 
#include <memory>
 
 
#include <ginkgo/core/base/abstract_factory.hpp>
#include <ginkgo/core/base/array.hpp>
#include <ginkgo/core/base/dim.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/polymorphic_object.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/base/utils.hpp>
#include <ginkgo/core/matrix/csr.hpp>
#include <ginkgo/core/matrix/identity.hpp>
#include <ginkgo/core/matrix/permutation.hpp>
#include <ginkgo/core/matrix/sparsity_csr.hpp>
#include <ginkgo/core/reorder/reordering_base.hpp>
 
 
namespace gko {
namespace reorder {
 
 
enum class starting_strategy { minimum_degree, pseudo_peripheral };
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class Rcm : public EnablePolymorphicObject<Rcm<ValueType, IndexType>,
                                           ReorderingBase<IndexType>>,
            public EnablePolymorphicAssignment<Rcm<ValueType, IndexType>> {
    friend class EnablePolymorphicObject<Rcm, ReorderingBase<IndexType>>;
 
public:
    using SparsityMatrix = matrix::SparsityCsr<ValueType, IndexType>;
    using PermutationMatrix = matrix::Permutation<IndexType>;
    using value_type = ValueType;
    using index_type = IndexType;
 
    std::shared_ptr<const PermutationMatrix> get_permutation() const
    {
        return permutation_;
    }
 
    std::shared_ptr<const PermutationMatrix> get_inverse_permutation() const
    {
        return inv_permutation_;
    }
 
    /*const array<index_type>& get_permutation_array() const override
    {
        return permutation_array_;
    }*/
 
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        bool GKO_FACTORY_PARAMETER_SCALAR(construct_inverse_permutation, false);
 
        starting_strategy GKO_FACTORY_PARAMETER_SCALAR(
            strategy, starting_strategy::pseudo_peripheral);
    };
    GKO_ENABLE_REORDERING_BASE_FACTORY(Rcm, parameters, Factory);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
protected:
    explicit Rcm(std::shared_ptr<const Executor> exec);
 
    explicit Rcm(const Factory* factory, const ReorderingBaseArgs& args);
 
private:
    std::shared_ptr<PermutationMatrix> permutation_;
    std::shared_ptr<PermutationMatrix> inv_permutation_;
};
 
 
}  // namespace reorder
 
 
namespace experimental {
namespace reorder {
 
 
using rcm_starting_strategy = gko::reorder::starting_strategy;
 
 
template <typename IndexType = int32>
class Rcm : public EnablePolymorphicObject<Rcm<IndexType>, LinOpFactory>,
            public EnablePolymorphicAssignment<Rcm<IndexType>> {
public:
    struct parameters_type;
    friend class EnablePolymorphicObject<Rcm<IndexType>, LinOpFactory>;
    friend class enable_parameters_type<parameters_type, Rcm<IndexType>>;
 
    using index_type = IndexType;
    using permutation_type = matrix::Permutation<index_type>;
 
    struct parameters_type
        : public enable_parameters_type<parameters_type, Rcm<IndexType>> {
        bool GKO_FACTORY_PARAMETER_SCALAR(skip_symmetrize, false);
 
        rcm_starting_strategy GKO_FACTORY_PARAMETER_SCALAR(
            strategy, rcm_starting_strategy::pseudo_peripheral);
    };
 
    const parameters_type& get_parameters() { return parameters_; }
 
    std::unique_ptr<permutation_type> generate(
        std::shared_ptr<const LinOp> system_matrix) const;
 
    static parameters_type build() { return {}; }
 
protected:
    explicit Rcm(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;
 
    parameters_type parameters_;
};
 
 
}  // namespace reorder
}  // namespace experimental
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_REORDER_RCM_HPP_