Ginkgo Generated from branch based on main. Ginkgo version 1.9.0
A numerical linear algebra library targeting many-core architectures
 
Loading...
Searching...
No Matches
scaled_permutation.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_MATRIX_SCALED_PERMUTATION_HPP_
6#define GKO_PUBLIC_CORE_MATRIX_SCALED_PERMUTATION_HPP_
7
8
9#include <memory>
10
11#include <ginkgo/core/base/array.hpp>
12#include <ginkgo/core/base/executor.hpp>
13#include <ginkgo/core/base/lin_op.hpp>
14#include <ginkgo/core/base/types.hpp>
15#include <ginkgo/core/base/utils.hpp>
16#include <ginkgo/core/matrix/permutation.hpp>
17
18
19namespace gko {
20namespace matrix {
21
22
35template <typename ValueType = default_precision, typename IndexType = int32>
36class ScaledPermutation final
37 : public EnableLinOp<ScaledPermutation<ValueType, IndexType>>,
38 public WritableToMatrixData<ValueType, IndexType> {
39 friend class EnablePolymorphicObject<ScaledPermutation, LinOp>;
40
41public:
42 using value_type = ValueType;
43 using index_type = IndexType;
44
50 value_type* get_scaling_factors() noexcept { return scale_.get_data(); }
51
59 const value_type* get_const_scaling_factors() const noexcept
60 {
61 return scale_.get_const_data();
62 }
63
69 index_type* get_permutation() noexcept { return permutation_.get_data(); }
70
78 const index_type* get_const_permutation() const noexcept
79 {
80 return permutation_.get_const_data();
81 }
82
91 std::unique_ptr<ScaledPermutation> compute_inverse() const;
92
101 std::unique_ptr<ScaledPermutation> compose(
103
104 void write(gko::matrix_data<value_type, index_type>& data) const override;
105
114 static std::unique_ptr<ScaledPermutation> create(
115 std::shared_ptr<const Executor> exec, size_type size = 0);
116
125 static std::unique_ptr<ScaledPermutation> create(
126 ptr_param<const Permutation<IndexType>> permutation);
127
137 static std::unique_ptr<ScaledPermutation> create(
138 std::shared_ptr<const Executor> exec, array<value_type> scaling_factors,
139 array<index_type> permutation_indices);
140
152 static std::unique_ptr<const ScaledPermutation> create_const(
153 std::shared_ptr<const Executor> exec,
154 gko::detail::const_array_view<value_type>&& scale,
155 gko::detail::const_array_view<index_type>&& perm_idxs);
156
157private:
158 ScaledPermutation(std::shared_ptr<const Executor> exec, size_type size = 0);
159
160 ScaledPermutation(std::shared_ptr<const Executor> exec,
161 array<value_type> scaling_factors,
162 array<index_type> permutation_indices);
163
164 void apply_impl(const LinOp* in, LinOp* out) const override;
165
166 void apply_impl(const LinOp*, const LinOp* in, const LinOp*,
167 LinOp* out) const override;
168
169 array<value_type> scale_;
170 array<index_type> permutation_;
171};
172
173
174} // namespace matrix
175} // namespace gko
176
177
178#endif // GKO_PUBLIC_CORE_MATRIX_SCALED_PERMUTATION_HPP_
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:662
Definition lin_op.hpp:117
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:660
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:166
Permutation is a matrix format that represents a permutation matrix, i.e.
Definition permutation.hpp:112
const value_type * get_const_scaling_factors() const noexcept
Returns a pointer to the scaling factors.
Definition scaled_permutation.hpp:59
index_type * get_permutation() noexcept
Returns a pointer to the permutation indices.
Definition scaled_permutation.hpp:69
const index_type * get_const_permutation() const noexcept
Returns a pointer to the permutation indices.
Definition scaled_permutation.hpp:78
static std::unique_ptr< ScaledPermutation > create(std::shared_ptr< const Executor > exec, array< value_type > scaling_factors, array< index_type > permutation_indices)
Creates a ScaledPermutation matrix from already allocated arrays.
static std::unique_ptr< ScaledPermutation > create(ptr_param< const Permutation< IndexType > > permutation)
Create a ScaledPermutation from a Permutation.
static std::unique_ptr< ScaledPermutation > create(std::shared_ptr< const Executor > exec, size_type size=0)
Creates an uninitialized ScaledPermutation matrix.
std::unique_ptr< ScaledPermutation > compose(ptr_param< const ScaledPermutation > other) const
Composes this scaled permutation with another scaled permutation.
std::unique_ptr< ScaledPermutation > compute_inverse() const
Returns the inverse of this operator as a scaled permutation.
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)
Creates a constant (immutable) ScaledPermutation matrix from constant arrays.
value_type * get_scaling_factors() noexcept
Returns a pointer to the scaling factors.
Definition scaled_permutation.hpp:50
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:41
The matrix namespace.
Definition dense_cache.hpp:15
The Ginkgo namespace.
Definition abstract_factory.hpp:20
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:89
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:126