Struct Matrix

source

#[repr(C)]pub struct Matrix<T, R, C, S> {
    pub data: S,
    /* private fields */
}

Expand description

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:

T: 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 Dyn 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 Dyn with type-level unsigned integers is allowed. Actually, a dynamically-sized column vector should be represented as a Matrix<T, Dyn, U1, S> (given some concrete types for T 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§

source §

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

§Dot/scalar product

source

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

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.

§Example

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

source

pub fn dotc<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, T: SimdComplexField, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

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.

§Example

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

source

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

The dot product between the transpose of self and rhs.

§Example

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

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

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

If beta is zero, self is never read.

§Example

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

source

pub fn gerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

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

If beta is zero, self is never read.

§Example

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

source

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

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

If beta is zero, self is never read.

§Example

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

source

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

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

If beta is zero, self is never read.

§Example

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

source

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

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.

§Example

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

source §

impl<T, R1, C1, S> Matrix<T, R1, C1, S>
where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

source

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

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

§Example

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.

source

pub fn syger<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

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.

§Example

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.

source

pub fn hegerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

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.

§Example

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.

source §

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

Can be used to implement zoom_to functionality.

source §

impl<T> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>
where T: RealField,

source

pub fn new_orthographic( left: T, right: T, bottom: T, top: T, znear: T, zfar: T, ) -> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>

Creates a new homogeneous matrix for an orthographic projection.

source

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

source

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

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

source

pub fn component_div<R2, C2, SB>( &self, rhs: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
where T: ClosedDivAssign, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

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

source

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

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

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

source

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

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

source

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

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

source

pub fn inf( &self, other: &Matrix<T, R1, C1, SA>, ) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>
where T: SimdPartialOrd, DefaultAllocator: Allocator<R1, C1>,

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

§Example

let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = Matrix2::new(2.0, 2.0, -2.0, -2.0);
assert_eq!(u.inf(&v), expected)

source

pub fn sup( &self, other: &Matrix<T, R1, C1, SA>, ) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>
where T: SimdPartialOrd, DefaultAllocator: Allocator<R1, C1>,

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

§Example

let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = Matrix2::new(4.0, 4.0, 1.0, 1.0);
assert_eq!(u.sup(&v), expected)

source

pub fn inf_sup( &self, other: &Matrix<T, R1, C1, SA>, ) -> (Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>, Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>)
where T: SimdPartialOrd, DefaultAllocator: Allocator<R1, C1>,

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

§Example

let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = (Matrix2::new(2.0, 2.0, -2.0, -2.0), Matrix2::new(4.0, 4.0, 1.0, 1.0));
assert_eq!(u.inf_sup(&v), expected)

source

pub fn add_scalar( &self, rhs: T, ) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>
where T: ClosedAddAssign, DefaultAllocator: Allocator<R1, C1>,

Adds a scalar to self.

§Example

let u = Matrix2::new(1.0, 2.0, 3.0, 4.0);
let s = 10.0;
let expected = Matrix2::new(11.0, 12.0, 13.0, 14.0);
assert_eq!(u.add_scalar(s), expected)

source

pub fn add_scalar_mut(&mut self, rhs: T)
where T: ClosedAddAssign, SA: StorageMut<T, R1, C1>,

Adds a scalar to self in-place.

§Example

let mut u = Matrix2::new(1.0, 2.0, 3.0, 4.0);
let s = 10.0;
u.add_scalar_mut(s);
let expected = Matrix2::new(11.0, 12.0, 13.0, 14.0);
assert_eq!(u, expected)

source §

impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>
where T: Scalar, R: Dim, C: Dim, DefaultAllocator: Allocator<R, C>,

source

pub fn uninit( nrows: R, ncols: C, ) -> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>

Builds a matrix with uninitialized elements of type MaybeUninit<T>.

source §

impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, R: Dim, C: Dim, DefaultAllocator: Allocator<R, C>,

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

source

pub fn from_element_generic( nrows: R, ncols: C, elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with all its elements set to elem.

source

pub fn repeat_generic( nrows: R, ncols: C, elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with all its elements set to elem.

Same as from_element_generic.

source

pub fn zeros_generic( nrows: R, ncols: C, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero,

Creates a matrix with all its elements set to 0.

source

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

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

source

pub fn from_row_iterator_generic( nrows: R, ncols: C, iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix with all its elements filled by an row-major order iterator.

source

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

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.

source

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

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

source

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

source

pub fn from_columns<SB>( columns: &[Matrix<T, R, Const<1>, SB>], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where SB: RawStorage<T, R>,

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

source

pub fn from_vec_generic( nrows: R, ncols: C, data: Vec<T>, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

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(Dyn(vec.len()), Const::<1>, 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);

source §

impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: Dim, T: Scalar, DefaultAllocator: Allocator<D, D>,

source

pub fn from_diagonal<SB>( diag: &Matrix<T, D, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where SB: RawStorage<T, D>, T: Zero,

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

source §

impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, R: DimName, C: DimName, DefaultAllocator: Allocator<R, C>,

§Constructors of statically-sized vectors or statically-sized matrices

source

pub fn from_element( elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

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

source

pub fn repeat( elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

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

source

pub fn zeros() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero,

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

source

pub fn from_iterator( iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

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

source

pub fn from_row_iterator( iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by a row-major iterator.

The output matrix is filled row-by-row.

§Example


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

// For Vectors from_row_iterator is identical to from_iterator
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);

source

pub fn from_fn<F>( f: F, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

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

source

pub fn identity() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero + One,

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

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

source

pub fn from_diagonal_element( elt: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero + One,

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

source

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

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

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

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

source §

impl<T, R> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Scalar, R: DimName, DefaultAllocator: Allocator<R, Dyn>,

§Constructors of matrices with a dynamic number of columns

source

pub fn from_element( ncols: usize, elem: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

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

source

pub fn repeat( ncols: usize, elem: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

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

source

pub fn zeros( ncols: usize, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero,

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

source

pub fn from_iterator( ncols: usize, iter: I, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = T>,

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

source

pub fn from_row_iterator( ncols: usize, iter: I, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by a row-major iterator.

The output matrix is filled row-by-row.

§Example


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

// For Vectors from_row_iterator is identical to from_iterator
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);

source

pub fn from_fn<F>( ncols: usize, f: F, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

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

source

pub fn identity( ncols: usize, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero + One,

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

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

source

pub fn from_diagonal_element( ncols: usize, elt: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero + One,

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

source

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

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

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

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

source §

impl<T, C> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where T: Scalar, C: DimName, DefaultAllocator: Allocator<Dyn, C>,

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

source

pub fn from_element( nrows: usize, elem: T, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

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

source

pub fn repeat( nrows: usize, elem: T, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

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

source

pub fn zeros( nrows: usize, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where T: Zero,

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

source

pub fn from_iterator( nrows: usize, iter: I, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

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

source

pub fn from_row_iterator( nrows: usize, iter: I, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by a row-major iterator.

The output matrix is filled row-by-row.

§Example


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

// For Vectors from_row_iterator is identical to from_iterator
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);

source

pub fn from_fn<F>( nrows: usize, f: F, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

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

source

pub fn identity( nrows: usize, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where T: Zero + One,

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

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

source

pub fn from_diagonal_element( nrows: usize, elt: T, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where T: Zero + One,

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

source

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

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

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

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

source §

impl<T> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where T: Scalar, DefaultAllocator: Allocator<Dyn, Dyn>,

§Constructors of fully dynamic matrices

source

pub fn from_element( nrows: usize, ncols: usize, elem: T, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>

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

source

pub fn repeat( nrows: usize, ncols: usize, elem: T, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>

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

source

pub fn zeros( nrows: usize, ncols: usize, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where T: Zero,

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

source

pub fn from_iterator( nrows: usize, ncols: usize, iter: I, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = T>,

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

source

pub fn from_row_iterator( nrows: usize, ncols: usize, iter: I, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by a row-major iterator.

The output matrix is filled row-by-row.

§Example


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

// For Vectors from_row_iterator is identical to from_iterator
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);

source

pub fn from_fn<F>( nrows: usize, ncols: usize, f: F, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

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

source

pub fn identity( nrows: usize, ncols: usize, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where T: Zero + One,

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

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

source

pub fn from_diagonal_element( nrows: usize, ncols: usize, elt: T, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where T: Zero + One,

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

source

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

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

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

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

source §

impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, R: DimName, C: DimName, DefaultAllocator: Allocator<R, C>,

source

pub fn from_row_slice( data: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

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

source

pub fn from_column_slice( data: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

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

source

pub fn from_vec( data: Vec<T>, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

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

source §

impl<T, R> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Scalar, R: DimName, DefaultAllocator: Allocator<R, Dyn>,

source

pub fn from_row_slice( data: &[T], ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

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

source

pub fn from_column_slice( data: &[T], ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

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

source

pub fn from_vec( data: Vec<T>, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

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

source §

impl<T, C> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where T: Scalar, C: DimName, DefaultAllocator: Allocator<Dyn, C>,

source

pub fn from_row_slice( data: &[T], ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

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

source

pub fn from_column_slice( data: &[T], ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

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

source

pub fn from_vec( data: Vec<T>, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

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

source §

impl<T> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where T: Scalar, DefaultAllocator: Allocator<Dyn, Dyn>,

source

pub fn from_row_slice( nrows: usize, ncols: usize, data: &[T], ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>

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

source

pub fn from_column_slice( nrows: usize, ncols: usize, data: &[T], ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>

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

source

pub fn from_vec( nrows: usize, ncols: usize, data: Vec<T>, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>

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

source

pub unsafe fn from_slice_with_strides_generic_unchecked( data: &'a [T], start: usize, nrows: R, ncols: C, rstride: RStride, cstride: CStride, ) -> Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>

Creates, without bounds checking, a matrix view from an array and with dimensions and strides specified by generic types instances.

§Safety

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

source

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

Creates a matrix view 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 Dyn().

source §

impl<'a, T, R, C> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>
where T: Scalar, R: Dim, C: Dim,

source

pub unsafe fn from_slice_generic_unchecked( data: &'a [T], start: usize, nrows: R, ncols: C, ) -> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>

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

§Safety

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

source

pub fn from_slice_generic( data: &'a [T], nrows: R, ncols: C, ) -> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>

§Safety

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

source

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

Creates a mutable matrix view 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 Dyn().

source §

impl<'a, T, R, C> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>
where T: Scalar, R: Dim, C: Dim,

source

pub unsafe fn from_slice_generic_unchecked( data: &'a mut [T], start: usize, nrows: R, ncols: C, ) -> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>

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

§Safety

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

source

pub fn from_slice_generic( data: &'a mut [T], nrows: R, ncols: C, ) -> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>

source

pub fn lower_triangle( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where DefaultAllocator: Allocator<R, C>,

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

source §

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

§Rows and columns extraction

source

pub fn select_rows<'a, I>( &self, irows: I, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where I: IntoIterator<Item = &'a usize>, ::IntoIter: ExactSizeIterator + Clone, DefaultAllocator: Allocator<Dyn, C>,

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

source

pub fn select_columns<'a, I>( &self, icols: I, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = &'a usize>, ::IntoIter: ExactSizeIterator, DefaultAllocator: Allocator<R, Dyn>,

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

source §

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

§Set rows, columns, and diagonal

source

pub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<T, R2, Const<1>, S2>)
where R2: Dim, R: DimMin<C>, S2: RawStorage<T, R2>, ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,

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

source

pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = T>)

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

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.

source

pub fn fill_upper_triangle(&mut self, val: T, shift: usize)
where T: Scalar,

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.

source §

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar, D: Dim, S: RawStorageMut<T, D, D>,

source

pub fn fill_lower_triangle_with_upper_triangle(&mut self)

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

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

source

pub fn fill_upper_triangle_with_lower_triangle(&mut self)

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

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

source §

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

§In-place swapping

source

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

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.

source

pub fn remove_row( self, i: usize, ) -> Matrix<T, <R as DimSub<Const<1>>>::Output, C, <DefaultAllocator as Allocator<<R as DimSub<Const<1>>>::Output, C>>::Buffer<T>>
where R: DimSub<Const<1>>, DefaultAllocator: Reallocator<T, R, C, <R as DimSub<Const<1>>>::Output, C>,

Removes the i-th row from this matrix.

source

pub fn remove_fixed_rows<const D: usize>( self, i: usize, ) -> Matrix<T, <R as DimSub<Const<D>>>::Output, C, <DefaultAllocator as Allocator<<R as DimSub<Const<D>>>::Output, C>>::Buffer<T>>
where R: DimSub<Const<D>>, DefaultAllocator: Reallocator<T, R, C, <R as DimSub<Const<D>>>::Output, C>,

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

source

pub fn remove_rows( self, i: usize, n: usize, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where R: DimSub<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, Dyn, C>,

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

source

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

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

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

source §

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

§Rows and columns insertion

source

pub fn insert_column( self, i: usize, val: T, ) -> Matrix<T, R, <C as DimAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<R, <C as DimAdd<Const<1>>>::Output>>::Buffer<T>>
where C: DimAdd<Const<1>>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<1>>>::Output>,

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

source

pub fn insert_fixed_columns<const D: usize>( self, i: usize, val: T, ) -> Matrix<T, R, <C as DimAdd<Const<D>>>::Output, <DefaultAllocator as Allocator<R, <C as DimAdd<Const<D>>>::Output>>::Buffer<T>>
where C: DimAdd<Const<D>>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<D>>>::Output>,

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

source

pub fn insert_columns( self, i: usize, n: usize, val: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where C: DimAdd<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, R, Dyn>,

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

source

pub unsafe fn insert_columns_generic_uninitialized<D>( self, i: usize, ninsert: D, ) -> Matrix<MaybeUninit<T>, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<R, <C as DimAdd<D>>::Output>>::BufferUninit<T>>
where D: Dim, C: DimAdd<D>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<D>>::Output>,

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

§Safety

The output matrix has all its elements initialized except for the the components of the added columns.

source

pub fn insert_row( self, i: usize, val: T, ) -> Matrix<T, <R as DimAdd<Const<1>>>::Output, C, <DefaultAllocator as Allocator<<R as DimAdd<Const<1>>>::Output, C>>::Buffer<T>>
where R: DimAdd<Const<1>>, DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<1>>>::Output, C>,

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

source

pub fn insert_fixed_rows<const D: usize>( self, i: usize, val: T, ) -> Matrix<T, <R as DimAdd<Const<D>>>::Output, C, <DefaultAllocator as Allocator<<R as DimAdd<Const<D>>>::Output, C>>::Buffer<T>>
where R: DimAdd<Const<D>>, DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<D>>>::Output, C>,

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

source

pub fn insert_rows( self, i: usize, n: usize, val: T, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where R: DimAdd<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, Dyn, C>,

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

source

pub unsafe fn insert_rows_generic_uninitialized<D>( self, i: usize, ninsert: D, ) -> Matrix<MaybeUninit<T>, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<<R as DimAdd<D>>::Output, C>>::BufferUninit<T>>
where D: Dim, R: DimAdd<D>, DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<D>>::Output, C>,

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

§Safety

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

source §

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

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(Const::<3>, Const::<2>);
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(Dyn(6), Dyn(2));
assert_eq!(reshaped, dm2);

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

source §

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Views 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((Const::<1>.., 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)));

source

pub fn get<'a, I>( &'a self, index: I, ) -> Option<>::Output>
where I: MatrixIndex<'a, T, R, C, S>,

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

source

pub fn get_mut<'a, I>( &'a mut self, index: I, ) -> Option<>::OutputMut>
where S: RawStorageMut<T, R, C>, I: MatrixIndexMut<'a, T, R, C, S>,

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

source

pub fn index<'a, I>( &'a self, index: I, ) -> >::Output
where I: MatrixIndex<'a, T, R, C, S>,

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

source

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

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

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

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

source

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

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

pub fn fold_with<T2>( &self, init_f: impl FnOnce(Option<&T>) -> T2, f: impl FnMut(T2, &T) -> T2, ) -> T2
where T: Scalar,

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.

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

source

pub fn column_iter_mut(&mut self) -> ColumnIterMut<'_, T, R, C, S> ⓘ
where S: RawStorageMut<T, R, C>,

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

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

Swaps two entries.

source

pub fn copy_from_slice(&mut self, slice: &[T])
where T: Scalar,

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.

source

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

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

source

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

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

source

pub fn apply_into<F>(self, f: F) -> Matrix<T, R, C, S>
where F: FnMut(&mut T),

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

source §

impl<T, D, S> Matrix<T, D, Const<1>, S>
where D: Dim, S: RawStorage<T, D>,

source

pub unsafe fn vget_unchecked(&self, i: usize) -> &T

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

§Safety

i must be less than D.

source §

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

source

The conjugate of self.

source

pub fn unscale( &self, real: <T as SimdComplexField>::SimdRealField, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where DefaultAllocator: Allocator<R, C>,

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

source

pub fn scale( &self, real: <T as SimdComplexField>::SimdRealField, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where DefaultAllocator: Allocator<R, C>,

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

source §

impl<T, R, C, S> Matrix<T, R, C, S>
where T: SimdComplexField, R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

source

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar, D: Dim, S: RawStorage<T, D, D>,

source

pub fn diagonal( &self, ) -> Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>
where DefaultAllocator: Allocator<D>,

The diagonal of this matrix.

source

pub fn map_diagonal<T2>( &self, f: impl FnMut(T) -> T2, ) -> Matrix<T2, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T2>>
where T2: Scalar, DefaultAllocator: Allocator<D>,

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.

source

pub fn trace(&self) -> T
where T: Scalar + Zero + ClosedAddAssign,

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

source §

impl<T, D, S> Matrix<T, D, D, S>
where T: SimdComplexField, D: Dim, S: Storage<T, D, D>,

source

pub fn symmetric_part( &self, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where DefaultAllocator: Allocator<D, D>,

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

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.

source §

impl<T, D, S> Matrix<T, D, Const<1>, S>
where T: Scalar, D: DimAdd<Const<1>>, S: RawStorage<T, D>,

source

pub fn push( &self, element: T, ) -> Matrix<T, <D as DimAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<<D as DimAdd<Const<1>>>::Output>>::Buffer<T>>
where DefaultAllocator: Allocator<<D as DimAdd<Const<1>>>::Output>,

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

source §

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign, R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Cross product

source

pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, Const<2>> + SameNumberOfColumns<C, Const<1>> + SameNumberOfRows<R2, Const<2>> + SameNumberOfColumns<C2, Const<1>>,

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

source

pub fn cross<R2, C2, SB>( &self, b: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer<T>>
where R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

The 3D cross product between two vectors.

Returns a reference to the single

Struct MatrixCopy item path

§Methods summary

§Vector and matrix construction

§Computer graphics utilities for transformations

§Common math operations

§Statistics

§Iteration, map, and fold

§Vector and matrix views

§In-place modification of a single matrix or vector

§Vector and matrix size modification

§Matrix decomposition

§Vector basis computation

§Type parameters

Fields§

Implementations§

impl<T, R, C, S> Matrix<T, R, C, S>where R: Dim, C: Dim, S: RawStorage<T, R, C>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

§Dot/scalar product

pub fn dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> Twhere R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

§Example

pub fn dotc<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> Twhere R2: Dim, C2: Dim, T: SimdComplexField, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

§Example

pub fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> Twhere R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,

§Example

impl<T, D, S> Matrix<T, D, Const<1>, S>where D: Dim, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign, S: StorageMut<T, D>,

§BLAS functions

pub fn axcpy<D2, SB>( &mut self, a: T, x: &Matrix<T, D2, Const<1>, SB>, c: T, b: T, )where D2: Dim, SB: Storage<T, D2>, ShapeConstraint: DimEq<D, D2>,

§Example

pub fn axpy<D2, SB>(&mut self, a: T, x: &Matrix<T, D2, Const<1>, SB>, b: T)where D2: Dim, T: One, SB: Storage<T, D2>, ShapeConstraint: DimEq<D, D2>,

§Example

pub fn gemv<R2, C2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )where R2: Dim, C2: Dim, D3: Dim, T: One, SB: Storage<T, R2, C2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, Const<1>>,

§Example

pub fn sygemv<D2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, D2, D2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, Const<1>>,

§Examples

pub fn hegemv<D2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, D2, D2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, Const<1>>,

§Examples

pub fn gemv_tr<R2, C2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )where R2: Dim, C2: Dim, D3: Dim, T: One, SB: Storage<T, R2, C2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, Const<1>>,

§Example

pub fn gemv_ad<R2, C2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )where R2: Dim, C2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, R2, C2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, Const<1>>,

§Example

impl<T, R1, C1, S> Matrix<T, R1, C1, S>where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

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

§Example

pub fn gerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

§Example

§Example

§Example

§Example

impl<T, R1, C1, S> Matrix<T, R1, C1, S>where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

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

§Example

pub fn syger<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

§Example

pub fn hegerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

§Example

impl<T, D1, S> Matrix<T, D1, D1, S>where D1: Dim, S: StorageMut<T, D1, D1>, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

§Example

§Example

§Example

§Example

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

pub fn neg_mut(&mut self)

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, T: Scalar + ClosedAddAssign,

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, T: Scalar + ClosedSubAssign,

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SA: Storage<T, R1, C1>,

§Special multiplications.

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

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

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

impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>where D: DimName, T: Scalar + Zero + One, DefaultAllocator: Allocator<D, D>,

§Translation and scaling in any dimension

pub fn new_scaling( scaling: T, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

pub fn new_nonuniform_scaling<SB>( scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

pub fn new_translation<SB>( translation: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

impl<T> Matrix<T, Const<3>, Const<3>, ArrayStorage<T, 3, 3>>where T: RealField,

§2D transformations as a Matrix3

pub fn new_rotation( angle: T, ) -> Matrix<T, Const<3>, Const<3>, ArrayStorage<T, 3, 3>>

pub fn new_nonuniform_scaling_wrt_point( scaling: &Matrix<T, Const<2>, Const<1>, ArrayStorage<T, 2, 1>>, pt: &OPoint<T, Const<2>>, ) -> Matrix<T, Const<3>, Const<3>, ArrayStorage<T, 3, 3>>

impl<T> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>where T: RealField,

§3D transformations as a Matrix4

pub fn new_rotation( axisangle: Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>, ) -> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>

Struct Matrix

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

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

pub fn dotc<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, T: SimdComplexField, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

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

impl<T, D, S> Matrix<T, D, Const<1>, S>
where D: Dim, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign, S: StorageMut<T, D>,

pub fn axcpy<D2, SB>( &mut self, a: T, x: &Matrix<T, D2, Const<1>, SB>, c: T, b: T, )
where D2: Dim, SB: Storage<T, D2>, ShapeConstraint: DimEq<D, D2>,

pub fn axpy<D2, SB>(&mut self, a: T, x: &Matrix<T, D2, Const<1>, SB>, b: T)
where D2: Dim, T: One, SB: Storage<T, D2>, ShapeConstraint: DimEq<D, D2>,

pub fn gemv<R2, C2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where R2: Dim, C2: Dim, D3: Dim, T: One, SB: Storage<T, R2, C2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, Const<1>>,

pub fn sygemv<D2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, D2, D2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, Const<1>>,

pub fn hegemv<D2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, D2, D2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, Const<1>>,

pub fn gemv_tr<R2, C2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where R2: Dim, C2: Dim, D3: Dim, T: One, SB: Storage<T, R2, C2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, Const<1>>,

pub fn gemv_ad<R2, C2, D3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, x: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where R2: Dim, C2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, R2, C2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, Const<1>>,

impl<T, R1, C1, S> Matrix<T, R1, C1, S>
where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

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

pub fn gerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

impl<T, R1, C1, S> Matrix<T, R1, C1, S>
where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

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

pub fn syger<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

pub fn hegerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

impl<T, D1, S> Matrix<T, D1, D1, S>
where D1: Dim, S: StorageMut<T, D1, D1>, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

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

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, T: Scalar + ClosedAddAssign,

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, T: Scalar + ClosedSubAssign,

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SA: Storage<T, R1, C1>,

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

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

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

impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimName, T: Scalar + Zero + One, DefaultAllocator: Allocator<D, D>,

pub fn new_nonuniform_scaling<SB>( scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

pub fn new_translation<SB>( translation: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

impl<T> Matrix<T, Const<3>, Const<3>, ArrayStorage<T, 3, 3>>
where T: RealField,

impl<T> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>
where T: RealField,

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, D: DimName, S: Storage<T, D, D>,

pub fn append_scaling( &self, scaling: T, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, DefaultAllocator: Allocator<D, D>,

pub fn prepend_scaling( &self, scaling: T, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, DefaultAllocator: Allocator<D, D>,

pub fn append_translation<SB>( &self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<D, D>,

pub fn append_scaling_mut(&mut self, scaling: T)
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>,

pub fn prepend_scaling_mut(&mut self, scaling: T)
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>,

pub fn append_nonuniform_scaling_mut<SB>( &mut self, scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

pub fn prepend_nonuniform_scaling_mut<SB>( &mut self, scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

pub fn append_translation_mut<SB>( &mut self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

pub fn prepend_translation_mut<SB>( &mut self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where D: DimNameSub<Const<1>>, S: StorageMut<T, D, D>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<<D as DimNameSub<Const<1>>>::Output>,

impl<T, D, S> Matrix<T, D, D, S>
where T: RealField, D: DimNameSub<Const<1>>, S: Storage<T, D, D>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimNameSub<Const<1>>>::Output> + Allocator<<D as DimNameSub<Const<1>>>::Output, <D as DimNameSub<Const<1>>>::Output>,

impl<T, S> Matrix<T, Const<3>, Const<3>, S>
where T: RealField, S: Storage<T, Const<3>, Const<3>>,

impl<T, S> Matrix<T, Const<4>, Const<4>, S>
where T: RealField, S: Storage<T, Const<4>, Const<4>>,

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

pub fn abs( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Signed, DefaultAllocator: Allocator<R, C>,

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

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

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