@ebowwa/quant-rust 0.1.0

package/src/stats/mod.rs

@@ -0,0 +1,257 @@
+//! Statistical Analysis Module
+//!
+//! Provides statistical functions including correlation, regression, distributions, etc.
+
+mod cdf;
+mod correlation;
+mod distribution;
+mod hypothesis;
+mod matrix;
+mod regression;
+mod rolling;
+mod timeseries;
+
+// Re-export types
+pub use correlation::CorrelationResult;
+pub use distribution::{DistributionStats, Moments};
+pub use hypothesis::{ADFResult, TTestResult};
+pub use regression::{MultipleRegressionResult, RegressionResult};
+pub use rolling::{RollingRegressionResult, RollingStats};
+pub use timeseries::{DoubleExponentialResult, TripleExponentialResult};
+
+// Re-export existing functions (for backward compatibility)
+pub use correlation::{correlation_with_p_value, covariance, pearson_correlation, spearman_correlation, correlation_matrix};
+pub use cdf::{beta, gamma, incomplete_beta, normal_cdf, t_cdf};
+pub use distribution::{distribution_stats, moments};
+pub use hypothesis::{adf_test, one_sample_t_test, two_sample_t_test};
+pub use matrix::{determinant, matrix_inverse, matrix_multiply, matrix_vector_multiply, solve_linear_system, transpose};
+pub use regression::{linear_regression, multiple_regression};
+pub use rolling::{rolling_correlation, rolling_regression, rolling_stats, rolling_z_score};
+pub use timeseries::{
+    autocorrelation, double_exponential_smoothing, exponential_smoothing,
+    partial_autocorrelation, triple_exponential_smoothing,
+};
+
+// Legacy functions (for backward compatibility with existing lib.rs)
+use serde::{Deserialize, Serialize};
+
+/// Linear regression result (legacy format)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LegacyRegressionResult {
+    /// Slope (beta coefficient)
+    pub slope: f64,
+    /// Intercept (alpha)
+    pub intercept: f64,
+    /// R-squared (coefficient of determination)
+    pub r_squared: f64,
+    /// Standard error of the slope
+    pub std_error: f64,
+    /// Number of observations
+    pub n: usize,
+}
+
+/// Distribution statistics (legacy format)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LegacyDistributionStats {
+    /// Mean
+    pub mean: f64,
+    /// Median
+    pub median: f64,
+    /// Standard deviation
+    pub std_dev: f64,
+    /// Variance
+    pub variance: f64,
+    /// Skewness (asymmetry measure)
+    pub skewness: f64,
+    /// Kurtosis (tail heaviness, excess over normal)
+    pub kurtosis: f64,
+    /// Minimum value
+    pub min: f64,
+    /// Maximum value
+    pub max: f64,
+    /// Sample size
+    pub count: usize,
+}
+
+/// Autocorrelation result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AutocorrelationResult {
+    /// Lag values
+    pub lags: Vec<usize>,
+    /// Autocorrelation coefficients
+    pub autocorrelations: Vec<f64>,
+    /// Confidence level (typically 1.96 / sqrt(n) for 95%)
+    pub confidence_bound: f64,
+}
+
+/// Calculate Pearson correlation coefficient (legacy)
+pub fn correlation(x: &[f64], y: &[f64]) -> f64 {
+    pearson_correlation(x, y)
+}
+
+/// Perform linear regression (legacy format)
+pub fn linear_regression_legacy(x: &[f64], y: &[f64]) -> LegacyRegressionResult {
+    let result = linear_regression(x, y);
+    LegacyRegressionResult {
+        slope: result.slope,
+        intercept: result.intercept,
+        r_squared: result.r_squared,
+        std_error: result.standard_error,
+        n: result.predictions.len(),
+    }
+}
+
+/// Calculate comprehensive distribution statistics (legacy format)
+pub fn distribution_statistics(data: &[f64]) -> LegacyDistributionStats {
+    let stats = distribution_stats(data);
+    LegacyDistributionStats {
+        mean: stats.mean,
+        median: stats.median,
+        std_dev: stats.std_dev,
+        variance: stats.variance,
+        skewness: stats.skewness,
+        kurtosis: stats.kurtosis,
+        min: stats.min,
+        max: stats.max,
+        count: if data.is_empty() { 0 } else { data.len() },
+    }
+}
+
+/// Calculate autocorrelation function (legacy format)
+pub fn autocorrelation_legacy(data: &[f64], max_lag: usize) -> AutocorrelationResult {
+    if data.is_empty() || max_lag == 0 {
+        return AutocorrelationResult {
+            lags: vec![],
+            autocorrelations: vec![],
+            confidence_bound: 0.0,
+        };
+    }
+
+    let n = data.len();
+    let mean_val = crate::utils::mean(data);
+    let variance_val: f64 = data.iter()
+        .map(|x| (x - mean_val).powi(2))
+        .sum::<f64>() / n as f64;
+
+    if variance_val == 0.0 {
+        return AutocorrelationResult {
+            lags: (0..=max_lag).collect(),
+            autocorrelations: vec![0.0; max_lag + 1],
+            confidence_bound: 0.0,
+        };
+    }
+
+    let max_lag = max_lag.min(n - 1);
+    let lags: Vec<usize> = (0..=max_lag).collect();
+    let mut autocorrelations = Vec::with_capacity(max_lag + 1);
+
+    for &lag in &lags {
+        if lag == 0 {
+            autocorrelations.push(1.0);
+        } else {
+            let mut cov = 0.0;
+            for i in lag..n {
+                cov += (data[i] - mean_val) * (data[i - lag] - mean_val);
+            }
+            cov /= n as f64;
+            autocorrelations.push(cov / variance_val);
+        }
+    }
+
+    // 95% confidence bound
+    let confidence_bound = 1.96 / (n as f64).sqrt();
+
+    AutocorrelationResult {
+        lags,
+        autocorrelations,
+        confidence_bound,
+    }
+}
+
+/// Calculate percentile of a dataset
+pub fn percentile(data: &[f64], p: f64) -> f64 {
+    crate::utils::percentile(data, p)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_correlation() {
+        let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
+        let corr = correlation(&x, &y);
+        assert!((corr - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_linear_regression_legacy() {
+        let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
+        let result = linear_regression_legacy(&x, &y);
+        assert!((result.slope - 2.0).abs() < 1e-10);
+        assert!((result.intercept).abs() < 1e-10);
+        assert!((result.r_squared - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_distribution_stats_legacy() {
+        let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+        let stats = distribution_statistics(&data);
+        assert_eq!(stats.mean, 3.0);
+        assert_eq!(stats.median, 3.0);
+        assert_eq!(stats.min, 1.0);
+        assert_eq!(stats.max, 5.0);
+    }
+
+    #[test]
+    fn test_pearson_correlation() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [2.0, 4.0, 6.0, 8.0, 10.0];
+        let corr = pearson_correlation(&x, &y);
+        assert!((corr - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_spearman_correlation() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [2.0, 4.0, 6.0, 8.0, 10.0];
+        let corr = spearman_correlation(&x, &y);
+        assert!((corr - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_normal_cdf() {
+        // The approximation has slight numerical error, so we use 1e-9 tolerance
+        assert!((normal_cdf(0.0) - 0.5).abs() < 1e-9);
+    }
+
+    #[test]
+    fn test_gamma() {
+        assert!((gamma(5.0) - 24.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_distribution_stats() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let stats = distribution_stats(&data);
+        assert!((stats.mean - 3.0).abs() < 1e-10);
+        assert!((stats.median - 3.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_one_sample_t_test() {
+        let sample = [5.0, 5.5, 6.0, 6.5, 7.0];
+        let result = one_sample_t_test(&sample, 5.0);
+        assert!(result.t_statistic > 0.0);
+    }
+
+    #[test]
+    fn test_rolling_stats() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let stats = rolling_stats(&data, 3);
+        assert_eq!(stats.mean.len(), 3);
+        assert!((stats.mean[0] - 2.0).abs() < 1e-10);
+    }
+}

package/src/stats/regression.rs

@@ -0,0 +1,239 @@
+//! Regression Analysis Module
+//!
+//! Simple and multiple linear regression with statistical diagnostics
+
+use serde::{Deserialize, Serialize};
+use crate::utils::mean;
+use super::matrix::{transpose, matrix_multiply, matrix_vector_multiply, matrix_inverse};
+
+/// Simple linear regression result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RegressionResult {
+    /// Slope (beta coefficient)
+    pub slope: f64,
+    /// Intercept (alpha)
+    pub intercept: f64,
+    /// R-squared (coefficient of determination)
+    pub r_squared: f64,
+    /// Adjusted R-squared
+    pub adjusted_r_squared: f64,
+    /// Standard error of the estimate
+    pub standard_error: f64,
+    /// Predicted values
+    pub predictions: Vec<f64>,
+    /// Residuals (actual - predicted)
+    pub residuals: Vec<f64>,
+}
+
+/// Multiple regression result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MultipleRegressionResult {
+    /// Coefficients for each predictor
+    pub coefficients: Vec<f64>,
+    /// Intercept
+    pub intercept: f64,
+    /// R-squared
+    pub r_squared: f64,
+    /// Predicted values
+    pub predictions: Vec<f64>,
+    /// Residuals
+    pub residuals: Vec<f64>,
+}
+
+/// Perform simple linear regression (y = slope * x + intercept)
+pub fn linear_regression(x: &[f64], y: &[f64]) -> RegressionResult {
+    if x.len() != y.len() || x.len() < 2 {
+        return RegressionResult {
+            slope: 0.0,
+            intercept: 0.0,
+            r_squared: 0.0,
+            adjusted_r_squared: 0.0,
+            standard_error: 0.0,
+            predictions: Vec::new(),
+            residuals: Vec::new(),
+        };
+    }
+
+    let n = x.len();
+    let mean_x = mean(x);
+    let mean_y = mean(y);
+
+    // Calculate slope and intercept
+    let mut sum_xy = 0.0;
+    let mut sum_x2 = 0.0;
+
+    for i in 0..n {
+        sum_xy += (x[i] - mean_x) * (y[i] - mean_y);
+        sum_x2 += (x[i] - mean_x) * (x[i] - mean_x);
+    }
+
+    let slope = if sum_x2 > 0.0 { sum_xy / sum_x2 } else { 0.0 };
+    let intercept = mean_y - slope * mean_x;
+
+    // Calculate predictions and residuals
+    let predictions: Vec<f64> = x.iter().map(|&xi| slope * xi + intercept).collect();
+    let residuals: Vec<f64> = y.iter()
+        .zip(predictions.iter())
+        .map(|(&yi, &pred)| yi - pred)
+        .collect();
+
+    // R-squared
+    let ss_res: f64 = residuals.iter().map(|r| r * r).sum();
+    let ss_tot: f64 = y.iter().map(|yi| (yi - mean_y).powi(2)).sum();
+    let r_squared = if ss_tot > 0.0 { 1.0 - ss_res / ss_tot } else { 0.0 };
+
+    // Adjusted R-squared
+    let adjusted_r_squared = if n > 2 {
+        1.0 - ((1.0 - r_squared) * (n - 1) as f64) / (n - 2) as f64
+    } else {
+        r_squared
+    };
+
+    // Standard error of estimate
+    let standard_error = if n > 2 {
+        (ss_res / (n - 2) as f64).sqrt()
+    } else {
+        0.0
+    };
+
+    RegressionResult {
+        slope,
+        intercept,
+        r_squared,
+        adjusted_r_squared,
+        standard_error,
+        predictions,
+        residuals,
+    }
+}
+
+/// Perform multiple linear regression (OLS)
+pub fn multiple_regression(y: &[f64], x_matrix: &[Vec<f64>]) -> MultipleRegressionResult {
+    let n = y.len();
+    let k = x_matrix.len(); // Number of predictors
+
+    if n < k + 1 || k == 0 {
+        return MultipleRegressionResult {
+            coefficients: vec![0.0; k],
+            intercept: 0.0,
+            r_squared: 0.0,
+            predictions: Vec::new(),
+            residuals: Vec::new(),
+        };
+    }
+
+    // Add intercept term (column of 1s)
+    let mut x_design: Vec<Vec<f64>> = Vec::with_capacity(n);
+    for i in 0..n {
+        let mut row = vec![1.0];
+        for col in x_matrix {
+            row.push(col[i]);
+        }
+        x_design.push(row);
+    }
+
+    // Normal equations: (X'X)^(-1) X'y
+    let xt = transpose(&x_design);
+    let xtx = matrix_multiply(&xt, &x_design);
+
+    let xtx_inv = match matrix_inverse(&xtx) {
+        Some(inv) => inv,
+        None => {
+            return MultipleRegressionResult {
+                coefficients: vec![0.0; k],
+                intercept: 0.0,
+                r_squared: 0.0,
+                predictions: Vec::new(),
+                residuals: Vec::new(),
+            }
+        }
+    };
+
+    let xty = matrix_vector_multiply(&xt, y);
+    let beta = matrix_vector_multiply(&xtx_inv, &xty);
+
+    let intercept = beta[0];
+    let coefficients = beta[1..].to_vec();
+
+    // Predictions
+    let predictions: Vec<f64> = (0..n)
+        .map(|i| {
+            let mut pred = intercept;
+            for (j, coeff) in coefficients.iter().enumerate() {
+                pred += coeff * x_matrix[j][i];
+            }
+            pred
+        })
+        .collect();
+
+    // Residuals
+    let residuals: Vec<f64> = y.iter()
+        .zip(predictions.iter())
+        .map(|(&yi, &pred)| yi - pred)
+        .collect();
+
+    // R-squared
+    let mean_y = mean(y);
+    let ss_tot: f64 = y.iter().map(|yi| (yi - mean_y).powi(2)).sum();
+    let ss_res: f64 = residuals.iter().map(|r| r * r).sum();
+    let r_squared = if ss_tot > 0.0 { 1.0 - ss_res / ss_tot } else { 0.0 };
+
+    MultipleRegressionResult {
+        coefficients,
+        intercept,
+        r_squared,
+        predictions,
+        residuals,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_linear_regression() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [2.0, 4.0, 6.0, 8.0, 10.0];
+        let result = linear_regression(&x, &y);
+
+        assert!((result.slope - 2.0).abs() < 1e-10);
+        assert!(result.intercept.abs() < 1e-10);
+        assert!((result.r_squared - 1.0).abs() < 1e-10);
+        assert_eq!(result.predictions.len(), 5);
+        assert_eq!(result.residuals.len(), 5);
+    }
+
+    #[test]
+    fn test_linear_regression_with_intercept() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [3.0, 5.0, 7.0, 9.0, 11.0]; // y = 2x + 1
+        let result = linear_regression(&x, &y);
+
+        assert!((result.slope - 2.0).abs() < 1e-10);
+        assert!((result.intercept - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_multiple_regression() {
+        let y = [5.0, 7.0, 9.0, 11.0, 13.0]; // y = x1 + x2 + 2
+        let x1 = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let x2 = [2.0, 2.0, 2.0, 2.0, 2.0];
+        let x_matrix = vec![x1.to_vec(), x2.to_vec()];
+
+        let result = multiple_regression(&y, &x_matrix);
+
+        assert_eq!(result.coefficients.len(), 2);
+        assert!((result.intercept - 2.0).abs() < 1e-8 || result.intercept.abs() < 1e-8);
+    }
+
+    #[test]
+    fn test_empty_regression() {
+        let x: [f64; 0] = [];
+        let y: [f64; 0] = [];
+        let result = linear_regression(&x, &y);
+
+        assert_eq!(result.slope, 0.0);
+        assert!(result.predictions.is_empty());
+    }
+}

package/src/stats/rolling.rs

@@ -0,0 +1,193 @@
+//! Rolling Statistics Module
+//!
+//! Rolling window statistical calculations
+
+use serde::{Deserialize, Serialize};
+use crate::utils::{mean, std_dev, min, max};
+use super::correlation::pearson_correlation;
+use super::regression::linear_regression;
+
+/// Rolling statistics result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RollingStats {
+    /// Rolling mean
+    pub mean: Vec<f64>,
+    /// Rolling standard deviation
+    pub std_dev: Vec<f64>,
+    /// Rolling minimum
+    pub min: Vec<f64>,
+    /// Rolling maximum
+    pub max: Vec<f64>,
+}
+
+/// Rolling regression result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RollingRegressionResult {
+    /// Rolling slope
+    pub slope: Vec<f64>,
+    /// Rolling intercept
+    pub intercept: Vec<f64>,
+    /// Rolling R-squared
+    pub r_squared: Vec<f64>,
+}
+
+/// Calculate rolling statistics
+pub fn rolling_stats(data: &[f64], period: usize) -> RollingStats {
+    if data.len() < period || period == 0 {
+        return RollingStats {
+            mean: Vec::new(),
+            std_dev: Vec::new(),
+            min: Vec::new(),
+            max: Vec::new(),
+        };
+    }
+
+    let result_len = data.len() - period + 1;
+    let mut means = Vec::with_capacity(result_len);
+    let mut std_devs = Vec::with_capacity(result_len);
+    let mut mins = Vec::with_capacity(result_len);
+    let mut maxs = Vec::with_capacity(result_len);
+
+    for i in 0..result_len {
+        let slice = &data[i..i + period];
+        means.push(mean(slice));
+        std_devs.push(std_dev(slice, false));
+        mins.push(min(slice));
+        maxs.push(max(slice));
+    }
+
+    RollingStats {
+        mean: means,
+        std_dev: std_devs,
+        min: mins,
+        max: maxs,
+    }
+}
+
+/// Calculate rolling correlation between two series
+pub fn rolling_correlation(x: &[f64], y: &[f64], period: usize) -> Vec<f64> {
+    if x.len() != y.len() || x.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    let result_len = x.len() - period + 1;
+    let mut result = Vec::with_capacity(result_len);
+
+    for i in 0..result_len {
+        let x_slice = &x[i..i + period];
+        let y_slice = &y[i..i + period];
+        result.push(pearson_correlation(x_slice, y_slice));
+    }
+
+    result
+}
+
+/// Calculate rolling regression
+pub fn rolling_regression(x: &[f64], y: &[f64], period: usize) -> RollingRegressionResult {
+    if x.len() != y.len() || x.len() < period || period == 0 {
+        return RollingRegressionResult {
+            slope: Vec::new(),
+            intercept: Vec::new(),
+            r_squared: Vec::new(),
+        };
+    }
+
+    let result_len = x.len() - period + 1;
+    let mut slopes = Vec::with_capacity(result_len);
+    let mut intercepts = Vec::with_capacity(result_len);
+    let mut r_squareds = Vec::with_capacity(result_len);
+
+    for i in 0..result_len {
+        let x_slice = &x[i..i + period];
+        let y_slice = &y[i..i + period];
+        let reg = linear_regression(x_slice, y_slice);
+
+        slopes.push(reg.slope);
+        intercepts.push(reg.intercept);
+        r_squareds.push(reg.r_squared);
+    }
+
+    RollingRegressionResult {
+        slope: slopes,
+        intercept: intercepts,
+        r_squared: r_squareds,
+    }
+}
+
+/// Calculate rolling z-score
+pub fn rolling_z_score(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    let result_len = data.len() - period + 1;
+    let mut result = Vec::with_capacity(result_len);
+
+    for i in 0..result_len {
+        let slice = &data[i..i + period];
+        let avg = mean(slice);
+        let sd = std_dev(slice, false);
+
+        // Z-score of the last element in the window
+        let z = if sd > 0.0 {
+            (slice[period - 1] - avg) / sd
+        } else {
+            0.0
+        };
+        result.push(z);
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rolling_stats() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let stats = rolling_stats(&data, 3);
+
+        assert_eq!(stats.mean.len(), 3);
+        assert!((stats.mean[0] - 2.0).abs() < 1e-10);
+        assert!((stats.mean[1] - 3.0).abs() < 1e-10);
+        assert!((stats.mean[2] - 4.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_rolling_correlation() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [2.0, 4.0, 6.0, 8.0, 10.0];
+        let corr = rolling_correlation(&x, &y, 3);
+
+        assert_eq!(corr.len(), 3);
+        // All windows should have perfect correlation
+        for &c in &corr {
+            assert!((c - 1.0).abs() < 1e-10);
+        }
+    }
+
+    #[test]
+    fn test_rolling_regression() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [2.0, 4.0, 6.0, 8.0, 10.0];
+        let reg = rolling_regression(&x, &y, 3);
+
+        assert_eq!(reg.slope.len(), 3);
+        // All slopes should be 2
+        for &s in &reg.slope {
+            assert!((s - 2.0).abs() < 1e-10);
+        }
+    }
+
+    #[test]
+    fn test_rolling_z_score() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let z = rolling_z_score(&data, 3);
+
+        assert_eq!(z.len(), 3);
+        // Last window [3, 4, 5], mean=4, std_dev=1, last element z = (5-4)/1 = 1
+        assert!((z[2] - 1.0).abs() < 1e-10);
+    }
+}