src/librand/distributions/exponential.rs

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! The exponential distribution.
  12
  13 use core::num::Float;
  14
  15 use {Rng, Rand};
  16 use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
  17
  18 /// A wrapper around an `f64` to generate Exp(1) random numbers.
  19 ///
  20 /// See `Exp` for the general exponential distribution.Note that this
  21  // has to be unwrapped before use as an `f64` (using either
  22 /// `*` or `mem::transmute` is safe).
  23 ///
  24 /// Implemented via the ZIGNOR variant[1] of the Ziggurat method. The
  25 /// exact description in the paper was adjusted to use tables for the
  26 /// exponential distribution rather than normal.
  27 ///
  28 /// [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to
  29 /// Generate Normal Random
  30 /// Samples*](http://www.doornik.com/research/ziggurat.pdf). Nuffield
  31 /// College, Oxford
  32 #[derive(Copy, Clone)]
  33 pub struct Exp1(pub f64);
  34
  35 // This could be done via `-rng.gen::<f64>().ln()` but that is slower.
  36 impl Rand for Exp1 {
  37     #[inline]
  38     fn rand<R:Rng>(rng: &mut R) -> Exp1 {
  39         #[inline]
  40         fn pdf(x: f64) -> f64 {
  41             (-x).exp()
  42         }
  43         #[inline]
  44         fn zero_case<R:Rng>(rng: &mut R, _u: f64) -> f64 {
  45             ziggurat_tables::ZIG_EXP_R - rng.gen::<f64>().ln()
  46         }
  47
  48         Exp1(ziggurat(rng, false,
  49                       &ziggurat_tables::ZIG_EXP_X,
  50                       &ziggurat_tables::ZIG_EXP_F,
  51                       pdf, zero_case))
  52     }
  53 }
  54
  55 /// The exponential distribution `Exp(lambda)`.
  56 ///
  57 /// This distribution has density function: `f(x) = lambda *
  58 /// exp(-lambda * x)` for `x > 0`.
  59 #[derive(Copy, Clone)]
  60 pub struct Exp {
  61     /// `lambda` stored as `1/lambda`, since this is what we scale by.
  62     lambda_inverse: f64
  63 }
  64
  65 impl Exp {
  66     /// Construct a new `Exp` with the given shape parameter
  67     /// `lambda`. Panics if `lambda <= 0`.
  68     pub fn new(lambda: f64) -> Exp {
  69         assert!(lambda > 0.0, "Exp::new called with `lambda` <= 0");
  70         Exp { lambda_inverse: 1.0 / lambda }
  71     }
  72 }
  73
  74 impl Sample<f64> for Exp {
  75     fn sample<R: Rng>(&mut self, rng: &mut R) -> f64 { self.ind_sample(rng) }
  76 }
  77 impl IndependentSample<f64> for Exp {
  78     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
  79         let Exp1(n) = rng.gen::<Exp1>();
  80         n * self.lambda_inverse
  81     }
  82 }
  83
  84 #[cfg(test)]
  85 mod test {
  86     use std::prelude::v1::*;
  87
  88     use distributions::{Sample, IndependentSample};
  89     use super::Exp;
  90
  91     #[test]
  92     fn test_exp() {
  93         let mut exp = Exp::new(10.0);
  94         let mut rng = ::test::rng();
  95         for _ in 0..1000 {
  96             assert!(exp.sample(&mut rng) >= 0.0);
  97             assert!(exp.ind_sample(&mut rng) >= 0.0);
  98         }
  99     }
 100     #[test]
 101     #[should_panic]
 102     fn test_exp_invalid_lambda_zero() {
 103         Exp::new(0.0);
 104     }
 105     #[test]
 106     #[should_panic]
 107     fn test_exp_invalid_lambda_neg() {
 108         Exp::new(-10.0);
 109     }
 110 }
 111
 112 #[cfg(test)]
 113 mod bench {
 114     extern crate test;
 115
 116     use std::prelude::v1::*;
 117
 118     use self::test::Bencher;
 119     use std::mem::size_of;
 120     use super::Exp;
 121     use distributions::Sample;
 122
 123     #[bench]
 124     fn rand_exp(b: &mut Bencher) {
 125         let mut rng = ::test::weak_rng();
 126         let mut exp = Exp::new(2.71828 * 3.14159);
 127
 128         b.iter(|| {
 129             for _ in 0..::RAND_BENCH_N {
 130                 exp.sample(&mut rng);
 131             }
 132         });
 133         b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
 134     }
 135 }