Type Definition rusty_perm::PermS

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

Permutation type with static size known in compile time.

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 = PermS<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 = PermS<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; SIZE]> for PermS<SIZE>

type Output = ()

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

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<Vec<T, Global>> for PermS<SIZE>

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

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

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]> 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 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, Global>> 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; SIZE], T> for PermS<SIZE>

type Output = Self

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], T> for PermS<SIZE>

type Output = Option<Self>

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 = Self

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, Global>, T> for PermS<SIZE>

type Output = Option<Self>

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<PermS<SIZE>>

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

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

type Output = PermS<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>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

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

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = PermS<SIZE>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.