✨ new interface + ♻️ major code updates (#6)

* 🚧 WIP

* 🚧

* 🚧

* 🚧

* ✨ new interface

* 🧹

* 🧹 formatting

* 🧹 fix linting

* 🚀 new alpha release (#7)

* 🚧 WIP

* 🧹 cleanup type hints

* 🧹

* 🐛 use multi-core if parallel=True

* 🖊️ update based on code review

* 🖍️ code review

* 🙈 formatting

* 🔥 support datetime64

* ✨ support int8, uint8, & bool

* 🐛 fix overflow issue

* 🧹 cleanup tests

* 🧹 cleanup readme for first main release

* ☕ support datetime64 as y as well

* ✨ support timedelta64 y

* ☎️ support timedelta64 x

* 🎨 update readme

Co-authored-by: jonasvdd <[email protected]>

Author: jvdd

.gitignore

@@ -1,3 +1,4 @@
+.vscode/*
 venv/
 TODO.md
 main.rs

Makefile

@@ -5,6 +5,11 @@ black = black tsdownsample tests
 install:
 	pip install -e .
 
+.PHONY: install-dev-requirements
+install-dev-requirements:
+	pip install -r tests/requirements.txt
+	pip install -r tests/requirements-linting.txt
+
 .PHONY: format
 format:
 	$(isort)

README.md

@@ -3,7 +3,9 @@
 [![PyPI Latest Release](https://img.shields.io/pypi/v/tsdownsample.svg)](https://pypi.org/project/tsdownsample/)
 [![support-version](https://img.shields.io/pypi/pyversions/tsdownsample)](https://img.shields.io/pypi/pyversions/tsdownsample)
 [![Downloads](https://pepy.tech/badge/tsdownsample)](https://pepy.tech/project/tsdownsample)
-<!-- [![Testing](https://github.com/predict-idlab/tsflex/actions/workflows/test.yml/badge.svg)](https://github.com/predict-idlab/tsflex/actions/workflows/test.yml) -->
+[![Testing](https://github.com/predict-idlab/tsdownsample/actions/workflows/ci-downsample_rs.yml/badge.svg)](https://github.com/predict-idlab/tsdownsample/actions/workflows/ci-downsample_rs.yml)
+[![Testing](https://github.com/predict-idlab/tsdownsample/actions/workflows/ci-tsdownsample.yml/badge.svg)](https://github.com/predict-idlab/tsdownsample/actions/workflows/ci-tsdownsample.yml)
+<!-- TODO: codecov -->
 
 **📈 Time series downsampling** algorithms for visualization
 
@@ -25,20 +27,21 @@
   - works on views of the data (no copies)
   - no intermediate data structures are created
 * **Flexible**: works on any type of data
-    - supported datatypes are `f16`, `f32`, `f64`, `i16`, `i32`, `i64`, `u16`, `u32`, `u64`
+    - 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`
     <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>
-      🐌 Programming languages facilitate support for this datatype by either (i) upcasting to `f32` or (ii) using a software implementation. <br>
+      🐌 Programming languages facilitate support for this datatype by either (i) upcasting to <u>f32</u> or (ii) using a software implementation. <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
 
 ## Install
 
-> ❗🚨❗ This package is currently under development - no stable release yet ❗🚨❗
-
+> ❗🚨❗ This package is currently under development - correct installation is not yet guaranteed ❗🚨❗
 
 ```bash
 pip install tsdownsample
@@ -48,16 +51,25 @@ pip install tsdownsample
 
 ```python
 from tsdownsample import MinMaxLTTBDownsampler
-import pandas as pd; import numpy as np
+import numpy as np
 
 # Create a time series
 y = np.random.randn(10_000_000)
-s = pd.Series(y)
+x = np.arange(len(y))
+
+# Downsample to 1000 points (assuming constant sampling rate)
+s_ds = MinMaxLTTBDownsampler().downsample(y, n_out=1000)
 
-# Downsample to 1000 points
-s_ds = MinMaxLTTBDownsampler.downsample(s, n_out=1000)
+# Downsample to 1000 points using the (possible irregularly spaced) x-data
+s_ds = MinMaxLTTBDownsampler().downsample(x, y, n_out=1000)
 ```
 
+## Limitations
+
+Assumes;
+(i) x-data monotinically increasing (i.e., sorted)
+(ii) no NaNs in the data
+
 ---
 
 <p align="center">

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.1" , features = ["half"] }
+argminmax = { version = "0.3" , features = ["half"] }
 half = { version = "2.1", default-features = false , optional = true}
 
 [dev-dependencies]

downsample_rs/src/lttb/scalar.rs

@@ -23,21 +23,24 @@ pub fn lttb<Tx: Num, Ty: Num>(x: ArrayView1<Tx>, y: ArrayView1<Ty>, n_out: usize
 
     for i in 0..n_out - 2 {
         // Calculate point average for next bucket (containing c).
-        let mut avg_x: Tx = Tx::default();
-        let mut avg_y: Ty = Ty::default();
+        // let mut avg_x: Tx = Tx::default();
+        // let mut avg_y: Ty = Ty::default();
+        // TODO: check the impact of using f64 (is necessary to avoid overflow)
+        let mut avg_x: f64 = 0.0;
+        let mut avg_y: f64 = 0.0;
 
         let avg_range_start = (every * (i + 1) as f64) as usize + 1;
         let avg_range_end = cmp::min((every * (i + 2) as f64) as usize + 1, x.len());
 
         for i in avg_range_start..avg_range_end {
-            avg_x = avg_x + x[i];
-            avg_y = avg_y + y[i];
+            avg_x = avg_x + x[i].to_f64();
+            avg_y = avg_y + y[i].to_f64();
         }
         // Slicing seems to be a lot slower
         // let avg_x: Tx = x.slice(s![avg_range_start..avg_range_end]).sum();
         // let avg_y: Ty = y.slice(s![avg_range_start..avg_range_end]).sum();
-        let avg_x: f64 = avg_x.to_f64() / (avg_range_end - avg_range_start) as f64;
-        let avg_y: f64 = avg_y.to_f64() / (avg_range_end - avg_range_start) as f64;
+        let avg_x: f64 = avg_x / (avg_range_end - avg_range_start) as f64;
+        let avg_y: f64 = avg_y / (avg_range_end - avg_range_start) as f64;
 
         // Get the range for this bucket
         let range_offs = (every * i as f64) as usize + 1;
@@ -93,17 +96,19 @@ pub fn lttb_without_x<Ty: Num>(y: ArrayView1<Ty>, n_out: usize) -> Array1<usize>
 
     for i in 0..n_out - 2 {
         // Calculate point average for next bucket (containing c).
-        let mut avg_y: Ty = Ty::default();
+        // let mut avg_y: Ty = Ty::default();
+        // TODO: check impact of using f64 (is necessary to avoid overflow)
+        let mut avg_y: f64 = 0.0;
 
         let avg_range_start = (every * (i + 1) as f64) as usize + 1;
         let avg_range_end = cmp::min((every * (i + 2) as f64) as usize + 1, y.len());
 
         for i in avg_range_start..avg_range_end {
-            avg_y = avg_y + y[i];
+            avg_y = avg_y + y[i].to_f64();
         }
         // Slicing seems to be a lot slower
         // let avg_x: Tx = x.slice(s![avg_range_start..avg_range_end]).sum();
-        let avg_y: f64 = avg_y.to_f64() / (avg_range_end - avg_range_start) as f64;
+        let avg_y: f64 = avg_y / (avg_range_end - avg_range_start) as f64;
         let avg_x: f64 = (avg_range_start + avg_range_end - 1) as f64 / 2.0;
 
         // Get the range for this bucket