Struct ohsl::matrix::Matrix

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

Implementations

impl<T> Matrix<T>

pub fn empty() -> Self

Create a new matrix of unspecified size

pub fn create(mat: Vec<Vector<T>>) -> Self

Create a matrix from an std::vec::Vec<Vector>

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

pub fn clear(&mut self)

Remove all the elements from 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

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

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)

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)

pub fn determinant(&self) -> T

Calculate the determinant of the matrix ( via LU decomposition )

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

Return the inverse of the matrix ( via LU decomposition )

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<T: Display> Matrix<T>

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

Print the matrix to a file

Trait Implementations

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

type Output = Self

The resulting type after applying the + operator.

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

Add the elements of two matrices together ( binary + )

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

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

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

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

pub fn add_assign(&mut self, rhs: T)

Add the same value to every element in a mutable matrix

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

pub fn clone(&self) -> Self

Clone the matrix

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

Performs copy-assignment from source.

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

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

Format the output

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

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

Format the output

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

type Output = Self

The resulting type after applying the / operator.

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

Divide a matrix by a scalar (matrix / scalar)

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

pub fn div_assign(&mut self, rhs: T)

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

impl<T> Index<usize> for Matrix<T>

type Output = Vector<T>

The returned type after indexing.

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

Indexing operator [] (read only)

impl<T> IndexMut<usize> for Matrix<T>

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

Indexing operator [] (read/write)

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

type Output = Self

The resulting type after applying the * operator.

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

Multiply two matrices together ( matrix * matrix )

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

type Output = Self

The resulting type after applying the * operator.

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

Multiply a matrix by a scalar (matrix * scalar)

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

type Output = Vector<T>

The resulting type after applying the * operator.

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

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

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

pub fn mul_assign(&mut self, rhs: T)

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

impl<T: Clone + Neg<Output = T>> Neg for Matrix<T>

type Output = Self

The resulting type after applying the - operator.

pub fn neg(self) -> Self::Output

Return the unary negation ( unary - ) of each element

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

type Output = Self

The resulting type after applying the - operator.

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

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

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

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

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

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

pub fn sub_assign(&mut self, rhs: T)

Subtract the same value from every element in a mutable matrix