logprob 0.4.0

A wrapper around floats to handle log probabilities
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

use core::f64;
use divan::Bencher;
use logprob::LogProb;
use num_traits::Float;

fn main() {
    divan::main();
}
const N: usize = 100;

fn p_and_q<T: Float + From<u16>>() -> (Vec<LogProb<T>>, Vec<LogProb<T>>) {
    let log_p: Vec<_> = (0..N)
        .map(|i| LogProb::new(-(<T as From<u16>>::from((i + 2) as u16))).unwrap())
        .collect();
    let log_q: Vec<_> = (0..N)
        .map(|i| LogProb::new(-(<T as From<u16>>::from(i as u16))).unwrap())
        .collect();
    (log_p, log_q)
}

#[divan::bench(types=[f64,f32])]
fn subtract_op<T: Float + From<u16> + Sync>(bencher: Bencher) {
    let (p, q) = p_and_q::<T>();
    bencher.bench(|| {
        for (x, y) in p.iter().zip(&q) {
            _ = divan::black_box(*x) - divan::black_box(*y);
        }
    });
}

#[divan::bench(types=[f64,f32])]
fn unchecked_sub<T: Float + From<u16> + Sync>(bencher: Bencher) {
    let (p, q) = p_and_q::<T>();
    bencher.bench(|| {
        for (x, y) in p.iter().zip(&q) {
            unsafe {
                _ = divan::black_box(x).unchecked_sub(*divan::black_box(y));
            }
        }
    });
}

#[divan::bench(types=[f64,f32])]
fn saturating_sub<T: Float + From<u16> + Sync>(bencher: Bencher) {
    let (p, q) = p_and_q::<T>();
    bencher.bench(|| {
        for (x, y) in p.iter().zip(&q) {
            _ = divan::black_box(x).saturating_sub(*divan::black_box(y));
        }
    });
}

#[divan::bench(types=[f64,f32])]
fn try_sub<T: Float + From<u16> + Sync>(bencher: Bencher) {
    let (p, q) = p_and_q::<T>();
    bencher.bench(|| {
        for (x, y) in p.iter().zip(&q) {
            _ = divan::black_box(x).try_sub(*divan::black_box(y)).unwrap();
        }
    });
}

#[divan::bench(types=[f64,f32])]
fn checked_sub<T: Float + From<u16> + Sync>(bencher: Bencher) {
    let (p, q) = p_and_q::<T>();
    bencher.bench(|| {
        for (x, y) in p.iter().zip(&q) {
            _ = divan::black_box(x)
                .checked_sub(*divan::black_box(y))
                .unwrap();
        }
    });
}