Struct Matrix

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

2D matrix.

Implementations

impl<T> Matrix<T>

pub fn from_fn<F>(row: usize, column: usize, f: F) -> Matrix<T>

where F: Fn(usize, usize) -> T,

Creates a new Matrix.

pub fn from_vec(row: usize, column: usize, data: Vec<T>) -> Matrix<T>

Creates a new Matrix from vector.

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

Returns the matrix’s row and column.

pub fn row(&self) -> usize

Returns the matrix’s row.

pub fn column(&self) -> usize

Returns the matrix’s column.

pub fn trans_in_place(&mut self)

Transposes the matrix in-place.

impl<T: Zero> Matrix<T>

pub fn zero(row: usize, column: usize) -> Matrix<T>

Creates a matrix whose elements are all zero.

impl<T: One + Zero> Matrix<T>

pub fn one(row: usize, column: usize) -> Matrix<T>

Creates a identity matrix.

impl<T: Clone> Matrix<T>

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

Returns transpose of the matrix.

Trait Implementations

impl<'a, 'b, Lhs, Rhs> Add<&'b Matrix<Rhs>> for &'a Matrix<Lhs>

where Lhs: Add<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: &Matrix<Rhs>) -> Matrix<<Lhs as Add<Rhs>>::Output>

Performs the + operation.

impl<'a, Lhs, Rhs> Add<&'a Matrix<Rhs>> for Matrix<Lhs>

where Lhs: Add<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: &Matrix<Rhs>) -> Matrix<<Lhs as Add<Rhs>>::Output>

Performs the + operation.

impl<'a, Lhs, Rhs> Add<Matrix<Rhs>> for &'a Matrix<Lhs>

where Lhs: Add<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: Matrix<Rhs>) -> Matrix<<Lhs as Add<Rhs>>::Output>

Performs the + operation.

impl<Lhs, Rhs> Add<Matrix<Rhs>> for Matrix<Lhs>

where Lhs: Add<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: Matrix<Rhs>) -> Matrix<<Lhs as Add<Rhs>>::Output>

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: Hash> Hash for Matrix<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

type Output = T

The returned type after indexing.

fn index(&self, (i, j): (usize, usize)) -> &T

Performs the indexing (container[index]) operation.

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

fn index_mut(&mut self, (i, j): (usize, usize)) -> &mut T

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

impl<'a, 'b, Lhs, Rhs> Mul<&'b Matrix<Rhs>> for &'a Matrix<Lhs>

where Lhs: Mul<Rhs> + Clone, Rhs: Clone, <Lhs as Mul<Rhs>>::Output: Add<Output = <Lhs as Mul<Rhs>>::Output>,

type Output = Matrix<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: &Matrix<Rhs>) -> Matrix<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

impl<'a, Lhs, Rhs> Mul<&'a Matrix<Rhs>> for Matrix<Lhs>

where Lhs: Mul<Rhs> + Clone, Rhs: Clone, <Lhs as Mul<Rhs>>::Output: Add<Output = <Lhs as Mul<Rhs>>::Output>,

type Output = Matrix<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: &Matrix<Rhs>) -> Matrix<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

impl<'a, Lhs, Rhs> Mul<Matrix<Rhs>> for &'a Matrix<Lhs>

where Lhs: Mul<Rhs> + Clone, Rhs: Clone, <Lhs as Mul<Rhs>>::Output: Add<Output = <Lhs as Mul<Rhs>>::Output>,

type Output = Matrix<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: Matrix<Rhs>) -> Matrix<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

impl<Lhs, Rhs> Mul<Matrix<Rhs>> for Matrix<Lhs>

where Lhs: Mul<Rhs> + Clone, Rhs: Clone, <Lhs as Mul<Rhs>>::Output: Add<Output = <Lhs as Mul<Rhs>>::Output>,

type Output = Matrix<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: Matrix<Rhs>) -> Matrix<<Lhs as Mul<Rhs>>::Output>

Performs the * 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<'a, 'b, Lhs, Rhs> Sub<&'b Matrix<Rhs>> for &'a Matrix<Lhs>

where Lhs: Sub<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: &Matrix<Rhs>) -> Matrix<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<'a, Lhs, Rhs> Sub<&'a Matrix<Rhs>> for Matrix<Lhs>

where Lhs: Sub<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: &Matrix<Rhs>) -> Matrix<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<'a, Lhs, Rhs> Sub<Matrix<Rhs>> for &'a Matrix<Lhs>

where Lhs: Sub<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: Matrix<Rhs>) -> Matrix<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<Lhs, Rhs> Sub<Matrix<Rhs>> for Matrix<Lhs>

where Lhs: Sub<Rhs> + Clone, Rhs: Clone,

type Output = Matrix<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: Matrix<Rhs>) -> Matrix<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

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

impl<T> StructuralPartialEq for Matrix<T>