Crate numeris 

numeris

Pure-Rust numerical algorithms library, no-std compatible. Similar in scope to SciPy, suitable for embedded targets (no heap allocation, no FPU assumptions).

Quick start

use numeris::{Matrix, Vector};

// Solve a linear system Ax = b
let a = Matrix::new([
    [2.0_f64, 1.0, -1.0],
    [-3.0, -1.0, 2.0],
    [-2.0, 1.0, 2.0],
]);
let b = Vector::from_array([8.0, -11.0, -3.0]);
let x = a.solve(&b).unwrap(); // x = [2, 3, -1]

Modules

• matrix — Fixed-size Matrix<T, M, N> with const-generic dimensions. Stack-allocated [[T; N]; M] row-major storage. Includes arithmetic, indexing, norms, block operations, and iteration. Vector<T, N> and ColumnVector<T, N> are type aliases for 1-row and 1-column matrices.

• dynmatrix — Heap-allocated DynMatrix<T> with runtime dimensions (requires alloc feature, included with std). Vec<T> row-major storage. Implements MatrixRef / MatrixMut, so all linalg free functions work automatically. DynVector<T> newtype for single-index vector access. Includes DynLu, DynCholesky, DynQr wrapper structs.

• linalg — LU (partial pivoting), Cholesky (A = LL^H), and QR (Householder) decompositions. Each provides solve(), inverse(), and det(). Free functions operate on &mut impl MatrixMut<T> for in-place use; wrapper structs offer a higher-level API. Convenience methods on both Matrix and DynMatrix: a.solve(&b), a.inverse(), a.det().

• ode — Fixed-step RK4 and 7 adaptive Runge-Kutta solvers (RKF45, RKTS54, RKV65, RKV87, RKV98, RKV98NoInterp, RKV98Efficient). PI step-size controller with dense output / interpolation. Requires ode feature.

• [optim] — Optimization: scalar root finding ([optim::brent], [optim::newton_1d]), BFGS quasi-Newton minimization ([optim::minimize_bfgs]), Gauss-Newton ([optim::least_squares_gn]) and Levenberg-Marquardt ([optim::least_squares_lm]) nonlinear least squares. Finite-difference Jacobian and gradient utilities. Requires optim feature.

• quaternion — Unit quaternion for 3D rotations. Scalar-first [w, x, y, z]. Construct from axis-angle, Euler angles, or rotation matrices. Supports Hamilton product, vector rotation, SLERP, and conversion back to matrices.

• traits — Element trait hierarchy:

  • Scalar — all matrix elements (Copy + PartialEq + Debug + Zero + One + Num)
  • FloatScalar — real floats (Scalar + Float), used by quaternions
  • LinalgScalar — real floats and complex numbers, used by decompositions and norms
  • MatrixRef / MatrixMut — generic read/write access for algorithms

Complex matrices

Enable the complex feature to use decompositions with Complex<f32> / Complex<f64>. Cholesky generalizes to Hermitian (A = LL^H), QR uses complex Householder reflections, and norms return real values. Zero overhead for real-only code paths.

Cargo features

Feature	Default	Description
std	yes	Implies alloc. Hardware FPU via system libm
alloc	via std	DynMatrix / DynVector (heap-allocated, runtime-sized)
ode	yes	ODE integration (RK4, adaptive solvers)
optim	no	Optimization (root finding, BFGS, Gauss-Newton, LM)
libm	baseline	Pure-Rust software float fallback
complex	no	Complex<f32> / Complex<f64> support via num-complex
all	no	All features: std + ode + optim + complex

Re-exports

pub use matrix::vector::ColumnVector;

pub use matrix::vector::ColumnVector3;

pub use matrix::vector::Vector;

pub use matrix::vector::Vector3;

pub use matrix::Matrix;

pub use matrix::aliases::Matrix1;

pub use matrix::aliases::Matrix2;

pub use matrix::aliases::Matrix3;

pub use matrix::aliases::Matrix4;

pub use matrix::aliases::Matrix5;

pub use matrix::aliases::Matrix6;

pub use matrix::aliases::Matrix1x2;

pub use matrix::aliases::Matrix1x3;

pub use matrix::aliases::Matrix1x4;

pub use matrix::aliases::Matrix1x5;

pub use matrix::aliases::Matrix1x6;

pub use matrix::aliases::Matrix2x1;

pub use matrix::aliases::Matrix2x3;

pub use matrix::aliases::Matrix2x4;

pub use matrix::aliases::Matrix2x5;

pub use matrix::aliases::Matrix2x6;

pub use matrix::aliases::Matrix3x1;

pub use matrix::aliases::Matrix3x2;

pub use matrix::aliases::Matrix3x4;

pub use matrix::aliases::Matrix3x5;

pub use matrix::aliases::Matrix3x6;

pub use matrix::aliases::Matrix4x1;

pub use matrix::aliases::Matrix4x2;

pub use matrix::aliases::Matrix4x3;

pub use matrix::aliases::Matrix4x5;

pub use matrix::aliases::Matrix4x6;

pub use matrix::aliases::Matrix5x1;

pub use matrix::aliases::Matrix5x2;

pub use matrix::aliases::Matrix5x3;

pub use matrix::aliases::Matrix5x4;

pub use matrix::aliases::Matrix5x6;

pub use matrix::aliases::Matrix6x1;

pub use matrix::aliases::Matrix6x2;

pub use matrix::aliases::Matrix6x3;

pub use matrix::aliases::Matrix6x4;

pub use matrix::aliases::Matrix6x5;

pub use matrix::aliases::Vector1;

pub use matrix::aliases::Vector2;

pub use matrix::aliases::Vector4;

pub use matrix::aliases::Vector5;

pub use matrix::aliases::Vector6;

pub use matrix::aliases::ColumnVector1;

pub use matrix::aliases::ColumnVector2;

pub use matrix::aliases::ColumnVector4;

pub use matrix::aliases::ColumnVector5;

pub use matrix::aliases::ColumnVector6;

pub use dynmatrix::DynMatrix;

pub use dynmatrix::DynVector;

pub use dynmatrix::DynMatrixf32;

pub use dynmatrix::DynMatrixf64;

pub use dynmatrix::DynMatrixi32;

pub use dynmatrix::DynMatrixi64;

pub use dynmatrix::DynMatrixu32;

pub use dynmatrix::DynMatrixu64;

pub use dynmatrix::DynVectorf32;

pub use dynmatrix::DynVectorf64;

pub use dynmatrix::DynVectori32;

pub use dynmatrix::DynVectori64;

pub use dynmatrix::DynVectoru32;

pub use dynmatrix::DynVectoru64;

pub use quaternion::Quaternion;

pub use traits::FloatScalar;

pub use traits::LinalgScalar;

pub use traits::MatrixMut;

pub use traits::MatrixRef;

pub use traits::Scalar;

Modules

dynmatrix

linalg

matrix

ode

ODE integration — fixed-step, adaptive, and stiff solvers.

quaternion

traits