parser: add recap dataset

parser/src/utils/lossy.rs

@@ -1,11 +1,59 @@
+use ordered_float::OrderedFloat;
+
 pub trait LossyFrom<T> {
     fn lossy_from(x: T) -> Self;
 }
 
+// ---
+// u32
+// ---
+
+impl LossyFrom<u32> for u32 {
+    #[inline(always)]
+    fn lossy_from(x: u32) -> Self {
+        x
+    }
+}
+
+impl LossyFrom<u64> for u32 {
+    #[inline(always)]
+    fn lossy_from(x: u64) -> Self {
+        x as u32
+    }
+}
+
+impl LossyFrom<usize> for u32 {
+    #[inline(always)]
+    fn lossy_from(x: usize) -> Self {
+        x as u32
+    }
+}
+
+impl LossyFrom<f32> for u32 {
+    #[inline(always)]
+    fn lossy_from(x: f32) -> Self {
+        x as u32
+    }
+}
+
+impl LossyFrom<OrderedFloat<f32>> for u32 {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f32>) -> Self {
+        x.0 as u32
+    }
+}
+
 // ---
 // u64
 // ---
 
+impl LossyFrom<u32> for u64 {
+    #[inline(always)]
+    fn lossy_from(x: u32) -> Self {
+        x as u64
+    }
+}
+
 impl LossyFrom<u64> for u64 {
     #[inline(always)]
     fn lossy_from(x: u64) -> Self {
@@ -20,6 +68,20 @@ impl LossyFrom<usize> for u64 {
     }
 }
 
+impl LossyFrom<f32> for u64 {
+    #[inline(always)]
+    fn lossy_from(x: f32) -> Self {
+        x as u64
+    }
+}
+
+impl LossyFrom<OrderedFloat<f32>> for u64 {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f32>) -> Self {
+        x.0 as u64
+    }
+}
+
 // ---
 // usize
 // ---
@@ -70,6 +132,13 @@ impl LossyFrom<f32> for f32 {
     }
 }
 
+impl LossyFrom<OrderedFloat<f32>> for f32 {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f32>) -> Self {
+        x.0
+    }
+}
+
 impl LossyFrom<f64> for f32 {
     #[inline(always)]
     fn lossy_from(x: f64) -> Self {
@@ -77,6 +146,66 @@ impl LossyFrom<f64> for f32 {
     }
 }
 
+impl LossyFrom<OrderedFloat<f64>> for f32 {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f64>) -> Self {
+        x.0 as f32
+    }
+}
+
+// ---
+// OrderedFloat<f32>
+// ---
+
+impl LossyFrom<u32> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: u32) -> Self {
+        OrderedFloat(x as f32)
+    }
+}
+
+impl LossyFrom<u64> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: u64) -> Self {
+        OrderedFloat(x as f32)
+    }
+}
+
+impl LossyFrom<usize> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: usize) -> Self {
+        OrderedFloat(x as f32)
+    }
+}
+
+impl LossyFrom<f32> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: f32) -> Self {
+        OrderedFloat(x)
+    }
+}
+
+impl LossyFrom<OrderedFloat<f32>> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f32>) -> Self {
+        x
+    }
+}
+
+impl LossyFrom<f64> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: f64) -> Self {
+        OrderedFloat(x as f32)
+    }
+}
+
+impl LossyFrom<OrderedFloat<f64>> for OrderedFloat<f32> {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f64>) -> Self {
+        OrderedFloat(x.0 as f32)
+    }
+}
+
 // ---
 // f64
 // ---
@@ -102,9 +231,69 @@ impl LossyFrom<f32> for f64 {
     }
 }
 
+impl LossyFrom<OrderedFloat<f32>> for f64 {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f32>) -> Self {
+        x.0 as f64
+    }
+}
+
 impl LossyFrom<f64> for f64 {
     #[inline(always)]
     fn lossy_from(x: f64) -> Self {
         x
     }
 }
+
+impl LossyFrom<OrderedFloat<f64>> for f64 {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f64>) -> Self {
+        x.0
+    }
+}
+
+// ---
+// OrderedFloat<f64>
+// ---
+
+impl LossyFrom<u64> for OrderedFloat<f64> {
+    #[inline(always)]
+    fn lossy_from(x: u64) -> Self {
+        OrderedFloat(x as f64)
+    }
+}
+
+impl LossyFrom<usize> for OrderedFloat<f64> {
+    #[inline(always)]
+    fn lossy_from(x: usize) -> Self {
+        OrderedFloat(x as f64)
+    }
+}
+
+impl LossyFrom<f32> for OrderedFloat<f64> {
+    #[inline(always)]
+    fn lossy_from(x: f32) -> Self {
+        OrderedFloat(x as f64)
+    }
+}
+
+impl LossyFrom<OrderedFloat<f32>> for OrderedFloat<f64> {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f32>) -> Self {
+        OrderedFloat(x.0 as f64)
+    }
+}
+
+impl LossyFrom<f64> for OrderedFloat<f64> {
+    #[inline(always)]
+    fn lossy_from(x: f64) -> Self {
+        OrderedFloat(x)
+    }
+}
+
+impl LossyFrom<OrderedFloat<f64>> for OrderedFloat<f64> {
+    #[inline(always)]
+    fn lossy_from(x: OrderedFloat<f64>) -> Self {
+        x
+    }
+}

parser/src/utils/mod.rs

@@ -3,6 +3,7 @@ mod date;
 mod flamegraph;
 mod log;
 mod lossy;
+mod percentile;
 mod retry;
 mod time;
 
@@ -11,5 +12,6 @@ pub use date::*;
 pub use flamegraph::*;
 pub use log::*;
 pub use lossy::*;
+pub use percentile::*;
 pub use retry::*;
 pub use time::*;

parser/src/utils/percentile.rs

@@ -0,0 +1,28 @@
+use std::ops::Add;
+
+use super::LossyFrom;
+
+pub fn get_percentile<T>(sorted: &[T], percentile: f32) -> T
+where
+    T: Clone + Copy + LossyFrom<f32> + Add<Output = T>,
+    f32: LossyFrom<T>,
+{
+    let len = sorted.len();
+
+    if len < 2 {
+        T::lossy_from(f32::NAN)
+    } else {
+        let index = (len - 1) as f32 * percentile;
+
+        let fract = index.fract();
+
+        if fract != 0.0 {
+            let left = *sorted.get(index as usize).unwrap();
+            let right = *sorted.get(index.ceil() as usize).unwrap();
+
+            T::lossy_from(f32::lossy_from(left + right) / 2.0)
+        } else {
+            *sorted.get(index as usize).unwrap()
+        }
+    }
+}