@ebowwa/quant-rust 0.1.0

package/src/stats/cdf.rs

@@ -0,0 +1,257 @@
+//! Distribution Functions Module
+//!
+//! Cumulative distribution functions and special functions
+
+/// Standard normal CDF (approximation using error function)
+pub fn normal_cdf(x: f64) -> f64 {
+    // Abramowitz and Stegun approximation for error function
+    // Then converted to standard normal CDF
+    const A1: f64 = 0.254829592;
+    const A2: f64 = -0.284496736;
+    const A3: f64 = 1.421413741;
+    const A4: f64 = -1.453152027;
+    const A5: f64 = 1.061405429;
+    const P: f64 = 0.3275911;
+
+    let sign = if x < 0.0 { -1.0 } else { 1.0 };
+    let z = x.abs() / std::f64::consts::SQRT_2;
+
+    let t = 1.0 / (1.0 + P * z);
+    let erf = 1.0 - (((((A5 * t + A4) * t) + A3) * t + A2) * t + A1) * t * (-z * z).exp();
+
+    0.5 * (1.0 + sign * erf)
+}
+
+/// t-distribution CDF approximation
+pub fn t_cdf(t: f64, df: f64) -> f64 {
+    // Approximation: t -> normal as df -> infinity
+    if df > 100.0 {
+        return normal_cdf(t);
+    }
+
+    // Use incomplete beta function approximation
+    let x = df / (df + t * t);
+    1.0 - 0.5 * incomplete_beta(x, df / 2.0, 0.5)
+}
+
+/// Gamma function (Lanczos approximation)
+pub fn gamma(x: f64) -> f64 {
+    if x < 0.5 {
+        return std::f64::consts::PI
+            / (std::f64::consts::PI * x).sin()
+            / gamma(1.0 - x);
+    }
+
+    let x = x - 1.0;
+    let g = 7;
+    let c = [
+        0.99999999999980993,
+        676.5203681218851,
+        -1259.1392167224028,
+        771.32342877765313,
+        -176.61502916214059,
+        12.507343278686905,
+        -0.13857109526572012,
+        9.9843695780195716e-6,
+        1.5056327351493116e-7,
+    ];
+
+    let mut y = c[0];
+    for i in 1..g + 2 {
+        y += c[i] / (x + i as f64);
+    }
+
+    let t = x + g as f64 + 0.5;
+    (2.0 * std::f64::consts::PI).sqrt() * t.powf(x + 0.5) * (-t).exp() * y
+}
+
+/// Beta function
+pub fn beta(a: f64, b: f64) -> f64 {
+    gamma(a) * gamma(b) / gamma(a + b)
+}
+
+/// Incomplete beta function (simplified approximation)
+pub fn incomplete_beta(x: f64, a: f64, b: f64) -> f64 {
+    if x <= 0.0 {
+        return 0.0;
+    }
+    if x >= 1.0 {
+        return 1.0;
+    }
+
+    // Use continued fraction expansion for better accuracy
+    // This is a simplified version
+    let max_iterations = 100;
+    let epsilon = 1e-10;
+
+    // Front term
+    let front = x.powf(a) * (1.0 - x).powf(b) / (a * beta(a, b));
+
+    // Lentz's algorithm for continued fraction
+    let mut f = 1.0;
+    let mut c = 1.0;
+    let mut d = 1.0 - (a + b) * x / (a + 1.0);
+    if d.abs() < epsilon {
+        d = epsilon;
+    }
+    d = 1.0 / d;
+
+    for m in 1..max_iterations {
+        let m_f64 = m as f64;
+
+        // Even step
+        let mut numerator = m_f64 * (b - m_f64) * x / ((a + 2.0 * m_f64 - 1.0) * (a + 2.0 * m_f64));
+        d = 1.0 + numerator * d;
+        if d.abs() < epsilon {
+            d = epsilon;
+        }
+        d = 1.0 / d;
+        c = 1.0 + numerator / c;
+        if c.abs() < epsilon {
+            c = epsilon;
+        }
+        f *= c * d;
+
+        // Odd step
+        numerator = -(a + m_f64) * (a + b + m_f64) * x / ((a + 2.0 * m_f64) * (a + 2.0 * m_f64 + 1.0));
+        d = 1.0 + numerator * d;
+        if d.abs() < epsilon {
+            d = epsilon;
+        }
+        d = 1.0 / d;
+        c = 1.0 + numerator / c;
+        if c.abs() < epsilon {
+            c = epsilon;
+        }
+
+        let delta = c * d;
+        f *= delta;
+
+        if (delta - 1.0).abs() < epsilon {
+            break;
+        }
+    }
+
+    front * f
+}
+
+/// Chi-squared CDF (approximation using incomplete gamma)
+pub fn chi_squared_cdf(x: f64, df: f64) -> f64 {
+    if x <= 0.0 {
+        return 0.0;
+    }
+
+    let k = df / 2.0;
+    lower_incomplete_gamma(x / 2.0, k) / gamma(k)
+}
+
+/// Lower incomplete gamma function (simplified)
+fn lower_incomplete_gamma(x: f64, a: f64) -> f64 {
+    if x < 0.0 || a <= 0.0 {
+        return 0.0;
+    }
+
+    // Series expansion
+    let max_iterations = 200;
+    let epsilon = 1e-10;
+
+    if x < a + 1.0 {
+        // Use series representation
+        let mut sum = 1.0 / a;
+        let mut term = 1.0 / a;
+
+        for n in 1..max_iterations {
+            term *= x / (a + n as f64);
+            sum += term;
+            if term.abs() < sum.abs() * epsilon {
+                break;
+            }
+        }
+
+        sum * x.powf(a) * (-x).exp()
+    } else {
+        // Use continued fraction
+        let mut f = 1.0;
+        let mut c = 1.0;
+        let mut d = 1.0 / (1.0 + x - a);
+
+        if d.abs() < epsilon {
+            d = epsilon;
+        }
+        d = 1.0 / d;
+
+        for n in 1..max_iterations {
+            let n_f64 = n as f64;
+            let coef = n_f64 * (a - n_f64);
+
+            let numerator = (1.0 + 2.0 * n_f64) * (x - a) + coef;
+            d = 1.0 + numerator * d;
+            if d.abs() < epsilon {
+                d = epsilon;
+            }
+            d = 1.0 / d;
+
+            c = 1.0 + numerator / c;
+            if c.abs() < epsilon {
+                c = epsilon;
+            }
+
+            let delta = c * d;
+            f *= delta;
+
+            if (delta - 1.0).abs() < epsilon {
+                break;
+            }
+        }
+
+        gamma(a) - x.powf(a) * (-x).exp() * f
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normal_cdf() {
+        // Standard normal: P(Z < 0) = 0.5
+        // The approximation has slight numerical error, so we use 1e-9 tolerance
+        assert!((normal_cdf(0.0) - 0.5).abs() < 1e-9);
+
+        // P(Z < 1.96) ≈ 0.975
+        assert!((normal_cdf(1.96) - 0.975).abs() < 0.001);
+
+        // P(Z < -1.96) ≈ 0.025
+        assert!((normal_cdf(-1.96) - 0.025).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_gamma() {
+        // Gamma(1) = 1
+        assert!((gamma(1.0) - 1.0).abs() < 1e-10);
+
+        // Gamma(5) = 4! = 24
+        assert!((gamma(5.0) - 24.0).abs() < 1e-10);
+
+        // Gamma(0.5) = sqrt(pi)
+        assert!((gamma(0.5) - std::f64::consts::PI.sqrt()).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_beta() {
+        // Beta(1, 1) = 1
+        assert!((beta(1.0, 1.0) - 1.0).abs() < 1e-10);
+
+        // Beta(2, 2) = 1/6
+        assert!((beta(2.0, 2.0) - 1.0 / 6.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_t_cdf() {
+        // For large df, t_cdf should approach normal_cdf
+        let t = 1.0;
+        let t_cdf_val = t_cdf(t, 1000.0);
+        let normal_cdf_val = normal_cdf(t);
+        assert!((t_cdf_val - normal_cdf_val).abs() < 0.01);
+    }
+}

package/src/stats/correlation.rs

@@ -0,0 +1,225 @@
+//! Correlation Analysis Module
+//!
+//! Pearson and Spearman correlation with statistical significance testing
+
+use serde::{Deserialize, Serialize};
+use super::cdf::normal_cdf;
+use crate::utils::mean;
+
+/// Correlation result with statistical significance
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CorrelationResult {
+    /// Correlation coefficient
+    pub correlation: f64,
+    /// P-value (two-tailed)
+    pub p_value: f64,
+    /// Sample size
+    pub n: usize,
+}
+
+/// Calculate Pearson correlation coefficient
+pub fn pearson_correlation(x: &[f64], y: &[f64]) -> f64 {
+    if x.len() != y.len() || x.is_empty() {
+        return 0.0;
+    }
+
+    let n = x.len();
+    let mean_x = mean(x);
+    let mean_y = mean(y);
+
+    let mut sum_xy = 0.0;
+    let mut sum_x2 = 0.0;
+    let mut sum_y2 = 0.0;
+
+    for i in 0..n {
+        let dx = x[i] - mean_x;
+        let dy = y[i] - mean_y;
+        sum_xy += dx * dy;
+        sum_x2 += dx * dx;
+        sum_y2 += dy * dy;
+    }
+
+    let denominator = (sum_x2 * sum_y2).sqrt();
+    if denominator > 0.0 {
+        sum_xy / denominator
+    } else {
+        0.0
+    }
+}
+
+/// Calculate Spearman rank correlation
+pub fn spearman_correlation(x: &[f64], y: &[f64]) -> f64 {
+    if x.len() != y.len() || x.is_empty() {
+        return 0.0;
+    }
+
+    // Convert to ranks
+    let rank_x = ranks(x);
+    let rank_y = ranks(y);
+
+    pearson_correlation(&rank_x, &rank_y)
+}
+
+/// Convert array to ranks (handling ties)
+fn ranks(arr: &[f64]) -> Vec<f64> {
+    let n = arr.len();
+    let mut indexed: Vec<(usize, f64)> = arr.iter().cloned().enumerate().collect();
+    indexed.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+
+    let mut ranks = vec![0.0; n];
+    let mut i = 0;
+
+    while i < n {
+        let mut j = i;
+        // Find ties
+        while j < n - 1 && indexed[j].1 == indexed[j + 1].1 {
+            j += 1;
+        }
+        // Average rank for ties (1-based rank)
+        let avg_rank = (i + j) as f64 / 2.0 + 1.0;
+        for k in i..=j {
+            ranks[indexed[k].0] = avg_rank;
+        }
+        i = j + 1;
+    }
+
+    ranks
+}
+
+/// Correlation with p-value (t-test)
+pub fn correlation_with_p_value(x: &[f64], y: &[f64]) -> CorrelationResult {
+    let n = x.len();
+    if n < 3 {
+        return CorrelationResult {
+            correlation: 0.0,
+            p_value: 1.0,
+            n,
+        };
+    }
+
+    let r = pearson_correlation(x, y);
+
+    // t-statistic for correlation
+    let r_squared = r * r;
+    if r_squared >= 1.0 {
+        return CorrelationResult {
+            correlation: r,
+            p_value: if r.abs() >= 1.0 { 0.0 } else { 1.0 },
+            n,
+        };
+    }
+
+    let t = r * ((n - 2) as f64 / (1.0 - r_squared)).sqrt();
+
+    // Approximate p-value using normal approximation for large n
+    let p_value = 2.0 * (1.0 - normal_cdf(t.abs()));
+
+    CorrelationResult {
+        correlation: r,
+        p_value: p_value.clamp(0.0, 1.0),
+        n,
+    }
+}
+
+/// Calculate correlation matrix for multiple series
+pub fn correlation_matrix(data: &[Vec<f64>]) -> Vec<Vec<f64>> {
+    let n = data.len();
+    if n == 0 {
+        return Vec::new();
+    }
+
+    let mut matrix = vec![vec![0.0; n]; n];
+
+    for i in 0..n {
+        matrix[i][i] = 1.0;
+        for j in (i + 1)..n {
+            let corr = pearson_correlation(&data[i], &data[j]);
+            matrix[i][j] = corr;
+            matrix[j][i] = corr;
+        }
+    }
+
+    matrix
+}
+
+/// Calculate covariance
+pub fn covariance(x: &[f64], y: &[f64]) -> f64 {
+    if x.len() != y.len() || x.is_empty() {
+        return f64::NAN;
+    }
+
+    let n = x.len() as f64;
+    let mean_x = mean(x);
+    let mean_y = mean(y);
+
+    x.iter()
+        .zip(y.iter())
+        .map(|(&xi, &yi)| (xi - mean_x) * (yi - mean_y))
+        .sum::<f64>() / n
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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_pearson_correlation_negative() {
+        let x = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = [10.0, 8.0, 6.0, 4.0, 2.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_correlation_with_p_value() {
+        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 = correlation_with_p_value(&x, &y);
+
+        assert!((result.correlation - 1.0).abs() < 1e-10);
+        assert!(result.p_value < 0.05); // Highly significant
+        assert_eq!(result.n, 5);
+    }
+
+    #[test]
+    fn test_correlation_matrix() {
+        let data = vec![
+            vec![1.0, 2.0, 3.0],
+            vec![2.0, 4.0, 6.0],
+            vec![3.0, 2.0, 1.0],
+        ];
+        let matrix = correlation_matrix(&data);
+
+        assert_eq!(matrix.len(), 3);
+        // Perfect correlation between first two series
+        assert!((matrix[0][1] - 1.0).abs() < 1e-10);
+        // Diagonal should be 1
+        assert!((matrix[0][0] - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_ranks() {
+        let arr = [3.0, 1.0, 4.0, 1.0, 5.0];
+        let r = ranks(&arr);
+
+        // 1.0 appears at indices 1 and 3, should have rank 1.5 (avg of 1 and 2)
+        assert!((r[1] - 1.5).abs() < 1e-10);
+        assert!((r[3] - 1.5).abs() < 1e-10);
+    }
+}

package/src/stats/distribution.rs

@@ -0,0 +1,194 @@
+//! Distribution Statistics Module
+//!
+//! Comprehensive distribution statistics including moments, skewness, kurtosis
+
+use serde::{Deserialize, Serialize};
+use crate::utils::{mean, median, mode, variance, std_dev, min, max};
+use crate::utils::quantiles::{quartiles, iqr};
+
+/// Distribution statistics result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DistributionStats {
+    /// Mean (average)
+    pub mean: f64,
+    /// Median (50th percentile)
+    pub median: f64,
+    /// Mode (most frequent value)
+    pub mode: f64,
+    /// Standard deviation
+    pub std_dev: f64,
+    /// Variance
+    pub variance: f64,
+    /// Skewness (Pearson's moment coefficient)
+    pub skewness: f64,
+    /// Kurtosis (excess kurtosis, normal = 0)
+    pub kurtosis: f64,
+    /// Minimum value
+    pub min: f64,
+    /// Maximum value
+    pub max: f64,
+    /// Range (max - min)
+    pub range: f64,
+    /// First quartile (25th percentile)
+    pub q1: f64,
+    /// Second quartile / Median (50th percentile)
+    pub q2: f64,
+    /// Third quartile (75th percentile)
+    pub q3: f64,
+    /// Interquartile range (Q3 - Q1)
+    pub iqr: f64,
+}
+
+/// Moments of a distribution
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Moments {
+    /// First moment (mean)
+    pub mean: f64,
+    /// Second central moment (variance)
+    pub variance: f64,
+    /// Third standardized moment (skewness)
+    pub skewness: f64,
+    /// Fourth standardized moment (excess kurtosis)
+    pub kurtosis: f64,
+}
+
+/// Calculate comprehensive distribution statistics
+pub fn distribution_stats(data: &[f64]) -> DistributionStats {
+    if data.is_empty() {
+        return DistributionStats {
+            mean: 0.0,
+            median: 0.0,
+            mode: 0.0,
+            std_dev: 0.0,
+            variance: 0.0,
+            skewness: 0.0,
+            kurtosis: 0.0,
+            min: 0.0,
+            max: 0.0,
+            range: 0.0,
+            q1: 0.0,
+            q2: 0.0,
+            q3: 0.0,
+            iqr: 0.0,
+        };
+    }
+
+    let avg = mean(data);
+    let sd = std_dev(data, false);
+    let (q1, q2, q3) = quartiles(data);
+
+    // Calculate skewness (Pearson's moment coefficient)
+    let skewness = if sd > 0.0 {
+        let n = data.len() as f64;
+        data.iter()
+            .map(|v| ((v - avg) / sd).powi(3))
+            .sum::<f64>() / n
+    } else {
+        0.0
+    };
+
+    // Calculate kurtosis (excess kurtosis, normal = 0)
+    let kurtosis = if sd > 0.0 {
+        let n = data.len() as f64;
+        data.iter()
+            .map(|v| ((v - avg) / sd).powi(4))
+            .sum::<f64>() / n - 3.0 // Excess kurtosis
+    } else {
+        0.0
+    };
+
+    let min_val = min(data);
+    let max_val = max(data);
+
+    DistributionStats {
+        mean: avg,
+        median: median(data),
+        mode: mode(data),
+        std_dev: sd,
+        variance: variance(data, false),
+        skewness,
+        kurtosis,
+        min: min_val,
+        max: max_val,
+        range: max_val - min_val,
+        q1,
+        q2,
+        q3,
+        iqr: iqr(data),
+    }
+}
+
+/// Calculate moments of distribution
+pub fn moments(data: &[f64]) -> Moments {
+    if data.is_empty() {
+        return Moments {
+            mean: 0.0,
+            variance: 0.0,
+            skewness: 0.0,
+            kurtosis: 0.0,
+        };
+    }
+
+    let avg = mean(data);
+    let sd = std_dev(data, false);
+    let n = data.len() as f64;
+
+    let mut m2 = 0.0;
+    let mut m3 = 0.0;
+    let mut m4 = 0.0;
+
+    for &x in data {
+        let d = x - avg;
+        m2 += d * d;
+        m3 += d * d * d;
+        m4 += d * d * d * d;
+    }
+
+    m2 /= n;
+    m3 /= n;
+    m4 /= n;
+
+    Moments {
+        mean: avg,
+        variance: m2,
+        skewness: if sd > 0.0 { m3 / (sd * sd * sd) } else { 0.0 },
+        kurtosis: if sd > 0.0 { m4 / (m2 * m2) - 3.0 } else { 0.0 },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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);
+        assert!((stats.min - 1.0).abs() < 1e-10);
+        assert!((stats.max - 5.0).abs() < 1e-10);
+        assert!((stats.range - 4.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_moments() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let m = moments(&data);
+
+        assert!((m.mean - 3.0).abs() < 1e-10);
+        assert!(m.variance > 0.0);
+    }
+
+    #[test]
+    fn test_empty_data() {
+        let data: [f64; 0] = [];
+        let stats = distribution_stats(&data);
+        assert_eq!(stats.mean, 0.0);
+        assert_eq!(stats.median, 0.0);
+
+        let m = moments(&data);
+        assert_eq!(m.mean, 0.0);
+    }
+}