1 files changed, 132 insertions, 0 deletions
diff --git a/rand/rand_distr/src/pert.rs b/rand/rand_distr/src/pert.rs
new file mode 100644
index 0000000..040cd05
--- /dev/null
+++ b/rand/rand_distr/src/pert.rs
@@ -0,0 +1,132 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//! The PERT distribution.
+
+use rand::Rng;
+use crate::{Distribution, Beta, StandardNormal, Exp1, Open01};
+use crate::utils::Float;
+
+/// The PERT distribution.
+///
+/// Similar to the [`Triangular`] distribution, the PERT distribution is
+/// parameterised by a range and a mode within that range. Unlike the
+/// [`Triangular`] distribution, the probability density function of the PERT
+/// distribution is smooth, with a configurable weighting around the mode.
+///
+/// # Example
+///
+/// ```rust
+/// use rand_distr::{Pert, Distribution};
+///
+/// let d = Pert::new(0., 5., 2.5).unwrap();
+/// let v = d.sample(&mut rand::thread_rng());
+/// println!("{} is from a PERT distribution", v);
+/// ```
+/// 
+/// [`Triangular`]: crate::Triangular
+#[derive(Clone, Copy, Debug)]
+pub struct Pert<N> {
+    min: N,
+    range: N,
+    beta: Beta<N>,
+}
+
+/// Error type returned from [`Pert`] constructors.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PertError {
+    /// `max < min` or `min` or `max` is NaN.
+    RangeTooSmall,
+    /// `mode < min` or `mode > max` or `mode` is NaN.
+    ModeRange,
+    /// `shape < 0` or `shape` is NaN
+    ShapeTooSmall,
+}
+
+impl<N: Float> Pert<N>
+where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distribution<N>
+{
+    /// Set up the PERT distribution with defined `min`, `max` and `mode`.
+    ///
+    /// This is equivalent to calling `Pert::new_shape` with `shape == 4.0`.
+    #[inline]
+    pub fn new(min: N, max: N, mode: N) -> Result<Pert<N>, PertError> {
+        Pert::new_with_shape(min, max, mode, N::from(4.))
+    }
+    
+    /// Set up the PERT distribution with defined `min`, `max`, `mode` and
+    /// `shape`.
+    pub fn new_with_shape(min: N, max: N, mode: N, shape: N) -> Result<Pert<N>, PertError> {
+        if !(max > min) {
+            return Err(PertError::RangeTooSmall);
+        }
+        if !(mode >= min && max >= mode) {
+            return Err(PertError::ModeRange);
+        }
+        if !(shape >= N::from(0.)) {
+            return Err(PertError::ShapeTooSmall);
+        }
+        
+        let range = max - min;
+        let mu = (min + max + shape * mode) / (shape + N::from(2.));
+        let v = if mu == mode {
+            shape * N::from(0.5) + N::from(1.)
+        } else {
+            (mu - min) * (N::from(2.) * mode - min - max)
+                / ((mode - mu) * (max - min))
+        };
+        let w = v * (max - mu) / (mu - min);
+        let beta = Beta::new(v, w).map_err(|_| PertError::RangeTooSmall)?;
+        Ok(Pert{ min, range, beta })
+    }
+}
+
+impl<N: Float> Distribution<N> for Pert<N>
+where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distribution<N>
+{
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> N {
+        self.beta.sample(rng) * self.range + self.min
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::f64;
+    use super::*;
+
+    #[test]
+    fn test_pert() {
+        for &(min, max, mode) in &[
+            (-1., 1., 0.),
+            (1., 2., 1.),
+            (5., 25., 25.),
+        ] {
+            let _distr = Pert::new(min, max, mode).unwrap();
+            // TODO: test correctness
+        }
+
+        for &(min, max, mode) in &[
+            (-1., 1., 2.),
+            (-1., 1., -2.),
+            (2., 1., 1.),
+        ] {
+            assert!(Pert::new(min, max, mode).is_err());
+        }
+    }
+    
+    #[test]
+    fn value_stability() {
+        let rng = crate::test::rng(860);
+        let distr = Pert::new(2., 10., 3.).unwrap();    // mean = 4, var = 12/7
+        let seq = distr.sample_iter(rng).take(5).collect::<Vec<f64>>();
+        println!("seq: {:?}", seq);
+        let expected = vec![4.631484136029422, 3.307201472321789,
+                3.29995019556348, 3.66835483991721, 3.514246139933899];
+        assert!(seq == expected);
+    }
+}