🔍 add searchsorted to get equidistant x-bins

.github/workflows/ci-downsample_rs.yml

@@ -42,7 +42,6 @@ jobs:
         run: cargo check --verbose --all-features
       - name: formatting check
         run: cargo fmt --all -- --check
-      # TODO: enable clippy once I write docs for all public items
       # - name: check with clippy
       #   run: cargo clippy --all --all-targets --all-features -- -D warnings
 

README.md

@@ -28,8 +28,8 @@
   - no intermediate data structures are created
 * **Flexible**: works on any type of data
     - supported datatypes are 
-      - for `x`: `f16`, `f32`, `f64`, `i16`, `i32`, `i64`, `u16`, `u32`, `u64`, `datetime64`
-      - for `y`: `f16`, `f32`, `f64`, `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`, `bool`
+      - for `x`: `f32`, `f64`, `i16`, `i32`, `i64`, `u16`, `u32`, `u64`, `datetime64`, `timedelta64`
+      - for `y`: `f16`, `f32`, `f64`, `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`, `datetime64`, `timedelta64`, `bool`
     <details>
       <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>

downsample_rs/Cargo.toml

@@ -7,9 +7,12 @@ description = "Downsample time series data"
 license = "MIT"
 
 [dependencies]
+# TODO: perhaps use polars?
 ndarray = {version = "0.15.6", default-features = false, features = ["rayon"] }
 argminmax = { version = "0.3" , features = ["half"] }
-half = { version = "2.1", default-features = false , optional = true}
+half = { version = "2.1", default-features = false , features=["num-traits"], optional = true}
+num-traits = { version = "0.2.15", default-features = false }
+rayon = { version = "1.6.0", default-features = false }
 
 [dev-dependencies]
 criterion = "0.3.0"

downsample_rs/benches/bench_lttb.rs

@@ -12,30 +12,30 @@ fn lttb_f32_random_array_long(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
     let y = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
-    c.bench_function("lttb_scal_f32", |b| {
-        b.iter(|| lttb_mod::lttb(black_box(x.view()), black_box(y.view()), black_box(2_000)))
+    c.bench_function("lttb_scalx_f32", |b| {
+        b.iter(|| lttb_mod::lttb_with_x(black_box(x.view()), black_box(y.view()), black_box(2_000)))
     });
 }
 fn lttb_f32_random_array_50m(c: &mut Criterion) {
     let n = 50_000_000;
     let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
     let y = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
-    c.bench_function("lttb_scal_50M_f32", |b| {
-        b.iter(|| lttb_mod::lttb(black_box(x.view()), black_box(y.view()), black_box(2_000)))
+    c.bench_function("lttb_scalx_50M_f32", |b| {
+        b.iter(|| lttb_mod::lttb_with_x(black_box(x.view()), black_box(y.view()), black_box(2_000)))
     });
 }
 
 fn lttb_without_x_f32_random_array_long(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let y = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
-    c.bench_function("lttbnox_scal_f32", |b| {
+    c.bench_function("lttb_scal_f32", |b| {
         b.iter(|| lttb_mod::lttb_without_x(black_box(y.view()), black_box(2_000)))
     });
 }
 fn lttb_without_x_f32_random_array_50m(c: &mut Criterion) {
     let n = 50_000_000;
     let y = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
-    c.bench_function("lttbnox_scal_50M_f32", |b| {
+    c.bench_function("lttb_scal_50M_f32", |b| {
         b.iter(|| lttb_mod::lttb_without_x(black_box(y.view()), black_box(2_000)))
     });
 }

downsample_rs/benches/bench_m4.rs

@@ -7,47 +7,87 @@ use downsample_rs::m4 as m4_mod;
 use criterion::{black_box, Criterion};
 use dev_utils::{config, utils};
 
+use ndarray::Array1;
+
 fn m4_f32_random_array_long_single_core(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
     c.bench_function("m4_scal_f32", |b| {
-        b.iter(|| m4_mod::m4_scalar(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_scalar_without_x(black_box(data.view()), black_box(2_000)))
     });
     c.bench_function("m4_simd_f32", |b| {
-        b.iter(|| m4_mod::m4_simd(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_simd_without_x(black_box(data.view()), black_box(2_000)))
     });
 }
 
 fn m4_f32_random_array_long_multi_core(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
     c.bench_function("m4_scal_p_f32", |b| {
-        b.iter(|| m4_mod::m4_scalar_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_scalar_without_x_parallel(black_box(data.view()), black_box(2_000)))
     });
     c.bench_function("m4_simd_p_f32", |b| {
-        b.iter(|| m4_mod::m4_simd_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_simd_without_x_parallel(black_box(data.view()), black_box(2_000)))
     });
 }
 
 fn m4_f32_random_array_50M_single_core(c: &mut Criterion) {
     let n = 50_000_000;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
+    let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
     c.bench_function("m4_scal_50M_f32", |b| {
-        b.iter(|| m4_mod::m4_scalar(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_scalar_without_x(black_box(data.view()), black_box(2_000)))
     });
     c.bench_function("m4_simd_50M_f32", |b| {
-        b.iter(|| m4_mod::m4_simd(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_simd_without_x(black_box(data.view()), black_box(2_000)))
+    });
+    c.bench_function("m4_scalx_50M_f32", |b| {
+        b.iter(|| {
+            m4_mod::m4_scalar_with_x(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
+    });
+    c.bench_function("m4_simdx_50M_f32", |b| {
+        b.iter(|| {
+            m4_mod::m4_simd_with_x(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
     });
 }
 
 fn m4_f32_random_array_50M_multi_core(c: &mut Criterion) {
     let n = 50_000_000;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
+    let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
     c.bench_function("m4_scal_p_50M_f32", |b| {
-        b.iter(|| m4_mod::m4_scalar_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_scalar_without_x_parallel(black_box(data.view()), black_box(2_000)))
     });
     c.bench_function("m4_simd_p_50M_f32", |b| {
-        b.iter(|| m4_mod::m4_simd_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| m4_mod::m4_simd_without_x_parallel(black_box(data.view()), black_box(2_000)))
+    });
+    c.bench_function("m4_scalx_p_50M_f32", |b| {
+        b.iter(|| {
+            m4_mod::m4_scalar_with_x_parallel(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
+    });
+    c.bench_function("m4_simdx_p_50M_f32", |b| {
+        b.iter(|| {
+            m4_mod::m4_simd_with_x_parallel(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
     });
 }
 

downsample_rs/benches/bench_minmax.rs

@@ -7,48 +7,122 @@ use downsample_rs::minmax as minmax_mod;
 use criterion::{black_box, Criterion};
 use dev_utils::{config, utils};
 
+use ndarray::Array1;
+
 fn minmax_f32_random_array_long_single_core(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
     c.bench_function("minmax_scal_f32", |b| {
-        b.iter(|| minmax_mod::min_max_scalar(black_box(data.view()), black_box(2_000)))
+        b.iter(|| minmax_mod::min_max_scalar_without_x(black_box(data.view()), black_box(2_000)))
     });
     c.bench_function("minmax_simd_f32", |b| {
-        b.iter(|| minmax_mod::min_max_simd(black_box(data.view()), black_box(2_000)))
+        b.iter(|| minmax_mod::min_max_simd_without_x(black_box(data.view()), black_box(2_000)))
     });
 }
 
 fn minmax_f32_random_array_long_multi_core(c: &mut Criterion) {
     let n = config::ARRAY_LENGTH_LONG;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
     c.bench_function("minmax_scal_p_f32", |b| {
-        b.iter(|| minmax_mod::min_max_scalar_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| {
+            minmax_mod::min_max_scalar_without_x_parallel(black_box(data.view()), black_box(2_000))
+        })
     });
     c.bench_function("minmax_simd_p_f32", |b| {
-        b.iter(|| minmax_mod::min_max_simd_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| {
+            minmax_mod::min_max_simd_without_x_parallel(black_box(data.view()), black_box(2_000))
+        })
     });
 }
 
 fn minmax_f32_random_array_50M_single_core(c: &mut Criterion) {
     let n = 50_000_000;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
+    let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
     c.bench_function("minmax_scal_50M_f32", |b| {
-        b.iter(|| minmax_mod::min_max_scalar(black_box(data.view()), black_box(2_000)))
+        b.iter(|| minmax_mod::min_max_scalar_without_x(black_box(data.view()), black_box(2_000)))
     });
     c.bench_function("minmax_simd_50M_f32", |b| {
-        b.iter(|| minmax_mod::min_max_simd(black_box(data.view()), black_box(2_000)))
+        b.iter(|| minmax_mod::min_max_simd_without_x(black_box(data.view()), black_box(2_000)))
+    });
+    c.bench_function("minmax_scalx_50M_f32", |b| {
+        b.iter(|| {
+            minmax_mod::min_max_scalar_with_x(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
     });
+    c.bench_function("minmax_simdx_50M_f32", |b| {
+        b.iter(|| {
+            minmax_mod::min_max_simd_with_x(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
+    });
+
+    // c.bench_function("minmax_scal_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_scalar_without_x(black_box(data.view()), black_box(60_000)))
+    // });
+    // c.bench_function("minmax_simd_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_simd_without_x(black_box(data.view()), black_box(60_000)))
+    // });
+    // c.bench_function("minmax_scalx_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_scalar_with_x(black_box(x.view()), black_box(data.view()), black_box(60_000)))
+    // });
+    // c.bench_function("minmax_simdx_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_simd_with_x(black_box(x.view()), black_box(data.view()), black_box(60_000)))
+    // });
 }
 
 fn minmax_f32_random_array_50M_long_multi_core(c: &mut Criterion) {
     let n = 50_000_000;
     let data = utils::get_random_array::<f32>(n, f32::MIN, f32::MAX);
+    let x = Array1::from((0..n).map(|i| i as i32).collect::<Vec<i32>>());
     c.bench_function("minmax_scal_p_50M_f32", |b| {
-        b.iter(|| minmax_mod::min_max_scalar_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| {
+            minmax_mod::min_max_scalar_without_x_parallel(black_box(data.view()), black_box(2_000))
+        })
     });
     c.bench_function("minmax_simd_p_50M_f32", |b| {
-        b.iter(|| minmax_mod::min_max_simd_parallel(black_box(data.view()), black_box(2_000)))
+        b.iter(|| {
+            minmax_mod::min_max_simd_without_x_parallel(black_box(data.view()), black_box(2_000))
+        })
     });
+    c.bench_function("minmax_scalx_p_50M_f32", |b| {
+        b.iter(|| {
+            minmax_mod::min_max_scalar_with_x_parallel(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
+    });
+    c.bench_function("minmax_simdx_p_50M_f32", |b| {
+        b.iter(|| {
+            minmax_mod::min_max_simd_with_x_parallel(
+                black_box(x.view()),
+                black_box(data.view()),
+                black_box(2_000),
+            )
+        })
+    });
+
+    // c.bench_function("minmax_scal_p_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_scalar_without_x_parallel(black_box(data.view()), black_box(60_000)))
+    // });
+    // c.bench_function("minmax_simd_p_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_simd_without_x_parallel(black_box(data.view()), black_box(60_000)))
+    // });
+    // c.bench_function("minmax_scalx_p_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_scalar_with_x_parallel(black_box(x.view()), black_box(data.view()), black_box(60_000)))
+    // });
+    // c.bench_function("minmax_simdx_p_50M_f32", |b| {
+    //     b.iter(|| minmax_mod::min_max_simd_with_x_parallel(black_box(x.view()), black_box(data.view()), black_box(60_000)))
+    // });
 }
 
 // fn minmax_f32_worst_case_array_long(c: &mut Criterion) {