NOTE: rapl requires Nightly and is strictly intended for non-production purposes only. rapl utilizes certain unstable features that may result in unexpected behavior, and is not optimized for performance.
rapl is an experimental numerical computing Rust that provides an simple way of working with N-dimensional array, along with a wide range of mathematical functions to manipulate them. It takes inspiration from NumPy and APL, with the primary aim of achieving maximum ergonomic and user-friendliness while maintaining generality. Notably, it offers automatic Rank Polymorphic broadcasting between arrays of varying shapes and scalars as a built-in feature.
```Rust
use rapl::*; fn main() { let a = Ndarr::from([1, 2, 3]); let b = Ndarr::from([[1, 2, 3], [4, 5, 6], [7, 8, 9]]); let r = a + b - 1; assert_eq!(r, Ndarr::from([[1, 3, 5], [4, 6, 8], [7, 9, 11]])); } ```
There are multiple handy ways of initializing N-dimensional arrays (or Ndarr).
- From Native Rust arrays to Ndarr.
Rust
let a = Ndarr::from(["a","b","c"]);
let b = Ndarr::from([[1,2],[3,4]]);
- From ranges.
Rust
let a = Ndarr::from(1..7).reshape(&[2,3])
- From &str
Rust
let chars = Ndarr::from("Hello rapl!"); //Ndarr<char,1>
- Others:
Rust
let ones: Ndarr<f32, 2> = Ndarr::ones(&[4,4]);
let zeros : Ndarr<i32, 3>= Ndarr::zeros(&[2,3,4]);
let letter_a = Ndarr::fill("a", &[5]);
let fold = Ndarr::new(data: &[0, 1, 2, 3], shape: [2, 2]).expect("Error initializing");
Rust
let ones: Ndarr<i32, 2> = Ndarr::ones(&[4,4]);
let twos = &ones + 1;
let sixes = &twos * 3;
Ndarrs,
```Rust
let a = Ndarr::from([[1,2],[3,4]]);
let b = Ndarr::from([[1,2],[-3,-4]]);asserteq!(a + b, Ndarr::from([[2,4],[0,0]]))
Note: If the shapes are not equal `rapl` will automatically broadcast the arrays into a compatible shape (if it exist) and perform the operation.
- Math operations including trigonometric functions
Rust
let x = Ndarr::from([-1.0 , -0.8, -0.6, -0.4, -0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0]);
let sinx = &x.sin();
let cosx = &x.sin();
let tanhx = &x.tanh();
let abs_x = x.abs();
- Map function
Rust
let a = Ndarr::from([[1,2],[3,4]]);
let mapped = a.map(|x| x**2-1);
```
Rust
let arr = Ndarr::from([[1,2,3],[4,5,6]]);
assert_eq!(arr.shape(), [2,3]);
assert_eq!(arr.clone().t().shape, [3,2]); //transpose
Rust
let a = Ndarr::from(1..7).reshape(&[2,3]).unwrap();
asserteq!(arr.sliceat(1)[0], Ndarr::from([1,3]))
- Reduce
Rust
let sumaxis = arr.clone().reduce(1, |x,y| x + y).unwrap();
asserteq!(sum_axis, Ndarr::from([6, 15])); //sum reduction
```
Rust
use rapl::*
use rapl::ops::{mat_mul};
let a = Ndarr::from(1..7).reshape(&[2,3]).unwrap();
let b = Ndarr::from(1..7).reshape(&[3,2]).unwrap();
let matmul = mat_mul(a, b))
``` - Outer Product.
```Rust let suits = Ndarr::from(["♣","♠","♥","♦"]); let ranks = Ndarr::from(["2","3","4","5","6","7","8","9","10","J","Q","K","A"]);
let addstr = |x: &str, y: &str| (x.toowned() + y);
let deck = ops::outerproduct( addstr, ranks, suits).flatten(); //All cards in a deck ```