Struct mtrs::Matrix

pub struct Matrix<T: Num> { /* fields omitted */ }

The main Matrix struct. Can be created in a variety of different ways.

#[macro_use] extern crate mtrs;
use mtrs::Matrix;

// All of these create a 2 x 2 matrix.

// From a 2D vector
let matrix = Matrix::from_vec(2, 2, vec![1, 2, 3, 4]);
// Identity matrix of i32
let matrix: Matrix<i32> = Matrix::identity(2);
// Matrix of ones
let matrix: Matrix<i32> = Matrix::ones(2, 2);
// Matrix of zeros
let matrix: Matrix<i32> = Matrix::zeros(2, 2);
// Matrix of `i32`s
let matrix = matrix![(2, 2); 1, 2, 3, 4];
// Matrix of `f64`s
let matrix = matrix![f64; (2, 2); 1, 2; 3, 4];

Implementations

impl<T: Num + Clone + Copy> Matrix<T>

pub fn transpose(&mut self)

Transposes the matrix, via mutating the original data. Does not return a new struct, instead modifies the old one.

#[macro_use] extern crate mtrs;

let mut matrix = matrix![(2, 2); 1, 2; 3, 4];
matrix.transpose();
assert_eq!(matrix, matrix![(2, 2); 1, 3; 2, 4]);

pub fn scalar_add(&self, value: T) -> Self

Add a scalar constant to the matrix

pub fn scalar_sub(&self, value: T) -> Self

Subtract a scalar constant from the matrix

pub fn scalar_mul(&self, value: T) -> Self

Multiply a scalar constant with the matrix

pub fn scalar_div(&self, value: T) -> Self

Divide each entry in the matrix by a scalar constant

pub fn determinant(&self) -> Option<T>

Calculate the determinant of the Matrix (if the Matrix is square)

pub fn inverse(&self) -> Option<Self>

Calculate the inverse of Matrix<T>, via multiplying the reciprocal of the determinant

impl<T: Num + Clone + Copy> Matrix<T>

pub fn identity(size: usize) -> Self

Creates a new identity matrix of size N * N

use mtrs::Matrix;

let matrix: Matrix<i32> = Matrix::identity(2);

assert_eq!(matrix.as_slice(), &[1, 0, 0, 1]);
assert_eq!(matrix.size(), (2, 2));

pub fn from_vec(height: usize, width: usize, body: Vec<T>) -> Self

Creates a new matrix from a pre-given size, passing a 2d Vec<T>

use mtrs::Matrix;

let matrix = Matrix::from_vec(2, 2, vec![1, 2, 7, 6]);

assert_eq!(matrix.as_slice(), &[1, 2, 7, 6]);

pub fn zeros(height: usize, width: usize) -> Self

Create a Matrix<i32> of size M * N filled with 0s

use mtrs::Matrix;

let matrix = Matrix::zeros(2, 2);

assert_eq!(matrix.as_slice(), &[0, 0, 0, 0]);
assert_eq!(matrix, Matrix::from_vec(2, 2, vec![0, 0, 0, 0]));

pub fn ones(height: usize, width: usize) -> Self

Create a Matrix<i32> of size M * N filled with 1s

use mtrs::Matrix;

let matrix = Matrix::ones(2, 2);

assert_eq!(matrix.as_slice(), &[1, 1, 1, 1]);
assert_eq!(matrix, Matrix::from_vec(2, 2, vec![1, 1, 1, 1]));

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

Returns a tuple representing the dimensions ((height, width))

use mtrs::Matrix;

let matrix: Matrix<i32> = Matrix::ones(2, 3);
assert_eq!(matrix.size(), (2, 3));

pub fn as_slice(&self) -> &[T]

Wrapper function for self.data.as_slice()

pub fn as_mut_slice(&mut self) -> &mut [T]

Wrapper function for self.data.as_mut_slice()

pub fn as_ptr(&self) -> *const T

Wrapper function for self.data.as_ptr()

pub fn as_mut_ptr(&mut self) -> *const T

Wrapper function for self.data.as_mut_ptr()

pub fn as_vec(&self) -> Vec<Vec<T>>

Return a Vec representation of the Matrix

use mtrs::Matrix;

let matrix = Matrix::from_vec(2, 2, vec![2, 1, 4, 3]);
assert_eq!(matrix.as_vec(), vec![vec![2, 1], vec![4, 3]]);

pub fn cols(&self) -> Vec<Vec<T>>

Returns a Vec of all the columns

Trait Implementations

impl<T: Num + Clone + Copy> Add<Matrix<T>> for Matrix<T>

Perform addition using the + operator

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T> Display for Matrix<T> where
    T: Num + Clone + Copy + Display, 

Pretty print of the Matrix via this impl

extern crate mtrs;
use mtrs::Matrix;

let matrix: Matrix<i32> = Matrix::identity(3);
println!("{}", matrix);

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

Formats the value using the given formatter.

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

Allows for the indexing of Matrix

extern crate mtrs;
use mtrs::Matrix;

let matrix: Matrix<u8> = Matrix::identity(3);
assert_eq!(matrix[(1, 1)], 1);

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Num + Clone + Copy> Mul<Matrix<T>> for Matrix<T>

Perform multiplication using the * operator

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

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

fn eq(&self, other: &Matrix<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Matrix<T>) -> bool

This method tests for !=.

impl<T: Num> StructuralPartialEq for Matrix<T>

impl<T: Num + Clone + Copy> Sub<Matrix<T>> for Matrix<T>

Perform subtraction using the - operator

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.