@ebowwa/quant-rust 0.1.0

package/src/stats/hypothesis.rs

@@ -0,0 +1,177 @@
+//! Hypothesis Testing Module
+//!
+//! Statistical hypothesis testing including t-tests and ADF test
+
+use serde::{Deserialize, Serialize};
+use crate::utils::{mean, variance, std_dev};
+use super::regression::linear_regression;
+use super::cdf::{normal_cdf, t_cdf};
+
+/// T-test result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TTestResult {
+    /// T-statistic
+    pub t_statistic: f64,
+    /// P-value (two-tailed)
+    pub p_value: f64,
+    /// Degrees of freedom
+    pub df: f64,
+}
+
+/// Augmented Dickey-Fuller test result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ADFResult {
+    /// Test statistic
+    pub t_statistic: f64,
+    /// Critical value (5% level)
+    pub critical_value: f64,
+    /// Whether the series is stationary
+    pub is_stationary: bool,
+}
+
+/// One-sample t-test
+pub fn one_sample_t_test(sample: &[f64], mu: f64) -> TTestResult {
+    let n = sample.len();
+
+    if n < 2 {
+        return TTestResult {
+            t_statistic: 0.0,
+            p_value: 1.0,
+            df: 0.0,
+        };
+    }
+
+    let sample_mean = mean(sample);
+    let sample_sd = std_dev(sample, false);
+
+    let t = (sample_mean - mu) / (sample_sd / (n as f64).sqrt());
+    let p_value = 2.0 * (1.0 - normal_cdf(t.abs()));
+
+    TTestResult {
+        t_statistic: t,
+        p_value: p_value.clamp(0.0, 1.0),
+        df: (n - 1) as f64,
+    }
+}
+
+/// Two-sample t-test (independent, Welch's t-test)
+pub fn two_sample_t_test(sample1: &[f64], sample2: &[f64]) -> TTestResult {
+    let n1 = sample1.len();
+    let n2 = sample2.len();
+
+    if n1 < 2 || n2 < 2 {
+        return TTestResult {
+            t_statistic: 0.0,
+            p_value: 1.0,
+            df: 0.0,
+        };
+    }
+
+    let mean1 = mean(sample1);
+    let mean2 = mean(sample2);
+    let var1 = variance(sample1, false);
+    let var2 = variance(sample2, false);
+
+    // Welch's t-test (unequal variances)
+    let se = (var1 / n1 as f64 + var2 / n2 as f64).sqrt();
+    let t = if se > 0.0 { (mean1 - mean2) / se } else { 0.0 };
+
+    // Degrees of freedom (Welch-Satterthwaite)
+    let numer = (var1 / n1 as f64 + var2 / n2 as f64).powi(2);
+    let denom = (var1 / n1 as f64).powi(2) / (n1 - 1) as f64
+              + (var2 / n2 as f64).powi(2) / (n2 - 1) as f64;
+    let df = if denom > 0.0 { numer / denom } else { 0.0 };
+
+    let p_value = 2.0 * (1.0 - t_cdf(t.abs(), df));
+
+    TTestResult {
+        t_statistic: t,
+        p_value: p_value.clamp(0.0, 1.0),
+        df,
+    }
+}
+
+/// Augmented Dickey-Fuller test for stationarity (simplified)
+pub fn adf_test(series: &[f64]) -> ADFResult {
+    if series.len() < 3 {
+        return ADFResult {
+            t_statistic: 0.0,
+            critical_value: -2.86,
+            is_stationary: false,
+        };
+    }
+
+    // Simplified ADF: regress diff(y) on lag(y)
+    let n = series.len();
+    let dy: Vec<f64> = (1..n).map(|i| series[i] - series[i - 1]).collect();
+    let lag_y: Vec<f64> = series[..n - 1].to_vec();
+
+    let reg = linear_regression(&lag_y, &dy);
+
+    // Critical value approximation (for large n, 5% level)
+    let critical_value = -2.86;
+    let is_stationary = reg.slope < critical_value;
+
+    ADFResult {
+        t_statistic: reg.slope,
+        critical_value,
+        is_stationary,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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);
+        assert!(result.p_value < 1.0);
+        assert_eq!(result.df as usize, 4);
+    }
+
+    #[test]
+    fn test_two_sample_t_test() {
+        let sample1 = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let sample2 = [6.0, 7.0, 8.0, 9.0, 10.0];
+        let result = two_sample_t_test(&sample1, &sample2);
+
+        assert!(result.t_statistic < 0.0);
+        assert!(result.p_value < 0.05); // Should be significant
+    }
+
+    #[test]
+    fn test_two_sample_t_test_equal() {
+        let sample1 = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let sample2 = [1.0, 2.0, 3.0, 4.0, 5.0];
+        let result = two_sample_t_test(&sample1, &sample2);
+
+        assert!(result.t_statistic.abs() < 1e-10);
+        assert!(result.p_value > 0.99); // Should not be significant
+    }
+
+    #[test]
+    fn test_adf_test() {
+        // Random walk (non-stationary)
+        let mut rw = vec![0.0];
+        for i in 1..100 {
+            rw.push(rw[i - 1] + (rand_random() - 0.5));
+        }
+
+        // This is a simplified test - results depend on the series
+        let _result = adf_test(&rw);
+    }
+
+    // Simple random function for testing
+    fn rand_random() -> f64 {
+        use std::time::{SystemTime, UNIX_EPOCH};
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .subsec_nanos();
+        (nanos as f64 / 1_000_000_000.0).fract()
+    }
+}

package/src/stats/matrix.rs

@@ -0,0 +1,346 @@
+//! Matrix Operations Module
+//!
+//! Internal matrix operations for regression and correlation analysis
+
+/// Transpose a matrix
+pub fn transpose(m: &[Vec<f64>]) -> Vec<Vec<f64>> {
+    if m.is_empty() {
+        return Vec::new();
+    }
+
+    let rows = m.len();
+    let cols = m[0].len();
+
+    if cols == 0 {
+        return vec![Vec::new(); rows];
+    }
+
+    (0..cols)
+        .map(|j| (0..rows).map(|i| m[i][j]).collect())
+        .collect()
+}
+
+/// Matrix multiplication (A * B)
+pub fn matrix_multiply(a: &[Vec<f64>], b: &[Vec<f64>]) -> Vec<Vec<f64>> {
+    if a.is_empty() || b.is_empty() {
+        return Vec::new();
+    }
+
+    let a_rows = a.len();
+    let a_cols = a[0].len();
+    let b_rows = b.len();
+    let b_cols = b[0].len();
+
+    if a_cols != b_rows {
+        return Vec::new();
+    }
+
+    let mut result = vec![vec![0.0; b_cols]; a_rows];
+
+    for i in 0..a_rows {
+        for j in 0..b_cols {
+            let mut sum = 0.0;
+            for k in 0..a_cols {
+                sum += a[i][k] * b[k][j];
+            }
+            result[i][j] = sum;
+        }
+    }
+
+    result
+}
+
+/// Matrix-vector multiplication (M * v)
+pub fn matrix_vector_multiply(m: &[Vec<f64>], v: &[f64]) -> Vec<f64> {
+    if m.is_empty() || v.is_empty() {
+        return Vec::new();
+    }
+
+    let rows = m.len();
+    let cols = m[0].len();
+
+    if cols != v.len() {
+        return vec![0.0; rows];
+    }
+
+    (0..rows)
+        .map(|i| m[i].iter().zip(v.iter()).map(|(&m_val, &v_val)| m_val * v_val).sum())
+        .collect()
+}
+
+/// Matrix inverse using Gauss-Jordan elimination
+pub fn matrix_inverse(m: &[Vec<f64>]) -> Option<Vec<Vec<f64>>> {
+    if m.is_empty() {
+        return None;
+    }
+
+    let n = m.len();
+
+    // Check if square
+    for row in m {
+        if row.len() != n {
+            return None;
+        }
+    }
+
+    // Create augmented matrix [M | I]
+    let mut augmented: Vec<Vec<f64>> = m.iter()
+        .enumerate()
+        .map(|(i, row)| {
+            let mut aug_row = row.clone();
+            aug_row.extend((0..n).map(|j| if i == j { 1.0 } else { 0.0 }));
+            aug_row
+        })
+        .collect();
+
+    // Forward elimination with partial pivoting
+    for i in 0..n {
+        // Find pivot
+        let mut max_row = i;
+        for k in (i + 1)..n {
+            if augmented[k][i].abs() > augmented[max_row][i].abs() {
+                max_row = k;
+            }
+        }
+
+        // Swap rows
+        augmented.swap(i, max_row);
+
+        // Check for singularity
+        if augmented[i][i].abs() < 1e-10 {
+            return None;
+        }
+
+        // Scale pivot row
+        let pivot = augmented[i][i];
+        for j in 0..(2 * n) {
+            augmented[i][j] /= pivot;
+        }
+
+        // Eliminate column
+        for k in 0..n {
+            if k != i {
+                let factor = augmented[k][i];
+                for j in 0..(2 * n) {
+                    augmented[k][j] -= factor * augmented[i][j];
+                }
+            }
+        }
+    }
+
+    // Extract inverse from augmented matrix
+    Some(
+        augmented
+            .iter()
+            .map(|row| row[n..].to_vec())
+            .collect()
+    )
+}
+
+/// Calculate determinant using LU decomposition
+pub fn determinant(m: &[Vec<f64>]) -> f64 {
+    if m.is_empty() {
+        return 0.0;
+    }
+
+    let n = m.len();
+
+    // Check if square
+    for row in m {
+        if row.len() != n {
+            return 0.0;
+        }
+    }
+
+    // Create a copy
+    let mut lu: Vec<Vec<f64>> = m.to_vec();
+    let mut det = 1.0;
+
+    for i in 0..n {
+        // Find pivot
+        let mut max_row = i;
+        for k in (i + 1)..n {
+            if lu[k][i].abs() > lu[max_row][i].abs() {
+                max_row = k;
+            }
+        }
+
+        if max_row != i {
+            lu.swap(i, max_row);
+            det *= -1.0;
+        }
+
+        if lu[i][i].abs() < 1e-10 {
+            return 0.0;
+        }
+
+        det *= lu[i][i];
+
+        for k in (i + 1)..n {
+            let factor = lu[k][i] / lu[i][i];
+            for j in (i + 1)..n {
+                lu[k][j] -= factor * lu[i][j];
+            }
+        }
+    }
+
+    det
+}
+
+/// Solve linear system Ax = b using LU decomposition
+pub fn solve_linear_system(a: &[Vec<f64>], b: &[f64]) -> Option<Vec<f64>> {
+    if a.is_empty() || b.is_empty() {
+        return None;
+    }
+
+    let n = a.len();
+    if n != b.len() {
+        return None;
+    }
+
+    // Check if square
+    for row in a {
+        if row.len() != n {
+            return None;
+        }
+    }
+
+    // Create augmented matrix [A | b]
+    let mut aug: Vec<Vec<f64>> = a.iter()
+        .zip(b.iter())
+        .map(|(row, &b_val)| {
+            let mut aug_row = row.clone();
+            aug_row.push(b_val);
+            aug_row
+        })
+        .collect();
+
+    // Forward elimination with partial pivoting
+    for i in 0..n {
+        // Find pivot
+        let mut max_row = i;
+        for k in (i + 1)..n {
+            if aug[k][i].abs() > aug[max_row][i].abs() {
+                max_row = k;
+            }
+        }
+
+        aug.swap(i, max_row);
+
+        if aug[i][i].abs() < 1e-10 {
+            return None;
+        }
+
+        // Eliminate
+        for k in (i + 1)..n {
+            let factor = aug[k][i] / aug[i][i];
+            for j in i..=n {
+                aug[k][j] -= factor * aug[i][j];
+            }
+        }
+    }
+
+    // Back substitution
+    let mut x = vec![0.0; n];
+    for i in (0..n).rev() {
+        let mut sum = aug[i][n];
+        for j in (i + 1)..n {
+            sum -= aug[i][j] * x[j];
+        }
+        x[i] = sum / aug[i][i];
+    }
+
+    Some(x)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_transpose() {
+        let m = vec![
+            vec![1.0, 2.0, 3.0],
+            vec![4.0, 5.0, 6.0],
+        ];
+        let t = transpose(&m);
+
+        assert_eq!(t.len(), 3);
+        assert_eq!(t[0], vec![1.0, 4.0]);
+        assert_eq!(t[1], vec![2.0, 5.0]);
+        assert_eq!(t[2], vec![3.0, 6.0]);
+    }
+
+    #[test]
+    fn test_matrix_multiply() {
+        let a = vec![
+            vec![1.0, 2.0],
+            vec![3.0, 4.0],
+        ];
+        let b = vec![
+            vec![5.0, 6.0],
+            vec![7.0, 8.0],
+        ];
+        let c = matrix_multiply(&a, &b);
+
+        assert_eq!(c, vec![
+            vec![19.0, 22.0],
+            vec![43.0, 50.0],
+        ]);
+    }
+
+    #[test]
+    fn test_matrix_vector_multiply() {
+        let m = vec![
+            vec![1.0, 2.0],
+            vec![3.0, 4.0],
+        ];
+        let v = vec![2.0, 3.0];
+        let result = matrix_vector_multiply(&m, &v);
+
+        assert_eq!(result, vec![8.0, 18.0]);
+    }
+
+    #[test]
+    fn test_matrix_inverse() {
+        let m = vec![
+            vec![4.0, 7.0],
+            vec![2.0, 6.0],
+        ];
+        let inv = matrix_inverse(&m).unwrap();
+
+        // Check that M * M^-1 = I
+        let product = matrix_multiply(&m, &inv);
+
+        assert!((product[0][0] - 1.0).abs() < 1e-10);
+        assert!(product[0][1].abs() < 1e-10);
+        assert!(product[1][0].abs() < 1e-10);
+        assert!((product[1][1] - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_determinant() {
+        let m = vec![
+            vec![1.0, 2.0],
+            vec![3.0, 4.0],
+        ];
+        let det = determinant(&m);
+
+        // det = 1*4 - 2*3 = -2
+        assert!((det - (-2.0)).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_solve_linear_system() {
+        let a = vec![
+            vec![2.0, 1.0],
+            vec![1.0, 3.0],
+        ];
+        let b = vec![5.0, 10.0];
+        let x = solve_linear_system(&a, &b).unwrap();
+
+        // 2x + y = 5, x + 3y = 10 => x = 1, y = 3
+        assert!((x[0] - 1.0).abs() < 1e-10);
+        assert!((x[1] - 3.0).abs() < 1e-10);
+    }
+}