Crate mdarray_linalg_faer 

mdarray_linalg_faer

faer backend for mdarray_linalg.

This crate provides the Faer struct that implements the linear algebra traits defined by mdarray_linalg, delegating computations to the pure-Rust faer library. Unlike the BLAS/LAPACK backends, faer does not require a system BLAS installation.

Backend implementation modules are private. Use Faer together with the operation traits from mdarray_linalg::prelude::*.

Scope

The Faer backend is the most complete backend and covers:

• Level 1 — vector operations: dot, dotc, norm2, norm1, add_to_scaled
• Level 2 — matrix-vector & outer product: matvec, outer
• Level 3 — matrix multiplication: matmul
• Tensor contraction — contract_all, contract_n, contract_pairs, contract
• Eigenvalue decomposition — eig, eig_full, eig_values, eigh
• Schur decomposition — schur, schur_complex
• SVD — svd, svd_thin, svd_s
• LU decomposition — lu, det, inv
• Cholesky decomposition — cholesky
• QR decomposition — qr
• Linear system solving — solve

Setup

Add the dependencies to your project:

cargo add mdarray mdarray-linalg mdarray-linalg-faer

Note: No BLAS/LAPACK linking is required — faer is a pure-Rust crate.

Example

All operations are accessed through the Faer backend via the traits from mdarray_linalg::prelude::*:

use mdarray::array;
use mdarray_linalg::prelude::*;
use mdarray_linalg::eig::EigDecomp;
use mdarray_linalg::svd::SVDDecomp;
use mdarray_linalg_faer::Faer;

// ----- Matrix multiplication (Level 3) -----
let a = array![[1., 2.], [3., 4.]];
let b = array![[5., 6.], [7., 8.]];

let c = Faer::default().matmul(&a, &b).eval();
assert_eq!(c, array![[19., 22.], [43., 50.]]);

// ----- Eigenvalue decomposition -----
let mut a = array![[1., 2.], [3., 4.]];
let EigDecomp {
    eigenvalues: lambda,
    right_eigenvectors,
    ..
} = Faer::default().eig(&mut a.clone()).expect("Eigenvalue decomposition failed");

println!("Eigenvalues: {:?}", lambda);
if let Some(v) = right_eigenvectors {
    println!("Right eigenvectors: {:?}", v);
}

// ----- SVD -----
let mut a = array![[1., 2.], [3., 4.]];
let SVDDecomp { s, u, vt } = Faer::default().svd_thin(&mut a).expect("SVD failed");
println!("Singular values: {:?}", s);

// ----- QR decomposition -----
let mut a = array![[12., -51., 4.], [6., 167., -68.], [-4., 24., -41.]];
let (q, r) = Faer::default().qr(&mut a);
println!("Q: {:?}", q);
println!("R: {:?}", r);

// ----- Tensor contraction -----
let t1 = array![[1., 2.], [3., 4.]].into_dyn();
let t2 = array![[5., 6.], [7., 8.]].into_dyn();

let scalar = Faer::default().contract_all(&t1, &t2);
assert_eq!(scalar, 70.0);

Note: Decomposition routines (eig, svd, lu, etc.) destroy the input matrix. Always pass a clone if you need the original data.

Currently supported types

f32, f64, Complex<f32>, Complex<f64>.

Structs

Faer

Faer backend.