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

use super::*;

use crate::{measures::ZeroConcentratedDivergence, metrics::SymmetricDistance};

#[test]
fn test_private_quantile_unsized() -> Fallible<()> {
    let candidates = vec![0, 25, 50, 75, 100];
    let input_domain = VectorDomain::new(AtomDomain::default());

    let m_q75 = make_private_quantile(
        input_domain.clone(),
        SymmetricDistance,
        ZeroConcentratedDivergence,
        candidates.clone(),
        0.75,
        0.0,
    )?;
    assert_eq!(m_q75.invoke(&(0..100).collect())?, 75);
    // since scale is zero, no noise is added, so eta is 0
    assert_eq!(m_q75.map(&1)?, f64::INFINITY);

    let m_q75 = make_private_quantile(
        input_domain,
        SymmetricDistance,
        ZeroConcentratedDivergence,
        candidates.clone(),
        0.75,
        1.0,
    )?;
    assert!((50..100).contains(&m_q75.invoke(&(0..100).collect())?));
    // (d_in * alpha / scale * 2)^2 / 8 = (1 * (3 / 4) / 1 * 2)^2 / 8
    assert_eq!(m_q75.map(&1)?, 0.28125);
    Ok(())
}

#[test]
fn test_private_quantile_sized() -> Fallible<()> {
    let candidates = vec![0, 25, 50, 75, 100];
    let input_domain = VectorDomain::new(AtomDomain::default()).with_size(100);

    let m_q75 = make_private_quantile(
        input_domain.clone(),
        SymmetricDistance,
        ZeroConcentratedDivergence,
        candidates.clone(),
        0.75,
        0.0,
    )?;
    assert_eq!(m_q75.invoke(&(0..100).collect())?, 75);
    assert_eq!(m_q75.map(&2)?, f64::INFINITY);

    let m_q75_sized = make_private_quantile(
        input_domain.clone(),
        SymmetricDistance,
        ZeroConcentratedDivergence,
        candidates,
        0.75,
        1.0,
    )?;
    assert!((50..100).contains(&m_q75.invoke(&(0..100).collect())?));
    // (d_in / scale)^2 / 8 = (2 / 1)^2 / 8 = 1 / 2
    assert_eq!(m_q75_sized.map(&2)?, 0.5);
    Ok(())
}