logprob 0.2.1

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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

use anyhow::Result;
use logprob::{
    log_sum_exp, log_sum_exp_clamped, log_sum_exp_float, softmax, LogProb, LogSumExp, Softmax,
};

#[test]
fn basic_construction() -> Result<()> {
    LogProb::new(-3.0)?;
    LogProb::new(f64::NEG_INFINITY)?;
    LogProb::new(0.0_f64)?;
    LogProb::new(-0.0_f64)?;
    assert!(LogProb::new(3.0).is_err());
    assert!(LogProb::new(f64::NAN).is_err());
    assert!(LogProb::new(f64::INFINITY).is_err());
    assert!(LogProb::new(23434.3432).is_err());

    let x: LogProb<f32> = (-3.0_f32).try_into()?;
    assert_eq!(x, LogProb::new(-3.0_f32)?);
    let x: LogProb<f64> = f64::NEG_INFINITY.try_into()?;
    assert_eq!(x, LogProb::new(f64::NEG_INFINITY)?);

    LogProb::new(-3.0_f64)?;
    LogProb::new(f32::NEG_INFINITY)?;
    LogProb::new(0.0_f32)?;
    LogProb::new(-0.0_f32)?;
    assert!(LogProb::new(3.0_f32).is_err());
    assert!(LogProb::new(f32::NAN).is_err());
    assert!(LogProb::new(f32::INFINITY).is_err());
    assert!(LogProb::new(23434.34_f32).is_err());
    Ok(())
}

#[test]
fn prob_of_zero_and_one() -> Result<()> {
    assert_eq!(LogProb::prob_of_zero(), LogProb::from_raw_prob(0.0_f64)?);
    assert_eq!(LogProb::prob_of_one(), LogProb::from_raw_prob(1.0_f64)?);
    assert_eq!(LogProb::prob_of_zero(), LogProb::from_raw_prob(0.0_f32)?);
    assert_eq!(LogProb::prob_of_one(), LogProb::from_raw_prob(1.0_f32)?);
    Ok(())
}

#[test]
fn addition() -> Result<()> {
    let x = LogProb::new(-3.0)? + LogProb::new(-3.0)?;
    assert_eq!(x, LogProb::new(-6.0)?);

    let x = LogProb::new(-0.0)? + LogProb::new(0.0)?;
    assert_eq!(x, LogProb::new(-0.0)?);
    assert_eq!(x, LogProb::new(0.0)?);

    #[allow(clippy::op_ref)]
    let x = &(LogProb::new(-0.0)?) + LogProb::new(0.0)?;
    assert_eq!(x, LogProb::new(-0.0)?);
    assert_eq!(x, LogProb::new(0.0)?);

    #[allow(clippy::op_ref)]
    let mut x = &(LogProb::new(-0.0)?) + &(LogProb::new(0.0)?);
    assert_eq!(x, LogProb::new(-0.0)?);
    assert_eq!(x, LogProb::new(0.0)?);

    x += LogProb::new(-0.5)?;
    assert_eq!(x, LogProb::new(-0.5)?);

    x += &LogProb::new(-0.5)?;
    assert_eq!(x, LogProb::new(-1.0)?);

    let x = LogProb::new(-0.5)? + LogProb::new(f64::NEG_INFINITY)?;
    assert_eq!(x, LogProb::new(f64::NEG_INFINITY)?);
    Ok(())
}

#[test]
fn multiplication() -> Result<()> {
    let x: LogProb<f64> = LogProb::new(-3.0)? * 4_u32;
    assert_eq!(x, LogProb::new(-12.0)?);

    let x: LogProb<f64> = 4_u8 * LogProb::new(-3.0)?;
    assert_eq!(x, LogProb::new(-12.0)?);

    let x: LogProb<f64> = 0_u8 * LogProb::new(-3.0)?;
    assert_eq!(x, LogProb::new(0.0)?);

    #[allow(clippy::op_ref)]
    let x: LogProb<f64> = &4_u8 * LogProb::new(-3.0)?;
    assert_eq!(x, LogProb::new(-12.0)?);

    #[allow(clippy::op_ref)]
    let x: LogProb<f64> = &4_u8 * &LogProb::new(-3.0)?;
    assert_eq!(x, LogProb::new(-12.0)?);

    #[allow(clippy::op_ref)]
    let x: LogProb<f64> = 4_u8 * &LogProb::new(-3.0)?;
    assert_eq!(x, LogProb::new(-12.0)?);

    #[allow(clippy::op_ref)]
    let x: LogProb<f64> = LogProb::new(-3.0)? * &4_u8;
    assert_eq!(x, LogProb::new(-12.0)?);

    #[allow(clippy::op_ref)]
    let x: LogProb<f64> = &LogProb::new(-3.0)? * &4_u8;
    assert_eq!(x, LogProb::new(-12.0)?);

    #[allow(clippy::op_ref)]
    let x: LogProb<f64> = &LogProb::new(-3.0)? * 4_u8;
    assert_eq!(x, LogProb::new(-12.0)?);
    Ok(())
}

#[test]
fn add_probs_test() -> Result<()> {
    let x = LogProb::from_raw_prob(0.5)?;
    let y = LogProb::from_raw_prob(0.25)?;
    assert_eq!(x.into_inner(), 0.5_f64.ln());
    assert_eq!(y.into_inner(), 0.25_f64.ln());

    let z = x.add_log_prob(y)?;
    assert_eq!(z, LogProb::from_raw_prob(0.75)?);
    assert!(x.add_log_prob(z).is_err());
    assert_eq!(x.add_log_prob_clamped(z), LogProb::new(0.0)?);
    approx::assert_relative_eq!(x.add_log_prob_float(z), (0.75 + 0.5_f64).ln());

    let x = LogProb::from_raw_prob(0.5)?;
    let y = LogProb::from_raw_prob(0.5)?;
    let z = x.add_log_prob(y)?;
    assert_eq!(z, LogProb::new(0.0)?);

    let sum = [0.5, 0.2, 0.3]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_no_alloc()?;
    approx::assert_relative_eq!(sum.into_inner(), LogProb::new(0.0)?.into_inner());

    let sum = [0.5, 0.2, 0.3]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp()?;
    approx::assert_relative_eq!(sum.into_inner(), LogProb::new(0.0)?.into_inner());

    assert!([0.5, 0.5, 0.3]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_no_alloc()
        .is_err());

    assert!([0.5, 0.5, 0.3]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp()
        .is_err());

    let sum = [0.5, 0.5, 0.5]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_clamped_no_alloc();
    approx::assert_relative_eq!(sum.into_inner(), 0.0);

    let sum = [0.5, 0.5, 0.5]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_clamped();
    approx::assert_relative_eq!(sum.into_inner(), 0.0);

    let sum = [0.5, 0.3, 0.0, 0.0]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_clamped_no_alloc();
    approx::assert_relative_eq!(sum.into_inner(), 0.8_f64.ln());

    let sum = [0.5, 0.3, 0.0, 0.0]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_clamped();
    approx::assert_relative_eq!(sum.into_inner(), 0.8_f64.ln());

    let sum = [0.5, 0.5, 0.5, 0.0]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_float_no_alloc();
    approx::assert_relative_eq!(sum, 1.5_f64.ln());

    let sum = [0.5, 0.5, 0.5, 0.0]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .log_sum_exp_float();
    approx::assert_relative_eq!(sum, 1.5_f64.ln());

    let v: Vec<_> = [0.5, 0.5, 0.5]
        .map(LogProb::from_raw_prob)
        .map(|x| x.unwrap())
        .into_iter()
        .collect();

    assert!(log_sum_exp(&v).is_err());
    approx::assert_relative_eq!(log_sum_exp_float(&v), 1.5_f64.ln());
    approx::assert_relative_eq!(log_sum_exp_clamped(&v).into_inner(), 0.0);

    let v_2: Vec<_> = v.iter().collect();

    assert!(log_sum_exp(&v_2).is_err());
    approx::assert_relative_eq!(log_sum_exp_float(&v_2), 1.5_f64.ln());
    approx::assert_relative_eq!(log_sum_exp_clamped(&v_2).into_inner(), 0.0);

    let v: Vec<LogProb<f64>> = vec![];
    assert_eq!(log_sum_exp(&v)?, LogProb::new(f64::NEG_INFINITY)?);
    assert_eq!(
        v.iter().log_sum_exp_no_alloc()?,
        LogProb::new(f64::NEG_INFINITY)?
    );
    assert_eq!(log_sum_exp_clamped(&v), LogProb::new(f64::NEG_INFINITY)?);
    assert_eq!(
        v.iter().log_sum_exp_clamped_no_alloc(),
        LogProb::new(f64::NEG_INFINITY)?
    );
    assert_eq!(log_sum_exp_float(&v), f64::NEG_INFINITY);
    assert_eq!(v.iter().log_sum_exp_float_no_alloc(), f64::NEG_INFINITY);

    assert_eq!(v.iter().log_sum_exp()?, LogProb::new(f64::NEG_INFINITY)?);
    assert_eq!(v.iter().log_sum_exp_float(), f64::NEG_INFINITY);
    assert_eq!(
        v.iter().log_sum_exp_clamped(),
        LogProb::new(f64::NEG_INFINITY)?
    );
    Ok(())
}

#[test]
fn softmax_test() -> Result<()> {
    let x: Vec<f64> = vec![0.5, -2.0, 5.];
    let s: Vec<_> = softmax(&x)?.map(|x| x.into_inner()).collect();
    assert_eq!(
        s,
        vec![
            -4.511949201585065,
            -7.011949201585065,
            -0.011949201585064628
        ]
    );
    let s_2: Vec<_> = x.into_iter().softmax()?.map(|x| x.into_inner()).collect();
    assert_eq!(s, s_2);

    let x: Vec<f64> = vec![];
    let s: Vec<f64> = softmax(&x)?.map(|x| x.into_inner()).collect();
    assert_eq!(x, s);
    let x: Vec<f64> = vec![0.5, f64::INFINITY, 5.];
    assert!(softmax(&x).is_err());
    let x: Vec<f64> = vec![0.5, f64::NAN, 5.];
    assert!(softmax(&x).is_err());
    Ok(())
}