Struct Permutation 

pub struct Permutation<const N: usize> { /* private fields */ }

The main type, representing a rearrangement of N objects.

Implementations

impl<const N: usize> Permutation<N>

Group Structure

pub fn identity() -> Self

The identity permutation that doesn’t reorder anything (leaves everything unchanged)

pub fn is_identity(&self) -> bool

Check if the permutation is equal to the identity

pub fn compose(self, rhs: Self) -> Self

Compute the permutation that is equivalent to first applying self and then rhs

pub fn inverse(self) -> Self

Compute the permutation that reverts the changes made by self

impl<const N: usize> Permutation<N>

Misc. Math

pub fn rotate_left(n: usize) -> Self

The permutation corresponding to slice::rotate_left(n)

pub fn rotate_right(n: usize) -> Self

The permutation corresponding to slice::rotate_right(n)

pub fn min_subperm_len(&self) -> usize

Computes the M such that self only changes the first M elements and leaves the rest alone

pub fn from_subperm<const M: usize>(sub: Permutation<M>) -> Self

Constructs a permutation that changes the first M elements according to sub and leaves the rest alone

Panics

• if M > N

pub fn from_fn<F: FnMut(usize) -> usize>(f: F) -> Result<Self, InvalidArrFnRepr>

Constructs a permutation from its function representation

The function representation is basically the same as the array representation: The equivalence is arr[i] == f(i).

pub fn as_fn(&self) -> impl Fn(usize) -> usize + '_

Converts a permutation to its function representation, borrowing from self

pub fn to_fn(self) -> impl Fn(usize) -> usize + 'static

Converts a permutation to its function representation, moving self

pub fn apply<T>(&self, array: [T; N]) -> [T; N]

Applies the reordering given by self to array

pub fn apply_in_place<T>(&self, slice: &mut [T])

Applies the permutation self to the first N elements of slice

See also Swaps::apply_in_place

Panics

• if slice.len() > self.min_subperm_len()

pub fn sign(&self) -> PermutationSign

Computes the permutation sign

pub fn is_even(&self) -> bool

Checks if the permutation is even, i.e. if the sign is positive

pub fn is_odd(&self) -> bool

Checks if the permutation is odd, i.e. if the sign is negative

impl<const N: usize> Permutation<N>

Representations

pub fn from_array_repr(arr: [usize; N]) -> Result<Self, InvalidArrFnRepr>

Construct a permutation from its array representation

• The array is interpreted as the one-line notation.
• Elements start at zero, unlike in mathematics where they usually start at 1

pub fn from_one_based_array_repr( arr: [NonZeroUsize; N], ) -> Result<Self, InvalidArrFnRepr>

Same as from_array_repr but uses the more familliar one-based values (used in mathematics)

pub fn to_array_repr(self) -> [usize; N]

Obtain the array representation for a permutation (see from_array_repr)

pub fn from_cycles_repr(cycles: Cycles<N>) -> Result<Self, InvalidCycleRepr>

Construct a permutation from its cycles representation

pub fn to_cycles_repr(self) -> Cycles<N>

Obtain the cycles representation for a permutation

pub fn from_swaps_repr<const M: usize, O: SwapsReprOrder>( swaps: Swaps<M, O>, ) -> Result<Self, InvalidSwapRepr>

Construct a permutation from its representation as a composition as M or less swaps

pub fn to_swaps_repr(self) -> Swaps<N, SequentialApplicationOrder>

Represent a permutation as N or less swaps

impl<const N: usize> Permutation<N>

Construct a permutations that would sort a slice/array when applyed

pub fn from_custom_sort<T: Ord, S: SortArray<N>>(arr: &[T; N]) -> Self

Construct a permutation that would sort arr according to the sort method given by S

pub fn from_sort_unstable<T: Ord>(arr: &[T; N]) -> Self

Construct a permutation that would sort arr according to the sort method given by CoreSortUnstable

pub fn from_sort<T: Ord>(arr: &[T; N]) -> Self

Available on crate feature std only.

Construct a permutation that would sort arr according to the sort method given by StdSort

pub fn from_custom_sort_slice<T: Ord, S: SortSlice>( sl: &[T], ) -> Result<Self, TooLongSliceForPermutation>

Construct a permutation that would sort sl according to the sort method given by S

pub fn from_sort_unstable_slice<T: Ord>( sl: &[T], ) -> Result<Self, TooLongSliceForPermutation>

Construct a permutation that would sort sl according to the sort method given by CoreSortUnstable

pub fn from_sort_slice<T: Ord>( sl: &[T], ) -> Result<Self, TooLongSliceForPermutation>

Available on crate feature std only.

Construct a permutation that would sort sl according to the sort method given by StdSort

Trait Implementations

impl<const N: usize> Clone for Permutation<N>

fn clone(&self) -> Permutation<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for Permutation<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Distribution<Permutation<N>> for Standard

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Permutation<N>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<const N: usize> Hash for Permutation<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize> PartialEq for Permutation<N>

fn eq(&self, other: &Permutation<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Copy for Permutation<N>

impl<const N: usize> Eq for Permutation<N>

impl<const N: usize> StructuralPartialEq for Permutation<N>