{"id":28050656,"url":"https://github.com/cool-japan/numrs","last_synced_at":"2026-04-01T21:33:51.917Z","repository":{"id":288380974,"uuid":"967893225","full_name":"cool-japan/numrs","owner":"cool-japan","description":"NumRS2: High-Performance Numerical Computing in Rust","archived":false,"fork":false,"pushed_at":"2026-03-21T10:21:26.000Z","size":3174,"stargazers_count":39,"open_issues_count":1,"forks_count":5,"subscribers_count":3,"default_branch":"master","last_synced_at":"2026-03-21T14:46:00.753Z","etag":null,"topics":["ai","artificial-intelligence","machine-learning","ml","numpy","rust","rust-lang","science"],"latest_commit_sha":null,"homepage":"https://github.com/cool-japan/numrs","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/cool-japan.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-04-17T07:01:15.000Z","updated_at":"2026-03-21T08:52:42.000Z","dependencies_parsed_at":"2025-04-17T20:24:45.413Z","dependency_job_id":"f555884a-e921-4d2b-9568-91fe84e18dab","html_url":"https://github.com/cool-japan/numrs","commit_stats":null,"previous_names":["cool-japan/numrs"],"tags_count":13,"template":false,"template_full_name":null,"purl":"pkg:github/cool-japan/numrs","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Fnumrs","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Fnumrs/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Fnumrs/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Fnumrs/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/cool-japan","download_url":"https://codeload.github.com/cool-japan/numrs/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Fnumrs/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31292376,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-01T21:15:39.731Z","status":"ssl_error","status_checked_at":"2026-04-01T21:15:34.046Z","response_time":53,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","artificial-intelligence","machine-learning","ml","numpy","rust","rust-lang","science"],"created_at":"2025-05-12T00:37:57.994Z","updated_at":"2026-04-01T21:33:51.906Z","avatar_url":"https://github.com/cool-japan.png","language":"Rust","funding_links":["https://github.com/sponsors/cool-japan"],"categories":[],"sub_categories":[],"readme":"# NumRS2 - High-Performance Numerical Computing for Rust\n\n[![Build Status](https://github.com/cool-japan/numrs/workflows/CI/badge.svg)](https://github.com/cool-japan/numrs/actions)\n[![Crates.io](https://img.shields.io/crates/v/numrs2.svg)](https://crates.io/crates/numrs2)\n[![Documentation](https://docs.rs/numrs2/badge.svg)](https://docs.rs/numrs2)\n[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)\n\nNumRS2 is a high-performance numerical computing library for Rust, designed as a Rust-native alternative to NumPy. It provides N-dimensional arrays, linear algebra operations, and comprehensive mathematical functions with a focus on performance, safety, and ease of use.\n\n\u003e **Version 0.3.2** - Patch release (2026-03-27): Minor improvements and updates. Features 128+ SIMD-vectorized functions (AVX2, AVX512, ARM NEON), 5,058+ tests passing, 222,000+ lines of production Rust code, 5,899+ public API items, zero stubs, built on pure Rust SciRS2 ecosystem.\n\n## ✨ Architecture Highlights\n\n### 🏗️ Enhanced Design\n- **Trait-based architecture** for extensibility and generic programming\n- **Hierarchical error system** with rich context and recovery suggestions  \n- **Memory management** with pluggable allocators (Arena, Pool, NUMA-aware)\n- **Comprehensive documentation** with migration guides and best practices\n\n### 🔧 Core Features\n- **N-dimensional arrays** with efficient memory layout and broadcasting\n- **Advanced linear algebra** with BLAS/LAPACK integration and matrix decompositions\n- **SIMD optimization** with automatic vectorization and CPU feature detection\n- **Thread safety** with parallel processing support via Rayon\n- **Python interoperability** for easy migration from NumPy\n\n## Main Features\n\n- **N-dimensional Array**: Core `Array` type with efficient memory layout and NumPy-compatible broadcasting\n- **Advanced Linear Algebra**:\n  - Matrix operations, decompositions, solvers through BLAS/LAPACK integration\n  - Sparse matrices (COO, CSR, CSC, DIA formats) with format conversions\n  - Iterative solvers (CG, GMRES, BiCGSTAB) for large systems\n  - Randomized algorithms (randomized SVD, random projections, range finders)\n- **Numerical Optimization**: BFGS, L-BFGS, Trust Region, Nelder-Mead, Levenberg-Marquardt, constrained optimization\n- **Root-Finding**: Bisection, Brent, Newton-Raphson, Secant, Halley, fixed-point iteration\n- **Numerical Differentiation**: Gradient, Jacobian, Hessian with Richardson extrapolation\n- **Automatic Differentiation**: Forward and reverse mode AD with higher-order derivatives\n- **Data Interoperability**:\n  - Apache Arrow integration for zero-copy data exchange\n  - Feather format support for fast columnar storage\n  - IPC streaming for inter-process communication\n  - Python bindings via PyO3 for NumPy compatibility\n- **Expression Templates**: Lazy evaluation and operation fusion for performance\n- **Advanced Indexing**: Fancy indexing, boolean masking, and conditional selection\n- **Polynomial Functions**: Interpolation, evaluation, and arithmetic operations\n- **Fast Fourier Transform**: Optimized FFT implementation with 1D/2D transforms, real FFT specialization, frequency shifting, and various windowing functions\n- **SIMD Acceleration**: Enhanced vectorized operations via SciRS2-Core with AVX2/AVX512/NEON support\n- **Parallel Computing**: Advanced multi-threaded execution with adaptive chunking and work-stealing\n- **GPU Acceleration**: Optional GPU-accelerated array operations using WGPU\n- **Mathematical Functions**: Comprehensive set of element-wise mathematical operations\n- **Statistical Analysis**: Descriptive statistics, probability distributions, and more\n- **Random Number Generation**: Modern interface for various distributions with fast generation and NumPy-compatible API\n- **SciRS2 Integration**: Integration with SciRS2 for advanced statistical distributions and scientific computing functionality\n- **Fully Type-Safe**: Leverage Rust's type system for compile-time guarantees\n\n## Optional Features\n\nNumRS2 includes several optional features that can be enabled in your `Cargo.toml`:\n\n- **matrix_decomp** (enabled by default): Matrix decomposition functions (SVD, QR, LU, etc.)\n- **lapack**: Enable LAPACK-dependent linear algebra operations (eigenvalues, matrix decompositions)\n- **validation**: Additional runtime validation checks for array operations\n- **arrow**: Apache Arrow integration for zero-copy data exchange with Python/Polars/DataFusion\n- **python**: Python bindings via PyO3 for NumPy interoperability\n- **gpu**: GPU acceleration for array operations using WGPU\n\nTo enable a feature:\n\n```toml\n[dependencies]\nnumrs2 = { version = \"0.3.2\", features = [\"arrow\"] }\n```\n\nOr, when building:\n\n```bash\ncargo build --features scirs\n```\n\n### 🚀 Performance Optimizations\n\nNumRS2 leverages SciRS2-Core (v0.4.0) for cutting-edge performance optimizations:\n\n- **Unified SIMD Operations**: All SIMD code goes through SciRS2-Core's SimdUnifiedOps trait\n- **Adaptive Algorithm Selection**: AutoOptimizer automatically chooses between scalar, SIMD, or GPU implementations\n- **Platform Detection**: Automatic detection of AVX2, AVX512, NEON, and GPU capabilities\n- **Parallel Operations**: Optimized parallel processing with intelligent work distribution\n- **Memory-Efficient Chunking**: Process large datasets without memory bottlenecks\n\nSee the [optimization example](examples/scirs2_optimization.rs) for usage details.\n\n### SciRS2 Integration\n\nThe SciRS2 integration provides additional advanced statistical distributions:\n\n- **Noncentral Chi-square**: Extends the standard chi-square with a noncentrality parameter\n- **Noncentral F**: Extends the standard F distribution with a noncentrality parameter\n- **Von Mises**: Circular normal distribution for directional statistics\n- **Maxwell-Boltzmann**: Used for modeling particle velocities in physics\n- **Truncated Normal**: Normal distribution with bounded support\n- **Multivariate Normal with Rotation**: Allows rotation of the coordinate system\n\nFor examples, see [scirs_integration_example.rs](examples/scirs_integration_example.rs)\n\n### GPU Acceleration\n\nThe GPU acceleration feature provides:\n\n- GPU-accelerated array operations for significant performance improvements\n- Seamless CPU/GPU interoperability with the same API\n- Support for various operations: arithmetic, matrix multiplication, element-wise functions, etc.\n- WGPU backend for cross-platform GPU support (Vulkan, Metal, DX12, WebGPU)\n\nFor examples, see [gpu_example.rs](examples/gpu_example.rs)\n\n### 🎯 Key Features\n\n**Numerical Optimization (scipy.optimize equivalent)**\n- BFGS \u0026 L-BFGS: Quasi-Newton methods for large-scale optimization\n- Trust Region: Robust optimization with dogleg path\n- Nelder-Mead: Derivative-free simplex method\n- Levenberg-Marquardt: Nonlinear least squares\n- Constrained optimization: Projected gradient, penalty methods\n\n**Root-Finding Algorithms (scipy.optimize.root_scalar)**\n- Bracketing methods: Bisection, Brent, Ridder, Illinois\n- Open methods: Newton-Raphson, Secant, Halley\n- Fixed-point iteration for implicit equations\n\n**Numerical Differentiation**\n- Gradient, Jacobian, and Hessian computation\n- Forward, backward, central differences\n- Richardson extrapolation for high accuracy\n\n**SIMD Optimization Infrastructure**\n- 86 AVX2-optimized functions with automatic threshold-based dispatch\n- 4-way loop unrolling and FMA (fused multiply-add) instructions\n- ARM NEON support with 42 vectorized f64 operations\n- Support for both f32 and f64 numeric types\n\n**Production-Ready Features**\n- Complete multi-array NPZ support for NumPy compatibility\n- Zero clippy warnings and zero critical errors\n- 5,058+ comprehensive tests\n- Enhanced scheduler with critical deadlock fix (1,143x speedup)\n- 222,000+ lines of production Rust code (671 Rust files)\n- 5,899+ public API items; zero unimplemented stubs\n\n**Enhanced Modules**\n- Linear algebra: Extended iterative solvers (CG, GMRES, BiCGSTAB, FGMRES, MINRES)\n- Mathematical functions: 1,187 lines of enhanced operations\n- Statistics: 1,397 lines of enhanced distributions and testing\n- Polynomial operations: Complete NumPy polynomial compatibility\n- Special functions: Spherical harmonics, Jacobi elliptic, Lambert W, and more\n\n## Example\n\n```rust\nuse numrs2::prelude::*;\n\nfn main() -\u003e Result\u003c()\u003e {\n    // Create arrays\n    let a = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0]).reshape(\u0026[2, 2]);\n    let b = Array::from_vec(vec![5.0, 6.0, 7.0, 8.0]).reshape(\u0026[2, 2]);\n    \n    // Basic operations with broadcasting\n    let c = a.add(\u0026b);\n    let d = a.multiply_broadcast(\u0026b)?;\n    \n    // Matrix multiplication\n    let e = a.matmul(\u0026b)?;\n    println!(\"a @ b = {}\", e);\n    \n    // Linear algebra operations\n    let (u, s, vt) = a.svd_compute()?;\n    println!(\"SVD components: U = {}, S = {}, Vt = {}\", u, s, vt);\n    \n    // Eigenvalues and eigenvectors\n    let symmetric = Array::from_vec(vec![2.0, 1.0, 1.0, 2.0]).reshape(\u0026[2, 2]);\n    let (eigenvalues, eigenvectors) = symmetric.eigh(\"lower\")?;\n    println!(\"Eigenvalues: {}\", eigenvalues);\n    \n    // Polynomial interpolation\n    let x = Array::linspace(0.0, 1.0, 5)?;\n    let y = Array::from_vec(vec![0.0, 0.1, 0.4, 0.9, 1.6]);\n    let poly = PolynomialInterpolation::lagrange(\u0026x, \u0026y)?;\n    println!(\"Interpolated value at 0.5: {}\", poly.evaluate(0.5));\n    \n    // FFT operations\n    let signal = Array::from_vec(vec![1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);\n    // Window the signal before transforming\n    let windowed_signal = signal.apply_window(\"hann\")?;\n    // Compute FFT\n    let spectrum = windowed_signal.fft()?;\n    // Shift frequencies to center the spectrum\n    let centered = spectrum.fftshift_complex()?;\n    println!(\"FFT magnitude: {}\", spectrum.power_spectrum()?);\n    \n    // Statistical operations\n    let data = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0]);\n    println!(\"mean = {}\", data.mean()?);\n    println!(\"std = {}\", data.std()?);\n    \n    // Sparse array operations\n    let mut sparse = SparseArray::new(\u0026[10, 10]);\n    sparse.set(\u0026[0, 0], 1.0)?;\n    sparse.set(\u0026[5, 5], 2.0)?;\n    println!(\"Density: {}\", sparse.density());\n    \n    // SIMD-accelerated operations\n    let result = simd_ops::apply_simd(\u0026data, |x| x * x + 2.0 * x + 1.0)?;\n    println!(\"SIMD result: {}\", result);\n\n    // Random number generation\n    let rng = random::default_rng();\n    let uniform = rng.random::\u003cf64\u003e(\u0026[3])?;\n    let normal = rng.normal(0.0, 1.0, \u0026[3])?;\n    println!(\"Random uniform [0,1): {}\", uniform);\n    println!(\"Random normal: {}\", normal);\n\n    Ok(())\n}\n```\n\n## Performance\n\nNumRS is designed with performance as a primary goal:\n\n- **Rust's Zero-Cost Abstractions**: Compile-time optimization without runtime overhead\n- **BLAS/LAPACK Integration**: Industry-standard libraries for linear algebra operations\n- **SIMD Vectorization**: Parallel processing at the CPU instruction level with automatic CPU feature detection\n- **Memory Layout Optimization**: Cache-friendly data structures and memory alignment\n- **Data Placement Strategies**: Optimized memory placement for better cache utilization\n- **Adaptive Parallelization**: Smart thresholds to determine when parallel execution is beneficial\n- **Scheduling Optimization**: Intelligent selection of work scheduling strategies based on workload\n- **Fine-grained Parallelism**: Advanced workload partitioning for better load balancing\n- **Modern Random Generation**: Advanced thread-safe RNG with PCG64 algorithm for high-quality randomness\n\n## Expression Templates\n\nNumRS2 provides a powerful expression templates system for lazy evaluation and performance optimization:\n\n### SharedArray - Reference-Counted Arrays\n\n```rust\nuse numrs2::prelude::*;\n\n// Create shared arrays with natural operator syntax\nlet a: SharedArray\u003cf64\u003e = SharedArray::from_vec(vec![1.0, 2.0, 3.0, 4.0]);\nlet b: SharedArray\u003cf64\u003e = SharedArray::from_vec(vec![10.0, 20.0, 30.0, 40.0]);\n\n// Cheap cloning (O(1) - just increments reference count)\nlet a_clone = a.clone();\n\n// Natural operator overloading\nlet sum = a.clone() + b.clone();         // [11.0, 22.0, 33.0, 44.0]\nlet product = a.clone() * b.clone();     // [10.0, 40.0, 90.0, 160.0]\nlet scaled = a.clone() * 2.0;            // [2.0, 4.0, 6.0, 8.0]\nlet result = (a.clone() + b.clone()) * 2.0 - 5.0;  // Chained operations\n```\n\n### SharedExpr - Lifetime-Free Lazy Evaluation\n\n```rust\nuse numrs2::expr::{SharedExpr, SharedExprBuilder};\n\n// Build expressions lazily - no computation until eval()\nlet c: SharedArray\u003cf64\u003e = SharedArray::from_vec(vec![1.0, 2.0, 3.0, 4.0]);\nlet expr = SharedExprBuilder::from_shared_array(c);\nlet squared = expr.map(|x| x * x);   // Expression built, not evaluated\nlet result = squared.eval();         // [1.0, 4.0, 9.0, 16.0] - evaluated here\n```\n\n### Common Subexpression Elimination (CSE)\n\n```rust\nuse numrs2::expr::{CachedExpr, ExprCache};\n\n// Automatic caching of repeated computations\nlet cache: ExprCache\u003cf64\u003e = ExprCache::new();\nlet cached_expr = CachedExpr::new(sum_expr.into_expr(), cache.clone());\n\nlet result1 = cached_expr.eval();  // Computes and caches\nlet result2 = cached_expr.eval();  // Uses cached result\n```\n\n### Memory Access Pattern Optimization\n\n```rust\nuse numrs2::memory_optimize::access_patterns::*;\n\n// Detect memory layout for optimization\nlet layout = detect_layout(\u0026[100, 100], \u0026[100, 1]);  // CContiguous\n\n// Get optimization hints for array shapes\nlet hints = OptimizationHints::default_for::\u003cf64\u003e(10000);\nprintln!(\"Block size: {}\", hints.block_size);\nprintln!(\"Use parallel: {}\", hints.use_parallel);\n\n// Cache-aware iteration for large arrays\nlet block_iter = BlockedIterator::new(10000, 64);\nfor block in block_iter {\n    // Process block.start..block.end with cache efficiency\n}\n\n// Cache-aware operations\ncache_aware_transform(\u0026src, \u0026mut dst, |x| x * 2.0);\ncache_aware_binary_op(\u0026a, \u0026b, \u0026mut result, |x, y| x + y);\n```\n\nSee the [expression templates example](examples/expression_templates_example.rs) for a comprehensive demonstration.\n\n## Installation\n\nAdd this to your `Cargo.toml`:\n\n```toml\n[dependencies]\nnumrs2 = \"0.3.2\"\n```\n\nFor BLAS/LAPACK support, ensure you have the necessary system libraries:\n\n**Note:** NumRS2 uses OxiBLAS, a pure Rust BLAS/LAPACK implementation with no C dependencies. You do NOT need to install system BLAS/LAPACK libraries.\n\nTo use LAPACK functionality (pure Rust via OxiBLAS):\n```bash\ncargo build --features lapack\ncargo test --features lapack\n```\n\nOxiBLAS provides:\n- Pure Rust implementation with SIMD optimizations (AVX2/NEON)\n- No external C dependencies required\n- 80-172% of OpenBLAS performance (competitive or faster on Apple M3)\n- Complete BLAS Level 1/2/3 and LAPACK operations\n\n## Implementation Details\n\nNumRS2 is built on top of the SciRS2 ecosystem and pure Rust libraries:\n\n- **SciRS2 ecosystem** (scirs2-core, scirs2-linalg, scirs2-stats, etc. v0.4.0): Provides the foundation for n-dimensional arrays, linear algebra, statistics, survival analysis, causal inference, bioinformatics, and combinatorics\n- **OxiBLAS** (pure Rust BLAS/LAPACK): Powers high-performance linear algebra routines with no C dependencies\n- **Oxicode**: Pure Rust serialization for data persistence\n- **Rayon**: Enables parallel computation capabilities\n- **num-traits / num-complex**: Provides generic numeric traits and complex number support for numerical operations\n\n## Features\n\nNumRS2 provides a comprehensive suite of numerical computing capabilities:\n\n### Core Functionality\n- **N-dimensional arrays** with efficient memory layout and broadcasting\n- **Linear algebra operations** with BLAS/LAPACK integration\n- **Matrix decompositions** (SVD, QR, Cholesky, LU, Schur, COD)\n- **Eigenvalue and eigenvector computation**\n- **Mathematical functions** with numerical stability optimizations\n\n### Performance Optimizations\n- **SIMD acceleration** with automatic CPU feature detection\n- **Parallel processing** with adaptive scheduling and load balancing  \n- **Memory optimization** with cache-friendly data structures\n- **Vectorized operations** for improved computational efficiency\n\n### Advanced Features\n- **Fast Fourier Transform** with 1D/2D transforms and windowing functions\n- **Polynomial operations** and interpolation methods\n- **Sparse matrix support** for memory-efficient computations\n- **Random number generation** with multiple distribution support\n- **Statistical analysis** functions and descriptive statistics\n\n### Integration \u0026 Interoperability\n- **GPU acceleration** support via WGPU (optional)\n- **SciRS2 integration** for advanced statistical distributions (optional)\n- **Memory-mapped arrays** for large dataset handling\n- **Serialization support** for data persistence\n\n## 📖 Documentation\n\n### 📚 Comprehensive Guides\n- **[Architecture Guide](docs/ARCHITECTURE.md)** - System design and core concepts\n- **[Migration Guide](docs/MIGRATION_GUIDE.md)** - Upgrading from previous versions\n- **[Trait System Guide](docs/TRAIT_GUIDE.md)** - Generic programming with NumRS2\n- **[Error Handling Guide](docs/ERROR_HANDLING.md)** - Robust error management\n- **[Memory Management Guide](docs/MEMORY_MANAGEMENT.md)** - Optimizing memory usage\n\n### 🔗 Additional Resources\n- [Official API Documentation](https://docs.rs/numrs2) - Complete API reference\n- [Getting Started Guide](GETTING_STARTED.md) - Essential information for beginners\n- [Installation Guide](INSTALL.md) - Detailed installation instructions\n- [User Guide](GUIDE.md) - Comprehensive guide to all NumRS features\n- [NumPy Migration Guide](NUMPY_MIGRATION.md) - Guide for NumPy users transitioning to NumRS2\n- [Implementation Status](IMPLEMENTATION_STATUS.md) - Current status and next steps\n- [Contributing Guide](CONTRIBUTING.md) - How to contribute to NumRS2\n\nModule-specific documentation:\n  - [Random Module Guide](examples/README_RANDOM.md) - Random number generation\n  - [Statistics Module Guide](examples/README_STATISTICS.md) - Statistical functions\n  - [Linear Algebra Guide](examples/README_LINALG.md) - Linear algebra operations\n  - [Polynomial Guide](examples/README_POLYNOMIAL.md) - Polynomial operations\n  - [FFT Guide](examples/README_FFT.md) - Fast Fourier Transform\n\nTesting Documentation:\n  - [Testing Guide](tests/README.md) - Guide for NumRS testing approach\n  - Property-based testing for mathematical operations\n    - Property tests for linear algebra operations\n    - Property tests for special functions\n    - Statistical validation of random distributions\n  - Reference testing\n    - Reference tests for random distributions\n    - Reference tests for linear algebra operations\n    - Reference tests for special functions\n  - Benchmarking\n    - Linear algebra benchmarks\n    - Special functions benchmarks\n\n## Examples\n\nCheck out the `examples/` directory for more usage examples:\n\n- `basic_usage.rs`: Core array operations and manipulations\n- `linalg_example.rs`: Linear algebra operations and solvers\n- `simd_example.rs`: SIMD-accelerated computations\n- `memory_optimize_example.rs`: Memory layout optimization for cache efficiency\n- `parallel_optimize_example.rs`: Parallelization optimization techniques\n- `random_distributions_example.rs`: Comprehensive examples of random number generation\n- See the [examples README](examples/README.md) for more details\n\n## Development\n\nNumRS is in active development. See [TODO.md](TODO.md) for upcoming features and development roadmap.\n\n## Testing\n\nNumRS requires the `approx` crate for testing. Tests can be run after installation with:\n\n```bash\ncargo test\n```\n\nFor running property-based and statistical tests for the random module:\n\n```bash\ncargo test --test test_random_statistical\ncargo test --test test_random_properties\ncargo test --test test_random_advanced\n```\n\n## Contributing\n\nNumRS2 is a community-driven project, and we welcome contributions from everyone. There are many ways to contribute:\n\n- **Code**: Implement new features or fix bugs\n- **Documentation**: Improve guides, docstrings, or examples\n- **Testing**: Write tests or improve existing ones\n- **Reviewing**: Review pull requests from other contributors\n- **Performance**: Identify bottlenecks or implement optimizations\n- **Examples**: Create example code showing library usage\n\nIf you're interested in contributing, please read our [Contributing Guide](CONTRIBUTING.md) for detailed instructions on how to get started.\n\nFor significant changes, please open an issue to discuss your ideas first.\n\n## Sponsorship\n\nNumRS2 is developed and maintained by **COOLJAPAN OU (Team Kitasan)**.\n\nIf you find NumRS2 useful, please consider sponsoring the project to support continued development of the Pure Rust ecosystem.\n\n[![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-red?logo=github)](https://github.com/sponsors/cool-japan)\n\n**[https://github.com/sponsors/cool-japan](https://github.com/sponsors/cool-japan)**\n\nYour sponsorship helps us:\n- Maintain and improve the COOLJAPAN ecosystem\n- Keep the entire ecosystem (OxiBLAS, OxiFFT, SciRS2, etc.) 100% Pure Rust\n- Provide long-term support and security updates\n\n## License\n\nThis project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcool-japan%2Fnumrs","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcool-japan%2Fnumrs","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcool-japan%2Fnumrs/lists"}