Struct Matrix 

pub struct Matrix<T> { /* private fields */ }

A Matrix with generic type items. Can be indexed by mat[(row, col)]

Implementations

impl<T> Matrix<T>

pub fn fill(rows: usize, cols: usize, e: T) -> Self

where T: Clone,

Generates a rowsxcols matrix where every element is e

pub fn build<F: FnMut(usize, usize) -> T>( rows: usize, cols: usize, builder_fn: F, ) -> Self

Generates a rowsxcols matrix where every element is obtained by evaluating builder_fn(row, col)

pub fn identity(rows: usize) -> Self

where T: MatrixElement,

Generates a rowsxrows identity matrix (using MatrixElement::zero() and MatrixElement::one())

pub fn from_vec(rows: usize, cols: usize, data: Vec<T>) -> Option<Self>

Generates a rowsxcols matrix with the data specified in data

returns None if data.len() != rows * cols

impl<T: Clone> Matrix<&T>

pub fn cloned(&self) -> Matrix<T>

Clones the elements of a Matrix<&T> and returns a Matrix<T>

impl<T> Matrix<T>

pub fn rows(&self) -> usize

returns the number of rows (the ‘height’) of the matrix

pub fn cols(&self) -> usize

returns the number of columns (the ‘width’) of the matrix

pub fn dim(&self) -> (usize, usize)

returns the number of rows and the number of columns of the matrix (in that order)

pub fn elements(&self) -> usize

returns the total number of elements in the matrix

pub fn split(self) -> (usize, usize, Vec<T>)

splits the struct up into its parts, that is into (rows, columns, data)

pub fn into_some(self) -> Matrix<Option<T>>

Converts a Matrix<T> to a Matrix<Option<T>> by mapping every element e to Some(e)

pub fn get(&self, row: usize, col: usize) -> IndexResult<&T>

get a reference to the item at (row, col)

Errors

Returns an error if the index is out of bounds

pub fn get_mut(&mut self, row: usize, col: usize) -> IndexResult<&mut T>

get a mutable reference to the item at (row, col)

Errors

Returns an error if the index is out of bounds

pub fn replace(&mut self, row: usize, col: usize, val: T) -> IndexResult<T>

get a the item at (row, col) and replace it with val

This works like {let res = self.get(row, col); self.set(row, col, val); res} but you get ownership of the returned value

Errors

Returns an error if the index is out of bounds

pub fn set(&mut self, row: usize, col: usize, val: T) -> IndexResult<()>

set the item at (row, col) to val

Errors

Returns an error if the index is out of bounds

pub fn get_row(&self, row: usize) -> Result<Vec<&T>, IndexOutOfBounds<usize>>

get an entire row of (references of) items

Errors

Returns an error if the row is out of bounds

pub fn get_row_mut( &mut self, row: usize, ) -> Result<Vec<&mut T>, IndexOutOfBounds<usize>>

get an entire row of (mutable references of) items

Errors

Returns an error if the row is out of bounds

pub fn get_col(&self, col: usize) -> Result<Vec<&T>, IndexOutOfBounds<usize>>

get an entire column of (references of) items

Errors

Returns an error if the column is out of bounds

pub fn get_col_mut( &mut self, col: usize, ) -> Result<Vec<&mut T>, IndexOutOfBounds<usize>>

get an entire column of (mutable references of) items

Errors

Returns an error if the column is out of bounds

pub fn map<F: Fn(T) -> U, U>(self, f: F) -> Matrix<U>

Returns a new Matrix that is obtained by applying the given function to each element

pub fn transposed(self) -> Self

Returns the Transpose of this Matrix

pub fn det(self) -> Option<T>

where T: Add<Output = T> + Sub<Output = T> + MatrixElement + Clone + Mul<Output = T>,

Returns the Determinant of this Matrix

pub fn scaled<U: Mul<T, Output = O> + Clone, O>(self, scalar: U) -> Matrix<O>

Multiplies the matrix with a scalar by multiplying each element with the scalar

impl<T> Matrix<Option<T>>

pub fn take(&mut self, row: usize, col: usize) -> IndexResult<Option<T>>

return the value at (row, col), leaving None in its place

impl Matrix<RotmatElement>

pub fn insert_rotation_value<T, O>(self, value: T) -> Matrix<O>

where T: Trig<Output = O> + Clone, O: Neg<Output = O> + Add<Output = O> + Mul<Output = O> + MatrixElement,

Takes a previously generated Rotation Matrix and inserts a specific value into it For f32 and f64, this would be the angle in radians, but for your own type it could be whatever… (it uses the Trig and the MatrixElement traits to get values for sin, -sin, cos, 0 and 1)

Trait Implementations

impl<T: Add<U, Output = O>, U, O> Add<Matrix<U>> for Matrix<T>

Adds two matrices element by element

type Output = Matrix<O>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<U>) -> Matrix<O>

Performs the + operation.

impl<T: Clone> Clone for Matrix<T>

fn clone(&self) -> Matrix<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Matrix<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for Matrix<T>

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

Formats the value using the given formatter.

impl<T> From<Matrix<T>> for Vector<T>

A Vector can be converted to a matrix and back

fn from(mat: Matrix<T>) -> Self

Converts to this type from the input type.

impl<T> From<Matrix<T>> for Vector2<T>

A Vector can be cast to a matrix and back

fn from(mat: Matrix<T>) -> Self

Converts to this type from the input type.

impl<T> From<Matrix<T>> for Vector3<T>

where T: Clone,

fn from(mat: Matrix<T>) -> Self

Converts to this type from the input type.

impl<T> From<Matrix<T>> for Vector4<T>

where T: Clone,

fn from(mat: Matrix<T>) -> Self

Converts to this type from the input type.

impl<T> Index<(usize, usize)> for Matrix<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<(usize, usize)> for Matrix<T>

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

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

impl<T> Into<Matrix<T>> for Vector<T>

A Vector can be cast to a matrix and back

fn into(self) -> Matrix<T>

Converts this type into the (usually inferred) input type.

impl<T> Into<Matrix<T>> for Vector2<T>

A Vector can be cast to a matrix and back

fn into(self) -> Matrix<T>

Converts this type into the (usually inferred) input type.

impl<T> Into<Matrix<T>> for Vector3<T>

fn into(self) -> Matrix<T>

Converts this type into the (usually inferred) input type.

impl<T> Into<Matrix<T>> for Vector4<T>

fn into(self) -> Matrix<T>

Converts this type into the (usually inferred) input type.

impl<T, U, O> Mul<Matrix<U>> for Matrix<T>

where T: Mul<U, Output = O> + Clone, U: Clone, O: Add<O, Output = O> + MatrixElement,

Matrix Multiplication

type Output = Matrix<O>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<U>) -> Matrix<O>

Performs the * operation.

impl<T, U, O> Mul<Vector<U>> for Matrix<T>

where T: Mul<U, Output = O> + Clone, U: Clone, O: Add<O, Output = O> + MatrixElement,

Matrix-Vector Multiplication

type Output = Vector<O>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<U>) -> Vector<O>

Performs the * operation.

impl<T, O> Neg for Matrix<T>

where T: Neg<Output = O>,

type Output = Matrix<O>

The resulting type after applying the - operator.

fn neg(self) -> Matrix<O>

Performs the unary - operation.

impl<T: PartialEq> PartialEq for Matrix<T>

fn eq(&self, other: &Matrix<T>) -> 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<T: Clone + Sub<U, Output = O>, U, O> Sub<Matrix<U>> for Matrix<T>

Subtracts two matrices element by element

type Output = Matrix<O>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<U>) -> Matrix<O>

Performs the - operation.

impl<T: Eq> Eq for Matrix<T>

impl<T> StructuralPartialEq for Matrix<T>