Struct mathru::algebra::linear::matrix::matrix::Matrix

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

Methods

impl<T> Matrix<T>

Important traits for MatrixIterator<'a, T>

impl<'a, T> Iterator for MatrixIterator<'a, T> where
    T: Real,  type Item = &'a T;

pub fn iter(&self) -> MatrixIterator<T>

Important traits for MatrixIteratorMut<'a, T>

impl<'a, T> Iterator for MatrixIteratorMut<'a, T> where
    T: Real,  type Item = &'a mut T;

pub fn iter_mut(&mut self) -> MatrixIteratorMut<T>

Important traits for MatrixRowIterator<'a, T>

impl<'a, T> Iterator for MatrixRowIterator<'a, T> where
    T: Real,  type Item = T;

pub fn row_iter(&self) -> MatrixRowIterator<T>

Important traits for MatrixRowIteratorMut<'a, T>

impl<'a, T> Iterator for MatrixRowIteratorMut<'a, T> where
    T: Real,  type Item = T;

pub fn row_iter_mut(&mut self) -> MatrixRowIteratorMut<T>

Important traits for MatrixColumnIterator<'a, T>

impl<'a, T> Iterator for MatrixColumnIterator<'a, T> where
    T: Real,  type Item = T;

pub fn column_iter(&self) -> MatrixColumnIterator<T>

Important traits for MatrixColumnIteratorMut<'a, T>

impl<'a, T> Iterator for MatrixColumnIteratorMut<'a, T> where
    T: Real,  type Item = T;

pub fn column_iter_mut(&mut self) -> MatrixColumnIteratorMut<T>

impl<T> Matrix<T> where
    T: Clone, 

pub fn apply_mut(self: Matrix<T>, f: &dyn Fn(&T) -> T) -> Matrix<T>

Applies the function f on every element in the matrix

pub fn apply(self: &Matrix<T>, f: &dyn Fn(&T) -> T) -> Matrix<T>

impl<T> Matrix<T> where
    T: Semiring + Sign, 

Returns the transposed matrix

Example

use mathru::algebra::linear::{Matrix};

let mut a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, -2.0, 3.0, -7.0]);
a = a.transpose();

let a_trans: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 3.0, -2.0, -7.0]);

assert_eq!(a_trans, a);

pub fn gcd(m: usize, n: usize) -> usize

pub fn transpose(self) -> Matrix<T>

Function to transpose a matrix without allocating memory for the transposed matrix

catanzaro.name/papers/PPoPP-2014.pdf TODO

Example

use mathru::algebra::linear::{Matrix};

let mut uut: Matrix<f64> = Matrix::new(4, 2, vec![1.0, 0.0, 3.0, 0.0, 1.0, -7.0, 0.5, 0.25]);
uut = uut.transpose();

let refer: Matrix<f64> = Matrix::new(2, 4, vec![1.0, 1.0, 0.0, -7.0, 3.0, 0.5, 0.0, 0.25]);
assert_eq!(refer, uut);

impl<T> Matrix<T> where
    T: Real, 

pub fn subst_backward_vector(&self, b: Vector<T>) -> Vector<T>

pub fn subst_backward_matrix(&self, b: Matrix<T>) -> Matrix<T>

impl<T> Matrix<T> where
    T: Real, 

pub fn subst_forward_vector(&self, b: Vector<T>) -> Vector<T>

pub fn subst_forward_matrix(&self, b: Matrix<T>) -> Matrix<T>

impl<T> Matrix<T> where
    T: Real, 

pub fn det<'a>(&'a self) -> T

Calculates the determinant

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, -2.0, 3.0, -7.0]);
let determinant_a: f64 = a.det();

assert_eq!(-1.0, determinant_a);

pub fn trace(&self) -> T where
    T: Real, 

Calculates the trace of a matrix

Arguments

self: square matrix

Panics

if it is not a square matrix

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, -2.0, 3.0, -7.0]);
let tr: f64 = a.trace();

assert_eq!(-6.0, tr);

impl<T> Matrix<T> where
    T: Real, 

pub fn get_column<'a>(&'a self, i: usize) -> Vector<T>

pub fn get_row<'a>(&'a self, i: usize) -> Vector<T>

return row vector

i: row

pub fn set_column(self, column: &Vector<T>, i: usize) -> Matrix<T>

set column

pub fn set_row(&mut self, row: &Vector<T>, i: usize)

set row

Arguments

• 'row'
• 'i'

Panics

impl<T> Matrix<T> where
    T: Real, 

pub fn givens<'d, 'e>(m: usize, i: usize, j: usize, c: T, s: T) -> Self

impl<T> Matrix<T> where
    T: Real, 

pub fn householder(v: &Vector<T>, k: usize) -> Self

Returns the householder matrix

Arguments

v: Column vector k: index 0 <= k < m

Panics

if index out of bounds

impl<T> Matrix<T> where
    T: Real, 

pub fn dec_sv<'a>(&'a self) -> (Self, Self, Self)

Computes the singular value decomposition

M = U * S * V*

Return

(u, s, v)

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(4, 4, vec![4.0, 1.0, -2.0, 2.0, 1.0, 2.0, 0.0, -2.0, 0.0, 3.0, -2.0, 2.0,
2.0, 1.0, -2.0, -1.0]);

let (u, s, v): (Matrix<f64>, Matrix<f64>, Matrix<f64>) = a.dec_sv();

pub fn rot(f: T, g: T) -> (T, T, T)

pub fn householder_bidiag<'a>(&'a self) -> (Self, Self, Self)

self is an m times n matrix with m >= n A = UBV^{T} U \in T^{m \times n} B \in T^{n \times n} V \in T^{n \times n}

impl<T> Matrix<T> where
    T: Real, 

pub fn get_slice(
    &self,
    row_s: usize,
    row_e: usize,
    column_s: usize,
    column_e: usize
) -> Matrix<T>

Returns a slice of the matrix

Arugments

0 <= row_s < m
0 <= row_e < m
0 <= column_s < n
0 <= column_e <= n

row_s: start row
row_e: end row
column_s: start column
column_e: end column

Example

use mathru::algebra::linear::{Matrix};

let mut a: Matrix<f64> = matrix![1.0, -2.0; 3.0, -7.0];
a = a.get_slice(0, 0, 1, 1);

let a_ref: Matrix<f64> = Matrix::new(1, 1, vec![-2.0]);

assert_eq!(a_ref, a);

pub fn set_slice(self, slice: &Self, row: usize, column: usize) -> Matrix<T>

Replaces parts of the matrix with the given values

Arugments

0 <= row < m
0 <= column < n

Example

use mathru::algebra::linear::{Matrix};

let mut a: Matrix<f64> = matrix![   1.0, 0.0;
                                    3.0, -7.0];

let b: Matrix<f64> = matrix![2.0, -1.0];
a = a.set_slice(&b, 0, 0);

let a_updated: Matrix<f64> = matrix![   2.0, -1.0;
                                        3.0, -7.0];

assert_eq!(a_updated, a);

impl<T> Matrix<T>

pub fn get_mut<'a>(&'a mut self, i: usize, j: usize) -> &'a mut T

Returns the mutual element a_ij from the matrix

Example

use mathru::algebra::linear::{Matrix};

let mut a: Matrix<f64> = matrix![1.0, 0.0; 3.0, -7.0];
*a.get_mut(1, 0) = -8.0;

let a_updated: Matrix<f64> = matrix![1.0, 0.0; -8.0, -7.0];
assert_eq!(a_updated, a);

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

Returns the element a_ij from the matrix

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = matrix![   1.0, 0.0;
                                3.0, -7.0];

let a_ref: f64 = 3.0;
let element: f64 = *a.get(1, 0);

assert_eq!(a_ref, element);

impl<T> Matrix<T> where
    T: Clone + Copy + Zero + One, 

pub fn new<'a, 'b>(m: usize, n: usize, data: Vec<T>) -> Self

Fortran like, column wise

[ 0, 1, 2] 3, 4, 5, 6, 7, 8 ] => vec![ 0, 3, 6, 1, 4, 7, 2, 5, 8]

impl<T> Matrix<T>

pub fn convert_to_vec(self) -> Vec<T>

impl<T> Matrix<T> where
    T: Scalar + Clone + Copy + Zero + One, 

pub fn new_random(m: usize, n: usize) -> Matrix<T>

impl<T> Matrix<T> where
    T: Zero + Clone, 

pub fn zero(m: usize, n: usize) -> Self

Returns the zero matrix(additive neutral element)

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = &a + &Matrix::zero(2, 2);

assert_eq!(a, b);

impl<T> Matrix<T> where
    T: One + Zero + Clone, 

pub fn one(size: usize) -> Self

Returns the eye matrix(multiplicative neutral element)

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = &a * &Matrix::one(2);

assert_eq!(a, b);

pub fn ones(m: usize, n: usize) -> Self

impl<T> Matrix<T> where
    T: Real, 

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

Calculates the pseudo inverse matrix

A^+ = (A^TA)^-1A^T

impl<T> Matrix<T>

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

Returns the matrix dimension

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(4, 2, vec![1.0, 0.0, 3.0, 0.0, 1.0, -7.0, 0.5, 0.25]);
let (m, n) = a.dim();

assert_eq!(4, m);
assert_eq!(2, n);

impl<T> Matrix<T> where
    T: Real + 'static, 

pub fn eigenvalue(&self) -> Vector<T>

Computes the eigenvalues of a real matrix

Arguments

Return

Vector with unsorted eigenvalues

Example

use mathru::algebra::linear::{Vector, Matrix};

let a: Matrix<f64> = Matrix::new(3, 3, vec![1.0, -3.0, 3.0, 3.0, -5.0, 3.0, 6.0, -6.0, 4.0]);
let eig: Vector<f64> = a.eigenvalue();

pub fn eigenvalue_r(&self) -> Vector<T>

impl<T> Matrix<T> where
    T: Real, 

pub fn dec_hessenberg(&self) -> (Matrix<T>, Matrix<T>)

Decomposes self in to the M

q * h * q^T = self

Arguments

Return

(q, h)

q:

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(3, 3, vec![1.0, 5.0, 3.0, 1.0, 0.0, -7.0, 3.0, 8.0, 9.0]);
let (q, h): (Matrix<f64>, Matrix<f64>) = a.dec_hessenberg();

impl<T> Matrix<T> where
    T: Real, 

pub fn dec_lu<'a>(&'a self) -> (Matrix<T>, Matrix<T>, Matrix<T>)

Decomposes the matrix into a upper and a lower matrix

PA = LU

Arguments

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, -2.0, 3.0, -7.0]);

let (l, u, p): (Matrix<f64>, Matrix<f64>, Matrix<f64>) = a.dec_lu();

impl<T> Matrix<T> where
    T: Real, 

pub fn dec_qr<'a>(&'a self) -> (Matrix<T>, Matrix<T>)

QR Decomposition with Givens rotations

A = QR
Q is an orthogonal matrix
R is an upper triangular matrix

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, -2.0, 3.0, -7.0]);

let (q, r): (Matrix<f64>, Matrix<f64>) = a.dec_qr();

impl<T> Matrix<T> where
    T: Real, 

pub fn inv<'a>(&'a self) -> Option<Matrix<T>>

Inverse Matrix

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b_inv: Matrix<f64> = a.inv().unwrap();

pub fn inv_r(&self) -> Option<Matrix<T>>

pub fn subst_backward<'a>(&'a mut self)

inplace backward substitution

impl<T> Matrix<T> where
    T: Real, 

pub fn add_func(&self, rhs: &Matrix<T>) -> Matrix<T>

impl<T> Matrix<T> where
    T: Real, 

pub fn dec_cholesky<'a>(&'a self) -> Matrix<T>

Decomposes the symetric, positive definite matrix A into a lower triangular matrix L A = L L^T

Arguments

A has to be symetric and postive definite

Example

#[macro_use]
extern crate mathru;
fn main()
{
    use mathru::algebra::linear::Matrix;

    let a: Matrix<f64> = matrix![   2.0, -1.0, 0.0;
                               -1.0, 2.0, -1.0;
                                0.0, -1.0,  2.0];

    let l: (Matrix<f64>) = a.dec_cholesky();
}

impl<T> Matrix<T> where
    T: Real, 

pub fn solve_vector(&self, y: &Vector<T>) -> Option<Vector<T>>

Solves Ax = y where A \in R^{m * n}, x \in R^n, y \in R^m

pub fn solve_vector_r(&self, y: &Vector<T>) -> Option<Vector<T>>

pub fn solve_matrix(&self, y: &Matrix<T>) -> Option<Matrix<T>>

Solves Ax = Y where A \in R^{m * n}, x \in R^n, y \in R^{m, k}

pub fn solve_matrix_r(&self, y: &Matrix<T>) -> Option<Matrix<T>>

Trait Implementations

impl<T> IntoIterator for Matrix<T> where
    T: Real, 

type Item = T

The type of the elements being iterated over.

type IntoIter = MatrixIntoIterator<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Clone> 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> PartialEq<Matrix<T>> for Matrix<T> where
    T: PartialEq, 

fn eq<'a, 'b>(&'a self, other: &'b Self) -> bool

Checks if two matrices are equal

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);

assert_eq!(true, a==b);

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<T> Div<T> for Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, m: T) -> Matrix<T>

Divides all matrix element with a scalar

Example

use mathru::algebra::linear::{Matrix};

let res_ref: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let f: f64 = 7.0;
let a: Matrix<f64> = Matrix::new(2, 2, vec![7.0, 0.0, 21.0, -49.0]);

assert_eq!(res_ref, a / f);

impl<'a, 'b, T> Div<&'b T> for &'a Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, m: &'b T) -> Matrix<T>

Divide all matrix with a scalar

Example

use mathru::algebra::linear::{Matrix};

let res_ref: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let a: Matrix<f64> = Matrix::new(2, 2, vec![4.0, 0.0, 12.0, -28.0]);

assert_eq!(res_ref, &a / &4.0);

impl<T> Sub<Matrix<T>> for Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Subtracts two matrices

A = (a_{ij}) \in T^{m \times n} B = (b_{ij}) \in T^{m \times n} A - B = ( a_{ij} - b_{ij} )

Arguments

rhs:

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);

assert_eq!(Matrix::zero(2, 2), a - b);

impl<'a, 'b, T> Sub<&'b Matrix<T>> for &'a Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Matrix<T>) -> Self::Output

Performs the - operation.

impl<'a, 'b, T> Sub<&'b T> for &'a Matrix<T> where
    T: Real, 

Subtracts scalar from all matrix elements

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Subtracts a scalar value from all matrix elements

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![5.0, 4.0, 7.0, -3.0]);

assert_eq!(b, &a - &-4.0);

impl<T> Sub<T> for Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Subtracts a scalar from all matrix elements

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![5.0, 4.0, 7.0, -3.0]);

assert_eq!(b, a - -4.0);

impl<T> Add<Matrix<T>> for Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Adds two matrices

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);

assert_eq!(b, Matrix::zero(2, 2) + a);

impl<'a, 'b, T> Add<&'b Matrix<T>> for &'a Matrix<T> where
    T: Real, 

Adds two matrices

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Matrix<T>) -> Self::Output

Adds two matrices

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);

assert_eq!(b, &Matrix::zero(2, 2) + &a);

impl<'a, 'b, T> Add<&'b T> for &'a Matrix<T> where
    T: Add + Zero + Clone, 

Add scalar to matrix

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Add a scalar to the matrix

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![-3.0, -4.0, -1.0, -11.0]);

assert_eq!(b, &a + &-4.0);

impl<T> Add<T> for Matrix<T> where
    T: Add + Zero + Clone, 

Add scalar to matrix

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Add a scalar to the matrix

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![-3.0, -4.0, -1.0, -11.0]);

assert_eq!(b, a + -4.0);

impl<T> Mul<Matrix<T>> for Vector<T> where
    T: Copy + Zero + Mul<T, Output = T> + Add<T, Output = T> + One + Display, 

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Matrix<T>> for &'a Vector<T> where
    T: Copy + Zero + Mul<T, Output = T> + Add<T, Output = T> + One + Display, 

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<T>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Vector<T>> for &'a Matrix<T> where
    T: Copy + Zero + Mul<T, Output = T> + Add<T, Output = T> + One + AddAssign, 

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, v: &'b Vector<T>) -> Vector<T>

Performs the * operation.

impl<T> Mul<T> for Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: T) -> Matrix<T>

Multiplies a matrix with a scalar

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let f: f64 = 7.0;
let res_ref: Matrix<f64> = Matrix::new(2, 2, vec![7.0, 0.0, 21.0, -49.0]);

assert_eq!(res_ref, a * f);

impl<'a, 'b, T> Mul<&'b T> for &'a Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &'b T) -> Matrix<T>

Multiplies a matrix with a scalar

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let res_ref: Matrix<f64> = Matrix::new(2, 2, vec![4.0, 0.0, 12.0, -28.0]);

assert_eq!(res_ref, &a * &4.0);

impl<T> Mul<Vector<T>> for Matrix<T> where
    T: Copy + Zero + Mul<T, Output = T> + Add<T, Output = T> + One + AddAssign, 

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: Vector<T>) -> Vector<T>

Performs the * operation.

impl<T> Mul<Matrix<T>> for Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Multiplies two matrices

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let res_ref: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, -18.0, 49.0]);
assert_eq!(res_ref, a * b);

impl<'a, 'b, T> Mul<&'b Matrix<T>> for &'a Matrix<T> where
    T: Real, 

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Matrix<T>) -> Self::Output

Multiplies two matrices

Example

use mathru::algebra::linear::{Matrix};

let a: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let b: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, 3.0, -7.0]);
let res_ref: Matrix<f64> = Matrix::new(2, 2, vec![1.0, 0.0, -18.0, 49.0]);
assert_eq!(res_ref, &a * &b);

impl<T> Serialize for Matrix<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de, T> Deserialize<'de> for Matrix<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.