Struct Mat 

pub struct Mat<S>
where
    S: Scalar,
{ /* private fields */ }

Extremely basic matrix type, written as Mat<S>, short for “matrix”.

Implementation Details

• The underlying data structure is a Vec<S>.
• This matrix implementation is row-major; the elements of the matrix are stored row-by-row in a one-dimensional “flat” data structure (in this case a Vec<S>).

Motivation

Rust does not have a matrix type in the std library, and users of this crate may not want to have dependencies such as nalgebra, ndarray, and/or faer.

Implementations

impl<S> Mat<S>

where S: Scalar,

pub fn iter(&self) -> impl Iterator<Item = &S>

Returns an iterator over the elements of the matrix.

Returns

An iterator that yields references to the elements of the matrix.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut S>

Returns a mutable iterator over the elements of the matrix.

Returns

An iterator that yields mutable references to the elements of the matrix.

Trait Implementations

impl<S> Clone for Mat<S>

where S: Scalar + Clone,

fn clone(&self) -> Mat<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for Mat<S>

where S: Scalar + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Scalar> Index<(usize, usize)> for Mat<S>

type Output = S

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<S: Scalar> IndexMut<(usize, usize)> for Mat<S>

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<S> IntoIterator for Mat<S>

where S: Scalar,

type Item = S

The type of the elements being iterated over.

type IntoIter = IntoIter<S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S> Matrix<S> for Mat<S>

where S: Scalar,

type VectorM = Vec<S>

Length-M Vector type implementing the crate::Vector trait that is compatible with this matrix type. An instance of this matrix type with shape (M, N) can be multiplied from the left by an instance of this vector type with length M, resulting in an instance of this vector type with length N (mathematically representing a row vector).

type VectorN = Vec<S>

Length-N Vector type implementing the crate::Vector trait that is compatible with this matrix type. An instance of this matrix type with shape (M, N) can be multiplied from the right by an instance of this vector type with length N, resulting in an instance of this vector type with length M (mathematically representing a column vector).

fn is_statically_sized() -> bool

Determine whether or not the matrix is statically-sized.

fn is_dynamically_sized() -> bool

Determine whether or not the matrix is dynamically-sized.

fn is_row_major() -> bool

Determine whether or not the matrix is row-major.

fn is_column_major() -> bool

Determine whether or not the matrix is column-major.

fn new_with_shape(rows: usize, cols: usize) -> Self

Create a matrix with the specified size, with each element set to 0.

fn shape(&self) -> (usize, usize)

Get the shape of the matrix.

fn from_row_slice(rows: usize, cols: usize, slice: &[S]) -> Self

Create a matrix from a slice of scalars arranged in row-major order.

fn from_col_slice(rows: usize, cols: usize, slice: &[S]) -> Self

Create a matrix from a slice of scalars arranged in column-major order.

fn as_slice<'a>(&'a self) -> Cow<'a, [S]>

Return a slice view of the matrix’s elements.

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

Matrix addition (elementwise).

fn add_assign(&mut self, other: &Self)

In-place matrix addition (elementwise) (self += other).

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

Matrix subtraction (elementwise).

fn sub_assign(&mut self, other: &Self)

In-place matrix subtraction (elementwise) (self -= other).

fn mul(&self, scalar: S) -> Self

Matrix-scalar multiplication.

fn mul_assign(&mut self, scalar: S)

In-place matrix-scalar multiplication (self * scalar or scalar * self).

fn div(&self, scalar: S) -> Self

Matrix-scalar division.

fn div_assign(&mut self, scalar: S)

In-place matrix-scalar division (self / scalar).

fn new_vector_n(&self) -> Self::VectorN

Create a length-N vector that is compatible with this M x N matrix.

fn new_vector_m(&self) -> Self::VectorM

Create a length-M vector that is compatible with this M x N matrix.

fn assert_same_shape(&self, other: &Self)

Assert that this matrix and another matrix have the same shape.

fn as_row_slice<'a>(&'a self) -> Cow<'a, [S]>

Return a slice view of the matrix’s elements in row-major order.

fn as_col_slice<'a>(&'a self) -> Cow<'a, [S]>

Return a slice view of the matrix’s elements in column-major order.

impl<S> PartialEq for Mat<S>

where S: Scalar + PartialEq,

fn eq(&self, other: &Mat<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> StructuralPartialEq for Mat<S>

where S: Scalar,