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

use crate::domains::OptionDomain;

use super::*;

#[test]
fn test_series_new() -> Fallible<()> {
    let series_domain = SeriesDomain::new("A", AtomDomain::<bool>::default());
    assert!(series_domain == series_domain);

    let series = Series::new("A".into(), vec![true; 50]);
    assert!(series_domain.member(&series)?);
    Ok(())
}

#[test]
fn test_series_bounded() -> Fallible<()> {
    let series_domain = SeriesDomain::new("A", AtomDomain::new_closed((1, 3))?);

    let inside_bounds = Series::new("A".into(), vec![1; 50]);
    assert!(series_domain.member(&inside_bounds)?);

    let outside_bounds = Series::new("A".into(), vec![4; 50]);
    assert!(!series_domain.member(&outside_bounds)?);

    Ok(())
}

#[test]
fn test_series_non_nan() -> Fallible<()> {
    // option domain with non-nan type
    let series_domain = SeriesDomain::new("A", OptionDomain::new(AtomDomain::<bool>::default()));

    let series = Series::new("A".into(), vec![Some(true), Some(false), None]);
    assert!(series_domain.member(&series)?);

    Ok(())
}

#[test]
fn test_series_nan_without_option() -> Fallible<()> {
    // nan type without options
    let series_domain = SeriesDomain::new("A", AtomDomain::<f64>::default());

    let series_with_none = Series::new("A".into(), vec![Some(1.), Some(f64::NAN), None]);
    assert!(!series_domain.member(&series_with_none)?);

    // series made with Option::Some are ok
    let series_with_some = Series::new("A".into(), vec![Some(1.), Some(f64::NAN)]);
    assert!(series_domain.member(&series_with_some)?);

    // series made without options are ok
    let series_wo_some = Series::new("A".into(), vec![1., f64::NAN]);
    assert!(series_domain.member(&series_wo_some)?);

    Ok(())
}

#[test]
fn test_series_nan_with_option() -> Fallible<()> {
    // permit both kinds of nullity
    let series_domain = SeriesDomain::new("A", OptionDomain::new(AtomDomain::<f64>::default()));

    // None and NaN are both ok
    let series_with_none = Series::new("A".into(), vec![Some(1.), Some(f64::NAN), None]);
    assert!(series_domain.member(&series_with_none)?);

    // doesn't have to have NaN
    let series_wo_none = Series::new("A".into(), vec![1., 2.]);
    assert!(series_domain.member(&series_wo_none)?);

    Ok(())
}