mc64.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_REORDER_MC64_HPP_
#define GKO_PUBLIC_CORE_REORDER_MC64_HPP_
 
 
#include <limits>
#include <memory>
 
#include <ginkgo/core/base/abstract_factory.hpp>
#include <ginkgo/core/base/composition.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/diagonal.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 experimental {
namespace reorder {
 
 
enum class mc64_strategy { max_diagonal_product, max_diagonal_sum };
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class Mc64 final
    : public EnablePolymorphicObject<Mc64<ValueType, IndexType>, LinOpFactory>,
      public EnablePolymorphicAssignment<Mc64<ValueType, IndexType>> {
public:
    struct parameters_type;
    friend class EnablePolymorphicObject<Mc64<ValueType, IndexType>,
                                         LinOpFactory>;
    friend class enable_parameters_type<parameters_type,
                                        Mc64<ValueType, IndexType>>;
 
    using value_type = ValueType;
    using index_type = IndexType;
    using result_type = Composition<value_type>;
    using matrix_type = matrix::Csr<value_type, index_type>;
 
    struct parameters_type
        : public enable_parameters_type<parameters_type, Mc64> {
        mc64_strategy GKO_FACTORY_PARAMETER_SCALAR(
            strategy, mc64_strategy::max_diagonal_product);
 
        remove_complex<ValueType> GKO_FACTORY_PARAMETER_SCALAR(
            tolerance,
            50 * std::numeric_limits<remove_complex<ValueType>>::epsilon());
    };
 
    const parameters_type& get_parameters() const { return parameters_; }
 
    std::unique_ptr<result_type> generate(
        std::shared_ptr<const LinOp> system_matrix) const;
 
    static parameters_type build() { return {}; }
 
private:
    explicit Mc64(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_MC64_HPP_