@ebowwa/quant-rust 0.1.0

package/src/utils/normalize.rs

@@ -0,0 +1,192 @@
+//! Normalization Module
+//!
+//! Functions for normalizing and scaling data
+
+use super::stats::{max, mean, min, std_dev};
+
+/// Min-max normalization (0-1 scale)
+///
+/// Returns 0.5 for all values if the range is zero.
+pub fn normalize_min_max(arr: &[f64]) -> Vec<f64> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    let min_val = min(arr);
+    let max_val = max(arr);
+    let range_val = max_val - min_val;
+
+    if range_val == 0.0 {
+        return vec![0.5; arr.len()];
+    }
+
+    arr.iter().map(|&v| (v - min_val) / range_val).collect()
+}
+
+/// Z-score normalization (standardization)
+///
+/// Returns 0 for all values if the standard deviation is zero.
+pub fn normalize_z_score(arr: &[f64]) -> Vec<f64> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    let avg = mean(arr);
+    let sd = std_dev(arr, true);
+
+    if sd == 0.0 {
+        return vec![0.0; arr.len()];
+    }
+
+    arr.iter().map(|&v| (v - avg) / sd).collect()
+}
+
+/// Percentage change from first element
+///
+/// Returns an empty vector if the array is empty or the first element is zero.
+pub fn percent_change(arr: &[f64]) -> Vec<f64> {
+    if arr.is_empty() || arr[0] == 0.0 {
+        return Vec::new();
+    }
+
+    let base = arr[0];
+    arr.iter().map(|&v| ((v - base) / base) * 100.0).collect()
+}
+
+/// Normalize to a specific range [new_min, new_max]
+pub fn normalize_to_range(arr: &[f64], new_min: f64, new_max: f64) -> Vec<f64> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    let min_val = min(arr);
+    let max_val = max(arr);
+    let range_val = max_val - min_val;
+
+    if range_val == 0.0 {
+        return vec![(new_min + new_max) / 2.0; arr.len()];
+    }
+
+    let new_range = new_max - new_min;
+    arr.iter()
+        .map(|&v| ((v - min_val) / range_val) * new_range + new_min)
+        .collect()
+}
+
+/// Decimal scaling normalization
+///
+/// Divides by 10^j where j is the number of digits in the max absolute value.
+pub fn decimal_scale(arr: &[f64]) -> Vec<f64> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    let max_abs = arr
+        .iter()
+        .map(|&v| v.abs())
+        .fold(0.0_f64, f64::max);
+
+    if max_abs == 0.0 {
+        return arr.to_vec();
+    }
+
+    let j = max_abs.log10().ceil() as i32;
+    let scale = 10_f64.powi(j);
+
+    arr.iter().map(|&v| v / scale).collect()
+}
+
+/// Robust scaling using median and IQR
+///
+/// Centers by median and scales by IQR. Good for data with outliers.
+pub fn robust_scale(arr: &[f64]) -> Vec<f64> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    use super::quantiles::iqr;
+    use super::stats::median;
+
+    let med = median(arr);
+    let iqr_val = iqr(arr);
+
+    if iqr_val == 0.0 {
+        return vec![0.0; arr.len()];
+    }
+
+    arr.iter().map(|&v| (v - med) / iqr_val).collect()
+}
+
+/// Softmax normalization
+///
+/// Converts values to probabilities that sum to 1.
+pub fn softmax(arr: &[f64]) -> Vec<f64> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    // Subtract max for numerical stability
+    let max_val = max(arr);
+
+    let exp_sum: f64 = arr.iter().map(|&v| ((v - max_val).exp())).sum();
+
+    if exp_sum == 0.0 {
+        return vec![1.0 / arr.len() as f64; arr.len()];
+    }
+
+    arr.iter()
+        .map(|&v| ((v - max_val).exp()) / exp_sum)
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_min_max() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let result = normalize_min_max(&data);
+        assert_eq!(result, vec![0.0, 0.25, 0.5, 0.75, 1.0]);
+    }
+
+    #[test]
+    fn test_normalize_min_max_constant() {
+        let data = [5.0, 5.0, 5.0];
+        let result = normalize_min_max(&data);
+        assert_eq!(result, vec![0.5, 0.5, 0.5]);
+    }
+
+    #[test]
+    fn test_normalize_z_score() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let result = normalize_z_score(&data);
+        // Mean = 3, std_dev = sqrt(2) for population
+        assert!((result[2]).abs() < 1e-10); // middle element should be 0
+    }
+
+    #[test]
+    fn test_percent_change() {
+        let data = [100.0, 110.0, 120.0];
+        let result = percent_change(&data);
+        assert_eq!(result, vec![0.0, 10.0, 20.0]);
+    }
+
+    #[test]
+    fn test_normalize_to_range() {
+        let data = [0.0, 50.0, 100.0];
+        let result = normalize_to_range(&data, -1.0, 1.0);
+        assert_eq!(result, vec![-1.0, 0.0, 1.0]);
+    }
+
+    #[test]
+    fn test_softmax() {
+        let data = [1.0, 2.0, 3.0];
+        let result = softmax(&data);
+        let sum: f64 = result.iter().sum();
+        assert!((sum - 1.0).abs() < 1e-10);
+        // Largest value should have highest probability
+        assert!(result[2] > result[1]);
+        assert!(result[1] > result[0]);
+    }
+}

package/src/utils/price.rs

@@ -0,0 +1,167 @@
+//! Price Extraction Module
+//!
+//! Extract various price types from OHLCV data
+
+use crate::types::OHLCV;
+
+/// Extract close prices from OHLCV data
+pub fn extract_close(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push(d.close);
+    }
+    result
+}
+
+/// Extract open prices from OHLCV data
+pub fn extract_open(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push(d.open);
+    }
+    result
+}
+
+/// Extract high prices from OHLCV data
+pub fn extract_high(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push(d.high);
+    }
+    result
+}
+
+/// Extract low prices from OHLCV data
+pub fn extract_low(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push(d.low);
+    }
+    result
+}
+
+/// Extract volume from OHLCV data
+pub fn extract_volume(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push(d.volume);
+    }
+    result
+}
+
+/// Extract typical price (HLC/3)
+pub fn extract_typical_price(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push((d.high + d.low + d.close) / 3.0);
+    }
+    result
+}
+
+/// Extract weighted close price ((H + L + C*2)/4)
+pub fn extract_weighted_close(data: &[OHLCV]) -> Vec<f64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push((d.high + d.low + d.close * 2.0) / 4.0);
+    }
+    result
+}
+
+/// Extract timestamps from OHLCV data
+pub fn extract_timestamps(data: &[OHLCV]) -> Vec<i64> {
+    let mut result = Vec::with_capacity(data.len());
+    for d in data {
+        result.push(d.timestamp);
+    }
+    result
+}
+
+/// Extract all price components as separate arrays
+pub fn extract_ohlcv(data: &[OHLCV]) -> (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>) {
+    let len = data.len();
+    let mut opens = Vec::with_capacity(len);
+    let mut highs = Vec::with_capacity(len);
+    let mut lows = Vec::with_capacity(len);
+    let mut closes = Vec::with_capacity(len);
+    let mut volumes = Vec::with_capacity(len);
+
+    for d in data {
+        opens.push(d.open);
+        highs.push(d.high);
+        lows.push(d.low);
+        closes.push(d.close);
+        volumes.push(d.volume);
+    }
+
+    (opens, highs, lows, closes, volumes)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_test_data() -> Vec<OHLCV> {
+        vec![
+            OHLCV { timestamp: 1000, open: 10.0, high: 12.0, low: 9.0, close: 11.0, volume: 1000.0 },
+            OHLCV { timestamp: 2000, open: 11.0, high: 13.0, low: 10.0, close: 12.0, volume: 1500.0 },
+            OHLCV { timestamp: 3000, open: 12.0, high: 14.0, low: 11.0, close: 13.0, volume: 2000.0 },
+        ]
+    }
+
+    #[test]
+    fn test_extract_close() {
+        let data = create_test_data();
+        assert_eq!(extract_close(&data), vec![11.0, 12.0, 13.0]);
+    }
+
+    #[test]
+    fn test_extract_open() {
+        let data = create_test_data();
+        assert_eq!(extract_open(&data), vec![10.0, 11.0, 12.0]);
+    }
+
+    #[test]
+    fn test_extract_high() {
+        let data = create_test_data();
+        assert_eq!(extract_high(&data), vec![12.0, 13.0, 14.0]);
+    }
+
+    #[test]
+    fn test_extract_low() {
+        let data = create_test_data();
+        assert_eq!(extract_low(&data), vec![9.0, 10.0, 11.0]);
+    }
+
+    #[test]
+    fn test_extract_volume() {
+        let data = create_test_data();
+        assert_eq!(extract_volume(&data), vec![1000.0, 1500.0, 2000.0]);
+    }
+
+    #[test]
+    fn test_extract_typical_price() {
+        let data = create_test_data();
+        let result = extract_typical_price(&data);
+        // (12 + 9 + 11) / 3 = 10.666...
+        assert!((result[0] - 10.666666666666666).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_extract_weighted_close() {
+        let data = create_test_data();
+        let result = extract_weighted_close(&data);
+        // (12 + 9 + 11*2) / 4 = 10.75
+        assert!((result[0] - 10.75).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_extract_ohlcv() {
+        let data = create_test_data();
+        let (o, h, l, c, v) = extract_ohlcv(&data);
+        assert_eq!(o, vec![10.0, 11.0, 12.0]);
+        assert_eq!(h, vec![12.0, 13.0, 14.0]);
+        assert_eq!(l, vec![9.0, 10.0, 11.0]);
+        assert_eq!(c, vec![11.0, 12.0, 13.0]);
+        assert_eq!(v, vec![1000.0, 1500.0, 2000.0]);
+    }
+}

package/src/utils/quantiles.rs

@@ -0,0 +1,177 @@
+//! Quantile Calculations Module
+//!
+//! Functions for calculating quantiles, quartiles, and IQR
+
+/// Calculate a specific quantile (0.0 to 1.0)
+///
+/// Uses linear interpolation between values.
+pub fn quantile(arr: &[f64], q: f64) -> f64 {
+    if arr.is_empty() || q < 0.0 || q > 1.0 {
+        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 pos = (sorted.len() - 1) as f64 * q;
+    let base = pos.floor() as usize;
+    let rest = pos - base as f64;
+
+    if base + 1 < sorted.len() {
+        sorted[base] + rest * (sorted[base + 1] - sorted[base])
+    } else {
+        sorted[base]
+    }
+}
+
+/// Calculate quartiles (Q1, Q2/Median, Q3)
+///
+/// Returns a tuple of (q1, q2, q3).
+pub fn quartiles(arr: &[f64]) -> (f64, f64, f64) {
+    let q1 = quantile(arr, 0.25);
+    let q2 = quantile(arr, 0.50);
+    let q3 = quantile(arr, 0.75);
+    (q1, q2, q3)
+}
+
+/// Calculate interquartile range (Q3 - Q1)
+pub fn iqr(arr: &[f64]) -> f64 {
+    let (q1, _, q3) = quartiles(arr);
+    q3 - q1
+}
+
+/// Calculate percentiles (0-100)
+pub fn percentile(arr: &[f64], p: f64) -> f64 {
+    quantile(arr, p / 100.0)
+}
+
+/// Calculate all five-number summary: (min, q1, median, q3, max)
+pub fn five_number_summary(arr: &[f64]) -> (f64, f64, f64, f64, f64) {
+    use super::stats::{max, min};
+
+    let minimum = min(arr);
+    let (q1, median, q3) = quartiles(arr);
+    let maximum = max(arr);
+
+    (minimum, q1, median, q3, maximum)
+}
+
+/// Calculate deciles (10th, 20th, ..., 90th percentiles)
+///
+/// Returns a vector of 9 values.
+pub fn deciles(arr: &[f64]) -> Vec<f64> {
+    (1..=9).map(|i| quantile(arr, i as f64 / 10.0)).collect()
+}
+
+/// Detect outliers using the IQR method
+///
+/// Values below Q1 - 1.5*IQR or above Q3 + 1.5*IQR are considered outliers.
+/// Returns a vector of booleans where true indicates an outlier.
+pub fn detect_outliers_iqr(arr: &[f64]) -> Vec<bool> {
+    if arr.is_empty() {
+        return Vec::new();
+    }
+
+    let (q1, _, q3) = quartiles(arr);
+    let iqr_val = q3 - q1;
+    let lower_bound = q1 - 1.5 * iqr_val;
+    let upper_bound = q3 + 1.5 * iqr_val;
+
+    arr.iter().map(|&v| v < lower_bound || v > upper_bound).collect()
+}
+
+/// Remove outliers using the IQR method
+///
+/// Returns a new vector with outliers removed.
+pub fn remove_outliers_iqr(arr: &[f64]) -> Vec<f64> {
+    let outliers = detect_outliers_iqr(arr);
+    arr.iter()
+        .zip(outliers.iter())
+        .filter_map(|(&v, &is_outlier)| {
+            if is_outlier {
+                None
+            } else {
+                Some(v)
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quantile() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+
+        // Q1 (25th percentile)
+        assert!((quantile(&data, 0.25) - 2.0).abs() < 1e-10);
+        // Median (50th percentile)
+        assert!((quantile(&data, 0.50) - 3.0).abs() < 1e-10);
+        // Q3 (75th percentile)
+        assert!((quantile(&data, 0.75) - 4.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_quartiles() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        let (q1, q2, q3) = quartiles(&data);
+
+        assert!((q1 - 2.75).abs() < 1e-10);
+        assert!((q2 - 4.5).abs() < 1e-10);
+        assert!((q3 - 6.25).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_iqr() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        let iqr_val = iqr(&data);
+        // IQR = Q3 - Q1 = 6.25 - 2.75 = 3.5
+        assert!((iqr_val - 3.5).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_percentile() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        assert!((percentile(&data, 50.0) - 3.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_five_number_summary() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let (min, q1, med, q3, max) = five_number_summary(&data);
+
+        assert_eq!(min, 1.0);
+        assert_eq!(max, 5.0);
+        assert!((med - 3.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_deciles() {
+        let data: Vec<f64> = (1..=100).map(|i| i as f64).collect();
+        let decs = deciles(&data);
+
+        assert_eq!(decs.len(), 9);
+        // 10th percentile should be around 10.9
+        assert!((decs[0] - 10.9).abs() < 0.1);
+        // 90th percentile should be around 90.1
+        assert!((decs[8] - 90.1).abs() < 0.1);
+    }
+
+    #[test]
+    fn test_detect_outliers_iqr() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0, 100.0]; // 100 is an outlier
+        let outliers = detect_outliers_iqr(&data);
+
+        assert!(!outliers[0]); // 1.0 is not an outlier
+        assert!(outliers[5]); // 100.0 is an outlier
+    }
+
+    #[test]
+    fn test_empty_array() {
+        let data: [f64; 0] = [];
+        assert_eq!(quantile(&data, 0.5), 0.0);
+        assert_eq!(iqr(&data), 0.0);
+    }
+}

package/src/utils/returns.rs

@@ -0,0 +1,158 @@
+//! Returns Calculations Module
+//!
+//! Functions for calculating and converting returns
+
+/// Calculate simple returns (P1 - P0) / P0
+///
+/// Returns an empty vector if prices has fewer than 2 elements.
+pub fn simple_returns(prices: &[f64]) -> Vec<f64> {
+    if prices.len() < 2 {
+        return Vec::new();
+    }
+
+    let mut result = Vec::with_capacity(prices.len() - 1);
+    for i in 1..prices.len() {
+        if prices[i - 1] != 0.0 {
+            result.push((prices[i] - prices[i - 1]) / prices[i - 1]);
+        } else {
+            result.push(f64::NAN);
+        }
+    }
+    result
+}
+
+/// Calculate log returns ln(P1 / P0)
+///
+/// Returns an empty vector if prices has fewer than 2 elements.
+pub fn log_returns(prices: &[f64]) -> Vec<f64> {
+    if prices.len() < 2 {
+        return Vec::new();
+    }
+
+    let mut result = Vec::with_capacity(prices.len() - 1);
+    for i in 1..prices.len() {
+        if prices[i - 1] > 0.0 && prices[i] > 0.0 {
+            result.push((prices[i] / prices[i - 1]).ln());
+        } else {
+            result.push(f64::NAN);
+        }
+    }
+    result
+}
+
+/// Convert returns to prices from an initial price
+pub fn returns_to_prices(initial: f64, returns: &[f64]) -> Vec<f64> {
+    let mut prices = Vec::with_capacity(returns.len() + 1);
+    prices.push(initial);
+
+    for &ret in returns {
+        let last = prices.last().unwrap_or(&initial);
+        prices.push(last * (1.0 + ret));
+    }
+
+    prices
+}
+
+/// Calculate cumulative returns
+///
+/// Returns a vector where the first element is 0 (no return yet),
+/// and each subsequent element is the cumulative return up to that point.
+pub fn cumulative_returns(returns: &[f64]) -> Vec<f64> {
+    let mut cum_ret = Vec::with_capacity(returns.len() + 1);
+    cum_ret.push(0.0);
+
+    let mut cumulative = 1.0;
+    for &ret in returns {
+        cumulative *= 1.0 + ret;
+        cum_ret.push(cumulative - 1.0);
+    }
+
+    cum_ret
+}
+
+/// Calculate absolute returns (price differences)
+pub fn absolute_returns(prices: &[f64]) -> Vec<f64> {
+    if prices.len() < 2 {
+        return Vec::new();
+    }
+
+    let mut result = Vec::with_capacity(prices.len() - 1);
+    for i in 1..prices.len() {
+        result.push(prices[i] - prices[i - 1]);
+    }
+    result
+}
+
+/// Annualize returns
+///
+/// Given a periodic return and the number of periods per year,
+/// calculate the annualized return.
+pub fn annualize_return(periodic_return: f64, periods_per_year: f64) -> f64 {
+    (1.0 + periodic_return).powf(periods_per_year) - 1.0
+}
+
+/// De-annualize returns
+///
+/// Convert an annual return to a periodic return.
+pub fn deannualize_return(annual_return: f64, periods_per_year: f64) -> f64 {
+    (1.0 + annual_return).powf(1.0 / periods_per_year) - 1.0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_simple_returns() {
+        let prices = [100.0, 110.0, 121.0, 133.1];
+        let returns = simple_returns(&prices);
+        assert_eq!(returns.len(), 3);
+        assert!((returns[0] - 0.10).abs() < 1e-10);
+        assert!((returns[1] - 0.10).abs() < 1e-10);
+        assert!((returns[2] - 0.10).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_log_returns() {
+        let prices = [100.0, 110.0];
+        let returns = log_returns(&prices);
+        assert_eq!(returns.len(), 1);
+        // ln(110/100) = ln(1.1) ~ 0.0953
+        assert!((returns[0] - 0.09531017980432493).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_returns_to_prices() {
+        let returns = [0.10, 0.10, 0.10];
+        let prices = returns_to_prices(100.0, &returns);
+        let expected = vec![100.0, 110.0, 121.0, 133.1];
+        assert_eq!(prices.len(), expected.len());
+        for (a, b) in prices.iter().zip(expected.iter()) {
+            assert!((a - b).abs() < 1e-9, "Expected {}, got {}", b, a);
+        }
+    }
+
+    #[test]
+    fn test_cumulative_returns() {
+        let returns = [0.10, 0.10, 0.10];
+        let cum = cumulative_returns(&returns);
+        assert_eq!(cum[0], 0.0);
+        // After 3x 10% gains: (1.1)^3 - 1 = 0.331
+        assert!((cum[3] - 0.331).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_empty_returns() {
+        assert!(simple_returns(&[100.0]).is_empty());
+        assert!(log_returns(&[100.0]).is_empty());
+    }
+
+    #[test]
+    fn test_annualize_return() {
+        // 1% monthly return annualized
+        let monthly = 0.01;
+        let annual = annualize_return(monthly, 12.0);
+        // (1.01)^12 - 1 ~ 0.1268
+        assert!((annual - 0.12682503013196972).abs() < 1e-10);
+    }
+}