| """Statistica appaiata: McNemar esatto, IC Newcombe (metodo 10) e Tango, Wilson, bootstrap a grappoli.""" |
| import math |
| import random |
|
|
| Z90 = 1.6448536269514722 |
| Z95 = 1.959963984540054 |
|
|
|
|
| def binom_two_sided(b, c): |
| """McNemar esatto a due code: binomiale(n=b+c, 1/2), p = min(1, 2*P(X<=min)).""" |
| n = b + c |
| if n == 0: |
| return 1.0 |
| k = min(b, c) |
| s = sum(math.comb(n, i) for i in range(k + 1)) / 2 ** n |
| return min(1.0, 2 * s) |
|
|
|
|
| def wilson(x, n, z=Z95): |
| if n == 0: |
| return (0.0, 1.0) |
| p = x / n |
| den = 1 + z * z / n |
| c = (p + z * z / (2 * n)) / den |
| h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / den |
| return (max(0.0, c - h), min(1.0, c + h)) |
|
|
|
|
| def paired_counts(x, y): |
| """x, y: liste 0/1 appaiate. a = entrambe giuste, b = x giusta y sbagliata, c = x sbagliata y giusta, d.""" |
| a = sum(1 for i, j in zip(x, y) if i and j) |
| b = sum(1 for i, j in zip(x, y) if i and not j) |
| c = sum(1 for i, j in zip(x, y) if not i and j) |
| d = sum(1 for i, j in zip(x, y) if not i and not j) |
| return a, b, c, d |
|
|
|
|
| def newcombe10(a, b, c, d, z=Z90): |
| """Newcombe (1998) metodo 10, differenza p1 - p2 con p1 = (a+b)/n, p2 = (a+c)/n.""" |
| n = a + b + c + d |
| p1, p2 = (a + b) / n, (a + c) / n |
| l1, u1 = wilson(a + b, n, z) |
| l2, u2 = wilson(a + c, n, z) |
| num = a * d - b * c |
| if num > 0: |
| num = max(num - n / 2, 0) |
| den = (a + b) * (c + d) * (a + c) * (b + d) |
| phi = num / math.sqrt(den) if den > 0 else 0.0 |
| th = p1 - p2 |
| dl = math.sqrt(max(0.0, (p1 - l1) ** 2 - 2 * phi * (p1 - l1) * (u2 - p2) + (u2 - p2) ** 2)) |
| du = math.sqrt(max(0.0, (u1 - p1) ** 2 - 2 * phi * (u1 - p1) * (p2 - l2) + (p2 - l2) ** 2)) |
| return th, th - dl, th + du |
|
|
|
|
| def _tango_z(b, c, n, delta): |
| """Statistica score di Tango (1998) per Δ = (b - c)/n; p21 vincolata stimata per massima verosimiglianza.""" |
| |
| lo = max(0.0, -delta) + 1e-12 |
| hi = (1 - delta) / 2 - 1e-12 |
| if hi <= lo: |
| return float("inf") if (b - c - n * delta) > 0 else float("-inf") |
| rest = n - b - c |
|
|
| def ll(q): |
| v = 0.0 |
| if b: |
| v += b * math.log(q + delta) |
| if c: |
| v += c * math.log(q) |
| if rest: |
| v += rest * math.log(max(1e-300, 1 - 2 * q - delta)) |
| return v |
| |
| g = (math.sqrt(5) - 1) / 2 |
| x1, x2 = hi - g * (hi - lo), lo + g * (hi - lo) |
| f1, f2 = ll(x1), ll(x2) |
| for _ in range(200): |
| if f1 < f2: |
| lo, x1, f1 = x1, x2, f2 |
| x2 = lo + g * (hi - lo) |
| f2 = ll(x2) |
| else: |
| hi, x2, f2 = x2, x1, f1 |
| x1 = hi - g * (hi - lo) |
| f1 = ll(x1) |
| q = (lo + hi) / 2 |
| var = n * (2 * q + delta - delta * delta) |
| if var <= 0: |
| var = 1e-12 |
| return (b - c - n * delta) / math.sqrt(var) |
|
|
|
|
| def tango(a, b, c, d, z=Z90): |
| n = a + b + c + d |
| th = (b - c) / n |
|
|
| def root(lo, hi, target): |
| |
| for _ in range(100): |
| m = (lo + hi) / 2 |
| if _tango_z(b, c, n, m) > target: |
| lo = m |
| else: |
| hi = m |
| return (lo + hi) / 2 |
| low = root(-0.999999, th, z) if th > -0.999999 else -1.0 |
| up = root(th, 0.999999, -z) if th < 0.999999 else 1.0 |
| return th, low, up |
|
|
|
|
| def ni_verdict(lower, margin=0.05): |
| return "dimostrata" if lower > -margin else "non dimostrata" |
|
|
|
|
| def cluster_bootstrap(pairs_by_cluster, B=10000, seed=20261017): |
| """pairs_by_cluster: {cluster: [(x, y), ...]}. Restituisce la distribuzione della differenza p_x - p_y.""" |
| rng = random.Random(seed) |
| keys = list(pairs_by_cluster) |
| out = [] |
| for _ in range(B): |
| sx = sy = n = 0 |
| for _k in range(len(keys)): |
| for x, y in pairs_by_cluster[keys[rng.randrange(len(keys))]]: |
| sx += x |
| sy += y |
| n += 1 |
| out.append((sx - sy) / n) |
| out.sort() |
| return out |
|
|
|
|
| def pct(sorted_vals, q): |
| i = q * (len(sorted_vals) - 1) |
| lo, hi = math.floor(i), math.ceil(i) |
| return sorted_vals[lo] + (sorted_vals[hi] - sorted_vals[lo]) * (i - lo) |
|
|
