Crate mdarray_linalg_nalgebra 

mdarray_linalg_nalgebra

nalgebra backend for mdarray_linalg.

This crate provides the Nalgebra struct that implements the linear algebra traits defined by mdarray_linalg, delegating computations to the pure-Rust nalgebra library. Nalgebra is particularly efficient for small matrices thanks to its extensive use of compile-time dimension optimizations.

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

Scope

The Nalgebra backend 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
• Argmax — argmax, argmax_abs

Setup

Add the dependencies to your project:

cargo add mdarray mdarray-linalg mdarray-linalg-nalgebra

Example

All operations are accessed through the Nalgebra 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_nalgebra::Nalgebra;

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

let c = Nalgebra::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,
    ..
} = Nalgebra::default().eig(&mut a.clone()).expect("Eigenvalue decomposition failed");

println!("Eigenvalues: {:?}", lambda);

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

// ----- Argmax -----
let x = array![1., 5., 3., 8., 2.];
let idx = Nalgebra::default().argmax(&x).unwrap();
assert_eq!(idx, vec![3]);

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

let scalar = Nalgebra::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

Nalgebra

Nalgebra backend.