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

#[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.

Methods summary

Because Matrix is the most generic types used as a common representation of all matrices and vectors of nalgebra this documentation page contains every single matrix/vector-related method. In order to make browsing this page simpler, the next subsections contain direct links to groups of methods related to a specific topic.

Type parameters

The generic Matrix type has four type parameters:

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

The matrix dimensions parameters R and C can either be:

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

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

Fields

data: S

The data storage that contains all the matrix components. Disappointed?

Well, if you came here to see how you can access the matrix components, you may be in luck: you can access the individual components of all vectors with compile-time dimensions <= 6 using field notation like this: vec.x, vec.y, vec.z, vec.w, vec.a, vec.b. Reference and assignation work too:

let mut vec = Vector3::new(1.0, 2.0, 3.0);
vec.x = 10.0;
vec.y += 30.0;
assert_eq!(vec.x, 10.0);
assert_eq!(vec.y + 100.0, 132.0);

Similarly, for matrices with compile-time dimensions <= 6, you can use field notation like this: mat.m11, mat.m42, etc. The first digit identifies the row to address and the second digit identifies the column to address. So mat.m13 identifies the component at the first row and third column (note that the count of rows and columns start at 1 instead of 0 here. This is so we match the mathematical notation).

For all matrices and vectors, independently from their size, individual components can be accessed and modified using indexing: vec[20], mat[(20, 19)]. Here the indexing starts at 0 as you would expect.

Implementations

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

Dot/scalar product

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

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

This is equal to self.transpose() * rhs. For the sesquilinear complex dot product, use self.dotc(rhs).

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);

`pub fn dotc<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where N: SimdComplexField, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, ShapeConstraint: DimEq<R, R2>, ShapeConstraint: DimEq<C, C2>,` [src]

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

This is equal to self.adjoint() * rhs. For real vectors, this is identical to self.dot(&rhs). 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 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.4, 0.3), Complex::new(0.2, 0.1));
assert_eq!(vec1.dotc(&vec2), Complex::new(2.0, -1.0));

// Note that for complex vectors, we generally have:
// vec1.dotc(&vec2) != vec2.dot(&vec2)
assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2));

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

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 N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>, D: Dim, S: StorageMut<N, D, U1>,` [src]

BLAS functions

`pub fn axcpy<D2, SB>(&mut self, a: N, x: &Matrix<N, D2, U1, SB>, c: N, b: N) where D2: Dim, SB: Storage<N, D2, U1>, ShapeConstraint: DimEq<D, D2>,` [src]

Computes self = a * x * c + b * self.

If b 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.axcpy(5.0, &vec2, 2.0, 5.0);
assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));

`pub fn axpy<D2, SB>(&mut self, a: N, x: &Matrix<N, D2, U1, SB>, b: N) where N: One, D2: Dim, SB: Storage<N, D2, U1>, ShapeConstraint: DimEq<D, D2>,` [src]

Computes self = a * x + b * self.

If b 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));

`pub fn gemv<R2, C2, D3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, x: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<D, R2>, ShapeConstraint: AreMultipliable<R2, C2, D3, U1>,` [src]

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));

`pub fn gemv_symm<D2, D3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, D2, D2, SB>, x: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, D2: Dim, SB: Storage<N, D2, D2>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<D, D2>, ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,` [src]

👎 Deprecated:

This is renamed sygemv to match the original BLAS terminology.

Computes self = alpha * a * x + beta * self, where a is a symmetric matrix, x a vector, and alpha, beta two scalars. DEPRECATED: use sygemv instead.

`pub fn sygemv<D2, D3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, D2, D2, SB>, x: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, D2: Dim, SB: Storage<N, D2, D2>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<D, D2>, ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,` [src]

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

For hermitian matrices, use .hegemv instead. 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.sygemv(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.sygemv(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 20.0));

`pub fn hegemv<D2, D3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, D2, D2, SB>, x: &Matrix<N, D3, U1, SC>, beta: N ) where N: SimdComplexField, D2: Dim, SB: Storage<N, D2, D2>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<D, D2>, ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,` [src]

Computes self = alpha * a * x + beta * self, where a is an hermitian 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(Complex::new(1.0, 0.0), Complex::new(2.0, -0.1),
                       Complex::new(2.0, 1.0), Complex::new(4.0, 0.0));
let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.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(Complex::new(1.0, 0.0), Complex::new(99999999.9, 999999999.9),
                       Complex::new(2.0, 1.0), Complex::new(4.0, 0.0));
let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0)));

`pub fn gemv_tr<R2, C2, D3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, x: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<D, C2>, ShapeConstraint: AreMultipliable<C2, R2, D3, U1>,` [src]

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);

`pub fn gemv_ad<R2, C2, D3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, x: &Matrix<N, D3, U1, SC>, beta: N ) where N: SimdComplexField, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<D, C2>, ShapeConstraint: AreMultipliable<C2, R2, D3, U1>,` [src]

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

For real matrices, this is the same as .gemv_tr. If beta is zero, self is never read.

Examples:

let mat = Matrix2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0),
                       Complex::new(5.0, 6.0), Complex::new(7.0, 8.0));
let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
let expected = mat.adjoint() * vec2 * Complex::new(10.0, 20.0) + vec1 * Complex::new(5.0, 15.0);

vec1.gemv_ad(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
assert_eq!(vec1, expected);

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

`pub fn ger<D2, D3, SB, SC>( &mut self, alpha: N, x: &Matrix<N, D2, U1, SB>, y: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, D2: Dim, SB: Storage<N, D2, U1>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<R1, D2>, ShapeConstraint: DimEq<C1, D3>,` [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);

`pub fn gerc<D2, D3, SB, SC>( &mut self, alpha: N, x: &Matrix<N, D2, U1, SB>, y: &Matrix<N, D3, U1, SC>, beta: N ) where N: SimdComplexField, D2: Dim, SB: Storage<N, D2, U1>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<R1, D2>, ShapeConstraint: DimEq<C1, D3>,` [src]

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

If beta is zero, self is never read.

Examples:

let mut mat = Matrix2x3::repeat(Complex::new(4.0, 5.0));
let vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector3::new(Complex::new(0.6, 0.5), Complex::new(0.4, 0.5), Complex::new(0.2, 0.1));
let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0);

mat.gerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0));
assert_eq!(mat, expected);

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

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);

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

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_eq!(mat1, expected);

`pub fn gemm_ad<R2, C2, R3, C3, SB, SC>( &mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, b: &Matrix<N, R3, C3, SC>, beta: N ) where N: SimdComplexField, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SC: Storage<N, R3, C3>, R3: Dim, C3: Dim, ShapeConstraint: SameNumberOfRows<R1, C2>, ShapeConstraint: SameNumberOfColumns<C1, C3>, ShapeConstraint: AreMultipliable<C2, R2, R3, C3>,` [src]

Computes self = alpha * a.adjoint() * 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(Complex::new(1.0, 4.0), Complex::new(7.0, 8.0),
                          Complex::new(2.0, 5.0), Complex::new(9.0, 10.0),
                          Complex::new(3.0, 6.0), Complex::new(11.0, 12.0));
let mat3 = Matrix3x4::new(Complex::new(0.1, 1.3), Complex::new(0.2, 1.4), Complex::new(0.3, 1.5), Complex::new(0.4, 1.6),
                          Complex::new(0.5, 1.7), Complex::new(0.6, 1.8), Complex::new(0.7, 1.9), Complex::new(0.8, 2.0),
                          Complex::new(0.9, 2.1), Complex::new(1.0, 2.2), Complex::new(1.1, 2.3), Complex::new(1.2, 2.4));
let expected = mat2.adjoint() * mat3 * Complex::new(10.0, 20.0) + mat1 * Complex::new(5.0, 15.0);

mat1.gemm_ad(Complex::new(10.0, 20.0), &mat2, &mat3, Complex::new(5.0, 15.0));
assert_eq!(mat1, expected);

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

`pub fn ger_symm<D2, D3, SB, SC>( &mut self, alpha: N, x: &Matrix<N, D2, U1, SB>, y: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, D2: Dim, SB: Storage<N, D2, U1>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<R1, D2>, ShapeConstraint: DimEq<C1, D3>,` [src]

👎 Deprecated:

This is renamed syger to match the original BLAS terminology.

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.

`pub fn syger<D2, D3, SB, SC>( &mut self, alpha: N, x: &Matrix<N, D2, U1, SB>, y: &Matrix<N, D3, U1, SC>, beta: N ) where N: One, D2: Dim, SB: Storage<N, D2, U1>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<R1, D2>, ShapeConstraint: DimEq<C1, D3>,` [src]

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

For hermitian complex matrices, use .hegerc instead. 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.syger(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, 99999.99999); // This was untouched.

`pub fn hegerc<D2, D3, SB, SC>( &mut self, alpha: N, x: &Matrix<N, D2, U1, SB>, y: &Matrix<N, D3, U1, SC>, beta: N ) where N: SimdComplexField, D2: Dim, SB: Storage<N, D2, U1>, D3: Dim, SC: Storage<N, D3, U1>, ShapeConstraint: DimEq<R1, D2>, ShapeConstraint: DimEq<C1, D3>,` [src]

Computes self = alpha * x * y.adjoint() + beta * self, where self is an hermitian 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(Complex::new(1.0, 3.0), Complex::new(2.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.2, 0.4), Complex::new(0.1, 0.3));
let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0);
mat.m12 = Complex::new(99999.99999, 88888.88888); // This component is on the upper-triangular part and will not be read/written.

mat.hegerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0));
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, Complex::new(99999.99999, 88888.88888)); // This was untouched.

`impl<N, D1, S> Matrix<N, D1, D1, S> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, S: StorageMut<N, D1, D1>, D1: Dim,` [src]

pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>( &mut self, work: &mut Matrix<N, D2, U1, S2>, alpha: N, lhs: &Matrix<N, R3, C3, S3>, mid: &Matrix<N, D4, D4, S4>, beta: N ) where D2: Dim, R3: Dim, C3: Dim, S2: StorageMut<N, D2, U1>, S3: Storage<N, R3, C3>, D4: Dim, S4: Storage<N, D4, D4>, ShapeConstraint: DimEq<D1, D2>, ShapeConstraint: DimEq<D1, R3>, ShapeConstraint: DimEq<D2, R3>, ShapeConstraint: DimEq<C3, D4>, [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);

`pub fn quadform_tr<R3, C3, S3, D4, S4>( &mut self, alpha: N, lhs: &Matrix<N, R3, C3, S3>, mid: &Matrix<N, D4, D4, S4>, beta: N ) where R3: Dim, C3: Dim, S3: Storage<N, R3, C3>, D4: Dim, S4: Storage<N, D4, D4>, ShapeConstraint: DimEq<D1, D1>, ShapeConstraint: DimEq<D1, R3>, ShapeConstraint: DimEq<C3, D4>, DefaultAllocator: Allocator<N, D1, U1>,` [src]

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);

pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>( &mut self, work: &mut Matrix<N, D2, U1, S2>, alpha: N, mid: &Matrix<N, D3, D3, S3>, rhs: &Matrix<N, R4, C4, S4>, beta: N ) where D2: Dim, D3: Dim, S2: StorageMut<N, D2, U1>, S3: Storage<N, D3, D3>, S4: Storage<N, R4, C4>, R4: Dim, C4: Dim, ShapeConstraint: DimEq<D3, R4>, ShapeConstraint: DimEq<D1, C4>, ShapeConstraint: DimEq<D2, D3>, ShapeConstraint: AreMultipliable<C4, R4, D2, U1>, [src]

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);

`pub fn quadform<D2, S2, R3, C3, S3>( &mut self, alpha: N, mid: &Matrix<N, D2, D2, S2>, rhs: &Matrix<N, R3, C3, S3>, beta: N ) where D2: Dim, R3: Dim, C3: Dim, S2: Storage<N, D2, D2>, S3: Storage<N, R3, C3>, ShapeConstraint: DimEq<D2, R3>, ShapeConstraint: DimEq<D1, C3>, ShapeConstraint: AreMultipliable<C3, R3, D2, U1>, DefaultAllocator: Allocator<N, D2, U1>,` [src]

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]

`pub fn neg_mut(&mut self)`[src]

Negates self in-place.

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

Special multiplications.

`pub fn tr_mul<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>,` [src]

Equivalent to self.transpose() * rhs.

`pub fn ad_mul<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where N: SimdComplexField, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>,` [src]

Equivalent to self.adjoint() * rhs.

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

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

`pub fn ad_mul_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<N, R2, C2, SB>, out: &mut Matrix<N, R3, C3, SC> ) where N: SimdComplexField, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SC: StorageMut<N, R3, C3>, R3: Dim, C3: Dim, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: DimEq<C1, R3>, ShapeConstraint: DimEq<C2, C3>,` [src]

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

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

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

`pub fn kronecker<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> Matrix<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer> where N: ClosedMul<N>, C2: Dim, C1: DimMul<C2>, R1: DimMul<R2>, R2: Dim, SB: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,` [src]

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

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

Translation and scaling in any dimension

`pub fn new_scaling( scaling: N ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

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

`pub fn new_nonuniform_scaling<SB>( scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

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

`pub fn new_translation<SB>( translation: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

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

2D transformations as a Matrix3

`pub fn new_rotation( angle: N ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

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

`pub fn new_nonuniform_scaling_wrt_point( scaling: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>, pt: &Point<N, U2> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

Creates a new homogeneous matrix that applies a scaling factor for each dimension with respect to point.

Can be used to implement “zoom_to” functionality.

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

3D transformations as a Matrix4

`pub fn new_rotation( axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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.

`pub fn new_rotation_wrt_point( axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>, pt: Point<N, U3> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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.

`pub fn new_nonuniform_scaling_wrt_point( scaling: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>, pt: &Point<N, U3> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

Creates a new homogeneous matrix that applies a scaling factor for each dimension with respect to point.

Can be used to implement “zoom_to” functionality.

`pub fn from_scaled_axis( axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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. This is identical to Self::new_rotation.

`pub fn from_euler_angles( roll: N, pitch: N, yaw: N ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

Creates a new rotation from Euler angles.

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

`pub fn from_axis_angle( axis: &Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>, angle: N ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

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

`pub fn new_orthographic( left: N, right: N, bottom: N, top: N, znear: N, zfar: N ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

Creates a new homogeneous matrix for an orthographic projection.

`pub fn new_perspective( aspect: N, fovy: N, znear: N, zfar: N ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

Creates a new homogeneous matrix for a perspective projection.

`pub fn face_towards( eye: &Point<N, U3>, target: &Point<N, U3>, up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

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.

`pub fn new_observer_frame( eye: &Point<N, U3>, target: &Point<N, U3>, up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

👎 Deprecated:

renamed to face_towards

Deprecated: Use [Matrix4::face_towards] instead.

`pub fn look_at_rh( eye: &Point<N, U3>, target: &Point<N, U3>, up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

Builds a right-handed look-at view matrix.

`pub fn look_at_lh( eye: &Point<N, U3>, target: &Point<N, U3>, up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

Builds a left-handed look-at view matrix.

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

Append/prepend translation and scaling

`#[must_use = "Did you mean to use append_scaling_mut()?"] pub fn append_scaling( &self, scaling: N ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

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

`#[must_use = "Did you mean to use prepend_scaling_mut()?"] pub fn prepend_scaling( &self, scaling: N ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

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

`#[must_use = "Did you mean to use append_nonuniform_scaling_mut()?"] pub fn append_nonuniform_scaling<SB>( &self, scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

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

`#[must_use = "Did you mean to use prepend_nonuniform_scaling_mut()?"] pub fn prepend_nonuniform_scaling<SB>( &self, scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

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

`#[must_use = "Did you mean to use append_translation_mut()?"] pub fn append_translation<SB>( &self, shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

Computes the transformation equal to self followed by a translation.

`#[must_use = "Did you mean to use prepend_translation_mut()?"] pub fn prepend_translation<SB>( &self, shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where D: DimNameSub<U1>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

Computes the transformation equal to a translation followed by self.

`pub fn append_scaling_mut(&mut self, scaling: N) where D: DimNameSub<U1>, S: StorageMut<N, D, D>,` [src]

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

`pub fn prepend_scaling_mut(&mut self, scaling: N) where D: DimNameSub<U1>, S: StorageMut<N, D, D>,` [src]

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

`pub fn append_nonuniform_scaling_mut<SB>( &mut self, scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) where D: DimNameSub<U1>, S: StorageMut<N, D, D>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

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

`pub fn prepend_nonuniform_scaling_mut<SB>( &mut self, scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) where D: DimNameSub<U1>, S: StorageMut<N, D, D>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

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

`pub fn append_translation_mut<SB>( &mut self, shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) where D: DimNameSub<U1>, S: StorageMut<N, D, D>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

Computes the transformation equal to self followed by a translation.

`pub fn prepend_translation_mut<SB>( &mut self, shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB> ) where D: DimNameSub<U1>, S: StorageMut<N, D, D>, SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>, DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,` [src]

Computes the transformation equal to a translation followed by self.

`impl<N, D, S> Matrix<N, D, D, S> where N: RealField, D: DimNameSub<U1>, 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]

Transformation of vectors and points

`pub fn transform_vector( &self, v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer> ) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>`[src]

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

`pub fn transform_point( &self, pt: &Point<N, <D as DimNameSub<U1>>::Output> ) -> Point<N, <D as DimNameSub<U1>>::Output>`[src]

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]

`pub fn abs( &self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Signed, DefaultAllocator: Allocator<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, R1, C1, SA> Matrix<N, R1, C1, SA> where N: Scalar, C1: Dim, R1: Dim, SA: Storage<N, R1, C1>,` [src]

Componentwise operations

pub fn component_mul<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where N: ClosedMul<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>, [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);

pub fn cmpy<R2, C2, SB, R3, C3, SC>( &mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, b: &Matrix<N, R3, C3, SC>, beta: N ) where N: ClosedMul<N, Output = N> + Zero<Output = N> + Mul<N> + Add<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SC: Storage<N, R3, C3>, R3: Dim, C3: Dim, SA: StorageMut<N, R1, C1>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R3>, ShapeConstraint: SameNumberOfColumns<C1, C3>, [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);

`pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where N: ClosedMul<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SA: StorageMut<N, R1, C1>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>,` [src]

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);

`pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where N: ClosedMul<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SA: StorageMut<N, R1, C1>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>,` [src]

👎 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);

pub fn component_div<R2, C2, SB>( &self, rhs: &Matrix<N, R2, C2, SB> ) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where N: ClosedDiv<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>, [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);

pub fn cdpy<R2, C2, SB, R3, C3, SC>( &mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, b: &Matrix<N, R3, C3, SC>, beta: N ) where N: ClosedDiv<N> + Zero<Output = N> + Mul<N, Output = N> + Add<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SC: Storage<N, R3, C3>, R3: Dim, C3: Dim, SA: StorageMut<N, R1, C1>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R3>, ShapeConstraint: SameNumberOfColumns<C1, C3>, [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);

`pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where N: ClosedDiv<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SA: StorageMut<N, R1, C1>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>,` [src]

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);

`pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where N: ClosedDiv<N>, C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SA: StorageMut<N, R1, C1>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>,` [src]

👎 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);

`pub fn inf( &self, other: &Matrix<N, R1, C1, SA> ) -> Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where N: SimdPartialOrd, DefaultAllocator: Allocator<N, R1, C1>,` [src]

Computes the infimum (aka. componentwise min) of two matrices/vectors.

`pub fn sup( &self, other: &Matrix<N, R1, C1, SA> ) -> Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where N: SimdPartialOrd, DefaultAllocator: Allocator<N, R1, C1>,` [src]

Computes the supremum (aka. componentwise max) of two matrices/vectors.

`pub fn inf_sup( &self, other: &Matrix<N, R1, C1, SA> ) -> (Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>, Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>) where N: SimdPartialOrd, DefaultAllocator: Allocator<N, R1, C1>,` [src]

Computes the (infimum, supremum) of two matrices/vectors.

`#[must_use = "Did you mean to use add_scalar_mut()?"] pub fn add_scalar( &self, rhs: N ) -> Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where N: ClosedAdd<N>, DefaultAllocator: Allocator<N, R1, C1>,` [src]

Adds a scalar to self.

`pub fn add_scalar_mut(&mut self, rhs: N) where N: ClosedAdd<N>, SA: StorageMut<N, R1, C1>,` [src]

Adds a scalar to self in-place.

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

Generic constructors

This set of matrix and vector construction functions are all generic with-regard to the matrix dimensions. They all expect to be given the dimension as inputs.

These functions should only be used when working on dimension-generic code.

`pub unsafe fn new_uninitialized_generic( nrows: R, ncols: C ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[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().

`pub fn from_element_generic( nrows: R, ncols: C, elem: N ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

Creates a matrix with all its elements set to elem.

`pub fn repeat_generic( nrows: R, ncols: C, elem: N ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

Creates a matrix with all its elements set to elem.

Same as from_element_generic.

`pub fn zeros_generic( nrows: R, ncols: C ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero,` [src]

Creates a matrix with all its elements set to 0.

`pub fn from_iterator_generic( nrows: R, ncols: C, iter: I ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where I: IntoIterator<Item = N>,` [src]

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

`pub fn from_row_slice_generic( nrows: R, ncols: C, slice: &[N] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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.

`pub fn from_column_slice_generic( nrows: R, ncols: C, slice: &[N] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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

`pub fn from_fn_generic<F>( nrows: R, ncols: C, f: F ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where F: FnMut(usize, usize) -> N,` [src]

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

`pub fn identity_generic( nrows: R, ncols: C ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero + One,` [src]

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.

`pub fn from_diagonal_element_generic( nrows: R, ncols: C, elt: N ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero + One,` [src]

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.

`pub fn from_partial_diagonal_generic( nrows: R, ncols: C, elts: &[N] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero,` [src]

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.

`pub fn from_rows<SB>( rows: &[Matrix<N, U1, C, SB>] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where SB: Storage<N, U1, C>,` [src]

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);

`pub fn from_columns<SB>( columns: &[Matrix<N, R, U1, SB>] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where SB: Storage<N, R, U1>,` [src]

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);

`pub fn new_random_generic( nrows: R, ncols: C ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where Standard: Distribution<N>,` [src]

Creates a matrix filled with random values.

`pub fn from_distribution_generic<Distr, G>( nrows: R, ncols: C, distribution: &Distr, rng: &mut G ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where G: Rng + ?Sized, Distr: Distribution<N> + ?Sized,` [src]

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

`pub fn from_vec_generic( nrows: R, ncols: C, data: Vec<N, Global> ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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_vec().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 N: Scalar, D: Dim, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn from_diagonal<SB>( diag: &Matrix<N, D, U1, SB> ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where N: Zero, SB: Storage<N, D, U1>,` [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(&[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, 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]

Constructors of statically-sized vectors or statically-sized matrices

`pub unsafe fn new_uninitialized( ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

Creates a new uninitialized matrix or vector.

`pub fn from_element( elem: N ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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);

`pub fn repeat( elem: N ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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);

`pub fn zeros( ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_iterator( iter: I ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where I: IntoIterator<Item = N>,` [src]

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);

`pub fn from_fn<F>( f: F ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where F: FnMut(usize, usize) -> N,` [src]

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);

`pub fn identity( ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_diagonal_element( elt: N ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_partial_diagonal( elts: &[N] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_distribution<Distr, G>( distribution: &Distr, rng: &mut G ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where G: Rng + ?Sized, Distr: Distribution<N> + ?Sized,` [src]

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

`pub fn new_random( ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where 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]

Constructors of matrices with a dynamic number of columns

`pub unsafe fn new_uninitialized( ncols: usize ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>`[src]

Creates a new uninitialized matrix or vector.

`pub fn from_element( ncols: usize, elem: N ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>`[src]

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);

`pub fn repeat( ncols: usize, elem: N ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>`[src]

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);

`pub fn zeros( ncols: usize ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_iterator( ncols: usize, iter: I ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where I: IntoIterator<Item = N>,` [src]

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);

`pub fn from_fn<F>( ncols: usize, f: F ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where F: FnMut(usize, usize) -> N,` [src]

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);

`pub fn identity( ncols: usize ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_diagonal_element( ncols: usize, elt: N ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_partial_diagonal( ncols: usize, elts: &[N] ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_distribution<Distr, G>( ncols: usize, distribution: &Distr, rng: &mut G ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where G: Rng + ?Sized, Distr: Distribution<N> + ?Sized,` [src]

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

`pub fn new_random( ncols: usize ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where 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]

Constructors of dynamic vectors and matrices with a dynamic number of rows

`pub unsafe fn new_uninitialized( nrows: usize ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>`[src]

Creates a new uninitialized matrix or vector.

`pub fn from_element( nrows: usize, elem: N ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>`[src]

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);

`pub fn repeat( nrows: usize, elem: N ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>`[src]

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);

`pub fn zeros( nrows: usize ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_iterator( nrows: usize, iter: I ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where I: IntoIterator<Item = N>,` [src]

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);

`pub fn from_fn<F>( nrows: usize, f: F ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where F: FnMut(usize, usize) -> N,` [src]

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);

`pub fn identity( nrows: usize ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_diagonal_element( nrows: usize, elt: N ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_partial_diagonal( nrows: usize, elts: &[N] ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_distribution<Distr, G>( nrows: usize, distribution: &Distr, rng: &mut G ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where G: Rng + ?Sized, Distr: Distribution<N> + ?Sized,` [src]

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

`pub fn new_random( nrows: usize ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where 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]

Constructors of fully dynamic matrices

`pub unsafe fn new_uninitialized( nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>`[src]

Creates a new uninitialized matrix or vector.

`pub fn from_element( nrows: usize, ncols: usize, elem: N ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>`[src]

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);

`pub fn repeat( nrows: usize, ncols: usize, elem: N ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>`[src]

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);

`pub fn zeros( nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_iterator( nrows: usize, ncols: usize, iter: I ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where I: IntoIterator<Item = N>,` [src]

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);

`pub fn from_fn<F>( nrows: usize, ncols: usize, f: F ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where F: FnMut(usize, usize) -> N,` [src]

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);

`pub fn identity( nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_diagonal_element( nrows: usize, ncols: usize, elt: N ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where N: Zero + One,` [src]

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);

`pub fn from_partial_diagonal( nrows: usize, ncols: usize, elts: &[N] ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where N: Zero,` [src]

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);

`pub fn from_distribution<Distr, G>( nrows: usize, ncols: usize, distribution: &Distr, rng: &mut G ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where G: Rng + ?Sized, Distr: Distribution<N> + ?Sized,` [src]

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

`pub fn new_random( nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where Standard: Distribution<N>,` [src]

Creates a matrix filled with random values.

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

`pub fn ith( i: usize, val: N ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>`[src]

The column vector with val as its i-th component.

`pub fn ith_axis( i: usize ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>`[src]

The column unit vector with N::one() as its i-th component.

`pub fn x( ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where <R as DimName>::Value: Cmp<UTerm>, <<R as DimName>::Value as Cmp<UTerm>>::Output == Greater,` [src]

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

`pub fn y( ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where <R as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<R as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

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

`pub fn z( ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where <R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

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

`pub fn w( ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where <R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>>, <<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B1>>>::Output == Greater,` [src]

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

`pub fn a( ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where <R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, <<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output == Greater,` [src]

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

`pub fn b( ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where <R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>, <<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>>::Output == Greater,` [src]

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

`pub fn x_axis( ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where <R as DimName>::Value: Cmp<UTerm>, <<R as DimName>::Value as Cmp<UTerm>>::Output == Greater,` [src]

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

`pub fn y_axis( ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where <R as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<R as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

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

`pub fn z_axis( ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where <R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

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

`pub fn w_axis( ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where <R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>>, <<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B1>>>::Output == Greater,` [src]

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

`pub fn a_axis( ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where <R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, <<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output == Greater,` [src]

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

`pub fn b_axis( ) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where <R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>, <<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>>::Output == Greater,` [src]

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

Creating matrix slices from `&[T]`

`pub unsafe fn from_slice_with_strides_generic_unchecked( data: &'a [N], start: usize, nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>`[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().

`pub fn from_slice_with_strides_generic( data: &'a [N], nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>`[src]

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> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>> where C: Dim, N: Scalar, R: Dim,` [src]

`pub unsafe fn from_slice_generic_unchecked( data: &'a [N], start: usize, nrows: R, ncols: C ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>`[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().

`pub fn from_slice_generic( data: &'a [N], nrows: R, ncols: C ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>`[src]

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, RStride, CStride> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>> where C: Dim, N: Scalar, R: Dim, RStride: Dim, CStride: Dim,` [src]

Creating mutable matrix slices from `&mut [T]`

`pub unsafe fn from_slice_with_strides_generic_unchecked( data: &'a mut [N], start: usize, nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>`[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().

`pub fn from_slice_with_strides_generic( data: &'a mut [N], nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>`[src]

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, SliceStorageMut<'a, N, R, C, U1, R>> where C: Dim, N: Scalar, R: Dim,` [src]

`pub unsafe fn from_slice_generic_unchecked( data: &'a mut [N], start: usize, nrows: R, ncols: C ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>`[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().

`pub fn from_slice_generic( data: &'a mut [N], nrows: R, ncols: C ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>`[src]

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]

Rows and columns extraction

`pub fn upper_triangle( &self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

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

`pub fn lower_triangle( &self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

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

`pub fn select_rows<'a, I>( &self, irows: I ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where I: IntoIterator<Item = &'a usize>, ::IntoIter: ExactSizeIterator, ::IntoIter: Clone, DefaultAllocator: Allocator<N, Dynamic, C>,` [src]

Creates a new matrix by extracting the given set of rows from self.

`pub fn select_columns<'a, I>( &self, icols: I ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where I: IntoIterator<Item = &'a usize>, ::IntoIter: ExactSizeIterator, DefaultAllocator: Allocator<N, R, Dynamic>,` [src]

Creates a new matrix by extracting the given set of columns from self.

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

Set rows, columns, and diagonal

`pub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<N, R2, U1, S2>) where R: DimMin<C>, R2: Dim, S2: Storage<N, R2, U1>, ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,` [src]

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

`pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = N>)`[src]

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

This will fill as many diagonal elements as the iterator yields, up to the minimum of the number of rows and columns of self, and starting with the diagonal element at index (0, 0).

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

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

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

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

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

In-place filling

`pub fn fill(&mut self, val: N)`[src]

Sets all the elements of this matrix to val.

`pub fn fill_with_identity(&mut self) where N: Zero + One,` [src]

Fills self with the identity matrix.

`pub fn fill_diagonal(&mut self, val: N)`[src]

Sets all the diagonal elements of this matrix to val.

`pub fn fill_row(&mut self, i: usize, val: N)`[src]

Sets all the elements of the selected row to val.

`pub fn fill_column(&mut self, j: usize, val: N)`[src]

Sets all the elements of the selected column to val.

`pub fn fill_lower_triangle(&mut self, val: N, shift: usize)`[src]

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

The parameter shift allows some subdiagonals to be left untouched:

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

`pub fn fill_upper_triangle(&mut self, val: N, shift: usize)`[src]

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.

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

`pub fn fill_lower_triangle_with_upper_triangle(&mut self)`[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.

`pub fn fill_upper_triangle_with_lower_triangle(&mut self)`[src]

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: StorageMut<N, R, C>,` [src]

In-place swapping

`pub fn swap_rows(&mut self, irow1: usize, irow2: usize)`[src]

Swaps two rows in-place.

`pub fn swap_columns(&mut self, icol1: usize, icol2: usize)`[src]

Swaps two columns in-place.

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

Rows and columns removal

`pub fn remove_column( self, i: usize ) -> Matrix<N, R, <C as DimSub<U1>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<U1>>::Output>>::Buffer> where C: DimSub<U1>, DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<U1>>::Output>,` [src]

Removes the i-th column from this matrix.

`pub fn remove_columns_at( self, indices: &[usize] ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where C: DimSub<Dynamic, Output = Dynamic>, DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,` [src]

Removes all columns in indices

`pub fn remove_rows_at( self, indices: &[usize] ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where R: DimSub<Dynamic, Output = Dynamic>, DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,` [src]

Removes all rows in indices

`pub fn remove_fixed_columns<D>( self, i: usize ) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer> where C: DimSub<D>, D: DimName, DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,` [src]

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

`pub fn remove_columns( self, i: usize, n: usize ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where C: DimSub<Dynamic, Output = Dynamic>, DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,` [src]

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

`pub fn remove_columns_generic<D>( self, i: usize, nremove: D ) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer> where C: DimSub<D>, D: Dim, DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,` [src]

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

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

`pub fn remove_row( self, i: usize ) -> Matrix<N, <R as DimSub<U1>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<U1>>::Output, C>>::Buffer> where R: DimSub<U1>, DefaultAllocator: Reallocator<N, R, C, <R as DimSub<U1>>::Output, C>,` [src]

Removes the i-th row from this matrix.

`pub fn remove_fixed_rows<D>( self, i: usize ) -> Matrix<N, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<D>>::Output, C>>::Buffer> where D: DimName, R: DimSub<D>, DefaultAllocator: Reallocator<N, R, C, <R as DimSub<D>>::Output, C>,` [src]

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

`pub fn remove_rows( self, i: usize, n: usize ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where R: DimSub<Dynamic, Output = Dynamic>, DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,` [src]

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

`pub fn remove_rows_generic<D>( self, i: usize, nremove: D ) -> Matrix<N, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<D>>::Output, C>>::Buffer> where D: Dim, R: DimSub<D>, DefaultAllocator: Reallocator<N, R, C, <R as DimSub<D>>::Output, C>,` [src]

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.

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

Rows and columns insertion

`pub fn insert_column( self, i: usize, val: N ) -> Matrix<N, R, <C as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<U1>>::Output>>::Buffer> where C: DimAdd<U1>, DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<U1>>::Output>,` [src]

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

`pub fn insert_fixed_columns<D>( self, i: usize, val: N ) -> Matrix<N, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<D>>::Output>>::Buffer> where C: DimAdd<D>, D: DimName, DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,` [src]

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

`pub fn insert_columns( self, i: usize, n: usize, val: N ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where C: DimAdd<Dynamic, Output = Dynamic>, DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,` [src]

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

`pub unsafe fn insert_columns_generic_uninitialized<D>( self, i: usize, ninsert: D ) -> Matrix<N, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<D>>::Output>>::Buffer> where C: DimAdd<D>, D: Dim, DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,` [src]

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

The added column values are not initialized.

`pub fn insert_row( self, i: usize, val: N ) -> Matrix<N, <R as DimAdd<U1>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<U1>>::Output, C>>::Buffer> where R: DimAdd<U1>, DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<U1>>::Output, C>,` [src]

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

`pub fn insert_fixed_rows<D>( self, i: usize, val: N ) -> Matrix<N, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<D>>::Output, C>>::Buffer> where D: DimName, R: DimAdd<D>, DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<D>>::Output, C>,` [src]

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

`pub fn insert_rows( self, i: usize, n: usize, val: N ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where R: DimAdd<Dynamic, Output = Dynamic>, DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,` [src]

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

`pub unsafe fn insert_rows_generic_uninitialized<D>( self, i: usize, ninsert: D ) -> Matrix<N, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<D>>::Output, C>>::Buffer> where D: Dim, R: DimAdd<D>, DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<D>>::Output, C>,` [src]

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.

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

Resizing and reshaping

`pub fn resize( self, new_nrows: usize, new_ncols: usize, val: N ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,` [src]

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

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

`pub fn resize_vertically( self, new_nrows: usize, val: N ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,` [src]

Resizes this matrix vertically, i.e., so that it contains new_nrows rows while keeping the same number of columns.

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

`pub fn resize_horizontally( self, new_ncols: usize, val: N ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,` [src]

Resizes this matrix horizontally, i.e., so that it contains new_ncolumns columns while keeping the same number of columns.

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

`pub fn fixed_resize<R2, C2>( self, val: N ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: DimName, R2: DimName, DefaultAllocator: Reallocator<N, R, C, R2, C2>,` [src]

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

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

`pub fn resize_generic<R2, C2>( self, new_nrows: R2, new_ncols: C2, val: N ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, DefaultAllocator: Reallocator<N, R, C, R2, C2>,` [src]

Resizes self such that it has dimensions new_nrows × new_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.

`pub fn reshape_generic<R2, C2>( self, new_nrows: R2, new_ncols: C2 ) -> Matrix<N, R2, C2, <S as ReshapableStorage<N, R, C, R2, C2>>::Output> where S: ReshapableStorage<N, R, C, R2, C2>, C2: Dim, R2: Dim,` [src]

Reshapes self such that it has dimensions new_nrows × new_ncols.

This will reinterpret self as if it is a matrix with new_nrows rows and new_ncols columns. The arrangements of the component in the output matrix are the same as what would be obtained by Matrix::from_slice_generic(self.as_slice(), new_nrows, new_ncols).

If self is a dynamically-sized matrix, then its components are neither copied nor moved. If self is staticyll-sized, then a copy may happen in some situations. This function will panic if the given dimensions are such that the number of elements of the input matrix are not equal to the number of elements of the output matrix.

Examples


let m1 = Matrix2x3::new(
    1.1, 1.2, 1.3,
    2.1, 2.2, 2.3
);
let m2 = Matrix3x2::new(
    1.1, 2.2,
    2.1, 1.3,
    1.2, 2.3
);
let reshaped = m1.reshape_generic(U3, U2);
assert_eq!(reshaped, m2);

let dm1 = DMatrix::from_row_slice(
    4,
    3,
    &[
        1.0, 0.0, 0.0,
        0.0, 0.0, 1.0,
        0.0, 0.0, 0.0,
        0.0, 1.0, 0.0
    ],
);
let dm2 = DMatrix::from_row_slice(
    6,
    2,
    &[
        1.0, 0.0,
        0.0, 1.0,
        0.0, 0.0,
        0.0, 1.0,
        0.0, 0.0,
        0.0, 0.0,
    ],
);
let reshaped = dm1.reshape_generic(Dynamic::new(6), Dynamic::new(2));
assert_eq!(reshaped, dm2);

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

In-place resizing

`pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: N) where DefaultAllocator: Reallocator<N, Dynamic, Dynamic, Dynamic, Dynamic>,` [src]

Resizes this matrix in-place.

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.

Defined only for owned fully-dynamic matrices, i.e., DMatrix.

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

`pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: N) where DefaultAllocator: Reallocator<N, Dynamic, C, Dynamic, C>,` [src]

Changes the number of rows of this matrix in-place.

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

Defined only for owned matrices with a dynamic number of rows (for example, DVector).

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

`pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: N) where DefaultAllocator: Reallocator<N, R, Dynamic, R, Dynamic>,` [src]

Changes the number of column of this matrix in-place.

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

Defined only for owned matrices with a dynamic number of columns (for example, DVector).

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

Slicing based on ranges

Indices to Individual Elements

Two-Dimensional Indices

let matrix = Matrix2::new(0, 2,
                          1, 3);

assert_eq!(matrix.index((0, 0)), &0);
assert_eq!(matrix.index((1, 0)), &1);
assert_eq!(matrix.index((0, 1)), &2);
assert_eq!(matrix.index((1, 1)), &3);

Linear Address Indexing

let matrix = Matrix2::new(0, 2,
                          1, 3);

assert_eq!(matrix.get(0), Some(&0));
assert_eq!(matrix.get(1), Some(&1));
assert_eq!(matrix.get(2), Some(&2));
assert_eq!(matrix.get(3), Some(&3));

Indices to Individual Rows and Columns

Index to a Row

let matrix = Matrix2::new(0, 2,
                          1, 3);

assert!(matrix.index((0, ..))
    .eq(&Matrix1x2::new(0, 2)));

Index to a Column

let matrix = Matrix2::new(0, 2,
                          1, 3);

assert!(matrix.index((.., 0))
    .eq(&Matrix2x1::new(0,
                        1)));

Indices to Parts of Individual Rows and Columns

Index to a Partial Row

let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((0, ..2))
    .eq(&Matrix1x2::new(0, 3)));

Index to a Partial Column

let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((..2, 0))
    .eq(&Matrix2x1::new(0,
                        1)));

assert!(matrix.index((U1.., 0))
    .eq(&Matrix2x1::new(1,
                        2)));

Indices to Ranges of Rows and Columns

Index to a Range of Rows

let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((1..3, ..))
    .eq(&Matrix2x3::new(1, 4, 7,
                        2, 5, 8)));

Index to a Range of Columns

let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((.., 1..3))
    .eq(&Matrix3x2::new(3, 6,
                        4, 7,
                        5, 8)));

`pub fn get<'a, I>( &'a self, index: I ) -> Option<>::Output> where I: MatrixIndex<'a, N, R, C, S>,` [src]

Produces a view of the data at the given index, or None if the index is out of bounds.

`pub fn get_mut<'a, I>( &'a mut self, index: I ) -> Option<>::OutputMut> where I: MatrixIndexMut<'a, N, R, C, S>, S: StorageMut<N, R, C>,` [src]

Produces a mutable view of the data at the given index, or None if the index is out of bounds.

`pub fn index<'a, I>( &'a self, index: I ) -> >::Output where I: MatrixIndex<'a, N, R, C, S>,` [src]

Produces a view of the data at the given index, or panics if the index is out of bounds.

`pub fn index_mut<'a, I>( &'a mut self, index: I ) -> >::OutputMut where I: MatrixIndexMut<'a, N, R, C, S>, S: StorageMut<N, R, C>,` [src]

Produces a mutable view of the data at the given index, or panics if the index is out of bounds.

`pub unsafe fn get_unchecked<'a, I>( &'a self, index: I ) -> >::Output where I: MatrixIndex<'a, N, R, C, S>,` [src]

Produces a view of the data at the given index, without doing any bounds checking.

`pub unsafe fn get_unchecked_mut<'a, I>( &'a mut self, index: I ) -> >::OutputMut where I: MatrixIndexMut<'a, N, R, C, S>, S: StorageMut<N, R, C>,` [src]

Returns a mutable view of the data at the given index, without doing any bounds checking.

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

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

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

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

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

Creates a new matrix with the given data.

`pub fn shape(&self) -> (usize, usize)`[src]

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));

`pub fn nrows(&self) -> usize`[src]

The number of rows of this matrix.

Examples:

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

`pub fn ncols(&self) -> usize`[src]

The number of columns of this matrix.

Examples:

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

`pub fn strides(&self) -> (usize, usize)`[src]

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));

`pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)`[src]

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

Example

let m = Matrix2::new(1, 2,
                     3, 4);
let i = m.vector_to_matrix_index(3);
assert_eq!(i, (1, 1));
assert_eq!(m[i], m[3]);

`pub fn as_ptr(&self) -> *const N`[src]

Returns a pointer to the start of the matrix.

If the matrix is not empty, this pointer is guaranteed to be aligned and non-null.

Example

let m = Matrix2::new(1, 2,
                     3, 4);
let ptr = m.as_ptr();
assert_eq!(unsafe { *ptr }, m[0]);

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

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

See relative_eq from the RelativeEq trait for more details.

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

Tests whether self and rhs are exactly equal.

`pub fn into_owned( self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

Moves this matrix into one that owns its data.

pub fn into_owned_sum<R2, C2>( self ) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where C2: Dim, R2: Dim, DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>, [src]

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

`pub fn clone_owned( &self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

Clones this matrix to one that owns its data.

pub fn clone_owned_sum<R2, C2>( &self ) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where C2: Dim, R2: Dim, DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>, [src]

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

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

Transposes self and store the result into out.

`#[must_use = "Did you mean to use transpose_mut()?"] pub fn transpose( &self ) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where DefaultAllocator: Allocator<N, C, R>,` [src]

Transposes self.

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

Elementwise mapping and folding

`pub fn map<N2, F>( &self, f: F ) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where F: FnMut(N) -> N2, N2: Scalar, DefaultAllocator: Allocator<N2, R, C>,` [src]

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

`pub fn fold_with<N2>( &self, init_f: impl FnOnce(Option<&N>) -> N2, f: impl FnMut(N2, &N) -> N2 ) -> N2`[src]

Similar to self.iter().fold(init, f) except that init is replaced by a closure.

The initialization closure is given the first component of this matrix:

If the matrix has no component (0 rows or 0 columns) then init_f is called with None and its return value is the value returned by this method.
If the matrix has has least one component, then init_f is called with the first component to compute the initial value. Folding then continues on all the remaining components of the matrix.

`pub fn map_with_location<N2, F>( &self, f: F ) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where F: FnMut(usize, usize, N) -> N2, N2: Scalar, DefaultAllocator: Allocator<N2, R, C>,` [src]

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(row, col, value).

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

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

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

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

`pub fn fold<Acc>(&self, init: Acc, f: impl FnMut(Acc, N) -> Acc) -> Acc`[src]

Folds a function f on each entry of self.

`pub fn zip_fold<N2, R2, C2, S2, Acc>( &self, rhs: &Matrix<N2, R2, C2, S2>, init: Acc, f: impl FnMut(Acc, N, N2) -> Acc ) -> Acc where N2: Scalar, C2: Dim, R2: Dim, S2: Storage<N2, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>,` [src]

Folds a function f on each pairs of entries from self and rhs.

`pub fn apply<F>(&mut self, f: F) where F: FnMut(N) -> N, S: StorageMut<N, R, C>,` [src]

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

`pub fn zip_apply<N2, R2, C2, S2>( &mut self, rhs: &Matrix<N2, R2, C2, S2>, f: impl FnMut(N, N2) -> N ) where S: StorageMut<N, R, C>, N2: Scalar, C2: Dim, R2: Dim, S2: Storage<N2, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>,` [src]

Replaces each component of self by the result of a closure f applied on its components joined with the components from rhs.

pub fn zip_zip_apply<N2, R2, C2, S2, N3, R3, C3, S3>( &mut self, b: &Matrix<N2, R2, C2, S2>, c: &Matrix<N3, R3, C3, S3>, f: impl FnMut(N, N2, N3) -> N ) where S: StorageMut<N, R, C>, N2: Scalar, N3: Scalar, C2: Dim, R2: Dim, R3: Dim, C3: Dim, S2: Storage<N2, R2, C2>, S3: Storage<N3, R3, C3>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>, [src]

Replaces each component of self by the result of a closure f applied on its components joined with the components from b and c.

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

Iteration on components, rows, and columns

`pub fn iter(&self) -> MatrixIter<'_, N, R, C, S>ⓘNotable traits for MatrixIter<'a, N, R, C, S> impl<'a, N, R, C, S> Iterator for MatrixIter<'a, N, R, C, S> where C: Dim, N: Scalar, R: Dim, S: 'a + Storage<N, R, C>, type Item = &'a N;`[src]

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

`pub fn row_iter(&self) -> RowIter<'_, N, R, C, S>ⓘNotable traits for RowIter<'a, N, R, C, S> impl<'a, N, R, C, S> Iterator for RowIter<'a, N, R, C, S> where C: Dim, N: Scalar, R: Dim, S: 'a + Storage<N, R, C>, type Item = Matrix<N, U1, C, SliceStorage<'a, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>;`[src]

Iterate through the rows of this matrix.

Example

let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, row) in a.row_iter().enumerate() {
    assert_eq!(row, a.row(i))
}

`pub fn column_iter(&self) -> ColumnIter<'_, N, R, C, S>ⓘNotable traits for ColumnIter<'a, N, R, C, S> impl<'a, N, R, C, S> Iterator for ColumnIter<'a, N, R, C, S> where C: Dim, N: Scalar, R: Dim, S: 'a + Storage<N, R, C>, type Item = Matrix<N, R, U1, SliceStorage<'a, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>;`[src]

Iterate through the columns of this matrix.

Example

let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, column) in a.column_iter().enumerate() {
    assert_eq!(column, a.column(i))
}

`pub fn iter_mut(&mut self) -> MatrixIterMut<'_, N, R, C, S>ⓘNotable traits for MatrixIterMut<'a, N, R, C, S> impl<'a, N, R, C, S> Iterator for MatrixIterMut<'a, N, R, C, S> where C: Dim, N: Scalar, R: Dim, S: 'a + StorageMut<N, R, C>, type Item = &'a mut N; where S: StorageMut<N, R, C>,` [src]

Mutably iterates through this matrix coordinates.

`pub fn row_iter_mut(&mut self) -> RowIterMut<'_, N, R, C, S>ⓘNotable traits for RowIterMut<'a, N, R, C, S> impl<'a, N, R, C, S> Iterator for RowIterMut<'a, N, R, C, S> where C: Dim, N: Scalar, R: Dim, S: 'a + StorageMut<N, R, C>, type Item = Matrix<N, U1, C, SliceStorageMut<'a, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>; where S: StorageMut<N, R, C>,` [src]

Mutably iterates through this matrix rows.

Example

let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, mut row) in a.row_iter_mut().enumerate() {
    row *= (i + 1) * 10;
}

let expected = Matrix2x3::new(10, 20, 30,
                              80, 100, 120);
assert_eq!(a, expected);

`pub fn column_iter_mut(&mut self) -> ColumnIterMut<'_, N, R, C, S>ⓘNotable traits for ColumnIterMut<'a, N, R, C, S> impl<'a, N, R, C, S> Iterator for ColumnIterMut<'a, N, R, C, S> where C: Dim, N: Scalar, R: Dim, S: 'a + StorageMut<N, R, C>, type Item = Matrix<N, R, U1, SliceStorageMut<'a, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>; where S: StorageMut<N, R, C>,` [src]

Mutably iterates through this matrix columns.

Example

let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, mut col) in a.column_iter_mut().enumerate() {
    col *= (i + 1) * 10;
}

let expected = Matrix2x3::new(10, 40, 90,
                              40, 100, 180);
assert_eq!(a, expected);

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

`pub fn as_mut_ptr(&mut self) -> *mut N`[src]

Returns a mutable pointer to the start of the matrix.

If the matrix is not empty, this pointer is guaranteed to be aligned and non-null.

`pub unsafe fn swap_unchecked( &mut self, row_cols1: (usize, usize), row_cols2: (usize, usize) )`[src]

Swaps two entries without bound-checking.

`pub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))`[src]

Swaps two entries.

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

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

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

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

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

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

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

`pub fn apply_into<F>(self, f: F) -> Matrix<N, R, C, S> where F: FnMut(N) -> N,` [src]

Returns self with each of its components replaced by the result of a closure f applied on it.

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

`pub unsafe fn vget_unchecked(&self, i: usize) -> &N`[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 N: Scalar, D: Dim, S: StorageMut<N, D, U1>,` [src]

`pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut N`[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]

`pub fn as_slice(&self) -> &[N]ⓘNotable traits for &'_ mut [u8] impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]`[src]

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]

`pub fn as_mut_slice(&mut self) -> &mut [N]ⓘNotable traits for &'_ mut [u8] impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]`[src]

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

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

`pub fn transpose_mut(&mut self)`[src]

Transposes the square matrix self in-place.

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

`pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>) where C2: Dim, R2: Dim, SB: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R, C2>, ShapeConstraint: SameNumberOfColumns<C, R2>,` [src]

Takes the adjoint (aka. conjugate-transpose) of self and store the result into out.

`#[must_use = "Did you mean to use adjoint_mut()?"] pub fn adjoint( &self ) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where DefaultAllocator: Allocator<N, C, R>,` [src]

The adjoint (aka. conjugate-transpose) of self.

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

👎 Deprecated:

Renamed self.adjoint_to(out).

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

`pub fn conjugate_transpose( &self ) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where DefaultAllocator: Allocator<N, C, R>,` [src]

👎 Deprecated:

Renamed self.adjoint().

The conjugate transposition of self.

`#[must_use = "Did you mean to use conjugate_mut()?"] pub fn conjugate( &self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

The conjugate of self.

`#[must_use = "Did you mean to use unscale_mut()?"] pub fn unscale( &self, real: <N as SimdComplexField>::SimdRealField ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

Divides each component of the complex matrix self by the given real.

`#[must_use = "Did you mean to use scale_mut()?"] pub fn scale( &self, real: <N as SimdComplexField>::SimdRealField ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where DefaultAllocator: Allocator<N, R, C>,` [src]

Multiplies each component of the complex matrix self by the given real.

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

`pub fn conjugate_mut(&mut self)`[src]

The conjugate of the complex matrix self computed in-place.

`pub fn unscale_mut(&mut self, real: <N as SimdComplexField>::SimdRealField)`[src]

Divides each component of the complex matrix self by the given real.

`pub fn scale_mut(&mut self, real: <N as SimdComplexField>::SimdRealField)`[src]

Multiplies each component of the complex matrix self by the given real.

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

`pub fn conjugate_transform_mut(&mut self)`[src]

👎 Deprecated:

Renamed to self.adjoint_mut().

Sets self to its adjoint.

`pub fn adjoint_mut(&mut self)`[src]

Sets self to its adjoint (aka. conjugate-transpose).

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

`pub fn diagonal( &self ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where DefaultAllocator: Allocator<N, D, U1>,` [src]

The diagonal of this matrix.

`pub fn map_diagonal<N2>( &self, f: impl FnMut(N) -> N2 ) -> Matrix<N2, D, U1, <DefaultAllocator as Allocator<N2, D, U1>>::Buffer> where N2: Scalar, DefaultAllocator: Allocator<N2, D, U1>,` [src]

Apply the given function to this matrix’s diagonal and returns it.

This is a more efficient version of self.diagonal().map(f) since this allocates only once.

`pub fn trace(&self) -> N where N: Scalar + Zero + ClosedAdd<N>,` [src]

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 N: SimdComplexField, D: Dim, S: Storage<N, D, D>,` [src]

`pub fn symmetric_part( &self ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where DefaultAllocator: Allocator<N, D, D>,` [src]

The symmetric part of self, i.e., 0.5 * (self + self.transpose()).

`pub fn hermitian_part( &self ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where DefaultAllocator: Allocator<N, D, D>,` [src]

The hermitian part of self, i.e., 0.5 * (self + self.adjoint()).

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

`pub fn to_homogeneous( &self ) -> Matrix<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>>::Buffer> where DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>,` [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 N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D, U1>,` [src]

`pub fn to_homogeneous( &self ) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer> where DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,` [src]

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

`pub fn from_homogeneous<SB>( v: Matrix<N, <D as DimAdd<U1>>::Output, U1, SB> ) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> where SB: Storage<N, <D as DimAdd<U1>>::Output, U1>, DefaultAllocator: Allocator<N, D, U1>,` [src]

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, D, S> Matrix<N, D, U1, S> where N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D, U1>,` [src]

`pub fn push( &self, element: N ) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer> where DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,` [src]

Constructs a new vector of higher dimension by appending element to the end of self.

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

Cross product

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

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

pub fn cross<R2, C2, SB>( &self, b: &Matrix<N, R2, C2, SB> ) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>, [src]

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: Scalar + Field, S: Storage<N, U3, U1>, DefaultAllocator: Allocator<N, U3, U1>,` [src]

`pub fn cross_matrix( &self ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[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: SimdComplexField, R: Dim, S: Storage<N, R, C>,` [src]

`pub fn angle<R2, C2, SB>( &self, other: &Matrix<N, R2, C2, SB> ) -> <N as SimdComplexField>::SimdRealField where C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, ShapeConstraint: DimEq<R, R2>, ShapeConstraint: DimEq<C, C2>,` [src]

The smallest angle between two vectors.

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

Slicing based on index and length

`pub fn row( &self, i: usize ) -> Matrix<N, U1, C, SliceStorage<'_, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn row_part( &self, i: usize, n: usize ) -> Matrix<N, U1, Dynamic, SliceStorage<'_, N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn rows( &self, first_row: usize, nrows: usize ) -> Matrix<N, Dynamic, C, SliceStorage<'_, N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

Extracts from this matrix a set of consecutive rows.

`pub fn rows_with_step( &self, first_row: usize, nrows: usize, step: usize ) -> Matrix<N, Dynamic, C, SliceStorage<'_, N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn fixed_rows<RSlice>( &self, first_row: usize ) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: DimName,` [src]

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

`pub fn fixed_rows_with_step<RSlice>( &self, first_row: usize, step: usize ) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where RSlice: DimName,` [src]

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

`pub fn rows_generic<RSlice>( &self, row_start: usize, nrows: RSlice ) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: Dim,` [src]

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

`pub fn rows_generic_with_step<RSlice>( &self, row_start: usize, nrows: RSlice, step: usize ) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where RSlice: Dim,` [src]

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

`pub fn column( &self, i: usize ) -> Matrix<N, R, U1, SliceStorage<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn column_part( &self, i: usize, n: usize ) -> Matrix<N, Dynamic, U1, SliceStorage<'_, N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn columns( &self, first_col: usize, ncols: usize ) -> Matrix<N, R, Dynamic, SliceStorage<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

Extracts from this matrix a set of consecutive columns.

`pub fn columns_with_step( &self, first_col: usize, ncols: usize, step: usize ) -> Matrix<N, R, Dynamic, SliceStorage<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>`[src]

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

`pub fn fixed_columns<CSlice>( &self, first_col: usize ) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where CSlice: DimName,` [src]

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

`pub fn fixed_columns_with_step<CSlice>( &self, first_col: usize, step: usize ) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where CSlice: DimName,` [src]

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

`pub fn columns_generic<CSlice>( &self, first_col: usize, ncols: CSlice ) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where CSlice: Dim,` [src]

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

`pub fn columns_generic_with_step<CSlice>( &self, first_col: usize, ncols: CSlice, step: usize ) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where CSlice: Dim,` [src]

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

`pub fn slice( &self, start: (usize, usize), shape: (usize, usize) ) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'_, N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn slice_with_steps( &self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize) ) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'_, N, Dynamic, Dynamic, Dynamic, Dynamic>>`[src]

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

`pub fn fixed_slice<RSlice, CSlice>( &self, irow: usize, icol: usize ) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: DimName, CSlice: DimName,` [src]

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

`pub fn fixed_slice_with_steps<RSlice, CSlice>( &self, start: (usize, usize), steps: (usize, usize) ) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, Dynamic, Dynamic>> where RSlice: DimName, CSlice: DimName,` [src]

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

`pub fn generic_slice<RSlice, CSlice>( &self, start: (usize, usize), shape: (RSlice, CSlice) ) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: Dim, CSlice: Dim,` [src]

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

`pub fn generic_slice_with_steps<RSlice, CSlice>( &self, start: (usize, usize), shape: (RSlice, CSlice), steps: (usize, usize) ) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, Dynamic, Dynamic>> where RSlice: Dim, CSlice: Dim,` [src]

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

pub fn rows_range_pair<Range1, Range2>( &self, r1: Range1, r2: Range2 ) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorage<'_, N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorage<'_, N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where Range1: SliceRange<R>, Range2: SliceRange<R>, [src]

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

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

pub fn columns_range_pair<Range1, Range2>( &self, r1: Range1, r2: Range2 ) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorage<'_, N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorage<'_, N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where Range1: SliceRange<C>, Range2: SliceRange<C>, [src]

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]

Mutable slicing based on index and length

`pub fn row_mut( &mut self, i: usize ) -> Matrix<N, U1, C, SliceStorageMut<'_, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn row_part_mut( &mut self, i: usize, n: usize ) -> Matrix<N, U1, Dynamic, SliceStorageMut<'_, N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn rows_mut( &mut self, first_row: usize, nrows: usize ) -> Matrix<N, Dynamic, C, SliceStorageMut<'_, N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

Extracts from this matrix a set of consecutive rows.

`pub fn rows_with_step_mut( &mut self, first_row: usize, nrows: usize, step: usize ) -> Matrix<N, Dynamic, C, SliceStorageMut<'_, N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn fixed_rows_mut<RSlice>( &mut self, first_row: usize ) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: DimName,` [src]

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

`pub fn fixed_rows_with_step_mut<RSlice>( &mut self, first_row: usize, step: usize ) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where RSlice: DimName,` [src]

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

`pub fn rows_generic_mut<RSlice>( &mut self, row_start: usize, nrows: RSlice ) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: Dim,` [src]

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

`pub fn rows_generic_with_step_mut<RSlice>( &mut self, row_start: usize, nrows: RSlice, step: usize ) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where RSlice: Dim,` [src]

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

`pub fn column_mut( &mut self, i: usize ) -> Matrix<N, R, U1, SliceStorageMut<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn column_part_mut( &mut self, i: usize, n: usize ) -> Matrix<N, Dynamic, U1, SliceStorageMut<'_, N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn columns_mut( &mut self, first_col: usize, ncols: usize ) -> Matrix<N, R, Dynamic, SliceStorageMut<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

Extracts from this matrix a set of consecutive columns.

`pub fn columns_with_step_mut( &mut self, first_col: usize, ncols: usize, step: usize ) -> Matrix<N, R, Dynamic, SliceStorageMut<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>`[src]

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

`pub fn fixed_columns_mut<CSlice>( &mut self, first_col: usize ) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where CSlice: DimName,` [src]

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

`pub fn fixed_columns_with_step_mut<CSlice>( &mut self, first_col: usize, step: usize ) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where CSlice: DimName,` [src]

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

`pub fn columns_generic_mut<CSlice>( &mut self, first_col: usize, ncols: CSlice ) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where CSlice: Dim,` [src]

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

`pub fn columns_generic_with_step_mut<CSlice>( &mut self, first_col: usize, ncols: CSlice, step: usize ) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where CSlice: Dim,` [src]

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

`pub fn slice_mut( &mut self, start: (usize, usize), shape: (usize, usize) ) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'_, N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>`[src]

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

`pub fn slice_with_steps_mut( &mut self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize) ) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'_, N, Dynamic, Dynamic, Dynamic, Dynamic>>`[src]

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

`pub fn fixed_slice_mut<RSlice, CSlice>( &mut self, irow: usize, icol: usize ) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: DimName, CSlice: DimName,` [src]

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

`pub fn fixed_slice_with_steps_mut<RSlice, CSlice>( &mut self, start: (usize, usize), steps: (usize, usize) ) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, Dynamic, Dynamic>> where RSlice: DimName, CSlice: DimName,` [src]

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

`pub fn generic_slice_mut<RSlice, CSlice>( &mut self, start: (usize, usize), shape: (RSlice, CSlice) ) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RSlice: Dim, CSlice: Dim,` [src]

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

`pub fn generic_slice_with_steps_mut<RSlice, CSlice>( &mut self, start: (usize, usize), shape: (RSlice, CSlice), steps: (usize, usize) ) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, Dynamic, Dynamic>> where RSlice: Dim, CSlice: Dim,` [src]

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

pub fn rows_range_pair_mut<Range1, Range2>( &mut self, r1: Range1, r2: Range2 ) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where Range1: SliceRange<R>, Range2: SliceRange<R>, [src]

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

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

pub fn columns_range_pair_mut<Range1, Range2>( &mut self, r1: Range1, r2: Range2 ) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where Range1: SliceRange<C>, Range2: SliceRange<C>, [src]

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: Storage<N, R, C>,` [src]

`pub fn slice_range<RowRange, ColRange>( &self, rows: RowRange, cols: ColRange ) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RowRange: SliceRange<R>, ColRange: SliceRange<C>,` [src]

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

`pub fn rows_range<RowRange>( &self, rows: RowRange ) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorage<'_, N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RowRange: SliceRange<R>,` [src]

Slice containing all the rows indexed by the range rows.

`pub fn columns_range<ColRange>( &self, cols: ColRange ) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where ColRange: SliceRange<C>,` [src]

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]

`pub fn slice_range_mut<RowRange, ColRange>( &mut self, rows: RowRange, cols: ColRange ) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RowRange: SliceRange<R>, ColRange: SliceRange<C>,` [src]

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

`pub fn rows_range_mut<RowRange>( &mut self, rows: RowRange ) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where RowRange: SliceRange<R>,` [src]

Slice containing all the rows indexed by the range rows.

`pub fn columns_range_mut<ColRange>( &mut self, cols: ColRange ) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where ColRange: SliceRange<C>,` [src]

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]

Magnitude and norms

`pub fn norm_squared(&self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

The squared L2 norm of this vector.

`pub fn norm(&self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

The L2 norm of this matrix.

Use .apply_norm to apply a custom norm.

`pub fn metric_distance<R2, C2, S2>( &self, rhs: &Matrix<N, R2, C2, S2> ) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField, C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>,` [src]

Compute the distance between self and rhs using the metric induced by the euclidean norm.

Use .apply_metric_distance to apply a custom norm.

`pub fn apply_norm( &self, norm: &impl Norm<N> ) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

Uses the given norm to compute the norm of self.

Example


let v = Vector3::new(1.0, 2.0, 3.0);
assert_eq!(v.apply_norm(&UniformNorm), 3.0);
assert_eq!(v.apply_norm(&LpNorm(1)), 6.0);
assert_eq!(v.apply_norm(&EuclideanNorm), v.norm());

`pub fn apply_metric_distance<R2, C2, S2>( &self, rhs: &Matrix<N, R2, C2, S2>, norm: &impl Norm<N> ) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField, C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2>, ShapeConstraint: SameNumberOfColumns<C, C2>,` [src]

Uses the metric induced by the given norm to compute the metric distance between self and rhs.

Example


let v1 = Vector3::new(1.0, 2.0, 3.0);
let v2 = Vector3::new(10.0, 20.0, 30.0);

assert_eq!(v1.apply_metric_distance(&v2, &UniformNorm), 27.0);
assert_eq!(v1.apply_metric_distance(&v2, &LpNorm(1)), 27.0 + 18.0 + 9.0);
assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm());

`pub fn magnitude(&self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

A synonym for the norm of this matrix.

Aka the length.

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

`pub fn magnitude_squared(&self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

A synonym for the squared norm of this matrix.

Aka the squared length.

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

`pub fn set_magnitude( &mut self, magnitude: <N as SimdComplexField>::SimdRealField ) where N: SimdComplexField, S: StorageMut<N, R, C>,` [src]

Sets the magnitude of this vector.

`#[must_use = "Did you mean to use normalize_mut()?"] pub fn normalize( &self ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where N: SimdComplexField, DefaultAllocator: Allocator<N, R, C>,` [src]

Returns a normalized version of this matrix.

`pub fn lp_norm(&self, p: i32) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

The Lp norm of this matrix.

`#[must_use = "Did you mean to use simd_try_normalize_mut()?"] pub fn simd_try_normalize( &self, min_norm: <N as SimdComplexField>::SimdRealField ) -> SimdOption<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> where N: SimdComplexField, <N as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<N, R, C>, DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>,` [src]

Attempts to normalize self.

The components of this matrix can be SIMD types.

`pub fn try_set_magnitude( &mut self, magnitude: <N as ComplexField>::RealField, min_magnitude: <N as ComplexField>::RealField ) where N: ComplexField, S: StorageMut<N, R, C>,` [src]

Sets the magnitude of this vector unless it is smaller than min_magnitude.

If self.magnitude() is smaller than min_magnitude, it will be left unchanged. Otherwise this is equivalent to: `*self = self.normalize() * magnitude.

`#[must_use = "Did you mean to use try_normalize_mut()?"] pub fn try_normalize( &self, min_norm: <N as ComplexField>::RealField ) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> where N: ComplexField, DefaultAllocator: Allocator<N, R, C>,` [src]

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

The components of this matrix cannot be SIMD types (see simd_try_normalize) instead.

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

In-place normalization

`pub fn normalize_mut(&mut self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

Normalizes this matrix in-place and returns its norm.

The components of the matrix cannot be SIMD types (see simd_try_normalize_mut instead).

`#[must_use = "Did you mean to use simd_try_normalize_mut()?"] pub fn simd_try_normalize_mut( &mut self, min_norm: <N as SimdComplexField>::SimdRealField ) -> SimdOption<<N as SimdComplexField>::SimdRealField> where N: SimdComplexField, <N as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<N, R, C>, DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>,` [src]

Normalizes this matrix in-place and return its norm.

The components of the matrix can be SIMD types.

`pub fn try_normalize_mut( &mut self, min_norm: <N as ComplexField>::RealField ) -> Option<<N as ComplexField>::RealField> where N: ComplexField,` [src]

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

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

`impl<N, D> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where N: ComplexField, D: DimName, DefaultAllocator: Allocator<N, D, U1>,` [src]

Basis and orthogonalization

`pub fn orthonormalize( vs: &mut [Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>] ) -> usize`[src]

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

`pub fn orthonormal_subspace_basis<F>( vs: &[Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>], f: F ) where F: FnMut(&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>) -> bool,` [src]

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

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

`pub fn len(&self) -> usize`[src]

The total number of elements of this matrix.

Examples:

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

`pub fn is_empty(&self) -> bool`[src]

Returns true if the matrix contains no elements.

Examples:

let mat = Matrix3x4::<f32>::zeros();
assert!(!mat.is_empty());

`pub fn is_square(&self) -> bool`[src]

Indicates if this is a square matrix.

`pub fn is_identity(&self, eps: <N as AbsDiffEq<N>>::Epsilon) -> bool where N: Zero + One + RelativeEq<N>, <N as AbsDiffEq<N>>::Epsilon: Copy,` [src]

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

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

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

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

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 N: RealField, D: Dim, S: Storage<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn is_special_orthogonal(&self, eps: N) -> bool where D: DimMin<D, Output = D>, DefaultAllocator: Allocator<(usize, usize), D, U1>,` [src]

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

`pub fn is_invertible(&self) -> bool`[src]

Returns true if this matrix is invertible.

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

Folding on columns and rows

`pub fn compress_rows( &self, f: impl Fn(Matrix<N, R, U1, SliceStorage<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) -> N ) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where DefaultAllocator: Allocator<N, U1, C>,` [src]

Returns a row vector where each element is the result of the application of f on the corresponding column of the original matrix.

`pub fn compress_rows_tr( &self, f: impl Fn(Matrix<N, R, U1, SliceStorage<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) -> N ) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where DefaultAllocator: Allocator<N, C, U1>,` [src]

Returns a column vector where each element is the result of the application of f on the corresponding column of the original matrix.

This is the same as self.compress_rows(f).transpose().

`pub fn compress_columns( &self, init: Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>, f: impl Fn(&mut Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>, Matrix<N, R, U1, SliceStorage<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where DefaultAllocator: Allocator<N, R, U1>,` [src]

Returns a column vector resulting from the folding of f on each column 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]

Common statistics operations

`pub fn sum(&self) -> N where N: ClosedAdd<N> + Zero,` [src]

The sum of all the elements of this matrix.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.sum(), 21.0);

`pub fn row_sum( &self ) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where N: ClosedAdd<N> + Zero, DefaultAllocator: Allocator<N, U1, C>,` [src]

The sum of all the rows of this matrix.

Use .row_variance_tr if you need the result in a column vector instead.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_sum(), RowVector3::new(5.0, 7.0, 9.0));

let mint = Matrix3x2::new(1,2,3,4,5,6);
assert_eq!(mint.row_sum(), RowVector2::new(9,12));

`pub fn row_sum_tr( &self ) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where N: ClosedAdd<N> + Zero, DefaultAllocator: Allocator<N, C, U1>,` [src]

The sum of all the rows of this matrix. The result is transposed and returned as a column vector.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_sum_tr(), Vector3::new(5.0, 7.0, 9.0));

let mint = Matrix3x2::new(1,2,3,4,5,6);
assert_eq!(mint.row_sum_tr(), Vector2::new(9,12));

`pub fn column_sum( &self ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where N: ClosedAdd<N> + Zero, DefaultAllocator: Allocator<N, R, U1>,` [src]

The sum of all the columns of this matrix.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.column_sum(), Vector2::new(6.0, 15.0));

let mint = Matrix3x2::new(1,2,3,4,5,6);
assert_eq!(mint.column_sum(), Vector3::new(3,7,11));

`pub fn variance(&self) -> N where N: Field + SupersetOf<f64>,` [src]

The variance of all the elements of this matrix.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8);

`pub fn row_variance( &self ) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where N: Field + SupersetOf<f64>, DefaultAllocator: Allocator<N, U1, C>,` [src]

The variance of all the rows of this matrix.

Use .row_variance_tr if you need the result in a column vector instead.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25));

`pub fn row_variance_tr( &self ) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where N: Field + SupersetOf<f64>, DefaultAllocator: Allocator<N, C, U1>,` [src]

The variance of all the rows of this matrix. The result is transposed and returned as a column vector.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25));

`pub fn column_variance( &self ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where N: Field + SupersetOf<f64>, DefaultAllocator: Allocator<N, R, U1>,` [src]

The variance of all the columns of this matrix.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8);

`pub fn mean(&self) -> N where N: Field + SupersetOf<f64>,` [src]

The mean of all the elements of this matrix.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.mean(), 3.5);

`pub fn row_mean( &self ) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where N: Field + SupersetOf<f64>, DefaultAllocator: Allocator<N, U1, C>,` [src]

The mean of all the rows of this matrix.

Use .row_mean_tr if you need the result in a column vector instead.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5));

`pub fn row_mean_tr( &self ) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where N: Field + SupersetOf<f64>, DefaultAllocator: Allocator<N, C, U1>,` [src]

The mean of all the rows of this matrix. The result is transposed and returned as a column vector.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5));

`pub fn column_mean( &self ) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where N: Field + SupersetOf<f64>, DefaultAllocator: Allocator<N, R, U1>,` [src]

The mean of all the columns of this matrix.

Example


let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0));

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

Swizzling

`pub fn xx( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UTerm>, <<D as DimName>::Value as Cmp<UTerm>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xxx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UTerm>, <<D as DimName>::Value as Cmp<UTerm>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xy( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yx( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yy( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xxy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xyx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xyy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yxx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yxy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yyx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yyy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UTerm, B1>>, <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xz( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yz( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zx( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zy( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zz( &self ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xxz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xyz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xzx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xzy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn xzz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yxz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yyz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yzx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yzy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn yzz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zxx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zxy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zxz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zyx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zyy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zyz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zzx( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zzy( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`pub fn zzz( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>, <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,` [src]

Builds a new vector from components of self.

`impl<N, D, S> Matrix<N, D, U1, S> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedSub<N> + ClosedMul<N>, D: Dim, S: Storage<N, D, U1>,` [src]

Interpolation

`pub fn lerp<S2>( &self, rhs: &Matrix<N, D, U1, S2>, t: N ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where S2: Storage<N, D, U1>, DefaultAllocator: Allocator<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));

`pub fn slerp<S2>( &self, rhs: &Matrix<N, D, U1, S2>, t: N ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where N: RealField, S2: Storage<N, D, U1>, DefaultAllocator: Allocator<N, D, U1>,` [src]

Computes the spherical linear interpolation between two non-zero vectors.

The result is a unit vector.

Examples:


let v1 =Vector2::new(1.0, 2.0);
let v2 = Vector2::new(2.0, -3.0);

let v = v1.slerp(&v2, 1.0);

assert_eq!(v, v2.normalize());

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

Find the min and max components

`pub fn amax(&self) -> N where N: Zero + SimdSigned + SimdPartialOrd,` [src]

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

Example

assert_eq!(Vector3::new(-1.0, 2.0, 3.0).amax(), 3.0);
assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0);

`pub fn camax(&self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

Returns the the 1-norm of the complex component with the largest 1-norm.

Example

assert_eq!(Vector3::new(
    Complex::new(-3.0, -2.0),
    Complex::new(1.0, 2.0),
    Complex::new(1.0, 3.0)).camax(), 5.0);

`pub fn max(&self) -> N where N: SimdPartialOrd + Zero,` [src]

Returns the component with the largest value.

Example

assert_eq!(Vector3::new(-1.0, 2.0, 3.0).max(), 3.0);
assert_eq!(Vector3::new(-1.0, -2.0, -3.0).max(), -1.0);
assert_eq!(Vector3::new(5u32, 2, 3).max(), 5);

`pub fn amin(&self) -> N where N: Zero + SimdPartialOrd + SimdSigned,` [src]

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

Example

assert_eq!(Vector3::new(-1.0, 2.0, -3.0).amin(), 1.0);
assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0);

`pub fn camin(&self) -> <N as SimdComplexField>::SimdRealField where N: SimdComplexField,` [src]

Returns the the 1-norm of the complex component with the smallest 1-norm.

Example

assert_eq!(Vector3::new(
    Complex::new(-3.0, -2.0),
    Complex::new(1.0, 2.0),
    Complex::new(1.0, 3.0)).camin(), 3.0);

`pub fn min(&self) -> N where N: SimdPartialOrd + Zero,` [src]

Returns the component with the smallest value.

Example

assert_eq!(Vector3::new(-1.0, 2.0, 3.0).min(), -1.0);
assert_eq!(Vector3::new(1.0, 2.0, 3.0).min(), 1.0);
assert_eq!(Vector3::new(5u32, 2, 3).min(), 2);

`pub fn icamax_full(&self) -> (usize, usize) where N: ComplexField,` [src]

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

Examples:

let mat = Matrix2x3::new(Complex::new(11.0, 1.0), Complex::new(-12.0, 2.0), Complex::new(13.0, 3.0),
                         Complex::new(21.0, 43.0), Complex::new(22.0, 5.0), Complex::new(-23.0, 0.0));
assert_eq!(mat.icamax_full(), (1, 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]

`pub fn iamax_full(&self) -> (usize, usize)`[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, D, S> Matrix<N, D, U1, S> where N: Scalar, D: Dim, S: Storage<N, D, U1>,` [src]

Find the min and max components (vector-specific methods)

`pub fn icamax(&self) -> usize where N: ComplexField,` [src]

Computes the index of the vector component with the largest complex or real absolute value.

Examples:

let vec = Vector3::new(Complex::new(11.0, 3.0), Complex::new(-15.0, 0.0), Complex::new(13.0, 5.0));
assert_eq!(vec.icamax(), 2);

`pub fn argmax(&self) -> (usize, N) where N: PartialOrd<N>,` [src]

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

Examples:

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

`pub fn imax(&self) -> usize where N: PartialOrd<N>,` [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);

`pub fn iamax(&self) -> usize where N: PartialOrd<N> + Signed,` [src]

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);

`pub fn argmin(&self) -> (usize, N) where N: PartialOrd<N>,` [src]

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

Examples:

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

`pub fn imin(&self) -> usize where N: PartialOrd<N>,` [src]

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

Examples:

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

`pub fn iamin(&self) -> usize where N: PartialOrd<N> + Signed,` [src]

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, D1, S1> Matrix<N, D1, U1, S1> where N: RealField, D1: Dim, S1: Storage<N, D1, U1>,` [src]

pub fn convolve_full<D2, S2>( &self, kernel: Matrix<N, D2, U1, S2> ) -> Matrix<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1>>::Buffer> where D2: DimAdd<D1, Output = <D1 as DimAdd<D2>>::Output>, D1: DimAdd<D2>, S2: Storage<N, D2, U1>, <D1 as DimAdd<D2>>::Output: DimSub<U1>, DefaultAllocator: Allocator<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1>, [src]

Returns the convolution of the target vector and a kernel.

Arguments

kernel - A Vector with size > 0

Errors

Inputs must satisfy vector.len() >= kernel.len() > 0.

`pub fn convolve_valid<D2, S2>( &self, kernel: Matrix<N, D2, U1, S2> ) -> Matrix<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1, <DefaultAllocator as Allocator<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1>>::Buffer> where D2: Dim, D1: DimAdd<U1>, S2: Storage<N, D2, U1>, <D1 as DimAdd<U1>>::Output: DimSub<D2>, DefaultAllocator: Allocator<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1>,` [src]

Returns the convolution of the target vector and a kernel.

The output convolution consists only of those elements that do not rely on the zero-padding.

Arguments

kernel - A Vector with size > 0

Errors

Inputs must satisfy self.len() >= kernel.len() > 0.

`pub fn convolve_same<D2, S2>( &self, kernel: Matrix<N, D2, U1, S2> ) -> Matrix<N, D1, U1, <DefaultAllocator as Allocator<N, D1, U1>>::Buffer> where D2: Dim, S2: Storage<N, D2, U1>, DefaultAllocator: Allocator<N, D1, U1>,` [src]

Returns the convolution of the target vector and a kernel.

The output convolution is the same size as vector, centered with respect to the ‘full’ output.

Arguments

kernel - A Vector with size > 0

Errors

Inputs must satisfy self.len() >= kernel.len() > 0.

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

`pub fn determinant(&self) -> N where DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<(usize, usize), D, U1>,` [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: ComplexField, R: Dim, S: Storage<N, R, C>,` [src]

Rectangular matrix decomposition

This section contains the methods for computing some common decompositions of rectangular matrices with real or complex components. The following are currently supported:

Decomposition	Factors	Details
QR	`Q * R`	`Q` is an unitary matrix, and `R` is upper-triangular.
LU with partial pivoting	`P⁻¹ * L * U`	`L` is lower-triangular with a diagonal filled with `1` and `U` is upper-triangular. `P` is a permutation matrix.
LU with full pivoting	`P⁻¹ * L * U ~ Q⁻¹`	`L` is lower-triangular with a diagonal filled with `1` and `U` is upper-triangular. `P` and `Q` are permutation matrices.
SVD	`U * Σ * Vᵀ`	`U` and `V` are two orthogonal matrices and `Σ` is a diagonal matrix containing the singular values.

`pub fn bidiagonalize(self) -> Bidiagonal<N, R, C> where R: DimMin<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.

`pub fn full_piv_lu(self) -> FullPivLU<N, R, C> where R: DimMin<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.

`pub fn lu(self) -> LU<N, R, C> where R: DimMin<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.

`pub fn qr(self) -> QR<N, R, C> where R: DimMin<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.

pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C> where R: DimMin<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>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>, [src]

Computes the Singular Value Decomposition using implicit shift.

pub fn try_svd( self, compute_u: bool, compute_v: bool, eps: <N as ComplexField>::RealField, max_niter: usize ) -> Option<SVD<N, R, C>> where R: DimMin<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>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>, [src]

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

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

Square matrix decomposition

This section contains the methods for computing some common decompositions of square matrices with real or complex components. The following are currently supported:

Decomposition	Factors	Details
Hessenberg	`Q * H * Qᵀ`	`Q` is a unitary matrix and `H` an upper-Hessenberg matrix.
Cholesky	`L * Lᵀ`	`L` is a lower-triangular matrix.
Schur decomposition	`Q * T * Qᵀ`	`Q` is an unitary matrix and `T` a quasi-upper-triangular matrix.
Symmetric eigendecomposition	`Q ~ Λ ~ Qᵀ`	`Q` is an unitary matrix, and `Λ` is a real diagonal matrix.
Symmetric tridiagonalization	`Q ~ T ~ Qᵀ`	`Q` is an unitary matrix, and `T` is a tridiagonal matrix.

`pub fn cholesky(self) -> Option<Cholesky<N, D>> where 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.

`pub fn hessenberg(self) -> Hessenberg<N, D> where D: DimSub<U1>, 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.

`pub fn schur(self) -> Schur<N, D> where D: DimSub<U1>, 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.

`pub fn try_schur( self, eps: <N as ComplexField>::RealField, max_niter: usize ) -> Option<Schur<N, D>> where D: DimSub<U1>, 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]

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.

`pub fn symmetric_eigen(self) -> SymmetricEigen<N, D> where D: DimSub<U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, D, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <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.

`pub fn try_symmetric_eigen( self, eps: <N as ComplexField>::RealField, max_niter: usize ) -> Option<SymmetricEigen<N, D>> where D: DimSub<U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, D, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <D as DimSub<U1>>::Output, U1>,` [src]

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.

`pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<N, D> where D: DimSub<U1>, 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, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where N: ComplexField, D: DimMin<D, Output = D>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<(usize, usize), <D as DimMin<D>>::Output, U1>, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, D, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, D, D>,` [src]

`pub fn exp( &self ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

Computes exponential of this matrix

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

`#[must_use = "Did you mean to use try_inverse_mut()?"] pub fn try_inverse( self ) -> Option<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> where DefaultAllocator: Allocator<N, D, D>,` [src]

Attempts to invert this matrix.

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

`pub fn try_inverse_mut(&mut self) -> bool where DefaultAllocator: Allocator<N, D, D>,` [src]

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

`impl<N, D, S> Matrix<N, D, D, S> where N: ComplexField, D: Dim + DimSub<U1>, S: Storage<N, D, D>, 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]

`pub fn eigenvalues( &self ) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>`[src]

Computes the eigenvalues of this matrix.

`pub fn complex_eigenvalues( &self ) -> Matrix<Complex<N>, D, U1, <DefaultAllocator as Allocator<Complex<N>, D, U1>>::Buffer> where N: RealField, DefaultAllocator: Allocator<Complex<N>, D, U1>,` [src]

Computes the eigenvalues of this matrix.

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

`pub fn solve_lower_triangular<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, 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.

`pub fn solve_upper_triangular<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn solve_lower_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn solve_lower_triangular_with_diag_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2>, diag: N ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn solve_upper_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_lower_triangular<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_upper_triangular<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_lower_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_upper_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn ad_solve_lower_triangular<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

`pub fn ad_solve_upper_triangular<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

`pub fn ad_solve_lower_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

`pub fn ad_solve_upper_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) -> bool where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

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

`pub fn solve_lower_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, 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.

`pub fn solve_upper_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn solve_lower_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn solve_lower_triangular_with_diag_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2>, diag: N ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn solve_upper_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_lower_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_upper_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_lower_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn tr_solve_upper_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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.

`pub fn ad_solve_lower_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

`pub fn ad_solve_upper_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<N, R2, C2, S2> ) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where C2: Dim, R2: Dim, S2: Storage<N, R2, C2>, DefaultAllocator: Allocator<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

`pub fn ad_solve_lower_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

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

`pub fn ad_solve_upper_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<N, R2, C2, S2> ) where C2: Dim, R2: Dim, S2: StorageMut<N, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,` [src]

Solves the linear system self.adjoint() . 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: ComplexField, 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>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>, [src]

`pub fn singular_values( &self ) -> Matrix<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1, <DefaultAllocator as Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>>::Buffer>`[src]

Computes the singular values of this matrix.

`pub fn rank(&self, eps: <N as ComplexField>::RealField) -> usize`[src]

Computes the rank of this matrix.

All singular values below eps are considered equal to 0.

`pub fn pseudo_inverse( self, eps: <N as ComplexField>::RealField ) -> Result<Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer>, &'static str> where DefaultAllocator: Allocator<N, C, R>,` [src]

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 N: ComplexField, D: DimSub<U1>, S: Storage<N, D, D>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, D, U1>, DefaultAllocator: Allocator<<N as ComplexField>::RealField, <D as DimSub<U1>>::Output, U1>,` [src]

`pub fn symmetric_eigenvalues( &self ) -> Matrix<<N as ComplexField>::RealField, D, U1, <DefaultAllocator as Allocator<<N as ComplexField>::RealField, D, U1>>::Buffer>`[src]

Computes the eigenvalues of this symmetric matrix.

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

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

`pub fn add_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<N, R2, C2, SB>, out: &mut Matrix<N, R3, C3, SC> ) where C2: Dim, R2: Dim, SB: Storage<N, R2, C2>, SC: StorageMut<N, R3, C3>, R3: Dim, C3: Dim, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R3>, ShapeConstraint: SameNumberOfColumns<C1, C3>,` [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 N: Scalar + ClosedSub<N>, C1: Dim, R1: Dim, SA: Storage<N, R1, C1>,` [src]

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

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

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

`pub fn from_row_slice( data: &[N] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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(&[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);

`pub fn from_column_slice( data: &[N] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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(&[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);

`pub fn from_vec( data: Vec<N, Global> ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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

`pub fn from_row_slice( data: &[N] ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>`[src]

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(&[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);

`pub fn from_column_slice( data: &[N] ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>`[src]

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(&[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);

`pub fn from_vec( data: Vec<N, Global> ) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>`[src]

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

`pub fn from_row_slice( data: &[N] ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>`[src]

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(&[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);

`pub fn from_column_slice( data: &[N] ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>`[src]

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(&[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);

`pub fn from_vec( data: Vec<N, Global> ) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>`[src]

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

`pub fn from_row_slice( nrows: usize, ncols: usize, data: &[N] ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>`[src]

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(&[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);

`pub fn from_column_slice( nrows: usize, ncols: usize, data: &[N] ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>`[src]

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(&[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);

`pub fn from_vec( nrows: usize, ncols: usize, data: Vec<N, Global> ) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>`[src]

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, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where N: Scalar, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`pub fn new( m11: N, m12: N, m21: N, m22: N ) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N, m41: N, m42: N, m43: N, m44: N, m45: N, m51: N, m52: N, m53: N, m54: N, m55: N ) -> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>`[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]

pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N, m41: N, m42: N, m43: N, m44: N, m45: N, m46: N, m51: N, m52: N, m53: N, m54: N, m55: N, m56: N, m61: N, m62: N, m63: N, m64: N, m65: N, m66: N ) -> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>[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]

`pub fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N ) -> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N ) -> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N ) -> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N ) -> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N ) -> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N ) -> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N ) -> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N ) -> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N ) -> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N ) -> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N, m41: N, m42: N, m43: N, m44: N, m45: N ) -> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N, m41: N, m42: N, m43: N, m44: N, m45: N, m46: N ) -> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N, m51: N, m52: N ) -> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N, m51: N, m52: N, m53: N ) -> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N, m51: N, m52: N, m53: N, m54: N ) -> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>`[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]

pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m16: N, m21: N, m22: N, m23: N, m24: N, m25: N, m26: N, m31: N, m32: N, m33: N, m34: N, m35: N, m36: N, m41: N, m42: N, m43: N, m44: N, m45: N, m46: N, m51: N, m52: N, m53: N, m54: N, m55: N, m56: N ) -> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>[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]

`pub fn new( m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N, m51: N, m52: N, m61: N, m62: N ) -> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N, m51: N, m52: N, m53: N, m61: N, m62: N, m63: N ) -> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>`[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]

`pub fn new( m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N, m51: N, m52: N, m53: N, m54: N, m61: N, m62: N, m63: N, m64: N ) -> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>`[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]

pub fn new( m11: N, m12: N, m13: N, m14: N, m15: N, m21: N, m22: N, m23: N, m24: N, m25: N, m31: N, m32: N, m33: N, m34: N, m35: N, m41: N, m42: N, m43: N, m44: N, m45: N, m51: N, m52: N, m53: N, m54: N, m55: N, m61: N, m62: N, m63: N, m64: N, m65: N ) -> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>[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]

`pub fn new( x: N ) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>`[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]

`pub fn new( x: N, y: N ) -> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N ) -> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N, w: N ) -> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N, w: N, a: N ) -> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N, w: N, a: N, b: N ) -> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>`[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]

`pub fn new( x: N, y: N ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N, w: N ) -> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N, w: N, a: N ) -> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>`[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]

`pub fn new( x: N, y: N, z: N, w: N, a: N, b: N ) -> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>`[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]

`pub fn from_slice( data: &'a [N] ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>`[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a [N], start: usize ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>`[src]

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]

`pub fn from_slice_with_strides( data: &'a [N], rstride: usize, cstride: usize ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a [N], start: usize, rstride: usize, cstride: usize ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a [N], ncols: usize ) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>`[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a [N], start: usize, ncols: usize ) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>`[src]

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]

`pub fn from_slice_with_strides( data: &'a [N], ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a [N], start: usize, ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a [N], nrows: usize ) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>>`[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a [N], start: usize, nrows: usize ) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>>`[src]

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]

`pub fn from_slice_with_strides( data: &'a [N], nrows: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a [N], start: usize, nrows: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a [N], nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, U1, Dynamic>>`[src]

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a [N], start: usize, nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, U1, Dynamic>>`[src]

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]

`pub fn from_slice_with_strides( data: &'a [N], nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a [N], start: usize, nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a mut [N] ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a mut [N], start: usize ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>`[src]

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]

`pub fn from_slice_with_strides_mut( data: &'a mut [N], rstride: usize, cstride: usize ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [N], start: usize, rstride: usize, cstride: usize ) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a mut [N], ncols: usize ) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a mut [N], start: usize, ncols: usize ) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>`[src]

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]

`pub fn from_slice_with_strides_mut( data: &'a mut [N], ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [N], start: usize, ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a mut [N], nrows: usize ) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a mut [N], start: usize, nrows: usize ) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>>`[src]

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]

`pub fn from_slice_with_strides_mut( data: &'a mut [N], nrows: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [N], start: usize, nrows: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>`[src]

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]

`pub fn from_slice( data: &'a mut [N], nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, U1, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_unchecked( data: &'a mut [N], start: usize, nrows: usize, ncols: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, U1, Dynamic>>`[src]

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]

`pub fn from_slice_with_strides_mut( data: &'a mut [N], nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>`[src]

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

Panics if data does not contain enough elements.

`pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [N], start: usize, nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>`[src]

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

Trait Implementations

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

`type Epsilon = <N as AbsDiffEq<N>>::Epsilon`

Used for specifying relative comparisons.

`pub fn default_epsilon( ) -> <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon`[src]

`pub fn abs_diff_eq( &self, other: &Matrix<N, R, C, S>, epsilon: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon ) -> bool`[src]

`pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool`[src]

impl<'a, 'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where N: Scalar + ClosedAdd<N>, D2: Dim, D1: DimName, 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]

`type Output = Point<N, D1>`

The resulting type after applying the + operator.

`pub fn add( self, right: &'b Matrix<N, D2, U1, SB> ) -> <&'a Point<N, D1> as Add<&'b Matrix<N, D2, U1, SB>>>::Output`[src]

impl<'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where N: Scalar + ClosedAdd<N>, D2: Dim, D1: DimName, 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]

`type Output = Point<N, D1>`

The resulting type after applying the + operator.

`pub fn add( self, right: &'b Matrix<N, D2, U1, SB> ) -> <Point<N, D1> as Add<&'b Matrix<N, D2, U1, SB>>>::Output`[src]

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

`type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>`

The resulting type after applying the + operator.

`pub fn add( self, rhs: &'b Matrix<N, R2, C2, SB> ) -> <Matrix<N, R1, C1, SA> as Add<&'b Matrix<N, R2, C2, SB>>>::Output`[src]

`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 N: Scalar + ClosedAdd<N>, C2: Dim, C1: Dim, R1: Dim, R2: Dim, SB: Storage<N, R2, C2>, SA: Storage<N, R1, C1>, DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>,` [src]

`type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>`

The resulting type after applying the + operator.

`pub fn add( self, rhs: &'b Matrix<N, R2, C2, SB> ) -> <&'a Matrix<N, R1, C1, SA> as Add<&'b Matrix<N, R2, C2, SB>>>::Output`[src]

impl<'a, N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where N: Scalar + ClosedAdd<N>, D2: Dim, D1: DimName, 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]

`type Output = Point<N, D1>`

The resulting type after applying the + operator.

`pub fn add( self, right: Matrix<N, D2, U1, SB> ) -> <&'a Point<N, D1> as Add<Matrix<N, D2, U1, SB>>>::Output`[src]

impl<N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for Point<N, D1> where N: Scalar + ClosedAdd<N>, D2: Dim, D1: DimName, 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]

`type Output = Point<N, D1>`

The resulting type after applying the + operator.

`pub fn add( self, right: Matrix<N, D2, U1, SB> ) -> <Point<N, D1> as Add<Matrix<N, D2, U1, SB>>>::Output`[src]

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

`type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>`

The resulting type after applying the + operator.

`pub fn add( self, rhs: Matrix<N, R2, C2, SB> ) -> <Matrix<N, R1, C1, SA> as Add<Matrix<N, R2, C2, SB>>>::Output`[src]

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

`type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>`

The resulting type after applying the + operator.

`pub fn add( self, rhs: Matrix<N, R2, C2, SB> ) -> <&'a Matrix<N, R1, C1, SA> as Add<Matrix<N, R2, C2, SB>>>::Output`[src]

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

`pub fn add_assign(&mut self, right: &'b Matrix<N, D2, U1, SB>)`[src]

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

`pub fn add_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)`[src]

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

`pub fn add_assign(&mut self, right: Matrix<N, D2, U1, SB>)`[src]

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

`pub fn add_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)`[src]

`impl<N> AsBytes for Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where N: RealField,` [src]

`pub fn as_bytes(&'a self) -> &'a [u8]ⓘNotable traits for &'_ mut [u8] impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]`[src]

`impl<N> AsBytes for Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where N: RealField,` [src]

`pub fn as_bytes(&'a self) -> &'a [u8]ⓘNotable traits for &'_ mut [u8] impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]`[src]

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

`pub fn as_mat( &self ) -> &Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn as_pnt(&self) -> &Point<T, U1>`[src]

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

`pub fn as_pnt(&self) -> &Point<T, U2>`[src]

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

`pub fn as_pnt(&self) -> &Point<T, U3>`[src]

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

`pub fn as_pnt(&self) -> &Point<T, U4>`[src]

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

`pub fn as_pnt(&self) -> &Point<T, U5>`[src]

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

`pub fn as_pnt(&self) -> &Point<T, U6>`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn as_vec( &self ) -> &Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>`[src]

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

`pub fn as_vec( &self ) -> &Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>`[src]

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

`pub fn as_vec( &self ) -> &Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`pub fn as_vec( &self ) -> &Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`pub fn as_vec( &self ) -> &Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>`[src]

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

`pub fn as_vec( &self ) -> &Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>`[src]

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

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[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]

`pub fn max_value( ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

`pub fn min_value( ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

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

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

`pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

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

`pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>`[src]

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

`pub fn default() -> Matrix<N, R, C, S>`[src]

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

`type Target = M6x2<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U6, U2, S> as Deref>::Target`[src]

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

`type Target = M6x4<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U6, U4, S> as Deref>::Target`[src]

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

`type Target = XYZW<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U1, U4, S> as Deref>::Target`[src]

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

`type Target = M2x4<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U2, U4, S> as Deref>::Target`[src]

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

`type Target = M3x2<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U3, U2, S> as Deref>::Target`[src]

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

`type Target = M5x2<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U5, U2, S> as Deref>::Target`[src]

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

`type Target = XYZ<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U1, U3, S> as Deref>::Target`[src]

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

`type Target = M5x6<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U5, U6, S> as Deref>::Target`[src]

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

`type Target = XYZWA<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U5, U1, S> as Deref>::Target`[src]

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

`type Target = M5x4<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U5, U4, S> as Deref>::Target`[src]

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

`type Target = M3x6<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U3, U6, S> as Deref>::Target`[src]

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

`type Target = M2x2<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U2, U2, S> as Deref>::Target`[src]

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

`type Target = M5x3<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U5, U3, S> as Deref>::Target`[src]

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

`type Target = XYZWAB<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U1, U6, S> as Deref>::Target`[src]

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

`type Target = M2x6<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U2, U6, S> as Deref>::Target`[src]

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

`type Target = M4x4<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U4, U4, S> as Deref>::Target`[src]

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

`type Target = X<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U1, U1, S> as Deref>::Target`[src]

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

`type Target = M3x4<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U3, U4, S> as Deref>::Target`[src]

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

`type Target = M4x3<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U4, U3, S> as Deref>::Target`[src]

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

`type Target = XYZWAB<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U6, U1, S> as Deref>::Target`[src]

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

`type Target = M2x5<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U2, U5, S> as Deref>::Target`[src]

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

`type Target = M6x5<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U6, U5, S> as Deref>::Target`[src]

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

`type Target = M3x3<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U3, U3, S> as Deref>::Target`[src]

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

`type Target = XYZW<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U4, U1, S> as Deref>::Target`[src]

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

`type Target = XY<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U1, U2, S> as Deref>::Target`[src]

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

`type Target = XYZWA<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U1, U5, S> as Deref>::Target`[src]

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

`type Target = XYZ<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U3, U1, S> as Deref>::Target`[src]

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

`type Target = XY<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U2, U1, S> as Deref>::Target`[src]

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

`type Target = M4x5<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U4, U5, S> as Deref>::Target`[src]

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

`type Target = M2x3<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U2, U3, S> as Deref>::Target`[src]

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

`type Target = M4x6<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U4, U6, S> as Deref>::Target`[src]

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

`type Target = M6x6<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U6, U6, S> as Deref>::Target`[src]

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

`type Target = M4x2<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U4, U2, S> as Deref>::Target`[src]

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

`type Target = M5x5<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U5, U5, S> as Deref>::Target`[src]

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

`type Target = M3x5<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U3, U5, S> as Deref>::Target`[src]

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

`type Target = M6x3<N>`

The resulting type after dereferencing.

`pub fn deref(&self) -> &<Matrix<N, U6, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U1, U5, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U5, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U3, U6, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U2, U1, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U1, U1, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U4, U4, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U5, U5, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U2, U2, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U6, U4, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U6, U2, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U5, U4, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U6, U5, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U5, U2, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U4, U2, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U4, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U3, U5, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U1, U6, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U4, U6, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U2, U6, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U4, U1, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U6, U1, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U4, U5, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U1, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U2, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U6, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U2, U5, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U5, U1, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U3, U2, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U1, U4, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U5, U6, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U3, U4, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U2, U4, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U1, U2, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U6, U6, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U3, U3, S> as Deref>::Target`[src]

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

`pub fn deref_mut(&mut self) -> &mut <Matrix<N, U3, U1, S> as Deref>::Target`[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]

`pub fn deserialize<D>( deserializer: D ) -> Result<Matrix<N, R, C, S>, <D as Deserializer<'de>>::Error> where D: Deserializer<'de>,` [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]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, 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]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Rotation<N, D2> ) -> <Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output`[src]

`impl<'a, 'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, 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]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Rotation<N, D2> ) -> <&'a Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output`[src]

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

`type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div(self, rhs: N) -> <&'a Matrix<N, R, C, S> as Div<N>>::Output`[src]

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

`type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div(self, rhs: N) -> <Matrix<N, R, C, S> as Div<N>>::Output`[src]

`impl<N, R1, C1, D2, SA> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, 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]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: Rotation<N, D2> ) -> <Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output`[src]

`impl<'a, N, R1, C1, D2, SA> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, 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]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: Rotation<N, D2> ) -> <&'a Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output`[src]

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

`pub fn div_assign(&mut self, right: &'b Rotation<N, 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]

`pub fn div_assign(&mut self, rhs: N)`[src]

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

`pub fn div_assign(&mut self, right: Rotation<N, C1>)`[src]

`impl<N, R, S, RV, SV> Extend<Matrix<N, RV, U1, SV>> for Matrix<N, R, Dynamic, S> where N: Scalar, R: Dim, S: Extend<Matrix<N, RV, U1, SV>>, RV: Dim, SV: Storage<N, RV, U1>, ShapeConstraint: SameNumberOfRows<R, RV>,` [src]

`pub fn extend(&mut self, iter: I) where I: IntoIterator<Item = Matrix<N, RV, U1, SV>>,` [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!

`pub fn extend_one(&mut self, item: A)`[src]

`pub fn extend_reserve(&mut self, additional: usize)`[src]

`impl<N, R, RV, SV> Extend<Matrix<N, RV, U1, SV>> for VecStorage<N, R, Dynamic> where N: Scalar, R: Dim, RV: Dim, SV: Storage<N, RV, U1>, ShapeConstraint: SameNumberOfRows<R, RV>,` [src]

`pub fn extend(&mut self, iter: I) where I: IntoIterator<Item = Matrix<N, RV, U1, SV>>,` [src]

Extends the number of columns of the VecStorage 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 VecStorage.

`pub fn extend_one(&mut self, item: A)`[src]

`pub fn extend_reserve(&mut self, additional: usize)`[src]

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

`pub fn extend(&mut self, iter: I) where I: IntoIterator<Item = N>,` [src]

Extend the number of rows of a Vector with elements from the given iterator.

Example

let mut vector = DVector::from_vec(vec![0, 1, 2]);
vector.extend(vec![3, 4, 5]);
assert!(vector.eq(&DVector::from_vec(vec![0, 1, 2, 3, 4, 5])));

`pub fn extend_one(&mut self, item: A)`[src]

`pub fn extend_reserve(&mut self, additional: usize)`[src]

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

`pub fn extend(&mut self, iter: I) where I: IntoIterator<Item = N>,` [src]

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]);

`pub fn extend_one(&mut self, item: A)`[src]

`pub fn extend_reserve(&mut self, additional: usize)`[src]

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

`pub fn fast_orthonormal_inverse( &self ) -> Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>`[src]

`pub fn fast_affine_inverse( &self ) -> Option<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>>`[src]

`impl<'a, N> From<&'a [N]> for Matrix<N, Dynamic, U1, SliceStorage<'a, N, Dynamic, U1, U1, Dynamic>> where N: Scalar + Copy,` [src]

`pub fn from( slice: &'a [N] ) -> Matrix<N, Dynamic, U1, SliceStorage<'a, N, Dynamic, U1, U1, Dynamic>>`[src]

impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix<N, R, C, S>> for Matrix<N, RSlice, CSlice, SliceStorage<'a, N, RSlice, CSlice, RStride, CStride>> where C: Dim, N: Scalar, R: Dim, S: Storage<N, R, C>, RStride: Dim, CStride: Dim, RSlice: Dim, CSlice: Dim, ShapeConstraint: DimEq<R, RSlice>, ShapeConstraint: DimEq<C, CSlice>, ShapeConstraint: DimEq<RStride, <S as Storage<N, R, C>>::RStride>, ShapeConstraint: DimEq<CStride, <S as Storage<N, R, C>>::CStride>, [src]

`pub fn from( m: &'a Matrix<N, R, C, S> ) -> Matrix<N, RSlice, CSlice, SliceStorage<'a, N, RSlice, CSlice, RStride, CStride>>`[src]

`impl<'a> From<&'a Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>> for Model`[src]

`pub fn from( mat: &Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer> ) -> Model`[src]

`impl<'a, N> From<&'a mut [N]> for Matrix<N, Dynamic, U1, SliceStorageMut<'a, N, Dynamic, U1, U1, Dynamic>> where N: Scalar + Copy,` [src]

`pub fn from( slice: &'a mut [N] ) -> Matrix<N, Dynamic, U1, SliceStorageMut<'a, N, Dynamic, U1, U1, Dynamic>>`[src]

impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<N, R, C, S>> for Matrix<N, RSlice, CSlice, SliceStorageMut<'a, N, RSlice, CSlice, RStride, CStride>> where C: Dim, N: Scalar, R: Dim, S: StorageMut<N, R, C>, RStride: Dim, CStride: Dim, RSlice: Dim, CSlice: Dim, ShapeConstraint: DimEq<R, RSlice>, ShapeConstraint: DimEq<C, CSlice>, ShapeConstraint: DimEq<RStride, <S as Storage<N, R, C>>::RStride>, ShapeConstraint: DimEq<CStride, <S as Storage<N, R, C>>::CStride>, [src]

`pub fn from( m: &'a mut Matrix<N, R, C, S> ) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'a, N, RSlice, CSlice, RStride, CStride>>`[src]

impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<N, R, C, S>> for Matrix<N, RSlice, CSlice, SliceStorage<'a, N, RSlice, CSlice, RStride, CStride>> where C: Dim, N: Scalar, R: Dim, S: Storage<N, R, C>, RStride: Dim, CStride: Dim, RSlice: Dim, CSlice: Dim, ShapeConstraint: DimEq<R, RSlice>, ShapeConstraint: DimEq<C, CSlice>, ShapeConstraint: DimEq<RStride, <S as Storage<N, R, C>>::RStride>, ShapeConstraint: DimEq<CStride, <S as Storage<N, R, C>>::CStride>, [src]

`pub fn from( m: &'a mut Matrix<N, R, C, S> ) -> Matrix<N, RSlice, CSlice, SliceStorage<'a, N, RSlice, CSlice, RStride, CStride>>`[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]

`pub fn from( arr: [[N; 2]; 2] ) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>`[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]

`pub fn from( arr: [[N; 2]; 3] ) -> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>`[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]

`pub fn from( arr: [[N; 2]; 4] ) -> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>`[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]

`pub fn from( arr: [[N; 2]; 5] ) -> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>`[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]

`pub fn from( arr: [[N; 2]; 6] ) -> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>`[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]

`pub fn from( arr: [[N; 3]; 2] ) -> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>`[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]

`pub fn from( arr: [[N; 3]; 3] ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[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]

`pub fn from( arr: [[N; 3]; 4] ) -> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>`[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]

`pub fn from( arr: [[N; 3]; 5] ) -> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>`[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]

`pub fn from( arr: [[N; 3]; 6] ) -> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>`[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]

`pub fn from( arr: [[N; 4]; 2] ) -> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>`[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]

`pub fn from( arr: [[N; 4]; 3] ) -> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>`[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]

`pub fn from( arr: [[N; 4]; 4] ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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]

`pub fn from( arr: [[N; 4]; 5] ) -> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>`[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]

`pub fn from( arr: [[N; 4]; 6] ) -> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>`[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]

`pub fn from( arr: [[N; 5]; 2] ) -> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>`[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]

`pub fn from( arr: [[N; 5]; 3] ) -> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>`[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]

`pub fn from( arr: [[N; 5]; 4] ) -> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>`[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]

`pub fn from( arr: [[N; 5]; 5] ) -> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>`[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]

`pub fn from( arr: [[N; 5]; 6] ) -> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>`[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]

`pub fn from( arr: [[N; 6]; 2] ) -> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>`[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]

`pub fn from( arr: [[N; 6]; 3] ) -> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>`[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]

`pub fn from( arr: [[N; 6]; 4] ) -> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>`[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]

`pub fn from( arr: [[N; 6]; 5] ) -> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>`[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]

`pub fn from( arr: [[N; 6]; 6] ) -> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>`[src]

impl<N, R, C> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 16]> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where C: Dim, N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 16]>, R: Dim, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: SimdValue, DefaultAllocator: Allocator<N, R, C>, DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>, [src]

`pub fn from( arr: [Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 16] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

impl<N, R, C> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 2]> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where C: Dim, N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 2]>, R: Dim, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: SimdValue, DefaultAllocator: Allocator<N, R, C>, DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>, [src]

`pub fn from( arr: [Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 2] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

impl<N, R, C> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 4]> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where C: Dim, N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 4]>, R: Dim, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: SimdValue, DefaultAllocator: Allocator<N, R, C>, DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>, [src]

`pub fn from( arr: [Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 4] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[src]

impl<N, R, C> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 8]> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where C: Dim, N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 8]>, R: Dim, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: SimdValue, DefaultAllocator: Allocator<N, R, C>, DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>, [src]

`pub fn from( arr: [Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 8] ) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>`[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]

`pub fn from( arr: [N; 1] ) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 10] ) -> Matrix<N, U10, U1, <DefaultAllocator as Allocator<N, U10, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 10] ) -> Matrix<N, U1, U10, <DefaultAllocator as Allocator<N, U1, U10>>::Buffer>`[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]

`pub fn from( arr: [N; 11] ) -> Matrix<N, U1, U11, <DefaultAllocator as Allocator<N, U1, U11>>::Buffer>`[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]

`pub fn from( arr: [N; 11] ) -> Matrix<N, U11, U1, <DefaultAllocator as Allocator<N, U11, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 12] ) -> Matrix<N, U1, U12, <DefaultAllocator as Allocator<N, U1, U12>>::Buffer>`[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]

`pub fn from( arr: [N; 12] ) -> Matrix<N, U12, U1, <DefaultAllocator as Allocator<N, U12, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 13] ) -> Matrix<N, U1, U13, <DefaultAllocator as Allocator<N, U1, U13>>::Buffer>`[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]

`pub fn from( arr: [N; 13] ) -> Matrix<N, U13, U1, <DefaultAllocator as Allocator<N, U13, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 14] ) -> Matrix<N, U14, U1, <DefaultAllocator as Allocator<N, U14, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 14] ) -> Matrix<N, U1, U14, <DefaultAllocator as Allocator<N, U1, U14>>::Buffer>`[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]

`pub fn from( arr: [N; 15] ) -> Matrix<N, U15, U1, <DefaultAllocator as Allocator<N, U15, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 15] ) -> Matrix<N, U1, U15, <DefaultAllocator as Allocator<N, U1, U15>>::Buffer>`[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]

`pub fn from( arr: [N; 16] ) -> Matrix<N, U16, U1, <DefaultAllocator as Allocator<N, U16, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 16] ) -> Matrix<N, U1, U16, <DefaultAllocator as Allocator<N, U1, U16>>::Buffer>`[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]

`pub fn from( arr: [N; 2] ) -> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>`[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]

`pub fn from( arr: [N; 2] ) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 3] ) -> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>`[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]

`pub fn from( arr: [N; 3] ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 4] ) -> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 4] ) -> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>`[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]

`pub fn from( arr: [N; 5] ) -> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 5] ) -> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>`[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]

`pub fn from( arr: [N; 6] ) -> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>`[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]

`pub fn from( arr: [N; 6] ) -> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 7] ) -> Matrix<N, U7, U1, <DefaultAllocator as Allocator<N, U7, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 7] ) -> Matrix<N, U1, U7, <DefaultAllocator as Allocator<N, U1, U7>>::Buffer>`[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]

`pub fn from( arr: [N; 8] ) -> Matrix<N, U1, U8, <DefaultAllocator as Allocator<N, U1, U8>>::Buffer>`[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]

`pub fn from( arr: [N; 8] ) -> Matrix<N, U8, U1, <DefaultAllocator as Allocator<N, U8, U1>>::Buffer>`[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]

`pub fn from( arr: [N; 9] ) -> Matrix<N, U9, U1, <DefaultAllocator as Allocator<N, U9, U1>>::Buffer>`[src]

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

`pub fn from( arr: [N; 9] ) -> Matrix<N, U1, U9, <DefaultAllocator as Allocator<N, U1, U9>>::Buffer>`[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 N: SimdRealField, D: DimName + DimNameAdd<U1>, 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]

`pub fn from( iso: Isometry<N, D, R> ) -> 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>`[src]

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

`pub fn from( coords: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> ) -> Point<N, D>`[src]

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

`pub fn from( vector: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> ) -> Translation<N, D>`[src]

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

`pub fn from( matrix_slice: Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, RStride, CStride>> ) -> Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>`[src]

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

`pub fn from( matrix_slice: Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, RStride, CStride>> ) -> Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>`[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, ArrayStorage<N, R, C>> where C: DimName, N: Scalar, R: DimName, RStride: Dim, CStride: Dim, <R as DimName>::Value: Mul<<C as DimName>::Value>, <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,` [src]

`pub fn from( matrix_slice: Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>> ) -> Matrix<N, R, C, ArrayStorage<N, R, C>>`[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, ArrayStorage<N, R, C>> where C: DimName, N: Scalar, R: DimName, RStride: Dim, CStride: Dim, <R as DimName>::Value: Mul<<C as DimName>::Value>, <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,` [src]

`pub fn from( matrix_slice: Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>> ) -> Matrix<N, R, C, ArrayStorage<N, R, C>>`[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, SliceStorage<'a, N, R, C, RStride, CStride>> where C: Dim, N: Scalar, R: Dim, RStride: Dim, CStride: Dim,` [src]

`pub fn from( slice_mut: Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>> ) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>`[src]

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

`pub fn from( matrix_slice: Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, RStride, CStride>> ) -> Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>`[src]

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

`pub fn from( matrix_slice: Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, RStride, CStride>> ) -> Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>`[src]

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

`pub fn from( coords: Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer> ) -> Quaternion<N>`[src]

`impl From<Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>> for Model`[src]

`pub fn from( mat: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer> ) -> Model`[src]

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

`pub fn from( orth: Orthographic3<N> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

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

`pub fn from( pers: Perspective3<N> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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 N: Scalar + Zero + One, D: DimName + DimNameAdd<U1>, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,` [src]

`pub fn from( t: Point<N, D> ) -> Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>`[src]

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

`pub fn from( q: Rotation<N, U2> ) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>`[src]

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

`pub fn from( q: Rotation<N, U2> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

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

`pub fn from( q: Rotation<N, U3> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

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

`pub fn from( q: Rotation<N, U3> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[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 N: SimdRealField, D: DimName + DimNameAdd<U1>, 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]

`pub fn from( sim: Similarity<N, D, R> ) -> 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>`[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, N: RealField, D: DimName + DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,` [src]

`pub fn from( t: Transform<N, D, C> ) -> 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>`[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 N: Scalar + Zero + One, D: DimName + DimNameAdd<U1>, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,` [src]

`pub fn from( t: Translation<N, D> ) -> 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>`[src]

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

`pub fn from( q: Unit<Complex<N>> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

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

`pub fn from( q: Unit<Complex<N>> ) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>`[src]

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

`pub fn from( q: Unit<Quaternion<N>> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

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

`pub fn from( q: Unit<Quaternion<N>> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

`impl<'a, N> From<Vec<N, Global>> for Matrix<N, Dynamic, U1, VecStorage<N, Dynamic, U1>> where N: Scalar,` [src]

`pub fn from( vec: Vec<N, Global> ) -> Matrix<N, Dynamic, U1, VecStorage<N, Dynamic, U1>>`[src]

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

`pub fn hash<H>(&self, state: &mut H) where H: Hasher,` [src]

`pub fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0 [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]

`type Output = N`

The returned type after indexing.

`pub fn index( &self, ij: (usize, usize) ) -> &<Matrix<N, R, C, S> as Index<(usize, usize)>>::Output`[src]

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

`type Output = N`

The returned type after indexing.

`pub fn index(&self, i: usize) -> &<Matrix<N, R, C, S> as Index<usize>>::Output`[src]

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

`pub fn index_mut(&mut self, ij: (usize, usize)) -> &mut N`[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]

`pub fn index_mut(&mut self, i: usize) -> &mut N`[src]

`impl<'a, N, R, C, S> Into<&'a [N]> for &'a Matrix<N, R, C, S> where C: Dim, N: Scalar + Copy, R: Dim, S: ContiguousStorage<N, R, C>,` [src]

`pub fn into(self) -> &'a [N]ⓘNotable traits for &'_ mut [u8] impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]`[src]

`impl<'a, N, R, C, S> Into<&'a mut [N]> for &'a mut Matrix<N, R, C, S> where C: Dim, N: Scalar + Copy, R: Dim, S: ContiguousStorageMut<N, R, C>,` [src]

`pub fn into(self) -> &'a mut [N]ⓘNotable traits for &'_ mut [u8] impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`type Item = &'a mut N`

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

`pub fn into_iter(self) -> <&'a mut Matrix<N, R, C, S> as IntoIterator>::IntoIter`[src]

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

`type Item = &'a N`

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

`pub fn into_iter(self) -> <&'a Matrix<N, R, C, S> as IntoIterator>::IntoIter`[src]

`impl IntoUniformValueRef for Matrix<i32, U2, U1, <DefaultAllocator as Allocator<i32, U2, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<u32, U3, U1, <DefaultAllocator as Allocator<u32, U3, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<i32, U4, U1, <DefaultAllocator as Allocator<i32, U4, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<u32, U2, U1, <DefaultAllocator as Allocator<u32, U2, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<f32, U4, U1, <DefaultAllocator as Allocator<f32, U4, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<u32, U4, U1, <DefaultAllocator as Allocator<u32, U4, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<i32, U3, U1, <DefaultAllocator as Allocator<i32, U3, U1>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

`impl IntoUniformValueRef for Matrix<f32, U3, U3, <DefaultAllocator as Allocator<f32, U3, U3>>::Buffer>`[src]

`pub fn into_uniform_value_ref(&self) -> UniformValueRef<'_>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`pub fn into_vec( self ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

`impl<T> IsParallel for Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> where T: PartialEq<T> + Scalar + RealField + Float,` [src]

`pub fn is_parallel( &self, other: &Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> ) -> bool`[src]

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

`type Output = Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`

`pub fn join( self, v: Matrix<T, U2, U1, S> ) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`

`pub fn join( self, v: Matrix<T, U2, U1, S> ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`

`pub fn join( self, v: Matrix<T, U2, U1, S2> ) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`

`pub fn join( self, v: Matrix<T, U3, U1, S> ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`

`pub fn join( self, v: Matrix<T, U3, U1, S3> ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>`

`pub fn join( self, v: T ) -> Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`

`pub fn join( self, v: T ) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>`[src]

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

`type Output = Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`

`pub fn join( self, v: T ) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>`[src]

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

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]