Struct Faer 

pub struct Faer;

Faer backend.

Implements the linear algebra traits from mdarray_linalg by delegating to the pure-Rust faer library. This backend supports the broadest range of operations — from basic BLAS to full decompositions and tensor contractions — without requiring any system BLAS/LAPACK installation.

Trait Implementations

impl<T> Contract<T> for Faer

where T: ComplexFloat + ComplexField + Zero + One + 'static + MulAdd<Output = T> + AddAssign + Sum,

fn matmul<'a, D0, D1, D2, La, Lb>( &self, a: &'a Slice<T, (D0, D1), La>, b: &'a Slice<T, (D1, D2), Lb>, ) -> impl MatmulBuilder<'a, T, D0, D1, D2, La, Lb>

where La: Layout, Lb: Layout, D0: Dim, D1: Dim, D2: Dim,

Matrix multiplication.

fn contract_all<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, ) -> T

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Contracts all axes of a with all axes of b.

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

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Contracts the last n axes of a with the first n axes of b.

fn contract_pairs<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, axes_a: &'a [usize], axes_b: &'a [usize], ) -> impl ContractBuilder<'a, T, Sa, Sb, La, Lb>

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Contracts explicit pairs of axes.

fn contract<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, indices_a: &'a [u8], indices_b: &'a [u8], indices_c: &'a [u8], ) -> impl ContractBuilder<'a, T, Sa, Sb, La, Lb>

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Fully general contraction of two tensors, à la einsum.

impl Default for Faer

fn default() -> Faer

Returns the “default value” for a type.

impl<T, D0: Dim, D1: Dim> Eig<T, D0, D1> for Faer

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

fn eig<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<EigDecomp<Self::SpectralScalar, D0, D1>, EigError>

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 Slice<T, (D0, D1), L>, ) -> Result<Array<Self::SpectralScalar, (D0,)>, EigError>

Compute only eigenvalues with new allocated vectors

fn eigh<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<EighDecomp<T, Self::RealScalar, D0, D1>, EigError>

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

fn schur<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<SchurDecomp<T, D0, D1>, SchurError>

Compute Schur decomposition with new allocated matrices

fn schur_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, t: &mut Slice<T, (D0, D1), Dense>, z: &mut Slice<T, (D0, D1), Dense>, ) -> Result<(), SchurError>

Compute Schur decomposition overwriting existing matrices

fn schur_complex<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<SchurDecomp<Self::SpectralScalar, D0, D1>, SchurError>

Compute Schur (complex) decomposition with new allocated matrices

fn schur_complex_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, t: &mut Slice<Self::SpectralScalar, (D0, D1), Dense>, z: &mut Slice<Self::SpectralScalar, (D0, D1), Dense>, ) -> Result<(), SchurError>

Compute Schur (complex) decomposition overwriting existing matrices

type SpectralScalar = Complex<<T as ComplexFloat>::Real>

Spectral scalar type used for general eigenvalues/eigenvectors and complex Schur decompositions.

type RealScalar = <T as ComplexFloat>::Real

Real scalar type used for self-adjoint eigenvalues.

fn eig_full<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<EigDecomp<Self::SpectralScalar, D0, D1>, 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.

impl<T, D0: Dim, D1: Dim> LU<T, D0, D1> for Faer

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

fn lu<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> (Array<T, (D0, D0)>, Array<T, (D0, D1)>, Array<T, (D0, D0)>)

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

fn lu_write<L: Layout, Ll: Layout, Lu: Layout, Lp: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, l: &mut Slice<T, (D0, D0), Ll>, u: &mut Slice<T, (D0, D1), Lu>, p: &mut Slice<T, (D0, D0), Lp>, )

Computes LU decomposition overwriting existing matrices

fn inv<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<Array<T, (D0, D1)>, InvError>

Computes inverse with new allocated matrix

fn inv_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<(), InvError>

Computes inverse overwriting the input matrix

fn det<L: Layout>(&self, a: &mut Slice<T, (D0, D1), L>) -> T

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

fn cholesky<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<Array<T, (D0, D1)>, InvError>

Computes the Cholesky decomposition, returning a lower-triangular matrix

fn cholesky_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<(), InvError>

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

impl<T, D0: Dim, D1: Dim> MatVec<T, D0, D1> for Faer

where T: FaerVectorScalar + One,

fn matvec<'a, La, Lx>( &self, a: &'a Slice<T, (D0, D1), La>, x: &'a Slice<T, (D1,), Lx>, ) -> impl MatVecBuilder<'a, T, La, Lx, D0, D1>

where La: Layout, Lx: Layout,

impl<T, Dx, Dy> Outer<T, Dx, Dy> for Faer

where T: FaerVectorScalar + One, Dx: Dim, Dy: Dim,

fn outer<'a, Lx, Ly>( &self, x: &'a Slice<T, (Dx,), Lx>, y: &'a Slice<T, (Dy,), Ly>, ) -> impl OuterBuilder<'a, T, Lx, Ly, Dx, Dy>

where Lx: Layout, Ly: Layout,

impl<T, D0: Dim, D1: Dim> QR<T, D0, D1> for Faer

where T: ComplexFloat + ComplexField + Default,

fn qr<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> (Array<T, (D0, usize)>, Array<T, (usize, D1)>)

Compute QR decomposition with new allocated matrices

fn qr_write<D2: Dim, L: Layout, Lq: Layout, Lr: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, q: &mut Slice<T, (D0, D2), Lq>, r: &mut Slice<T, (D2, D1), Lr>, )

Compute QR decomposition overwriting existing matrices

impl<T, D> SVD<T, D> for Faer

where T: ComplexFloat + ComplexField + Default, D: Dim,

fn svd<L: Layout>( &self, a: &mut Slice<T, (D, D), L>, ) -> Result<SVDDecomp<T, Self::SingularValue, D>, SVDError>

Compute full SVD with new allocated matrices

fn svd_thin<L: Layout>( &self, a: &mut Slice<T, (D, D), L>, ) -> Result<SVDDecomp<T, Self::SingularValue, D>, SVDError>

Compute thin SVD with new allocated matrices

fn svd_s<L: Layout>( &self, a: &mut Slice<T, (D, D), L>, ) -> Result<Array<Self::SingularValue, (D,)>, SVDError>

Compute only singular values with new allocated matrix

fn svd_write<L: Layout, Ls: Layout, Lu: Layout, Lvt: Layout>( &self, a: &mut Slice<T, (D, D), L>, s: &mut Slice<Self::SingularValue, (D,), Ls>, u: &mut Slice<T, (D, D), Lu>, vt: &mut Slice<T, (D, D), Lvt>, ) -> Result<(), SVDError>

Compute full SVD, overwriting existing matrices

fn svd_write_s<L: Layout, Ls: Layout>( &self, a: &mut Slice<T, (D, D), L>, s: &mut Slice<Self::SingularValue, (D,), Ls>, ) -> Result<(), SVDError>

Compute only singular values, overwriting existing matrix

type SingularValue = T

Scalar type used for singular values.

impl<T, D: Dim> Solve<T, D> for Faer

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

fn solve<R: Dim, La: Layout, Lb: Layout>( &self, a: &mut Slice<T, (D, D), La>, b: &Slice<T, (D, R), Lb>, ) -> Result<Array<T, (D, R)>, SolveError>

Solves linear system AX = B with new allocated solution matrix.

fn solve_write<R: Dim, La: Layout, Lb: Layout>( &self, a: &mut Slice<T, (D, D), La>, b: &mut Slice<T, (D, R), Lb>, ) -> Result<(), SolveError>

Solves linear system AX = B, overwriting B with the solution X.

impl<T, D: Dim> VecOps<T, D> for Faer

where T: FaerVectorScalar + Zero + Copy,

type Real = <T as ComplexFloat>::Real

Real scalar type used for norm results and real rotation coefficients.

fn add_to_scaled<Lx: Layout, Ly: Layout>( &self, _alpha: T, _x: &Slice<T, (D,), Lx>, _y: &mut Slice<T, (D,), Ly>, )

Accumulate a scaled vector: y := α·x + y

fn dot<Lx: Layout, Ly: Layout>( &self, x: &Slice<T, (D,), Lx>, y: &Slice<T, (D,), Ly>, ) -> T

Dot product: ∑xᵢyᵢ

fn dotc<Lx: Layout, Ly: Layout>( &self, x: &Slice<T, (D,), Lx>, y: &Slice<T, (D,), Ly>, ) -> T

Conjugated dot product: ∑conj(xᵢ) * yᵢ (BLAS convention)

fn norm2<Lx: Layout>(&self, x: &Slice<T, (D,), Lx>) -> Self::Real

L2 norm: √(∑|xᵢ|²)

fn norm1<Lx: Layout>(&self, x: &Slice<T, (D,), Lx>) -> Self::Real

L1 norm (Manhattan) for complex numbers: ∑(|re(xᵢ)| + |im(xᵢ)|). For real numbers this reduces to ∑|xᵢ|.

fn rot<Lx: Layout, Ly: Layout>( &self, _x: &mut Slice<T, (D,), Lx>, _y: &mut Slice<T, (D,), Ly>, _c: Self::Real, _s: T, )

Givens rotation