distributions 0.0.2

Some statistic distributions written in rust
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

use std::rand::{mod, Rng, task_rng, TaskRng};
use std::rand::distributions::{Sample, Normal,IndependentSample};
use super::{Distribution,ContinuousDistribution,HasCdf};
use std::num::Float;
use std::f64::consts::PI;

pub struct Uniform {
    a: f64,
    b: f64,
    pub entropy: f64,
}

impl Uniform {
    pub fn new(a: f64, b: f64) -> Uniform {
        Uniform {
            a: a,
            b: b,
            entropy: (b - a).ln(),
        }
    }
}

impl Sample<f64> for Uniform {
    fn sample<R>(&mut self, rng: &mut R) -> f64 where R: Rng {
        self.ind_sample(rng)
    }
}

impl IndependentSample<f64> for Uniform {
    fn ind_sample<R>(&self, rng: &mut R) -> f64 where R: Rng {
        rng.gen_range(self.a, self.b)
    }
}

impl Distribution<f64> for Uniform {
    fn mean(&self) -> f64 {
        (self.a + self.b) / 2.0
    }
    fn variance(&self) -> f64 {
        (self.b - self.a).powi(2) / 12.0
    }
}

impl ContinuousDistribution<f64> for Uniform {
    fn unnormalized_log_pdf(&self, x: f64) -> f64 {
        if x <= self.b && x >= self.a {
            let f = 1. / (self.b - self.a);
            f.ln()
        } else {
            0f64
        }
    }
    fn log_normalizer(&self) -> f64 {
        self.entropy
    }
}

impl HasCdf<f64> for Uniform {
    fn probability(&self, a: f64, b: f64) -> f64 {
        (b - a) / (self.b - self.a)
    }
    fn cdf(&self, x: f64) -> f64 {
        match x {
            x if x <= self.a => 0f64,
            x if x >= self.b => 1f64,
            _ => (x - self.a) / (self.b - self.a)
        }
    }
}

#[test]
fn test_uniform_distr() {
    let mut d = Uniform::new(1.0, 3.);
    for _ in range(0u, 99u) {
        let rand = d.sample(&mut task_rng());
        assert!(rand <= 3.0 && rand >= 1.0);
    }
}