Struct nalgebra::base::Matrix

#[repr(C)]
pub struct Matrix<N: Scalar, R: Dim, C: Dim, S> {
    pub data: S,
    // some fields omitted
}

The most generic column-major matrix (and vector) type.

It combines four type parameters:

• N: for the matrix components scalar type.
• R: for the matrix number of rows.
• C: for the matrix number of columns.
• S: for the matrix data storage, i.e., the buffer that actually contains the matrix components.

The matrix dimensions parameters R and C can either be:

• type-level unsigned integer constants (e.g. U1, U124) from the nalgebra:: root module. All numbers from 0 to 127 are defined that way.
• type-level unsigned integer constants (e.g. U1024, U10000) from the typenum:: crate. Using those, you will not get error messages as nice as for numbers smaller than 128 defined on the nalgebra:: module.
• the special value Dynamic from the nalgebra:: root module. This indicates that the specified dimension is not known at compile-time. Note that this will generally imply that the matrix data storage S performs a dynamic allocation and contains extra metadata for the matrix shape.

Note that mixing Dynamic with type-level unsigned integers is allowed. Actually, a dynamically-sized column vector should be represented as a Matrix<N, Dynamic, U1, S> (given some concrete types for N and a compatible data storage type S).

Fields

data: S

The data storage that contains all the matrix components and informations about its number of rows and column (if needed).

Methods

impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn iamax_full(&self) -> (usize, usize)

Computes the index of the matrix component with the largest absolute value.

impl<N, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where     N: Scalar + Zero + ClosedAdd + ClosedMul,

pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where     SB: Storage<N, R2, C2>,     ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

The dot product between two matrices (seen as vectors).

Note that this is not the matrix multiplication as in, e.g., numpy. For matrix multiplication, use one of: .gemm, mul_to, .mul, *.

pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where     SB: Storage<N, R2, C2>,     ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,

The dot product between the transpose of self and rhs.

impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S> where     N: Scalar + Zero + ClosedAdd + ClosedMul,

pub fn ger<D2: Dim, D3: Dim, SB, SC>(     &mut self,     alpha: N,     x: &Vector<N, D2, SB>,     y: &Vector<N, D3, SC>,     beta: N ) where     N: One,     SB: Storage<N, D2>,     SC: Storage<N, D3>,     ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

Computes self = alpha * x * y.transpose() + beta * self.

If beta is zero, self is never read.

pub fn gemm<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(     &mut self,     alpha: N,     a: &Matrix<N, R2, C2, SB>,     b: &Matrix<N, R3, C3, SC>,     beta: N ) where     N: One,     SB: Storage<N, R2, C2>,     SC: Storage<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,

Computes self = alpha * a * b + beta * self, where a, b, self are matrices. alpha and beta are scalar.

If beta is zero, self is never read.

pub fn gemm_tr<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(     &mut self,     alpha: N,     a: &Matrix<N, R2, C2, SB>,     b: &Matrix<N, R3, C3, SC>,     beta: N ) where     N: One,     SB: Storage<N, R2, C2>,     SC: Storage<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,

Computes self = alpha * a.transpose() * b + beta * self, where a, b, self are matrices. alpha and beta are scalar.

If beta is zero, self is never read.

impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S> where     N: Scalar + Zero + ClosedAdd + ClosedMul,

pub fn ger_symm<D2: Dim, D3: Dim, SB, SC>(     &mut self,     alpha: N,     x: &Vector<N, D2, SB>,     y: &Vector<N, D3, SC>,     beta: N ) where     N: One,     SB: Storage<N, D2>,     SC: Storage<N, D3>,     ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

Computes self = alpha * x * y.transpose() + beta * self, where self is a symmetric matrix.

If beta is zero, self is never read. The result is symmetric. Only the lower-triangular (including the diagonal) part of self is read/written.

impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where     N: Scalar + ClosedNeg,     S: StorageMut<N, R, C>,

pub fn neg_mut(&mut self)

Negates self in-place.

impl<N, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA> where     N: Scalar + ClosedAdd,

pub fn add_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(     &self,     rhs: &Matrix<N, R2, C2, SB>,     out: &mut Matrix<N, R3, C3, SC> ) where     SB: Storage<N, R2, C2>,     SC: StorageMut<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Equivalent to self + rhs but stores the result into out to avoid allocations.

impl<N, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA> where     N: Scalar + ClosedSub,

pub fn sub_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(     &self,     rhs: &Matrix<N, R2, C2, SB>,     out: &mut Matrix<N, R3, C3, SC> ) where     SB: Storage<N, R2, C2>,     SC: StorageMut<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Equivalent to self + rhs but stores the result into out to avoid allocations.

impl<N, R1: Dim, C1: Dim, SA> Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SA: Storage<N, R1, C1>,

pub fn tr_mul<R2: Dim, C2: Dim, SB>(     &self,     rhs: &Matrix<N, R2, C2, SB> ) -> MatrixMN<N, C1, C2> where     SB: Storage<N, R2, C2>,     DefaultAllocator: Allocator<N, C1, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2>,

Equivalent to self.transpose() * rhs.

pub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(     &self,     rhs: &Matrix<N, R2, C2, SB>,     out: &mut Matrix<N, R3, C3, SC> ) where     SB: Storage<N, R2, C2>,     SC: StorageMut<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,

Equivalent to self.transpose() * rhs but stores the result into out to avoid allocations.

pub fn mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(     &self,     rhs: &Matrix<N, R2, C2, SB>,     out: &mut Matrix<N, R3, C3, SC> ) where     SB: Storage<N, R2, C2>,     SC: StorageMut<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,

Equivalent to self * rhs but stores the result into out to avoid allocations.

pub fn kronecker<R2: Dim, C2: Dim, SB>(     &self,     rhs: &Matrix<N, R2, C2, SB> ) -> MatrixMN<N, DimProd<R1, R2>, DimProd<C1, C2>> where     N: ClosedMul,     R1: DimMul<R2>,     C1: DimMul<C2>,     SB: Storage<N, R2, C2>,     DefaultAllocator: Allocator<N, DimProd<R1, R2>, DimProd<C1, C2>>,

The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).

impl<N: Scalar + ClosedAdd, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn add_scalar(&self, rhs: N) -> MatrixMN<N, R, C> where     DefaultAllocator: Allocator<N, R, C>,

Adds a scalar to self.

pub fn add_scalar_mut(&mut self, rhs: N) where     S: StorageMut<N, R, C>,

Adds a scalar to self in-place.

impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn amax(&self) -> N

Returns the absolute value of the coefficient with the largest absolute value.

pub fn amin(&self) -> N

Returns the absolute value of the coefficient with the smallest absolute value.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn abs(&self) -> MatrixMN<N, R, C> where     N: Signed,     DefaultAllocator: Allocator<N, R, C>,

Computes the componentwise absolute value.

impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>

pub fn component_mul<R2, C2, SB>(     &self,     rhs: &Matrix<N, R2, C2, SB> ) -> MatrixSum<N, R1, C1, R2, C2> where     N: ClosedMul,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Componentwise matrix multiplication.

impl<N: Scalar, R1: Dim, C1: Dim, SA: StorageMut<N, R1, C1>> Matrix<N, R1, C1, SA>

pub fn cmpy<R2, C2, SB, R3, C3, SC>(     &mut self,     alpha: N,     a: &Matrix<N, R2, C2, SB>,     b: &Matrix<N, R3, C3, SC>,     beta: N ) where     N: ClosedMul + Zero + Mul<N, Output = N> + Add<N, Output = N>,     R2: Dim,     C2: Dim,     R3: Dim,     C3: Dim,     SB: Storage<N, R2, C2>,     SC: Storage<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Computes componentwise self[i] = alpha * a[i] * b[i] + beta * self[i].

pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where     N: ClosedMul,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Inplace componentwise matrix multiplication.

pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where     N: ClosedMul,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Deprecated

: This is renamed using the _assign sufix instead of the _mut suffix.

Inplace componentwise matrix multiplication.

impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>

pub fn component_div<R2, C2, SB>(     &self,     rhs: &Matrix<N, R2, C2, SB> ) -> MatrixSum<N, R1, C1, R2, C2> where     N: ClosedDiv,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Componentwise matrix division.

impl<N: Scalar, R1: Dim, C1: Dim, SA: StorageMut<N, R1, C1>> Matrix<N, R1, C1, SA>

pub fn cdpy<R2, C2, SB, R3, C3, SC>(     &mut self,     alpha: N,     a: &Matrix<N, R2, C2, SB>,     b: &Matrix<N, R3, C3, SC>,     beta: N ) where     N: ClosedDiv + Zero + Mul<N, Output = N> + Add<N, Output = N>,     R2: Dim,     C2: Dim,     R3: Dim,     C3: Dim,     SB: Storage<N, R2, C2>,     SC: Storage<N, R3, C3>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Computes componentwise self[i] = alpha * a[i] / b[i] + beta * self[i].

pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where     N: ClosedDiv,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Inplace componentwise matrix division.

pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where     N: ClosedDiv,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Deprecated

: This is renamed using the _assign sufix instead of the _mut suffix.

Inplace componentwise matrix division.

impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn upper_triangle(&self) -> MatrixMN<N, R, C> where     DefaultAllocator: Allocator<N, R, C>,

Extracts the upper triangular part of this matrix (including the diagonal).

pub fn lower_triangle(&self) -> MatrixMN<N, R, C> where     DefaultAllocator: Allocator<N, R, C>,

Extracts the upper triangular part of this matrix (including the diagonal).

impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>

pub fn fill(&mut self, val: N)

Sets all the elements of this matrix to val.

pub fn fill_with_identity(&mut self) where     N: Zero + One,

Fills self with the identity matrix.

pub fn fill_diagonal(&mut self, val: N)

Sets all the diagonal elements of this matrix to val.

pub fn fill_row(&mut self, i: usize, val: N)

Sets all the elements of the selected row to val.

pub fn fill_column(&mut self, j: usize, val: N)

Sets all the elements of the selected column to val.

pub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<N, R2, S2>) where     R: DimMin<C>,     S2: Storage<N, R2>,     ShapeConstraint: DimEq<DimMinimum<R, C>, R2>,

Fills the diagonal of this matrix with the content of the given vector.

pub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<N, C2, S2>) where     S2: Storage<N, U1, C2>,     ShapeConstraint: SameNumberOfColumns<C, C2>,

Fills the selected row of this matrix with the content of the given vector.

pub fn set_column<R2: Dim, S2>(&mut self, i: usize, column: &Vector<N, R2, S2>) where     S2: Storage<N, R2, U1>,     ShapeConstraint: SameNumberOfRows<R, R2>,

Fills the selected column of this matrix with the content of the given vector.

pub fn fill_lower_triangle(&mut self, val: N, shift: usize)

Sets all the elements of the lower-triangular part of this matrix to val.

The parameter shift allows some subdiagonals to be left untouched:

• If shift = 0 then the diagonal is overwritten as well.
• If shift = 1 then the diagonal is left untouched.
• If shift > 1, then the diagonal and the first shift - 1 subdiagonals are left untouched.

pub fn fill_upper_triangle(&mut self, val: N, shift: usize)

Sets all the elements of the lower-triangular part of this matrix to val.

The parameter shift allows some superdiagonals to be left untouched:

• If shift = 0 then the diagonal is overwritten as well.
• If shift = 1 then the diagonal is left untouched.
• If shift > 1, then the diagonal and the first shift - 1 superdiagonals are left untouched.

pub fn swap_rows(&mut self, irow1: usize, irow2: usize)

Swaps two rows in-place.

pub fn swap_columns(&mut self, icol1: usize, icol2: usize)

Swaps two columns in-place.

impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S>

pub fn fill_lower_triangle_with_upper_triangle(&mut self)

Copies the upper-triangle of this matrix to its lower-triangular part.

This makes the matrix symmetric. Panics if the matrix is not square.

pub fn fill_upper_triangle_with_lower_triangle(&mut self)

Copies the upper-triangle of this matrix to its upper-triangular part.

This makes the matrix symmetric. Panics if the matrix is not square.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn remove_column(self, i: usize) -> MatrixMN<N, R, DimDiff<C, U1>> where     C: DimSub<U1>,     DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, U1>>,

Removes the i-th column from this matrix.

pub fn remove_fixed_columns<D>(self, i: usize) -> MatrixMN<N, R, DimDiff<C, D>> where     D: DimName,     C: DimSub<D>,     DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,

Removes D::dim() consecutive columns from this matrix, starting with the i-th (included).

pub fn remove_columns(self, i: usize, n: usize) -> MatrixMN<N, R, Dynamic> where     C: DimSub<Dynamic, Output = Dynamic>,     DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,

Removes n consecutive columns from this matrix, starting with the i-th (included).

pub fn remove_columns_generic<D>(     self,     i: usize,     nremove: D ) -> MatrixMN<N, R, DimDiff<C, D>> where     D: Dim,     C: DimSub<D>,     DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,

Removes nremove.value() columns from this matrix, starting with the i-th (included).

This is the generic implementation of .remove_columns(...) and .remove_fixed_columns(...) which have nicer API interfaces.

pub fn remove_row(self, i: usize) -> MatrixMN<N, DimDiff<R, U1>, C> where     R: DimSub<U1>,     DefaultAllocator: Reallocator<N, R, C, DimDiff<R, U1>, C>,

Removes the i-th row from this matrix.

pub fn remove_fixed_rows<D>(self, i: usize) -> MatrixMN<N, DimDiff<R, D>, C> where     D: DimName,     R: DimSub<D>,     DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,

Removes D::dim() consecutive rows from this matrix, starting with the i-th (included).

pub fn remove_rows(self, i: usize, n: usize) -> MatrixMN<N, Dynamic, C> where     R: DimSub<Dynamic, Output = Dynamic>,     DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,

Removes n consecutive rows from this matrix, starting with the i-th (included).

pub fn remove_rows_generic<D>(     self,     i: usize,     nremove: D ) -> MatrixMN<N, DimDiff<R, D>, C> where     D: Dim,     R: DimSub<D>,     DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,

Removes nremove.value() rows from this matrix, starting with the i-th (included).

This is the generic implementation of .remove_rows(...) and .remove_fixed_rows(...) which have nicer API interfaces.

pub fn insert_column(self, i: usize, val: N) -> MatrixMN<N, R, DimSum<C, U1>> where     C: DimAdd<U1>,     DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, U1>>,

Inserts a column filled with val at the i-th position.

pub fn insert_fixed_columns<D>(     self,     i: usize,     val: N ) -> MatrixMN<N, R, DimSum<C, D>> where     D: DimName,     C: DimAdd<D>,     DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,

Inserts D::dim() columns filled with val starting at the i-th position.

pub fn insert_columns(     self,     i: usize,     n: usize,     val: N ) -> MatrixMN<N, R, Dynamic> where     C: DimAdd<Dynamic, Output = Dynamic>,     DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,

Inserts n columns filled with val starting at the i-th position.

pub unsafe fn insert_columns_generic_uninitialized<D>(     self,     i: usize,     ninsert: D ) -> MatrixMN<N, R, DimSum<C, D>> where     D: Dim,     C: DimAdd<D>,     DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,

Inserts ninsert.value() columns starting at the i-th place of this matrix.

The added column values are not initialized.

pub fn insert_row(self, i: usize, val: N) -> MatrixMN<N, DimSum<R, U1>, C> where     R: DimAdd<U1>,     DefaultAllocator: Reallocator<N, R, C, DimSum<R, U1>, C>,

Inserts a row filled with val at the i-th position.

pub fn insert_fixed_rows<D>(     self,     i: usize,     val: N ) -> MatrixMN<N, DimSum<R, D>, C> where     D: DimName,     R: DimAdd<D>,     DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,

Inserts D::dim() rows filled with val starting at the i-th position.

pub fn insert_rows(self, i: usize, n: usize, val: N) -> MatrixMN<N, Dynamic, C> where     R: DimAdd<Dynamic, Output = Dynamic>,     DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,

Inserts n rows filled with val starting at the i-th position.

pub unsafe fn insert_rows_generic_uninitialized<D>(     self,     i: usize,     ninsert: D ) -> MatrixMN<N, DimSum<R, D>, C> where     D: Dim,     R: DimAdd<D>,     DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,

Inserts ninsert.value() rows at the i-th place of this matrix.

The added rows values are not initialized. This is the generic implementation of .insert_rows(...) and .insert_fixed_rows(...) which have nicer API interfaces.

pub fn resize(self, new_nrows: usize, new_ncols: usize, val: N) -> DMatrix<N> where     DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,

Resizes this matrix so that it contains new_nrows rows and new_ncols columns.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows and/or columns than self, then the extra rows or columns are filled with val.

pub fn fixed_resize<R2: DimName, C2: DimName>(     self,     val: N ) -> MatrixMN<N, R2, C2> where     DefaultAllocator: Reallocator<N, R, C, R2, C2>,

Resizes this matrix so that it contains R2::value() rows and C2::value() columns.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows and/or columns than self, then the extra rows or columns are filled with val.

pub fn resize_generic<R2: Dim, C2: Dim>(     self,     new_nrows: R2,     new_ncols: C2,     val: N ) -> MatrixMN<N, R2, C2> where     DefaultAllocator: Reallocator<N, R, C, R2, C2>,

Resizes self such that it has dimensions new_nrows × now_ncols.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows and/or columns than self, then the extra rows or columns are filled with val.

impl<N: Scalar, R: Dim, C: Dim, S> Matrix<N, R, C, S>

pub unsafe fn from_data_statically_unchecked(data: S) -> Matrix<N, R, C, S>

Creates a new matrix with the given data without statically checking that the matrix dimension matches the storage dimension.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn from_data(data: S) -> Matrix<N, R, C, S>

Creates a new matrix with the given data.

pub fn len(&self) -> usize

The total number of elements of this matrix.

pub fn shape(&self) -> (usize, usize)

The shape of this matrix returned as the tuple (number of rows, number of columns).

pub fn nrows(&self) -> usize

The number of rows of this matrix.

pub fn ncols(&self) -> usize

The number of columns of this matrix.

pub fn strides(&self) -> (usize, usize)

The strides (row stride, column stride) of this matrix.

Important traits for MatrixIter<'a, N, R, C, S>

impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator for MatrixIter<'a, N, R, C, S> type Item = &'a N;

pub fn iter(&self) -> MatrixIter<N, R, C, S>

Iterates through this matrix coordinates.

pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)

Computes the row and column coordinates of the i-th element of this matrix seen as a vector.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

Gets a reference to the element of this matrix at row irow and column icol without bound-checking.

pub fn relative_eq<R2, C2, SB>(     &self,     other: &Matrix<N, R2, C2, SB>,     eps: N::Epsilon,     max_relative: N::Epsilon ) -> bool where     N: RelativeEq,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     N::Epsilon: Copy,     ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Tests whether self and rhs are equal up to a given epsilon.

See relative_eq from the RelativeEq trait for more details.

pub fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> bool where     N: PartialEq,     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Tests whether self and rhs are exactly equal.

pub fn into_owned(self) -> MatrixMN<N, R, C> where     DefaultAllocator: Allocator<N, R, C>,

Moves this matrix into one that owns its data.

pub fn into_owned_sum<R2, C2>(self) -> MatrixSum<N, R, C, R2, C2> where     R2: Dim,     C2: Dim,     DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Moves this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.

pub fn clone_owned(&self) -> MatrixMN<N, R, C> where     DefaultAllocator: Allocator<N, R, C>,

Clones this matrix to one that owns its data.

pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<N, R, C, R2, C2> where     R2: Dim,     C2: Dim,     DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Clones this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.

pub fn map<N2: Scalar, F: FnMut(N) -> N2>(&self, f: F) -> MatrixMN<N2, R, C> where     DefaultAllocator: Allocator<N2, R, C>,

Returns a matrix containing the result of f applied to each of its entries.

pub fn zip_map<N2, N3, S2, F>(     &self,     rhs: &Matrix<N2, R, C, S2>,     f: F ) -> MatrixMN<N3, R, C> where     N2: Scalar,     N3: Scalar,     S2: Storage<N2, R, C>,     F: FnMut(N, N2) -> N3,     DefaultAllocator: Allocator<N3, R, C>,

Returns a matrix containing the result of f applied to each entries of self and rhs.

pub fn zip_zip_map<N2, N3, N4, S2, S3, F>(     &self,     b: &Matrix<N2, R, C, S2>,     c: &Matrix<N3, R, C, S3>,     f: F ) -> MatrixMN<N4, R, C> where     N2: Scalar,     N3: Scalar,     N4: Scalar,     S2: Storage<N2, R, C>,     S3: Storage<N3, R, C>,     F: FnMut(N, N2, N3) -> N4,     DefaultAllocator: Allocator<N4, R, C>,

Returns a matrix containing the result of f applied to each entries of self and b, and c.

pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>) where     R2: Dim,     C2: Dim,     SB: StorageMut<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,

Transposes self and store the result into out.

pub fn transpose(&self) -> MatrixMN<N, C, R> where     DefaultAllocator: Allocator<N, C, R>,

Transposes self.

impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>

Important traits for MatrixIterMut<'a, N, R, C, S>

impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator for MatrixIterMut<'a, N, R, C, S> type Item = &'a mut N;

pub fn iter_mut(&mut self) -> MatrixIterMut<N, R, C, S>

Mutably iterates through this matrix coordinates.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut N

Gets a mutable reference to the i-th element of this matrix.

pub unsafe fn swap_unchecked(     &mut self,     row_cols1: (usize, usize),     row_cols2: (usize, usize) )

Swaps two entries without bound-checking.

pub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))

Swaps two entries.

pub fn copy_from_slice(&mut self, slice: &[N])

Fills this matrix with the content of a slice. Both must hold the same number of elements.

The components of the slice are assumed to be ordered in column-major order.

pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Fills this matrix with the content of another one. Both must have the same shape.

pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,

Fills this matrix with the content of the transpose another one.

pub fn apply<F: FnMut(N) -> N>(&mut self, f: F) where     DefaultAllocator: Allocator<N, R, C>,

Replaces each component of self by the result of a closure f applied on it.

impl<N: Scalar, R: Dim, C: Dim, S: ContiguousStorage<N, R, C>> Matrix<N, R, C, S>

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

pub fn as_slice(&self) -> &[N]

Extracts a slice containing the entire matrix entries ordered column-by-columns.

impl<N: Scalar, R: Dim, C: Dim, S: ContiguousStorageMut<N, R, C>> Matrix<N, R, C, S>

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

pub fn as_mut_slice(&mut self) -> &mut [N]

Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.

impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S>

pub fn transpose_mut(&mut self)

Transposes the square matrix self in-place.

impl<N: Real, R: Dim, C: Dim, S: Storage<Complex<N>, R, C>> Matrix<Complex<N>, R, C, S>

pub fn conjugate_transpose_to<R2, C2, SB>(     &self,     out: &mut Matrix<Complex<N>, R2, C2, SB> ) where     R2: Dim,     C2: Dim,     SB: StorageMut<Complex<N>, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,

Takes the conjugate and transposes self and store the result into out.

pub fn conjugate_transpose(&self) -> MatrixMN<Complex<N>, C, R> where     DefaultAllocator: Allocator<Complex<N>, C, R>,

The conjugate transposition of self.

impl<N: Real, D: Dim, S: StorageMut<Complex<N>, D, D>> Matrix<Complex<N>, D, D, S>

pub fn conjugate_transpose_mut(&mut self)

Sets self to its conjugate transpose.

impl<N: Scalar + Ring, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> N where     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,

The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x.

pub fn cross<R2, C2, SB>(     &self,     b: &Matrix<N, R2, C2, SB> ) -> MatrixCross<N, R, C, R2, C2> where     R2: Dim,     C2: Dim,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,     ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

The 3D cross product between two vectors.

Panics if the shape is not 3D vector. In the future, this will be implemented only for dynamically-sized matrices and statically-sized 3D matrices.

impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> N where     SB: Storage<N, R2, C2>,     ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

The smallest angle between two vectors.

impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn norm_squared(&self) -> N

The squared L2 norm of this vector.

pub fn norm(&self) -> N

The L2 norm of this matrix.

pub fn magnitude(&self) -> N

A synonym for the norm of this matrix.

Aka the length.

This function is simply implemented as a call to norm()

pub fn magnitude_squared(&self) -> N

A synonym for the squared norm of this matrix.

Aka the squared length.

This function is simply implemented as a call to norm_squared()

pub fn normalize(&self) -> MatrixMN<N, R, C> where     DefaultAllocator: Allocator<N, R, C>,

Returns a normalized version of this matrix.

pub fn try_normalize(&self, min_norm: N) -> Option<MatrixMN<N, R, C>> where     DefaultAllocator: Allocator<N, R, C>,

Returns a normalized version of this matrix unless its norm as smaller or equal to eps.

impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>

pub fn normalize_mut(&mut self) -> N

Normalizes this matrix in-place and returns its norm.

pub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>

Normalizes this matrix in-place or does nothing if its norm is smaller or equal to eps.

If the normalization succeeded, returns the old normal of this matrix.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn row(&self, i: usize) -> MatrixSlice<N, U1, C, S::RStride, S::CStride>

Returns a slice containing the i-th row of this matrix.

pub fn row_part(     &self,     i: usize,     n: usize ) -> MatrixSlice<N, U1, Dynamic, S::RStride, S::CStride>

Returns a slice containing the n first elements of the i-th row of this matrix.

pub fn rows(     &self,     first_row: usize,     nrows: usize ) -> MatrixSlice<N, Dynamic, C, S::RStride, S::CStride>

Extracts from this matrix a set of consecutive rows.

pub fn rows_with_step(     &self,     first_row: usize,     nrows: usize,     step: usize ) -> MatrixSlice<N, Dynamic, C, Dynamic, S::CStride>

Extracts from this matrix a set of consecutive rows regularly skipping step rows.

pub fn fixed_rows<RSlice: DimName>(     &self,     first_row: usize ) -> MatrixSlice<N, RSlice, C, S::RStride, S::CStride>

Extracts a compile-time number of consecutive rows from this matrix.

pub fn fixed_rows_with_step<RSlice: DimName>(     &self,     first_row: usize,     step: usize ) -> MatrixSlice<N, RSlice, C, Dynamic, S::CStride>

Extracts from this matrix a compile-time number of rows regularly skipping step rows.

pub fn rows_generic<RSlice: Dim>(     &self,     row_start: usize,     nrows: RSlice ) -> MatrixSlice<N, RSlice, C, S::RStride, S::CStride>

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

pub fn rows_generic_with_step<RSlice>(     &self,     row_start: usize,     nrows: RSlice,     step: usize ) -> MatrixSlice<N, RSlice, C, Dynamic, S::CStride> where     RSlice: Dim,

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

pub fn column(&self, i: usize) -> MatrixSlice<N, R, U1, S::RStride, S::CStride>

Returns a slice containing the i-th column of this matrix.

pub fn column_part(     &self,     i: usize,     n: usize ) -> MatrixSlice<N, Dynamic, U1, S::RStride, S::CStride>

Returns a slice containing the n first elements of the i-th column of this matrix.

pub fn columns(     &self,     first_col: usize,     ncols: usize ) -> MatrixSlice<N, R, Dynamic, S::RStride, S::CStride>

Extracts from this matrix a set of consecutive columns.

pub fn columns_with_step(     &self,     first_col: usize,     ncols: usize,     step: usize ) -> MatrixSlice<N, R, Dynamic, S::RStride, Dynamic>

Extracts from this matrix a set of consecutive columns regularly skipping step columns.

pub fn fixed_columns<CSlice: DimName>(     &self,     first_col: usize ) -> MatrixSlice<N, R, CSlice, S::RStride, S::CStride>

Extracts a compile-time number of consecutive columns from this matrix.

pub fn fixed_columns_with_step<CSlice: DimName>(     &self,     first_col: usize,     step: usize ) -> MatrixSlice<N, R, CSlice, S::RStride, Dynamic>

Extracts from this matrix a compile-time number of columns regularly skipping step columns.

pub fn columns_generic<CSlice: Dim>(     &self,     first_col: usize,     ncols: CSlice ) -> MatrixSlice<N, R, CSlice, S::RStride, S::CStride>

Extracts from this matrix ncols columns. The number of columns may or may not be known at compile-time.

pub fn columns_generic_with_step<CSlice: Dim>(     &self,     first_col: usize,     ncols: CSlice,     step: usize ) -> MatrixSlice<N, R, CSlice, S::RStride, Dynamic>

Extracts from this matrix ncols columns skipping step columns. Both argument may or may not be values known at compile-time.

pub fn slice(     &self,     start: (usize, usize),     shape: (usize, usize) ) -> MatrixSlice<N, Dynamic, Dynamic, S::RStride, S::CStride>

Slices this matrix starting at its component (irow, icol) and with (nrows, ncols) consecutive elements.

pub fn slice_with_steps(     &self,     start: (usize, usize),     shape: (usize, usize),     steps: (usize, usize) ) -> MatrixSlice<N, Dynamic, Dynamic, Dynamic, Dynamic>

Slices this matrix starting at its component (start.0, start.1) and with (shape.0, shape.1) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

pub fn fixed_slice<RSlice, CSlice>(     &self,     irow: usize,     icol: usize ) -> MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride> where     RSlice: DimName,     CSlice: DimName,

Slices this matrix starting at its component (irow, icol) and with (R::dim(), CSlice::dim()) consecutive components.

pub fn fixed_slice_with_steps<RSlice, CSlice>(     &self,     start: (usize, usize),     steps: (usize, usize) ) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic> where     RSlice: DimName,     CSlice: DimName,

Slices this matrix starting at its component (start.0, start.1) and with (R::dim(), CSlice::dim()) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

pub fn generic_slice<RSlice, CSlice>(     &self,     start: (usize, usize),     shape: (RSlice, CSlice) ) -> MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride> where     RSlice: Dim,     CSlice: Dim,

Creates a slice that may or may not have a fixed size and stride.

pub fn generic_slice_with_steps<RSlice, CSlice>(     &self,     start: (usize, usize),     shape: (RSlice, CSlice),     steps: (usize, usize) ) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic> where     RSlice: Dim,     CSlice: Dim,

Creates a slice that may or may not have a fixed size and stride.

pub fn rows_range_pair<Range1: SliceRange<R>, Range2: SliceRange<R>>(     &self,     r1: Range1,     r2: Range2 ) -> (MatrixSlice<N, Range1::Size, C, S::RStride, S::CStride>, MatrixSlice<N, Range2::Size, C, S::RStride, S::CStride>)

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

pub fn columns_range_pair<Range1: SliceRange<C>, Range2: SliceRange<C>>(     &self,     r1: Range1,     r2: Range2 ) -> (MatrixSlice<N, R, Range1::Size, S::RStride, S::CStride>, MatrixSlice<N, R, Range2::Size, S::RStride, S::CStride>)

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>

pub fn row_mut(     &mut self,     i: usize ) -> MatrixSliceMut<N, U1, C, S::RStride, S::CStride>

Returns a slice containing the i-th row of this matrix.

pub fn row_part_mut(     &mut self,     i: usize,     n: usize ) -> MatrixSliceMut<N, U1, Dynamic, S::RStride, S::CStride>

Returns a slice containing the n first elements of the i-th row of this matrix.

pub fn rows_mut(     &mut self,     first_row: usize,     nrows: usize ) -> MatrixSliceMut<N, Dynamic, C, S::RStride, S::CStride>

Extracts from this matrix a set of consecutive rows.

pub fn rows_with_step_mut(     &mut self,     first_row: usize,     nrows: usize,     step: usize ) -> MatrixSliceMut<N, Dynamic, C, Dynamic, S::CStride>

Extracts from this matrix a set of consecutive rows regularly skipping step rows.

pub fn fixed_rows_mut<RSlice: DimName>(     &mut self,     first_row: usize ) -> MatrixSliceMut<N, RSlice, C, S::RStride, S::CStride>

Extracts a compile-time number of consecutive rows from this matrix.

pub fn fixed_rows_with_step_mut<RSlice: DimName>(     &mut self,     first_row: usize,     step: usize ) -> MatrixSliceMut<N, RSlice, C, Dynamic, S::CStride>

Extracts from this matrix a compile-time number of rows regularly skipping step rows.

pub fn rows_generic_mut<RSlice: Dim>(     &mut self,     row_start: usize,     nrows: RSlice ) -> MatrixSliceMut<N, RSlice, C, S::RStride, S::CStride>

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

pub fn rows_generic_with_step_mut<RSlice>(     &mut self,     row_start: usize,     nrows: RSlice,     step: usize ) -> MatrixSliceMut<N, RSlice, C, Dynamic, S::CStride> where     RSlice: Dim,

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

pub fn column_mut(     &mut self,     i: usize ) -> MatrixSliceMut<N, R, U1, S::RStride, S::CStride>

Returns a slice containing the i-th column of this matrix.

pub fn column_part_mut(     &mut self,     i: usize,     n: usize ) -> MatrixSliceMut<N, Dynamic, U1, S::RStride, S::CStride>

Returns a slice containing the n first elements of the i-th column of this matrix.

pub fn columns_mut(     &mut self,     first_col: usize,     ncols: usize ) -> MatrixSliceMut<N, R, Dynamic, S::RStride, S::CStride>

Extracts from this matrix a set of consecutive columns.

pub fn columns_with_step_mut(     &mut self,     first_col: usize,     ncols: usize,     step: usize ) -> MatrixSliceMut<N, R, Dynamic, S::RStride, Dynamic>

Extracts from this matrix a set of consecutive columns regularly skipping step columns.

pub fn fixed_columns_mut<CSlice: DimName>(     &mut self,     first_col: usize ) -> MatrixSliceMut<N, R, CSlice, S::RStride, S::CStride>

Extracts a compile-time number of consecutive columns from this matrix.

pub fn fixed_columns_with_step_mut<CSlice: DimName>(     &mut self,     first_col: usize,     step: usize ) -> MatrixSliceMut<N, R, CSlice, S::RStride, Dynamic>

Extracts from this matrix a compile-time number of columns regularly skipping step columns.

pub fn columns_generic_mut<CSlice: Dim>(     &mut self,     first_col: usize,     ncols: CSlice ) -> MatrixSliceMut<N, R, CSlice, S::RStride, S::CStride>

Extracts from this matrix ncols columns. The number of columns may or may not be known at compile-time.

pub fn columns_generic_with_step_mut<CSlice: Dim>(     &mut self,     first_col: usize,     ncols: CSlice,     step: usize ) -> MatrixSliceMut<N, R, CSlice, S::RStride, Dynamic>

Extracts from this matrix ncols columns skipping step columns. Both argument may or may not be values known at compile-time.

pub fn slice_mut(     &mut self,     start: (usize, usize),     shape: (usize, usize) ) -> MatrixSliceMut<N, Dynamic, Dynamic, S::RStride, S::CStride>

Slices this matrix starting at its component (irow, icol) and with (nrows, ncols) consecutive elements.

pub fn slice_with_steps_mut(     &mut self,     start: (usize, usize),     shape: (usize, usize),     steps: (usize, usize) ) -> MatrixSliceMut<N, Dynamic, Dynamic, Dynamic, Dynamic>

Slices this matrix starting at its component (start.0, start.1) and with (shape.0, shape.1) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

pub fn fixed_slice_mut<RSlice, CSlice>(     &mut self,     irow: usize,     icol: usize ) -> MatrixSliceMut<N, RSlice, CSlice, S::RStride, S::CStride> where     RSlice: DimName,     CSlice: DimName,

Slices this matrix starting at its component (irow, icol) and with (R::dim(), CSlice::dim()) consecutive components.

pub fn fixed_slice_with_steps_mut<RSlice, CSlice>(     &mut self,     start: (usize, usize),     steps: (usize, usize) ) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic> where     RSlice: DimName,     CSlice: DimName,

Slices this matrix starting at its component (start.0, start.1) and with (R::dim(), CSlice::dim()) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

pub fn generic_slice_mut<RSlice, CSlice>(     &mut self,     start: (usize, usize),     shape: (RSlice, CSlice) ) -> MatrixSliceMut<N, RSlice, CSlice, S::RStride, S::CStride> where     RSlice: Dim,     CSlice: Dim,

Creates a slice that may or may not have a fixed size and stride.

pub fn generic_slice_with_steps_mut<RSlice, CSlice>(     &mut self,     start: (usize, usize),     shape: (RSlice, CSlice),     steps: (usize, usize) ) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic> where     RSlice: Dim,     CSlice: Dim,

Creates a slice that may or may not have a fixed size and stride.

pub fn rows_range_pair_mut<Range1: SliceRange<R>, Range2: SliceRange<R>>(     &mut self,     r1: Range1,     r2: Range2 ) -> (MatrixSliceMut<N, Range1::Size, C, S::RStride, S::CStride>, MatrixSliceMut<N, Range2::Size, C, S::RStride, S::CStride>)

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

pub fn columns_range_pair_mut<Range1: SliceRange<C>, Range2: SliceRange<C>>(     &mut self,     r1: Range1,     r2: Range2 ) -> (MatrixSliceMut<N, R, Range1::Size, S::RStride, S::CStride>, MatrixSliceMut<N, R, Range2::Size, S::RStride, S::CStride>)

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn slice_range<RowRange, ColRange>(     &self,     rows: RowRange,     cols: ColRange ) -> MatrixSlice<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where     RowRange: SliceRange<R>,     ColRange: SliceRange<C>,

Slices a sub-matrix containing the rows indexed by the range rows and the columns indexed by the range cols.

pub fn rows_range<RowRange: SliceRange<R>>(     &self,     rows: RowRange ) -> MatrixSlice<N, RowRange::Size, C, S::RStride, S::CStride>

Slice containing all the rows indexed by the range rows.

pub fn columns_range<ColRange: SliceRange<C>>(     &self,     cols: ColRange ) -> MatrixSlice<N, R, ColRange::Size, S::RStride, S::CStride>

Slice containing all the columns indexed by the range rows.

impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>

pub fn slice_range_mut<RowRange, ColRange>(     &mut self,     rows: RowRange,     cols: ColRange ) -> MatrixSliceMut<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where     RowRange: SliceRange<R>,     ColRange: SliceRange<C>,

Slices a mutable sub-matrix containing the rows indexed by the range rows and the columns indexed by the range cols.

pub fn rows_range_mut<RowRange: SliceRange<R>>(     &mut self,     rows: RowRange ) -> MatrixSliceMut<N, RowRange::Size, C, S::RStride, S::CStride>

Slice containing all the rows indexed by the range rows.

pub fn columns_range_mut<ColRange: SliceRange<C>>(     &mut self,     cols: ColRange ) -> MatrixSliceMut<N, R, ColRange::Size, S::RStride, S::CStride>

Slice containing all the columns indexed by the range cols.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>

pub fn is_empty(&self) -> bool

Indicates if this is an empty matrix.

pub fn is_square(&self) -> bool

Indicates if this is a square matrix.

pub fn is_identity(&self, eps: N::Epsilon) -> bool where     N: Zero + One + RelativeEq,     N::Epsilon: Copy,

Indicated if this is the identity matrix within a relative error of eps.

If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates (i, i) for i from 0 to min(R, C)) are equal one; and that all other elements are zero.

pub fn is_orthogonal(&self, eps: N::Epsilon) -> bool where     N: Zero + One + ClosedAdd + ClosedMul + RelativeEq,     S: Storage<N, R, C>,     N::Epsilon: Copy,     DefaultAllocator: Allocator<N, C, C>,

Checks that Mᵀ × M = Id.

In this definition Id is approximately equal to the identity matrix with a relative error equal to eps.

impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where     DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>,

pub fn qr(self) -> QR<N, R, C>

Computes the QR decomposition of this matrix.

impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where     DimMinimum<R, C>: DimSub<U1>,     DefaultAllocator: Allocator<N, R, C> + Allocator<N, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>> + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,

pub fn bidiagonalize(self) -> Bidiagonal<N, R, C>

Computes the bidiagonalization using householder reflections.

impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where     DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,

pub fn lu(self) -> LU<N, R, C>

Computes the LU decomposition with partial (row) pivoting of matrix.

impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where     DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,

pub fn full_piv_lu(self) -> FullPivLU<N, R, C>

Computes the LU decomposition with full pivoting of matrix.

This effectively computes P, L, U, Q such that P * matrix * Q = LU.

impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where     DimMinimum<R, C>: DimSub<U1>,     DefaultAllocator: Allocator<N, R, C> + Allocator<N, C> + Allocator<N, R> + Allocator<N, DimDiff<DimMinimum<R, C>, U1>> + Allocator<N, DimMinimum<R, C>, C> + Allocator<N, R, DimMinimum<R, C>> + Allocator<N, DimMinimum<R, C>>,

pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C>

Computes the Singular Value Decomposition using implicit shift.

pub fn try_svd(     self,     compute_u: bool,     compute_v: bool,     eps: N,     max_niter: usize ) -> Option<SVD<N, R, C>>

Attempts to compute the Singular Value Decomposition of matrix using implicit shift.

Arguments

• compute_u − set this to true to enable the computation of left-singular vectors.
• compute_v − set this to true to enable the computation of left-singular vectors.
• eps − tolerance used to determine when a value converged to 0.
• max_niter − maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded, None is returned. If niter == 0, then the algorithm continues indefinitely until convergence.

pub fn singular_values(&self) -> VectorN<N, DimMinimum<R, C>>

Computes the singular values of this matrix.

pub fn rank(&self, eps: N) -> usize

Computes the rank of this matrix.

All singular values below eps are considered equal to 0.

pub fn pseudo_inverse(self, eps: N) -> MatrixMN<N, C, R> where     DefaultAllocator: Allocator<N, C, R>,

Computes the pseudo-inverse of this matrix.

All singular values below eps are considered equal to 0.

Trait Implementations

impl<N: Scalar, S> Deref for Matrix<N, U1, U1, S> where     S: ContiguousStorage<N, U1, U1>,

type Target = X<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U1, U1, S> where     S: ContiguousStorageMut<N, U1, U1>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U2, U1, S> where     S: ContiguousStorage<N, U2, U1>,

type Target = XY<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U2, U1, S> where     S: ContiguousStorageMut<N, U2, U1>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U3, U1, S> where     S: ContiguousStorage<N, U3, U1>,

type Target = XYZ<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U3, U1, S> where     S: ContiguousStorageMut<N, U3, U1>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U4, U1, S> where     S: ContiguousStorage<N, U4, U1>,

type Target = XYZW<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U4, U1, S> where     S: ContiguousStorageMut<N, U4, U1>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U5, U1, S> where     S: ContiguousStorage<N, U5, U1>,

type Target = XYZWA<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U5, U1, S> where     S: ContiguousStorageMut<N, U5, U1>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U6, U1, S> where     S: ContiguousStorage<N, U6, U1>,

type Target = XYZWAB<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U6, U1, S> where     S: ContiguousStorageMut<N, U6, U1>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U1, U2, S> where     S: ContiguousStorage<N, U1, U2>,

type Target = XY<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U1, U2, S> where     S: ContiguousStorageMut<N, U1, U2>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U1, U3, S> where     S: ContiguousStorage<N, U1, U3>,

type Target = XYZ<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U1, U3, S> where     S: ContiguousStorageMut<N, U1, U3>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U1, U4, S> where     S: ContiguousStorage<N, U1, U4>,

type Target = XYZW<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U1, U4, S> where     S: ContiguousStorageMut<N, U1, U4>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U1, U5, S> where     S: ContiguousStorage<N, U1, U5>,

type Target = XYZWA<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U1, U5, S> where     S: ContiguousStorageMut<N, U1, U5>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U1, U6, S> where     S: ContiguousStorage<N, U1, U6>,

type Target = XYZWAB<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U1, U6, S> where     S: ContiguousStorageMut<N, U1, U6>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U2, U2, S> where     S: ContiguousStorage<N, U2, U2>,

type Target = M2x2<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U2, U2, S> where     S: ContiguousStorageMut<N, U2, U2>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U2, U3, S> where     S: ContiguousStorage<N, U2, U3>,

type Target = M2x3<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U2, U3, S> where     S: ContiguousStorageMut<N, U2, U3>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U2, U4, S> where     S: ContiguousStorage<N, U2, U4>,

type Target = M2x4<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U2, U4, S> where     S: ContiguousStorageMut<N, U2, U4>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U2, U5, S> where     S: ContiguousStorage<N, U2, U5>,

type Target = M2x5<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U2, U5, S> where     S: ContiguousStorageMut<N, U2, U5>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U2, U6, S> where     S: ContiguousStorage<N, U2, U6>,

type Target = M2x6<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U2, U6, S> where     S: ContiguousStorageMut<N, U2, U6>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U3, U2, S> where     S: ContiguousStorage<N, U3, U2>,

type Target = M3x2<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U3, U2, S> where     S: ContiguousStorageMut<N, U3, U2>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U3, U3, S> where     S: ContiguousStorage<N, U3, U3>,

type Target = M3x3<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U3, U3, S> where     S: ContiguousStorageMut<N, U3, U3>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U3, U4, S> where     S: ContiguousStorage<N, U3, U4>,

type Target = M3x4<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U3, U4, S> where     S: ContiguousStorageMut<N, U3, U4>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U3, U5, S> where     S: ContiguousStorage<N, U3, U5>,

type Target = M3x5<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U3, U5, S> where     S: ContiguousStorageMut<N, U3, U5>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U3, U6, S> where     S: ContiguousStorage<N, U3, U6>,

type Target = M3x6<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U3, U6, S> where     S: ContiguousStorageMut<N, U3, U6>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U4, U2, S> where     S: ContiguousStorage<N, U4, U2>,

type Target = M4x2<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U4, U2, S> where     S: ContiguousStorageMut<N, U4, U2>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U4, U3, S> where     S: ContiguousStorage<N, U4, U3>,

type Target = M4x3<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U4, U3, S> where     S: ContiguousStorageMut<N, U4, U3>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U4, U4, S> where     S: ContiguousStorage<N, U4, U4>,

type Target = M4x4<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U4, U4, S> where     S: ContiguousStorageMut<N, U4, U4>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U4, U5, S> where     S: ContiguousStorage<N, U4, U5>,

type Target = M4x5<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U4, U5, S> where     S: ContiguousStorageMut<N, U4, U5>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U4, U6, S> where     S: ContiguousStorage<N, U4, U6>,

type Target = M4x6<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U4, U6, S> where     S: ContiguousStorageMut<N, U4, U6>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U5, U2, S> where     S: ContiguousStorage<N, U5, U2>,

type Target = M5x2<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U5, U2, S> where     S: ContiguousStorageMut<N, U5, U2>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U5, U3, S> where     S: ContiguousStorage<N, U5, U3>,

type Target = M5x3<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U5, U3, S> where     S: ContiguousStorageMut<N, U5, U3>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U5, U4, S> where     S: ContiguousStorage<N, U5, U4>,

type Target = M5x4<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U5, U4, S> where     S: ContiguousStorageMut<N, U5, U4>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U5, U5, S> where     S: ContiguousStorage<N, U5, U5>,

type Target = M5x5<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U5, U5, S> where     S: ContiguousStorageMut<N, U5, U5>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U5, U6, S> where     S: ContiguousStorage<N, U5, U6>,

type Target = M5x6<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U5, U6, S> where     S: ContiguousStorageMut<N, U5, U6>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U6, U2, S> where     S: ContiguousStorage<N, U6, U2>,

type Target = M6x2<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U6, U2, S> where     S: ContiguousStorageMut<N, U6, U2>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U6, U3, S> where     S: ContiguousStorage<N, U6, U3>,

type Target = M6x3<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U6, U3, S> where     S: ContiguousStorageMut<N, U6, U3>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U6, U4, S> where     S: ContiguousStorage<N, U6, U4>,

type Target = M6x4<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U6, U4, S> where     S: ContiguousStorageMut<N, U6, U4>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U6, U5, S> where     S: ContiguousStorage<N, U6, U5>,

type Target = M6x5<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U6, U5, S> where     S: ContiguousStorageMut<N, U6, U5>,

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

Mutably dereferences the value.

impl<N: Scalar, S> Deref for Matrix<N, U6, U6, S> where     S: ContiguousStorage<N, U6, U6>,

type Target = M6x6<N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Scalar, S> DerefMut for Matrix<N, U6, U6, S> where     S: ContiguousStorageMut<N, U6, U6>,

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

Mutably dereferences the value.

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Index<usize> for Matrix<N, R, C, S>

type Output = N

The returned type after indexing.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn index(&self, i: usize) -> &N

Performs the indexing (container[index]) operation.

impl<N, R: Dim, C: Dim, S> Index<(usize, usize)> for Matrix<N, R, C, S> where     N: Scalar,     S: Storage<N, R, C>,

type Output = N

The returned type after indexing.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn index(&self, ij: (usize, usize)) -> &N

Performs the indexing (container[index]) operation.

impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IndexMut<usize> for Matrix<N, R, C, S>

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn index_mut(&mut self, i: usize) -> &mut N

Performs the mutable indexing (container[index]) operation.

impl<N, R: Dim, C: Dim, S> IndexMut<(usize, usize)> for Matrix<N, R, C, S> where     N: Scalar,     S: StorageMut<N, R, C>,

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn index_mut(&mut self, ij: (usize, usize)) -> &mut N

Performs the mutable indexing (container[index]) operation.

impl<N, R: Dim, C: Dim, S> Neg for Matrix<N, R, C, S> where     N: Scalar + ClosedNeg,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<N, R, C>,

type Output = MatrixMN<N, R, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, N, R: Dim, C: Dim, S> Neg for &'a Matrix<N, R, C, S> where     N: Scalar + ClosedNeg,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<N, R, C>,

type Output = MatrixMN<N, R, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedAdd,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

type Output = MatrixSum<N, R1, C1, R2, C2>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the + operation.

impl<'a, N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedAdd,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,     ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,

type Output = MatrixSum<N, R2, C2, R1, C1>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the + operation.

impl<N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedAdd,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

type Output = MatrixSum<N, R1, C1, R2, C2>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the + operation.

impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedAdd,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

type Output = MatrixSum<N, R1, C1, R2, C2>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the + operation.

impl<'b, N, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedAdd,     SA: StorageMut<N, R1, C1>,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

fn add_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)

Performs the += operation.

impl<N, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedAdd,     SA: StorageMut<N, R1, C1>,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

fn add_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)

Performs the += operation.

impl<'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedSub,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

type Output = MatrixSum<N, R1, C1, R2, C2>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the - operation.

impl<'a, N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedSub,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,     ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,

type Output = MatrixSum<N, R2, C2, R1, C1>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the - operation.

impl<N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedSub,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

type Output = MatrixSum<N, R1, C1, R2, C2>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the - operation.

impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedSub,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

type Output = MatrixSum<N, R1, C1, R2, C2>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the - operation.

impl<'b, N, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedSub,     SA: StorageMut<N, R1, C1>,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

fn sub_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)

Performs the -= operation.

impl<N, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     C2: Dim,     N: Scalar + ClosedSub,     SA: StorageMut<N, R1, C1>,     SB: Storage<N, R2, C2>,     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

fn sub_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)

Performs the -= operation.

impl<N, R: Dim, C: Dim, S> Mul<N> for Matrix<N, R, C, S> where     N: Scalar + ClosedMul,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<N, R, C>,

type Output = MatrixMN<N, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl<'a, N, R: Dim, C: Dim, S> Mul<N> for &'a Matrix<N, R, C, S> where     N: Scalar + ClosedMul,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<N, R, C>,

type Output = MatrixMN<N, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl<N, R: Dim, C: Dim, S> MulAssign<N> for Matrix<N, R, C, S> where     N: Scalar + ClosedMul,     S: StorageMut<N, R, C>,

fn mul_assign(&mut self, rhs: N)

Performs the *= operation.

impl<N, R: Dim, C: Dim, S> Div<N> for Matrix<N, R, C, S> where     N: Scalar + ClosedDiv,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<N, R, C>,

type Output = MatrixMN<N, R, C>

The resulting type after applying the / operator.

fn div(self, rhs: N) -> Self::Output

Performs the / operation.

impl<'a, N, R: Dim, C: Dim, S> Div<N> for &'a Matrix<N, R, C, S> where     N: Scalar + ClosedDiv,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<N, R, C>,

type Output = MatrixMN<N, R, C>

The resulting type after applying the / operator.

fn div(self, rhs: N) -> Self::Output

Performs the / operation.

impl<N, R: Dim, C: Dim, S> DivAssign<N> for Matrix<N, R, C, S> where     N: Scalar + ClosedDiv,     S: StorageMut<N, R, C>,

fn div_assign(&mut self, rhs: N)

Performs the /= operation.

impl<R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<Matrix<u8, R, C, S>> for u8 where     DefaultAllocator: Allocator<u8, R, C>,

type Output = MatrixMN<u8, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<u8, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<&'b Matrix<u8, R, C, S>> for u8 where     DefaultAllocator: Allocator<u8, R, C>,

type Output = MatrixMN<u8, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<u8, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<Matrix<u16, R, C, S>> for u16 where     DefaultAllocator: Allocator<u16, R, C>,

type Output = MatrixMN<u16, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<u16, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<&'b Matrix<u16, R, C, S>> for u16 where     DefaultAllocator: Allocator<u16, R, C>,

type Output = MatrixMN<u16, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<u16, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<Matrix<u32, R, C, S>> for u32 where     DefaultAllocator: Allocator<u32, R, C>,

type Output = MatrixMN<u32, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<u32, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<&'b Matrix<u32, R, C, S>> for u32 where     DefaultAllocator: Allocator<u32, R, C>,

type Output = MatrixMN<u32, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<u32, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<Matrix<u64, R, C, S>> for u64 where     DefaultAllocator: Allocator<u64, R, C>,

type Output = MatrixMN<u64, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<u64, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<&'b Matrix<u64, R, C, S>> for u64 where     DefaultAllocator: Allocator<u64, R, C>,

type Output = MatrixMN<u64, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<u64, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<Matrix<usize, R, C, S>> for usize where     DefaultAllocator: Allocator<usize, R, C>,

type Output = MatrixMN<usize, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<usize, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<&'b Matrix<usize, R, C, S>> for usize where     DefaultAllocator: Allocator<usize, R, C>,

type Output = MatrixMN<usize, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<usize, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<Matrix<i8, R, C, S>> for i8 where     DefaultAllocator: Allocator<i8, R, C>,

type Output = MatrixMN<i8, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<i8, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<&'b Matrix<i8, R, C, S>> for i8 where     DefaultAllocator: Allocator<i8, R, C>,

type Output = MatrixMN<i8, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<i8, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<Matrix<i16, R, C, S>> for i16 where     DefaultAllocator: Allocator<i16, R, C>,

type Output = MatrixMN<i16, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<i16, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<&'b Matrix<i16, R, C, S>> for i16 where     DefaultAllocator: Allocator<i16, R, C>,

type Output = MatrixMN<i16, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<i16, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<Matrix<i32, R, C, S>> for i32 where     DefaultAllocator: Allocator<i32, R, C>,

type Output = MatrixMN<i32, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<i32, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<&'b Matrix<i32, R, C, S>> for i32 where     DefaultAllocator: Allocator<i32, R, C>,

type Output = MatrixMN<i32, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<i32, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<Matrix<i64, R, C, S>> for i64 where     DefaultAllocator: Allocator<i64, R, C>,

type Output = MatrixMN<i64, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<i64, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<&'b Matrix<i64, R, C, S>> for i64 where     DefaultAllocator: Allocator<i64, R, C>,

type Output = MatrixMN<i64, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<i64, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<Matrix<isize, R, C, S>> for isize where     DefaultAllocator: Allocator<isize, R, C>,

type Output = MatrixMN<isize, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<isize, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<&'b Matrix<isize, R, C, S>> for isize where     DefaultAllocator: Allocator<isize, R, C>,

type Output = MatrixMN<isize, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<isize, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<Matrix<f32, R, C, S>> for f32 where     DefaultAllocator: Allocator<f32, R, C>,

type Output = MatrixMN<f32, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<f32, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<&'b Matrix<f32, R, C, S>> for f32 where     DefaultAllocator: Allocator<f32, R, C>,

type Output = MatrixMN<f32, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<f32, R, C, S>) -> Self::Output

Performs the * operation.

impl<R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<Matrix<f64, R, C, S>> for f64 where     DefaultAllocator: Allocator<f64, R, C>,

type Output = MatrixMN<f64, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<f64, R, C, S>) -> Self::Output

Performs the * operation.

impl<'b, R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<&'b Matrix<f64, R, C, S>> for f64 where     DefaultAllocator: Allocator<f64, R, C>,

type Output = MatrixMN<f64, R, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<f64, R, C, S>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SA: Storage<N, R1, C1>,     SB: Storage<N, R2, C2>,     DefaultAllocator: Allocator<N, R1, C2>,     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = MatrixMN<N, R1, C2>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<'a, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SB: Storage<N, R2, C2>,     SA: Storage<N, R1, C1>,     DefaultAllocator: Allocator<N, R1, C2>,     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = MatrixMN<N, R1, C2>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<'b, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SB: Storage<N, R2, C2>,     SA: Storage<N, R1, C1>,     DefaultAllocator: Allocator<N, R1, C2>,     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = MatrixMN<N, R1, C2>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SB: Storage<N, R2, C2>,     SA: Storage<N, R1, C1>,     DefaultAllocator: Allocator<N, R1, C2>,     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = MatrixMN<N, R1, C2>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SB: Storage<N, R2, C1>,     SA: ContiguousStorageMut<N, R1, C1> + Clone,     ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,     DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,

fn mul_assign(&mut self, rhs: Matrix<N, R2, C1, SB>)

Performs the *= operation.

impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where     R1: Dim,     C1: Dim,     R2: Dim,     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     SB: Storage<N, R2, C1>,     SA: ContiguousStorageMut<N, R1, C1> + Clone,     ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,     DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,

fn mul_assign(&mut self, rhs: &'b Matrix<N, R2, C1, SB>)

Performs the *= operation.

impl<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> IntoIterator for &'a Matrix<N, R, C, S>

type Item = &'a N

The type of the elements being iterated over.

type IntoIter = MatrixIter<'a, N, R, C, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IntoIterator for &'a mut Matrix<N, R, C, S>

type Item = &'a mut N

The type of the elements being iterated over.

type IntoIter = MatrixIterMut<'a, N, R, C, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<N, S> Into<[N; 1]> for Matrix<N, U1, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U1>,

fn into(self) -> [N; 1]

Performs the conversion.

impl<N, S> AsRef<[N; 1]> for Matrix<N, U1, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U1>,

fn as_ref(&self) -> &[N; 1]

Performs the conversion.

impl<N, S> AsMut<[N; 1]> for Matrix<N, U1, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U1>,

fn as_mut(&mut self) -> &mut [N; 1]

Performs the conversion.

impl<N, S> Into<[N; 2]> for Matrix<N, U1, U2, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U2>,

fn into(self) -> [N; 2]

Performs the conversion.

impl<N, S> AsRef<[N; 2]> for Matrix<N, U1, U2, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U2>,

fn as_ref(&self) -> &[N; 2]

Performs the conversion.

impl<N, S> AsMut<[N; 2]> for Matrix<N, U1, U2, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U2>,

fn as_mut(&mut self) -> &mut [N; 2]

Performs the conversion.

impl<N, S> Into<[N; 3]> for Matrix<N, U1, U3, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U3>,

fn into(self) -> [N; 3]

Performs the conversion.

impl<N, S> AsRef<[N; 3]> for Matrix<N, U1, U3, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U3>,

fn as_ref(&self) -> &[N; 3]

Performs the conversion.

impl<N, S> AsMut<[N; 3]> for Matrix<N, U1, U3, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U3>,

fn as_mut(&mut self) -> &mut [N; 3]

Performs the conversion.

impl<N, S> Into<[N; 4]> for Matrix<N, U1, U4, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U4>,

fn into(self) -> [N; 4]

Performs the conversion.

impl<N, S> AsRef<[N; 4]> for Matrix<N, U1, U4, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U4>,

fn as_ref(&self) -> &[N; 4]

Performs the conversion.

impl<N, S> AsMut<[N; 4]> for Matrix<N, U1, U4, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U4>,

fn as_mut(&mut self) -> &mut [N; 4]

Performs the conversion.

impl<N, S> Into<[N; 5]> for Matrix<N, U1, U5, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U5>,

fn into(self) -> [N; 5]

Performs the conversion.

impl<N, S> AsRef<[N; 5]> for Matrix<N, U1, U5, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U5>,

fn as_ref(&self) -> &[N; 5]

Performs the conversion.

impl<N, S> AsMut<[N; 5]> for Matrix<N, U1, U5, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U5>,

fn as_mut(&mut self) -> &mut [N; 5]

Performs the conversion.

impl<N, S> Into<[N; 6]> for Matrix<N, U1, U6, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U6>,

fn into(self) -> [N; 6]

Performs the conversion.

impl<N, S> AsRef<[N; 6]> for Matrix<N, U1, U6, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U6>,

fn as_ref(&self) -> &[N; 6]

Performs the conversion.

impl<N, S> AsMut<[N; 6]> for Matrix<N, U1, U6, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U6>,

fn as_mut(&mut self) -> &mut [N; 6]

Performs the conversion.

impl<N, S> Into<[N; 7]> for Matrix<N, U1, U7, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U7>,

fn into(self) -> [N; 7]

Performs the conversion.

impl<N, S> AsRef<[N; 7]> for Matrix<N, U1, U7, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U7>,

fn as_ref(&self) -> &[N; 7]

Performs the conversion.

impl<N, S> AsMut<[N; 7]> for Matrix<N, U1, U7, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U7>,

fn as_mut(&mut self) -> &mut [N; 7]

Performs the conversion.

impl<N, S> Into<[N; 8]> for Matrix<N, U1, U8, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U8>,

fn into(self) -> [N; 8]

Performs the conversion.

impl<N, S> AsRef<[N; 8]> for Matrix<N, U1, U8, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U8>,

fn as_ref(&self) -> &[N; 8]

Performs the conversion.

impl<N, S> AsMut<[N; 8]> for Matrix<N, U1, U8, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U8>,

fn as_mut(&mut self) -> &mut [N; 8]

Performs the conversion.

impl<N, S> Into<[N; 9]> for Matrix<N, U1, U9, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U9>,

fn into(self) -> [N; 9]

Performs the conversion.

impl<N, S> AsRef<[N; 9]> for Matrix<N, U1, U9, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U9>,

fn as_ref(&self) -> &[N; 9]

Performs the conversion.

impl<N, S> AsMut<[N; 9]> for Matrix<N, U1, U9, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U9>,

fn as_mut(&mut self) -> &mut [N; 9]

Performs the conversion.

impl<N, S> Into<[N; 10]> for Matrix<N, U1, U10, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U10>,

fn into(self) -> [N; 10]

Performs the conversion.

impl<N, S> AsRef<[N; 10]> for Matrix<N, U1, U10, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U10>,

fn as_ref(&self) -> &[N; 10]

Performs the conversion.

impl<N, S> AsMut<[N; 10]> for Matrix<N, U1, U10, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U10>,

fn as_mut(&mut self) -> &mut [N; 10]

Performs the conversion.

impl<N, S> Into<[N; 11]> for Matrix<N, U1, U11, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U11>,

fn into(self) -> [N; 11]

Performs the conversion.

impl<N, S> AsRef<[N; 11]> for Matrix<N, U1, U11, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U11>,

fn as_ref(&self) -> &[N; 11]

Performs the conversion.

impl<N, S> AsMut<[N; 11]> for Matrix<N, U1, U11, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U11>,

fn as_mut(&mut self) -> &mut [N; 11]

Performs the conversion.

impl<N, S> Into<[N; 12]> for Matrix<N, U1, U12, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U12>,

fn into(self) -> [N; 12]

Performs the conversion.

impl<N, S> AsRef<[N; 12]> for Matrix<N, U1, U12, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U12>,

fn as_ref(&self) -> &[N; 12]

Performs the conversion.

impl<N, S> AsMut<[N; 12]> for Matrix<N, U1, U12, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U12>,

fn as_mut(&mut self) -> &mut [N; 12]

Performs the conversion.

impl<N, S> Into<[N; 13]> for Matrix<N, U1, U13, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U13>,

fn into(self) -> [N; 13]

Performs the conversion.

impl<N, S> AsRef<[N; 13]> for Matrix<N, U1, U13, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U13>,

fn as_ref(&self) -> &[N; 13]

Performs the conversion.

impl<N, S> AsMut<[N; 13]> for Matrix<N, U1, U13, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U13>,

fn as_mut(&mut self) -> &mut [N; 13]

Performs the conversion.

impl<N, S> Into<[N; 14]> for Matrix<N, U1, U14, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U14>,

fn into(self) -> [N; 14]

Performs the conversion.

impl<N, S> AsRef<[N; 14]> for Matrix<N, U1, U14, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U14>,

fn as_ref(&self) -> &[N; 14]

Performs the conversion.

impl<N, S> AsMut<[N; 14]> for Matrix<N, U1, U14, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U14>,

fn as_mut(&mut self) -> &mut [N; 14]

Performs the conversion.

impl<N, S> Into<[N; 15]> for Matrix<N, U1, U15, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U15>,

fn into(self) -> [N; 15]

Performs the conversion.

impl<N, S> AsRef<[N; 15]> for Matrix<N, U1, U15, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U15>,

fn as_ref(&self) -> &[N; 15]

Performs the conversion.

impl<N, S> AsMut<[N; 15]> for Matrix<N, U1, U15, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U15>,

fn as_mut(&mut self) -> &mut [N; 15]

Performs the conversion.

impl<N, S> Into<[N; 16]> for Matrix<N, U1, U16, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U16>,

fn into(self) -> [N; 16]

Performs the conversion.

impl<N, S> AsRef<[N; 16]> for Matrix<N, U1, U16, S> where     N: Scalar,     S: ContiguousStorage<N, U1, U16>,

fn as_ref(&self) -> &[N; 16]

Performs the conversion.

impl<N, S> AsMut<[N; 16]> for Matrix<N, U1, U16, S> where     N: Scalar,     S: ContiguousStorageMut<N, U1, U16>,

fn as_mut(&mut self) -> &mut [N; 16]

Performs the conversion.

impl<N, S> Into<[N; 2]> for Matrix<N, U2, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U2, U1>,

fn into(self) -> [N; 2]

Performs the conversion.

impl<N, S> AsRef<[N; 2]> for Matrix<N, U2, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U2, U1>,

fn as_ref(&self) -> &[N; 2]

Performs the conversion.

impl<N, S> AsMut<[N; 2]> for Matrix<N, U2, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U2, U1>,

fn as_mut(&mut self) -> &mut [N; 2]

Performs the conversion.

impl<N, S> Into<[N; 3]> for Matrix<N, U3, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U3, U1>,

fn into(self) -> [N; 3]

Performs the conversion.

impl<N, S> AsRef<[N; 3]> for Matrix<N, U3, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U3, U1>,

fn as_ref(&self) -> &[N; 3]

Performs the conversion.

impl<N, S> AsMut<[N; 3]> for Matrix<N, U3, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U3, U1>,

fn as_mut(&mut self) -> &mut [N; 3]

Performs the conversion.

impl<N, S> Into<[N; 4]> for Matrix<N, U4, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U4, U1>,

fn into(self) -> [N; 4]

Performs the conversion.

impl<N, S> AsRef<[N; 4]> for Matrix<N, U4, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U4, U1>,

fn as_ref(&self) -> &[N; 4]

Performs the conversion.

impl<N, S> AsMut<[N; 4]> for Matrix<N, U4, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U4, U1>,

fn as_mut(&mut self) -> &mut [N; 4]

Performs the conversion.

impl<N, S> Into<[N; 5]> for Matrix<N, U5, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U5, U1>,

fn into(self) -> [N; 5]

Performs the conversion.

impl<N, S> AsRef<[N; 5]> for Matrix<N, U5, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U5, U1>,

fn as_ref(&self) -> &[N; 5]

Performs the conversion.

impl<N, S> AsMut<[N; 5]> for Matrix<N, U5, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U5, U1>,

fn as_mut(&mut self) -> &mut [N; 5]

Performs the conversion.

impl<N, S> Into<[N; 6]> for Matrix<N, U6, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U6, U1>,

fn into(self) -> [N; 6]

Performs the conversion.

impl<N, S> AsRef<[N; 6]> for Matrix<N, U6, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U6, U1>,

fn as_ref(&self) -> &[N; 6]

Performs the conversion.

impl<N, S> AsMut<[N; 6]> for Matrix<N, U6, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U6, U1>,

fn as_mut(&mut self) -> &mut [N; 6]

Performs the conversion.

impl<N, S> Into<[N; 7]> for Matrix<N, U7, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U7, U1>,

fn into(self) -> [N; 7]

Performs the conversion.

impl<N, S> AsRef<[N; 7]> for Matrix<N, U7, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U7, U1>,

fn as_ref(&self) -> &[N; 7]

Performs the conversion.

impl<N, S> AsMut<[N; 7]> for Matrix<N, U7, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U7, U1>,

fn as_mut(&mut self) -> &mut [N; 7]

Performs the conversion.

impl<N, S> Into<[N; 8]> for Matrix<N, U8, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U8, U1>,

fn into(self) -> [N; 8]

Performs the conversion.

impl<N, S> AsRef<[N; 8]> for Matrix<N, U8, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U8, U1>,

fn as_ref(&self) -> &[N; 8]

Performs the conversion.

impl<N, S> AsMut<[N; 8]> for Matrix<N, U8, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U8, U1>,

fn as_mut(&mut self) -> &mut [N; 8]

Performs the conversion.

impl<N, S> Into<[N; 9]> for Matrix<N, U9, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U9, U1>,

fn into(self) -> [N; 9]

Performs the conversion.

impl<N, S> AsRef<[N; 9]> for Matrix<N, U9, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U9, U1>,

fn as_ref(&self) -> &[N; 9]

Performs the conversion.

impl<N, S> AsMut<[N; 9]> for Matrix<N, U9, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U9, U1>,

fn as_mut(&mut self) -> &mut [N; 9]

Performs the conversion.

impl<N, S> Into<[N; 10]> for Matrix<N, U10, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U10, U1>,

fn into(self) -> [N; 10]

Performs the conversion.

impl<N, S> AsRef<[N; 10]> for Matrix<N, U10, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U10, U1>,

fn as_ref(&self) -> &[N; 10]

Performs the conversion.

impl<N, S> AsMut<[N; 10]> for Matrix<N, U10, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U10, U1>,

fn as_mut(&mut self) -> &mut [N; 10]

Performs the conversion.

impl<N, S> Into<[N; 11]> for Matrix<N, U11, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U11, U1>,

fn into(self) -> [N; 11]

Performs the conversion.

impl<N, S> AsRef<[N; 11]> for Matrix<N, U11, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U11, U1>,

fn as_ref(&self) -> &[N; 11]

Performs the conversion.

impl<N, S> AsMut<[N; 11]> for Matrix<N, U11, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U11, U1>,

fn as_mut(&mut self) -> &mut [N; 11]

Performs the conversion.

impl<N, S> Into<[N; 12]> for Matrix<N, U12, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U12, U1>,

fn into(self) -> [N; 12]

Performs the conversion.

impl<N, S> AsRef<[N; 12]> for Matrix<N, U12, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U12, U1>,

fn as_ref(&self) -> &[N; 12]

Performs the conversion.

impl<N, S> AsMut<[N; 12]> for Matrix<N, U12, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U12, U1>,

fn as_mut(&mut self) -> &mut [N; 12]

Performs the conversion.

impl<N, S> Into<[N; 13]> for Matrix<N, U13, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U13, U1>,

fn into(self) -> [N; 13]

Performs the conversion.

impl<N, S> AsRef<[N; 13]> for Matrix<N, U13, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U13, U1>,

fn as_ref(&self) -> &[N; 13]

Performs the conversion.

impl<N, S> AsMut<[N; 13]> for Matrix<N, U13, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U13, U1>,

fn as_mut(&mut self) -> &mut [N; 13]

Performs the conversion.

impl<N, S> Into<[N; 14]> for Matrix<N, U14, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U14, U1>,

fn into(self) -> [N; 14]

Performs the conversion.

impl<N, S> AsRef<[N; 14]> for Matrix<N, U14, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U14, U1>,

fn as_ref(&self) -> &[N; 14]

Performs the conversion.

impl<N, S> AsMut<[N; 14]> for Matrix<N, U14, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U14, U1>,

fn as_mut(&mut self) -> &mut [N; 14]

Performs the conversion.

impl<N, S> Into<[N; 15]> for Matrix<N, U15, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U15, U1>,

fn into(self) -> [N; 15]

Performs the conversion.

impl<N, S> AsRef<[N; 15]> for Matrix<N, U15, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U15, U1>,

fn as_ref(&self) -> &[N; 15]

Performs the conversion.

impl<N, S> AsMut<[N; 15]> for Matrix<N, U15, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U15, U1>,

fn as_mut(&mut self) -> &mut [N; 15]

Performs the conversion.

impl<N, S> Into<[N; 16]> for Matrix<N, U16, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U16, U1>,

fn into(self) -> [N; 16]

Performs the conversion.

impl<N, S> AsRef<[N; 16]> for Matrix<N, U16, U1, S> where     N: Scalar,     S: ContiguousStorage<N, U16, U1>,

fn as_ref(&self) -> &[N; 16]

Performs the conversion.

impl<N, S> AsMut<[N; 16]> for Matrix<N, U16, U1, S> where     N: Scalar,     S: ContiguousStorageMut<N, U16, U1>,

fn as_mut(&mut self) -> &mut [N; 16]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where     S: ContiguousStorage<N, U2, U2>,

fn into(self) -> [[N; 2]; 2]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where     S: ContiguousStorage<N, U2, U2>,

fn as_ref(&self) -> &[[N; 2]; 2]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where     S: ContiguousStorageMut<N, U2, U2>,

fn as_mut(&mut self) -> &mut [[N; 2]; 2]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where     S: ContiguousStorage<N, U2, U3>,

fn into(self) -> [[N; 2]; 3]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where     S: ContiguousStorage<N, U2, U3>,

fn as_ref(&self) -> &[[N; 2]; 3]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where     S: ContiguousStorageMut<N, U2, U3>,

fn as_mut(&mut self) -> &mut [[N; 2]; 3]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where     S: ContiguousStorage<N, U2, U4>,

fn into(self) -> [[N; 2]; 4]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where     S: ContiguousStorage<N, U2, U4>,

fn as_ref(&self) -> &[[N; 2]; 4]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where     S: ContiguousStorageMut<N, U2, U4>,

fn as_mut(&mut self) -> &mut [[N; 2]; 4]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where     S: ContiguousStorage<N, U2, U5>,

fn into(self) -> [[N; 2]; 5]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where     S: ContiguousStorage<N, U2, U5>,

fn as_ref(&self) -> &[[N; 2]; 5]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where     S: ContiguousStorageMut<N, U2, U5>,

fn as_mut(&mut self) -> &mut [[N; 2]; 5]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where     S: ContiguousStorage<N, U2, U6>,

fn into(self) -> [[N; 2]; 6]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where     S: ContiguousStorage<N, U2, U6>,

fn as_ref(&self) -> &[[N; 2]; 6]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where     S: ContiguousStorageMut<N, U2, U6>,

fn as_mut(&mut self) -> &mut [[N; 2]; 6]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where     S: ContiguousStorage<N, U3, U2>,

fn into(self) -> [[N; 3]; 2]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where     S: ContiguousStorage<N, U3, U2>,

fn as_ref(&self) -> &[[N; 3]; 2]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where     S: ContiguousStorageMut<N, U3, U2>,

fn as_mut(&mut self) -> &mut [[N; 3]; 2]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where     S: ContiguousStorage<N, U3, U3>,

fn into(self) -> [[N; 3]; 3]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where     S: ContiguousStorage<N, U3, U3>,

fn as_ref(&self) -> &[[N; 3]; 3]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where     S: ContiguousStorageMut<N, U3, U3>,

fn as_mut(&mut self) -> &mut [[N; 3]; 3]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where     S: ContiguousStorage<N, U3, U4>,

fn into(self) -> [[N; 3]; 4]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where     S: ContiguousStorage<N, U3, U4>,

fn as_ref(&self) -> &[[N; 3]; 4]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where     S: ContiguousStorageMut<N, U3, U4>,

fn as_mut(&mut self) -> &mut [[N; 3]; 4]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where     S: ContiguousStorage<N, U3, U5>,

fn into(self) -> [[N; 3]; 5]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where     S: ContiguousStorage<N, U3, U5>,

fn as_ref(&self) -> &[[N; 3]; 5]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where     S: ContiguousStorageMut<N, U3, U5>,

fn as_mut(&mut self) -> &mut [[N; 3]; 5]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where     S: ContiguousStorage<N, U3, U6>,

fn into(self) -> [[N; 3]; 6]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where     S: ContiguousStorage<N, U3, U6>,

fn as_ref(&self) -> &[[N; 3]; 6]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where     S: ContiguousStorageMut<N, U3, U6>,

fn as_mut(&mut self) -> &mut [[N; 3]; 6]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where     S: ContiguousStorage<N, U4, U2>,

fn into(self) -> [[N; 4]; 2]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where     S: ContiguousStorage<N, U4, U2>,

fn as_ref(&self) -> &[[N; 4]; 2]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where     S: ContiguousStorageMut<N, U4, U2>,

fn as_mut(&mut self) -> &mut [[N; 4]; 2]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where     S: ContiguousStorage<N, U4, U3>,

fn into(self) -> [[N; 4]; 3]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where     S: ContiguousStorage<N, U4, U3>,

fn as_ref(&self) -> &[[N; 4]; 3]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where     S: ContiguousStorageMut<N, U4, U3>,

fn as_mut(&mut self) -> &mut [[N; 4]; 3]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where     S: ContiguousStorage<N, U4, U4>,

fn into(self) -> [[N; 4]; 4]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where     S: ContiguousStorage<N, U4, U4>,

fn as_ref(&self) -> &[[N; 4]; 4]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where     S: ContiguousStorageMut<N, U4, U4>,

fn as_mut(&mut self) -> &mut [[N; 4]; 4]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where     S: ContiguousStorage<N, U4, U5>,

fn into(self) -> [[N; 4]; 5]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where     S: ContiguousStorage<N, U4, U5>,

fn as_ref(&self) -> &[[N; 4]; 5]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where     S: ContiguousStorageMut<N, U4, U5>,

fn as_mut(&mut self) -> &mut [[N; 4]; 5]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where     S: ContiguousStorage<N, U4, U6>,

fn into(self) -> [[N; 4]; 6]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where     S: ContiguousStorage<N, U4, U6>,

fn as_ref(&self) -> &[[N; 4]; 6]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where     S: ContiguousStorageMut<N, U4, U6>,

fn as_mut(&mut self) -> &mut [[N; 4]; 6]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where     S: ContiguousStorage<N, U5, U2>,

fn into(self) -> [[N; 5]; 2]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where     S: ContiguousStorage<N, U5, U2>,

fn as_ref(&self) -> &[[N; 5]; 2]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where     S: ContiguousStorageMut<N, U5, U2>,

fn as_mut(&mut self) -> &mut [[N; 5]; 2]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where     S: ContiguousStorage<N, U5, U3>,

fn into(self) -> [[N; 5]; 3]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where     S: ContiguousStorage<N, U5, U3>,

fn as_ref(&self) -> &[[N; 5]; 3]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where     S: ContiguousStorageMut<N, U5, U3>,

fn as_mut(&mut self) -> &mut [[N; 5]; 3]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where     S: ContiguousStorage<N, U5, U4>,

fn into(self) -> [[N; 5]; 4]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where     S: ContiguousStorage<N, U5, U4>,

fn as_ref(&self) -> &[[N; 5]; 4]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where     S: ContiguousStorageMut<N, U5, U4>,

fn as_mut(&mut self) -> &mut [[N; 5]; 4]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where     S: ContiguousStorage<N, U5, U5>,

fn into(self) -> [[N; 5]; 5]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where     S: ContiguousStorage<N, U5, U5>,

fn as_ref(&self) -> &[[N; 5]; 5]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where     S: ContiguousStorageMut<N, U5, U5>,

fn as_mut(&mut self) -> &mut [[N; 5]; 5]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where     S: ContiguousStorage<N, U5, U6>,

fn into(self) -> [[N; 5]; 6]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where     S: ContiguousStorage<N, U5, U6>,

fn as_ref(&self) -> &[[N; 5]; 6]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where     S: ContiguousStorageMut<N, U5, U6>,

fn as_mut(&mut self) -> &mut [[N; 5]; 6]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where     S: ContiguousStorage<N, U6, U2>,

fn into(self) -> [[N; 6]; 2]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where     S: ContiguousStorage<N, U6, U2>,

fn as_ref(&self) -> &[[N; 6]; 2]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where     S: ContiguousStorageMut<N, U6, U2>,

fn as_mut(&mut self) -> &mut [[N; 6]; 2]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where     S: ContiguousStorage<N, U6, U3>,

fn into(self) -> [[N; 6]; 3]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where     S: ContiguousStorage<N, U6, U3>,

fn as_ref(&self) -> &[[N; 6]; 3]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where     S: ContiguousStorageMut<N, U6, U3>,

fn as_mut(&mut self) -> &mut [[N; 6]; 3]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where     S: ContiguousStorage<N, U6, U4>,

fn into(self) -> [[N; 6]; 4]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where     S: ContiguousStorage<N, U6, U4>,

fn as_ref(&self) -> &[[N; 6]; 4]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where     S: ContiguousStorageMut<N, U6, U4>,

fn as_mut(&mut self) -> &mut [[N; 6]; 4]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where     S: ContiguousStorage<N, U6, U5>,

fn into(self) -> [[N; 6]; 5]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where     S: ContiguousStorage<N, U6, U5>,

fn as_ref(&self) -> &[[N; 6]; 5]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where     S: ContiguousStorageMut<N, U6, U5>,

fn as_mut(&mut self) -> &mut [[N; 6]; 5]

Performs the conversion.

impl<N: Scalar, S> Into<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where     S: ContiguousStorage<N, U6, U6>,

fn into(self) -> [[N; 6]; 6]

Performs the conversion.

impl<N: Scalar, S> AsRef<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where     S: ContiguousStorage<N, U6, U6>,

fn as_ref(&self) -> &[[N; 6]; 6]

Performs the conversion.

impl<N: Scalar, S> AsMut<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where     S: ContiguousStorageMut<N, U6, U6>,

fn as_mut(&mut self) -> &mut [[N; 6]; 6]

Performs the conversion.

impl<N: Hash + Scalar, R: Hash + Dim, C: Hash + Dim, S: Hash> Hash for Matrix<N, R, C, S>

fn hash<__HNRCS: Hasher>(&self, state: &mut __HNRCS)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<N: Clone + Scalar, R: Clone + Dim, C: Clone + Dim, S: Clone> Clone for Matrix<N, R, C, S>

fn clone(&self) -> Matrix<N, R, C, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy + Scalar, R: Copy + Dim, C: Copy + Dim, S: Copy> Copy for Matrix<N, R, C, S>

impl<N: Scalar, R: Dim, C: Dim, S: Debug> Debug for Matrix<N, R, C, S>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<N, R: Dim, C: Dim, S> AbsDiffEq for Matrix<N, R, C, S> where     N: Scalar + AbsDiffEq,     S: Storage<N, R, C>,     N::Epsilon: Copy,

type Epsilon = N::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Self, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<N, R: Dim, C: Dim, S> RelativeEq for Matrix<N, R, C, S> where     N: Scalar + RelativeEq,     S: Storage<N, R, C>,     N::Epsilon: Copy,

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(     &self,     other: &Self,     epsilon: Self::Epsilon,     max_relative: Self::Epsilon ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(     &self,     other: &Self,     epsilon: Self::Epsilon,     max_relative: Self::Epsilon ) -> bool

The inverse of ApproxEq::relative_eq.

impl<N, R: Dim, C: Dim, S> UlpsEq for Matrix<N, R, C, S> where     N: Scalar + UlpsEq,     S: Storage<N, R, C>,     N::Epsilon: Copy,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N, R: Dim, C: Dim, S> PartialOrd for Matrix<N, R, C, S> where     N: Scalar + PartialOrd,     S: Storage<N, R, C>,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, right: &Self) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, right: &Self) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, right: &Self) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, right: &Self) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<N, R: Dim, C: Dim, S> Eq for Matrix<N, R, C, S> where     N: Scalar + Eq,     S: Storage<N, R, C>,

impl<N, R: Dim, C: Dim, S> PartialEq for Matrix<N, R, C, S> where     N: Scalar,     S: Storage<N, R, C>,

fn eq(&self, right: &Matrix<N, R, C, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<N, R: Dim, C: Dim, S> Display for Matrix<N, R, C, S> where     N: Scalar + Display,     S: Storage<N, R, C>,     DefaultAllocator: Allocator<usize, R, C>,

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

Formats the value using the given formatter.

impl<N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,     ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(self, right: Point<N, D2>) -> Self::Output

Performs the * operation.

impl<'a, N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,     ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(self, right: Point<N, D2>) -> Self::Output

Performs the * operation.

impl<'b, N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,     ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<N, D2>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,     ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<N, D2>) -> Self::Output

Performs the * operation.

impl<N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<Matrix<N, R2, C2, SB>> for Rotation<N, D1> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,     DefaultAllocator: Allocator<N, D1, C2>,     ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,

type Output = MatrixMN<N, D1, C2>

The resulting type after applying the * operator.

fn mul(self, right: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<'a, N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,     DefaultAllocator: Allocator<N, D1, C2>,     ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,

type Output = MatrixMN<N, D1, C2>

The resulting type after applying the * operator.

fn mul(self, right: Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<'b, N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<&'b Matrix<N, R2, C2, SB>> for Rotation<N, D1> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,     DefaultAllocator: Allocator<N, D1, C2>,     ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,

type Output = MatrixMN<N, D1, C2>

The resulting type after applying the * operator.

fn mul(self, right: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,     DefaultAllocator: Allocator<N, D1, C2>,     ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,

type Output = MatrixMN<N, D1, C2>

The resulting type after applying the * operator.

fn mul(self, right: &'b Matrix<N, R2, C2, SB>) -> Self::Output

Performs the * operation.

impl<N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the * operator.

fn mul(self, right: Rotation<N, D2>) -> Self::Output

Performs the * operation.

impl<'a, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the * operator.

fn mul(self, right: Rotation<N, D2>) -> Self::Output

Performs the * operation.

impl<'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the * operator.

fn mul(self, right: &'b Rotation<N, D2>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the * operator.

fn mul(self, right: &'b Rotation<N, D2>) -> Self::Output

Performs the * operation.

impl<N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the / operator.

fn div(self, right: Rotation<N, D2>) -> Self::Output

Performs the / operation.

impl<'a, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the / operator.

fn div(self, right: Rotation<N, D2>) -> Self::Output

Performs the / operation.

impl<'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the / operator.

fn div(self, right: &'b Rotation<N, D2>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul,     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,     DefaultAllocator: Allocator<N, R1, D2>,     ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,

type Output = MatrixMN<N, R1, D2>

The resulting type after applying the / operator.

fn div(self, right: &'b Rotation<N, D2>) -> Self::Output

Performs the / operation.