sim-lib-numbers-stats 0.6.0

Statistical and probability helpers for the SIM number stack.
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
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
121
122
123
124
125
126

use super::*;

#[test]
fn sampler_replays_refuses_and_forks_independently() {
    let mut sampler = SeededSampler::with_max_words(7, 2);
    let first = sampler.try_next_u64().unwrap();
    let receipt = sampler.receipt();
    let second = sampler.try_next_u64().unwrap();
    assert_eq!(
        SeededSampler::replay(receipt).try_next_u64().unwrap(),
        second
    );
    assert!(matches!(
        sampler.try_next_u64(),
        Err(DesignError::WorkLimit {
            required: 3,
            limit: 2
        })
    ));
    let root = SeededSampler::new(7);
    let mut left = root.fork(1);
    let mut right = root.fork(2);
    assert_ne!(left.try_next_u64().unwrap(), right.try_next_u64().unwrap());
    assert_eq!(first, 7_191_089_600_892_374_487);
}

#[test]
fn sobol_prefix_and_latin_occupancy_are_canonical() {
    let sobol = SobolPlan {
        dimensions: 2,
        points: 4,
        skip: 0,
        scramble: Scramble::None,
        seed: 0,
        max_work: 8,
        untested_regions: vec![],
    }
    .generate()
    .unwrap();
    assert_eq!(
        sobol.points,
        vec![
            vec![0.0, 0.0],
            vec![0.5, 0.5],
            vec![0.75, 0.25],
            vec![0.25, 0.75]
        ]
    );
    assert!(matches!(
        SobolPlan {
            dimensions: 5,
            points: 1,
            skip: 0,
            scramble: Scramble::None,
            seed: 0,
            max_work: 5,
            untested_regions: vec![]
        }
        .generate(),
        Err(DesignError::UnsupportedDimension { maximum: 4, .. })
    ));
    let latin = LatinHypercubePlan {
        dimensions: 3,
        points: 8,
        seed: 11,
        max_work: 21,
        untested_regions: vec![],
    }
    .generate()
    .unwrap();
    assert_eq!(latin.coverage.stratum_occupancy, vec![vec![1; 8]; 3]);
    assert!(matches!(
        LatinHypercubePlan {
            dimensions: 2,
            points: 8,
            seed: 1,
            max_work: 13,
            untested_regions: vec![]
        }
        .generate(),
        Err(DesignError::WorkLimit {
            required: 14,
            limit: 13
        })
    ));
}

#[test]
fn coverage_and_distribution_edges_are_explicit() {
    let base = SobolPlan {
        dimensions: 1,
        points: 2,
        skip: 0,
        scramble: Scramble::None,
        seed: 0,
        max_work: 2,
        untested_regions: vec![],
    }
    .generate()
    .unwrap();
    let swept = SweepPlan {
        inject_lower_boundary: true,
        inject_upper_boundary: true,
        untested_regions: vec![UntestedRegion {
            label: "singularity".into(),
            reason: "caller excluded".into(),
        }],
    }
    .apply(base);
    assert_eq!(swept.coverage.boundary_injections, vec![0, 3]);
    assert_eq!(swept.coverage.duplicates, vec![(1, 0)]);
    assert_eq!(swept.coverage.untested_regions.len(), 1);

    let moments =
        standardized_moments(&[-1.0, 0.0, 1.0, 2.0], MomentConvention::Population).unwrap();
    assert_eq!(moments.skewness, 0.0);
    let same =
        kolmogorov_smirnov_two_sample(&[0.0, 1.0], &[0.0, 1.0], KsMethod::ExactStatistic).unwrap();
    assert_eq!(same.statistic, 0.0);
    assert_eq!(same.p_value, None);
    let separated =
        kolmogorov_smirnov_two_sample(&[0.0, 1.0], &[2.0, 3.0], KsMethod::Asymptotic).unwrap();
    assert_eq!(separated.statistic, 1.0);
    assert!(separated.p_value.unwrap() <= 1.0);
    assert!(kolmogorov_smirnov_one_sample(&[0.5], |_| 2.0, KsMethod::ExactStatistic).is_err());
}