Struct opensrdk_linear_algebra::matrix::Matrix

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

Matrix

Implementations

impl Matrix

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

impl Matrix<c64>

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

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 getrf(self) -> Result<(Matrix, Vec<i32>), MatrixError>

LU decomposition

for f64

impl Matrix<c64>

pub fn getrf(self) -> Result<(Matrix<c64>, Vec<i32>), MatrixError>

LU decomposition

for c64

impl Matrix

pub fn getri(self, ipiv: &[i32]) -> Result<Matrix, MatrixError>

Inverse

with matrix decomposed by getrf

impl Matrix<c64>

pub fn getri(self, ipiv: &[i32]) -> Result<Matrix<c64>, MatrixError>

Inverse

with matrix decomposed by getrf

impl Matrix

pub fn getrs(&self, ipiv: &[i32], b: Matrix) -> Result<Matrix, MatrixError>

Solve equation

with matrix decomposed by getrf

$$ \mathbf{A} \mathbf{x} = \mathbf{b} $$

$$ \mathbf{x} = \mathbf{A}^{-1} \mathbf{b} $$

impl Matrix<c64>

pub fn getrs(
    &self,
    ipiv: &[i32],
    bt: Matrix<c64>
) -> Result<Matrix<c64>, MatrixError>

Solve equation

with matrix decomposed by getrf

$$ \mathbf{A} \mathbf{x} = \mathbf{b} $$

$$ \mathbf{x} = \mathbf{A}^{-1} \mathbf{b} $$

impl Matrix<c64>

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

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

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

Linear product

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

Hamadard product

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 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<Matrix, 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<Matrix<c64>, MatrixError>

Cholesky decomposition

for positive definite c64 matrix

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

A = L * L^*

impl Matrix

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

Inverse

with matrix decomposed by potrf

impl Matrix<c64>

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

Inverse

with matrix decomposed by potrf

impl Matrix

pub fn potrs(&self, b: Matrix) -> Result<Matrix, MatrixError>

Solve equation

with matrix decomposed by potrf

$$ \mathbf{A} \mathbf{x} = \mathbf{b} $$

$$ \mathbf{x} = \mathbf{A}^{-1} \mathbf{b} $$

impl Matrix<c64>

pub fn potrs(&self, b: Matrix<c64>) -> Result<Matrix<c64>, MatrixError>

Solve equation

with matrix decomposed by potrf

$$ \mathbf{A} \mathbf{x} = \mathbf{b} $$

$$ \mathbf{x} = \mathbf{A}^{-1} \mathbf{b} $$

impl Matrix

pub fn sytrd(self) -> Result<(Matrix, SymmetricTridiagonalMatrix), 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<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<T> Matrix<T> where
    T: Number, 

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

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

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

pub fn rows(&self) -> usize

pub fn cols(&self) -> usize

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

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

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

impl Matrix<f64>

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

impl Matrix<c64>

pub fn to_real(&self) -> Matrix<f64>

Trait Implementations

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 Add<Matrix<Complex<f64>>> for c64

type Output = Matrix<c64>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<c64>) -> 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 &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 Add<Matrix<f64>> for f64

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: Matrix) -> 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: Clone> Clone for Matrix<T> where
    T: Number, 

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: Debug> Debug for Matrix<T> where
    T: Number, 

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

Formats the value using the given formatter.

impl<T: Default> Default for Matrix<T> where
    T: Number, 

fn default() -> Matrix<T>

Returns the “default value” for a type.

impl<T: Hash> Hash for Matrix<T> where
    T: Number, 

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, 

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 Mul<&'_ Matrix<Complex<f64>>> for Matrix<c64>

type Output = Matrix<c64>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix<c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<c64>) -> 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<f64>> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&'_ Matrix<f64>> for &Matrix<f64>

type Output = Matrix<f64>

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 Mul<Complex<f64>> for Matrix<c64>

type Output = Matrix<c64>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix<c64>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix<c64>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix<c64>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<c64>) -> 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<f64>> for f64

type Output = Matrix<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<f64>> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix<f64>

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 Mul<f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: PartialEq> PartialEq<Matrix<T>> for Matrix<T> where
    T: Number, 

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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 Sub<Matrix<Complex<f64>>> for c64

type Output = Matrix<c64>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<c64>) -> 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 &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 Sub<Matrix<f64>> for f64

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix) -> 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> 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> StructuralPartialEq for Matrix<T> where
    T: Number,