stats-ci 0.1.1

A pure Rust library for computing and working with confidence intervals on sample data.
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

use rand::{thread_rng, Rng};
use rayon::prelude::*;
use stats_ci::*;
use std::time::Instant;

///
/// Measures the time elapsed to compute a 95% confidence interval for a reasonably large array.
/// Measurements on a 2022 MacBook Air (M2, 24GB RAM, 1TB SSD) with rustc 1.62.2 yield a runtime of
/// nearly 80ms for an array of 20M elements (when compiled in --release), or about 14ms when run
/// in parallel (chunks).
///
fn main() {
    type Float = f64;
    const POPULATION_SIZE: usize = 20_000_000;
    const CHUNK_SIZE: usize = 10_000;

    let mut rng = thread_rng();
    let mut source_population = vec![0 as Float; POPULATION_SIZE];
    rng.fill(&mut source_population[..]);

    println!("Sequential call:");
    let population = source_population.clone();
    let start = Instant::now();
    let stats = mean::Arithmetic::from_iter(&population).unwrap();
    let ci = stats.ci_mean(Confidence::new_two_sided(0.95)).unwrap();
    let elapsed = start.elapsed();
    println!("Elapsed: {:?}", elapsed);
    println!("CI: {} (theoretical mean: 0.5)", ci);

    println!("\nParallel call:");
    let population = source_population.clone();
    let start = Instant::now();
    let ci = population
        .par_iter()
        .map(|&x| mean::Arithmetic::from_iter(&[x]).unwrap())
        .reduce(|| mean::Arithmetic::new(), |s1, s2| s1 + s2)
        .ci_mean(Confidence::new_two_sided(0.95))
        .unwrap();
    let elapsed = start.elapsed();
    println!("Elapsed: {:?}", elapsed);
    println!("CI: {} (theoretical mean: 0.5)", ci);

    println!("\nParallel call (chunk size: {}):", CHUNK_SIZE);
    let population = source_population.clone();
    let start = Instant::now();
    let ci = population
        .par_chunks(CHUNK_SIZE)
        .map(|chunk| {
            let mut stats = mean::Arithmetic::new();
            for x in chunk {
                stats.append(*x).unwrap();
            }
            stats
        })
        .reduce(|| mean::Arithmetic::new(), |s1, s2| s1 + s2)
        .ci_mean(Confidence::new_two_sided(0.95))
        .unwrap();
    let elapsed = start.elapsed();
    println!("Elapsed: {:?}", elapsed);
    println!("CI: {} (theoretical mean: 0.5)", ci);
}