merge master

Author: newpavlov

CHANGELOG.md

@@ -14,19 +14,28 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
 - Added a `serde1` feature and added Serialize/Deserialize to `UniformInt` and `WeightedIndex` (#974)
 - Document types supported by `random` (#994)
 - Implement weighted sampling without replacement (#976, #1013)
+- Add `IteratorRandom::choose_stable` as an alternative to `choose` which does not depend on size hints (#1057)
 
 ### Changes
+- `getrandom` updated to v0.2 (#1041)
+- `ThreadRng` is no longer `Copy` to enable safe usage within thread-local destructors (see #968)
 - `gen_range(a, b)` was replaced with `gen_range(a..b)`, and `gen_range(a..=b)`
   is supported (#744, #1003). Note that `a` and `b` can no longer be references or SIMD types.
 - Replace `AsByteSliceMut` with `Fill` (#940)
 - Move alias method for `WeightedIndex` to `rand_distr` (#945)
 - `Alphanumeric` samples bytes instead of chars (#935)
 - The minimum supported Rust version is now 1.36 (#1011)
+- Restrict `rand::rngs::adapter` to `std` (#1027)
 - Better NaN handling for `WeightedIndex` (#1005)
 - Implement `IntoIterator` for `IndexVec`, replacing the `into_iter` method (#1007)
 - Reduce packaged crate size (#983)
-- Drop some unsafe code (#962, #963)
+- Drop some unsafe code (#962, #963, #1011)
 - Improve treatment of rounding errors in `WeightedIndex::update_weights` (#956)
+- `StdRng`: Switch from ChaCha20 to ChaCha12 for better performance (#1028)
+- `SmallRng`: Replace PCG algorithm with xoshiro{128,256}++ (#1038)
+- The `nightly` feature no longer implies the `simd_support` feature (#1048)
+- Fix `simd_support` feature to work on current nightlies (#1056)
+- Improve accuracy and performance of `IteratorRandom::choose` (#1059)
 
 ## [0.7.3] - 2020-01-10
 ### Fixes

Cargo.toml

@@ -23,7 +23,7 @@ appveyor = { repository = "rust-random/rand" }
 [features]
 # Meta-features:
 default = ["std", "std_rng"]
-nightly = ["simd_support"] # enables all features requiring nightly rust
+nightly = [] # enables performance optimizations requiring nightly rust
 serde1 = ["serde"]
 
 # Option (enabled by default): without "std" rand uses libcore; this option
@@ -43,7 +43,7 @@ simd_support = ["packed_simd"]
 std_rng = ["rand_chacha", "rand_hc"]
 
 # Option: enable SmallRng
-small_rng = ["rand_pcg"]
+small_rng = []
 
 [workspace]
 members = [
@@ -56,14 +56,13 @@ members = [
 
 [dependencies]
 rand_core = { path = "rand_core", version = "0.5.1" }
-rand_pcg = { path = "rand_pcg", version = "0.2.1", optional = true }
 log = { version = "0.4.4", optional = true }
 serde = { version = "1.0.103", features = ["derive"], optional = true }
 
 [dependencies.packed_simd]
 # NOTE: so far no version works reliably due to dependence on unstable features
-version = "0.3"
-# git = "https://github.com/rust-lang-nursery/packed_simd"
+package = "packed_simd_2"
+version = "0.3.4"
 optional = true
 features = ["into_bits"]
 

README.md

@@ -103,9 +103,13 @@ Optionally, the following dependencies can be enabled:
 Additionally, these features configure Rand:
 
 -   `small_rng` enables inclusion of the `SmallRng` PRNG
--   `nightly` enables all experimental features
+-   `nightly` enables some optimizations requiring nightly Rust
 -   `simd_support` (experimental) enables sampling of SIMD values
-    (uniformly random SIMD integers and floats)
+    (uniformly random SIMD integers and floats), requiring nightly Rust
+
+Note that nightly features are not stable and therefore not all library and
+compiler versions will be compatible. This is especially true of Rand's
+experimental `simd_support` feature.
 
 Rand supports limited functionality in `no_std` mode (enabled via
 `default-features = false`). In this case, `OsRng` and `from_entropy` are

rand_chacha/src/guts.rs

@@ -101,6 +101,7 @@ impl ChaCha {
     }
 }
 
+#[allow(clippy::many_single_char_names)]
 #[inline(always)]
 fn refill_wide_impl<Mach: Machine>(
     m: Mach, state: &mut ChaCha, drounds: u32, out: &mut [u8; BUFSZ],

rand_core/Cargo.toml

@@ -25,7 +25,7 @@ serde1 = ["serde"] # enables serde for BlockRng wrapper
 
 [dependencies]
 serde = { version = "1", features = ["derive"], optional = true }
-getrandom = { version = "0.1", optional = true }
+getrandom = { version = "0.2", optional = true }
 
 [package.metadata.docs.rs]
 # To build locally:

rand_core/src/error.rs

@@ -28,10 +28,14 @@ pub struct Error {
 impl Error {
     /// Codes at or above this point can be used by users to define their own
     /// custom errors.
+    ///
+    /// This is identical to [`getrandom::Error::CUSTOM_START`](https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.CUSTOM_START).
     pub const CUSTOM_START: u32 = (1 << 31) + (1 << 30);
     /// Codes below this point represent OS Errors (i.e. positive i32 values).
     /// Codes at or above this point, but below [`Error::CUSTOM_START`] are
     /// reserved for use by the `rand` and `getrandom` crates.
+    ///
+    /// This is identical to [`getrandom::Error::INTERNAL_START`](https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.INTERNAL_START).
     pub const INTERNAL_START: u32 = 1 << 31;
 
     /// Construct from any type supporting `std::error::Error`
@@ -208,3 +212,14 @@ impl fmt::Display for ErrorCode {
 
 #[cfg(feature = "std")]
 impl std::error::Error for ErrorCode {}
+
+#[cfg(test)]
+mod test {
+    #[cfg(feature = "getrandom")]
+    #[test]
+    fn test_error_codes() {
+        // Make sure the values are the same as in `getrandom`.
+        assert_eq!(super::Error::CUSTOM_START, getrandom::Error::CUSTOM_START);
+        assert_eq!(super::Error::INTERNAL_START, getrandom::Error::INTERNAL_START);
+    }
+}

rand_core/src/lib.rs

@@ -35,7 +35,6 @@
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
-#![allow(clippy::unreadable_literal)]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
 #![no_std]
 

rand_distr/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+- New `Beta` sampling algorithm for improved performance and accuracy (#1000)
+- `Normal` and `LogNormal` now support `from_mean_cv` and `from_zscore` (#1044)
+- Variants of `NormalError` changed (#1044)
+
 ## [0.3.0] - 2020-08-25
 - Move alias method for `WeightedIndex` from `rand` (#945)
 - Rename `WeightedIndex` to `WeightedAliasIndex` (#1008)
@@ -12,7 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Remove `Distribution<u64>` impl for `Poisson` (#987)
 - Tweak `Dirichlet` and `alias_method` to use boxed slice instead of `Vec` (#987)
 - Use whitelist for package contents, reducing size by 5kb (#983)
-- Add case `lambda = 0` in the parametrixation of `Exp` (#972)
+- Add case `lambda = 0` in the parametrization of `Exp` (#972)
 - Implement inverse Gaussian distribution (#954)
 - Reformatting and use of `rustfmt::skip` (#926)
 - All error types now implement `std::error::Error` (#919)

rand_distr/benches/distributions.rs

@@ -20,7 +20,7 @@ use std::mem::size_of;
 use test::Bencher;
 
 use rand::prelude::*;
-use rand_distr::{weighted::WeightedIndex, *};
+use rand_distr::*;
 
 // At this time, distributions are optimised for 64-bit platforms.
 use rand_pcg::Pcg64Mcg;
@@ -112,11 +112,15 @@ distr_float!(distr_normal, f64, Normal::new(-1.23, 4.56).unwrap());
 distr_float!(distr_log_normal, f64, LogNormal::new(-1.23, 4.56).unwrap());
 distr_float!(distr_gamma_large_shape, f64, Gamma::new(10., 1.0).unwrap());
 distr_float!(distr_gamma_small_shape, f64, Gamma::new(0.1, 1.0).unwrap());
+distr_float!(distr_beta_small_param, f64, Beta::new(0.1, 0.1).unwrap());
+distr_float!(distr_beta_large_param_similar, f64, Beta::new(101., 95.).unwrap());
+distr_float!(distr_beta_large_param_different, f64, Beta::new(10., 1000.).unwrap());
+distr_float!(distr_beta_mixed_param, f64, Beta::new(0.5, 100.).unwrap());
 distr_float!(distr_cauchy, f64, Cauchy::new(4.2, 6.9).unwrap());
 distr_float!(distr_triangular, f64, Triangular::new(0., 1., 0.9).unwrap());
 distr_int!(distr_binomial, u64, Binomial::new(20, 0.7).unwrap());
 distr_int!(distr_binomial_small, u64, Binomial::new(1000000, 1e-30).unwrap());
-distr_int!(distr_poisson, u64, Poisson::new(4.0).unwrap());
+distr_float!(distr_poisson, f64, Poisson::new(4.0).unwrap());
 distr!(distr_bernoulli, bool, Bernoulli::new(0.18).unwrap());
 distr_arr!(distr_circle, [f64; 2], UnitCircle);
 distr_arr!(distr_sphere, [f64; 3], UnitSphere);
@@ -127,10 +131,10 @@ distr_int!(distr_weighted_u32, usize, WeightedIndex::new(&[1u32, 2, 3, 4, 12, 0,
 distr_int!(distr_weighted_f64, usize, WeightedIndex::new(&[1.0f64, 0.001, 1.0/3.0, 4.01, 0.0, 3.3, 22.0, 0.001]).unwrap());
 distr_int!(distr_weighted_large_set, usize, WeightedIndex::new((0..10000).rev().chain(1..10001)).unwrap());
 
-distr_int!(distr_weighted_alias_method_i8, usize, weighted::alias_method::WeightedIndex::new(vec![1i8, 2, 3, 4, 12, 0, 2, 1]).unwrap());
-distr_int!(distr_weighted_alias_method_u32, usize, weighted::alias_method::WeightedIndex::new(vec![1u32, 2, 3, 4, 12, 0, 2, 1]).unwrap());
-distr_int!(distr_weighted_alias_method_f64, usize, weighted::alias_method::WeightedIndex::new(vec![1.0f64, 0.001, 1.0/3.0, 4.01, 0.0, 3.3, 22.0, 0.001]).unwrap());
-distr_int!(distr_weighted_alias_method_large_set, usize, weighted::alias_method::WeightedIndex::new((0..10000).rev().chain(1..10001).collect()).unwrap());
+distr_int!(distr_weighted_alias_method_i8, usize, WeightedAliasIndex::new(vec![1i8, 2, 3, 4, 12, 0, 2, 1]).unwrap());
+distr_int!(distr_weighted_alias_method_u32, usize, WeightedAliasIndex::new(vec![1u32, 2, 3, 4, 12, 0, 2, 1]).unwrap());
+distr_int!(distr_weighted_alias_method_f64, usize, WeightedAliasIndex::new(vec![1.0f64, 0.001, 1.0/3.0, 4.01, 0.0, 3.3, 22.0, 0.001]).unwrap());
+distr_int!(distr_weighted_alias_method_large_set, usize, WeightedAliasIndex::new((0..10000).rev().chain(1..10001).collect()).unwrap());
 
 
 #[bench]

rand_distr/src/binomial.rs

@@ -12,6 +12,7 @@
 use crate::{Distribution, Uniform};
 use rand::Rng;
 use core::fmt;
+use core::cmp::Ordering;
 
 /// The binomial distribution `Binomial(n, p)`.
 ///
@@ -210,24 +211,28 @@ impl Distribution<u64> for Binomial {
                     let s = p / q;
                     let a = s * (n + 1.);
                     let mut f = 1.0;
-                    if m < y {
-                        let mut i = m;
-                        loop {
-                            i += 1;
-                            f *= a / (i as f64) - s;
-                            if i == y {
-                                break;
+                    match m.cmp(&y) {
+                        Ordering::Less => {
+                            let mut i = m;
+                            loop {
+                                i += 1;
+                                f *= a / (i as f64) - s;
+                                if i == y {
+                                    break;
+                                }
                             }
-                        }
-                    } else if m > y {
-                        let mut i = y;
-                        loop {
-                            i += 1;
-                            f /= a / (i as f64) - s;
-                            if i == m {
-                                break;
+                        },
+                        Ordering::Greater => {
+                            let mut i = y;
+                            loop {
+                                i += 1;
+                                f /= a / (i as f64) - s;
+                                if i == m {
+                                    break;
+                                }
                             }
-                        }
+                        },
+                        Ordering::Equal => {},
                     }
                     if v > f {
                         continue;