scaled_permutation.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MATRIX_SCALED_PERMUTATION_HPP_
#define GKO_PUBLIC_CORE_MATRIX_SCALED_PERMUTATION_HPP_
 
 
#include <memory>
 
#include <ginkgo/core/base/array.hpp>
#include <ginkgo/core/base/executor.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/base/utils.hpp>
#include <ginkgo/core/matrix/permutation.hpp>
 
 
namespace gko {
namespace matrix {
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class ScaledPermutation final
    : public LinOp,
      public EnableCloneable<ScaledPermutation<ValueType, IndexType>>,
      public WritableToMatrixData<ValueType, IndexType> {
    friend class EnableCloneable<ScaledPermutation>;
    GKO_ASSERT_SUPPORTED_VALUE_AND_INDEX_TYPE;
 
public:
    using value_type = ValueType;
    using index_type = IndexType;
 
    value_type* get_scaling_factors() noexcept { return scale_.get_data(); }
 
    const value_type* get_const_scaling_factors() const noexcept
    {
        return scale_.get_const_data();
    }
 
    index_type* get_permutation() noexcept { return permutation_.get_data(); }
 
    const index_type* get_const_permutation() const noexcept
    {
        return permutation_.get_const_data();
    }
 
    std::unique_ptr<ScaledPermutation> compute_inverse() const;
 
    std::unique_ptr<ScaledPermutation> compose(
        ptr_param<const ScaledPermutation> other) const;
 
    void write(gko::matrix_data<value_type, index_type>& data) const override;
 
    static std::unique_ptr<ScaledPermutation> create(
        std::shared_ptr<const Executor> exec, size_type size = 0);
 
    static std::unique_ptr<ScaledPermutation> create(
        ptr_param<const Permutation<IndexType>> permutation);
 
    static std::unique_ptr<ScaledPermutation> create(
        std::shared_ptr<const Executor> exec, array<value_type> scaling_factors,
        array<index_type> permutation_indices);
 
    static std::unique_ptr<const ScaledPermutation> create_const(
        std::shared_ptr<const Executor> exec,
        gko::detail::const_array_view<value_type>&& scale,
        gko::detail::const_array_view<index_type>&& perm_idxs);
 
private:
    ScaledPermutation(std::shared_ptr<const Executor> exec, size_type size = 0);
 
    ScaledPermutation(std::shared_ptr<const Executor> exec,
                      array<value_type> scaling_factors,
                      array<index_type> permutation_indices);
 
    void apply_impl(const LinOp* in, LinOp* out) const override;
 
    void apply_impl(const LinOp*, const LinOp* in, const LinOp*,
                    LinOp* out) const override;
 
    array<value_type> scale_;
    array<index_type> permutation_;
};
 
 
}  // namespace matrix
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MATRIX_SCALED_PERMUTATION_HPP_