[][src]Struct nalgebra::base::Matrix

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

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

It combines four type parameters:

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

The matrix dimensions parameters R and C can either be:

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

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

Fields

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

Methods

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

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

Examples:

let mat = Matrix2x3::new(11, -12, 13,
                         21, 22, -23);
assert_eq!(mat.iamax_full(), (1, 2));

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

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

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

Examples:

let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.dot(&vec2), 1.4);

let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
                          4.0, 5.0, 6.0);
let mat2 = Matrix2x3::new(0.1, 0.2, 0.3,
                          0.4, 0.5, 0.6);
assert_eq!(mat1.dot(&mat2), 9.1);

The dot product between the transpose of self and rhs.

Examples:

let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = RowVector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.tr_dot(&vec2), 1.4);

let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
                          4.0, 5.0, 6.0);
let mat2 = Matrix3x2::new(0.1, 0.4,
                          0.2, 0.5,
                          0.3, 0.6);
assert_eq!(mat1.tr_dot(&mat2), 9.1);

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

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

If beta is zero, self is never read.

Examples:

let mut mat = Matrix2x3::repeat(4.0);
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;

mat.ger(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat, expected);

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

If beta is zero, self is never read.

Examples:

let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix2x3::new(1.0, 2.0, 3.0,
                          4.0, 5.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
                          0.5, 0.6, 0.7, 0.8,
                          0.9, 1.0, 1.1, 1.2);
let expected = mat2 * mat3 * 10.0 + mat1 * 5.0;

mat1.gemm(10.0, &mat2, &mat3, 5.0);
assert_relative_eq!(mat1, expected);

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

If beta is zero, self is never read.

Examples:

let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix3x2::new(1.0, 4.0,
                          2.0, 5.0,
                          3.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
                          0.5, 0.6, 0.7, 0.8,
                          0.9, 1.0, 1.1, 1.2);
let expected = mat2.transpose() * mat3 * 10.0 + mat1 * 5.0;

mat1.gemm_tr(10.0, &mat2, &mat3, 5.0);
assert_relative_eq!(mat1, expected);

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

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

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

Examples:

let mut mat = Matrix2::identity();
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
mat.m12 = 99999.99999; // This component is on the upper-triangular part and will not be read/written.

mat.ger_symm(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, 99999.99999); // This was untouched.

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

Negates self in-place.

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

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

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

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

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

Equivalent to self.transpose() * rhs.

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

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

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

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

Adds a scalar to self.

Adds a scalar to self in-place.

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

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

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

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

Computes the component-wise absolute value.

Example

let a = Matrix2::new(0.0, 1.0,
                     -2.0, -3.0);
assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0))

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

Componentwise matrix or vector multiplication.

Example

let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);

assert_eq!(a.component_mul(&b), expected);

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

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

Example

let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_mul(&b) * 5.0) + m * 10.0;

m.cmpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);

Inplace componentwise matrix or vector multiplication.

Example

let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);

a.component_mul_assign(&b);

assert_eq!(a, expected);

Deprecated

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

Inplace componentwise matrix or vector multiplication.

Example

let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);

a.component_mul_assign(&b);

assert_eq!(a, expected);

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

Componentwise matrix or vector division.

Example

let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);

assert_eq!(a.component_div(&b), expected);

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

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

Example

let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_div(&b) * 5.0) + m * 10.0;

m.cdpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);

Inplace componentwise matrix or vector division.

Example

let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);

a.component_div_assign(&b);

assert_eq!(a, expected);

Deprecated

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

Inplace componentwise matrix or vector division.

Example

let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);

a.component_div_assign(&b);

assert_eq!(a, expected);

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

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

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

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

Sets all the elements of this matrix to val.

Fills self with the identity matrix.

Sets all the diagonal elements of this matrix to val.

Sets all the elements of the selected row to val.

Sets all the elements of the selected column to val.

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

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

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

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

The parameter shift allows some subdiagonals to be left untouched:

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

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

The parameter shift allows some superdiagonals to be left untouched:

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

Swaps two rows in-place.

Swaps two columns in-place.

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

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

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

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

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

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

Removes the i-th column from this matrix.

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

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

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

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

Removes the i-th row from this matrix.

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

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

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

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

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

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

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

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

The added column values are not initialized.

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

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

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

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

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

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

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

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

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

Resizes self such that it has dimensions new_nrows × now_ncols.

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

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

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]

Creates a new matrix with the given data.

The total number of elements of this matrix.

Examples:

let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.len(), 12);

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

Examples:

let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.shape(), (3, 4));

The number of rows of this matrix.

Examples:

let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.nrows(), 3);

The number of columns of this matrix.

Examples:

let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.ncols(), 4);

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

Examples:

let mat = DMatrix::<f32>::zeros(10, 10);
let slice = mat.slice_with_steps((0, 0), (5, 3), (1, 2));
// The column strides is the number of steps (here 2) multiplied by the corresponding dimension.
assert_eq!(mat.strides(), (1, 10));

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

Iterates through this matrix coordinates in column-major order.

Examples:

let mat = Matrix2x3::new(11, 12, 13,
                         21, 22, 23);
let mut it = mat.iter();
assert_eq!(*it.next().unwrap(), 11);
assert_eq!(*it.next().unwrap(), 21);
assert_eq!(*it.next().unwrap(), 12);
assert_eq!(*it.next().unwrap(), 22);
assert_eq!(*it.next().unwrap(), 13);
assert_eq!(*it.next().unwrap(), 23);
assert!(it.next().is_none());

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

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

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

See relative_eq from the RelativeEq trait for more details.

Tests whether self and rhs are exactly equal.

Moves this matrix into one that owns its data.

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

Clones this matrix to one that owns its data.

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

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

Returns a matrix containing the result of f applied to each of its entries. Unlike map, f also gets passed the row and column index, i.e. f(value, row, col).

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

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

Transposes self and store the result into out.

Transposes self.

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

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

Mutably iterates through this matrix coordinates.

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

Swaps two entries without bound-checking.

Swaps two entries.

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

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

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

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

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

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

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

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

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

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

Transposes the square matrix self in-place.

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

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

The conjugate transposition of self.

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

Sets self to its conjugate transpose.

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

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

The 3D cross product between two vectors.

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

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

The smallest angle between two vectors.

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

The squared L2 norm of this vector.

The L2 norm of this matrix.

A synonym for the norm of this matrix.

Aka the length.

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

A synonym for the squared norm of this matrix.

Aka the squared length.

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

Returns a normalized version of this matrix.

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

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

Normalizes this matrix in-place and returns its norm.

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

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

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

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

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

Extracts from this matrix a set of consecutive rows.

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

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

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

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

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

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

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

Extracts from this matrix a set of consecutive columns.

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

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

Extracts from this matrix a set of consecutive rows.

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

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

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

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

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

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

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

Extracts from this matrix a set of consecutive columns.

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

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

Slice containing all the rows indexed by the range rows.

Slice containing all the columns indexed by the range rows.

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

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

Slice containing all the rows indexed by the range rows.

Slice containing all the columns indexed by the range cols.

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

Indicates if this is an empty matrix.

Indicates if this is a square matrix.

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.

Checks that Mᵀ × M = Id.

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

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

Computes the bidiagonalization using householder reflections.

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

Computes the LU decomposition with full pivoting of matrix.

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

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

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

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

Computes the QR decomposition of this matrix.

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

Computes the Singular Value Decomposition using implicit shift.

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

Arguments

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

Computes the singular values of this matrix.

Computes the rank of this matrix.

All singular values below eps are considered equal to 0.

Computes the pseudo-inverse of this matrix.

All singular values below eps are considered equal to 0.

Trait Implementations

impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, MatrixArray<N, R, C>> where
    N: Scalar,
    R: DimName,
    C: DimName,
    RStride: Dim,
    CStride: Dim,
    R::Value: Mul<C::Value>,
    Prod<R::Value, C::Value>: ArrayLength<N>, 
[src]

Performs the conversion.

impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, MatrixVec<N, Dynamic, C>> where
    N: Scalar,
    C: Dim,
    RStride: Dim,
    CStride: Dim
[src]

Performs the conversion.

impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, MatrixVec<N, R, Dynamic>> where
    N: Scalar,
    R: DimName,
    RStride: Dim,
    CStride: Dim
[src]

Performs the conversion.

impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, MatrixArray<N, R, C>> where
    N: Scalar,
    R: DimName,
    C: DimName,
    RStride: Dim,
    CStride: Dim,
    R::Value: Mul<C::Value>,
    Prod<R::Value, C::Value>: ArrayLength<N>, 
[src]

Performs the conversion.

impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, MatrixVec<N, Dynamic, C>> where
    N: Scalar,
    C: Dim,
    RStride: Dim,
    CStride: Dim
[src]

Performs the conversion.

impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, MatrixVec<N, R, Dynamic>> where
    N: Scalar,
    R: DimName,
    RStride: Dim,
    CStride: Dim
[src]

Performs the conversion.

impl<N: Scalar, D: DimName> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Point<N, D> where
    DefaultAllocator: Allocator<N, D>, 
[src]

Performs the conversion.

impl<N: Real> From<Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>> for Quaternion<N>
[src]

Performs the conversion.

impl<N: Scalar, D: DimName> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Translation<N, D> where
    DefaultAllocator: Allocator<N, D>, 
[src]

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

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

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

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

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

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

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

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

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

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

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

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
    N: Scalar,
    S: Storage<N, R, C>, 
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

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

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

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

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

The resulting type after applying the + operator.

Performs the + operation.

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

The resulting type after applying the + operator.

Performs the + operation.

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

The resulting type after applying the + operator.

Performs the + operation.

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

The resulting type after applying the + operator.

Performs the + operation.

impl<'a, 'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    N: Scalar + ClosedAdd,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the + operator.

Performs the + operation.

impl<'a, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    N: Scalar + ClosedAdd,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the + operator.

Performs the + operation.

impl<'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedAdd,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the + operator.

Performs the + operation.

impl<N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedAdd,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the + operator.

Performs the + operation.

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

The resulting type after applying the - operator.

Performs the - operation.

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

The resulting type after applying the - operator.

Performs the - operation.

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

The resulting type after applying the - operator.

Performs the - operation.

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

The resulting type after applying the - operator.

Performs the - operation.

impl<'a, 'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    N: Scalar + ClosedSub,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the - operator.

Performs the - operation.

impl<'a, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    N: Scalar + ClosedSub,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the - operator.

Performs the - operation.

impl<'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedSub,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the - operator.

Performs the - operation.

impl<N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedSub,
    DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>, 
[src]

The resulting type after applying the - operator.

Performs the - operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.

Performs the * operation.

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

The resulting type after applying the * operator.