Struct Matrix

pub struct Matrix<T = f64>
where
    T: Number,
{ /* private fields */ }

Matrix

use opensrdk_linear_algebra::*;

let a = mat!(
  1.0, 2.0;
  3.0, 4.0
);
assert_eq!(a[0], [1.0, 3.0]);
assert_eq!(a[1], [2.0, 4.0]);

assert_eq!(a[(0, 0)], 1.0);
assert_eq!(a[(0, 1)], 2.0);
assert_eq!(a[(1, 0)], 3.0);
assert_eq!(a[(1, 1)], 4.0);

Implementations

impl Matrix

pub fn gemm( self, lhs: &Matrix, rhs: &Matrix, alpha: f64, beta: f64, ) -> Result<Matrix, MatrixError>

C = self A = lhs B = rhs return alpha*op( A )op( B ) + betaC,

impl Matrix<c64>

pub fn gemm( self, lhs: &Matrix<c64>, rhs: &Matrix<c64>, alpha: c64, beta: c64, ) -> Result<Matrix<c64>, MatrixError>

impl Matrix<c64>

pub fn adjoint(&self) -> Matrix<c64>

impl Matrix<f64>

pub fn dot(&self, rhs: &Self) -> Self

impl Matrix<c64>

pub fn dot(&self, rhs: &Self) -> Self

impl<T> Matrix<T>

where T: Number,

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

Transpose

impl<T> Matrix<T>

where T: Number,

pub fn tr(&self) -> T

Trace

impl Matrix

pub fn gesvd(self) -> Result<(Matrix, Matrix, Matrix), MatrixError>

Singular Value Decomposition

https://en.wikipedia.org/wiki/Singular_value_decomposition

M = U * Sigma * V^T (u, sigma, vt)

impl Matrix

pub fn posv_cgm( vec_mul: &dyn Fn(Vec<f64>) -> Result<Vec<f64>, Box<dyn Error + Send + Sync>>, b: Vec<f64>, iterations: usize, ) -> Result<Vec<f64>, MatrixError>

Solve equations with Conjugate Gradient Method

for positiveDefinite matrix

impl Matrix

pub fn potrf(self) -> Result<POTRF, MatrixError>

Cholesky decomposition

for positive definite f64 matrix

https://en.wikipedia.org/wiki/Cholesky_decomposition

A = L * L^T

impl Matrix<c64>

pub fn potrf(self) -> Result<POTRF<c64>, MatrixError>

Cholesky decomposition

for positive definite c64 matrix

https://en.wikipedia.org/wiki/Cholesky_decomposition

A = L * L^*

impl Matrix

pub fn sytrd(self) -> Result<SYTRD, MatrixError>

Tridiagonalize

for symmetric matrix

pub fn sytrd_k( n: usize, k: usize, vec_mul: &dyn Fn(Vec<f64>) -> Result<Vec<f64>, Box<dyn Error + Send + Sync>>, probe: Option<&[f64]>, ) -> Result<(Matrix, SymmetricTridiagonalMatrix), MatrixError>

Lanczos algorithm

for symmetric matrix only k iteration

impl Matrix

pub fn sytrf(self) -> Result<SYTRF, MatrixError>

impl Matrix<c64>

pub fn sytrf(self) -> Result<SYTRF<c64>, MatrixError>

pub fn hetrf(self) -> Result<HETRF, MatrixError>

impl<T> Matrix<T>

where T: Number,

pub fn trdet(&self) -> T

Determinant

for triangle matrix To apply this method to none triangle matrix, use LU decomposition or Cholesky decomposition.

impl Matrix

pub fn getrf(self) -> Result<GETRF, MatrixError>

LU decomposition

for f64

impl Matrix<c64>

pub fn getrf(self) -> Result<GETRF<c64>, MatrixError>

LU decomposition

for c64

impl<T> Matrix<T>

where T: Number,

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

pub fn from(rows: usize, elems: Vec<T>) -> Result<Self, MatrixError>

You can do unwrap() if you have a conviction that elems.len() % rows == 0

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

pub fn rows(&self) -> usize

pub fn cols(&self) -> usize

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

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

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

pub fn reshape(self, rows: usize) -> Self

pub fn eject_row(&self, index: usize) -> Vec<T>

pub fn eject_sub_matrix( &self, start_i: usize, start_j: usize, rows: usize, cols: usize, ) -> Matrix<T>

impl Matrix<c64>

pub fn real(&self) -> (Matrix<f64>, Matrix<f64>)

Trait Implementations

impl<T> Add<&DiagonalMatrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<&Matrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<&T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<DiagonalMatrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix<Complex<f64>>> for &c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix<Complex<f64>>> for c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Matrix<T>> for &DiagonalMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Matrix<T>> for &Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Matrix<T>> for DiagonalMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix> for &f64

type Output = Matrix

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix> for f64

type Output = Matrix

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign for Matrix<T>

where T: Number,

fn add_assign(&mut self, rhs: Matrix<T>)

Performs the += operation.

impl<T> Clone for Matrix<T>

where T: Number + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Matrix<T>

where T: Number + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Matrix<T>

where T: Number + Default,

fn default() -> Matrix<T>

Returns the “default value” for a type.

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

where T: Number + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div<&Matrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<&T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Matrix<Complex<f64>>> for &c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<c64>) -> Self::Output

Performs the / operation.

impl Div<Matrix<Complex<f64>>> for c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<c64>) -> Self::Output

Performs the / operation.

impl<T> Div<Matrix<T>> for &Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Matrix> for &f64

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<f64>) -> Self::Output

Performs the / operation.

impl Div<Matrix> for f64

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<f64>) -> Self::Output

Performs the / operation.

impl<T> Div<T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign for Matrix<T>

where T: Number,

fn div_assign(&mut self, rhs: Matrix<T>)

Performs the /= operation.

impl From<Matrix> for Matrix<c64>

fn from(m: Matrix<f64>) -> Self

Converts to this type from the input type.

impl<T> Hash for Matrix<T>

where T: Number + Hash,

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>

where T: Number,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

where T: Number,

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

where T: Number,

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

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

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

where T: Number,

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

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

impl<T> Mul<&Matrix<T>> for &SparseMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Matrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Matrix<T>> for SparseMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&SparseMatrix<T>> for &Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&SparseMatrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Complex<f64>>> for &c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Complex<f64>>> for c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Matrix<T>> for &Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Matrix<T>> for &SparseMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Matrix<T>> for SparseMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix> for &f64

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix> for f64

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<SparseMatrix<T>> for &Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<SparseMatrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign for Matrix<T>

where T: Number,

fn mul_assign(&mut self, rhs: Matrix<T>)

Performs the *= operation.

impl<T> Neg for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> PartialEq for Matrix<T>

where T: Number + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

const 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> Product for Matrix<T>

where T: Number,

fn product<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T> Serialize for Matrix<T>

where T: Number + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub<&DiagonalMatrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<&Matrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<&T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<DiagonalMatrix<T>> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix<Complex<f64>>> for &c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix<Complex<f64>>> for c64

type Output = Matrix<Complex<f64>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Matrix<T>> for &DiagonalMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Matrix<T>> for &Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Matrix<T>> for DiagonalMatrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix> for &f64

type Output = Matrix

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix> for f64

type Output = Matrix

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<T> for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub for Matrix<T>

where T: Number,

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign for Matrix<T>

where T: Number,

fn sub_assign(&mut self, rhs: Matrix<T>)

Performs the -= operation.

impl<T> SubMatrix<T> for &Matrix<T>

where T: Number,

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

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

impl<T> SubMatrix<T> for Matrix<T>

where T: Number,

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

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

impl<T> Sum for Matrix<T>

where T: Number,

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Tensor<T> for Matrix<T>

where T: Number,

fn rank(&self) -> usize

fn size(&self, level: usize) -> usize

fn elem(&self, indices: &[usize]) -> T

fn elem_mut(&mut self, indices: &[usize]) -> &mut T

impl<T> StructuralPartialEq for Matrix<T>

where T: Number,