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 len(&self) -> N

returns the dimension of the permutation

pub fn into_inverse(self) -> Self

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 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) -> Perm<Inner>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for &Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for &Perm<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for Perm<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Cols, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<&Perm<R>> for &Mat<L>

type Output = Mat<Own<T, Rows, Cols>>

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, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<&Perm<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<&Perm<R>> for &SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<&Perm<R>> for &SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Cols, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<&Perm<R>> for Mat<L>

type Output = Mat<Own<T, Rows, Cols>>

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, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<&Perm<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<&Perm<R>> for SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<&Perm<R>> for SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for &Perm<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for Perm<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseRowMat<R>> for &Perm<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseRowMat<R>> for Perm<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for &Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<Mat<R>> for &Perm<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<Mat<R>> for Perm<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Cols, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<Perm<R>> for &Mat<L>

type Output = Mat<Own<T, Rows, Cols>>

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, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<Perm<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<Perm<R>> for &SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<Perm<R>> for &SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Cols, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<Perm<R>> for Mat<L>

type Output = Mat<Own<T, Rows, Cols>>

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, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<Perm<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<Perm<R>> for SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<Perm<R>> for SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for &Perm<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for Perm<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseRowMat<R>> for &Perm<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseRowMat<R>> for Perm<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: SparseRowMat<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

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<'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

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