SciRS2: Scientific Computing in Rust — All-in-One Meta-Crate

scirs2 is the all-in-one convenience meta-crate for the SciRS2 scientific computing ecosystem. It re-exports the complete set of SciRS2 sub-crates through a unified interface, so you can depend on a single crate and enable only the domains you need via Cargo feature flags.

If you prefer minimal compile times and finer dependency control, use the individual sub-crates directly (e.g., scirs2-linalg, scirs2-stats). If you want the full ecosystem available in one dependency, use this crate.

Installation

Add the meta-crate to your Cargo.toml:

[dependencies]
scirs2 = "0.3.4"

With only the sub-crates you need (recommended for production):

[dependencies]
scirs2 = { version = "0.3.4", default-features = false, features = ["linalg", "stats", "optimize"] }

For the complete ecosystem:

[dependencies]
scirs2 = { version = "0.3.4", features = ["full"] }

Or depend on individual sub-crates directly for fastest compile times:

[dependencies]
scirs2-core     = "0.3.4"
scirs2-linalg   = "0.3.4"
scirs2-stats    = "0.3.4"

Feature Flags

Each sub-crate is gated behind a feature flag of the same name. default enables the standard feature group.

Feature Groups

Individual Feature Flags

Re-exported Sub-crates

All sub-crates are accessible as top-level modules when their feature is enabled:

Quick Start Examples

Linear Algebra + Statistics

use scirs2::prelude::*;
use ndarray::array;

fn main() -> CoreResult<()> {
    // Matrix eigendecomposition (scirs2-linalg)
    let a = array![[4.0_f64, 2.0], [1.0, 3.0]];
    let eig = linalg::eigen::eig(&a)?;
    println!("Eigenvalues: {:?}", eig.eigenvalues);

    // Normal distribution and sampling (scirs2-stats)
    let normal = stats::distributions::Normal::new(0.0_f64, 1.0)?;
    let samples = normal.rvs(1000)?;
    let mean = stats::descriptive::mean(&samples.view())?;
    println!("Sample mean: {:.4}", mean);

    Ok(())
}

Optimization + Special Functions

use scirs2::{optimize, special};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Minimize the Rosenbrock function (scirs2-optimize)
    let result = optimize::unconstrained::minimize(
        |x: &[f64]| (1.0 - x[0]).powi(2) + 100.0 * (x[1] - x[0].powi(2)).powi(2),
        &[0.0, 0.0],
        "L-BFGS-B",
        None,
    )?;
    println!("Minimum at: {:?}", result.x);

    // Gamma function (scirs2-special)
    let g5 = special::gamma::gamma(5.0_f64)?;
    println!("Gamma(5) = {}", g5);  // 24.0

    Ok(())
}

Signal Processing + FFT

use scirs2::{signal, fft};
use ndarray::Array1;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let t = Array1::linspace(0.0_f64, 1.0, 1024);
    let sig = t.mapv(|ti| (2.0 * std::f64::consts::PI * 50.0 * ti).sin());

    // Butterworth lowpass filter (scirs2-signal)
    let sos = signal::filter::iirfilter(4, &[100.0], None, None, "butter", "low", 1024.0)?;
    let filtered = signal::filter::sosfilt(&sos, sig.view())?;

    // FFT of filtered signal (scirs2-fft)
    let spectrum = fft::rfft(filtered.view())?;
    println!("FFT output length: {}", spectrum.len());

    Ok(())
}

Neural Network + Autograd

use scirs2::{neural, autograd};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build a feed-forward network (scirs2-neural)
    let model = neural::Sequential::new()
        .dense(784, 256)?
        .relu()
        .dense(256, 10)?
        .softmax()?;

    // Compute gradients via automatic differentiation (scirs2-autograd)
    autograd::run(|ctx| {
        let x = ctx.placeholder("x", &[1, 784]);
        let logits = model.forward_autograd(ctx, x)?;
        let loss = autograd::losses::cross_entropy(logits, &[3])?;
        let grads = autograd::grad(&[loss], model.parameters())?;
        println!("Gradient norms computed: {}", grads.len());
        Ok(())
    })?;

    Ok(())
}

Architecture

SciRS2 follows a strict layered architecture per the SciRS2 Ecosystem Policy:

scirs2 (meta-crate, re-exports all)
├── scirs2-core          ← Only crate allowed external dependencies (OxiBLAS, OxiFFT, etc.)
├── Scientific Computing Layer
│   ├── scirs2-linalg    ← Linear algebra
│   ├── scirs2-stats     ← Statistics
│   ├── scirs2-optimize  ← Optimization
│   ├── scirs2-integrate ← Integration / ODEs
│   ├── scirs2-interpolate ← Interpolation
│   ├── scirs2-fft       ← Fourier analysis
│   ├── scirs2-special   ← Special functions
│   ├── scirs2-signal    ← Signal processing
│   ├── scirs2-sparse    ← Sparse matrices
│   └── scirs2-spatial   ← Spatial algorithms
├── Machine Learning Layer
│   ├── scirs2-cluster   ← Clustering
│   ├── scirs2-transform ← Dimensionality reduction
│   ├── scirs2-metrics   ← Evaluation metrics
│   ├── scirs2-neural    ← Neural networks
│   └── scirs2-autograd  ← Automatic differentiation
└── Application Layer
    ├── scirs2-ndimage   ← Image processing
    ├── scirs2-series    ← Time series
    ├── scirs2-graph     ← Graph algorithms
    ├── scirs2-vision    ← Computer vision
    ├── scirs2-text      ← NLP
    ├── scirs2-io        ← Data I/O
    └── scirs2-datasets  ← Datasets

Key Design Principles

• Pure Rust by Default: Zero C/Fortran dependencies. OxiBLAS replaces OpenBLAS; OxiFFT replaces FFTW. All optional C-backed features are feature-gated.
• Core-Only External Dependencies: Only scirs2-core links to external libraries. All other crates use scirs2-core abstractions.
• No unwrap(): The entire ecosystem enforces proper error propagation through Result.
• Workspace-Unified: All crates share the same version, edition, and lint configuration from the workspace root Cargo.toml.

Performance

SciRS2 v0.3.4 delivers production-grade performance:

• SIMD Acceleration: AVX2/AVX-512/NEON paths for 3-12x speedups on element-wise operations
• GPU Backends: Metal (Apple Silicon), with CUDA and ROCm in development
• Pure Rust FFT: OxiFFT backend for competitive FFT throughput without C dependencies
• Parallel Algorithms: Rayon-based parallel iterators in compute-intensive paths
• Memory-Efficient: Buddy/Slab/Compaction allocators, arena allocators for hot paths

Contributing

See CONTRIBUTING.md for contribution guidelines.

License

Apache License 2.0. See LICENSE for details.

Copyright COOLJAPAN OU (Team Kitasan)