scirs2-core

Foundation crate for the SciRS2 scientific computing ecosystem.

scirs2-core provides the essential utilities, abstractions, and optimizations shared by every SciRS2 module. It enforces the SciRS2 POLICY: only scirs2-core uses external dependencies directly; all other crates consume re-exports and abstractions from this crate.

Installation

[dependencies]
scirs2-core = "0.3.0"

With optional feature flags:

[dependencies]
scirs2-core = { version = "0.3.0", features = ["validation", "simd", "parallel", "gpu"] }

Features (v0.3.0)

Performance

• SIMD-accelerated array operations (SSE, AVX, AVX2, AVX-512, NEON) — up to 14x speedup over scalar
• Ultra-optimized SIMD with multiple accumulators, FMA, 8-way loop unrolling, software pipelining
• Work-stealing scheduler with NUMA-aware thread placement
• Parallel iterators (parallel map, reduce, scan, map-reduce)
• Async utilities: semaphore, channel, timeout, rate limiter
• Cache-oblivious B-tree and matrix multiply algorithms
• GPU memory management: pool allocator, slab allocator, buddy allocator, best-fit allocator

Data Structures

• Lock-free queue, stack, and hash map (using CAS, epoch-based reclamation)
• HAMT (Hash Array Mapped Trie) persistent functional data structure
• Persistent red-black tree (immutable update)
• Interval tree, segment tree, van Emde Boas tree
• Skip list, finger tree, B-tree variants
• String interning (global thread-safe interner)
• Task graph with topological scheduling

Memory Management

• Arena allocator (bump allocation)
• Slab allocator (fixed-size object pools)
• NUMA-aware allocator with topology detection
• Object pool with configurable capacity
• Zero-copy buffer management
• Memory-mapped array support (MemoryMappedArray)
• Chunked out-of-core array processing

Distributed Computing

• Ring allreduce (parameter averaging across nodes)
• Parameter server (key-value store with async push/pull)
• Collective operations: broadcast, scatter, gather, allgather, reduce-scatter
• Lock-free distributed data structures

Validation

• Schema-based data validation with constraints
• Config file validation (JSON/TOML/YAML compatible schemas)
• Assertion helpers for numeric arrays (check_finite, check_positive, check_shape)
• Type coercion utilities

Scientific Infrastructure

• 30+ mathematical constants, 40+ physical constants
• Generic numeric traits (Float, ScalarElem, LinalgScalar, etc.)
• Complex number support via num-complex re-exports
• Arbitrary precision arithmetic (multi-precision floats and integers)
• Interval arithmetic (verified computing)
• Extended precision accumulators (Kahan, pairwise)

ML Pipeline

• Transformer trait for data preprocessing steps
• Predictor trait for model inference
• Evaluator trait for scoring and metrics
• Pipeline struct for chaining transformers and a final predictor
• Batch inference utilities

Observability

• Structured logging (tracing-compatible)
• Metrics collector (counters, histograms, gauges)
• GPU profiler and perf-event profiler stubs
• Distributed tracing integration

Other Utilities

• Bioinformatics: sequence alignment extensions, motif finding, sequence type utilities
• Geospatial: geodesic calculations, projections, spatial indexing
• Quantum computing primitives: qubit representation, gate operations, measurement simulation
• Reactive programming primitives: observable, subject, operators
• Combinatorics utilities: permutations, combinations, partitions
• Concurrent collections: concurrent hash map, priority queue

Usage Examples

Basic validation

use scirs2_core::validation::{check_finite, check_positive};
use scirs2_core::ndarray::array;

let data = array![[1.0_f64, 2.0], [3.0, 4.0]];
check_finite(&data.view(), "input")?;
check_positive(&data.view(), "weights")?;

SIMD operations

use scirs2_core::simd_ops::{simd_add_f64, simd_dot_f64};

let a = vec![1.0_f64; 1024];
let b = vec![2.0_f64; 1024];

let sum = simd_add_f64(&a, &b);
let dot = simd_dot_f64(&a, &b);

Parallel processing

use scirs2_core::parallel_ops::{parallel_map, parallel_reduce};

let data: Vec<f64> = (0..1_000_000).map(|i| i as f64).collect();

let squares: Vec<f64> = parallel_map(&data, |&x| x * x)?;
let total: f64 = parallel_reduce(&data, 0.0, |acc, &x| acc + x)?;

Lock-free queue

use scirs2_core::concurrent::LockFreeQueue;

let queue: LockFreeQueue<i32> = LockFreeQueue::new();
queue.push(42);
let val = queue.pop(); // Some(42)

ML pipeline

use scirs2_core::ml_pipeline::{Pipeline, Transformer, Predictor};

// Build a pipeline: StandardScaler -> LinearModel
let pipeline = Pipeline::builder()
    .add_transformer(StandardScaler::new())
    .set_predictor(LinearModel::load("model.bin")?)
    .build();

let predictions = pipeline.predict(&features)?;

Feature Flags

Links

• API Documentation
• SciRS2 Repository
• SciRS2 POLICY

License

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