Struct Permutation 

pub struct Permutation<D>
where
    D: Dim,
    DefaultAllocator: Allocator<D>,
{ /* private fields */ }

describes an orthogonal permutation matrix P that can be used to permute the rows or columns of an appropriately shaped matrix. Due to LAPACK internals, an instance must be mutably borrowed when applying the permutation, but the permutation itself will remain unchanged on success.

Note: the associated functions take Self by mutable reference due to the LAPACK internal implementation of the permutation logic.

Implementations

impl<'a, D> Permutation<D>

where D: Dim, DefaultAllocator: Allocator<D>,

pub fn permute_cols_mut<T, R, S>( &mut self, mat: &mut Matrix<T, R, D, S>, ) -> Result<(), Error>

where R: Dim, S: RawStorageMut<T, R, D> + IsContiguous, T: QrScalar,

Apply the column permutation to a matrix A, equivalent to P A.

pub fn inv_permute_cols_mut<T, R, S>( &mut self, mat: &mut Matrix<T, R, D, S>, ) -> Result<(), Error>

where R: Dim, S: RawStorageMut<T, R, D> + IsContiguous, T: QrScalar,

Apply the inverse column permutation to a matrix A, equivalent to P^T A.

pub fn permute_rows_mut<T, C, S>( &mut self, mat: &mut Matrix<T, D, C, S>, ) -> Result<(), Error>

where C: Dim, S: RawStorageMut<T, D, C> + IsContiguous, T: QrScalar,

Apply the row permutation to a matrix A, equivalent to P A.

pub fn inv_permute_rows_mut<T, C, S>( &mut self, mat: &mut Matrix<T, D, C, S>, ) -> Result<(), Error>

where C: Dim, S: RawStorageMut<T, D, C> + IsContiguous, T: QrScalar,

Apply the inverse row permutation to a matrix A, equivalent to P^T A.

Trait Implementations

impl<D> Clone for Permutation<D>

where D: Dim + Clone, DefaultAllocator: Allocator<D>,

fn clone(&self) -> Permutation<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D> Debug for Permutation<D>

where D: Dim + Debug, DefaultAllocator: Allocator<D>,

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

Formats the value using the given formatter.

impl<D> PartialEq for Permutation<D>

where D: Dim + PartialEq, DefaultAllocator: Allocator<D>,

fn eq(&self, other: &Permutation<D>) -> 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<D> Eq for Permutation<D>

where D: Dim + Eq, DefaultAllocator: Allocator<D>,

impl<D> StructuralPartialEq for Permutation<D>

where D: Dim, DefaultAllocator: Allocator<D>,