Struct nalgebra::core::Matrix [−] [src]

#[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 contants (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, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + ClosedNeg, S: StorageMut<N, R, C>,`
[src]

`fn neg_mut(&mut self)`

Negates self in-place.

`impl<N, R1: Dim, C1: Dim, SA> Matrix<N, R1, C1, SA> where N: Scalar, SA: Storage<N, R1, C1>,`
[src]

`fn tr_mul<R2: Dim, C2: Dim, SB>( &self, right: &Matrix<N, R2, C2, SB> ) -> MatrixTrMul<N, R1, C1, C2, SA> where N: Zero + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA::Alloc: Allocator<N, C1, C2>, ShapeConstraint: AreMultipliable<C1, R1, R2, C2>,`

Equivalent to self.transpose() * right.

`fn kronecker<R2: Dim, C2: Dim, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> OwnedMatrix<N, DimProd<R1, R2>, DimProd<C1, C2>, SA::Alloc> where N: ClosedMul, R1: DimMul<R2>, C1: DimMul<C2>, SB: Storage<N, R2, C2>, SA::Alloc: 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, R: Dim, C: Dim, S> Matrix<N, R, C, S>`
[src]

`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>`
[src]

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

Creates a new matrix with the given data.

`fn into_owned(self) -> OwnedMatrix<N, R, C, S::Alloc>`

Moves this matrix into one that owns its data.

`fn into_owned_sum<R2, C2>(self) -> MatrixSum<N, R, C, R2, C2, S> where R2: Dim, C2: Dim, S::Alloc: SameShapeAllocator<N, R, C, R2, C2, S>, 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.

`fn clone_owned(&self) -> OwnedMatrix<N, R, C, S::Alloc>`

Clones this matrix into one that owns its data.

`fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<N, R, C, R2, C2, S> where R2: Dim, C2: Dim, S::Alloc: SameShapeAllocator<N, R, C, R2, C2, S>, 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.

`fn len(&self) -> usize`

The total number of elements of this matrix.

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

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

`fn nrows(&self) -> usize`

The number of rows of this matrix.

`fn ncols(&self) -> usize`

The number of columns of this matrix.

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

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

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

Iterates through this matrix coordinates.

`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.

`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.

`fn relative_eq<R2, C2, SB>( &self, other: &Matrix<N, R2, C2, SB>, eps: N::Epsilon, max_relative: N::Epsilon ) -> bool where N: ApproxEq, 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 ApproxEq trait for more details.

`impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>`
[src]

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

Mutably iterates through this matrix coordinates.

`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.

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

Swaps two entries without bound-checking.

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

Swaps two entries.

`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.

`fn fill(&mut self, value: N)`

Sets all the entries of this matrix to value.

`impl<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

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

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

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

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

`fn map<F: FnMut(N) -> N>(&self, f: F) -> Matrix<N, R, C, S>`

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

`fn zip_map<F: FnMut(N, N) -> N>( &self, rhs: &Matrix<N, R, C, S>, f: F ) -> Matrix<N, R, C, S>`

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

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: Allocator<N, C, R>,`
[src]

`fn transpose(&self) -> OwnedMatrix<N, C, R, S::Alloc>`

Transposes self.

`impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S>`
[src]

`fn transpose_mut(&mut self)`

Transposes the square matrix self in-place.

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + Ring, S: Storage<N, R, C>,`
[src]

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

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

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

The dot product between the transpose of self and other.

`fn norm_squared(&self) -> N`

The squared L2 norm of this matrix.

`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.

`fn cross<R2, C2, SB>( &self, b: &Matrix<N, R2, C2, SB> ) -> MatrixCross<N, R, C, R2, C2, S> where R2: Dim, C2: Dim, SB: Storage<N, R2, C2>, S::Alloc: SameShapeAllocator<N, R, C, R2, C2, S>, 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, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Real, S: Storage<N, R, C>,`
[src]

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

The smallest angle between two matrices seen as vectors.

`fn norm(&self) -> N`

The L2 norm of this matrix.

`fn normalize(&self) -> OwnedMatrix<N, R, C, S::Alloc>`

Returns a normalized version of this matrix.

`fn try_normalize(&self, min_norm: N) -> Option<OwnedMatrix<N, R, C, S::Alloc>>`

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

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Real, S: StorageMut<N, R, C>,`
[src]

`fn normalize_mut(&mut self) -> N`

Normalizes this matrix in-place and returns its norm.

`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 succeded, returns the old normal of this matrix.

`impl<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`unsafe fn new_uninitialized_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S>`

Creates a new uninitialized matrix. If the matrix has a compile-time dimension, this panics if nrows != R::to_usize() or ncols != C::to_usize().

`fn from_element_generic(nrows: R, ncols: C, elem: N) -> Matrix<N, R, C, S>`

Creates a matrix with all its elements set to elem.

`fn from_iterator_generic(nrows: R, ncols: C, iter: I) -> Matrix<N, R, C, S> where I: IntoIterator<Item = N>,`

Creates a matrix with all its elements filled by an iterator.

`fn from_row_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Matrix<N, R, C, S>`

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

`fn from_column_slice_generic( nrows: R, ncols: C, slice: &[N] ) -> Matrix<N, R, C, S>`

Creates a matrix with its elements filled with the components provided by a slice. The components must have the same layout as the matrix data storage (i.e. row-major or column-major).

`fn from_fn_generic<F>(nrows: R, ncols: C, f: F) -> Matrix<N, R, C, S> where F: FnMut(usize, usize) -> N,`

Creates a matrix filled with the results of a function applied to each of its component coordinates.

`fn identity_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S> where N: Zero + One,`

Creates a new indentity matrix.

If the matrix is not square, the largest square submatrix starting at index (0, 0) is set to the identity matrix. All other entries are set to zero.

`fn from_diagonal_element_generic( nrows: R, ncols: C, elt: N ) -> Matrix<N, R, C, S> where N: Zero + One,`

Creates a new matrix with its diagonal filled with copies of elt.

If the matrix is not square, the largest square submatrix starting at index (0, 0) is set to the identity matrix. All other entries are set to zero.

`fn from_rows<SB>(rows: &[Matrix<N, U1, C, SB>]) -> Matrix<N, R, C, S> where SB: Storage<N, U1, C>,`

Builds a new matrix from its rows.

Panics if not enough rows are provided (for statically-sized matrices), or if all rows do not have the same dimensions.

`fn from_columns<SB>(columns: &[ColumnVector<N, R, SB>]) -> Matrix<N, R, C, S> where SB: Storage<N, R, U1>,`

Builds a new matrix from its columns.

Panics if not enough columns are provided (for statically-sized matrices), or if all columns do not have the same dimensions.

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + Rand, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn new_random_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S>`

Creates a matrix filled with random values.

`impl<N: Scalar, R: DimName, C: DimName, S> Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`unsafe fn new_uninitialized() -> Matrix<N, R, C, S>`

Creates a new uninitialized matrix.

`fn from_element(elem: N) -> Matrix<N, R, C, S>`

Creates a matrix with all its elements set to elem.

`fn from_iterator(iter: I) -> Matrix<N, R, C, S> where I: IntoIterator<Item = N>,`

Creates a matrix with all its elements filled by an iterator.

`fn from_row_slice(slice: &[N]) -> Matrix<N, R, C, S>`

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

`fn from_column_slice(slice: &[N]) -> Matrix<N, R, C, S>`

Creates a matrix with its elements filled with the components provided by a slice in column-major order.

`fn from_fn<F>(f: F) -> Matrix<N, R, C, S> where F: FnMut(usize, usize) -> N,`

Creates a matrix filled with the results of a function applied to each of its component coordinates.

`fn identity() -> Matrix<N, R, C, S> where N: Zero + One,`

Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.

`fn from_diagonal_element(elt: N) -> Matrix<N, R, C, S> where N: Zero + One,`

Creates a matrix filled with its diagonal filled with elt and all other components set to zero.

`impl<N: Scalar + Rand, R: DimName, C: DimName, S> Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn new_random() -> Matrix<N, R, C, S>`

Creates a matrix filled with random values.

`impl<N: Scalar, R: DimName, S> Matrix<N, R, Dynamic, S> where S: OwnedStorage<N, R, Dynamic>, S::Alloc: OwnedAllocator<N, R, Dynamic, S>,`
[src]

`unsafe fn new_uninitialized(ncols: usize) -> Matrix<N, R, Dynamic, S>`

Creates a new uninitialized matrix.

`fn from_element(ncols: usize, elem: N) -> Matrix<N, R, Dynamic, S>`

Creates a matrix with all its elements set to elem.

`fn from_iterator(ncols: usize, iter: I) -> Matrix<N, R, Dynamic, S> where I: IntoIterator<Item = N>,`

Creates a matrix with all its elements filled by an iterator.

`fn from_row_slice(ncols: usize, slice: &[N]) -> Matrix<N, R, Dynamic, S>`

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

`fn from_column_slice(ncols: usize, slice: &[N]) -> Matrix<N, R, Dynamic, S>`

Creates a matrix with its elements filled with the components provided by a slice in column-major order.

`fn from_fn<F>(ncols: usize, f: F) -> Matrix<N, R, Dynamic, S> where F: FnMut(usize, usize) -> N,`

Creates a matrix filled with the results of a function applied to each of its component coordinates.

`fn identity(ncols: usize) -> Matrix<N, R, Dynamic, S> where N: Zero + One,`

Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.

`fn from_diagonal_element(ncols: usize, elt: N) -> Matrix<N, R, Dynamic, S> where N: Zero + One,`

Creates a matrix filled with its diagonal filled with elt and all other components set to zero.

`impl<N: Scalar + Rand, R: DimName, S> Matrix<N, R, Dynamic, S> where S: OwnedStorage<N, R, Dynamic>, S::Alloc: OwnedAllocator<N, R, Dynamic, S>,`
[src]

`fn new_random(ncols: usize) -> Matrix<N, R, Dynamic, S>`

Creates a matrix filled with random values.

`impl<N: Scalar, C: DimName, S> Matrix<N, Dynamic, C, S> where S: OwnedStorage<N, Dynamic, C>, S::Alloc: OwnedAllocator<N, Dynamic, C, S>,`
[src]

`unsafe fn new_uninitialized(nrows: usize) -> Matrix<N, Dynamic, C, S>`

Creates a new uninitialized matrix.

`fn from_element(nrows: usize, elem: N) -> Matrix<N, Dynamic, C, S>`

Creates a matrix with all its elements set to elem.

`fn from_iterator(nrows: usize, iter: I) -> Matrix<N, Dynamic, C, S> where I: IntoIterator<Item = N>,`

Creates a matrix with all its elements filled by an iterator.

`fn from_row_slice(nrows: usize, slice: &[N]) -> Matrix<N, Dynamic, C, S>`

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

`fn from_column_slice(nrows: usize, slice: &[N]) -> Matrix<N, Dynamic, C, S>`

Creates a matrix with its elements filled with the components provided by a slice in column-major order.

`fn from_fn<F>(nrows: usize, f: F) -> Matrix<N, Dynamic, C, S> where F: FnMut(usize, usize) -> N,`

Creates a matrix filled with the results of a function applied to each of its component coordinates.

`fn identity(nrows: usize) -> Matrix<N, Dynamic, C, S> where N: Zero + One,`

Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.

`fn from_diagonal_element(nrows: usize, elt: N) -> Matrix<N, Dynamic, C, S> where N: Zero + One,`

Creates a matrix filled with its diagonal filled with elt and all other components set to zero.

`impl<N: Scalar + Rand, C: DimName, S> Matrix<N, Dynamic, C, S> where S: OwnedStorage<N, Dynamic, C>, S::Alloc: OwnedAllocator<N, Dynamic, C, S>,`
[src]

`fn new_random(nrows: usize) -> Matrix<N, Dynamic, C, S>`

Creates a matrix filled with random values.

`impl<N: Scalar, S> Matrix<N, Dynamic, Dynamic, S> where S: OwnedStorage<N, Dynamic, Dynamic>, S::Alloc: OwnedAllocator<N, Dynamic, Dynamic, S>,`
[src]

`unsafe fn new_uninitialized( nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, S>`

Creates a new uninitialized matrix.

`fn from_element( nrows: usize, ncols: usize, elem: N ) -> Matrix<N, Dynamic, Dynamic, S>`

Creates a matrix with all its elements set to elem.

`fn from_iterator( nrows: usize, ncols: usize, iter: I ) -> Matrix<N, Dynamic, Dynamic, S> where I: IntoIterator<Item = N>,`

Creates a matrix with all its elements filled by an iterator.

`fn from_row_slice( nrows: usize, ncols: usize, slice: &[N] ) -> Matrix<N, Dynamic, Dynamic, S>`

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

`fn from_column_slice( nrows: usize, ncols: usize, slice: &[N] ) -> Matrix<N, Dynamic, Dynamic, S>`

Creates a matrix with its elements filled with the components provided by a slice in column-major order.

`fn from_fn<F>( nrows: usize, ncols: usize, f: F ) -> Matrix<N, Dynamic, Dynamic, S> where F: FnMut(usize, usize) -> N,`

Creates a matrix filled with the results of a function applied to each of its component coordinates.

`fn identity(nrows: usize, ncols: usize) -> Matrix<N, Dynamic, Dynamic, S> where N: Zero + One,`

Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.

`fn from_diagonal_element( nrows: usize, ncols: usize, elt: N ) -> Matrix<N, Dynamic, Dynamic, S> where N: Zero + One,`

Creates a matrix filled with its diagonal filled with elt and all other components set to zero.

`impl<N: Scalar + Rand, S> Matrix<N, Dynamic, Dynamic, S> where S: OwnedStorage<N, Dynamic, Dynamic>, S::Alloc: OwnedAllocator<N, Dynamic, Dynamic, S>,`
[src]

`fn new_random(nrows: usize, ncols: usize) -> Matrix<N, Dynamic, Dynamic, S>`

Creates a matrix filled with random values.

`impl<N, S> Matrix<N, U2, U2, S> where N: Scalar, S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

`fn new(m11: N, m12: N, m21: N, m22: N) -> Matrix<N, U2, U2, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U3, U3, S> where N: Scalar, S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N ) -> Matrix<N, U3, U3, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U4, U4, S> where N: Scalar, S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N ) -> Matrix<N, U4, U4, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U5, U5, S> where N: Scalar, S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N, m41: N, m42: N, m43: N, m44: N, m45: N, m51: N, m52: N, m53: N, m54: N, m55: N ) -> Matrix<N, U5, U5, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U6, U6, S> where N: Scalar, S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N, m41: N, m42: N, m43: N, m44: N, m45: N, m46: N, m51: N, m52: N, m53: N, m54: N, m55: N, m56: N, m61: N, m62: N, m63: N, m64: N, m65: N, m66: N ) -> Matrix<N, U6, U6, S>

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U2, U3, S> where N: Scalar, S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

`fn new(m11: N, m12: N, m13: N, m21: N, m22: N, m23: N) -> Matrix<N, U2, U3, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U2, U4, S> where N: Scalar, S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N ) -> Matrix<N, U2, U4, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U2, U5, S> where N: Scalar, S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N ) -> Matrix<N, U2, U5, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U2, U6, S> where N: Scalar, S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N ) -> Matrix<N, U2, U6, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U3, U2, S> where N: Scalar, S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

`fn new(m11: N, m12: N, m21: N, m22: N, m31: N, m32: N) -> Matrix<N, U3, U2, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U3, U4, S> where N: Scalar, S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N ) -> Matrix<N, U3, U4, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U3, U5, S> where N: Scalar, S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N ) -> Matrix<N, U3, U5, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U3, U6, S> where N: Scalar, S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N ) -> Matrix<N, U3, U6, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U4, U2, S> where N: Scalar, S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

`fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N ) -> Matrix<N, U4, U2, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U4, U3, S> where N: Scalar, S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N ) -> Matrix<N, U4, U3, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U4, U5, S> where N: Scalar, S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N, m41: N, m42: N, m43: N, m44: N, m45: N ) -> Matrix<N, U4, U5, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U4, U6, S> where N: Scalar, S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N, m41: N, m42: N, m43: N, m44: N, m45: N, m46: N ) -> Matrix<N, U4, U6, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U5, U2, S> where N: Scalar, S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

`fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N, m51: N, m52: N ) -> Matrix<N, U5, U2, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U5, U3, S> where N: Scalar, S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N, m51: N, m52: N, m53: N ) -> Matrix<N, U5, U3, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U5, U4, S> where N: Scalar, S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N, m51: N, m52: N, m53: N, m54: N ) -> Matrix<N, U5, U4, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U5, U6, S> where N: Scalar, S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N, m41: N, m42: N, m43: N, m44: N, m45: N, m46: N, m51: N, m52: N, m53: N, m54: N, m55: N, m56: N ) -> Matrix<N, U5, U6, S>

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U6, U2, S> where N: Scalar, S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

`fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N, m51: N, m52: N, m61: N, m62: N ) -> Matrix<N, U6, U2, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U6, U3, S> where N: Scalar, S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N, m51: N, m52: N, m53: N, m61: N, m62: N, m63: N ) -> Matrix<N, U6, U3, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U6, U4, S> where N: Scalar, S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

`fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N, m51: N, m52: N, m53: N, m54: N, m61: N, m62: N, m63: N, m64: N ) -> Matrix<N, U6, U4, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U6, U5, S> where N: Scalar, S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N, m41: N, m42: N, m43: N, m44: N, m45: N, m51: N, m52: N, m53: N, m54: N, m55: N, m61: N, m62: N, m63: N, m64: N, m65: N ) -> Matrix<N, U6, U5, S>

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U1, U1, S> where N: Scalar, S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

`fn new(x: N) -> Matrix<N, U1, U1, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U1, U2, S> where N: Scalar, S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

`fn new(x: N, y: N) -> Matrix<N, U1, U2, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U1, U3, S> where N: Scalar, S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

`fn new(x: N, y: N, z: N) -> Matrix<N, U1, U3, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U1, U4, S> where N: Scalar, S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

`fn new(x: N, y: N, z: N, w: N) -> Matrix<N, U1, U4, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U1, U5, S> where N: Scalar, S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

`fn new(x: N, y: N, z: N, w: N, a: N) -> Matrix<N, U1, U5, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U1, U6, S> where N: Scalar, S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

`fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Matrix<N, U1, U6, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U2, U1, S> where N: Scalar, S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

`fn new(x: N, y: N) -> Matrix<N, U2, U1, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U3, U1, S> where N: Scalar, S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

`fn new(x: N, y: N, z: N) -> Matrix<N, U3, U1, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U4, U1, S> where N: Scalar, S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

`fn new(x: N, y: N, z: N, w: N) -> Matrix<N, U4, U1, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U5, U1, S> where N: Scalar, S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

`fn new(x: N, y: N, z: N, w: N, a: N) -> Matrix<N, U5, U1, S>`

Initializes this matrix from its components.

`impl<N, S> Matrix<N, U6, U1, S> where N: Scalar, S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

`fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Matrix<N, U6, U1, S>`

Initializes this matrix from its components.

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>`
[src]

`fn is_square(&self) -> bool`

Indicates if this is a square matrix.

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where N: ApproxEq, N::Epsilon: Copy,`
[src]

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

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.

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>`
[src]

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

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

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

Extracts from this matrix a set of consecutive rows.

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

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

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

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

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

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

`fn rows_generic<RSlice, RStep>( &self, row_start: usize, nrows: RSlice, step: RStep ) -> MatrixSlice<N, RSlice, C, DimProd<RStep, S::RStride>, S::CStride, S::Alloc> where RSlice: Dim, RStep: DimMul<S::RStride>,`

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

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

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

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

Extracts from this matrix a set of consecutive columns.

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

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

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

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

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

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

`fn columns_generic<CSlice, CStep>( &self, first_col: usize, ncols: CSlice, step: CStep ) -> MatrixSlice<N, R, CSlice, S::RStride, DimProd<CStep, S::CStride>, S::Alloc> where CSlice: Dim, CStep: DimMul<S::CStride>,`

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

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

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

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

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.

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

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

`fn fixed_slice_with_steps<RSlice, CSlice>( &self, start: (usize, usize), steps: (usize, usize) ) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic, S::Alloc> 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.

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

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

`fn generic_slice_with_steps<RSlice, CSlice, RStep, CStep>( &self, start: (usize, usize), shape: (RSlice, CSlice), steps: (RStep, CStep) ) -> MatrixSlice<N, RSlice, CSlice, DimProd<RStep, S::RStride>, DimProd<CStep, S::CStride>, S::Alloc> where RSlice: Dim, CSlice: Dim, RStep: DimMul<S::RStride>, CStep: DimMul<S::CStride>,`

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

`impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>`
[src]

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

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

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

Extracts from this matrix a set of consecutive rows.

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

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

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

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

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

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

`fn rows_generic_mut<RSlice, RStep>( &mut self, row_start: usize, nrows: RSlice, step: RStep ) -> MatrixSliceMut<N, RSlice, C, DimProd<RStep, S::RStride>, S::CStride, S::Alloc> where RSlice: Dim, RStep: DimMul<S::RStride>,`

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

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

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

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

Extracts from this matrix a set of consecutive columns.

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

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

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

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

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

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

`fn columns_generic_mut<CSlice, CStep>( &mut self, first_col: usize, ncols: CSlice, step: CStep ) -> MatrixSliceMut<N, R, CSlice, S::RStride, DimProd<CStep, S::CStride>, S::Alloc> where CSlice: Dim, CStep: DimMul<S::CStride>,`

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

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

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

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

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.

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

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

`fn fixed_slice_with_steps_mut<RSlice, CSlice>( &mut self, start: (usize, usize), steps: (usize, usize) ) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic, S::Alloc> 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.

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

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

`fn generic_slice_with_steps_mut<RSlice, CSlice, RStep, CStep>( &mut self, start: (usize, usize), shape: (RSlice, CSlice), steps: (RStep, CStep) ) -> MatrixSliceMut<N, RSlice, CSlice, DimProd<RStep, S::RStride>, DimProd<CStep, S::CStride>, S::Alloc> where RSlice: Dim, CSlice: Dim, RStep: DimMul<S::RStride>, CStep: DimMul<S::CStride>,`

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

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>`
[src]

`fn abs(&self) -> OwnedMatrix<N, R, C, S::Alloc> where N: Signed,`

Computes the componentwise absolute value.

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>`
[src]

`fn component_mul<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> MatrixSum<N, R, C, R2, C2, S> where N: ClosedMul, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>, S::Alloc: SameShapeAllocator<N, R, C, R2, C2, S>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,`

Componentwise matrix multiplication.

`impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>`
[src]

`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<R, R2> + SameNumberOfColumns<C, C2>,`

Mutable, componentwise matrix multiplication.

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>`
[src]

`fn component_div<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> MatrixSum<N, R, C, R2, C2, S> where N: ClosedDiv, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>, S::Alloc: SameShapeAllocator<N, R, C, R2, C2, S>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,`

Componentwise matrix division.

`impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>`
[src]

`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<R, R2> + SameNumberOfColumns<C, C2>,`

Mutable, componentwise matrix division.

Trait Implementations

`impl<N: Scalar, S> Deref for Matrix<N, U1, U1, S> where S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

`type Target = X<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U1, U1, S> where S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U2, U1, S> where S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

`type Target = XY<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U2, U1, S> where S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U3, U1, S> where S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

`type Target = XYZ<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U3, U1, S> where S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U4, U1, S> where S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

`type Target = XYZW<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U4, U1, S> where S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U5, U1, S> where S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

`type Target = XYZWA<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U5, U1, S> where S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U6, U1, S> where S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

`type Target = XYZWAB<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U6, U1, S> where S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U1, U2, S> where S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

`type Target = XY<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U1, U2, S> where S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U1, U3, S> where S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

`type Target = XYZ<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U1, U3, S> where S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U1, U4, S> where S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

`type Target = XYZW<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U1, U4, S> where S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U1, U5, S> where S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

`type Target = XYZWA<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U1, U5, S> where S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U1, U6, S> where S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

`type Target = XYZWAB<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U1, U6, S> where S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U2, U2, S> where S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

`type Target = M2x2<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U2, U2, S> where S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U2, U3, S> where S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

`type Target = M2x3<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U2, U3, S> where S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U2, U4, S> where S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

`type Target = M2x4<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U2, U4, S> where S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U2, U5, S> where S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

`type Target = M2x5<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U2, U5, S> where S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U2, U6, S> where S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

`type Target = M2x6<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U2, U6, S> where S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U3, U2, S> where S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

`type Target = M3x2<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U3, U2, S> where S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U3, U3, S> where S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

`type Target = M3x3<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U3, U3, S> where S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U3, U4, S> where S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

`type Target = M3x4<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U3, U4, S> where S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U3, U5, S> where S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

`type Target = M3x5<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U3, U5, S> where S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U3, U6, S> where S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

`type Target = M3x6<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U3, U6, S> where S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U4, U2, S> where S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

`type Target = M4x2<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U4, U2, S> where S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U4, U3, S> where S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

`type Target = M4x3<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U4, U3, S> where S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U4, U4, S> where S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

`type Target = M4x4<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U4, U4, S> where S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U4, U5, S> where S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

`type Target = M4x5<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U4, U5, S> where S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U4, U6, S> where S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

`type Target = M4x6<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U4, U6, S> where S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U5, U2, S> where S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

`type Target = M5x2<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U5, U2, S> where S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U5, U3, S> where S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

`type Target = M5x3<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U5, U3, S> where S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U5, U4, S> where S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

`type Target = M5x4<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U5, U4, S> where S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U5, U5, S> where S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

`type Target = M5x5<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U5, U5, S> where S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U5, U6, S> where S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

`type Target = M5x6<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U5, U6, S> where S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U6, U2, S> where S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

`type Target = M6x2<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U6, U2, S> where S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U6, U3, S> where S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

`type Target = M6x3<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U6, U3, S> where S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U6, U4, S> where S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

`type Target = M6x4<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U6, U4, S> where S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U6, U5, S> where S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

`type Target = M6x5<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U6, U5, S> where S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

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

The method called to mutably dereference a value

`impl<N: Scalar, S> Deref for Matrix<N, U6, U6, S> where S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

`type Target = M6x6<N>`

The resulting type after dereferencing

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

The method called to dereference a value

`impl<N: Scalar, S> DerefMut for Matrix<N, U6, U6, S> where S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

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

The method called to mutably dereference a value

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

`type Output = N`

The returned type after indexing

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

The method for 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>,`
[src]

`type Output = N`

The returned type after indexing

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

The method for 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>`
[src]

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

The method for 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>,`
[src]

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

The method for 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>,`
[src]

`type Output = OwnedMatrix<N, R, C, S::Alloc>`

The resulting type after applying the - operator

`fn neg(self) -> Self::Output`

The method for the unary - operator

`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>,`
[src]

`type Output = OwnedMatrix<N, R, C, S::Alloc>`

The resulting type after applying the - operator

`fn neg(self) -> Self::Output`

The method for the unary - operator

`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>, SA::Alloc: SameShapeAllocator<N, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,`
[src]

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

The resulting type after applying the + operator

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

The method for the + operator

`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>, SB::Alloc: SameShapeAllocator<N, R2, C2, R1, C1, SB>, ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,`
[src]

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

The resulting type after applying the + operator

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

The method for the + operator

`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>, SA::Alloc: SameShapeAllocator<N, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,`
[src]

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

The resulting type after applying the + operator

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

The method for the + operator

`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>, SA::Alloc: SameShapeAllocator<N, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,`
[src]

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

The resulting type after applying the + operator

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

The method for the + operator

`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>,`
[src]

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

The method for the += operator

`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>,`
[src]

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

The method for the += operator

`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>, SA::Alloc: SameShapeAllocator<N, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,`
[src]

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

The resulting type after applying the - operator

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

The method for the - operator

`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>, SB::Alloc: SameShapeAllocator<N, R2, C2, R1, C1, SB>, ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,`
[src]

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

The resulting type after applying the - operator

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

The method for the - operator

`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>, SA::Alloc: SameShapeAllocator<N, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,`
[src]

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

The resulting type after applying the - operator

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

The method for the - operator

`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>, SA::Alloc: SameShapeAllocator<N, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,`
[src]

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

The resulting type after applying the - operator

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

The method for the - operator

`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>,`
[src]

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

The method for the -= operator

`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>,`
[src]

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

The method for the -= operator

`impl<N, R: Dim, C: Dim, S> Mul<N> for Matrix<N, R, C, S> where N: Scalar + ClosedMul, S: Storage<N, R, C>,`
[src]

`type Output = OwnedMatrix<N, R, C, S::Alloc>`

The resulting type after applying the * operator

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

The method for the * operator

`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>,`
[src]

`type Output = OwnedMatrix<N, R, C, S::Alloc>`

The resulting type after applying the * operator

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

The method for the * operator

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

`fn mul_assign(&mut self, right: N)`

The method for the *= operator

`impl<N, R: Dim, C: Dim, S> Div<N> for Matrix<N, R, C, S> where N: Scalar + ClosedDiv, S: Storage<N, R, C>,`
[src]

`type Output = OwnedMatrix<N, R, C, S::Alloc>`

The resulting type after applying the / operator

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

The method for the / operator

`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>,`
[src]

`type Output = OwnedMatrix<N, R, C, S::Alloc>`

The resulting type after applying the / operator

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

The method for the / operator

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

`fn div_assign(&mut self, right: N)`

The method for the /= operator

`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 + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA: Storage<N, R1, C1>, SA::Alloc: Allocator<N, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,`
[src]

`type Output = MatrixMul<N, R1, C1, C2, SA>`

The resulting type after applying the * operator

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

The method for the * operator

`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 + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA: Storage<N, R1, C1>, SA::Alloc: Allocator<N, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,`
[src]

`type Output = MatrixMul<N, R1, C1, C2, SA>`

The resulting type after applying the * operator

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

The method for the * operator

`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 + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA: Storage<N, R1, C1>, SA::Alloc: Allocator<N, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,`
[src]

`type Output = MatrixMul<N, R1, C1, C2, SA>`

The resulting type after applying the * operator

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

The method for the * operator

`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 + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA: Storage<N, R1, C1>, SA::Alloc: Allocator<N, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,`
[src]

`type Output = MatrixMul<N, R1, C1, C2, SA>`

The resulting type after applying the * operator

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

The method for the * operator

`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 + ClosedAdd + ClosedMul, SB: Storage<N, R2, C1>, SA: OwnedStorage<N, R1, C1>, ShapeConstraint: AreMultipliable<R1, C1, R2, C1>, SA::Alloc: OwnedAllocator<N, R1, C1, SA>,`
[src]

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

The method for the *= operator

`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 + ClosedAdd + ClosedMul, SB: Storage<N, R2, C1>, SA: OwnedStorage<N, R1, C1>, ShapeConstraint: AreMultipliable<R1, C1, R2, C1>, SA::Alloc: OwnedAllocator<N, R1, C1, SA>,`
[src]

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

The method for the *= operator

`impl<N: Hash + Scalar, R: Hash + Dim, C: Hash + Dim, S: Hash> Hash for Matrix<N, R, C, S>`
[src]

`fn hash<HNRCS: Hasher>(&self, arg_0: &mut __HNRCS)`

Feeds this value into the given [Hasher]. Read more

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,`
1.3.0

Feeds a slice of this type into the given [Hasher]. Read more

`impl<N: Debug + Scalar, R: Debug + Dim, C: Debug + Dim, S: Debug> Debug for Matrix<N, R, C, S>`
[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`

Formats the value using the given formatter.

`impl<N: Clone + Scalar, R: Clone + Dim, C: Clone + Dim, S: Clone> Clone for Matrix<N, R, C, S>`
[src]

`fn clone(&self) -> Matrix<N, R, C, S>`

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl<N: Copy + Scalar, R: Copy + Dim, C: Copy + Dim, S: Copy> Copy for Matrix<N, R, C, S>`
[src]

`impl<N, R: Dim, C: Dim, S> ApproxEq for Matrix<N, R, C, S> where N: Scalar + ApproxEq, S: Storage<N, R, C>, N::Epsilon: Copy,`
[src]

`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. Read more

`fn default_max_relative() -> Self::Epsilon`

The default relative tolerance for testing values that are far-apart. Read more

`fn default_max_ulps() -> u32`

The default ULPs to tolerate when testing values that are far-apart. Read more

`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 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 relative_ne( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool`

The inverse of ApproxEq::relative_eq.

`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>,`
[src]

`fn partial_cmp(&self, other: &Self) -> Option<Ordering>`

This method returns an ordering between self and other values if one exists. Read more

`fn lt(&self, right: &Self) -> bool`

This method tests less than (for self and other) and is used by the < operator. Read more

`fn le(&self, right: &Self) -> bool`

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

`fn gt(&self, right: &Self) -> bool`

This method tests greater than (for self and other) and is used by the > operator. Read more

`fn ge(&self, right: &Self) -> bool`

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

`impl<N, R: Dim, C: Dim, S> Eq for Matrix<N, R, C, S> where N: Scalar + Eq, S: Storage<N, R, C>,`
[src]

`impl<N, R: Dim, C: Dim, S> PartialEq for Matrix<N, R, C, S> where N: Scalar, S: Storage<N, R, C>,`
[src]

`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 ==. Read more

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

This method tests for !=.

`impl<N, R: Dim, C: Dim, S> Display for Matrix<N, R, C, S> where N: Real + Display, S: Storage<N, R, C>, S::Alloc: Allocator<usize, R, C>,`
[src]

`fn fmt(&self, f: &mut Formatter) -> Result`

Formats the value using the given formatter. Read more

`impl<N, R: DimName, C: DimName, S> Zero for Matrix<N, R, C, S> where N: Scalar + Zero + ClosedAdd, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn zero() -> Self`

Returns the additive identity element of Self, 0. Read more

`fn is_zero(&self) -> bool`

Returns true if self is equal to the additive identity.

`impl<N, D: DimName, S> One for Matrix<N, D, D, S> where N: Scalar + Zero + One + ClosedMul + ClosedAdd, S: OwnedStorage<N, D, D>, S::Alloc: OwnedAllocator<N, D, D, S>,`
[src]

`fn one() -> Self`

Returns the multiplicative identity element of Self, 1. Read more

`impl<N, R: DimName, C: DimName, S> Bounded for Matrix<N, R, C, S> where N: Scalar + Bounded, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn max_value() -> Self`

returns the largest finite number this type can represent

`fn min_value() -> Self`

returns the smallest finite number this type can represent

`impl<N: Scalar + Rand, R: Dim, C: Dim, S> Rand for Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn rand<G: Rng>(rng: &mut G) -> Self`

Generates a random instance of this type using the specified source of randomness. Read more

`impl<N, R: DimName, C: DimName, S> Identity<Additive> for Matrix<N, R, C, S> where N: Scalar + Zero, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn identity() -> Self`

The identity element.

`impl<N, R: DimName, C: DimName, S> AbstractMagma<Additive> for Matrix<N, R, C, S> where N: Scalar + ClosedAdd, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn operate(&self, other: &Self) -> Self`

Performs an operation.

`fn op(&self, O, lhs: &Self) -> Self`

Performs specific operation.

`impl<N, R: DimName, C: DimName, S> Inverse<Additive> for Matrix<N, R, C, S> where N: Scalar + ClosedNeg, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn inverse(&self) -> Matrix<N, R, C, S>`

Returns the inverse of self, relative to the operator O.

`fn inverse_mut(&mut self)`

In-place inversin of self.

`impl<N, R: DimName, C: DimName, S> AbstractSemigroup<Additive> for Matrix<N, R, C, S> where N: Scalar + AbstractSemigroup<Additive> + ClosedAdd, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where Self: ApproxEq,`

Returns true if associativity holds for the given arguments. Approximate equality is used for verifications. Read more

`fn prop_is_associative(args: (Self, Self, Self)) -> bool where Self: Eq,`

Returns true if associativity holds for the given arguments.

`impl<N, R: DimName, C: DimName, S> AbstractMonoid<Additive> for Matrix<N, R, C, S> where N: Scalar + AbstractMonoid<Additive> + Zero + ClosedAdd, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn prop_operating_identity_element_is_noop_approx(a: Self) -> bool where Self: ApproxEq,`

Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications. Read more

`fn prop_operating_identity_element_is_noop(a: Self) -> bool where Self: Eq,`

Checks whether operating with the identity element is a no-op for the given argument. Read more

`impl<N, R: DimName, C: DimName, S> AbstractQuasigroup<Additive> for Matrix<N, R, C, S> where N: Scalar + AbstractQuasigroup<Additive> + ClosedAdd + ClosedNeg, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where Self: ApproxEq,`

Returns true if latin squareness holds for the given arguments. Approximate equality is used for verifications. Read more

`fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where Self: Eq,`

Returns true if latin squareness holds for the given arguments.

`impl<N, R: DimName, C: DimName, S> AbstractLoop<Additive> for Matrix<N, R, C, S> where N: Scalar + AbstractLoop<Additive> + Zero + ClosedAdd + ClosedNeg, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`impl<N, R: DimName, C: DimName, S> AbstractGroup<Additive> for Matrix<N, R, C, S> where N: Scalar + AbstractGroup<Additive> + Zero + ClosedAdd + ClosedNeg, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`impl<N, R: DimName, C: DimName, S> AbstractGroupAbelian<Additive> for Matrix<N, R, C, S> where N: Scalar + AbstractGroupAbelian<Additive> + Zero + ClosedAdd + ClosedNeg, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn prop_is_commutative_approx(args: (Self, Self)) -> bool where Self: ApproxEq,`

Returns true if the operator is commutative for the given argument tuple. Approximate equality is used for verifications. Read more

`fn prop_is_commutative(args: (Self, Self)) -> bool where Self: Eq,`

Returns true if the operator is commutative for the given argument tuple.

`impl<N, R: DimName, C: DimName, S> AbstractModule for Matrix<N, R, C, S> where N: Scalar + RingCommutative, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`type AbstractRing = N`

The underlying scalar field.

`fn multiply_by(&self, n: N) -> Self`

Multiplies an element of the ring with an element of the module.

`impl<N, R: DimName, C: DimName, S> Module for Matrix<N, R, C, S> where N: Scalar + RingCommutative, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`type Ring = N`

The underlying scalar field.

`impl<N, R: DimName, C: DimName, S> VectorSpace for Matrix<N, R, C, S> where N: Scalar + Field, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`type Field = N`

The underlying scalar field.

`impl<N, R: DimName, C: DimName, S> FiniteDimVectorSpace for Matrix<N, R, C, S> where N: Scalar + Field, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn dimension() -> usize`

The vector space dimension.

`fn canonical_basis_element(i: usize) -> Self`

The i-the canonical basis element.

`fn dot(&self, other: &Self) -> N`

The dot product between two vectors.

`unsafe fn component_unchecked(&self, i: usize) -> &N`

Same as &self[i] but without bound-checking.

`unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N`

Same as &mut self[i] but without bound-checking.

`fn canonical_basis<F>(f: F) where F: FnMut(&Self) -> bool,`

Applies the given closule to each element of this vector space's canonical basis. Stops if f returns false. Read more

`impl<N, R: DimName, C: DimName, S> NormedSpace for Matrix<N, R, C, S> where N: Real, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn norm_squared(&self) -> N`

The squared norm of this vector.

`fn norm(&self) -> N`

The norm of this vector.

`fn normalize(&self) -> Self`

Returns a normalized version of this vector.

`fn normalize_mut(&mut self) -> N`

Normalizes this vector in-place and returns its norm.

`fn try_normalize(&self, min_norm: N) -> Option<Self>`

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

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

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

`impl<N, R: DimName, C: DimName, S> InnerSpace for Matrix<N, R, C, S> where N: Real, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`type Real = N`

The result of inner product (same as the field used by this vector space).

`fn angle(&self, other: &Self) -> N`

Measures the angle between two vectors.

`fn inner_product(&self, other: &Self) -> N`

Computes the inner product of self with other.

`impl<N, R: DimName, C: DimName, S> FiniteDimInnerSpace for Matrix<N, R, C, S> where N: Real, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn orthonormalize(vs: &mut [Matrix<N, R, C, S>]) -> usize`

Orthonormalizes the given family of vectors. The largest free family of vectors is moved at the beginning of the array and its size is returned. Vectors at an indices larger or equal to this length can be modified to an arbitrary value. Read more

`fn orthonormal_subspace_basis<F>(vs: &[Self], f: F) where F: FnMut(&Self) -> bool,`

Applies the given closure to each element of the orthonormal basis of the subspace orthogonal to free family of vectors vs. If vs is not a free family, the result is unspecified. Read more

`impl<N, R: Dim, C: Dim, S> MeetSemilattice for Matrix<N, R, C, S> where N: Scalar + MeetSemilattice, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn meet(&self, other: &Self) -> Self`

Returns the meet (aka. infimum) of two values.

`impl<N, R: Dim, C: Dim, S> JoinSemilattice for Matrix<N, R, C, S> where N: Scalar + JoinSemilattice, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn join(&self, other: &Self) -> Self`

Returns the join (aka. supremum) of two values.

`impl<N, R: Dim, C: Dim, S> Lattice for Matrix<N, R, C, S> where N: Scalar + Lattice, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn meet_join(&self, other: &Self) -> (Self, Self)`

Returns the infimum and the supremum simultaneously.

`fn partial_min(&'a self, other: &'a Self) -> Option<&'a Self>`

Return the minimum of self and other if they are comparable.

`fn partial_max(&'a self, other: &'a Self) -> Option<&'a Self>`

Return the maximum of self and other if they are comparable.

`fn partial_sort2(&'a self, other: &'a Self) -> Option<(&'a Self, &'a Self)>`

Sorts two values in increasing order using a partial ordering.

`fn partial_clamp(&'a self, min: &'a Self, max: &'a Self) -> Option<&'a Self>`

Clamp value between min and max. Returns None if value is not comparable to min or max. Read more

impl<N1, N2, R1, C1, R2, C2, SA, SB> SubsetOf<Matrix<N2, R2, C2, SB>> for Matrix<N1, R1, C1, SA> where R1: Dim, C1: Dim, R2: Dim, C2: Dim, N1: Scalar, N2: Scalar + SupersetOf<N1>, SA: OwnedStorage<N1, R1, C1>, SB: OwnedStorage<N2, R2, C2>, SB::Alloc: OwnedAllocator<N2, R2, C2, SB>, SA::Alloc: OwnedAllocator<N1, R1, C1, SA> + SameShapeAllocator<N1, R1, C1, R2, C2, SA>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]

`fn to_superset(&self) -> Matrix<N2, R2, C2, SB>`

The inclusion map: converts self to the equivalent element of its superset.

`fn is_in_subset(m: &Matrix<N2, R2, C2, SB>) -> bool`

Checks if element is actually part of the subset Self (and can be converted to it).

`unsafe fn from_superset_unchecked(m: &Matrix<N2, R2, C2, SB>) -> Self`

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

`fn from_superset(element: &T) -> Option<Self>`

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

`impl<N, R, C, S> From<[N; 1]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U1, Output = Equal>,`
[src]

`fn from(arr: [N; 1]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 1]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U1, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 1]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U1, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 1]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U1, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 2]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U2, Output = Equal>,`
[src]

`fn from(arr: [N; 2]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 2]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U2, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 2]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U2, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 2]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U2, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 3]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U3, Output = Equal>,`
[src]

`fn from(arr: [N; 3]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 3]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U3, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 3]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U3, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 3]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U3, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 4]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U4, Output = Equal>,`
[src]

`fn from(arr: [N; 4]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 4]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U4, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 4]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U4, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 4]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U4, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 5]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U5, Output = Equal>,`
[src]

`fn from(arr: [N; 5]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 5]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U5, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 5]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U5, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 5]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U5, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 6]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U6, Output = Equal>,`
[src]

`fn from(arr: [N; 6]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 6]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U6, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 6]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U6, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 6]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U6, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 7]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U7, Output = Equal>,`
[src]

`fn from(arr: [N; 7]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 7]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U7, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 7]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U7, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 7]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U7, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 8]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U8, Output = Equal>,`
[src]

`fn from(arr: [N; 8]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 8]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U8, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 8]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U8, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 8]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U8, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 9]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U9, Output = Equal>,`
[src]

`fn from(arr: [N; 9]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 9]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U9, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 9]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U9, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 9]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U9, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 10]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U10, Output = Equal>,`
[src]

`fn from(arr: [N; 10]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 10]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U10, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 10]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U10, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 10]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U10, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 11]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U11, Output = Equal>,`
[src]

`fn from(arr: [N; 11]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 11]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U11, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 11]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U11, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 11]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U11, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 12]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U12, Output = Equal>,`
[src]

`fn from(arr: [N; 12]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 12]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U12, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 12]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U12, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 12]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U12, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 13]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U13, Output = Equal>,`
[src]

`fn from(arr: [N; 13]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 13]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U13, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 13]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U13, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 13]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U13, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 14]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U14, Output = Equal>,`
[src]

`fn from(arr: [N; 14]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 14]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U14, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 14]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U14, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 14]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U14, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 15]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U15, Output = Equal>,`
[src]

`fn from(arr: [N; 15]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 15]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U15, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 15]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U15, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 15]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U15, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 16]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U16, Output = Equal>,`
[src]

`fn from(arr: [N; 16]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 16]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U16, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 16]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U16, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 16]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U16, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 17]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U17, Output = Equal>,`
[src]

`fn from(arr: [N; 17]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 17]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U17, Output = Equal>,`
[src]

`fn into(self) -> [N; 17]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 17]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U17, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 17]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U17, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 18]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U18, Output = Equal>,`
[src]

`fn from(arr: [N; 18]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 18]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U18, Output = Equal>,`
[src]

`fn into(self) -> [N; 18]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 18]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U18, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 18]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U18, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 19]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U19, Output = Equal>,`
[src]

`fn from(arr: [N; 19]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 19]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U19, Output = Equal>,`
[src]

`fn into(self) -> [N; 19]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 19]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U19, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 19]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U19, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 20]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U20, Output = Equal>,`
[src]

`fn from(arr: [N; 20]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 20]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U20, Output = Equal>,`
[src]

`fn into(self) -> [N; 20]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 20]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U20, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 20]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U20, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 21]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U21, Output = Equal>,`
[src]

`fn from(arr: [N; 21]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 21]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U21, Output = Equal>,`
[src]

`fn into(self) -> [N; 21]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 21]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U21, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 21]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U21, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 22]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U22, Output = Equal>,`
[src]

`fn from(arr: [N; 22]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 22]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U22, Output = Equal>,`
[src]

`fn into(self) -> [N; 22]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 22]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U22, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 22]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U22, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 23]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U23, Output = Equal>,`
[src]

`fn from(arr: [N; 23]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 23]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U23, Output = Equal>,`
[src]

`fn into(self) -> [N; 23]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 23]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U23, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 23]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U23, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 24]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U24, Output = Equal>,`
[src]

`fn from(arr: [N; 24]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 24]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U24, Output = Equal>,`
[src]

`fn into(self) -> [N; 24]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 24]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U24, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 24]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U24, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 25]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U25, Output = Equal>,`
[src]

`fn from(arr: [N; 25]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 25]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U25, Output = Equal>,`
[src]

`fn into(self) -> [N; 25]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 25]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U25, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 25]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U25, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 26]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U26, Output = Equal>,`
[src]

`fn from(arr: [N; 26]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 26]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U26, Output = Equal>,`
[src]

`fn into(self) -> [N; 26]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 26]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U26, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 26]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U26, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 27]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U27, Output = Equal>,`
[src]

`fn from(arr: [N; 27]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 27]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U27, Output = Equal>,`
[src]

`fn into(self) -> [N; 27]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 27]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U27, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 27]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U27, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 28]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U28, Output = Equal>,`
[src]

`fn from(arr: [N; 28]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 28]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U28, Output = Equal>,`
[src]

`fn into(self) -> [N; 28]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 28]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U28, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 28]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U28, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 29]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U29, Output = Equal>,`
[src]

`fn from(arr: [N; 29]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 29]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U29, Output = Equal>,`
[src]

`fn into(self) -> [N; 29]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 29]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U29, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 29]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U29, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 30]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U30, Output = Equal>,`
[src]

`fn from(arr: [N; 30]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 30]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U30, Output = Equal>,`
[src]

`fn into(self) -> [N; 30]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 30]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U30, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 30]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U30, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 31]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U31, Output = Equal>,`
[src]

`fn from(arr: [N; 31]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 31]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U31, Output = Equal>,`
[src]

`fn into(self) -> [N; 31]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 31]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U31, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 31]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U31, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 32]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U32, Output = Equal>,`
[src]

`fn from(arr: [N; 32]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 32]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U32, Output = Equal>,`
[src]

`fn into(self) -> [N; 32]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 32]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U32, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 32]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U32, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 33]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U33, Output = Equal>,`
[src]

`fn from(arr: [N; 33]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 33]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U33, Output = Equal>,`
[src]

`fn into(self) -> [N; 33]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 33]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U33, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 33]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U33, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 34]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U34, Output = Equal>,`
[src]

`fn from(arr: [N; 34]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 34]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U34, Output = Equal>,`
[src]

`fn into(self) -> [N; 34]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 34]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U34, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 34]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U34, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 35]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U35, Output = Equal>,`
[src]

`fn from(arr: [N; 35]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 35]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U35, Output = Equal>,`
[src]

`fn into(self) -> [N; 35]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 35]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U35, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 35]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U35, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> From<[N; 36]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U36, Output = Equal>,`
[src]

`fn from(arr: [N; 36]) -> Self`

Performs the conversion.

`impl<N, R, C, S> Into<[N; 36]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U36, Output = Equal>,`
[src]

`fn into(self) -> [N; 36]`

Performs the conversion.

`impl<N, R, C, S> AsRef<[N; 36]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U36, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, R, C, S> AsMut<[N; 36]> for Matrix<N, R, C, S> where N: Scalar, R: DimName + DimNameMul<C>, C: DimName, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, <DimNameProd<R, C> as DimName>::Value: Cmp<U36, Output = Equal>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 1]; 1]> for Matrix<N, U1, U1, S> where N: Scalar, S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

`fn from(arr: [[N; 1]; 1]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 1]; 1]> for Matrix<N, U1, U1, S> where N: Scalar, S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 1]; 1]> for Matrix<N, U1, U1, S> where N: Scalar, S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 1]; 1]> for Matrix<N, U1, U1, S> where N: Scalar, S: OwnedStorage<N, U1, U1>, S::Alloc: OwnedAllocator<N, U1, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 1]; 2]> for Matrix<N, U1, U2, S> where N: Scalar, S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

`fn from(arr: [[N; 1]; 2]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 1]; 2]> for Matrix<N, U1, U2, S> where N: Scalar, S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 1]; 2]> for Matrix<N, U1, U2, S> where N: Scalar, S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 1]; 2]> for Matrix<N, U1, U2, S> where N: Scalar, S: OwnedStorage<N, U1, U2>, S::Alloc: OwnedAllocator<N, U1, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 1]; 3]> for Matrix<N, U1, U3, S> where N: Scalar, S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

`fn from(arr: [[N; 1]; 3]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 1]; 3]> for Matrix<N, U1, U3, S> where N: Scalar, S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 1]; 3]> for Matrix<N, U1, U3, S> where N: Scalar, S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 1]; 3]> for Matrix<N, U1, U3, S> where N: Scalar, S: OwnedStorage<N, U1, U3>, S::Alloc: OwnedAllocator<N, U1, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 1]; 4]> for Matrix<N, U1, U4, S> where N: Scalar, S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

`fn from(arr: [[N; 1]; 4]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 1]; 4]> for Matrix<N, U1, U4, S> where N: Scalar, S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 1]; 4]> for Matrix<N, U1, U4, S> where N: Scalar, S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 1]; 4]> for Matrix<N, U1, U4, S> where N: Scalar, S: OwnedStorage<N, U1, U4>, S::Alloc: OwnedAllocator<N, U1, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 1]; 5]> for Matrix<N, U1, U5, S> where N: Scalar, S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

`fn from(arr: [[N; 1]; 5]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 1]; 5]> for Matrix<N, U1, U5, S> where N: Scalar, S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 1]; 5]> for Matrix<N, U1, U5, S> where N: Scalar, S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 1]; 5]> for Matrix<N, U1, U5, S> where N: Scalar, S: OwnedStorage<N, U1, U5>, S::Alloc: OwnedAllocator<N, U1, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 1]; 6]> for Matrix<N, U1, U6, S> where N: Scalar, S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

`fn from(arr: [[N; 1]; 6]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 1]; 6]> for Matrix<N, U1, U6, S> where N: Scalar, S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 1]; 6]> for Matrix<N, U1, U6, S> where N: Scalar, S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 1]; 6]> for Matrix<N, U1, U6, S> where N: Scalar, S: OwnedStorage<N, U1, U6>, S::Alloc: OwnedAllocator<N, U1, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 2]; 1]> for Matrix<N, U2, U1, S> where N: Scalar, S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

`fn from(arr: [[N; 2]; 1]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 2]; 1]> for Matrix<N, U2, U1, S> where N: Scalar, S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 2]; 1]> for Matrix<N, U2, U1, S> where N: Scalar, S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 2]; 1]> for Matrix<N, U2, U1, S> where N: Scalar, S: OwnedStorage<N, U2, U1>, S::Alloc: OwnedAllocator<N, U2, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where N: Scalar, S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

`fn from(arr: [[N; 2]; 2]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where N: Scalar, S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where N: Scalar, S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where N: Scalar, S: OwnedStorage<N, U2, U2>, S::Alloc: OwnedAllocator<N, U2, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where N: Scalar, S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

`fn from(arr: [[N; 2]; 3]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where N: Scalar, S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where N: Scalar, S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where N: Scalar, S: OwnedStorage<N, U2, U3>, S::Alloc: OwnedAllocator<N, U2, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where N: Scalar, S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

`fn from(arr: [[N; 2]; 4]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where N: Scalar, S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where N: Scalar, S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where N: Scalar, S: OwnedStorage<N, U2, U4>, S::Alloc: OwnedAllocator<N, U2, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where N: Scalar, S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

`fn from(arr: [[N; 2]; 5]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where N: Scalar, S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where N: Scalar, S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where N: Scalar, S: OwnedStorage<N, U2, U5>, S::Alloc: OwnedAllocator<N, U2, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where N: Scalar, S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

`fn from(arr: [[N; 2]; 6]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where N: Scalar, S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where N: Scalar, S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where N: Scalar, S: OwnedStorage<N, U2, U6>, S::Alloc: OwnedAllocator<N, U2, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 3]; 1]> for Matrix<N, U3, U1, S> where N: Scalar, S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

`fn from(arr: [[N; 3]; 1]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 3]; 1]> for Matrix<N, U3, U1, S> where N: Scalar, S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 3]; 1]> for Matrix<N, U3, U1, S> where N: Scalar, S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 3]; 1]> for Matrix<N, U3, U1, S> where N: Scalar, S: OwnedStorage<N, U3, U1>, S::Alloc: OwnedAllocator<N, U3, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where N: Scalar, S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

`fn from(arr: [[N; 3]; 2]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where N: Scalar, S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where N: Scalar, S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where N: Scalar, S: OwnedStorage<N, U3, U2>, S::Alloc: OwnedAllocator<N, U3, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where N: Scalar, S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

`fn from(arr: [[N; 3]; 3]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where N: Scalar, S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where N: Scalar, S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where N: Scalar, S: OwnedStorage<N, U3, U3>, S::Alloc: OwnedAllocator<N, U3, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where N: Scalar, S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

`fn from(arr: [[N; 3]; 4]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where N: Scalar, S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where N: Scalar, S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where N: Scalar, S: OwnedStorage<N, U3, U4>, S::Alloc: OwnedAllocator<N, U3, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where N: Scalar, S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

`fn from(arr: [[N; 3]; 5]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where N: Scalar, S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where N: Scalar, S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where N: Scalar, S: OwnedStorage<N, U3, U5>, S::Alloc: OwnedAllocator<N, U3, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where N: Scalar, S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

`fn from(arr: [[N; 3]; 6]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where N: Scalar, S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where N: Scalar, S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where N: Scalar, S: OwnedStorage<N, U3, U6>, S::Alloc: OwnedAllocator<N, U3, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 4]; 1]> for Matrix<N, U4, U1, S> where N: Scalar, S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

`fn from(arr: [[N; 4]; 1]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 4]; 1]> for Matrix<N, U4, U1, S> where N: Scalar, S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 4]; 1]> for Matrix<N, U4, U1, S> where N: Scalar, S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 4]; 1]> for Matrix<N, U4, U1, S> where N: Scalar, S: OwnedStorage<N, U4, U1>, S::Alloc: OwnedAllocator<N, U4, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where N: Scalar, S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

`fn from(arr: [[N; 4]; 2]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where N: Scalar, S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where N: Scalar, S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where N: Scalar, S: OwnedStorage<N, U4, U2>, S::Alloc: OwnedAllocator<N, U4, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where N: Scalar, S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

`fn from(arr: [[N; 4]; 3]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where N: Scalar, S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where N: Scalar, S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where N: Scalar, S: OwnedStorage<N, U4, U3>, S::Alloc: OwnedAllocator<N, U4, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where N: Scalar, S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

`fn from(arr: [[N; 4]; 4]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where N: Scalar, S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where N: Scalar, S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where N: Scalar, S: OwnedStorage<N, U4, U4>, S::Alloc: OwnedAllocator<N, U4, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where N: Scalar, S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

`fn from(arr: [[N; 4]; 5]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where N: Scalar, S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where N: Scalar, S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where N: Scalar, S: OwnedStorage<N, U4, U5>, S::Alloc: OwnedAllocator<N, U4, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where N: Scalar, S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

`fn from(arr: [[N; 4]; 6]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where N: Scalar, S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where N: Scalar, S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where N: Scalar, S: OwnedStorage<N, U4, U6>, S::Alloc: OwnedAllocator<N, U4, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 5]; 1]> for Matrix<N, U5, U1, S> where N: Scalar, S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

`fn from(arr: [[N; 5]; 1]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 5]; 1]> for Matrix<N, U5, U1, S> where N: Scalar, S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 5]; 1]> for Matrix<N, U5, U1, S> where N: Scalar, S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 5]; 1]> for Matrix<N, U5, U1, S> where N: Scalar, S: OwnedStorage<N, U5, U1>, S::Alloc: OwnedAllocator<N, U5, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where N: Scalar, S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

`fn from(arr: [[N; 5]; 2]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where N: Scalar, S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where N: Scalar, S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where N: Scalar, S: OwnedStorage<N, U5, U2>, S::Alloc: OwnedAllocator<N, U5, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where N: Scalar, S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

`fn from(arr: [[N; 5]; 3]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where N: Scalar, S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where N: Scalar, S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where N: Scalar, S: OwnedStorage<N, U5, U3>, S::Alloc: OwnedAllocator<N, U5, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where N: Scalar, S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

`fn from(arr: [[N; 5]; 4]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where N: Scalar, S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where N: Scalar, S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where N: Scalar, S: OwnedStorage<N, U5, U4>, S::Alloc: OwnedAllocator<N, U5, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where N: Scalar, S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

`fn from(arr: [[N; 5]; 5]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where N: Scalar, S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where N: Scalar, S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where N: Scalar, S: OwnedStorage<N, U5, U5>, S::Alloc: OwnedAllocator<N, U5, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where N: Scalar, S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

`fn from(arr: [[N; 5]; 6]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where N: Scalar, S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where N: Scalar, S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where N: Scalar, S: OwnedStorage<N, U5, U6>, S::Alloc: OwnedAllocator<N, U5, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 6]; 1]> for Matrix<N, U6, U1, S> where N: Scalar, S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

`fn from(arr: [[N; 6]; 1]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 6]; 1]> for Matrix<N, U6, U1, S> where N: Scalar, S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 6]; 1]> for Matrix<N, U6, U1, S> where N: Scalar, S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 6]; 1]> for Matrix<N, U6, U1, S> where N: Scalar, S: OwnedStorage<N, U6, U1>, S::Alloc: OwnedAllocator<N, U6, U1, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where N: Scalar, S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

`fn from(arr: [[N; 6]; 2]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where N: Scalar, S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where N: Scalar, S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where N: Scalar, S: OwnedStorage<N, U6, U2>, S::Alloc: OwnedAllocator<N, U6, U2, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where N: Scalar, S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

`fn from(arr: [[N; 6]; 3]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where N: Scalar, S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where N: Scalar, S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where N: Scalar, S: OwnedStorage<N, U6, U3>, S::Alloc: OwnedAllocator<N, U6, U3, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where N: Scalar, S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

`fn from(arr: [[N; 6]; 4]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where N: Scalar, S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where N: Scalar, S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where N: Scalar, S: OwnedStorage<N, U6, U4>, S::Alloc: OwnedAllocator<N, U6, U4, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where N: Scalar, S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

`fn from(arr: [[N; 6]; 5]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where N: Scalar, S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where N: Scalar, S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where N: Scalar, S: OwnedStorage<N, U6, U5>, S::Alloc: OwnedAllocator<N, U6, U5, S>,`
[src]

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

Performs the conversion.

`impl<N, S> From<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where N: Scalar, S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

`fn from(arr: [[N; 6]; 6]) -> Self`

Performs the conversion.

`impl<N, S> Into<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where N: Scalar, S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsRef<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where N: Scalar, S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, S> AsMut<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where N: Scalar, S: OwnedStorage<N, U6, U6>, S::Alloc: OwnedAllocator<N, U6, U6, S>,`
[src]

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

Performs the conversion.

`impl<N, R1: DimName, C1: Dim, D2: DimName, SA, SB> Mul<PointBase<N, D2, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, U1>, SA::Alloc: Allocator<N, R1, U1>, ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,`
[src]

`type Output = PointMul<N, R1, C1, SA>`

The resulting type after applying the * operator

`fn mul(self, right: PointBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<'a, N, R1: DimName, C1: Dim, D2: DimName, SA, SB> Mul<PointBase<N, D2, SB>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, U1>, SA::Alloc: Allocator<N, R1, U1>, ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,`
[src]

`type Output = PointMul<N, R1, C1, SA>`

The resulting type after applying the * operator

`fn mul(self, right: PointBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<'b, N, R1: DimName, C1: Dim, D2: DimName, SA, SB> Mul<&'b PointBase<N, D2, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, U1>, SA::Alloc: Allocator<N, R1, U1>, ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,`
[src]

`type Output = PointMul<N, R1, C1, SA>`

The resulting type after applying the * operator

`fn mul(self, right: &'b PointBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<'a, 'b, N, R1: DimName, C1: Dim, D2: DimName, SA, SB> Mul<&'b PointBase<N, D2, SB>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, U1>, SA::Alloc: Allocator<N, R1, U1>, ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,`
[src]

`type Output = PointMul<N, R1, C1, SA>`

The resulting type after applying the * operator

`fn mul(self, right: &'b PointBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Mul<RotationBase<N, D2, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the * operator

`fn mul(self, right: RotationBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<'a, N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Mul<RotationBase<N, D2, SB>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the * operator

`fn mul(self, right: RotationBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<'b, N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Mul<&'b RotationBase<N, D2, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the * operator

`fn mul(self, right: &'b RotationBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<'a, 'b, N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Mul<&'b RotationBase<N, D2, SB>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the * operator

`fn mul(self, right: &'b RotationBase<N, D2, SB>) -> Self::Output`

The method for the * operator

`impl<N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Div<RotationBase<N, D2, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the / operator

`fn div(self, right: RotationBase<N, D2, SB>) -> Self::Output`

The method for the / operator

`impl<'a, N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Div<RotationBase<N, D2, SB>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the / operator

`fn div(self, right: RotationBase<N, D2, SB>) -> Self::Output`

The method for the / operator

`impl<'b, N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Div<&'b RotationBase<N, D2, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the / operator

`fn div(self, right: &'b RotationBase<N, D2, SB>) -> Self::Output`

The method for the / operator

`impl<'a, 'b, N, R1: Dim, C1: Dim, D2: DimName, SA, SB> Div<&'b RotationBase<N, D2, SB>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: Storage<N, R1, C1>, SB: Storage<N, D2, D2>, SA::Alloc: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,`
[src]

`type Output = MatrixMul<N, R1, C1, D2, SA>`

The resulting type after applying the / operator

`fn div(self, right: &'b RotationBase<N, D2, SB>) -> Self::Output`

The method for the / operator

`impl<N, R1: DimName, C1: DimName, SA, SB> MulAssign<RotationBase<N, C1, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: OwnedStorage<N, R1, C1>, SB: Storage<N, C1, C1>, SA::Alloc: OwnedAllocator<N, R1, C1, SA>,`
[src]

`fn mul_assign(&mut self, right: RotationBase<N, C1, SB>)`

The method for the *= operator

`impl<'b, N, R1: DimName, C1: DimName, SA, SB> MulAssign<&'b RotationBase<N, C1, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: OwnedStorage<N, R1, C1>, SB: Storage<N, C1, C1>, SA::Alloc: OwnedAllocator<N, R1, C1, SA>,`
[src]

`fn mul_assign(&mut self, right: &'b RotationBase<N, C1, SB>)`

The method for the *= operator

`impl<N, R1: DimName, C1: DimName, SA, SB> DivAssign<RotationBase<N, C1, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: OwnedStorage<N, R1, C1>, SB: Storage<N, C1, C1>, SA::Alloc: OwnedAllocator<N, R1, C1, SA>,`
[src]

`fn div_assign(&mut self, right: RotationBase<N, C1, SB>)`

The method for the /= operator

`impl<'b, N, R1: DimName, C1: DimName, SA, SB> DivAssign<&'b RotationBase<N, C1, SB>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + ClosedAdd + ClosedMul, SA: OwnedStorage<N, R1, C1>, SB: Storage<N, C1, C1>, SA::Alloc: OwnedAllocator<N, R1, C1, SA>,`
[src]

`fn div_assign(&mut self, right: &'b RotationBase<N, C1, SB>)`

The method for the /= operator

`impl<N, R: Dim, C: Dim, S> Axpy<N> for Matrix<N, R, C, S> where N: Scalar + Field, S: StorageMut<N, R, C>,`
[src]

`fn axpy(&mut self, a: N, x: &Self)`

Computes self = a * x + self.

Struct nalgebra::core::Matrix [−] [src]

Fields

Methods

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

fn neg_mut(&mut self)

impl<N, R1: Dim, C1: Dim, SA> Matrix<N, R1, C1, SA> where N: Scalar, SA: Storage<N, R1, C1>, [src]

fn tr_mul<R2: Dim, C2: Dim, SB>( &self, right: &Matrix<N, R2, C2, SB>) -> MatrixTrMul<N, R1, C1, C2, SA> where N: Zero + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA::Alloc: Allocator<N, C1, C2>, ShapeConstraint: AreMultipliable<C1, R1, R2, C2>,

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

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

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

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

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

fn into_owned(self) -> OwnedMatrix<N, R, C, S::Alloc>

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

fn clone_owned(&self) -> OwnedMatrix<N, R, C, S::Alloc>

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

fn len(&self) -> usize

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

fn nrows(&self) -> usize

fn ncols(&self) -> usize

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

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

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

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

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

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

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

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

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

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

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

fn fill(&mut self, value: N)

impl<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: OwnedAllocator<N, R, C, S>, [src]

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

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

fn map<F: FnMut(N) -> N>(&self, f: F) -> Matrix<N, R, C, S>

fn zip_map<F: FnMut(N, N) -> N>( &self, rhs: &Matrix<N, R, C, S>, f: F) -> Matrix<N, R, C, S>

impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: Allocator<N, C, R>, [src]

fn transpose(&self) -> OwnedMatrix<N, C, R, S::Alloc>

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

fn transpose_mut(&mut self)

impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + Ring, S: Storage<N, R, C>, [src]

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

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

fn norm_squared(&self) -> N

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

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

impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Real, S: Storage<N, R, C>, [src]

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

fn norm(&self) -> N

fn normalize(&self) -> OwnedMatrix<N, R, C, S::Alloc>

fn try_normalize(&self, min_norm: N) -> Option<OwnedMatrix<N, R, C, S::Alloc>>

impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Real, S: StorageMut<N, R, C>, [src]

fn normalize_mut(&mut self) -> N

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

impl<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: OwnedAllocator<N, R, C, S>, [src]

unsafe fn new_uninitialized_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S>

fn from_element_generic(nrows: R, ncols: C, elem: N) -> Matrix<N, R, C, S>

fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Matrix<N, R, C, S> where I: IntoIterator<Item = N>,

fn from_row_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Matrix<N, R, C, S>

fn from_column_slice_generic( nrows: R, ncols: C, slice: &[N]) -> Matrix<N, R, C, S>

fn from_fn_generic<F>(nrows: R, ncols: C, f: F) -> Matrix<N, R, C, S> where F: FnMut(usize, usize) -> N,

fn identity_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S> where N: Zero + One,

fn from_diagonal_element_generic( nrows: R, ncols: C, elt: N) -> Matrix<N, R, C, S> where N: Zero + One,

fn from_rows<SB>(rows: &[Matrix<N, U1, C, SB>]) -> Matrix<N, R, C, S> where SB: Storage<N, U1, C>,

fn from_columns<SB>(columns: &[ColumnVector<N, R, SB>]) -> Matrix<N, R, C, S> where SB: Storage<N, R, U1>,

impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + Rand, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, [src]

fn new_random_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S>

impl<N: Scalar, R: DimName, C: DimName, S> Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, [src]

unsafe fn new_uninitialized() -> Matrix<N, R, C, S>

fn from_element(elem: N) -> Matrix<N, R, C, S>

fn from_iterator<I>(iter: I) -> Matrix<N, R, C, S> where I: IntoIterator<Item = N>,

fn from_row_slice(slice: &[N]) -> Matrix<N, R, C, S>

fn from_column_slice(slice: &[N]) -> Matrix<N, R, C, S>

fn from_fn<F>(f: F) -> Matrix<N, R, C, S> where F: FnMut(usize, usize) -> N,

fn identity() -> Matrix<N, R, C, S> where N: Zero + One,

fn from_diagonal_element(elt: N) -> Matrix<N, R, C, S> where N: Zero + One,

impl<N: Scalar + Rand, R: DimName, C: DimName, S> Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>, [src]

fn new_random() -> Matrix<N, R, C, S>

impl<N: Scalar, R: DimName, S> Matrix<N, R, Dynamic, S> where S: OwnedStorage<N, R, Dynamic>, S::Alloc: OwnedAllocator<N, R, Dynamic, S>, [src]

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

`fn neg_mut(&mut self)`

`impl<N, R1: Dim, C1: Dim, SA> Matrix<N, R1, C1, SA> where N: Scalar, SA: Storage<N, R1, C1>,`
[src]

`fn tr_mul<R2: Dim, C2: Dim, SB>( &self, right: &Matrix<N, R2, C2, SB> ) -> MatrixTrMul<N, R1, C1, C2, SA> where N: Zero + ClosedAdd + ClosedMul, SB: Storage<N, R2, C2>, SA::Alloc: Allocator<N, C1, C2>, ShapeConstraint: AreMultipliable<C1, R1, R2, C2>,`

`fn kronecker<R2: Dim, C2: Dim, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> OwnedMatrix<N, DimProd<R1, R2>, DimProd<C1, C2>, SA::Alloc> where N: ClosedMul, R1: DimMul<R2>, C1: DimMul<C2>, SB: Storage<N, R2, C2>, SA::Alloc: Allocator<N, DimProd<R1, R2>, DimProd<C1, C2>>,`

`impl<N: Scalar, R: Dim, C: Dim, S> Matrix<N, R, C, S>`
[src]

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

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>`
[src]

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

`fn into_owned(self) -> OwnedMatrix<N, R, C, S::Alloc>`

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

`fn clone_owned(&self) -> OwnedMatrix<N, R, C, S::Alloc>`

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

`fn len(&self) -> usize`

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

`fn nrows(&self) -> usize`

`fn ncols(&self) -> usize`

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

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

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

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

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

`impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>`
[src]

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

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

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

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

`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>,`

`fn fill(&mut self, value: N)`

`impl<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

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

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

`fn map<F: FnMut(N) -> N>(&self, f: F) -> Matrix<N, R, C, S>`

`fn zip_map<F: FnMut(N, N) -> N>( &self, rhs: &Matrix<N, R, C, S>, f: F ) -> Matrix<N, R, C, S>`

`impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: Allocator<N, C, R>,`
[src]

`fn transpose(&self) -> OwnedMatrix<N, C, R, S::Alloc>`

`impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S>`
[src]

`fn transpose_mut(&mut self)`

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + Ring, S: Storage<N, R, C>,`
[src]

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

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

`fn norm_squared(&self) -> N`

`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>,`

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

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Real, S: Storage<N, R, C>,`
[src]

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

`fn norm(&self) -> N`

`fn normalize(&self) -> OwnedMatrix<N, R, C, S::Alloc>`

`fn try_normalize(&self, min_norm: N) -> Option<OwnedMatrix<N, R, C, S::Alloc>>`

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Real, S: StorageMut<N, R, C>,`
[src]

`fn normalize_mut(&mut self) -> N`

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

`impl<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C>> Matrix<N, R, C, S> where S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`unsafe fn new_uninitialized_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S>`

`fn from_element_generic(nrows: R, ncols: C, elem: N) -> Matrix<N, R, C, S>`

`fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Matrix<N, R, C, S> where I: IntoIterator<Item = N>,`

`fn from_row_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Matrix<N, R, C, S>`

`fn from_column_slice_generic( nrows: R, ncols: C, slice: &[N] ) -> Matrix<N, R, C, S>`

`fn from_fn_generic<F>(nrows: R, ncols: C, f: F) -> Matrix<N, R, C, S> where F: FnMut(usize, usize) -> N,`

`fn identity_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S> where N: Zero + One,`

`fn from_diagonal_element_generic( nrows: R, ncols: C, elt: N ) -> Matrix<N, R, C, S> where N: Zero + One,`

`fn from_rows<SB>(rows: &[Matrix<N, U1, C, SB>]) -> Matrix<N, R, C, S> where SB: Storage<N, U1, C>,`

`fn from_columns<SB>(columns: &[ColumnVector<N, R, SB>]) -> Matrix<N, R, C, S> where SB: Storage<N, R, U1>,`

`impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where N: Scalar + Rand, S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn new_random_generic(nrows: R, ncols: C) -> Matrix<N, R, C, S>`

`impl<N: Scalar, R: DimName, C: DimName, S> Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`unsafe fn new_uninitialized() -> Matrix<N, R, C, S>`

`fn from_element(elem: N) -> Matrix<N, R, C, S>`

`fn from_iterator<I>(iter: I) -> Matrix<N, R, C, S> where I: IntoIterator<Item = N>,`

`fn from_row_slice(slice: &[N]) -> Matrix<N, R, C, S>`

`fn from_column_slice(slice: &[N]) -> Matrix<N, R, C, S>`

`fn from_fn<F>(f: F) -> Matrix<N, R, C, S> where F: FnMut(usize, usize) -> N,`

`fn identity() -> Matrix<N, R, C, S> where N: Zero + One,`

`fn from_diagonal_element(elt: N) -> Matrix<N, R, C, S> where N: Zero + One,`

`impl<N: Scalar + Rand, R: DimName, C: DimName, S> Matrix<N, R, C, S> where S: OwnedStorage<N, R, C>, S::Alloc: OwnedAllocator<N, R, C, S>,`
[src]

`fn new_random() -> Matrix<N, R, C, S>`

`impl<N: Scalar, R: DimName, S> Matrix<N, R, Dynamic, S> where S: OwnedStorage<N, R, Dynamic>, S::Alloc: OwnedAllocator<N, R, Dynamic, S>,`
[src]

`unsafe fn new_uninitialized(ncols: usize) -> Matrix<N, R, Dynamic, S>`

`fn from_element(ncols: usize, elem: N) -> Matrix<N, R, Dynamic, S>`

`fn from_iterator<I>(ncols: usize, iter: I) -> Matrix<N, R, Dynamic, S> where I: IntoIterator<Item = N>,`