Type Definition nalgebra::base::MatrixMN

pub type MatrixMN<N, R, C> = Matrix<N, R, C, Owned<N, R, C>>;

A statically sized column-major matrix with R rows and C columns.

Implementations

impl<N: Scalar, R: Dim, C: Dim> MatrixMN<N, R, C>where
    DefaultAllocator: Allocator<N, R, C>,

pub unsafe fn new_uninitialized_generic(nrows: R, ncols: C) -> Self

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

pub fn from_element_generic(nrows: R, ncols: C, elem: N) -> Self

Creates a matrix with all its elements set to elem.

pub fn repeat_generic(nrows: R, ncols: C, elem: N) -> Self

Creates a matrix with all its elements set to elem.

Same as from_element_generic.

pub fn zeros_generic(nrows: R, ncols: C) -> Selfwhere
    N: Zero,

Creates a matrix with all its elements set to 0.

pub fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Selfwhere
    I: IntoIterator<Item = N>,

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

pub fn from_row_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Self

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

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

pub fn from_column_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Self

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

pub fn from_fn_generic<F>(nrows: R, ncols: C, f: F) -> Selfwhere
    F: FnMut(usize, usize) -> N,

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

pub fn identity_generic(nrows: R, ncols: C) -> Selfwhere
    N: Zero + One,

Creates a new identity matrix.

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

pub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: N) -> Selfwhere
    N: Zero + One,

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

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

pub fn from_partial_diagonal_generic(nrows: R, ncols: C, elts: &[N]) -> Selfwhere
    N: 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.

pub fn from_rows<SB>(rows: &[Matrix<N, U1, C, SB>]) -> Selfwhere
    SB: Storage<N, U1, C>,

Builds a new matrix from its rows.

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

Example

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

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

pub fn from_columns<SB>(columns: &[Vector<N, R, SB>]) -> Selfwhere
    SB: Storage<N, 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);

pub fn new_random_generic(nrows: R, ncols: C) -> Selfwhere
    Standard: Distribution<N>,

Creates a matrix filled with random values.

pub fn from_distribution_generic<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
    nrows: R,
    ncols: C,
    distribution: &mut Distr,
    rng: &mut G
) -> Self

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

impl<N: Scalar, R: DimName, C: DimName> MatrixMN<N, R, C>where
    DefaultAllocator: Allocator<N, R, C>,

pub unsafe fn new_uninitialized() -> Self

Creates a new uninitialized matrix or vector.

pub fn from_element(elem: N) -> Self

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

Example

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

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

pub fn repeat(elem: N) -> Self

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

Same as .from_element.

Example

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

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

pub fn zeros() -> Selfwhere
    N: 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);

pub fn from_iterator<I>(iter: I) -> Selfwhere
    I: IntoIterator<Item = N>,

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

The output matrix is filled column-by-column.

Example

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

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

pub fn from_row_slice(slice: &[N]) -> Self

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

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

Example

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

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

pub fn from_column_slice(slice: &[N]) -> Self

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

Example

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

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

pub fn from_fn<F>(f: F) -> Selfwhere
    F: FnMut(usize, usize) -> N,

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

Example

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

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

pub fn identity() -> Selfwhere
    N: Zero + One,

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

Example

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

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

pub fn from_diagonal_element(elt: N) -> Selfwhere
    N: 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);

pub fn from_partial_diagonal(elts: &[N]) -> Selfwhere
    N: 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);

pub fn from_distribution<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
    distribution: &mut Distr,
    rng: &mut G
) -> Self

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

impl<N: Scalar, R: DimName, C: DimName> MatrixMN<N, R, C>where
    DefaultAllocator: Allocator<N, R, C>,
    Standard: Distribution<N>,

pub fn new_random() -> Self

Creates a matrix filled with random values.

impl<N: Scalar, R: DimName> MatrixMN<N, R, Dynamic>where
    DefaultAllocator: Allocator<N, R, Dynamic>,

pub unsafe fn new_uninitialized(ncols: usize) -> Self

Creates a new uninitialized matrix or vector.

pub fn from_element(ncols: usize, elem: N) -> Self

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

Example

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

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

pub fn repeat(ncols: usize, elem: N) -> Self

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

Same as .from_element.

Example

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

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

pub fn zeros(ncols: usize) -> Selfwhere
    N: 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);

pub fn from_iterator<I>(ncols: usize, iter: I) -> Selfwhere
    I: IntoIterator<Item = N>,

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

The output matrix is filled column-by-column.

Example

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

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

pub fn from_row_slice(ncols: usize, slice: &[N]) -> Self

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

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

Example

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

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

pub fn from_column_slice(ncols: usize, slice: &[N]) -> Self

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

Example

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

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

pub fn from_fn<F>(ncols: usize, f: F) -> Selfwhere
    F: FnMut(usize, usize) -> N,

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

Example

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

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

pub fn identity(ncols: usize) -> Selfwhere
    N: Zero + One,

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

Example

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

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

pub fn from_diagonal_element(ncols: usize, elt: N) -> Selfwhere
    N: 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);

pub fn from_partial_diagonal(ncols: usize, elts: &[N]) -> Selfwhere
    N: 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);

pub fn from_distribution<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
    ncols: usize,
    distribution: &mut Distr,
    rng: &mut G
) -> Self

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

impl<N: Scalar, R: DimName> MatrixMN<N, R, Dynamic>where
    DefaultAllocator: Allocator<N, R, Dynamic>,
    Standard: Distribution<N>,

pub fn new_random(ncols: usize) -> Self

Creates a matrix filled with random values.

impl<N: Scalar, C: DimName> MatrixMN<N, Dynamic, C>where
    DefaultAllocator: Allocator<N, Dynamic, C>,

pub unsafe fn new_uninitialized(nrows: usize) -> Self

Creates a new uninitialized matrix or vector.

pub fn from_element(nrows: usize, elem: N) -> Self

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

Example

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

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

pub fn repeat(nrows: usize, elem: N) -> Self

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

Same as .from_element.

Example

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

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

pub fn zeros(nrows: usize) -> Selfwhere
    N: 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);

pub fn from_iterator<I>(nrows: usize, iter: I) -> Selfwhere
    I: IntoIterator<Item = N>,

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

The output matrix is filled column-by-column.

Example

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

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

pub fn from_row_slice(nrows: usize, slice: &[N]) -> Self

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

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

Example

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

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

pub fn from_column_slice(nrows: usize, slice: &[N]) -> Self

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

Example

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

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

pub fn from_fn<F>(nrows: usize, f: F) -> Selfwhere
    F: FnMut(usize, usize) -> N,

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

Example

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

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

pub fn identity(nrows: usize) -> Selfwhere
    N: Zero + One,

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

Example

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

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

pub fn from_diagonal_element(nrows: usize, elt: N) -> Selfwhere
    N: 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);

pub fn from_partial_diagonal(nrows: usize, elts: &[N]) -> Selfwhere
    N: 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);

pub fn from_distribution<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
    nrows: usize,
    distribution: &mut Distr,
    rng: &mut G
) -> Self

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

impl<N: Scalar, C: DimName> MatrixMN<N, Dynamic, C>where
    DefaultAllocator: Allocator<N, Dynamic, C>,
    Standard: Distribution<N>,

pub fn new_random(nrows: usize) -> Self

Creates a matrix filled with random values.

impl<N: Scalar> MatrixMN<N, Dynamic, Dynamic>where
    DefaultAllocator: Allocator<N, Dynamic, Dynamic>,

pub unsafe fn new_uninitialized(nrows: usize, ncols: usize) -> Self

Creates a new uninitialized matrix or vector.

pub fn from_element(nrows: usize, ncols: usize, elem: N) -> Self

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

Example

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

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

pub fn repeat(nrows: usize, ncols: usize, elem: N) -> Self

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

Same as .from_element.

Example

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

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

pub fn zeros(nrows: usize, ncols: usize) -> Selfwhere
    N: 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);

pub fn from_iterator<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
    I: IntoIterator<Item = N>,

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

The output matrix is filled column-by-column.

Example

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

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

pub fn from_row_slice(nrows: usize, ncols: usize, slice: &[N]) -> Self

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

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

Example

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

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

pub fn from_column_slice(nrows: usize, ncols: usize, slice: &[N]) -> Self

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

Example

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

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

pub fn from_fn<F>(nrows: usize, ncols: usize, f: F) -> Selfwhere
    F: FnMut(usize, usize) -> N,

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

Example

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

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

pub fn identity(nrows: usize, ncols: usize) -> Selfwhere
    N: Zero + One,

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

Example

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

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

pub fn from_diagonal_element(nrows: usize, ncols: usize, elt: N) -> Selfwhere
    N: 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);

pub fn from_partial_diagonal(nrows: usize, ncols: usize, elts: &[N]) -> Selfwhere
    N: 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);

pub fn from_distribution<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
    nrows: usize,
    ncols: usize,
    distribution: &mut Distr,
    rng: &mut G
) -> Self

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

impl<N: Scalar> MatrixMN<N, Dynamic, Dynamic>where
    DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
    Standard: Distribution<N>,

pub fn new_random(nrows: usize, ncols: usize) -> Self

Creates a matrix filled with random values.

impl<N> MatrixMN<N, U2, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U2>,

pub fn new(m11: N, m12: N, m21: N, m22: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U3, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U3>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m21: N,
    m22: N,
    m23: N,
    m31: N,
    m32: N,
    m33: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U4, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U4>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m31: N,
    m32: N,
    m33: N,
    m34: N,
    m41: N,
    m42: N,
    m43: N,
    m44: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U5, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U5>,

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

Initializes this matrix from its components.

impl<N> MatrixMN<N, U6, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U6>,

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

Initializes this matrix from its components.

impl<N> MatrixMN<N, U2, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U3>,

pub fn new(m11: N, m12: N, m13: N, m21: N, m22: N, m23: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U2, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U4>,

pub fn new(m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U2, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U5>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m15: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m25: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U2, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U6>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m15: N,
    m16: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m25: N,
    m26: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U3, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U2>,

pub fn new(m11: N, m12: N, m21: N, m22: N, m31: N, m32: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U3, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U4>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m31: N,
    m32: N,
    m33: N,
    m34: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U3, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U5>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m15: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m25: N,
    m31: N,
    m32: N,
    m33: N,
    m34: N,
    m35: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U3, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U6>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m15: N,
    m16: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m25: N,
    m26: N,
    m31: N,
    m32: N,
    m33: N,
    m34: N,
    m35: N,
    m36: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U4, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U2>,

pub fn new(m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U4, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U3>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m21: N,
    m22: N,
    m23: N,
    m31: N,
    m32: N,
    m33: N,
    m41: N,
    m42: N,
    m43: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U4, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U5>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m15: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m25: N,
    m31: N,
    m32: N,
    m33: N,
    m34: N,
    m35: N,
    m41: N,
    m42: N,
    m43: N,
    m44: N,
    m45: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U4, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U6>,

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

Initializes this matrix from its components.

impl<N> MatrixMN<N, U5, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U2>,

pub fn new(
    m11: N,
    m12: N,
    m21: N,
    m22: N,
    m31: N,
    m32: N,
    m41: N,
    m42: N,
    m51: N,
    m52: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U5, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U3>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m21: N,
    m22: N,
    m23: N,
    m31: N,
    m32: N,
    m33: N,
    m41: N,
    m42: N,
    m43: N,
    m51: N,
    m52: N,
    m53: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U5, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U4>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m14: N,
    m21: N,
    m22: N,
    m23: N,
    m24: N,
    m31: N,
    m32: N,
    m33: N,
    m34: N,
    m41: N,
    m42: N,
    m43: N,
    m44: N,
    m51: N,
    m52: N,
    m53: N,
    m54: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U5, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U6>,

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

Initializes this matrix from its components.

impl<N> MatrixMN<N, U6, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U2>,

pub fn new(
    m11: N,
    m12: N,
    m21: N,
    m22: N,
    m31: N,
    m32: N,
    m41: N,
    m42: N,
    m51: N,
    m52: N,
    m61: N,
    m62: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U6, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U3>,

pub fn new(
    m11: N,
    m12: N,
    m13: N,
    m21: N,
    m22: N,
    m23: N,
    m31: N,
    m32: N,
    m33: N,
    m41: N,
    m42: N,
    m43: N,
    m51: N,
    m52: N,
    m53: N,
    m61: N,
    m62: N,
    m63: N
) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U6, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U4>,

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

Initializes this matrix from its components.

impl<N> MatrixMN<N, U6, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U5>,

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

Initializes this matrix from its components.

impl<N> MatrixMN<N, U1, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>,

pub fn new(x: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U1, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U2>,

pub fn new(x: N, y: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U1, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U3>,

pub fn new(x: N, y: N, z: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U1, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U4>,

pub fn new(x: N, y: N, z: N, w: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U1, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U5>,

pub fn new(x: N, y: N, z: N, w: N, a: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U1, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U6>,

pub fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U2, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>,

pub fn new(x: N, y: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U3, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>,

pub fn new(x: N, y: N, z: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U4, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>,

pub fn new(x: N, y: N, z: N, w: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U5, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>,

pub fn new(x: N, y: N, z: N, w: N, a: N) -> Self

Initializes this matrix from its components.

impl<N> MatrixMN<N, U6, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>,

pub fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Self

Initializes this matrix from its components.

Trait Implementations

impl<N, R: DimName, C: DimName> AbstractMagma<Additive> for MatrixMN<N, R, C>where
    N: Scalar + ClosedAdd,
    DefaultAllocator: Allocator<N, R, C>,

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

Performs an operation.

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

Performs specific operation.

impl<N, R: DimName, C: DimName> AbstractModule<Additive, Additive, Multiplicative> for MatrixMN<N, R, C>where
    N: Scalar + RingCommutative,
    DefaultAllocator: Allocator<N, R, C>,

type AbstractRing = N

The underlying scalar field.

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

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

impl<N, R: DimName, C: DimName> Bounded for MatrixMN<N, R, C>where
    N: Scalar + Bounded,
    DefaultAllocator: Allocator<N, R, C>,

fn max_value() -> Self

Returns the largest finite number this type can represent

fn min_value() -> Self

Returns the smallest finite number this type can represent

impl<'b, N, R1: DimName, C1: DimName> DivAssign<&'b Rotation<N, C1>> for MatrixMN<N, R1, C1>where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,

fn div_assign(&mut self, right: &'b Rotation<N, C1>)

Performs the /= operation.

impl<N, R1: DimName, C1: DimName> DivAssign<Rotation<N, C1>> for MatrixMN<N, R1, C1>where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,

fn div_assign(&mut self, right: Rotation<N, C1>)

Performs the /= operation.

impl<N: Real, R: DimName, C: DimName> FiniteDimInnerSpace for MatrixMN<N, R, C>where
    DefaultAllocator: Allocator<N, R, C>,

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

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

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

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

impl<N, R: DimName, C: DimName> FiniteDimVectorSpace for MatrixMN<N, R, C>where
    N: Scalar + Field,
    DefaultAllocator: Allocator<N, R, C>,

fn dimension() -> usize

The vector space dimension.

fn canonical_basis_element(i: usize) -> Self

The i-the canonical basis element.

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

The dot product between two vectors.

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

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

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

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

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

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

impl<N: Scalar> From<[[N; 2]; 2]> for MatrixMN<N, U2, U2>where
    DefaultAllocator: Allocator<N, U2, U2>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 2]; 3]> for MatrixMN<N, U2, U3>where
    DefaultAllocator: Allocator<N, U2, U3>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 2]; 4]> for MatrixMN<N, U2, U4>where
    DefaultAllocator: Allocator<N, U2, U4>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 2]; 5]> for MatrixMN<N, U2, U5>where
    DefaultAllocator: Allocator<N, U2, U5>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 2]; 6]> for MatrixMN<N, U2, U6>where
    DefaultAllocator: Allocator<N, U2, U6>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 3]; 2]> for MatrixMN<N, U3, U2>where
    DefaultAllocator: Allocator<N, U3, U2>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 3]; 3]> for MatrixMN<N, U3, U3>where
    DefaultAllocator: Allocator<N, U3, U3>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 3]; 4]> for MatrixMN<N, U3, U4>where
    DefaultAllocator: Allocator<N, U3, U4>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 3]; 5]> for MatrixMN<N, U3, U5>where
    DefaultAllocator: Allocator<N, U3, U5>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 3]; 6]> for MatrixMN<N, U3, U6>where
    DefaultAllocator: Allocator<N, U3, U6>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 4]; 2]> for MatrixMN<N, U4, U2>where
    DefaultAllocator: Allocator<N, U4, U2>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 4]; 3]> for MatrixMN<N, U4, U3>where
    DefaultAllocator: Allocator<N, U4, U3>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 4]; 4]> for MatrixMN<N, U4, U4>where
    DefaultAllocator: Allocator<N, U4, U4>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 4]; 5]> for MatrixMN<N, U4, U5>where
    DefaultAllocator: Allocator<N, U4, U5>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 4]; 6]> for MatrixMN<N, U4, U6>where
    DefaultAllocator: Allocator<N, U4, U6>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 5]; 2]> for MatrixMN<N, U5, U2>where
    DefaultAllocator: Allocator<N, U5, U2>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 5]; 3]> for MatrixMN<N, U5, U3>where
    DefaultAllocator: Allocator<N, U5, U3>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 5]; 4]> for MatrixMN<N, U5, U4>where
    DefaultAllocator: Allocator<N, U5, U4>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 5]; 5]> for MatrixMN<N, U5, U5>where
    DefaultAllocator: Allocator<N, U5, U5>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 5]; 6]> for MatrixMN<N, U5, U6>where
    DefaultAllocator: Allocator<N, U5, U6>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 6]; 2]> for MatrixMN<N, U6, U2>where
    DefaultAllocator: Allocator<N, U6, U2>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 6]; 3]> for MatrixMN<N, U6, U3>where
    DefaultAllocator: Allocator<N, U6, U3>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 6]; 4]> for MatrixMN<N, U6, U4>where
    DefaultAllocator: Allocator<N, U6, U4>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 6]; 5]> for MatrixMN<N, U6, U5>where
    DefaultAllocator: Allocator<N, U6, U5>,

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

Converts to this type from the input type.

impl<N: Scalar> From<[[N; 6]; 6]> for MatrixMN<N, U6, U6>where
    DefaultAllocator: Allocator<N, U6, U6>,

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

Converts to this type from the input type.

impl<N> From<[N; 1]> for MatrixMN<N, U1, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 10]> for MatrixMN<N, U1, U10>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U10>,

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

Converts to this type from the input type.

impl<N> From<[N; 10]> for MatrixMN<N, U10, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U10, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 11]> for MatrixMN<N, U1, U11>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U11>,

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

Converts to this type from the input type.

impl<N> From<[N; 11]> for MatrixMN<N, U11, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U11, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 12]> for MatrixMN<N, U1, U12>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U12>,

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

Converts to this type from the input type.

impl<N> From<[N; 12]> for MatrixMN<N, U12, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U12, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 13]> for MatrixMN<N, U1, U13>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U13>,

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

Converts to this type from the input type.

impl<N> From<[N; 13]> for MatrixMN<N, U13, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U13, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 14]> for MatrixMN<N, U1, U14>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U14>,

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

Converts to this type from the input type.

impl<N> From<[N; 14]> for MatrixMN<N, U14, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U14, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 15]> for MatrixMN<N, U1, U15>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U15>,

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

Converts to this type from the input type.

impl<N> From<[N; 15]> for MatrixMN<N, U15, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U15, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 16]> for MatrixMN<N, U1, U16>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U16>,

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

Converts to this type from the input type.

impl<N> From<[N; 16]> for MatrixMN<N, U16, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U16, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 2]> for MatrixMN<N, U1, U2>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U2>,

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

Converts to this type from the input type.

impl<N> From<[N; 2]> for MatrixMN<N, U2, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 3]> for MatrixMN<N, U1, U3>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U3>,

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

Converts to this type from the input type.

impl<N> From<[N; 3]> for MatrixMN<N, U3, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 4]> for MatrixMN<N, U1, U4>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U4>,

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

Converts to this type from the input type.

impl<N> From<[N; 4]> for MatrixMN<N, U4, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 5]> for MatrixMN<N, U1, U5>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U5>,

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

Converts to this type from the input type.

impl<N> From<[N; 5]> for MatrixMN<N, U5, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 6]> for MatrixMN<N, U1, U6>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U6>,

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

Converts to this type from the input type.

impl<N> From<[N; 6]> for MatrixMN<N, U6, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 7]> for MatrixMN<N, U1, U7>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U7>,

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

Converts to this type from the input type.

impl<N> From<[N; 7]> for MatrixMN<N, U7, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U7, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 8]> for MatrixMN<N, U1, U8>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U8>,

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

Converts to this type from the input type.

impl<N> From<[N; 8]> for MatrixMN<N, U8, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U8, U1>,

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

Converts to this type from the input type.

impl<N> From<[N; 9]> for MatrixMN<N, U1, U9>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U9>,

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

Converts to this type from the input type.

impl<N> From<[N; 9]> for MatrixMN<N, U9, U1>where
    N: Scalar,
    DefaultAllocator: Allocator<N, U9, U1>,

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

Converts to this type from the input type.

impl<N, R: DimName, C: DimName> Identity<Additive> for MatrixMN<N, R, C>where
    N: Scalar + Zero,
    DefaultAllocator: Allocator<N, R, C>,

fn identity() -> Self

The identity element.

fn id(_: O) -> Selfwhere
    Self: Sized,

Specific identity.

impl<N: Real, R: DimName, C: DimName> InnerSpace for MatrixMN<N, R, C>where
    DefaultAllocator: Allocator<N, R, C>,

type Real = N

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

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

Measures the angle between two vectors.

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

Computes the inner product of self with other.

impl<N, R: DimName, C: DimName> Inverse<Additive> for MatrixMN<N, R, C>where
    N: Scalar + ClosedNeg,
    DefaultAllocator: Allocator<N, R, C>,

fn inverse(&self) -> MatrixMN<N, R, C>

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

fn inverse_mut(&mut self)

In-place inversin of self.

impl<N, R: Dim, C: Dim> JoinSemilattice for MatrixMN<N, R, C>where
    N: Scalar + JoinSemilattice,
    DefaultAllocator: Allocator<N, R, C>,

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

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

impl<N, R: Dim, C: Dim> Lattice for MatrixMN<N, R, C>where
    N: Scalar + Lattice,
    DefaultAllocator: Allocator<N, R, C>,

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

Returns the infimum and the supremum simultaneously.

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

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

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

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

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

Sorts two values in increasing order using a partial ordering.

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

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

impl<N, R: Dim, C: Dim> MeetSemilattice for MatrixMN<N, R, C>where
    N: Scalar + MeetSemilattice,
    DefaultAllocator: Allocator<N, R, C>,

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

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

impl<N, R: DimName, C: DimName> Module for MatrixMN<N, R, C>where
    N: Scalar + RingCommutative,
    DefaultAllocator: Allocator<N, R, C>,

type Ring = N

The underlying scalar field.

impl<'b, N, R1: DimName, C1: DimName> MulAssign<&'b Rotation<N, C1>> for MatrixMN<N, R1, C1>where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,

fn mul_assign(&mut self, right: &'b Rotation<N, C1>)

Performs the *= operation.

impl<N, R1: DimName, C1: DimName> MulAssign<Rotation<N, C1>> for MatrixMN<N, R1, C1>where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,

fn mul_assign(&mut self, right: Rotation<N, C1>)

Performs the *= operation.

impl<N: Real, R: DimName, C: DimName> NormedSpace for MatrixMN<N, R, C>where
    DefaultAllocator: Allocator<N, R, C>,

fn norm_squared(&self) -> N

The squared norm of this vector.

fn norm(&self) -> N

The norm of this vector.

fn normalize(&self) -> Self

Returns a normalized version of this vector.

fn normalize_mut(&mut self) -> N

Normalizes this vector in-place and returns its norm.

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

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

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

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

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

fn to_superset(&self) -> MatrixMN<N2, R2, C2>

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

fn is_in_subset(m: &MatrixMN<N2, R2, C2>) -> bool

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

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

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

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

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

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

fn sum<I: Iterator<Item = &'a MatrixMN<N, R, C>>>(iter: I) -> MatrixMN<N, R, C>

Method which takes an iterator and generates Self from the elements by “summing up” the items.

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

fn sum<I: Iterator<Item = MatrixMN<N, R, C>>>(iter: I) -> MatrixMN<N, R, C>

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<N, R: DimName, C: DimName> VectorSpace for MatrixMN<N, R, C>where
    N: Scalar + Field,
    DefaultAllocator: Allocator<N, R, C>,

type Field = N

The underlying scalar field.

impl<N, R: DimName, C: DimName> Zero for MatrixMN<N, R, C>where
    N: Scalar + Zero + ClosedAdd,
    DefaultAllocator: Allocator<N, R, C>,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<N, R: DimName, C: DimName> AbstractGroup<Additive> for MatrixMN<N, R, C>where
    N: Scalar + AbstractGroup<Additive> + Zero + ClosedAdd + ClosedNeg,
    DefaultAllocator: Allocator<N, R, C>,

impl<N, R: DimName, C: DimName> AbstractGroupAbelian<Additive> for MatrixMN<N, R, C>where
    N: Scalar + AbstractGroupAbelian<Additive> + Zero + ClosedAdd + ClosedNeg,
    DefaultAllocator: Allocator<N, R, C>,

impl<N, R: DimName, C: DimName> AbstractLoop<Additive> for MatrixMN<N, R, C>where
    N: Scalar + AbstractLoop<Additive> + Zero + ClosedAdd + ClosedNeg,
    DefaultAllocator: Allocator<N, R, C>,

impl<N, R: DimName, C: DimName> AbstractMonoid<Additive> for MatrixMN<N, R, C>where
    N: Scalar + AbstractMonoid<Additive> + Zero + ClosedAdd,
    DefaultAllocator: Allocator<N, R, C>,

impl<N, R: DimName, C: DimName> AbstractQuasigroup<Additive> for MatrixMN<N, R, C>where
    N: Scalar + AbstractQuasigroup<Additive> + ClosedAdd + ClosedNeg,
    DefaultAllocator: Allocator<N, R, C>,

impl<N, R: DimName, C: DimName> AbstractSemigroup<Additive> for MatrixMN<N, R, C>where
    N: Scalar + AbstractSemigroup<Additive> + ClosedAdd,
    DefaultAllocator: Allocator<N, R, C>,