Struct Faer 

pub struct Faer;

Trait Implementations

impl Default for Faer

fn default() -> Faer

Returns the “default value” for a type.

impl<T> Eig<T> for Faer

where T: ComplexFloat + ComplexField + Default + From<<T as ComplexFloat>::Real> + 'static,

fn eig<L: Layout>(&self, a: &mut DSlice<T, 2, L>) -> EigResult<T>

Compute eigenvalues and right eigenvectors with new allocated matrices The matrix A satisfies: A * v = λ * v where v are the right eigenvectors

fn eig_values<L: Layout>(&self, a: &mut DSlice<T, 2, L>) -> EigResult<T>

Compute only eigenvalues with new allocated vectors

fn eigh<L: Layout>(&self, a: &mut DSlice<T, 2, L>) -> EigResult<T>

Compute eigenvalues and eigenvectors of a Hermitian matrix (input should be complex)

fn eigs<L: Layout>(&self, a: &mut DSlice<T, 2, L>) -> EigResult<T>

Compute eigenvalues and eigenvectors of a symmetric matrix (input should be real)

fn schur<L: Layout>(&self, _a: &mut DSlice<T, 2, L>) -> SchurResult<T>

Compute Schur decomposition with new allocated matrices

fn schur_overwrite<L: Layout>( &self, _a: &mut DSlice<T, 2, L>, _t: &mut DSlice<T, 2, Dense>, _z: &mut DSlice<T, 2, Dense>, ) -> Result<(), SchurError>

Compute Schur decomposition overwriting existing matrices

fn schur_complex<L: Layout>(&self, _a: &mut DSlice<T, 2, L>) -> SchurResult<T>

Compute Schur (complex) decomposition with new allocated matrices

fn schur_complex_overwrite<L: Layout>( &self, _a: &mut DSlice<T, 2, L>, _t: &mut DSlice<T, 2, Dense>, _z: &mut DSlice<T, 2, Dense>, ) -> Result<(), SchurError>

Compute Schur (complex) decomposition overwriting existing matrices

fn eig_full<L: Layout>( &self, _a: &mut DSlice<T, 2, L>, ) -> Result<EigDecomp<T>, EigError>

Compute eigenvalues and both left/right eigenvectors with new allocated matrices The matrix A satisfies: A * vr = λ * vr and vl^H * A = λ * vl^H where vr are right eigenvectors and vl are left eigenvectors

impl<T> LU<T> for Faer

where T: ComplexFloat + ComplexField + Default + From<<T as ComplexFloat>::Real> + 'static,

fn lu<L: Layout>( &self, a: &mut DSlice<T, 2, L>, ) -> (DTensor<T, 2>, DTensor<T, 2>, DTensor<T, 2>)

Computes LU decomposition with new allocated matrices: L, U, P (permutation matrix)

fn lu_overwrite<L: Layout, Ll: Layout, Lu: Layout, Lp: Layout>( &self, a: &mut DSlice<T, 2, L>, l: &mut DSlice<T, 2, Ll>, u: &mut DSlice<T, 2, Lu>, p: &mut DSlice<T, 2, Lp>, )

Computes LU decomposition overwriting existing matrices

fn inv<L: Layout>(&self, a: &mut DSlice<T, 2, L>) -> InvResult<T>

Computes inverse with new allocated matrix

fn inv_overwrite<L: Layout>( &self, a: &mut DSlice<T, 2, L>, ) -> Result<(), InvError>

Computes inverse overwriting the input matrix

fn det<L: Layout>(&self, a: &mut DSlice<T, 2, L>) -> T

Computes the determinant of a square matrix. Panics if the matrix is non-square.

fn choleski<L: Layout>(&self, _a: &mut DSlice<T, 2, L>) -> InvResult<T>

Computes the Cholesky decomposition, returning a lower-triangular matrix

fn choleski_overwrite<L: Layout>( &self, _a: &mut DSlice<T, 2, L>, ) -> Result<(), InvError>

Computes the Cholesky decomposition in-place, overwriting the input matrix

impl<T> MatMul<T> for Faer

where T: ComplexFloat + ComplexField + One + 'static,

fn contract_all<'a, La, Lb>( &self, a: &'a Slice<T, DynRank, La>, b: &'a Slice<T, DynRank, Lb>, ) -> impl ContractBuilder<'a, T, La, Lb>

where T: 'a, La: Layout, Lb: Layout,

Contracts all axes of the first tensor with all axes of the second tensor.

fn contract_n<'a, La, Lb>( &self, a: &'a Slice<T, DynRank, La>, b: &'a Slice<T, DynRank, Lb>, n: usize, ) -> impl ContractBuilder<'a, T, La, Lb>

where T: 'a, La: Layout, Lb: Layout,

Contracts the last n axes of the first tensor with the first n axes of the second tensor.

Example

For two matrices (2D tensors), contract_n(1) performs standard matrix multiplication.

fn contract<'a, La, Lb>( &self, a: &'a Slice<T, DynRank, La>, b: &'a Slice<T, DynRank, Lb>, axes_a: impl Into<Box<[usize]>>, axes_b: impl Into<Box<[usize]>>, ) -> impl ContractBuilder<'a, T, La, Lb>

where T: 'a, La: Layout, Lb: Layout,

Specifies exactly which axes to contract_all.

Example

specific([1, 2], [3, 4]) contracts axis 1 and 2 of a with axes 3 and 4 of b.

fn matmul<'a, La, Lb>( &self, a: &'a DSlice<T, 2, La>, b: &'a DSlice<T, 2, Lb>, ) -> impl MatMulBuilder<'a, T, La, Lb>

where La: Layout, Lb: Layout,

impl<T> QR<T> for Faer

where T: ComplexFloat + ComplexField + Default + From<<T as ComplexFloat>::Real> + 'static,

fn qr<L: Layout>( &self, a: &mut DSlice<T, 2, L>, ) -> (DTensor<T, 2>, DTensor<T, 2>)

Compute full QR decomposition with new allocated matrices

fn qr_overwrite<L: Layout, Lq: Layout, Lr: Layout>( &self, a: &mut DSlice<T, 2, L>, q: &mut DSlice<T, 2, Lq>, r: &mut DSlice<T, 2, Lr>, )

Compute full QR decomposition, overwriting existing matrices

impl<T> SVD<T> for Faer

where T: ComplexFloat + ComplexField + Default + From<<T as ComplexFloat>::Real> + 'static,

fn svd<L: Layout>( &self, a: &mut DSlice<T, 2, L>, ) -> Result<SVDDecomp<T>, SVDError>

Compute full SVD with new allocated matrices

fn svd_s<L: Layout>( &self, a: &mut DSlice<T, 2, L>, ) -> Result<DTensor<T, 2>, SVDError>

Compute only singular values with new allocated matrix

fn svd_overwrite<L: Layout, Ls: Layout, Lu: Layout, Lvt: Layout>( &self, a: &mut DSlice<T, 2, L>, s: &mut DSlice<T, 2, Ls>, u: &mut DSlice<T, 2, Lu>, vt: &mut DSlice<T, 2, Lvt>, ) -> Result<(), SVDError>

Compute full SVD, overwriting existing matrices

fn svd_overwrite_s<L: Layout, Ls: Layout>( &self, a: &mut DSlice<T, 2, L>, s: &mut DSlice<T, 2, Ls>, ) -> Result<(), SVDError>

Compute only singular values, overwriting existing matrix

impl<T> Solve<T> for Faer

where T: ComplexFloat + ComplexField + Default + From<<T as ComplexFloat>::Real> + 'static,

fn solve<La: Layout, Lb: Layout>( &self, a: &mut DSlice<T, 2, La>, b: &DSlice<T, 2, Lb>, ) -> SolveResultType<T>

Solves linear system AX = B with new allocated solution matrix A is modified (overwritten with LU decomposition) Returns the solution X and P the permutation matrix (identity in that case), or error

fn solve_overwrite<La: Layout, Lb: Layout, Lp: Layout>( &self, a: &mut DSlice<T, 2, La>, b: &mut DSlice<T, 2, Lb>, p: &mut DSlice<T, 2, Lp>, ) -> Result<(), SolveError>

Solves linear system AX = b overwriting existing matrices A is overwritten with its LU decomposition B is overwritten with the solution X P is filled with the permutation matrix such that PA = LU (here P = identity) Returns Ok(()) on success, Err(SolveError) on failure