Struct Matrix

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

Implementations

impl<T> Matrix<T>

pub fn clear(&mut self)

Remove all the elements from the matrix

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

pub fn get_row(&self, row: usize) -> Vector<T>

Get a row of the matrix as a vector

pub fn get_col(&self, col: usize) -> Vector<T>

Get a column of the matrix as a vector

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

Set a row of the matrix using a vector

pub fn set_col(&mut self, col: usize, vec: Vector<T>)

Set a column of the matrix using a vector

pub fn delete_row(&mut self, row: usize)

Delete a row from the matrix

pub fn multiply(&self, vec: &Vector<T>) -> Vector<T>

Multiply the matrix by a (column) vector and return a vector

pub fn eye(size: usize) -> Self

Create a square identity matrix of specified size

pub fn resize(&mut self, n_rows: usize, n_cols: usize)

Resize the matrix (empty entries are appended if necessary)

pub fn transpose_in_place(&mut self)

Transpose the matrix in place

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

Return the transpose of the matrix

pub fn swap_rows(&mut self, row_1: usize, row_2: usize)

Swap two rows of the matrix

pub fn swap_elem( &mut self, row_1: usize, col_1: usize, row_2: usize, col_2: usize, )

Swap two elements of the matrix

pub fn fill(&mut self, elem: T)

Fill the matrix with specified elements

pub fn fill_diag(&mut self, elem: T)

Fill the leading diagonal of the matrix with specified elements

pub fn fill_band(&mut self, offset: isize, elem: T)

Fill a diagonal band of the matrix with specified elements ( offset above main diagonal +, below main diagonal - )

pub fn fill_tridiag(&mut self, lower: T, diag: T, upper: T)

Fill the main three diagonals of the matrix with specified elements

pub fn fill_row(&mut self, row: usize, elem: T)

Fill a row of the matrix with specified elements

pub fn fill_col(&mut self, col: usize, elem: T)

Fill a column of the matrix with specified elements

impl<T: Clone + Copy + Number + Signed + PartialOrd> Matrix<T>

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

Solve the system of equations Ax=b where b is a specified vector using Gaussian elimination (the matrix A is modified in the process)

Examples found in repository

examples/sparse_linear_system.rs (line 31)

fn main() {
    println!( "------------------ Sparse linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let n: usize = 4;
    let mut a = Mat64::new( n, n, 0.0 );
    let mut triplets = Vec::new();
    for i in 0..n {
        a[(i,i)] = 2.0;
        triplets.push( ( i, i, 2.0 ) );
        if i > 0 {
            a[( i - 1 , i )] = 1.0;
            triplets.push( ( i - 1, i, 1.0 ) );
        }
        if i < n - 1 {
            a[( i + 1 , i )] = 1.0;
            triplets.push( ( i + 1, i, 1.0 ) );
        }
    }
    println!( "  * A ={}", a );
    let b = Vec64::random( n );
    println!( "  * b^T ={}", b );
    println!( "  * as both dense and sparse linear systems.");
    let dense_x = a.solve_basic( &b );
    println!( "  * The dense system gives the solution vector");
    println!( "  * x^T ={}", dense_x );
    let sparse = Sparse::<f64>::from_triplets( n, n, &mut triplets );
    //let sparse_x = sparse.solve( b ).unwrap();
    let mut sparse_x = Vector::<f64>::new( n, 0.0 );
    let max_iter = 1000;
    let tol = 1e-8;
    let result = sparse.solve_bicgstab( &b, &mut sparse_x, max_iter, tol );
    println!( "  * The sparse system gives the solution vector");
    println!( "  * x^T ={}", sparse_x );
    match result {
        Ok( iter ) => println!( "  * The sparse system converged in {} iterations.", iter ),
        Err( error ) => println!( "  * The sparse system failed to converge, error = {}", error )
    }
    let diff = dense_x - sparse_x;
    println!( "  * The maximum difference between the two is {:+.2e}", diff.norm_inf() );
    println!( "-------------------- FINISHED ---------------------" );
}

examples/linear_systems.rs (line 21)

fn main() {
    println!( "------------------ Linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let mut a = Mat64::new( 3, 3, 0.0 );
    a[(0,0)] = 1.0; a[(0,1)] = 1.0; a[(0,2)] =   1.0;
    a[(1,0)] = 0.0; a[(1,1)] = 2.0; a[(1,2)] =   5.0;
    a[(2,0)] = 2.0; a[(2,1)] = 5.0; a[(2,2)] = - 1.0;
    println!( "  * A ={}", a );
    let b = Vec64::create( vec![ 6.0, -4.0, 27.0 ] ); 
    println!( "  * b^T ={}", b );
    let x = a.clone().solve_basic( &b );
    println!( "  * gives the solution vector");
    println!( "  * x^T ={}", x );
    println!( "---------------------------------------------------" );
    println!( "  * Lets solve the complex linear system Cy = d where" );
    let mut c = Matrix::<Cmplx>::new( 2, 2, Cmplx::new( 1.0, 1.0 ) );
    c[(0,1)] = Cmplx::new( -1.0, 0.0 );
    c[(1,0)] = Cmplx::new( 1.0, -1.0 );
    println!( "  * C ={}", c );
    let mut d = Vector::<Cmplx>::new( 2, Cmplx::new( 0.0, 1.0 ) );
    d[1] = Cmplx::new( 1.0, 0.0 );
    println!( "  * d^T ={}", d );
    println!( "  * Using LU decomposition we find that ");
    let y = c.clone().solve_lu( &d );
    println!( "  * y^T ={}", y );
    println!( "---------------------------------------------------" );
    println!( "  * We may also find the determinant of a matrix" );
    println!( "  * |A| = {}", a.determinant() );
    println!( "  * |C| = {}", c.determinant() ); 
    println!( "  * or the inverse of a matrix" );
    let inverse = a.inverse();
    println!( "  * A^-1 =\n{}", inverse );
    println!( "  * C^-1 =\n{}", c.inverse() );
    println!( "  * We can check this by multiplication" );
    println!( "  * I = A * A^-1 =\n{}", a * inverse );
    println!( "  * which is sufficiently accurate for our purposes.");
    println!( "-------------------- FINISHED ---------------------" );
}

pub fn lu_decomp_in_place(&mut self) -> (usize, Matrix<T>)

Replace the matrix with its LU decomposition and return the number of pivots and a permutation matrix

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

Solve the system of equations Ax=b where b is a specified vector using LU decomposition (the matrix A is modified in the process)

Examples found in repository

examples/linear_systems.rs (line 34)

fn main() {
    println!( "------------------ Linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let mut a = Mat64::new( 3, 3, 0.0 );
    a[(0,0)] = 1.0; a[(0,1)] = 1.0; a[(0,2)] =   1.0;
    a[(1,0)] = 0.0; a[(1,1)] = 2.0; a[(1,2)] =   5.0;
    a[(2,0)] = 2.0; a[(2,1)] = 5.0; a[(2,2)] = - 1.0;
    println!( "  * A ={}", a );
    let b = Vec64::create( vec![ 6.0, -4.0, 27.0 ] ); 
    println!( "  * b^T ={}", b );
    let x = a.clone().solve_basic( &b );
    println!( "  * gives the solution vector");
    println!( "  * x^T ={}", x );
    println!( "---------------------------------------------------" );
    println!( "  * Lets solve the complex linear system Cy = d where" );
    let mut c = Matrix::<Cmplx>::new( 2, 2, Cmplx::new( 1.0, 1.0 ) );
    c[(0,1)] = Cmplx::new( -1.0, 0.0 );
    c[(1,0)] = Cmplx::new( 1.0, -1.0 );
    println!( "  * C ={}", c );
    let mut d = Vector::<Cmplx>::new( 2, Cmplx::new( 0.0, 1.0 ) );
    d[1] = Cmplx::new( 1.0, 0.0 );
    println!( "  * d^T ={}", d );
    println!( "  * Using LU decomposition we find that ");
    let y = c.clone().solve_lu( &d );
    println!( "  * y^T ={}", y );
    println!( "---------------------------------------------------" );
    println!( "  * We may also find the determinant of a matrix" );
    println!( "  * |A| = {}", a.determinant() );
    println!( "  * |C| = {}", c.determinant() ); 
    println!( "  * or the inverse of a matrix" );
    let inverse = a.inverse();
    println!( "  * A^-1 =\n{}", inverse );
    println!( "  * C^-1 =\n{}", c.inverse() );
    println!( "  * We can check this by multiplication" );
    println!( "  * I = A * A^-1 =\n{}", a * inverse );
    println!( "  * which is sufficiently accurate for our purposes.");
    println!( "-------------------- FINISHED ---------------------" );
}

pub fn determinant(&self) -> T

Calculate the determinant of the matrix ( via LU decomposition )

Examples found in repository

examples/linear_systems.rs (line 38)

fn main() {
    println!( "------------------ Linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let mut a = Mat64::new( 3, 3, 0.0 );
    a[(0,0)] = 1.0; a[(0,1)] = 1.0; a[(0,2)] =   1.0;
    a[(1,0)] = 0.0; a[(1,1)] = 2.0; a[(1,2)] =   5.0;
    a[(2,0)] = 2.0; a[(2,1)] = 5.0; a[(2,2)] = - 1.0;
    println!( "  * A ={}", a );
    let b = Vec64::create( vec![ 6.0, -4.0, 27.0 ] ); 
    println!( "  * b^T ={}", b );
    let x = a.clone().solve_basic( &b );
    println!( "  * gives the solution vector");
    println!( "  * x^T ={}", x );
    println!( "---------------------------------------------------" );
    println!( "  * Lets solve the complex linear system Cy = d where" );
    let mut c = Matrix::<Cmplx>::new( 2, 2, Cmplx::new( 1.0, 1.0 ) );
    c[(0,1)] = Cmplx::new( -1.0, 0.0 );
    c[(1,0)] = Cmplx::new( 1.0, -1.0 );
    println!( "  * C ={}", c );
    let mut d = Vector::<Cmplx>::new( 2, Cmplx::new( 0.0, 1.0 ) );
    d[1] = Cmplx::new( 1.0, 0.0 );
    println!( "  * d^T ={}", d );
    println!( "  * Using LU decomposition we find that ");
    let y = c.clone().solve_lu( &d );
    println!( "  * y^T ={}", y );
    println!( "---------------------------------------------------" );
    println!( "  * We may also find the determinant of a matrix" );
    println!( "  * |A| = {}", a.determinant() );
    println!( "  * |C| = {}", c.determinant() ); 
    println!( "  * or the inverse of a matrix" );
    let inverse = a.inverse();
    println!( "  * A^-1 =\n{}", inverse );
    println!( "  * C^-1 =\n{}", c.inverse() );
    println!( "  * We can check this by multiplication" );
    println!( "  * I = A * A^-1 =\n{}", a * inverse );
    println!( "  * which is sufficiently accurate for our purposes.");
    println!( "-------------------- FINISHED ---------------------" );
}

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

Return the inverse of the matrix ( via LU decomposition )

Examples found in repository

examples/linear_systems.rs (line 41)

fn main() {
    println!( "------------------ Linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let mut a = Mat64::new( 3, 3, 0.0 );
    a[(0,0)] = 1.0; a[(0,1)] = 1.0; a[(0,2)] =   1.0;
    a[(1,0)] = 0.0; a[(1,1)] = 2.0; a[(1,2)] =   5.0;
    a[(2,0)] = 2.0; a[(2,1)] = 5.0; a[(2,2)] = - 1.0;
    println!( "  * A ={}", a );
    let b = Vec64::create( vec![ 6.0, -4.0, 27.0 ] ); 
    println!( "  * b^T ={}", b );
    let x = a.clone().solve_basic( &b );
    println!( "  * gives the solution vector");
    println!( "  * x^T ={}", x );
    println!( "---------------------------------------------------" );
    println!( "  * Lets solve the complex linear system Cy = d where" );
    let mut c = Matrix::<Cmplx>::new( 2, 2, Cmplx::new( 1.0, 1.0 ) );
    c[(0,1)] = Cmplx::new( -1.0, 0.0 );
    c[(1,0)] = Cmplx::new( 1.0, -1.0 );
    println!( "  * C ={}", c );
    let mut d = Vector::<Cmplx>::new( 2, Cmplx::new( 0.0, 1.0 ) );
    d[1] = Cmplx::new( 1.0, 0.0 );
    println!( "  * d^T ={}", d );
    println!( "  * Using LU decomposition we find that ");
    let y = c.clone().solve_lu( &d );
    println!( "  * y^T ={}", y );
    println!( "---------------------------------------------------" );
    println!( "  * We may also find the determinant of a matrix" );
    println!( "  * |A| = {}", a.determinant() );
    println!( "  * |C| = {}", c.determinant() ); 
    println!( "  * or the inverse of a matrix" );
    let inverse = a.inverse();
    println!( "  * A^-1 =\n{}", inverse );
    println!( "  * C^-1 =\n{}", c.inverse() );
    println!( "  * We can check this by multiplication" );
    println!( "  * I = A * A^-1 =\n{}", a * inverse );
    println!( "  * which is sufficiently accurate for our purposes.");
    println!( "-------------------- FINISHED ---------------------" );
}

impl Matrix<f64>

pub fn norm_1(&self) -> f64

Return the matrix one-norm (max absolute column sum)

pub fn norm_inf(&self) -> f64

Return the matrix inf-norm (max absolute row sum)

pub fn norm_p(&self, p: f64) -> f64

Return the matrix p-norm (p=2 is Frobenius, p=inf is max norm)

pub fn norm_frob(&self) -> f64

Return the matrix Frobenius norm

pub fn norm_max(&self) -> f64

Return the entrywise max-norm of the matrix

pub fn jacobian(point: Vec64, func: &dyn Fn(Vec64) -> Vec64, delta: f64) -> Self

Create the Jacobian matrix of a vector valued function at a point using finite-differences

impl Matrix<Cmplx>

pub fn jacobian_cmplx( point: Vector<Cmplx>, func: &dyn Fn(Vector<Cmplx>) -> Vector<Cmplx>, delta: f64, ) -> Self

Create the Jacobian matrix of a complex vector valued function at a point using finite-differences

impl<T> Matrix<T>

pub fn empty() -> Self

Create a new matrix of unspecified size

pub fn rows(&self) -> usize

Return the number of rows in the matrix

pub fn cols(&self) -> usize

Return the number of columns in the matrix

pub fn numel(&self) -> usize

Return the number of elements in the matrix

impl<T: Clone + Number> Matrix<T>

pub fn new(rows: usize, cols: usize, elem: T) -> Self

Create a new matrix of specified size

Examples found in repository

examples/sparse_linear_system.rs (line 13)

fn main() {
    println!( "------------------ Sparse linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let n: usize = 4;
    let mut a = Mat64::new( n, n, 0.0 );
    let mut triplets = Vec::new();
    for i in 0..n {
        a[(i,i)] = 2.0;
        triplets.push( ( i, i, 2.0 ) );
        if i > 0 {
            a[( i - 1 , i )] = 1.0;
            triplets.push( ( i - 1, i, 1.0 ) );
        }
        if i < n - 1 {
            a[( i + 1 , i )] = 1.0;
            triplets.push( ( i + 1, i, 1.0 ) );
        }
    }
    println!( "  * A ={}", a );
    let b = Vec64::random( n );
    println!( "  * b^T ={}", b );
    println!( "  * as both dense and sparse linear systems.");
    let dense_x = a.solve_basic( &b );
    println!( "  * The dense system gives the solution vector");
    println!( "  * x^T ={}", dense_x );
    let sparse = Sparse::<f64>::from_triplets( n, n, &mut triplets );
    //let sparse_x = sparse.solve( b ).unwrap();
    let mut sparse_x = Vector::<f64>::new( n, 0.0 );
    let max_iter = 1000;
    let tol = 1e-8;
    let result = sparse.solve_bicgstab( &b, &mut sparse_x, max_iter, tol );
    println!( "  * The sparse system gives the solution vector");
    println!( "  * x^T ={}", sparse_x );
    match result {
        Ok( iter ) => println!( "  * The sparse system converged in {} iterations.", iter ),
        Err( error ) => println!( "  * The sparse system failed to converge, error = {}", error )
    }
    let diff = dense_x - sparse_x;
    println!( "  * The maximum difference between the two is {:+.2e}", diff.norm_inf() );
    println!( "-------------------- FINISHED ---------------------" );
}

examples/linear_systems.rs (line 14)

fn main() {
    println!( "------------------ Linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let mut a = Mat64::new( 3, 3, 0.0 );
    a[(0,0)] = 1.0; a[(0,1)] = 1.0; a[(0,2)] =   1.0;
    a[(1,0)] = 0.0; a[(1,1)] = 2.0; a[(1,2)] =   5.0;
    a[(2,0)] = 2.0; a[(2,1)] = 5.0; a[(2,2)] = - 1.0;
    println!( "  * A ={}", a );
    let b = Vec64::create( vec![ 6.0, -4.0, 27.0 ] ); 
    println!( "  * b^T ={}", b );
    let x = a.clone().solve_basic( &b );
    println!( "  * gives the solution vector");
    println!( "  * x^T ={}", x );
    println!( "---------------------------------------------------" );
    println!( "  * Lets solve the complex linear system Cy = d where" );
    let mut c = Matrix::<Cmplx>::new( 2, 2, Cmplx::new( 1.0, 1.0 ) );
    c[(0,1)] = Cmplx::new( -1.0, 0.0 );
    c[(1,0)] = Cmplx::new( 1.0, -1.0 );
    println!( "  * C ={}", c );
    let mut d = Vector::<Cmplx>::new( 2, Cmplx::new( 0.0, 1.0 ) );
    d[1] = Cmplx::new( 1.0, 0.0 );
    println!( "  * d^T ={}", d );
    println!( "  * Using LU decomposition we find that ");
    let y = c.clone().solve_lu( &d );
    println!( "  * y^T ={}", y );
    println!( "---------------------------------------------------" );
    println!( "  * We may also find the determinant of a matrix" );
    println!( "  * |A| = {}", a.determinant() );
    println!( "  * |C| = {}", c.determinant() ); 
    println!( "  * or the inverse of a matrix" );
    let inverse = a.inverse();
    println!( "  * A^-1 =\n{}", inverse );
    println!( "  * C^-1 =\n{}", c.inverse() );
    println!( "  * We can check this by multiplication" );
    println!( "  * I = A * A^-1 =\n{}", a * inverse );
    println!( "  * which is sufficiently accurate for our purposes.");
    println!( "-------------------- FINISHED ---------------------" );
}

impl<T: Display> Matrix<T>

pub fn output(&self, filename: &str)

Print the matrix to a file

Trait Implementations

impl<T: Copy + Number> Add<&Matrix<T>> for &Matrix<T>

fn add(self, plus: &Matrix<T>) -> Self::Output

Add the elements of two matrices together ( binary + )

type Output = Matrix<T>

The resulting type after applying the + operator.

impl<T: Copy + Number> Add for Matrix<T>

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

Add the elements of two matrices together ( binary + )

type Output = Matrix<T>

The resulting type after applying the + operator.

impl<T: Copy + Number> AddAssign<&Matrix<T>> for Matrix<T>

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

Add a matrix to a mutable matrix and assign the result ( += )

impl<T: Copy + Number> AddAssign<T> for Matrix<T>

fn add_assign(&mut self, rhs: T)

Add the same value to every element in a mutable matrix

impl<T: Copy + Number> AddAssign for Matrix<T>

fn add_assign(&mut self, rhs: Self)

Add a matrix to a mutable matrix and assign the result ( += )

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

fn clone(&self) -> Self

Clone the matrix

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

Performs copy-assignment from source.

impl<T> Debug for Matrix<T>

where T: Debug,

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

Format the output

impl<T> Display for Matrix<T>

where T: Debug,

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

Format the output

impl<T: Copy + Number> Div<T> for &Matrix<T>

fn div(self, scalar: T) -> Self::Output

Divide a matrix by a scalar (matrix / scalar)

type Output = Matrix<T>

The resulting type after applying the / operator.

impl<T: Copy + Number> Div<T> for Matrix<T>

fn div(self, scalar: T) -> Self::Output

Divide a matrix by a scalar (matrix / scalar)

type Output = Matrix<T>

The resulting type after applying the / operator.

impl<T: Copy + Number> DivAssign<T> for Matrix<T>

fn div_assign(&mut self, rhs: T)

Divide a mutable matrix by a scalar (matrix /= scalar)

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

fn index<'a>(&'a self, index: (usize, usize)) -> &'a T

Indexing operator [] (read only)

type Output = T

The returned type after indexing.

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

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

Indexing operator [] (read/write)

impl<T: Clone + Copy + Number> Mul<&Matrix<T>> for &Matrix<T>

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

Multiply two matrices together ( matrix * matrix )

type Output = Matrix<T>

The resulting type after applying the * operator.

impl<T: Clone + Copy + Number> Mul<&Vector<T>> for &Matrix<T>

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

Multiply a matrix with a (column) vector ( matrix * vector )

type Output = Vector<T>

The resulting type after applying the * operator.

impl Mul<Matrix<f64>> for f64

fn mul(self, matrix: Matrix<f64>) -> Self::Output

Allow multiplication on the left by f64 (f64 * matrix)

type Output = Matrix<f64>

The resulting type after applying the * operator.

impl<T: Copy + Number> Mul<T> for &Matrix<T>

fn mul(self, scalar: T) -> Self::Output

Multiply a matrix by a scalar (matrix * scalar)

type Output = Matrix<T>

The resulting type after applying the * operator.

impl<T: Copy + Number> Mul<T> for Matrix<T>

fn mul(self, scalar: T) -> Self::Output

Multiply a matrix by a scalar (matrix * scalar)

type Output = Matrix<T>

The resulting type after applying the * operator.

impl<T: Clone + Copy + Number> Mul<Vector<T>> for Matrix<T>

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

Multiply a matrix with a (column) vector ( matrix * vector )

type Output = Vector<T>

The resulting type after applying the * operator.

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

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

Multiply two matrices together ( matrix * matrix )

type Output = Matrix<T>

The resulting type after applying the * operator.

impl<T: Copy + Number> MulAssign<T> for Matrix<T>

fn mul_assign(&mut self, rhs: T)

Multiply a mutable matrix by a scalar (matrix *= scalar)

impl<T: Copy + Neg<Output = T> + Signed> Neg for &Matrix<T>

fn neg(self) -> Self::Output

Return the unary negation ( unary - ) of each element

type Output = Matrix<T>

The resulting type after applying the - operator.

impl<T: Copy + Neg<Output = T> + Signed> Neg for Matrix<T>

fn neg(self) -> Self::Output

Return the unary negation ( unary - ) of each element

type Output = Matrix<T>

The resulting type after applying the - operator.

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: Copy + Number> Sub<&Matrix<T>> for &Matrix<T>

fn sub(self, minus: &Matrix<T>) -> Self::Output

Subtract the elements of one matrix from another ( binary - )

type Output = Matrix<T>

The resulting type after applying the - operator.

impl<T: Copy + Number> Sub for Matrix<T>

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

Subtract the elements of one matrix from another ( binary - )

type Output = Matrix<T>

The resulting type after applying the - operator.

impl<T: Copy + Number> SubAssign<&Matrix<T>> for Matrix<T>

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

Subtract a matrix from a mutable matrix and assign the result ( -= )

impl<T: Copy + Number> SubAssign<T> for Matrix<T>

fn sub_assign(&mut self, rhs: T)

Subtract the same value from every element in a mutable matrix

impl<T: Copy + Number> SubAssign for Matrix<T>

fn sub_assign(&mut self, rhs: Self)

Subtract a matrix from a mutable matrix and assign the result ( -= )

impl<T> StructuralPartialEq for Matrix<T>