Type Alias PermD 

pub type PermD = Perm<Dynamic>;

Permutation type with runtime size.

Aliased Type

pub struct PermD { /* private fields */ }

Implementations

impl PermD

pub fn empty() -> Self

pub fn unit() -> Self

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

pub fn identity(size: usize) -> Self

pub fn cycle(size: usize) -> Self

pub fn reverse_cycle(size: usize) -> Self

pub fn permute_indices(&self, perm: &PermD) -> Option<Self>

pub fn conjugate_with(&self, other: &PermD) -> Option<Self>

pub fn to_size(&self, new_size: usize) -> Option<PermD>

pub fn into_static<const SIZE: usize>(self) -> Option<PermS<SIZE>>

Trait Implementations

impl Mul<&Perm<Dynamic>> for &PermD

type Output = Perm<Dynamic>

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 &PermD

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> PermApply<[T]> for PermD

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

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

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

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

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

impl<T> PermApply<Vec<T>> for PermD

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

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

impl PermFromIndices<&[usize]> for PermD

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

Builds a dynamic permutation from a slice of indices.

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

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

Builds a dynamic permutation from an array of indices.

impl PermFromIndices<Cow<'_, [usize]>> for PermD

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

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

impl PermFromIndices<Vec<usize>> for PermD

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

Builds a dynamic permutation from a vector of indices.

impl<T> PermFromSorting<&[T], T> for PermD

type Output = Perm<Dynamic>

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 PermD

type Output = Perm<Dynamic>

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 PermD

type Output = Perm<Dynamic>

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> PermFromSorting<Vec<T>, T> for PermD

type Output = Perm<Dynamic>

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 PermProduct<Perm<Dynamic>> for PermD

type Output = Option<Perm<Dynamic>>

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

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

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

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

impl Permutation for PermD

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 PermD

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<Perm<Static<SIZE>>> for PermD

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.