🤖 switch to maturin for build & release (#4)

* 🤖 switch to maturin for build & release

* 🕳️ add empty _rust subfolder

* 🧹

* 🧹

* 💫 head/tail recursion for build macro

* 🙈 fix release nb

* 🧹

* ♻️ pass minmax_ratio in Python bindings

* 🙈 addminmax_ratio to minmaxlttb

* 😬 further disable mypy checks

* 🧹 formatting

* 🙈 fix benches

* :clown: format subpackage

Author: jvdd

.github/workflows/ci-tsdownsample.yml

@@ -21,8 +21,6 @@ jobs:
       - uses: actions/setup-python@v4
         with:
           python-version: '3.10'
-      - run: pip install -r tests/requirements-linting.txt
-
       - name: Install Rust toolchain
         uses: actions-rs/toolchain@v1
         with:
@@ -36,6 +34,7 @@ jobs:
       - name: Cache rust
         uses: Swatinem/rust-cache@v2
 
+      - run: pip install -r tests/requirements-linting.txt
       - run: pip freeze
       - run: make lint  # Lint Python & Rust
       - run: make mypy  # Type check Python

Cargo.toml

@@ -1,12 +1,16 @@
 [package]
-name = "tsdownsample_rs"
+name = "tsdownsample"  # Same name as the Python package
 version = "0.1.0"
 edition = "2021"
 authors = ["Jeroen Van Der Donckt"]
 description = "Python bindings for time series downsampling algorithms"
 repository = "https://github.com/predict-idlab/tsdownsample"
 license = "MIT"
 
+[package.metadata.maturin]
+# Import the Rust library under this path
+# See: https://www.maturin.rs/project_layout.html#import-rust-as-a-submodule-of-your-project
+name = "tsdownsample._rust._tsdownsample_rs"
 
 [dependencies]
 downsample_rs = { path = "downsample_rs", features = ["half"]}
@@ -16,5 +20,5 @@ half = { version = "2.1", default-features = false }
 paste = { version = "1.0.9", default-features = false }
 
 [lib]
-name = "tsdownsample_rs"
+name = "tsdownsample"
 crate-type = ["cdylib"]

Makefile

@@ -3,7 +3,6 @@ isort = isort tsdownsample tests
 black = black tsdownsample tests
 
 install:
-	pip install -r requirements.txt
 	pip install -e .
 
 .PHONY: format
@@ -47,6 +46,7 @@ clean:
 	rm -f `find . -type f -name '*.py[co]' `
 	rm -f `find . -type f -name '*~' `
 	rm -f `find . -type f -name '.*~' `
+	rm -f `find . -type f -name '*.cpython-*' `
 	rm -rf dist
 	rm -rf build
 	rm -rf target
@@ -55,8 +55,8 @@ clean:
 	rm -rf .mypy_cache
 	rm -rf htmlcov
 	rm -rf *.egg-info
+	rm -rf .ruff*
 	rm -f .coverage
 	rm -f .coverage.*
 	rm -rf build
-	rm -f tsdownsample/*.so
-	python setup.py clean
+	rm -f tsdownsample/*.so

README.md

@@ -30,7 +30,7 @@
       <summary><i>!! 🚀 <code>f16</code> <a href="https://github.com/jvdd/argminmax">argminmax</a> is 200-300x faster than numpy</i></summary>
       In contrast with all other data types above, <code>f16</code> is *not* hardware supported (i.e., no instructions for f16) by most modern CPUs!! <br>
       🐌 Programming languages facilitate support for this datatype by either (i) upcasting to `f32` or (ii) using a software implementation. <br>
-      💡 As for argminmax, only comparisons are needed - and thus no arithmetic operations - creating a <ins>symmetrical ordinal mapping from <code>f16</code> to <code>i16</code></ins> is sufficient. This mapping allows to use the hardware supported scalar and SIMD <code>i16</code> instructions - while not producing any memory overhead 🎉 <br>
+      💡 As for argminmax, only comparisons are needed - and thus no arithmetic operations - creating a <u>symmetrical ordinal mapping from <code>f16</code> to <code>i16</code></u> is sufficient. This mapping allows to use the hardware supported scalar and SIMD <code>i16</code> instructions - while not producing any memory overhead 🎉 <br>
       <i>More details are described in <a href="https://github.com/jvdd/argminmax/pull/1">argminmax PR #1</a>.</i>
     </details>
 * **Easy to use**: simple & flexible API
@@ -47,7 +47,7 @@ pip install tsdownsample
 ## Usage
 
 ```python
-from tsdownsample import MinMaxLTTBDowsampler
+from tsdownsample import MinMaxLTTBDownsampler
 import pandas as pd; import numpy as np
 
 # Create a time series

downsample_rs/Cargo.toml

@@ -8,7 +8,7 @@ license = "MIT"
 
 [dependencies]
 ndarray = {version = "0.15.6", default-features = false, features = ["rayon"] }
-argminmax = { version = "0.2" , features = ["half"] }
+argminmax = { version = "0.2.1" , features = ["half"] }
 half = { version = "2.1", default-features = false , optional = true}
 
 [dev-dependencies]

downsample_rs/benches/bench_minmaxlttb.rs

@@ -8,6 +8,8 @@ use criterion::{black_box, Criterion};
 use dev_utils::{config, utils};
 use ndarray::Array1;
 
+const MINMAX_RATIO: usize = 30;
+
 fn minmaxlttb_f32_random_array_long_single_core(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
@@ -18,6 +20,7 @@ fn minmaxlttb_f32_random_array_long_single_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -27,6 +30,7 @@ fn minmaxlttb_f32_random_array_long_single_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -42,6 +46,7 @@ fn minmaxlttb_f32_random_array_long_multi_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -51,6 +56,7 @@ fn minmaxlttb_f32_random_array_long_multi_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -66,6 +72,7 @@ fn minmaxlttb_f32_random_array_50M_single_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -75,6 +82,7 @@ fn minmaxlttb_f32_random_array_50M_single_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -90,6 +98,7 @@ fn minmaxlttb_f32_random_array_50M_multi_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -99,6 +108,7 @@ fn minmaxlttb_f32_random_array_50M_multi_core(c: &mut Criterion) {
                 black_box(x.view()),
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -109,11 +119,21 @@ fn minmaxlttb_without_x_f32_random_array_50M_single_core(c: &mut Criterion) {
     let y = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
     c.bench_function("mmlttbnox_scal_50M_f32", |b| {
         b.iter(|| {
-            minmaxlttb_mod::minmaxlttb_scalar_without_x(black_box(y.view()), black_box(2_000))
+            minmaxlttb_mod::minmaxlttb_scalar_without_x(
+                black_box(y.view()),
+                black_box(2_000),
+                black_box(MINMAX_RATIO),
+            )
         })
     });
     c.bench_function("mmlttbnox_simd_50M_f32", |b| {
-        b.iter(|| minmaxlttb_mod::minmaxlttb_simd_without_x(black_box(y.view()), black_box(2_000)))
+        b.iter(|| {
+            minmaxlttb_mod::minmaxlttb_simd_without_x(
+                black_box(y.view()),
+                black_box(2_000),
+                black_box(MINMAX_RATIO),
+            )
+        })
     });
 }
 
@@ -125,6 +145,7 @@ fn minmaxlttb_without_x_f32_random_array_50M_multi_core(c: &mut Criterion) {
             minmaxlttb_mod::minmaxlttb_scalar_without_x_parallel(
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });
@@ -133,6 +154,7 @@ fn minmaxlttb_without_x_f32_random_array_50M_multi_core(c: &mut Criterion) {
             minmaxlttb_mod::minmaxlttb_simd_without_x_parallel(
                 black_box(y.view()),
                 black_box(2_000),
+                black_box(MINMAX_RATIO),
             )
         })
     });

downsample_rs/src/m4/generic.rs

@@ -47,6 +47,7 @@ pub(crate) fn m4_generic<T: Copy + PartialOrd>(
     sampled_indices
 }
 
+#[inline(always)]
 pub(crate) fn m4_generic_parallel<T: Copy + PartialOrd + Send + Sync>(
     arr: ArrayView1<T>,
     n_out: usize,

downsample_rs/src/minmaxlttb/generic.rs

@@ -3,46 +3,46 @@ use ndarray::{Array1, ArrayView1};
 use super::super::lttb::utils::Num;
 use super::super::lttb::{lttb, lttb_without_x};
 
-const SIZE_THRESHOLD: usize = 10_000_000;
-const RATIO_THRESHOLD: usize = 100;
-const MINMAX_RATIO: usize = 30;
-
-#[inline]
+#[inline(always)]
 pub(crate) fn minmaxlttb_generic<
     Tx: Num,
     Ty: Num + PartialOrd, // TODO: check if partialord is needed
 >(
     x: ArrayView1<Tx>,
     y: ArrayView1<Ty>,
     n_out: usize,
+    minmax_ratio: usize,
     f_minmax: fn(ArrayView1<Ty>, usize) -> Array1<usize>,
 ) -> Array1<usize> {
     assert_eq!(x.len(), y.len());
-    // Apply first min max aggregation (if above threshold & ratio)
-    if x.len() > SIZE_THRESHOLD && x.len() / n_out > RATIO_THRESHOLD {
-        let index = f_minmax(y, n_out * MINMAX_RATIO);
+    assert!(minmax_ratio > 1);
+    // Apply first min max aggregation (if above ratio)
+    if x.len() / n_out > minmax_ratio {
+        let index = f_minmax(y, n_out * minmax_ratio);
         let x = index.mapv(|i| x[i]);
         let y = index.mapv(|i| y[i]);
         let index_points_selected = lttb(x.view(), y.view(), n_out);
         return index_points_selected.mapv(|i| index[i]);
     }
-    // Apply lttb on all data when requirements are not met
+    // Apply lttb on all data when requirement is not met
     lttb(x, y, n_out)
 }
 
-#[inline]
+#[inline(always)]
 pub(crate) fn minmaxlttb_generic_without_x<Ty: Num>(
     y: ArrayView1<Ty>,
     n_out: usize,
+    minmax_ratio: usize,
     f_minmax: fn(ArrayView1<Ty>, usize) -> Array1<usize>,
 ) -> Array1<usize> {
-    // Apply first min max aggregation (if above threshold & ratio)
-    if y.len() > SIZE_THRESHOLD && y.len() / n_out > RATIO_THRESHOLD {
-        let index = f_minmax(y, n_out * 30);
+    assert!(minmax_ratio > 1);
+    // Apply first min max aggregation (if above ratio)
+    if y.len() / n_out > minmax_ratio {
+        let index = f_minmax(y, n_out * minmax_ratio);
         let y = index.mapv(|i| y[i]);
         let index_points_selected = lttb(index.view(), y.view(), n_out);
         return index_points_selected.mapv(|i| index[i]);
     }
-    // Apply lttb on all data when requirements are not met
+    // Apply lttb on all data when requirement is not met
     lttb_without_x(y.view(), n_out)
 }

downsample_rs/src/minmaxlttb/scalar.rs

@@ -12,21 +12,23 @@ pub fn minmaxlttb_scalar<Tx: Num, Ty: Num + PartialOrd>(
     x: ArrayView1<Tx>,
     y: ArrayView1<Ty>,
     n_out: usize,
+    minmax_ratio: usize,
 ) -> Array1<usize>
 where
     SCALAR: ScalarArgMinMax<Ty>,
 {
-    minmaxlttb_generic(x, y, n_out, minmax::min_max_scalar)
+    minmaxlttb_generic(x, y, n_out, minmax_ratio, minmax::min_max_scalar)
 }
 
 pub fn minmaxlttb_scalar_without_x<Ty: Num + PartialOrd>(
     y: ArrayView1<Ty>,
     n_out: usize,
+    minmax_ratio: usize,
 ) -> Array1<usize>
 where
     SCALAR: ScalarArgMinMax<Ty>,
 {
-    minmaxlttb_generic_without_x(y, n_out, minmax::min_max_scalar)
+    minmaxlttb_generic_without_x(y, n_out, minmax_ratio, minmax::min_max_scalar)
 }
 
 // ------------------------------------- PARALLEL --------------------------------------
@@ -35,33 +37,78 @@ pub fn minmaxlttb_scalar_parallel<Tx: Num + Send + Sync, Ty: Num + PartialOrd +
     x: ArrayView1<Tx>,
     y: ArrayView1<Ty>,
     n_out: usize,
+    minmax_ratio: usize,
 ) -> Array1<usize>
 where
     SCALAR: ScalarArgMinMax<Ty>,
 {
-    minmaxlttb_generic(x, y, n_out, minmax::min_max_scalar_parallel)
+    minmaxlttb_generic(x, y, n_out, minmax_ratio, minmax::min_max_scalar_parallel)
 }
 
 pub fn minmaxlttb_scalar_without_x_parallel<Ty: Num + PartialOrd + Send + Sync>(
     y: ArrayView1<Ty>,
     n_out: usize,
+    minmax_ratio: usize,
 ) -> Array1<usize>
 where
     SCALAR: ScalarArgMinMax<Ty>,
 {
-    minmaxlttb_generic_without_x(y, n_out, minmax::min_max_scalar_parallel)
+    minmaxlttb_generic_without_x(y, n_out, minmax_ratio, minmax::min_max_scalar_parallel)
 }
 
 // ---- TEST
 
 #[cfg(test)]
 mod tests {
-    extern crate dev_utils;
+    use super::{minmaxlttb_scalar, minmaxlttb_scalar_without_x};
+    use super::{minmaxlttb_scalar_parallel, minmaxlttb_scalar_without_x_parallel};
+    use ndarray::{array, s, Array1};
 
+    extern crate dev_utils;
     use dev_utils::utils;
 
-    use super::{minmaxlttb_scalar, minmaxlttb_scalar_without_x};
-    use ndarray::{array, s, Array1};
+    fn get_array_f32(n: usize) -> Array1<f32> {
+        utils::get_random_array(n, f32::MIN, f32::MAX)
+    }
+
+    #[test]
+    fn test_minmaxlttb() {
+        let x = array![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let y = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
+        let sampled_indices = minmaxlttb_scalar(x.view(), y.view(), 4, 2);
+        assert_eq!(sampled_indices, array![0, 1, 5, 9]);
+    }
+
+    #[test]
+    fn test_minmaxlttb_without_x() {
+        let y = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
+        let sampled_indices = minmaxlttb_scalar_without_x(y.view(), 4, 2);
+        assert_eq!(sampled_indices, array![0, 1, 5, 9]);
+    }
+
+    #[test]
+    fn test_minmaxlttb_parallel() {
+        let x = array![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let y = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
+        let sampled_indices = minmaxlttb_scalar_parallel(x.view(), y.view(), 4, 2);
+        assert_eq!(sampled_indices, array![0, 1, 5, 9]);
+    }
+
+    #[test]
+    fn test_minmaxlttb_without_x_parallel() {
+        let y = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
+        let sampled_indices = minmaxlttb_scalar_without_x_parallel(y.view(), 4, 2);
+        assert_eq!(sampled_indices, array![0, 1, 5, 9]);
+    }
 
-    // TODO
+    #[test]
+    fn test_many_random_runs_same_output() {
+        let n = 20_000;
+        for _ in 0..100 {
+            let arr = get_array_f32(n);
+            let idxs1 = minmaxlttb_scalar_without_x(arr.view(), 100, 5);
+            let idxs2 = minmaxlttb_scalar_without_x_parallel(arr.view(), 100, 5);
+            assert_eq!(idxs1, idxs2);
+        }
+    }
 }