Struct opensrdk_linear_algebra::matrix::ge::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 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 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<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 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<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<f64>

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

impl Matrix<c64>

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

Trait Implementations

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the + operator.

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

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the + operator.

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

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix<f64>> for &f64

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix<f64>> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix<f64>> for f64

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Clone for Matrix<T>where T: Number + Clone,

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Complex<f64>>> for &Matrix<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 Mul<Matrix<Complex<f64>>> for Matrix<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 &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 &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 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> 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<Matrix<T>> for Matrix<T>where T: Number + PartialEq,

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the - operator.

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

type Output = Matrix<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Matrix<Complex<f64>>

The resulting type after applying the - operator.

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

type Output = Matrix<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix<f64>> for &f64

type Output = Matrix<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix<f64>> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix<f64>> for f64

type Output = Matrix<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for Matrix<f64>

type Output = Matrix<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> 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> 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,