[−][src]Struct rin::math::core::Matrix

#[repr(C)]

pub struct Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,  {
    pub data: S,
    // some fields omitted
}

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

It combines four type parameters:

The matrix dimensions parameters R and C can either be:

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, D, S> Matrix<N, D, U1, S> where
    D: Dim,
    N: Scalar + PartialOrd<N> + Signed,
    S: Storage<N, D, U1>, 
[src]

Computes the index of the vector component with the largest value.

Examples:

let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.imax(), 2);

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

Examples:

let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.iamax(), 1);

Computes the index of the vector component with the smallest value.

Examples:

let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.imin(), 1);

Computes the index of the vector component with the smallest absolute value.

Examples:

let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.iamin(), 0);

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar + PartialOrd<N> + Signed,
    R: Dim,
    S: Storage<N, R, C>, 
[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, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
    R: Dim,
    S: Storage<N, R, C>, 
[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, D, S> Matrix<N, D, U1, S> where
    D: Dim,
    N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
    S: StorageMut<N, D, U1>, 
[src]

Computes self = a * x + b * self.

If be is zero, self is never read from.

Examples:

let mut vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
vec1.axpy(10.0, &vec2, 5.0);
assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));

Computes self = alpha * a * x + beta * self, where a is a matrix, x a vector, and alpha, beta two scalars.

If beta is zero, self is never read.

Examples:

let mut vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let mat = Matrix2::new(1.0, 2.0,
                       3.0, 4.0);
vec1.gemv(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 21.0));

Computes self = alpha * a * x + beta * self, where a is a symmetric matrix, x a vector, and alpha, beta two scalars.

If beta is zero, self is never read. If self is read, only its lower-triangular part (including the diagonal) is actually read.

Examples:

let mat = Matrix2::new(1.0, 2.0,
                       2.0, 4.0);
let mut vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
vec1.gemv_symm(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 20.0));


// The matrix upper-triangular elements can be garbage because it is never
// read by this method. Therefore, it is not necessary for the caller to
// fill the matrix struct upper-triangle.
let mat = Matrix2::new(1.0, 9999999.9999999,
                       2.0, 4.0);
let mut vec1 = Vector2::new(1.0, 2.0);
vec1.gemv_symm(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 20.0));

Computes self = alpha * a.transpose() * x + beta * self, where a is a matrix, x a vector, and alpha, beta two scalars.

If beta is zero, self is never read.

Examples:

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

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

impl<N, R1, C1, S> Matrix<N, R1, C1, S> where
    C1: Dim,
    N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    S: StorageMut<N, R1, C1>, 
[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, C1, S> Matrix<N, R1, C1, S> where
    C1: Dim,
    N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    S: StorageMut<N, R1, C1>, 
[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, D1, S> Matrix<N, D1, D1, S> where
    D1: Dim,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    S: StorageMut<N, D1, D1>, 
[src]

Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self.

This uses the provided workspace work to avoid allocations for intermediate results.

Examples:

// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let lhs = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0,
                                          4.0, 5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
                                          0.5, 0.6, 0.7,
                                          0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(2);
let expected = &lhs * &mid * lhs.transpose() * 10.0 + &mat * 5.0;

mat.quadform_tr_with_workspace(&mut workspace, 10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);

Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self.

This allocates a workspace vector of dimension D1 for intermediate results. If D1 is a type-level integer, then the allocation is performed on the stack. Use .quadform_tr_with_workspace(...) instead to avoid allocations.

Examples:

let mut mat = Matrix2::identity();
let lhs = Matrix2x3::new(1.0, 2.0, 3.0,
                         4.0, 5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
                       0.5, 0.6, 0.7,
                       0.9, 1.0, 1.1);
let expected = lhs * mid * lhs.transpose() * 10.0 + mat * 5.0;

mat.quadform_tr(10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);

Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self.

This uses the provided workspace work to avoid allocations for intermediate results.

// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let rhs = DMatrix::from_row_slice(3, 2, &[1.0, 2.0,
                                          3.0, 4.0,
                                          5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
                                          0.5, 0.6, 0.7,
                                          0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(3);
let expected = rhs.transpose() * &mid * &rhs * 10.0 + &mat * 5.0;

mat.quadform_with_workspace(&mut workspace, 10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);

Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self.

This allocates a workspace vector of dimension D2 for intermediate results. If D2 is a type-level integer, then the allocation is performed on the stack. Use .quadform_with_workspace(...) instead to avoid allocations.

let mut mat = Matrix2::identity();
let rhs = Matrix3x2::new(1.0, 2.0,
                         3.0, 4.0,
                         5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
                       0.5, 0.6, 0.7,
                       0.9, 1.0, 1.1);
let expected = rhs.transpose() * mid * rhs * 10.0 + mat * 5.0;

mat.quadform(10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);

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

Negates self in-place.

impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
    C1: Dim,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar + ClosedAdd<N>,
    R: Dim,
    S: Storage<N, R, C>, 
[src]

Adds a scalar to self.

Adds a scalar to self in-place.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar + PartialOrd<N> + Signed,
    R: Dim,
    S: Storage<N, R, C>, 
[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, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Ring,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Creates a new homogeneous matrix that applies the same scaling factor on each dimension.

Creates a new homogeneous matrix that applies a distinct scaling factor for each dimension.

Creates a new homogeneous matrix that applies a pure translation.

impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Real, 
[src]

Builds a 2 dimensional homogeneous rotation matrix from an angle in radian.

impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where
    N: Real, 
[src]

Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).

Returns the identity matrix if the given argument is zero.

Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).

Returns the identity matrix if the given argument is zero.

Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).

Returns the identity matrix if the given argument is zero. This is identical to Self::new_rotation.

Creates a new rotation from Euler angles.

The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.

Builds a 3D homogeneous rotation matrix from an axis and a rotation angle.

Creates a new homogeneous matrix for an orthographic projection.

Creates a new homogeneous matrix for a perspective projection.

Creates an isometry that corresponds to the local frame of an observer standing at the point eye and looking toward target.

It maps the view direction target - eye to the positive z axis and the origin to the eye.

Builds a right-handed look-at view matrix.

Builds a left-handed look-at view matrix.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimName,
    N: Scalar + Ring,
    S: Storage<N, D, D>, 
[src]

Computes the transformation equal to self followed by an uniform scaling factor.

Computes the transformation equal to an uniform scaling factor followed by self.

Computes the transformation equal to self followed by a non-uniform scaling factor.

Computes the transformation equal to a non-uniform scaling factor followed by self.

Computes the transformation equal to self followed by a translation.

Computes the transformation equal to a translation followed by self.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimName,
    N: Scalar + Ring,
    S: StorageMut<N, D, D>, 
[src]

Computes in-place the transformation equal to self followed by an uniform scaling factor.

Computes in-place the transformation equal to an uniform scaling factor followed by self.

Computes in-place the transformation equal to self followed by a non-uniform scaling factor.

Computes in-place the transformation equal to a non-uniform scaling factor followed by self.

Computes the transformation equal to self followed by a translation.

Computes the transformation equal to a translation followed by self.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimNameSub<U1>,
    N: Real,
    S: Storage<N, D, D>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>, 
[src]

Transforms the given vector, assuming the matrix self uses homogeneous coordinates.

Transforms the given point, assuming the matrix self uses homogeneous coordinates.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Storage<N, R, C>, 
[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, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: Dim,
    N: Scalar,
    R: Dim,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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().

Creates a matrix with all its elements set to elem.

Creates a matrix with all its elements set to elem.

Same as from_element_generic.

Creates a matrix with all its elements set to 0.

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

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.

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. column-major).

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

Creates a new identity 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.

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.

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

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.

Example


let m = Matrix3::from_rows(&[ RowVector3::new(1.0, 2.0, 3.0),  RowVector3::new(4.0, 5.0, 6.0),  RowVector3::new(7.0, 8.0, 9.0) ]);

assert!(m.m11 == 1.0 && m.m12 == 2.0 && m.m13 == 3.0 &&
        m.m21 == 4.0 && m.m22 == 5.0 && m.m23 == 6.0 &&
        m.m31 == 7.0 && m.m32 == 8.0 && m.m33 == 9.0);

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.

Example


let m = Matrix3::from_columns(&[ Vector3::new(1.0, 2.0, 3.0),  Vector3::new(4.0, 5.0, 6.0),  Vector3::new(7.0, 8.0, 9.0) ]);

assert!(m.m11 == 1.0 && m.m12 == 4.0 && m.m13 == 7.0 &&
        m.m21 == 2.0 && m.m22 == 5.0 && m.m23 == 8.0 &&
        m.m31 == 3.0 && m.m32 == 6.0 && m.m33 == 9.0);

Creates a matrix filled with random values.

Creates a matrix filled with random values from the given distribution.

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

Example


let vec = vec![0, 1, 2, 3, 4, 5];
let vec_ptr = vec.as_ptr();

let matrix = Matrix::from_vec_generic(Dynamic::new(vec.len()), U1, vec);
let matrix_storage_ptr = matrix.data.as_ptr();

// `matrix` is backed by exactly the same `Vec` as it was constructed from.
assert_eq!(matrix_storage_ptr, vec_ptr);

impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: Dim,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Creates a square matrix with its diagonal set to diag and all other entries set to 0.

Example


let m = Matrix3::from_diagonal(&Vector3::new(1.0, 2.0, 3.0));
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal(&DVector::from_row_slice(3, &[1.0, 2.0, 3.0]));

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 3.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 3.0);

impl<N, R> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
    N: Scalar + Zero + One,
    R: DimName,
    DefaultAllocator: Allocator<N, R, U1>, 
[src]

The column vector with a 1 as its first component, and zero elsewhere.

The column vector with a 1 as its second component, and zero elsewhere.

The column vector with a 1 as its third component, and zero elsewhere.

The column vector with a 1 as its fourth component, and zero elsewhere.

The column vector with a 1 as its fifth component, and zero elsewhere.

The column vector with a 1 as its sixth component, and zero elsewhere.

The unit column vector with a 1 as its first component, and zero elsewhere.

The unit column vector with a 1 as its second component, and zero elsewhere.

The unit column vector with a 1 as its third component, and zero elsewhere.

The unit column vector with a 1 as its fourth component, and zero elsewhere.

The unit column vector with a 1 as its fifth component, and zero elsewhere.

The unit column vector with a 1 as its sixth component, and zero elsewhere.

impl<'a, N, R, C, RStride, CStride> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>> where
    C: Dim,
    CStride: Dim,
    N: Scalar,
    R: Dim,
    RStride: Dim, 
[src]

Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances.

This method is unsafe because the input data array is not checked to contain enough elements. The generic types R, C, RStride, CStride can either be type-level integers or integers wrapped with Dynamic::new().

Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.

Panics if the input data array dose not contain enough elements. The generic types R, C, RStride, CStride can either be type-level integers or integers wrapped with Dynamic::new().

impl<'a, N, R, C, RStride, CStride> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>> where
    C: Dim,
    CStride: Dim,
    N: Scalar,
    R: Dim,
    RStride: Dim, 
[src]

Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.

This method is unsafe because the input data array is not checked to contain enough elements. The generic types R, C, RStride, CStride can either be type-level integers or integers wrapped with Dynamic::new().

Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.

Panics if the input data array dose not contain enough elements. The generic types R, C, RStride, CStride can either be type-level integers or integers wrapped with Dynamic::new().

impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>> where
    C: Dim,
    N: Scalar,
    R: Dim, 
[src]

Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances.

This method is unsafe because the input data array is not checked to contain enough elements. The generic types R and C can either be type-level integers or integers wrapped with Dynamic::new().

Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.

Panics if the input data array dose not contain enough elements. The generic types R and C can either be type-level integers or integers wrapped with Dynamic::new().

impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>> where
    C: Dim,
    N: Scalar,
    R: Dim, 
[src]

Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances.

This method is unsafe because the input data array is not checked to contain enough elements. The generic types R and C can either be type-level integers or integers wrapped with Dynamic::new().

Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.

Panics if the input data array dose not contain enough elements. The generic types R and C can either be type-level integers or integers wrapped with Dynamic::new().

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar + Zero,
    R: Dim,
    S: Storage<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: StorageMut<N, R, C>, 
[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, D, S> Matrix<N, D, D, S> where
    D: Dim,
    N: Scalar,
    S: StorageMut<N, D, D>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Storage<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim, 
[src]

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

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Storage<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: StorageMut<N, R, C>, 
[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, D, S> Matrix<N, D, U1, S> where
    D: Dim,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Gets a reference to the i-th element of this column vector without bound checking.

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

Gets a mutable reference to the i-th element of this column vector without bound checking.

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

ⓘImportant traits for &'a mut [u8]

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

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

ⓘImportant traits for &'a mut [u8]

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

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

Transposes the square matrix self in-place.

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

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

The conjugate transposition of self.

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

Sets self to its conjugate transpose.

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

Creates a square matrix with its diagonal set to diag and all other entries set to 0.

Computes a trace of a square matrix, i.e., the sum of its diagonal elements.

impl<N, D, S> Matrix<N, D, D, S> where
    D: IsNotStaticOne + DimAdd<U1>,
    N: Scalar + Zero + One,
    S: Storage<N, D, D>, 
[src]

Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and and setting the diagonal element to 1.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimAdd<U1>,
    N: Scalar + Zero,
    S: Storage<N, D, U1>, 
[src]

Computes the coordinates in projective space of this vector, i.e., appends a 0 to its coordinates.

Constructs a vector from coordinates in projective space, i.e., removes a 0 at the end of self. Returns None if this last component is not zero.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar + Ring,
    R: Dim,
    S: Storage<N, R, C>, 
[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, S> Matrix<N, U3, U1, S> where
    N: Real,
    S: Storage<N, U3, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

Computes the matrix M such that for all vector v we have M * v == self.cross(&v).

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

The smallest angle between two vectors.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Real,
    R: Dim,
    S: Storage<N, R, C>, 
[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, D, S> Matrix<N, D, U1, S> where
    D: Dim,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedSub<N> + ClosedMul<N>,
    S: Storage<N, D, U1>, 
[src]

Returns self * (1.0 - t) + rhs * t, i.e., the linear blend of the vectors x and y using the scalar value a.

The value for a is not restricted to the range [0, 1].

Examples:

let x = Vector3::new(1.0, 2.0, 3.0);
let y = Vector3::new(10.0, 20.0, 30.0);
assert_eq!(x.lerp(&y, 0.1), Vector3::new(1.9, 3.8, 5.7));

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Real,
    R: Dim,
    S: StorageMut<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Storage<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: StorageMut<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Storage<N, R, C>, 
[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, D, S> Matrix<N, D, D, S> where
    D: Dim,
    N: Real,
    S: Storage<N, D, D>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Checks that this matrix is orthogonal and has a determinant equal to 1.

Returns true if this matrix is invertible.

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

Computes the bidiagonalization using householder reflections.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimSub<Dynamic>,
    N: Real,
    S: Storage<N, D, D>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Attempts to compute the Cholesky decomposition of this matrix.

Returns None if the input matrix is not definite-positive. The input matrix is assumed to be symmetric and only the lower-triangular part is read.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimMin<D, Output = D>,
    N: Real,
    S: Storage<N, D, D>, 
[src]

Computes the matrix determinant.

If the matrix has a dimension larger than 3, an LU decomposition is used.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Real,
    R: DimMin<C>,
    S: Storage<N, R, C>,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>, 
[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, D, S> Matrix<N, D, D, S> where
    D: DimSub<U1>,
    N: Real,
    S: Storage<N, D, D>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, 
[src]

Computes the Hessenberg decomposition of this matrix using householder reflections.

impl<N, D, S> Matrix<N, D, D, S> where
    D: Dim,
    N: Real,
    S: Storage<N, D, D>, 
[src]

Attempts to invert this matrix.

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

Attempts to invert this matrix in-place. Returns false and leaves self untouched if inversion fails.

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

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

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

Computes the QR decomposition of this matrix.

impl<N, D, S> Matrix<N, D, D, S> where
    D: Dim + DimSub<U1>,
    N: Real,
    S: Storage<N, D, D>,
    ShapeConstraint: DimEq<Dynamic, <D as DimSub<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, <D as DimSub<U1>>::Output>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

Computes the Schur decomposition of a square matrix.

Attempts to compute the Schur decomposition of a square matrix.

If only eigenvalues are needed, it is more efficient to call the matrix method .eigenvalues() instead.

Arguments

  • 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 eigenvalues of this matrix.

Computes the eigenvalues of this matrix.

impl<N, D, S> Matrix<N, D, D, S> where
    D: Dim,
    N: Real,
    S: Storage<N, D, D>, 
[src]

Computes the solution of the linear system self . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Computes the solution of the linear system self . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Solves the linear system self . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Solves the linear system self . x = b where x is the unknown and only the lower-triangular part of self is considered not-zero. The diagonal is never read as it is assumed to be equal to diag. Returns false and does not modify its inputs if diag is zero.

Solves the linear system self . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Computes the solution of the linear system self.transpose() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Computes the solution of the linear system self.transpose() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Solves the linear system self.transpose() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Solves the linear system self.transpose() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Real,
    R: DimMin<C>,
    S: Storage<N, R, C>,
    <R as DimMin<C>>::Output: DimSub<U1>,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<N, C, U1>,
    DefaultAllocator: Allocator<N, R, U1>,
    DefaultAllocator: Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, C>,
    DefaultAllocator: Allocator<N, R, <R as DimMin<C>>::Output>,
    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>, 
[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.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimSub<U1>,
    N: Real,
    S: Storage<N, D, D>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, 
[src]

Computes the eigendecomposition of this symmetric matrix.

Only the lower-triangular part (including the diagonal) of m is read.

Computes the eigendecomposition of the given symmetric matrix with user-specified convergence parameters.

Only the lower-triangular part (including the diagonal) of m is read.

Arguments

  • 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 eigenvalues of this symmetric matrix.

Only the lower-triangular part of the matrix is read.

impl<N, D, S> Matrix<N, D, D, S> where
    D: DimSub<U1>,
    N: Real,
    S: Storage<N, D, D>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, 
[src]

Computes the tridiagonalization of this symmetric matrix.

Only the lower-triangular part (including the diagonal) of m is read.

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

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

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

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

impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
    C1: Dim,
    N: Scalar,
    R1: Dim,
    SA: Storage<N, R1, C1>, 
[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, R1, C1, SA> Matrix<N, R1, C1, SA> where
    C1: Dim,
    N: Scalar,
    R1: Dim,
    SA: StorageMut<N, R1, C1>, 
[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, R1, C1, SA> Matrix<N, R1, C1, SA> where
    C1: Dim,
    N: Scalar,
    R1: Dim,
    SA: Storage<N, R1, C1>, 
[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, R1, C1, SA> Matrix<N, R1, C1, SA> where
    C1: Dim,
    N: Scalar,
    R1: Dim,
    SA: StorageMut<N, R1, C1>, 
[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, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

Creates a new uninitialized matrix or vector.

Creates a matrix or vector with all its elements set to elem.

Example


let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to elem.

Same as .from_element.

Example


let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to 0.

Example


let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);

assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);

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

The output matrix is filled column-by-column.

Example


let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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.

Example


let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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.

Example


let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);

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

Example


let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);

assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

Example


let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);

Creates a matrix or vector filled with random values from the given distribution.

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

Example


let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);

assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);


// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);

assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>,
    Standard: Distribution<N>, 
[src]

Creates a matrix filled with random values.

impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
    N: Scalar,
    R: DimName,
    DefaultAllocator: Allocator<N, R, Dynamic>, 
[src]

Creates a new uninitialized matrix or vector.

Creates a matrix or vector with all its elements set to elem.

Example


let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to elem.

Same as .from_element.

Example


let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to 0.

Example


let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);

assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);

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

The output matrix is filled column-by-column.

Example


let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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.

Example


let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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.

Example


let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);

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

Example


let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);

assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

Example


let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);

Creates a matrix or vector filled with random values from the given distribution.

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

Example


let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);

assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);


// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);

assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
    N: Scalar,
    R: DimName,
    DefaultAllocator: Allocator<N, R, Dynamic>,
    Standard: Distribution<N>, 
[src]

Creates a matrix filled with random values.

impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
    C: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, Dynamic, C>, 
[src]

Creates a new uninitialized matrix or vector.

Creates a matrix or vector with all its elements set to elem.

Example


let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to elem.

Same as .from_element.

Example


let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to 0.

Example


let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);

assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);

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

The output matrix is filled column-by-column.

Example


let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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.

Example


let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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.

Example


let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);

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

Example


let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);

assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

Example


let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);

Creates a matrix or vector filled with random values from the given distribution.

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

Example


let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);

assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);


// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);

assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
    C: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, Dynamic, C>,
    Standard: Distribution<N>, 
[src]

Creates a matrix filled with random values.

impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, Dynamic, Dynamic>, 
[src]

Creates a new uninitialized matrix or vector.

Creates a matrix or vector with all its elements set to elem.

Example


let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to elem.

Same as .from_element.

Example


let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);

Creates a matrix or vector with all its elements set to 0.

Example


let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);

assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);

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

The output matrix is filled column-by-column.

Example


let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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.

Example


let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

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

Example


let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);

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.

Example


let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);

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

Example


let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);

assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

Example


let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);

Creates a matrix or vector filled with random values from the given distribution.

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

Example


let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);

assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);


// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);

assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);

impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
    Standard: Distribution<N>, 
[src]

Creates a matrix filled with random values.

impl<N> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U2>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U3>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U4>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U5>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U6>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U3>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U4>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U5>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U6>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U2>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U4>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U5>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U6>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U2>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U3>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U5>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U6>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U2>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U3>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U4>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U6>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U2>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U3>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U4>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U5>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U2>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U3>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U4>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U5>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U6>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>, 
[src]

Initializes this matrix from its components.

impl<N> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>, 
[src]

Initializes this matrix from its components.

impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>> where
    C: DimName,
    N: Scalar,
    R: DimName, 
[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>> where
    C: DimName,
    N: Scalar,
    R: DimName, 
[src]

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>> where
    N: Scalar,
    R: DimName, 
[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>> where
    N: Scalar,
    R: DimName, 
[src]

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>> where
    C: DimName,
    N: Scalar, 
[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>> where
    C: DimName,
    N: Scalar, 
[src]

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, U1, Dynamic>> where
    N: Scalar, 
[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>> where
    N: Scalar, 
[src]

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>> where
    C: DimName,
    N: Scalar,
    R: DimName, 
[src]

Creates a new mutable matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice from the given data array.

impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>> where
    C: DimName,
    N: Scalar,
    R: DimName, 
[src]

Creates a new mutable matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.

impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>> where
    N: Scalar,
    R: DimName, 
[src]

Creates a new mutable matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice from the given data array.

impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>> where
    N: Scalar,
    R: DimName, 
[src]

Creates a new mutable matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.

impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>> where
    C: DimName,
    N: Scalar, 
[src]

Creates a new mutable matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice from the given data array.

impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>> where
    C: DimName,
    N: Scalar, 
[src]

Creates a new mutable matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.

impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, U1, Dynamic>> where
    N: Scalar, 
[src]

Creates a new mutable matrix slice from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice from the given data array.

impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>> where
    N: Scalar, 
[src]

Creates a new mutable matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.

impl<N, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Storage<N, R, C>, 
[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, R, C, S> Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: StorageMut<N, R, C>, 
[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, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

impl<N, D, S> Matrix<N, D, U1, S> where
    D: DimName,
    N: Scalar,
    S: Storage<N, D, U1>, 
[src]

Builds a new vector from components of self.

Trait Implementations

impl<T> AsMat<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Orthographic3<T> where
    T: Real, 
[src]

impl<T> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for [T; 3] where
    T: Scalar, 
[src]

impl<T> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for T where
    T: Scalar, 
[src]

impl<'a, T> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for &'a [T] where
    T: Scalar, 
[src]

impl<'a, T> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for &'a [T] where
    T: Scalar, 
[src]

impl<'a, T> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for &'a [T] where
    T: Scalar, 
[src]

impl<T> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for T where
    T: Scalar, 
[src]

impl<T> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for [T; 4] where
    T: Scalar, 
[src]

impl<T> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for T where
    T: Scalar, 
[src]

impl<T> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for [T; 2] where
    T: Scalar, 
[src]

impl<T> AsPnt<Point<T, U2>> for Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> AsPnt<Point<T, U6>> for Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> AsPnt<Point<T, U5>> for Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> AsPnt<Point<T, U3>> for Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> AsPnt<Point<T, U4>> for Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> AsPnt<Point<T, U1>> for Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> FastInverse for Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer> where
    T: Real, 
[src]

impl<T> ToMat<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Orthographic3<T> where
    T: Real, 
[src]

impl<T> AsVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point<T, U1> where
    T: Real, 
[src]

impl<T> AsVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point<T, U6> where
    T: Real, 
[src]

impl<T> AsVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point<T, U5> where
    T: Real, 
[src]

impl<T> AsVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point<T, U3> where
    T: Real, 
[src]

impl<T> AsVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point<T, U4> where
    T: Real, 
[src]

impl<T> AsVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point<T, U2> where
    T: Real, 
[src]

impl<T> ToPnt<Point<T, U1>> for Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> ToPnt<Point<T, U5>> for Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> ToPnt<Point<T, U4>> for Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> ToPnt<Point<T, U3>> for Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> ToPnt<Point<T, U6>> for Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> ToPnt<Point<T, U2>> for Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer> where
    T: Real, 
[src]

impl<N> NumVec<N> for Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where
    N: BaseNum, 
[src]

impl<N> NumVec<N> for Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where
    N: BaseNum, 
[src]

impl<N> NumVec<N> for Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer> where
    N: BaseNum, 
[src]

impl<N> NumVec<N> for Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer> where
    N: BaseNum, 
[src]

impl<N> NumVec<N> for Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer> where
    N: BaseNum, 
[src]

impl<N> NumVec<N> for Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer> where
    N: BaseNum, 
[src]

impl<T, S> JoinVec<T, Matrix<T, U2, U1, S>> for T where
    S: Storage<T, U2, U1>,
    T: BaseNum, 
[src]

impl<'a, T, S> JoinVec<T, T> for Matrix<T, U3, U1, S> where
    S: Storage<T, U3, U1>,
    T: BaseNum, 
[src]

impl<'a, T, S> JoinVec<T, T> for Matrix<T, U2, U1, S> where
    S: Storage<T, U2, U1>,
    T: BaseNum, 
[src]

impl<'a, T, S1, S2> JoinVec<T, Matrix<T, U2, U1, S2>> for Matrix<T, U1, U1, S1> where
    S1: Storage<T, U1, U1>,
    S2: Storage<T, U2, U1>,
    T: BaseNum, 
[src]

impl<'a, T, S> JoinVec<T, Matrix<T, U2, U1, S>> for Matrix<T, U2, U1, S> where
    S: Storage<T, U2, U1>,
    T: BaseNum, 
[src]

impl<'a, T, S1, S3> JoinVec<T, Matrix<T, U3, U1, S3>> for Matrix<T, U1, U1, S1> where
    S1: Storage<T, U1, U1>,
    S3: Storage<T, U3, U1>,
    T: BaseNum, 
[src]

impl<T, S> JoinVec<T, Matrix<T, U3, U1, S>> for T where
    S: Storage<T, U3, U1>,
    T: BaseNum, 
[src]

impl<'a, T, S> JoinVec<T, T> for Matrix<T, U1, U1, S> where
    S: Storage<T, U1, U1>,
    T: BaseNum, 
[src]

impl<T> FastMul<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer> where
    T: Real, 
[src]

impl<T> FastMul<Matrix<T, U2, U2, <DefaultAllocator as Allocator<T, U2, U2>>::Buffer>> for Matrix<T, U2, U2, <DefaultAllocator as Allocator<T, U2, U2>>::Buffer> where
    T: Real, 
[src]

impl<T> FastMul<Matrix<T, U3, U3, <DefaultAllocator as Allocator<T, U3, U3>>::Buffer>> for Matrix<T, U3, U3, <DefaultAllocator as Allocator<T, U3, U3>>::Buffer> where
    T: Real, 
[src]

impl<T> FastMul<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer> where
    T: Real, 
[src]

impl<T> FastMul<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Matrix<T, U2, U2, <DefaultAllocator as Allocator<T, U2, U2>>::Buffer> where
    T: Real, 
[src]

impl<T> FastMul<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Matrix<T, U3, U3, <DefaultAllocator as Allocator<T, U3, U3>>::Buffer> where
    T: Real, 
[src]

impl<T> ToVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point<T, U4> where
    T: Real, 
[src]

impl<T> ToVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point<T, U3> where
    T: Real, 
[src]

impl<T> ToVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point<T, U1> where
    T: Real, 
[src]

impl<T> ToVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point<T, U6> where
    T: Real, 
[src]

impl<T> ToVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point<T, U2> where
    T: Real, 
[src]

impl<T> ToVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point<T, U5> where
    T: Real, 
[src]

impl<T> FastDot<T> for Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> FastDot<T> for Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> FastDot<T> for Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> FastDot<T> for Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer> where
    T: Real, 
[src]

impl<T> FastDot<T> for Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer> where
    T: Real, 
[src]

impl<N> FloatVec<N> for Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where
    N: BaseNum + Real, 
[src]

impl<N> FloatVec<N> for Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer> where
    N: BaseNum + Real, 
[src]

impl<N> FloatVec<N> for Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where
    N: BaseNum + Real, 
[src]

impl<N> FloatVec<N> for Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer> where
    N: BaseNum + Real, 
[src]

impl<N> FloatVec<N> for Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer> where
    N: BaseNum + Real, 
[src]

impl<N> FloatVec<N> for Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer> where
    N: BaseNum + Real, 
[src]

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

The resulting type after applying the - operator.

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

The resulting type after applying the - operator.

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

The resulting type after applying the - operator.

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

The resulting type after applying 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
    C1: Dim,
    C2: Dim,
    N: Scalar + ClosedSub<N>,
    R1: Dim,
    R2: Dim,
    SA: Storage<N, R1, C1>,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R1, R2>,
    ShapeConstraint: SameNumberOfColumns<C1, C2>, 
[src]

The resulting type after applying the - operator.

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

The resulting type after applying 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
    C1: Dim,
    C2: Dim,
    N: Scalar + ClosedSub<N>,
    R1: Dim,
    R2: Dim,
    SA: Storage<N, R1, C1>,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
    ShapeConstraint: SameNumberOfRows<R2, R1>,
    ShapeConstraint: SameNumberOfColumns<C2, C1>, 
[src]

The resulting type after applying the - operator.

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

The resulting type after applying the - operator.

impl<N> From<[N; 9]> for Matrix<N, U1, U9, <DefaultAllocator as Allocator<N, U1, U9>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U9>, 
[src]

impl<N> From<[[N; 6]; 3]> for Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U3>, 
[src]

impl<N> From<[N; 1]> for Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>, 
[src]

impl<N> From<[N; 13]> for Matrix<N, U13, U1, <DefaultAllocator as Allocator<N, U13, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U13, U1>, 
[src]

impl<N> From<[[N; 6]; 5]> for Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U5>, 
[src]

impl<N> From<[[N; 2]; 2]> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U2>, 
[src]

impl<N> From<[[N; 4]; 4]> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U4>, 
[src]

impl<N> From<[N; 7]> for Matrix<N, U1, U7, <DefaultAllocator as Allocator<N, U1, U7>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U7>, 
[src]

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
    CStride: Dim,
    N: Scalar,
    R: DimName,
    RStride: Dim, 
[src]

impl<N> From<[N; 8]> for Matrix<N, U8, U1, <DefaultAllocator as Allocator<N, U8, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U8, U1>, 
[src]

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

impl<N> From<[N; 3]> for Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U3>, 
[src]

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
    C: Dim,
    CStride: Dim,
    N: Scalar,
    RStride: Dim, 
[src]

impl<N> From<Rotation<N, U3>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where
    N: Real, 
[src]

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

impl<N> From<Rotation<N, U3>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Real, 
[src]

impl<N> From<Rotation<N, U2>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Real, 
[src]

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

impl<N> From<[N; 6]> for Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U6>, 
[src]

impl<N> From<[N; 6]> for Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>, 
[src]

impl<N> From<[N; 7]> for Matrix<N, U7, U1, <DefaultAllocator as Allocator<N, U7, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U7, U1>, 
[src]

impl<N> From<Unit<Quaternion<N>>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Real, 
[src]

impl<N> From<[[N; 3]; 2]> for Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U2>, 
[src]

impl<N> From<[N; 16]> for Matrix<N, U1, U16, <DefaultAllocator as Allocator<N, U1, U16>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U16>, 
[src]

impl<N> From<[[N; 3]; 6]> for Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U6>, 
[src]

impl<N> From<[[N; 6]; 6]> for Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U6>, 
[src]

impl<N> From<[[N; 4]; 3]> for Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U3>, 
[src]

impl<N> From<[N; 9]> for Matrix<N, U9, U1, <DefaultAllocator as Allocator<N, U9, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U9, U1>, 
[src]

impl<N> From<[N; 5]> for Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U5>, 
[src]

impl<N, D, C> From<Transform<N, D, C>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> where
    C: TCategory,
    D: DimName + DimNameAdd<U1>,
    N: Real,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, 
[src]

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

impl<N> From<[[N; 6]; 4]> for Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U4>, 
[src]

impl<N> From<[N; 8]> for Matrix<N, U1, U8, <DefaultAllocator as Allocator<N, U1, U8>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U8>, 
[src]

impl<N> From<[[N; 5]; 3]> for Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U3>, 
[src]

impl<N> From<[N; 16]> for Matrix<N, U16, U1, <DefaultAllocator as Allocator<N, U16, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U16, U1>, 
[src]

impl<N> From<[[N; 4]; 6]> for Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U6>, 
[src]

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
    C: DimName,
    CStride: Dim,
    N: Scalar,
    R: DimName,
    RStride: Dim,
    <R as DimName>::Value: Mul<<C as DimName>::Value>,
    <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>, 
[src]

impl<N> From<[N; 12]> for Matrix<N, U12, U1, <DefaultAllocator as Allocator<N, U12, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U12, U1>, 
[src]

impl<N> From<[N; 15]> for Matrix<N, U15, U1, <DefaultAllocator as Allocator<N, U15, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U15, U1>, 
[src]

impl<N> From<[N; 4]> for Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>, 
[src]

impl<N> From<Rotation<N, U2>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where
    N: Real, 
[src]

impl<N> From<[N; 2]> for Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>, 
[src]

impl<N> From<[[N; 6]; 2]> for Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U2>, 
[src]

impl<N> From<[[N; 2]; 5]> for Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U5>, 
[src]

impl<N> From<[[N; 5]; 6]> for Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U6>, 
[src]

impl<N> From<[N; 11]> for Matrix<N, U1, U11, <DefaultAllocator as Allocator<N, U1, U11>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U11>, 
[src]

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
    C: Dim,
    CStride: Dim,
    N: Scalar,
    RStride: Dim, 
[src]

impl<N> From<[[N; 2]; 4]> for Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U4>, 
[src]

impl<N> From<[N; 10]> for Matrix<N, U10, U1, <DefaultAllocator as Allocator<N, U10, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U10, U1>, 
[src]

impl<N> From<[N; 3]> for Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

impl<N> From<[[N; 5]; 5]> for Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U5>, 
[src]

impl<N> From<Unit<Complex<N>>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Real, 
[src]

impl<N> From<[[N; 4]; 5]> for Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U5>, 
[src]

impl<N> From<[N; 14]> for Matrix<N, U14, U1, <DefaultAllocator as Allocator<N, U14, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U14, U1>, 
[src]

impl<N> From<[N; 12]> for Matrix<N, U1, U12, <DefaultAllocator as Allocator<N, U1, U12>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U12>, 
[src]

impl<N> From<[N; 11]> for Matrix<N, U11, U1, <DefaultAllocator as Allocator<N, U11, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U11, U1>, 
[src]

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
    CStride: Dim,
    N: Scalar,
    R: DimName,
    RStride: Dim, 
[src]

impl<N> From<[[N; 4]; 2]> for Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U2>, 
[src]

impl<N> From<[[N; 2]; 3]> for Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U3>, 
[src]

impl<N> From<[[N; 2]; 6]> for Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U6>, 
[src]

impl<N> From<[[N; 3]; 5]> for Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U5>, 
[src]

impl<N> From<[N; 15]> for Matrix<N, U1, U15, <DefaultAllocator as Allocator<N, U1, U15>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U15>, 
[src]

impl<N> From<[N; 5]> for Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>, 
[src]

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
    C: DimName,
    CStride: Dim,
    N: Scalar,
    R: DimName,
    RStride: Dim,
    <R as DimName>::Value: Mul<<C as DimName>::Value>,
    <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>, 
[src]

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

impl<N> From<[N; 13]> for Matrix<N, U1, U13, <DefaultAllocator as Allocator<N, U1, U13>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U13>, 
[src]

impl<N> From<Unit<Complex<N>>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where
    N: Real, 
[src]

impl<N, D, R> From<Similarity<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> where
    D: DimName + DimNameAdd<U1>,
    N: Real,
    R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, 
[src]

impl<N> From<[N; 4]> for Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U4>, 
[src]

impl<N> From<[[N; 5]; 2]> for Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U2>, 
[src]

impl<N, D, R> From<Isometry<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> where
    D: DimName + DimNameAdd<U1>,
    N: Real,
    R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

impl<N> From<[[N; 5]; 4]> for Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U4>, 
[src]

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

impl<N> From<[[N; 3]; 4]> for Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U4>, 
[src]

impl<N> From<[N; 14]> for Matrix<N, U1, U14, <DefaultAllocator as Allocator<N, U1, U14>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U14>, 
[src]

impl<N> From<[N; 2]> for Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U2>, 
[src]

impl<N> From<[[N; 3]; 3]> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U3>, 
[src]

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

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

impl<N> From<[N; 10]> for Matrix<N, U1, U10, <DefaultAllocator as Allocator<N, U1, U10>>::Buffer> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U10>, 
[src]

impl<N, R, C> Lattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: Dim,
    N: Scalar + Lattice,
    R: Dim,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

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

Sorts two values in increasing order using a partial ordering.

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

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

This method tests for !=.

impl<N, R, C> AbstractSemigroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + AbstractSemigroup<Additive> + ClosedAdd<N>,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

Returns true if associativity holds for the given arguments.

impl<N, D> AbstractSemigroup<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + AbstractSemigroup<Multiplicative>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

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

Returns true if associativity holds for the given arguments.

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

The inverse of ApproxEq::relative_eq.

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

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

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

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

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

impl<N, R, C> AbstractLoop<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + AbstractLoop<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

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

impl<N, R1, C1> MulAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
    C1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, C1, C1>, 
[src]

impl<'b, N, R1, C1> MulAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
    C1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, C1, C1>, 
[src]

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

impl<N, D> Transformation<Point<N, <D as DimNameSub<U1>>::Output>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimNameSub<U1>,
    N: Real,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>, 
[src]

impl<N, D> Product<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

impl<'a, N, D> Product<&'a Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

impl<'a, N, R, C> Sum<&'a Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + ClosedAdd<N> + Zero,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

impl<N, R, C> Sum<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + ClosedAdd<N> + Zero,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

The resulting type after applying the - operator.

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

The resulting type after applying the - operator.

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

Used for specifying relative comparisons.

The inverse of ApproxEq::abs_diff_eq.

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

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

impl<N, R, C> InnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Real,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

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

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

The returned type after indexing.

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

The returned type after indexing.

impl<N, S> Mul<Matrix<N, U2, U1, S>> for Unit<Complex<N>> where
    N: Real,
    S: Storage<N, U2, U1>,
    DefaultAllocator: Allocator<N, U2, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, S> Mul<Matrix<N, U2, U1, S>> for &'a Unit<Complex<N>> where
    N: Real,
    S: Storage<N, U2, U1>,
    DefaultAllocator: Allocator<N, U2, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<'b, N, SB> Mul<&'b Matrix<N, U3, U1, SB>> for Unit<Quaternion<N>> where
    N: Real,
    SB: Storage<N, U3, U1>,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where
    C2: Dim,
    D1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R2: Dim,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, D1>,
    DefaultAllocator: Allocator<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    ShapeConstraint: AreMultipliable<D1, D1, R2, C2>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where
    C2: Dim,
    D1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R2: Dim,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, D1>,
    DefaultAllocator: Allocator<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    ShapeConstraint: AreMultipliable<D1, D1, R2, C2>, 
[src]

The resulting type after applying the * operator.

impl<'b, N, S> Mul<&'b Matrix<N, U2, U1, S>> for Unit<Complex<N>> where
    N: Real,
    S: Storage<N, U2, U1>,
    DefaultAllocator: Allocator<N, U2, U1>, 
[src]

The resulting type after applying the * operator.

impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, SB> Mul<Matrix<N, U3, U1, SB>> for &'a Unit<Quaternion<N>> where
    N: Real,
    SB: Storage<N, U3, U1>,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, D, C> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<N, R1, C1, D2, SA> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the * operator.

impl<'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, S> Mul<&'b Matrix<N, U2, U1, S>> for &'a Unit<Complex<N>> where
    N: Real,
    S: Storage<N, U2, U1>,
    DefaultAllocator: Allocator<N, U2, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Rotation<N, D1> where
    C2: Dim,
    D1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R2: Dim,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, D1>,
    DefaultAllocator: Allocator<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    ShapeConstraint: AreMultipliable<D1, D1, R2, C2>, 
[src]

The resulting type after applying the * operator.

impl<N, D, C> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<N, SB> Mul<Matrix<N, U3, U1, SB>> for Unit<Quaternion<N>> where
    N: Real,
    SB: Storage<N, U3, U1>,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, D, C> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for Rotation<N, D1> where
    C2: Dim,
    D1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R2: Dim,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, D1>,
    DefaultAllocator: Allocator<N, R2, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    DefaultAllocator: Allocator<N, D1, C2>,
    ShapeConstraint: AreMultipliable<D1, D1, R2, C2>, 
[src]

The resulting type after applying the * operator.

impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, N, R1, C1, D2, SA> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 
[src]

The resulting type after applying the * operator.

impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R> where
    D: DimName,
    N: Real,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 
[src]

The resulting type after applying the * operator.

impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 
[src]

The resulting type after applying the * operator.

impl<'b, N, D, C> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<'a, 'b, N, SB> Mul<&'b Matrix<N, U3, U1, SB>> for &'a Unit<Quaternion<N>> where
    N: Real,
    SB: Storage<N, U3, U1>,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Translation<N1, D> where
    D: DimNameAdd<U1>,
    N1: Real,
    N2: Real + SupersetOf<N1>,
    DefaultAllocator: Allocator<N1, D, U1>,
    DefaultAllocator: Allocator<N2, D, U1>,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, 
[src]

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

impl<N1, N2, D, C> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Transform<N1, D, C> where
    C: TCategory,
    D: DimName + DimNameAdd<U1>,
    N1: Real + SubsetOf<N2>,
    N2: Real,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    <N1 as AbsDiffEq>::Epsilon: Copy,
    <N2 as AbsDiffEq>::Epsilon: Copy, 
[src]

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

impl<N1, N2> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for Unit<Quaternion<N1>> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 
[src]

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

impl<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Isometry<N1, D, R> where
    D: DimNameAdd<U1> + DimMin<D, Output = D>,
    N1: Real,
    N2: Real + SupersetOf<N1>,
    R: Rotation<Point<N1, D>> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
    DefaultAllocator: Allocator<N1, D, U1>,
    DefaultAllocator: Allocator<N1, D, D>,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<(usize, usize), D, U1>,
    DefaultAllocator: Allocator<N2, D, D>,
    DefaultAllocator: Allocator<N2, D, U1>, 
[src]

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

impl<N1, N2, R1, C1, R2, C2> SubsetOf<Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>> for Matrix<N1, R1, C1, <DefaultAllocator as Allocator<N1, R1, C1>>::Buffer> where
    C1: Dim,
    C2: Dim,
    N1: Scalar,
    N2: Scalar + SupersetOf<N1>,
    R1: Dim,
    R2: Dim,
    DefaultAllocator: Allocator<N2, R2, C2>,
    DefaultAllocator: Allocator<N1, R1, C1>,
    DefaultAllocator: SameShapeAllocator<N1, R1, C1, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R1, R2>,
    ShapeConstraint: SameNumberOfColumns<C1, C2>, 
[src]

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

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>> for Point<N1, D> where
    D: DimNameAdd<U1>,
    N1: Scalar,
    N2: Scalar + Zero + One + ClosedDiv<N2> + SupersetOf<N1>,
    DefaultAllocator: Allocator<N1, D, U1>,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N2, D, U1>, 
[src]

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

impl<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Similarity<N1, D, R> where
    D: DimNameAdd<U1> + DimMin<D, Output = D>,
    N1: Real,
    N2: Real + SupersetOf<N1>,
    R: Rotation<Point<N1, D>> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
    DefaultAllocator: Allocator<N1, D, U1>,
    DefaultAllocator: Allocator<N1, D, D>,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<(usize, usize), D, U1>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, D, D>,
    DefaultAllocator: Allocator<N2, D, U1>, 
[src]

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

impl<N1, N2> SubsetOf<Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>> for Unit<Complex<N1>> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 
[src]

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

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Rotation<N1, D> where
    D: DimNameAdd<U1> + DimMin<D, Output = D>,
    N1: Real,
    N2: Real + SupersetOf<N1>,
    DefaultAllocator: Allocator<N1, D, D>,
    DefaultAllocator: Allocator<N2, D, D>,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<(usize, usize), D, U1>, 
[src]

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

impl<N, R, C> Inverse<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + ClosedNeg,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

impl<N, R, C> AbstractModule<Additive, Additive, Multiplicative> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + RingCommutative,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

The underlying scalar field.

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

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

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

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

impl<N, R, C> Bounded for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + Bounded,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

impl<N, D> AbstractMonoid<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + AbstractMonoid<Multiplicative> + One,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

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

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

impl<N, R, C> AbstractMonoid<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + AbstractMonoid<Additive> + Zero + ClosedAdd<N>,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

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

impl<N, R, C> AbstractGroupAbelian<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + AbstractGroupAbelian<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

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

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

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

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

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

The resulting type after dereferencing.

impl<N, R, C> VectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + Field,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

The underlying scalar field.

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

Performs copy-assignment from source. Read more

impl<N, R, C> FiniteDimVectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + Field,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

impl<N, R, C> Identity<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + Zero,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

Specific identity.

impl<N, D> Identity<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Specific identity.

impl<N, R, RV, SV> Extend<Matrix<N, RV, U1, SV>> for MatrixVec<N, R, Dynamic> where
    N: Scalar,
    R: Dim,
    RV: Dim,
    SV: Storage<N, RV, U1>,
    ShapeConstraint: SameNumberOfRows<R, RV>, 
[src]

Extends the number of columns of the MatrixVec with vectors from the given iterator.

Panics

This function panics if the number of rows of each Vector yielded by the iterator is not equal to the number of rows of this MatrixVec.

impl<N, S> Extend<N> for Matrix<N, Dynamic, U1, S> where
    N: Scalar,
    S: Extend<N>, 
[src]

Extend the number of rows of the Vector with elements from a given iterator.

Extend the number of rows of a Vector with elements from the given iterator.

Example

let mut vector = DVector::from_vec(3, vec![0, 1, 2]);
vector.extend(vec![3, 4, 5]);
assert!(vector.eq(&DVector::from_vec(6, vec![0, 1, 2, 3, 4, 5])));

impl<N, R, S> Extend<N> for Matrix<N, R, Dynamic, S> where
    N: Scalar,
    R: Dim,
    S: Extend<N>, 
[src]

Extend the number of columns of the Matrix with elements from a given iterator.

Extend the number of columns of the Matrix with elements from the given iterator.

Example


let data = vec![0, 1, 2,      // column 1
                3, 4, 5];     // column 2

let mut matrix = DMatrix::from_vec(3, 2, data);

matrix.extend(vec![6, 7, 8]); // column 3

assert!(matrix.eq(&Matrix3::new(0, 3, 6,
                                1, 4, 7,
                                2, 5, 8)));

Panics

This function panics if the number of elements yielded by the given iterator is not a multiple of the number of rows of the Matrix.

let data = vec![0, 1, 2,  // column 1
                3, 4, 5]; // column 2

let mut matrix = DMatrix::from_vec(3, 2, data);

// The following panics because the vec length is not a multiple of 3.
matrix.extend(vec![6, 7, 8, 9]);

impl<N, R, S, RV, SV> Extend<Matrix<N, RV, U1, SV>> for Matrix<N, R, Dynamic, S> where
    N: Scalar,
    R: Dim,
    RV: Dim,
    S: Extend<Matrix<N, RV, U1, SV>>,
    SV: Storage<N, RV, U1>,
    ShapeConstraint: SameNumberOfRows<R, RV>, 
[src]

Extends the number of columns of a Matrix with Vectors from a given iterator.

Example


let data = vec![0, 1, 2,          // column 1
                3, 4, 5];         // column 2

let mut matrix = DMatrix::from_vec(3, 2, data);

matrix.extend(
  vec![Vector3::new(6,  7,  8),   // column 3
       Vector3::new(9, 10, 11)]); // column 4

assert!(matrix.eq(&Matrix3x4::new(0, 3, 6,  9,
                                  1, 4, 7, 10,
                                  2, 5, 8, 11)));

Panics

This function panics if the dimension of each Vector yielded by the given iterator is not equal to the number of rows of this Matrix.

let mut matrix =
  DMatrix::from_vec(3, 2,
                    vec![0, 1, 2,   // column 1
                         3, 4, 5]); // column 2

// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
  vec![Vector2::new(6,  7)]); // too few dimensions!
let mut matrix =
  DMatrix::from_vec(3, 2,
                    vec![0, 1, 2,   // column 1
                         3, 4, 5]); // column 2

// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
  vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!

impl<N, R, C> FiniteDimInnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Real,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

impl<N, R, C> Module for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + RingCommutative,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

The underlying scalar field.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<N, R, C> JoinSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: Dim,
    N: Scalar + JoinSemilattice,
    R: Dim,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<N, D> AbstractMagma<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Performs specific operation.

impl<N, R, C> AbstractMagma<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + ClosedAdd<N>,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

Performs specific operation.

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

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

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

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<N, R, C> AbstractQuasigroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + AbstractQuasigroup<Additive> + ClosedAdd<N> + ClosedNeg,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

Returns true if latin squareness holds for the given arguments.

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

impl<N, R, C> AbstractGroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + AbstractGroup<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

impl<N, R, C> Zero for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Scalar + Zero + ClosedAdd<N>,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

impl<'b, N, R1, C1> DivAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
    C1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, C1, C1>, 
[src]

impl<N, R1, C1> DivAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
    C1: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, C1, C1>, 
[src]

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

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

impl<'de, N, R, C, S> Deserialize<'de> for Matrix<N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: Deserialize<'de>, 
[src]

impl<N, D> One for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimName,
    N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, D>, 
[src]

Returns true if self is equal to the multiplicative identity. Read more

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

impl<'a, N, R1, C1, D2, SA> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the / operator.

impl<N, R1, C1, D2, SA> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the / operator.

impl<'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the / operator.

impl<'a, 'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: Dim,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    DefaultAllocator: Allocator<N, R1, D2>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, D2>, 
[src]

The resulting type after applying the / operator.

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

impl<N, R, C> NormedSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: DimName,
    N: Real,
    R: DimName,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

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

The resulting type after applying the + operator.

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

The resulting type after applying the + operator.

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

The resulting type after applying the + operator.

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

The resulting type after applying 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
    C1: Dim,
    C2: Dim,
    N: Scalar + ClosedAdd<N>,
    R1: Dim,
    R2: Dim,
    SA: Storage<N, R1, C1>,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
    ShapeConstraint: SameNumberOfRows<R2, R1>,
    ShapeConstraint: SameNumberOfColumns<C2, C1>, 
[src]

The resulting type after applying 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
    C1: Dim,
    C2: Dim,
    N: Scalar + ClosedAdd<N>,
    R1: Dim,
    R2: Dim,
    SA: Storage<N, R1, C1>,
    SB: Storage<N, R2, C2>,
    DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R1, R2>,
    ShapeConstraint: SameNumberOfColumns<C1, C2>, 
[src]

The resulting type after applying the + operator.

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

The resulting type after applying the + operator.

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

The resulting type after applying the + operator.

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

The inverse of ApproxEq::ulps_eq.

impl<N, R, C> MeetSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
    C: Dim,
    N: Scalar + MeetSemilattice,
    R: Dim,
    DefaultAllocator: Allocator<N, R, C>, 
[src]

impl ToSimpleVao<Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>, Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>> for Mesh<Vec2>
[src]

impl ToSimpleVao<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>, Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>> for Mesh<Vec3>
[src]

impl From<Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>> for Model
[src]

impl<'a> From<&'a Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>> for Model
[src]

Auto Trait Implementations

impl<N, R, C, S> Send for Matrix<N, R, C, S> where
    N: Send,
    S: Send, 

impl<N, R, C, S> Sync for Matrix<N, R, C, S> where
    N: Sync,
    S: Sync, 

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> ToString for T where
    T: Display + ?Sized, 
[src]

impl<T> ToOwned for T where
    T: Clone, 
[src]

impl<T> From for T
[src]

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized, 
[src]

impl<T> Any for T where
    T: 'static + ?Sized, 
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> BorrowMut for T where
    T: ?Sized, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[u32; 3]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[u32; 2]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[i32; 2]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[f32; 4]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[f32; 4]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[i32; 2]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[i32; 3]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[f32; 2]>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[u32; 4]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[u32; 4]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<u32> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[u32; 2]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[i32; 4]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[f32; 2]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[u32; 3]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[[f32; 4]; 4]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[[f32; 3]; 3]>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[f32; 3]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[u32; 2]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[[f32; 4]; 4]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<u32>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<i32> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[[f32; 3]; 3]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[i32; 4]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<i32>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[[f32; 3]; 3]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[f32; 3]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[i32; 2]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[f32; 3]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<[i32; 3]>,
    U: Deref<Target = T>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<[f32; 2]> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[f32; 9]>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[u32; 3]>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[[f32; 4]; 4]>, 
[src]

impl<T> AsUniform for T where
    T: AsRef<[i32; 3]>, 
[src]

impl<U, T> AsUniform for U where
    T: AsUniform<dyn AsRef<f32> + 'static>,
    U: Deref<Target = T>, 
[src]

impl<T> Any for T where
    T: Any, 
[src]

impl<T> SetParameter for T
[src]

Sets value as a parameter of self.

impl<T> DeserializeOwned for T where
    T: Deserialize<'de>, 
[src]

impl<V> IntoVec for V
[src]

impl<T> IntoPnt for T where
    T: Scalar, 
[src]

impl<T> IntoPnt for T where
    T: Scalar, 
[src]

impl<T> IntoPnt for T where
    T: Scalar, 
[src]

impl<V> IntoPnt for V
[src]

impl<T> Scalar for T where
    T: Copy + PartialEq<T> + Any + Debug, 
[src]

Tests if Self the same as the type T Read more

impl<T, Right> ClosedDiv for T where
    T: Div<Right, Output = T> + DivAssign<Right>, 
[src]

impl<SS, SP> SupersetOf for SP where
    SS: SubsetOf<SP>, 
[src]

impl<T, Right> ClosedSub for T where
    T: Sub<Right, Output = T> + SubAssign<Right>, 
[src]

impl<T, Right> ClosedMul for T where
    T: Mul<Right, Output = T> + MulAssign<Right>, 
[src]

impl<T> ClosedNeg for T where
    T: Neg<Output = T>, 
[src]

impl<T, Right> ClosedAdd for T where
    T: Add<Right, Output = T> + AddAssign<Right>, 
[src]

impl<R, E> Transformation for R where
    E: EuclideanSpace<Real = R>,
    R: Real,
    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,
    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
    <E as EuclideanSpace>::Coordinates: ClosedNeg, 
[src]

impl<T> MultiplicativeMonoid for T where
    T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One, 
[src]

impl<T> Same for T
[src]

Should always be Self

impl<T> Rand for T where
    Standard: Distribution<T>, 
[src]

impl<T> AdditiveMagma for T where
    T: AbstractMagma<Additive>, 
[src]

impl<T> AdditiveQuasigroup for T where
    T: AbstractQuasigroup<Additive> + ClosedSub<T> + AdditiveMagma, 
[src]

impl<T> AdditiveLoop for T where
    T: AbstractLoop<Additive> + ClosedNeg + AdditiveQuasigroup + Zero, 
[src]

impl<T> AdditiveSemigroup for T where
    T: AbstractSemigroup<Additive> + ClosedAdd<T> + AdditiveMagma, 
[src]

impl<T> AdditiveMonoid for T where
    T: AbstractMonoid<Additive> + AdditiveSemigroup + Zero, 
[src]

impl<T> AdditiveGroup for T where
    T: AbstractGroup<Additive> + AdditiveLoop + AdditiveMonoid, 
[src]

impl<T> AdditiveGroupAbelian for T where
    T: AbstractGroupAbelian<Additive> + AdditiveGroup, 
[src]

impl<T> MultiplicativeMagma for T where
    T: AbstractMagma<Multiplicative>, 
[src]

impl<T> MultiplicativeSemigroup for T where
    T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma, 
[src]