opendp 0.15.0

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

use super::*;
use crate::error::ErrorVariant;

#[test]
fn test_binary_search() -> Fallible<()> {
    assert_eq!(binary_search::<i32>(|x| *x <= -5, None)?, -5);
    assert_eq!(binary_search::<i32>(|x| *x <= 5, None)?, 5);
    assert_eq!(binary_search::<i32>(|x| *x >= -5, None)?, -5);
    assert_eq!(binary_search::<i32>(|x| *x >= 5, None)?, 5);
    Ok(())
}

#[test]
fn test_binary_search_sorts_bounds() -> Fallible<()> {
    assert_eq!(binary_search(|x: &i32| *x > 5, Some((10, 0)))?, 6);
    assert_eq!(binary_search(|x: &i32| *x < 5, Some((10, 0)))?, 4);
    Ok(())
}

#[test]
fn test_signed_binary_search_reports_direction() -> Fallible<()> {
    assert_eq!(
        signed_binary_search(|x: &i32| *x >= 5, Some((0, 10)))?,
        (5, 1)
    );
    assert_eq!(
        signed_binary_search(|x: &i32| *x <= 5, Some((0, 10)))?,
        (5, -1)
    );
    Ok(())
}

#[test]
fn test_exponential_bounds_search_bands() {
    assert_eq!(
        exponential_bounds_search::<i32>(&|x| *x > 5),
        Some((1, 65_536))
    );
    assert_eq!(
        exponential_bounds_search::<f64>(&|x| *x > 5.0),
        Some((2.0, 16.0))
    );
}

#[test]
fn test_fallible_binary_search_recovers_from_exception_boundary() -> Fallible<()> {
    let discovered = fallible_binary_search::<i32>(
        |x| {
            if *x <= 0 {
                return fallible!(FailedFunction, "x must be positive");
            }
            Ok(*x >= 5)
        },
        None,
    )?;

    assert_eq!(discovered, 5);
    Ok(())
}

#[test]
fn test_binary_search_handles_full_signed_ranges() -> Fallible<()> {
    assert_eq!(
        binary_search(|x: &i32| *x >= 0, Some((i32::MIN, i32::MAX)))?,
        0
    );
    assert_eq!(
        binary_search(|x: &i8| *x <= 0, Some((i8::MIN, i8::MAX)))?,
        0
    );
    Ok(())
}

#[test]
fn test_binary_search_uses_search_error_variant() {
    let err = binary_search(|x: &i32| *x < 0, Some((0, 10))).unwrap_err();
    assert_eq!(err.variant, ErrorVariant::Search);
    assert_eq!(
        err.message.as_deref(),
        Some("the decision boundary of the predicate is outside the bounds")
    );
}