opendp 0.14.2-dev.20260401.2

A library of differential privacy algorithms for the statistical analysis of sensitive private data.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crate::traits::samplers::test::{
    ALPHA, BASE_N, assert_close_normal, run_wilson_test, sample_mean_bool,
};

use super::*;
use dashu::rbig;

pub const N_RATIONAL: usize = 2 * BASE_N;
pub const N_FLOAT: usize = 3 * BASE_N;

#[test]
fn bernoulli_rational_boundaries() -> Fallible<()> {
    assert!(!sample_bernoulli_rational(rbig!(0))?);
    assert!(sample_bernoulli_rational(rbig!(1))?);
    Ok(())
}

#[test]
fn bernoulli_rational_rejects_invalid_inputs() {
    assert!(sample_bernoulli_rational(rbig!(-1 / 2)).is_err());
    assert!(sample_bernoulli_rational(rbig!(3 / 2)).is_err());
}

#[test]
fn wilson_rational_fixed_points() {
    let ps = vec![
        rbig!(0 / 1),
        rbig!(1 / 16),
        rbig!(1 / 2),
        rbig!(15 / 16),
        rbig!(1 / 1),
    ];

    for p in ps {
        let p0 = p.to_f64().value();
        run_wilson_test(
            || sample_bernoulli_rational(p.clone()).unwrap(),
            p0,
            N_RATIONAL,
            ALPHA,
            "sample_bernoulli_rational",
        );
    }
}

fn run_wilson_test_float<T: Float>(p: T, constant_time: bool, n: usize, label: &str)
where
    T::Bits: ExactIntCast<usize>,
    usize: ExactIntCast<T::Bits>,
{
    run_wilson_test(
        || sample_bernoulli_float::<T>(p, constant_time).unwrap(),
        p.to_f64().unwrap(),
        n,
        ALPHA,
        label,
    );
}

#[test]
fn bernoulli_float_boundaries_f64() -> Fallible<()> {
    for _ in 0..20_000 {
        assert!(!sample_bernoulli_float::<f64>(0.0, false)?);
        assert!(!sample_bernoulli_float::<f64>(0.0, true)?);
        assert!(sample_bernoulli_float::<f64>(1.0, false)?);
        assert!(sample_bernoulli_float::<f64>(1.0, true)?);
    }
    Ok(())
}

const PROBS: [f64; 10] = [0.0, 0.5, 0.25, 0.125, 0.75, 0.1, 0.2, 0.3, 0.7, 0.99];

#[test]
fn wilson_float_f64_fixed_points() {
    for &p in &PROBS {
        run_wilson_test_float::<f64>(p, false, N_FLOAT, "bernoulli_float f64 non-constant-time");
        run_wilson_test_float::<f64>(p, true, N_FLOAT, "bernoulli_float f64 constant-time");
    }
}

#[test]
fn wilson_float_f32_fixed_points() {
    for &p in &PROBS {
        run_wilson_test_float::<f32>(
            p as f32,
            false,
            N_FLOAT / 2,
            "bernoulli_float f32 non-constant-time",
        );
        run_wilson_test_float::<f32>(
            p as f32,
            true,
            N_FLOAT / 2,
            "bernoulli_float f32 constant-time",
        );
    }
}

#[test]
fn bernoulli_float_constant_time_and_nonconstant_match_f64() {
    // Compare ct vs non-ct at same p via a mean-difference test
    for &p in &PROBS {
        let m_ct = sample_mean_bool(|| sample_bernoulli_float::<f64>(p, true).unwrap(), N_FLOAT);
        let m_nc = sample_mean_bool(|| sample_bernoulli_float::<f64>(p, false).unwrap(), N_FLOAT);

        // Under the null, both estimators target the same mean p, so
        // SE(diff) = sqrt(Var(hat1)+Var(hat2)) with Var(hat)=p(1-p)/N.
        let se_diff = (2.0 * p * (1.0 - p) / (N_FLOAT as f64)).sqrt();
        assert_close_normal(m_ct, m_nc, se_diff, "ct vs non-ct (f64)");
    }
}

#[test]
fn bernoulli_float_power_of_two_spot_checks_f64() {
    let ps: Vec<f64> = vec![0.5, 0.25, 0.125, 0.0625, 0.03125];
    for &p in &ps {
        run_wilson_test_float::<f64>(p, false, N_FLOAT, "dyadic f64 non-constant-time");
        run_wilson_test_float::<f64>(p, true, N_FLOAT, "dyadic f64 constant-time");
    }
}