Merge branch 'master' into uniform-float

Author: vks

.github/workflows/test.yml

@@ -79,13 +79,13 @@ jobs:
         run: |
           cargo test --target ${{ matrix.target }} --features=nightly
           cargo test --target ${{ matrix.target }} --all-features
-          cargo test --target ${{ matrix.target }} --benches --features=nightly,small_rng
+          cargo test --target ${{ matrix.target }} --benches --features=small_rng,nightly
           cargo test --target ${{ matrix.target }} --manifest-path rand_distr/Cargo.toml --benches
           cargo test --target ${{ matrix.target }} --lib --tests --no-default-features
       - name: Test rand
         run: |
           cargo test --target ${{ matrix.target }} --lib --tests --no-default-features
-          cargo build --target ${{ matrix.target }} --no-default-features --features alloc,getrandom,small_rng
+          cargo build --target ${{ matrix.target }} --no-default-features --features alloc,getrandom,small_rng,unbiased
           cargo test --target ${{ matrix.target }} --lib --tests --no-default-features --features=alloc,getrandom,small_rng
           cargo test --target ${{ matrix.target }} --examples
       - name: Test rand (all stable features)

CHANGELOG.md

@@ -12,6 +12,7 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
 ### Distributions
 - `{Uniform, UniformSampler}::{new, new_inclusive}` return a `Result` (instead of potentially panicking) (#1229)
 - `Uniform` implements `TryFrom` instead of `From` for ranges (#1229)
+- `Uniform` now uses Canon's method (single sampling) / Lemire's method (distribution sampling) for faster sampling (breaks value stability; #1287)
 
 ### Other
 - Simpler and faster implementation of Floyd's F2 (#1277). This

Cargo.toml

@@ -51,6 +51,11 @@ std_rng = ["rand_chacha"]
 # Option: enable SmallRng
 small_rng = []
 
+# Option: use unbiased sampling for algorithms supporting this option: Uniform distribution.
+# By default, bias affecting no more than one in  2^48 samples is accepted.
+# Note: enabling this option is expected to affect reproducibility of results.
+unbiased = []
+
 [workspace]
 members = [
     "rand_core",
@@ -76,6 +81,10 @@ bincode = "1.2.1"
 rayon = "1.5.3"
 criterion = { version = "0.4" }
 
+[[bench]]
+name = "uniform"
+harness = false
+
 [[bench]]
 name = "seq_choose"
 path = "benches/seq_choose.rs"

benches/uniform.rs

@@ -0,0 +1,78 @@
+// Copyright 2021 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.
+
+//! Implement benchmarks for uniform distributions over integer types
+
+use core::time::Duration;
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use rand::distributions::uniform::{SampleRange, Uniform};
+use rand::prelude::*;
+use rand_chacha::ChaCha8Rng;
+use rand_pcg::{Pcg32, Pcg64};
+
+const WARM_UP_TIME: Duration = Duration::from_millis(1000);
+const MEASUREMENT_TIME: Duration = Duration::from_secs(3);
+const SAMPLE_SIZE: usize = 100_000;
+const N_RESAMPLES: usize = 10_000;
+
+macro_rules! sample {
+    ($R:ty, $T:ty, $U:ty, $g:expr) => {
+        $g.bench_function(BenchmarkId::new(stringify!($R), "single"), |b| {
+            let mut rng = <$R>::from_entropy();
+            let x = rng.gen::<$U>();
+            let bits = (<$T>::BITS / 2);
+            let mask = (1 as $U).wrapping_neg() >> bits;
+            let range = (x >> bits) * (x & mask);
+            let low = <$T>::MIN;
+            let high = low.wrapping_add(range as $T);
+
+            b.iter(|| (low..=high).sample_single(&mut rng));
+        });
+
+        $g.bench_function(BenchmarkId::new(stringify!($R), "distr"), |b| {
+            let mut rng = <$R>::from_entropy();
+            let x = rng.gen::<$U>();
+            let bits = (<$T>::BITS / 2);
+            let mask = (1 as $U).wrapping_neg() >> bits;
+            let range = (x >> bits) * (x & mask);
+            let low = <$T>::MIN;
+            let high = low.wrapping_add(range as $T);
+            let dist = Uniform::<$T>::new_inclusive(<$T>::MIN, high).unwrap();
+
+            b.iter(|| dist.sample(&mut rng));
+        });
+    };
+
+    ($c:expr, $T:ty, $U:ty) => {{
+        let mut g = $c.benchmark_group(concat!("sample", stringify!($T)));
+        g.sample_size(SAMPLE_SIZE);
+        g.warm_up_time(WARM_UP_TIME);
+        g.measurement_time(MEASUREMENT_TIME);
+        g.nresamples(N_RESAMPLES);
+        sample!(SmallRng, $T, $U, g);
+        sample!(ChaCha8Rng, $T, $U, g);
+        sample!(Pcg32, $T, $U, g);
+        sample!(Pcg64, $T, $U, g);
+        g.finish();
+    }};
+}
+
+fn sample(c: &mut Criterion) {
+    sample!(c, i8, u8);
+    sample!(c, i16, u16);
+    sample!(c, i32, u32);
+    sample!(c, i64, u64);
+    sample!(c, i128, u128);
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default();
+    targets = sample
+}
+criterion_main!(benches);

rand_core/src/lib.rs

@@ -451,7 +451,7 @@ impl<R: RngCore + ?Sized> RngCore for Box<R> {
 ///
 /// # Examples
 ///
-/// ```rust
+/// ```no_run
 /// # use std::{io, io::Read};
 /// # use std::fs::File;
 /// # use rand_core::{OsRng, RngCore};

rand_distr/CHANGELOG.md

@@ -9,6 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   This breaks serialization compatibility with older versions.
 - Upgrade Rand
 - Fix Knuth's method so `Poisson` doesn't return -1.0 for small lambda
+- Fix `Poisson` distribution instantiation so it return an error if lambda is infinite
+- `Dirichlet` now uses `const` generics, which means that its size is required at compile time (#1292)
+- The `Dirichlet::new_with_size` constructor was removed (#1292)
 
 ## [0.4.3] - 2021-12-30
 - Fix `no_std` build (#1208)

rand_distr/Cargo.toml

@@ -27,6 +27,7 @@ serde1 = ["serde", "rand/serde1"]
 rand = { path = "..", version = "0.9.0", default-features = false }
 num-traits = { version = "0.2", default-features = false, features = ["libm"] }
 serde = { version = "1.0.103", features = ["derive"], optional = true }
+serde_with = { version = "1.14.0", optional = true }
 
 [dev-dependencies]
 rand_pcg = { version = "0.4.0", path = "../rand_pcg" }

rand_distr/src/dirichlet.rs

@@ -13,7 +13,8 @@ use num_traits::Float;
 use crate::{Distribution, Exp1, Gamma, Open01, StandardNormal};
 use rand::Rng;
 use core::fmt;
-use alloc::{boxed::Box, vec, vec::Vec};
+#[cfg(feature = "serde_with")]
+use serde_with::serde_as;
 
 /// The Dirichlet distribution `Dirichlet(alpha)`.
 ///
@@ -27,22 +28,23 @@ use alloc::{boxed::Box, vec, vec::Vec};
 /// use rand::prelude::*;
 /// use rand_distr::Dirichlet;
 ///
-/// let dirichlet = Dirichlet::new(&[1.0, 2.0, 3.0]).unwrap();
+/// let dirichlet = Dirichlet::new([1.0, 2.0, 3.0]).unwrap();
 /// let samples = dirichlet.sample(&mut rand::thread_rng());
 /// println!("{:?} is from a Dirichlet([1.0, 2.0, 3.0]) distribution", samples);
 /// ```
 #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+#[cfg_attr(feature = "serde_with", serde_as)]
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
-pub struct Dirichlet<F>
+pub struct Dirichlet<F, const N: usize>
 where
     F: Float,
     StandardNormal: Distribution<F>,
     Exp1: Distribution<F>,
     Open01: Distribution<F>,
 {
     /// Concentration parameters (alpha)
-    alpha: Box<[F]>,
+    #[cfg_attr(feature = "serde_with", serde_as(as = "[_; N]"))]
+    alpha: [F; N],
 }
 
 /// Error type returned from `Dirchlet::new`.
@@ -72,7 +74,7 @@ impl fmt::Display for Error {
 #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl std::error::Error for Error {}
 
-impl<F> Dirichlet<F>
+impl<F, const N: usize> Dirichlet<F, N>
 where
     F: Float,
     StandardNormal: Distribution<F>,
@@ -83,8 +85,8 @@ where
     ///
     /// Requires `alpha.len() >= 2`.
     #[inline]
-    pub fn new(alpha: &[F]) -> Result<Dirichlet<F>, Error> {
-        if alpha.len() < 2 {
+    pub fn new(alpha: [F; N]) -> Result<Dirichlet<F, N>, Error> {
+        if N < 2 {
             return Err(Error::AlphaTooShort);
         }
         for &ai in alpha.iter() {
@@ -93,36 +95,19 @@ where
             }
         }
 
-        Ok(Dirichlet { alpha: alpha.to_vec().into_boxed_slice() })
-    }
-
-    /// Construct a new `Dirichlet` with the given shape parameter `alpha` and `size`.
-    ///
-    /// Requires `size >= 2`.
-    #[inline]
-    pub fn new_with_size(alpha: F, size: usize) -> Result<Dirichlet<F>, Error> {
-        if !(alpha > F::zero()) {
-            return Err(Error::AlphaTooSmall);
-        }
-        if size < 2 {
-            return Err(Error::SizeTooSmall);
-        }
-        Ok(Dirichlet {
-            alpha: vec![alpha; size].into_boxed_slice(),
-        })
+        Ok(Dirichlet { alpha })
     }
 }
 
-impl<F> Distribution<Vec<F>> for Dirichlet<F>
+impl<F, const N: usize> Distribution<[F; N]> for Dirichlet<F, N>
 where
     F: Float,
     StandardNormal: Distribution<F>,
     Exp1: Distribution<F>,
     Open01: Distribution<F>,
 {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vec<F> {
-        let n = self.alpha.len();
-        let mut samples = vec![F::zero(); n];
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [F; N] {
+        let mut samples = [F::zero(); N];
         let mut sum = F::zero();
 
         for (s, &a) in samples.iter_mut().zip(self.alpha.iter()) {
@@ -140,27 +125,12 @@ where
 
 #[cfg(test)]
 mod test {
+    use alloc::vec::Vec;
     use super::*;
 
     #[test]
     fn test_dirichlet() {
-        let d = Dirichlet::new(&[1.0, 2.0, 3.0]).unwrap();
-        let mut rng = crate::test::rng(221);
-        let samples = d.sample(&mut rng);
-        let _: Vec<f64> = samples
-            .into_iter()
-            .map(|x| {
-                assert!(x > 0.0);
-                x
-            })
-            .collect();
-    }
-
-    #[test]
-    fn test_dirichlet_with_param() {
-        let alpha = 0.5f64;
-        let size = 2;
-        let d = Dirichlet::new_with_size(alpha, size).unwrap();
+        let d = Dirichlet::new([1.0, 2.0, 3.0]).unwrap();
         let mut rng = crate::test::rng(221);
         let samples = d.sample(&mut rng);
         let _: Vec<f64> = samples
@@ -175,17 +145,17 @@ mod test {
     #[test]
     #[should_panic]
     fn test_dirichlet_invalid_length() {
-        Dirichlet::new_with_size(0.5f64, 1).unwrap();
+        Dirichlet::new([0.5]).unwrap();
     }
 
     #[test]
     #[should_panic]
     fn test_dirichlet_invalid_alpha() {
-        Dirichlet::new_with_size(0.0f64, 2).unwrap();
+        Dirichlet::new([0.1, 0.0, 0.3]).unwrap();
     }
 
     #[test]
     fn dirichlet_distributions_can_be_compared() {
-        assert_eq!(Dirichlet::new(&[1.0, 2.0]), Dirichlet::new(&[1.0, 2.0]));
+        assert_eq!(Dirichlet::new([1.0, 2.0]), Dirichlet::new([1.0, 2.0]));
     }
 }

rand_distr/src/poisson.rs

@@ -44,14 +44,17 @@ where F: Float + FloatConst, Standard: Distribution<F>
 /// Error type returned from `Poisson::new`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Error {
-    /// `lambda <= 0` or `nan`.
+    /// `lambda <= 0`
     ShapeTooSmall,
+    /// `lambda = ∞` or `lambda = nan`
+    NonFinite,
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {
             Error::ShapeTooSmall => "lambda is not positive in Poisson distribution",
+            Error::NonFinite => "lambda is infinite or nan in Poisson distribution",
         })
     }
 }
@@ -66,6 +69,9 @@ where F: Float + FloatConst, Standard: Distribution<F>
     /// Construct a new `Poisson` with the given shape parameter
     /// `lambda`.
     pub fn new(lambda: F) -> Result<Poisson<F>, Error> {
+	if !lambda.is_finite() {
+            return Err(Error::NonFinite);
+        }
         if !(lambda > F::zero()) {
             return Err(Error::ShapeTooSmall);
         }
@@ -163,7 +169,7 @@ mod test {
     fn test_poisson_avg() {
         test_poisson_avg_gen::<f64>(10.0, 0.1);
         test_poisson_avg_gen::<f64>(15.0, 0.1);
-        
+
         test_poisson_avg_gen::<f32>(10.0, 0.1);
         test_poisson_avg_gen::<f32>(15.0, 0.1);
 
@@ -178,6 +184,12 @@ mod test {
         Poisson::new(0.0).unwrap();
     }
 
+    #[test]
+    #[should_panic]
+    fn test_poisson_invalid_lambda_infinity() {
+        Poisson::new(f64::INFINITY).unwrap();
+    }
+
     #[test]
     #[should_panic]
     fn test_poisson_invalid_lambda_neg() {
@@ -188,4 +200,4 @@ mod test {
     fn poisson_distributions_can_be_compared() {
         assert_eq!(Poisson::new(1.0), Poisson::new(1.0));
     }
-}
+}

rand_distr/tests/value_stability.rs

@@ -348,10 +348,10 @@ fn weibull_stability() {
 fn dirichlet_stability() {
     let mut rng = get_rng(223);
     assert_eq!(
-        rng.sample(Dirichlet::new(&[1.0, 2.0, 3.0]).unwrap()),
-        vec![0.12941567177708177, 0.4702121891675036, 0.4003721390554146]
+        rng.sample(Dirichlet::new([1.0, 2.0, 3.0]).unwrap()),
+        [0.12941567177708177, 0.4702121891675036, 0.4003721390554146]
     );
-    assert_eq!(rng.sample(Dirichlet::new_with_size(8.0, 5).unwrap()), vec![
+    assert_eq!(rng.sample(Dirichlet::new([8.0; 5]).unwrap()), [
         0.17684200044809556,
         0.29915953935953055,
         0.1832858056608014,