@ebowwa/quant-rust 0.1.0

package/src/utils/rolling.rs

@@ -0,0 +1,97 @@
+//! Rolling Window Operations Module
+//!
+//! Sliding window calculations for time series analysis
+
+use super::stats::{mean, std_dev, max, min};
+
+/// Apply a function over a sliding window
+///
+/// Returns an empty vector if the array is shorter than the window size.
+pub fn rolling<T, F>(arr: &[f64], window: usize, f: F) -> Vec<T>
+where
+    F: Fn(&[f64]) -> T,
+{
+    if arr.len() < window || window == 0 {
+        return Vec::new();
+    }
+
+    let result_len = arr.len() - window + 1;
+    let mut result = Vec::with_capacity(result_len);
+
+    for i in 0..result_len {
+        let slice = &arr[i..i + window];
+        result.push(f(slice));
+    }
+
+    result
+}
+
+/// Rolling mean (Simple Moving Average)
+pub fn rolling_mean(arr: &[f64], period: usize) -> Vec<f64> {
+    rolling(arr, period, mean)
+}
+
+/// Rolling standard deviation (sample)
+pub fn rolling_std_dev(arr: &[f64], period: usize) -> Vec<f64> {
+    rolling(arr, period, |slice| std_dev(slice, false))
+}
+
+/// Rolling minimum
+pub fn rolling_min(arr: &[f64], period: usize) -> Vec<f64> {
+    rolling(arr, period, min)
+}
+
+/// Rolling maximum
+pub fn rolling_max(arr: &[f64], period: usize) -> Vec<f64> {
+    rolling(arr, period, max)
+}
+
+/// Rolling sum
+pub fn rolling_sum(arr: &[f64], period: usize) -> Vec<f64> {
+    rolling(arr, period, |slice| slice.iter().sum())
+}
+
+/// Rolling variance (sample)
+pub fn rolling_variance(arr: &[f64], period: usize) -> Vec<f64> {
+    use super::stats::variance;
+    rolling(arr, period, |slice| variance(slice, false))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rolling() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let result: Vec<f64> = rolling(&data, 3, |s| s.iter().sum());
+        assert_eq!(result, vec![6.0, 9.0, 12.0]);
+    }
+
+    #[test]
+    fn test_rolling_mean() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let result = rolling_mean(&data, 3);
+        assert_eq!(result.len(), 3);
+        assert!((result[0] - 2.0).abs() < 1e-10);
+        assert!((result[1] - 3.0).abs() < 1e-10);
+        assert!((result[2] - 4.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_rolling_empty() {
+        let data = [1.0, 2.0];
+        let result = rolling_mean(&data, 5);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_rolling_min_max() {
+        let data = [5.0, 3.0, 8.0, 2.0, 9.0, 1.0];
+        let min_result = rolling_min(&data, 3);
+        let max_result = rolling_max(&data, 3);
+
+        assert_eq!(min_result, vec![3.0, 2.0, 2.0, 1.0]);
+        assert_eq!(max_result, vec![8.0, 8.0, 9.0, 9.0]);
+    }
+}

package/src/utils/stats.rs

@@ -0,0 +1,154 @@
+//! Array Statistics Module
+//!
+//! Common statistical functions for quantitative analysis
+
+/// Calculate the sum of an array
+pub fn sum(arr: &[f64]) -> f64 {
+    arr.iter().sum()
+}
+
+/// Calculate the mean (average) of an array
+pub fn mean(arr: &[f64]) -> f64 {
+    if arr.is_empty() {
+        return 0.0;
+    }
+    sum(arr) / arr.len() as f64
+}
+
+/// Calculate the median of an array
+pub fn median(arr: &[f64]) -> f64 {
+    if arr.is_empty() {
+        return 0.0;
+    }
+
+    let mut sorted: Vec<f64> = arr.to_vec();
+    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+    let mid = sorted.len() / 2;
+    if sorted.len() % 2 != 0 {
+        sorted[mid]
+    } else {
+        (sorted[mid - 1] + sorted[mid]) / 2.0
+    }
+}
+
+/// Calculate the mode of an array
+pub fn mode(arr: &[f64]) -> f64 {
+    if arr.is_empty() {
+        return 0.0;
+    }
+
+    use std::collections::HashMap;
+    let mut frequency: HashMap<u64, usize> = HashMap::new();
+
+    // Use bit representation for hashing floats
+    for &val in arr {
+        let key = val.to_bits();
+        *frequency.entry(key).or_insert(0) += 1;
+    }
+
+    let mut max_freq = 0;
+    let mut mode_val = arr[0];
+
+    for (&key, &freq) in &frequency {
+        if freq > max_freq {
+            max_freq = freq;
+            mode_val = f64::from_bits(key);
+        }
+    }
+
+    mode_val
+}
+
+/// Calculate variance
+/// population: true for population variance, false for sample variance
+pub fn variance(arr: &[f64], population: bool) -> f64 {
+    if arr.is_empty() {
+        return 0.0;
+    }
+
+    let avg = mean(arr);
+    let sum_sq_diff: f64 = arr.iter().map(|&val| (val - avg).powi(2)).sum();
+
+    let divisor = if population {
+        arr.len() as f64
+    } else {
+        (arr.len() - 1) as f64
+    };
+
+    sum_sq_diff / divisor
+}
+
+/// Calculate standard deviation
+/// population: true for population std dev, false for sample std dev
+pub fn std_dev(arr: &[f64], population: bool) -> f64 {
+    variance(arr, population).sqrt()
+}
+
+/// Calculate the minimum value
+pub fn min(arr: &[f64]) -> f64 {
+    if arr.is_empty() {
+        return 0.0;
+    }
+    arr.iter().cloned().fold(f64::INFINITY, f64::min)
+}
+
+/// Calculate the maximum value
+pub fn max(arr: &[f64]) -> f64 {
+    if arr.is_empty() {
+        return 0.0;
+    }
+    arr.iter().cloned().fold(f64::NEG_INFINITY, f64::max)
+}
+
+/// Calculate the range (max - min)
+pub fn range(arr: &[f64]) -> f64 {
+    max(arr) - min(arr)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sum() {
+        assert_eq!(sum(&[1.0, 2.0, 3.0, 4.0, 5.0]), 15.0);
+        assert_eq!(sum(&[]), 0.0);
+    }
+
+    #[test]
+    fn test_mean() {
+        assert_eq!(mean(&[1.0, 2.0, 3.0, 4.0, 5.0]), 3.0);
+        assert_eq!(mean(&[]), 0.0);
+    }
+
+    #[test]
+    fn test_median() {
+        assert_eq!(median(&[1.0, 2.0, 3.0, 4.0, 5.0]), 3.0);
+        assert_eq!(median(&[1.0, 2.0, 3.0, 4.0]), 2.5);
+        assert_eq!(median(&[]), 0.0);
+    }
+
+    #[test]
+    fn test_variance() {
+        let data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
+        // Population variance
+        assert!((variance(&data, true) - 4.0).abs() < 1e-10);
+        // Sample variance
+        assert!((variance(&data, false) - 4.571428571).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_std_dev() {
+        let data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
+        assert!((std_dev(&data, true) - 2.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_min_max_range() {
+        let data = [1.0, 5.0, 3.0, 9.0, 2.0];
+        assert_eq!(min(&data), 1.0);
+        assert_eq!(max(&data), 9.0);
+        assert_eq!(range(&data), 8.0);
+    }
+}