RustyNum is a high-performance numerical computation library written in Rust, created to demonstrate the potential of Rust's SIMD (Single Instruction, Multiple Data) capabilities using the nightly portable_simd feature, and serving as a fast alternative to Numpy.

• High Performance: Utilizes Rust's portable_simd for accelerated numerical operations across various hardware platforms, achieving up to 2.86x faster computations for certain operations compared to Numpy.
• Python Bindings: Seamless integration with Python, providing a familiar Numpy-like interface.
• Lightweight: Minimal dependencies (no external crates are used), ensuring a small footprint and easy deployment. Rustynum Python wheels are only 300kBytes (50x smaller than Numpy wheels).

You can install RustyNum directly from PyPI:

pip install rustynum

If you're familiar with Numpy, you'll quickly get used to RustyNum!

import numpy as np
a = np.array([1.0, 2.0, 3.0, 4.0], dtype="float32")
a = a + 2

import rustynum as rnp
b = rnp.NumArray([1.0, 2.0, 3.0, 4.0], dtype="float32")
b = b + 2

print(a.mean()) # 4.5
print(b.mean().item()) # 4.5

You can perform advanced operations such as matrix-vector and matrix-matrix multiplications:

# matrix-vector dot product
import numpy as np

a = np.random.rand(4 * 4).astype(np.float32)
b = np.random.rand(4).astype(np.float32)

result_numpy = np.dot(a.reshape((4, 4)), b)

import rustynum as rnp

a_rnp = rnp.NumArray(a.tolist())
b_rnp = rnp.NumArray(b.tolist())

result_rust = a_rnp.reshape([4, 4]).dot(b_rnp).tolist()

print(result_numpy) # [0.8383043 1.678406  1.4153088 0.7959367]
print(result_rust) # [0.8383043 1.678406  1.4153088 0.7959367]

RustyNum offers a variety of numerical operations and data types, with more features planned for the future.

• float64
• float32

• Dot product
• Mean
• Min/Max
• Addition (+), Subtraction (-), Multiplication (*), Division (/)
• Reshape

• Matrix-vector dot product
• Matrix-matrix dot product

Planned Features:

• N-dimensional arrays
  • Useful for filters, image processing, and machine learning
• Additional operations: arange, linspace, median, argmin, argmax, sort, std, var, zeros, cumsum, interp
• Integer support
• Extended shaping and reshaping capabilities
• C++ and WASM bindings

Not Planned:

• Random number generation (use the rand crate)

RustyNum is built on four core principles:

1. No 3rd Party Dependencies: Ensuring transparency and control over the codebase.
2. Leverage Portable SIMD: Utilizing Rust's nightly SIMD feature for high-performance operations across platforms.
3. First-Class Language Bindings: Providing robust support for Python, with plans for WebAssembly and C++.
4. Numpy-like Interface: Offering a familiar and intuitive user experience for those coming from Python.

RustyNum leverages Rust's portable_simd feature to achieve significant performance improvements in numerical computations. On a MacBook Pro M1 Pro, RustyNum outperforms Numpy in several key operations. Below are benchmark results comparing RustyNum 0.1.2 with Numpy 1.24.4:

• RustyNum significantly outperforms Numpy in basic operations such as mean, min, and dot product, with speedup factors over 2x.
• For larger operations, especially matrix-vector and matrix-matrix multiplications, Numpy currently performs better, which highlights areas for potential optimization in RustyNum.

These results demonstrate RustyNum's potential for high-performance numerical computations, particularly in operations where SIMD instructions can be fully leveraged.

Run using

cargo test

cargo doc --open

Run using

cargo criterion

Don't use maturin. But only setup.py

cd bindings/python/ && python setup.py install

or

cd bindings/python/ && python setup.py bdist_wheel

Then run tests using

pytest tests

or benchmarks using

pytest benchmarks