qualia_core_db/solvers/statistics/hypothesis/
nonparametric.rs1use super::super::distributions::{chi_squared, fisher_f};
8
9#[derive(Debug, Clone, Copy, PartialEq)]
11pub struct NonparametricResult {
12 pub statistic: f64,
13 pub p_value: f64,
14 pub dof: f64,
15}
16
17pub fn mcnemar(b: u64, c: u64) -> Option<NonparametricResult> {
22 let nb = b as f64;
23 let nc = c as f64;
24 if b + c == 0 {
25 return None;
26 }
27 let diff = (nb - nc).abs();
28 let stat = if diff >= 1.0 {
29 (diff - 1.0).powi(2) / (nb + nc)
30 } else {
31 0.0
32 };
33 Some(NonparametricResult {
34 statistic: stat,
35 p_value: chi_squared::upper_p(stat, 1.0),
36 dof: 1.0,
37 })
38}
39
40#[derive(Debug, Clone, Copy, PartialEq)]
42pub struct FriedmanResult {
43 pub chi_square: f64,
45 pub chi_p_value: f64,
47 pub df: f64,
48 pub iman_davenport_f: f64,
50 pub f_p_value: f64,
52}
53
54pub fn friedman(data: &[&[f64]]) -> Option<FriedmanResult> {
59 let n = data.len();
60 if n < 2 {
61 return None;
62 }
63 let k = data[0].len();
64 if k < 2 || data.iter().any(|b| b.len() != k) {
65 return None;
66 }
67
68 let mut rank_sum = vec![0.0; k];
71 let mut idx = vec![0usize; k];
72 let mut ranks = vec![0.0; k];
73 for block in data {
74 super::super::correlation::rank_into(block, &mut idx, &mut ranks)?;
75 for j in 0..k {
76 rank_sum[j] += ranks[j];
77 }
78 }
79 let mean_rank: Vec<f64> = rank_sum.iter().map(|&s| s / n as f64).collect();
80
81 let kf = k as f64;
82 let nf = n as f64;
83 let grand = (kf + 1.0) / 2.0;
85 let ss: f64 = mean_rank.iter().map(|&r| (r - grand).powi(2)).sum();
86 let chi = 12.0 * nf / (kf * (kf + 1.0)) * ss;
87 let df = kf - 1.0;
88 let chi_p = chi_squared::upper_p(chi, df);
89
90 let denom = nf * (kf - 1.0) - chi;
92 let (f_stat, f_p) = if denom.abs() > 1e-12 && (nf - 1.0) > 0.0 {
93 let f = (nf - 1.0) * chi / denom;
94 let df1 = kf - 1.0;
95 let df2 = (kf - 1.0) * (nf - 1.0);
96 let f_clamped = f.max(0.0);
97 (f_clamped, fisher_f::upper_p(f_clamped, df1, df2))
98 } else {
99 (f64::INFINITY, 0.0)
100 };
101
102 Some(FriedmanResult {
103 chi_square: chi,
104 chi_p_value: chi_p,
105 df,
106 iman_davenport_f: f_stat,
107 f_p_value: f_p,
108 })
109}
110
111#[derive(Debug, Clone, Copy, PartialEq)]
115pub struct MannWhitneyResult {
116 pub u: f64,
117 pub p_value: f64,
118 pub n1: usize,
119 pub n2: usize,
120}
121
122pub fn mann_whitney_u(x: &[f64], y: &[f64]) -> Option<MannWhitneyResult> {
124 let n1 = x.len();
125 let n2 = y.len();
126 if n1 == 0 || n2 == 0 {
127 return None;
128 }
129 let mut all = Vec::with_capacity(n1 + n2);
130 for &v in x {
131 all.push((v, 0));
132 }
133 for &v in y {
134 all.push((v, 1));
135 }
136 all.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
137 let mut rank_sum1 = 0.0;
138 let mut i = 0;
139 while i < all.len() {
140 let mut j = i;
141 while j < all.len() && (all[j].0 - all[i].0).abs() < 1e-12 {
142 j += 1;
143 }
144 let rank = (i + j) as f64 / 2.0 + 0.5; for k in i..j {
146 if all[k].1 == 0 {
147 rank_sum1 += rank;
148 }
149 }
150 i = j;
151 }
152 let u1 = rank_sum1 - (n1 as f64 * (n1 as f64 + 1.0) / 2.0);
153 let u2 = (n1 * n2) as f64 - u1;
154 let u = u1.min(u2);
155 let mu = (n1 * n2) as f64 / 2.0;
157 let sigma = ((n1 * n2) as f64 * (n1 + n2 + 1) as f64 / 12.0).sqrt();
158 let z = (u - mu) / sigma.max(1e-9);
159 let p = 2.0 * (1.0 - 0.5 * (1.0 + (z / (2.0f64.sqrt())).tanh())); Some(MannWhitneyResult {
161 u,
162 p_value: p.clamp(0.0, 1.0),
163 n1,
164 n2,
165 })
166}
167
168#[derive(Debug, Clone, Copy, PartialEq)]
171pub struct KolmogorovSmirnovResult {
172 pub d: f64,
173 pub p_value: f64,
174}
175
176pub fn ks_1sample(data: &[f64]) -> Option<KolmogorovSmirnovResult> {
178 if data.is_empty() {
179 return None;
180 }
181 let mut sorted = data.to_vec();
182 sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
183 let n = sorted.len() as f64;
184 let mut d = 0.0f64;
185 for (i, &x) in sorted.iter().enumerate() {
186 let cdf = x.clamp(0.0, 1.0);
187 let i_f = i as f64;
188 d = d.max(((i_f + 1.0) / n - cdf).abs());
189 d = d.max((cdf - i_f / n).abs());
190 }
191 let p = (-2.0 * n * d * d).exp().min(1.0);
193 Some(KolmogorovSmirnovResult { d, p_value: p })
194}
195
196#[cfg(test)]
197mod tests {
198 use super::*;
199
200 #[test]
201 fn mcnemar_detects_disagreement() {
202 let r = mcnemar(30, 5).unwrap();
204 assert_eq!(r.dof, 1.0);
205 assert!(r.statistic > 15.0);
206 assert!(r.p_value < 0.001);
207 let sym = mcnemar(20, 18).unwrap();
209 assert!(sym.p_value > 0.5);
210 assert!(mcnemar(0, 0).is_none());
211 }
212
213 #[test]
214 fn friedman_detects_a_consistent_ordering() {
215 let b1 = [1.0, 2.0, 3.0];
217 let b2 = [1.1, 2.2, 3.3];
218 let b3 = [0.9, 2.1, 3.1];
219 let b4 = [1.0, 2.5, 3.4];
220 let b5 = [1.2, 2.0, 3.0];
221 let r = friedman(&[&b1, &b2, &b3, &b4, &b5]).unwrap();
222 assert_eq!(r.df, 2.0);
223 assert!(r.chi_square > 6.0, "chi2 {}", r.chi_square);
224 assert!(r.chi_p_value < 0.05);
225 assert!(r.f_p_value < 0.05);
226 }
227
228 #[test]
229 fn friedman_no_difference_is_not_significant() {
230 let b1 = [1.0, 2.0, 3.0];
232 let b2 = [3.0, 1.0, 2.0];
233 let b3 = [2.0, 3.0, 1.0];
234 let r = friedman(&[&b1, &b2, &b3]).unwrap();
235 assert!(r.chi_p_value > 0.2, "p {}", r.chi_p_value);
236 }
237
238 #[test]
239 fn guards() {
240 assert!(friedman(&[&[1.0, 2.0][..]]).is_none()); let ragged: [&[f64]; 2] = [&[1.0, 2.0], &[1.0]];
242 assert!(friedman(&ragged).is_none());
243 }
244}