gko::matrix::ScaledPermutation#

Permutation composed with a row scaling. Stores a permutation and a diagonal scaling factor per row; apply(b, x) permutes and scales in a single pass. Produced by reordering algorithms that combine row-permutation with row-equilibration (e.g. MC64).

template<typename ValueType = default_precision, typename IndexType = int32>
class ScaledPermutation #

Inherits from

ScaledPermutation is a matrix combining a permutation with scaling factors. It is a combination of Diagonal and Permutation, and can be read as \(SP = P \cdot S\), i.e. the scaling gets applied before the permutation.

Template Parameters:

  • IndexType – index type of permutation indices

  • ValueType – value type of the scaling factors

Public Functions

inline value_type *get_scaling_factors() noexcept#

Returns a pointer to the scaling factors.

Returns:

the pointer to the scaling factors.

inline const value_type *get_const_scaling_factors() const noexcept#

Returns a pointer to the scaling factors.

Note

This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

Returns:

the pointer to the scaling factors.

inline index_type *get_permutation() noexcept#

Returns a pointer to the permutation indices.

Returns:

the pointer to the permutation indices.

inline const index_type *get_const_permutation() const noexcept#

Returns a pointer to the permutation indices.

Note

This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

Returns:

the pointer to the permutation indices.

std::unique_ptr<ScaledPermutation> compute_inverse() const#

Returns the inverse of this operator as a scaled permutation. It is computed via \((P S)^-1 = P^{-1} (P S P^{-1})\).

Returns:

a newly created ScaledPermutation object storing the inverse of the permutation and scaling factors of this ScaledPermutation.

std::unique_ptr<ScaledPermutation> compose(
ptr_param<const ScaledPermutation> other,
) const#

Composes this scaled permutation with another scaled permutation. This means result = other * this from the matrix perspective, which is equivalent to first scaling and permuting by this and then by other.

Parameters:

other – the other permutation

Returns:

the combined permutation

Public Static Functions

static std::unique_ptr<ScaledPermutation> create(
std::shared_ptr<const Executor> exec,
size_type size = 0,
)#

Creates an uninitialized ScaledPermutation matrix.

Parameters:

  • exec – Executor associated to the matrix

  • size – dimensions of the (square) scaled permutation matrix

Returns:

A smart pointer to the newly created matrix.

static std::unique_ptr<ScaledPermutation> create(
ptr_param<const Permutation<IndexType>> permutation,
)#

Create a ScaledPermutation from a Permutation. The permutation will be copied, the scaling factors are all set to 1.0.

Parameters:

permutation – the permutation

Returns:

A smart pointer to the newly created matrix.

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.

Parameters:

  • exec – Executor associated to the matrix

  • permutation_indices – array of permutation indices

  • scaling_factors – array of scaling factors

Returns:

A smart pointer to the newly created matrix.

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.

Parameters:

  • exec – the executor to create the object on

  • perm_idxs – the permutation index array of the matrix

  • scale – the scaling factor array

Returns:

A smart pointer to the constant matrix wrapping the input arrays (if it resides on the same executor as the matrix) or a copy of the arrays on the correct executor.