Type Alias PermS 

pub type PermS<const SIZE: usize> = Perm<Static<SIZE>>;

Permutation type with static size known in compile time.

Aliased Type

pub struct PermS<const SIZE: usize> { /* private fields */ }

Implementations

impl<const SIZE: usize> PermS<SIZE>

pub fn identity() -> Self

pub fn swap(first: usize, second: usize) -> Option<Self>

pub fn cycle() -> Self

pub fn reverse_cycle() -> Self

pub fn permute_indices(&self, perm: &PermS<SIZE>) -> Self

pub fn conjugate_with(&self, other: &PermS<SIZE>) -> Self

pub fn to_size<const NEW_SIZE: usize>(&self) -> Option<PermS<NEW_SIZE>>

impl<const SIZE: usize> PermS<SIZE>

pub fn into_dynamic(self) -> PermD

Trait Implementations

impl<const SIZE: usize> Mul<&Perm<Dynamic>> for &PermS<SIZE>

type Output = Perm<Static<SIZE>>

The resulting type after applying the * operator.

fn mul(self, other: &PermD) -> Self::Output

Performs the * operation.

impl<const SIZE: usize> Mul<&Perm<Static<SIZE>>> for &PermS<SIZE>

type Output = Perm<Static<SIZE>>

The resulting type after applying the * operator.

fn mul(self, other: &PermS<SIZE>) -> Self::Output

Performs the * operation.

impl<T, const SIZE: usize> PermApply<[T]> for PermS<SIZE>

type Output = Result<(), &'static str>

fn apply(&self, input: &mut [T]) -> Self::Output

impl<T, const SIZE: usize> PermApply<[T; SIZE]> for PermS<SIZE>

type Output = ()

fn apply(&self, input: &mut [T; SIZE]) -> Self::Output

impl<T, const SIZE: usize> PermApply<Vec<T>> for PermS<SIZE>

type Output = Result<(), &'static str>

fn apply(&self, input: &mut Vec<T>) -> Self::Output

impl<const SIZE: usize> PermFromIndices<&[usize]> for PermS<SIZE>

fn from_indices(indices: &[usize]) -> Option<Self>

Builds a static permutation from a slice of indices.

impl<const SIZE: usize> PermFromIndices<&[usize; SIZE]> for PermS<SIZE>

fn from_indices(indices: &[usize; SIZE]) -> Option<Self>

Builds a static permutation from a borrowed array of indices.

impl<const SIZE: usize> PermFromIndices<[usize; SIZE]> for PermS<SIZE>

fn from_indices(indices: [usize; SIZE]) -> Option<Self>

Builds a static permutation from an owned array of indices.

impl<const SIZE: usize> PermFromIndices<Cow<'_, [usize]>> for PermS<SIZE>

fn from_indices(indices: Cow<'_, [usize]>) -> Option<Self>

Builds a static permutation from a copy-on-write slice of indices.

impl<const SIZE: usize> PermFromIndices<Vec<usize>> for PermS<SIZE>

fn from_indices(indices: Vec<usize>) -> Option<Self>

Builds a static permutation from a vector indices.

impl<T, const SIZE: usize> PermFromSorting<&[T], T> for PermS<SIZE>

type Output = Option<Perm<Static<SIZE>>>

fn from_sort(vec: &[T]) -> Self::Output

where T: Ord,

Builds a permutation by sorting a slice-like type.

fn from_sort_by<F>(vec: &[T], compare: F) -> Self::Output

where F: FnMut(&T, &T) -> Ordering,

Builds a permutation by sorting a slice-like type with a comparing function.

fn from_sort_by_key<B, F>(vec: &[T], f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function.

fn from_sort_by_cached_key<B, F>(vec: &[T], f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function. The key is not re-computed twice.

impl<T, const SIZE: usize> PermFromSorting<&[T; SIZE], T> for PermS<SIZE>

type Output = Perm<Static<SIZE>>

fn from_sort(vec: &[T; SIZE]) -> Self::Output

where T: Ord,

Builds a permutation by sorting a slice-like type.

fn from_sort_by<F>(vec: &[T; SIZE], compare: F) -> Self::Output

where F: FnMut(&T, &T) -> Ordering,

Builds a permutation by sorting a slice-like type with a comparing function.

fn from_sort_by_key<B, F>(vec: &[T; SIZE], f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function.

fn from_sort_by_cached_key<B, F>(vec: &[T; SIZE], f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function. The key is not re-computed twice.

impl<T, const SIZE: usize> PermFromSorting<[T; SIZE], T> for PermS<SIZE>

type Output = Perm<Static<SIZE>>

fn from_sort(vec: [T; SIZE]) -> Self::Output

where T: Ord,

Builds a permutation by sorting a slice-like type.

fn from_sort_by<F>(vec: [T; SIZE], compare: F) -> Self::Output

where F: FnMut(&T, &T) -> Ordering,

Builds a permutation by sorting a slice-like type with a comparing function.

fn from_sort_by_key<B, F>(vec: [T; SIZE], f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function.

fn from_sort_by_cached_key<B, F>(vec: [T; SIZE], f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function. The key is not re-computed twice.

impl<T, const SIZE: usize> PermFromSorting<Vec<T>, T> for PermS<SIZE>

type Output = Option<Perm<Static<SIZE>>>

fn from_sort(vec: Vec<T>) -> Self::Output

where T: Ord,

Builds a permutation by sorting a slice-like type.

fn from_sort_by<F>(vec: Vec<T>, compare: F) -> Self::Output

where F: FnMut(&T, &T) -> Ordering,

Builds a permutation by sorting a slice-like type with a comparing function.

fn from_sort_by_key<B, F>(vec: Vec<T>, f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function.

fn from_sort_by_cached_key<B, F>(vec: Vec<T>, f: F) -> Self::Output

where B: Ord, F: FnMut(&T) -> B,

Builds a permutation by sorting a slice-like type with a key function. The key is not re-computed twice.

impl<const SIZE: usize> PermProduct<Perm<Dynamic>> for PermS<SIZE>

type Output = Option<Perm<Static<SIZE>>>

fn perm_product(&self, other: &PermD) -> Self::Output

impl<const SIZE: usize> PermProduct<Perm<Static<SIZE>>> for PermS<SIZE>

type Output = Perm<Static<SIZE>>

fn perm_product(&self, other: &PermS<SIZE>) -> Self::Output

impl<const SIZE: usize> Permutation for PermS<SIZE>

fn indices(&self) -> &[usize]

Gets the reference to the internal permuted indices.

fn len(&self) -> usize

Gets the size of permutation.

fn inverse(&self) -> Self

Builds the inverse of permutation.

fn pow(&self, exp: u32) -> Self

impl<'a, const SIZE: usize> Product<&'a Perm<Static<SIZE>>> for PermS<SIZE>

fn product<I>(iter: I) -> Self

where I: Iterator<Item = &'a PermS<SIZE>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<const SIZE: usize> Product for PermS<SIZE>

fn product<I>(iter: I) -> Self

where I: Iterator<Item = PermS<SIZE>>,

Takes an iterator and generates Self from the elements by multiplying the items.