OMatrix in nalgebra::base - Rust
Description: An owned matrix column-major matrix with `R` rows and `C` columns.
Keywords: rust, rustlang, rust-lang, OMatrix

# Type Definition nalgebra::base::OMatrix

source ·

    pub type OMatrix<T, R, C> = Matrix<T, R, C, Owned<T, R, C>>;

Expand description

An owned matrix column-major matrix with `R` rows and `C` columns.

Because this is an alias, not all its methods are listed here. See the `Matrix` type too.

## Implementations§

source§

### impl<T, D: DimName> OMatrix<T, D, D>where
T: Scalar + Zero + One,
DefaultAllocator: Allocator<T, D, D>,

#### Translation and scaling in any dimension

source

#### pub fn new_scaling(scaling: T) -> Self

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

source

#### pub fn new_nonuniform_scaling<SB>(
scaling: &Vector<T, DimNameDiff<D, U1>, SB>
) -> Selfwhere
D: DimNameSub<U1>,
SB: Storage<T, DimNameDiff<D, U1>>,

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

source

#### pub fn new_translation<SB>(
translation: &Vector<T, DimNameDiff<D, U1>, SB>
) -> Selfwhere
D: DimNameSub<U1>,
SB: Storage<T, DimNameDiff<D, U1>>,

Creates a new homogeneous matrix that applies a pure translation.

source§

### impl<T: Scalar, R: Dim, C: Dim> OMatrix<T, R, C>where
DefaultAllocator: Allocator<T, 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) -> Self

Creates a matrix with all its elements set to `elem`.

source

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

Creates a matrix with all its elements set to `elem`.

Same as `from_element_generic`.

source

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

Creates a matrix with all its elements set to 0.

source

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

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

source

#### pub fn from_row_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Selfwhere
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]) -> 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.

source

#### pub fn from_column_slice_generic(nrows: R, ncols: C, slice: &[T]) -> 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).

source

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

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

source

#### pub fn identity_generic(nrows: R, ncols: C) -> Selfwhere
T: 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.

source

#### pub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: T) -> Selfwhere
T: 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.

source

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

source

#### pub fn from_rows<SB>(rows: &[Matrix<T, Const<1>, C, SB>]) -> Selfwhere
SB: RawStorage<T, Const<1>, 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);

source

#### pub fn from_columns<SB>(columns: &[Vector<T, R, SB>]) -> Selfwhere
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>) -> Self

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: Dim> OMatrix<T, D, D>where
T: Scalar,
DefaultAllocator: Allocator<T, D, D>,

source

#### pub fn from_diagonal<SB: RawStorage<T, D>>(diag: &Vector<T, D, SB>) -> Selfwhere
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: Scalar, R: DimName, C: DimName> OMatrix<T, R, C>where
DefaultAllocator: Allocator<T, R, C>,

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

source

#### pub fn from_element(elem: T) -> 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);

source

#### pub fn repeat(elem: T) -> 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);

source

#### pub fn zeros() -> Selfwhere
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<I>(iter: I) -> Selfwhere
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<I>(iter: I) -> Selfwhere
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) -> Selfwhere
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() -> Selfwhere
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) -> Selfwhere
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]) -> Selfwhere
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: Scalar, R: DimName> OMatrix<T, R, Dyn>where
DefaultAllocator: Allocator<T, R, Dyn>,

#### Constructors of matrices with a dynamic number of columns

source

#### pub fn from_element(ncols: usize, elem: T) -> 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);

source

#### pub fn repeat(ncols: usize, elem: T) -> 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);

source

#### pub fn zeros(ncols: usize) -> Selfwhere
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<I>(ncols: usize, iter: I) -> Selfwhere
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<I>(ncols: usize, iter: I) -> Selfwhere
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) -> Selfwhere
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) -> Selfwhere
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) -> Selfwhere
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]) -> Selfwhere
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: Scalar, C: DimName> OMatrix<T, Dyn, C>where
DefaultAllocator: Allocator<T, Dyn, C>,

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

source

#### pub fn from_element(nrows: usize, elem: T) -> 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);

source

#### pub fn repeat(nrows: usize, elem: T) -> 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);

source

#### pub fn zeros(nrows: usize) -> Selfwhere
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<I>(nrows: usize, iter: I) -> Selfwhere
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<I>(nrows: usize, iter: I) -> Selfwhere
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) -> Selfwhere
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) -> Selfwhere
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) -> Selfwhere
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]) -> Selfwhere
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: Scalar> OMatrix<T, Dyn, Dyn>where
DefaultAllocator: Allocator<T, Dyn, Dyn>,

#### Constructors of fully dynamic matrices

source

#### pub fn from_element(nrows: usize, ncols: usize, elem: T) -> 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);

source

#### pub fn repeat(nrows: usize, ncols: usize, elem: T) -> 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);

source

#### pub fn zeros(nrows: usize, ncols: usize) -> Selfwhere
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<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
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<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
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) -> Selfwhere
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) -> Selfwhere
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) -> Selfwhere
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]) -> Selfwhere
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: Scalar, R: DimName, C: DimName> OMatrix<T, R, C>where
DefaultAllocator: Allocator<T, R, C>,

source

#### pub fn from_row_slice(data: &[T]) -> 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(&[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]) -> 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(&[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>) -> Self

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: Scalar, R: DimName> OMatrix<T, R, Dyn>where
DefaultAllocator: Allocator<T, R, Dyn>,

source

#### pub fn from_row_slice(data: &[T]) -> 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(&[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]) -> 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(&[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>) -> Self

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: Scalar, C: DimName> OMatrix<T, Dyn, C>where
DefaultAllocator: Allocator<T, Dyn, C>,

source

#### pub fn from_row_slice(data: &[T]) -> 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(&[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]) -> 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(&[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>) -> Self

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: Scalar> OMatrix<T, Dyn, Dyn>where
DefaultAllocator: Allocator<T, Dyn, Dyn>,

source

#### pub fn from_row_slice(nrows: usize, ncols: usize, data: &[T]) -> 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(&[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]) -> 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(&[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>) -> Self

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: Scalar> OMatrix<T, Dyn, Dyn>

#### In-place resizing

source

#### pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T)where
DefaultAllocator: Reallocator<T, Dyn, Dyn, Dyn, Dyn>,

Resizes this matrix in-place.

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

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

source§

### impl<T: Scalar, C: Dim> OMatrix<T, Dyn, C>where
DefaultAllocator: Allocator<T, Dyn, C>,

source

#### pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T)where
DefaultAllocator: Reallocator<T, Dyn, C, Dyn, C>,

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

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

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

source§

### impl<T: Scalar, R: Dim> OMatrix<T, R, Dyn>where
DefaultAllocator: Allocator<T, R, Dyn>,

source

#### pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T)where
DefaultAllocator: Reallocator<T, R, Dyn, R, Dyn>,

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

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

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

## Trait Implementations§

source§

### impl<T, R: DimName, C: DimName> Bounded for OMatrix<T, R, C>where
T: Scalar + Bounded,
DefaultAllocator: Allocator<T, R, C>,

source§

#### fn max_value() -> Self

Returns the largest finite number this type can represent
source§

#### fn min_value() -> Self

Returns the smallest finite number this type can represent
source§

### impl<T, R: Dim, C: Dim> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 16]> for OMatrix<T, R, C>where
T: From<[<T as SimdValue>::Element; 16]> + Scalar + PrimitiveSimdValue,
T::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,

source§

#### fn from(arr: [OMatrix<T::Element, R, C>; 16]) -> Self

Converts to this type from the input type.
source§

### impl<T, R: Dim, C: Dim> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 2]> for OMatrix<T, R, C>where
T: From<[<T as SimdValue>::Element; 2]> + Scalar + PrimitiveSimdValue,
T::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,

source§

#### fn from(arr: [OMatrix<T::Element, R, C>; 2]) -> Self

Converts to this type from the input type.
source§

### impl<T, R: Dim, C: Dim> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 4]> for OMatrix<T, R, C>where
T: From<[<T as SimdValue>::Element; 4]> + Scalar + PrimitiveSimdValue,
T::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,

source§

#### fn from(arr: [OMatrix<T::Element, R, C>; 4]) -> Self

Converts to this type from the input type.
source§

### impl<T, R: Dim, C: Dim> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 8]> for OMatrix<T, R, C>where
T: From<[<T as SimdValue>::Element; 8]> + Scalar + PrimitiveSimdValue,
T::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,

source§

#### fn from(arr: [OMatrix<T::Element, R, C>; 8]) -> Self

Converts to this type from the input type.
source§

### impl<T: SimdRealField, R, const D: usize> From<Isometry<T, R, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>where
Const<D>: DimNameAdd<U1>,
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

source§

#### fn from(iso: Isometry<T, R, D>) -> Self

Converts to this type from the input type.
source§

### impl<T: Scalar + Zero + One, const D: usize> From<Scale<T, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>where
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, DimNameSum<Const<D>, U1>, U1> + Allocator<T, Const<D>>,

source§

#### fn from(t: Scale<T, D>) -> Self

Converts to this type from the input type.
source§

### impl<T: SimdRealField, R, const D: usize> From<Similarity<T, R, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>where
Const<D>: DimNameAdd<U1>,
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

source§

#### fn from(sim: Similarity<T, R, D>) -> Self

Converts to this type from the input type.
source§

### impl<T: RealField, C, const D: usize> From<Transform<T, C, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>where
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

source§

#### fn from(t: Transform<T, C, D>) -> Self

Converts to this type from the input type.
source§

### impl<T: Scalar + Zero + One, const D: usize> From<Translation<T, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>where
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, Const<D>>,

source§

#### fn from(t: Translation<T, D>) -> Self

Converts to this type from the input type.
source§

### impl<T: SimdComplexField, R: Dim, C: Dim> Normed for OMatrix<T, R, C>where
DefaultAllocator: Allocator<T, R, C>,

§

#### type Norm = <T as SimdComplexField>::SimdRealField

The type of the norm.
source§

#### fn norm(&self) -> T::SimdRealField

Computes the norm.
source§

#### fn norm_squared(&self) -> T::SimdRealField

Computes the squared norm.
source§

#### fn scale_mut(&mut self, n: Self::Norm)

Multiply `self` by n.
source§

#### fn unscale_mut(&mut self, n: Self::Norm)

Divides `self` by n.
source§

### impl<T, D: DimName> One for OMatrix<T, D, D>where
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<T, D, D>,

source§

#### fn one() -> Self

Returns the multiplicative identity element of `Self`, `1`. Read more
source§

#### fn set_one(&mut self)

Sets `self` to the multiplicative identity element of `Self`, `1`.
source§

#### fn is_one(&self) -> bool where
Self: PartialEq<Self>,

Returns `true` if `self` is equal to the multiplicative identity. Read more
source§

### impl<'a, T, D: DimName> Product<&'a Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>> for OMatrix<T, D, D>where
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<T, D, D>,

source§

#### fn product<I: Iterator<Item = &'a OMatrix<T, D, D>>>(
iter: I
) -> OMatrix<T, D, D>

Method which takes an iterator and generates `Self` from the elements by multiplying the items. Read more
source§

### impl<T, D: DimName> Product<Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>> for OMatrix<T, D, D>where
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<T, D, D>,

source§

#### fn product<I: Iterator<Item = OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D>

Method which takes an iterator and generates `Self` from the elements by multiplying the items. Read more
source§

### impl<T, R, C> SimdValue for OMatrix<T, R, C>where
T: Scalar + SimdValue,
R: Dim,
C: Dim,
T::Element: Scalar,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,

§

#### type Element = Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>

The type of the elements of each lane of this SIMD value.
§

#### type SimdBool = <T as SimdValue>::SimdBool

Type of the result of comparing two SIMD values like `self`.
source§

#### fn lanes() -> usize

The number of lanes of this SIMD value.
source§

#### fn splat(val: Self::Element) -> Self

Initializes an SIMD value with each lanes set to `val`.
source§

#### fn extract(&self, i: usize) -> Self::Element

Extracts the i-th lane of `self`. Read more
source§

#### unsafe fn extract_unchecked(&self, i: usize) -> Self::Element

Extracts the i-th lane of `self` without bound-checking.
source§

#### fn replace(&mut self, i: usize, val: Self::Element)

Replaces the i-th lane of `self` by `val`. Read more
source§

#### unsafe fn replace_unchecked(&mut self, i: usize, val: Self::Element)

Replaces the i-th lane of `self` by `val` without bound-checking.
source§

#### fn select(self, cond: Self::SimdBool, other: Self) -> Self

Merges `self` and `other` depending on the lanes of `cond`. Read more
source§

#### fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Selfwhere
Self: Clone,

Applies a function to each lane of `self`. Read more
source§

#### fn zip_map_lanes(
self,
b: Self,
f: impl Fn(Self::Element, Self::Element) -> Self::Element
) -> Selfwhere
Self: Clone,

Applies a function to each lane of `self` paired with the corresponding lane of `b`. Read more
source§

### impl<T1, T2, R1, C1, R2, C2> SubsetOf<Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>> for OMatrix<T1, R1, C1>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<T2, R2, C2> + Allocator<T1, R1, C1> + SameShapeAllocator<T1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

source§

#### fn to_superset(&self) -> OMatrix<T2, R2, C2>

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

#### fn is_in_subset(m: &OMatrix<T2, R2, C2>) -> bool

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

#### fn from_superset_unchecked(m: &OMatrix<T2, R2, C2>) -> Self

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

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

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

### impl<'a, T, C: Dim> Sum<&'a Matrix<T, Dyn, C, <DefaultAllocator as Allocator<T, Dyn, C>>::Buffer>> for OMatrix<T, Dyn, C>where
T: Scalar + ClosedAdd + Zero,
DefaultAllocator: Allocator<T, Dyn, C>,

source§

#### fn sum<I: Iterator<Item = &'a OMatrix<T, Dyn, C>>>(
iter: I
) -> OMatrix<T, Dyn, C>

##### Example

    let v = &DVector::repeat(3, 1.0f64);

    assert_eq!(vec![v, v, v].into_iter().sum::<DVector<f64>>(),
               v + v + v);

##### Panics

Panics if the iterator is empty:

ⓘ

    iter::empty::<&DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!

source§

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

source§

#### fn sum<I: Iterator<Item = &'a OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C>

Method which takes an iterator and generates `Self` from the elements by “summing up” the items. Read more
source§

### impl<T, C: Dim> Sum<Matrix<T, Dyn, C, <DefaultAllocator as Allocator<T, Dyn, C>>::Buffer>> for OMatrix<T, Dyn, C>where
T: Scalar + ClosedAdd + Zero,
DefaultAllocator: Allocator<T, Dyn, C>,

source§

#### fn sum<I: Iterator<Item = OMatrix<T, Dyn, C>>>(iter: I) -> OMatrix<T, Dyn, C>

##### Example

    assert_eq!(vec![DVector::repeat(3, 1.0f64),
                    DVector::repeat(3, 1.0f64),
                    DVector::repeat(3, 1.0f64)].into_iter().sum::<DVector<f64>>(),
               DVector::repeat(3, 1.0f64) + DVector::repeat(3, 1.0f64) + DVector::repeat(3, 1.0f64));

##### Panics

Panics if the iterator is empty:

ⓘ

    iter::empty::<DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!

source§

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

source§

#### fn sum<I: Iterator<Item = OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C>

Method which takes an iterator and generates `Self` from the elements by “summing up” the items. Read more
source§

### impl<T, R: DimName, C: DimName> Zero for OMatrix<T, R, C>where
T: Scalar + Zero + ClosedAdd,
DefaultAllocator: Allocator<T, R, C>,

source§

#### fn zero() -> Self

Returns the additive identity element of `Self`, `0`. Read more
source§

#### fn is_zero(&self) -> bool

Returns `true` if `self` is equal to the additive identity.
source§

#### fn set_zero(&mut self)

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