uncertain 0.3.1

Fast and correct computations with uncertain values.
Documentation 
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

use rand_distr::{Bernoulli, Binomial, Normal};
use uncertain::*;

#[test]
fn positive_pr() {
    let cases: Vec<f32> = vec![0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.89];
    for p in cases {
        let p_true = p + 0.1;
        let x = Distribution::from(Bernoulli::new(p_true.into()).unwrap());
        assert!(x.pr(p));
    }

    let cases: Vec<f32> = vec![0.1, 0.2, 0.3, 0.4, 0.5];
    for p in cases {
        let p_true_much_higher = p + 0.49;
        let x = Distribution::from(Bernoulli::new(p_true_much_higher.into()).unwrap());
        assert!(x.pr(p));
    }

    let cases: Vec<f32> = vec![0.1, 0.2, 0.3];
    for p in cases {
        let p_tru_way_higher = p + 0.6;
        let x = Distribution::from(Bernoulli::new(p_tru_way_higher.into()).unwrap());
        assert!(x.pr(p));
    }
}

#[test]
fn negative_pr() {
    let cases: Vec<f32> = vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7];
    for p in cases {
        let p_too_high = p + 0.1;
        let x = Distribution::from(Bernoulli::new(p.into()).unwrap());
        assert!(!x.pr(p_too_high));
    }

    let cases: Vec<f32> = vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7];
    for p in cases {
        let p_way_too_high = p + 0.2;
        let x = Distribution::from(Bernoulli::new(p.into()).unwrap());
        assert!(!x.pr(p_way_too_high));
    }

    let cases: Vec<f32> = vec![0.1, 0.2, 0.3, 0.4, 0.5];
    for p in cases {
        let p_very_way_too_high = p + 0.49;
        let x = Distribution::from(Bernoulli::new(p.into()).unwrap());
        assert!(!x.pr(p_very_way_too_high));
    }
}

#[test]
fn gaussian_pr() {
    let x = Distribution::from(Normal::new(5.0, 3.0).unwrap());
    let more_than_mean = x.map(|num| num > 5.0);

    assert!(more_than_mean.pr(0.1));
    assert!(more_than_mean.pr(0.2));
    assert!(more_than_mean.pr(0.3));
    assert!(more_than_mean.pr(0.4));

    assert!(!more_than_mean.pr(0.6));
    assert!(!more_than_mean.pr(0.7));
    assert!(!more_than_mean.pr(0.8));
    assert!(!more_than_mean.pr(0.9));
}

#[test]
fn very_certain() {
    let x = Distribution::from(Bernoulli::new(0.1).unwrap());
    assert!(x.pr(1e-5))
}

#[test]
fn not() {
    let x = Distribution::from(Bernoulli::new(0.7).unwrap());
    assert!(x.pr(0.2));
    assert!(x.pr(0.6));
    let not_x = x.not();
    assert!(not_x.pr(0.2));
    assert!(!not_x.pr(0.6));
}

#[test]
fn sampling_sanity_check() {
    let x = Distribution::from(Binomial::new(100, 0.5).unwrap()).into_ref();
    let diff = (&x).sub(&x);
    assert!(diff.map(|d| d == 0).pr(0.9999));
}