oxiblas

Unified API for OxiBLAS - Pure Rust BLAS/LAPACK implementation

Overview

oxiblas is the meta-crate that re-exports all OxiBLAS functionality through a unified, convenient API. This is the recommended way to use OxiBLAS for most users.

Features

• Complete BLAS - Level 1, 2, 3 operations
• Extensive LAPACK - LU, QR, SVD, Cholesky, EVD, and more
• Sparse matrices - 9 formats with iterative solvers
• Tensor operations - Einstein summation, batched operations
• Extended precision - f16, f128 support
• High performance - 80-172% of OpenBLAS depending on operation
• Pure Rust - No C dependencies, easy cross-compilation

Quick Start

[dependencies]
oxiblas = "0.1"

# With all features
oxiblas = { version = "0.1", features = ["full"] }

Usage

Matrix Operations

use oxiblas::prelude::*;

// Create matrices
let a = Mat::from_rows(&[
    &[1.0, 2.0, 3.0],
    &[4.0, 5.0, 6.0],
]);

let b = Mat::from_rows(&[
    &[7.0, 8.0],
    &[9.0, 10.0],
    &[11.0, 12.0],
]);

// Matrix multiplication
let mut c = Mat::zeros(2, 2);
gemm(1.0, a.as_ref(), b.as_ref(), 0.0, c.as_mut());
// c = [[58, 64], [139, 154]]

Linear Algebra

use oxiblas::prelude::*;

let a = Mat::from_rows(&[
    &[2.0, 1.0, 1.0],
    &[4.0, 3.0, 3.0],
    &[8.0, 7.0, 9.0],
]);

// LU decomposition
let lu = Lu::compute(a.as_ref())?;
let det = lu.determinant();
let inv = lu.inverse()?;

// QR decomposition
let qr = Qr::compute(a.as_ref())?;
let q = qr.q();
let r = qr.r();

// SVD
let svd = Svd::compute(a.as_ref())?;
let singular_values = svd.singular_values();

// Solve Ax = b
let b = vec![4.0, 10.0, 24.0];
let x = lu.solve(&b)?;

Sparse Matrices

use oxiblas::prelude::*;

// Create sparse matrix
let mut coo = CooMatrix::<f64>::new(1000, 1000);
coo.push(0, 0, 4.0);
coo.push(0, 1, -1.0);
// ... add more elements

let csr = CsrMatrix::from_coo(&coo);

// Solve sparse system with GMRES
let b = vec![/*...*/];
let result = gmres(&csr, &b, 1e-10, 100, 30, None)?;

Tensor Operations

use oxiblas::prelude::*;

// Einstein summation
let c = einsum("ij,jk->ik", &a, &[m, n], Some((&b, &[n, k])))?;

// Batched matrix multiplication
let a_batch = Tensor3::from_data(data_a, batch, m, k);
let b_batch = Tensor3::from_data(data_b, batch, k, n);
let c_batch = batched_matmul(&a_batch, &b_batch)?;

Module Structure

The oxiblas crate re-exports from these sub-crates:

Prelude

The oxiblas::prelude module provides convenient imports:

use oxiblas::prelude::*;

// Now you have access to:
// - Mat, MatRef, MatMut (matrix types)
// - gemm, gemv, dot, axpy, etc. (BLAS operations)
// - Lu, Qr, Svd, Cholesky, etc. (LAPACK decompositions)
// - CsrMatrix, CooMatrix, etc. (sparse matrices)
// - gmres, cg, bicgstab, etc. (sparse solvers)

Feature Flags

Examples

# Minimal (dense matrices only)
oxiblas = "0.1"

# With parallelization
oxiblas = { version = "0.1", features = ["parallel"] }

# With extended precision
oxiblas = { version = "0.1", features = ["f16", "f128"] }

# With ndarray support
oxiblas = { version = "0.1", features = ["ndarray"] }

# All features
oxiblas = { version = "0.1", features = ["full"] }

Examples

The repository includes comprehensive examples:

# Basic BLAS operations
cargo run --example basic_blas

# LAPACK decompositions
cargo run --example lapack_decompositions

# Extended precision
cargo run --example extended_precision --features f128

# Tensor operations
cargo run --example tensor_operations

# Sparse matrices
cargo run --example sparse_matrices --features parallel

Performance

OxiBLAS provides competitive performance with industry-standard libraries:

macOS M3 (Apple Silicon)

Linux x86_64 (Intel Xeon)

Summary: OxiBLAS achieves 80-172% of OpenBLAS performance across different platforms and operations.

Documentation

• Main README - Project overview and features
• API Documentation - Complete API reference
• Examples - Usage examples
• Benchmarks README - Performance benchmarking guide

Sub-Crate Documentation

For more detailed documentation on specific components:

• oxiblas-core - Core traits and SIMD
• oxiblas-matrix - Matrix types
• oxiblas-blas - BLAS operations
• oxiblas-lapack - LAPACK decompositions
• oxiblas-sparse - Sparse matrices
• oxiblas-ndarray - ndarray integration
• oxiblas-benchmarks - Benchmarking suite

Ecosystem

OxiBLAS is part of the SciRS2 scientific computing ecosystem:

• SciRS2 - Scientific computing library
• NumRS2 - Numerical computing
• SkleaRS - Machine learning
• ToRSh - Tensor operations
• TrustformeRS - Transformers
• QuantRS2 - Quantum computing framework
• OxiRS - Semantic Web platform

Requirements

• Rust: 1.85+ (Edition 2024)
• No external C dependencies
• Supported platforms: x86_64, AArch64 (Linux, macOS, Windows)

License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

Citation

If you use OxiBLAS in your research, please cite:

@software{oxiblas2025,
  author = {OxiBLAS Contributors},
  title = {OxiBLAS: Pure Rust BLAS/LAPACK Implementation},
  year = {2025},
  url = {https://github.com/cool-japan/oxiblas}
}