Struct Perm 

#[repr(transparent)]
pub struct Perm<Inner>(pub Inner);

generic Perm wrapper

Tuple Fields

0: Inner

Implementations

impl<I: Index, N: Shape> Perm<Own<I, N>>

pub fn as_shape<M: Shape>(&self, dim: M) -> PermRef<'_, I, M>

returns the input permutation with the given shape after checking that it matches the current shape

pub fn into_shape<M: Shape>(self, dim: M) -> Perm<I, M>

returns the input permutation with the given shape after checking that it matches the current shape

pub fn new_checked( forward: Box<[Idx<N, I>]>, inverse: Box<[Idx<N, I>]>, dim: N, ) -> Self

creates a new permutation, by checking the validity of the inputs

panics

the function panics if any of the following conditions are violated: forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other

pub unsafe fn new_unchecked( forward: Box<[Idx<N, I>]>, inverse: Box<[Idx<N, I>]>, ) -> Self

creates a new permutation reference, without checking the validity of the inputs

safety

forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other

pub fn into_arrays(self) -> (Box<[Idx<N, I>]>, Box<[Idx<N, I>]>)

returns the permutation as an array

pub fn arrays(&self) -> (&[Idx<N, I>], &[Idx<N, I>])

returns the permutation as an array

pub fn len(&self) -> N

returns the dimension of the permutation

pub fn into_inverse(self) -> Self

returns the inverse permutation

pub fn inverse(&self) -> PermRef<'_, I, N>

returns the inverse permutation

pub fn transpose(&self) -> PermRef<'_, I, N>

returns the inverse permutation

impl<I: Index, N: Shape, Inner: for<'short> Reborrow<'short, Target = Ref<'short, I, N>>> Perm<Inner>

pub fn as_ref(&self) -> PermRef<'_, I, N>

convert self to a permutation view

impl<'a, I: Index, N: Shape> Perm<Ref<'a, I, N>>

pub fn as_shape<M: Shape>(self, dim: M) -> PermRef<'a, I, M>

returns the input permutation with the given shape after checking that it matches the current shape

pub fn new_checked( forward: &'a [Idx<N, I>], inverse: &'a [Idx<N, I>], dim: N, ) -> Self

creates a new permutation, by checking the validity of the inputs

panics

the function panics if any of the following conditions are violated:

• forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other

pub unsafe fn new_unchecked( forward: &'a [Idx<N, I>], inverse: &'a [Idx<N, I>], dim: N, ) -> Self

creates a new permutation reference, without checking the validity of the inputs

safety

forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other

pub fn arrays(self) -> (&'a [Idx<N, I>], &'a [Idx<N, I>])

returns the permutation as an array

pub fn len(&self) -> N

returns the dimension of the permutation

pub fn inverse(self) -> Self

returns the inverse permutation

pub fn transpose(self) -> Self

returns the inverse permutation

pub fn canonicalized(self) -> PermRef<'a, I::FixedWidth, N>

cast the permutation to the fixed width index type

pub fn uncanonicalized<J: Index>(self) -> PermRef<'a, J, N>

cast the permutation from the fixed width index type

impl<'a, 'N, I: Index> Perm<Ref<'a, I, Dim<'N>>>

pub fn bound_arrays( self, ) -> (&'a Array<'N, Idx<Dim<'N>, I>>, &'a Array<'N, Idx<Dim<'N>, I>>)

returns the permutation as an array

impl<Inner> Perm<Inner>

pub fn from_inner_ref(inner: &Inner) -> &Self

wrap by reference

pub fn from_inner_mut(inner: &mut Inner) -> &mut Self

wrap by mutable reference

Trait Implementations

impl<Inner: Clone> Clone for Perm<Inner>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Inner: Copy> Copy for Perm<Inner>

impl<Inner: Debug> Debug for Perm<Inner>

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

Formats the value using the given formatter.

impl<Inner> Deref for Perm<Inner>

type Target = Inner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Inner> DerefMut for Perm<Inner>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Inner: IntoConst> IntoConst for Perm<Inner>

type Target = Perm<<Inner as IntoConst>::Target>

fn into_const(self) -> Self::Target

impl<I: Index, N: Shape, L: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>> Mul<&Perm<R>> for &Perm<L>

type Output = Perm<Own<I, N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Perm<R>) -> Self::Output

Performs the * operation.

impl<I: Index, N: Shape, L: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>> Mul<&Perm<R>> for Perm<L>

type Output = Perm<Own<I, N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Perm<R>) -> Self::Output

Performs the * operation.

impl<I: Index, N: Shape, L: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>> Mul<Perm<R>> for Perm<L>

type Output = Perm<Own<I, N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Perm<R>) -> Self::Output

Performs the * operation.

impl<I: Index, N: Shape, L: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, N>>> Mul<Perm<R>> for &Perm<L>

type Output = Perm<Own<I, N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Perm<R>) -> Self::Output

Performs the * operation.

impl<LI: Index, LN: Shape, RI: Index, RN: Shape, L: for<'a> Reborrow<'a, Target = Ref<'a, LI, LN>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RI, RN>>> PartialEq<Perm<R>> for Perm<L>

where LN::Idx<LI>: PartialEq<RN::Idx<RI>>,

fn eq(&self, other: &Perm<R>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'short, Inner: Reborrow<'short>> Reborrow<'short> for Perm<Inner>

type Target = Perm<<Inner as Reborrow<'short>>::Target>

fn rb(&'short self) -> Self::Target

impl<'short, Inner: ReborrowMut<'short>> ReborrowMut<'short> for Perm<Inner>

type Target = Perm<<Inner as ReborrowMut<'short>>::Target>

fn rb_mut(&'short mut self) -> Self::Target