Merge branch 'master' into improve-beta

Author: vks

CHANGELOG.md

@@ -19,6 +19,7 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
   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)
 - Better NaN handling for `WeightedIndex` (#1005)
 - Implement `IntoIterator` for `IndexVec`, replacing the `into_iter` method (#1007)
 - Reduce packaged crate size (#983)

Cargo.toml

@@ -86,4 +86,7 @@ rand_hc = { path = "rand_hc", version = "0.2" }
 bincode = "1.2.1"
 
 [package.metadata.docs.rs]
+# To build locally:
+# RUSTDOCFLAGS="--cfg doc_cfg" cargo +nightly doc --all-features --no-deps --open
 all-features = true
+rustdoc-args = ["--cfg", "doc_cfg"]

benches/distributions.rs

@@ -176,7 +176,7 @@ distr_nz_int!(distr_standard_nz64, NonZeroU64, u64, Standard);
 distr_nz_int!(distr_standard_nz128, NonZeroU128, u128, Standard);
 
 distr!(distr_standard_bool, bool, Standard);
-distr!(distr_standard_alphanumeric, char, Alphanumeric);
+distr!(distr_standard_alphanumeric, u8, Alphanumeric);
 distr!(distr_standard_codepoint, char, Standard);
 
 distr_float!(distr_standard_f32, f32, Standard);

benches/seq.rs

@@ -177,3 +177,24 @@ sample_indices!(misc_sample_indices_100_of_1G, sample, 100, 1000_000_000);
 sample_indices!(misc_sample_indices_200_of_1G, sample, 200, 1000_000_000);
 sample_indices!(misc_sample_indices_400_of_1G, sample, 400, 1000_000_000);
 sample_indices!(misc_sample_indices_600_of_1G, sample, 600, 1000_000_000);
+
+macro_rules! sample_indices_rand_weights {
+    ($name:ident, $amount:expr, $length:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut rng = SmallRng::from_rng(thread_rng()).unwrap();
+            b.iter(|| {
+                index::sample_weighted(&mut rng, $length, |idx| (1 + (idx % 100)) as u32, $amount)
+            })
+        }
+    };
+}
+
+sample_indices_rand_weights!(misc_sample_weighted_indices_1_of_1k, 1, 1000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_10_of_1k, 10, 1000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_100_of_1k, 100, 1000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_100_of_1M, 100, 1000_000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_200_of_1M, 200, 1000_000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_400_of_1M, 400, 1000_000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_600_of_1M, 600, 1000_000);
+sample_indices_rand_weights!(misc_sample_weighted_indices_1k_of_1M, 1000, 1000_000);

rand_core/Cargo.toml

@@ -28,4 +28,7 @@ serde = { version = "1", features = ["derive"], optional = true }
 getrandom = { version = "0.1", optional = true }
 
 [package.metadata.docs.rs]
+# To build locally:
+# RUSTDOCFLAGS="--cfg doc_cfg" cargo +nightly doc --all-features --no-deps --open
 all-features = true
+rustdoc-args = ["--cfg", "doc_cfg"]

rand_core/src/block.rs

@@ -21,12 +21,14 @@
 //!
 //! # Example
 //!
-//! ```norun
+//! ```no_run
+//! use rand_core::{RngCore, SeedableRng};
 //! use rand_core::block::{BlockRngCore, BlockRng};
 //!
 //! struct MyRngCore;
 //!
 //! impl BlockRngCore for MyRngCore {
+//!     type Item = u32;
 //!     type Results = [u32; 16];
 //!
 //!     fn generate(&mut self, results: &mut Self::Results) {
@@ -35,7 +37,7 @@
 //! }
 //!
 //! impl SeedableRng for MyRngCore {
-//!     type Seed = unimplemented!();
+//!     type Seed = [u8; 32];
 //!     fn from_seed(seed: Self::Seed) -> Self {
 //!         unimplemented!()
 //!     }
@@ -44,7 +46,8 @@
 //! // optionally, also implement CryptoRng for MyRngCore
 //!
 //! // Final RNG.
-//! type MyRng = BlockRng<u32, MyRngCore>;
+//! let mut rng = BlockRng::<MyRngCore>::seed_from_u64(0);
+//! println!("First value: {}", rng.next_u32());
 //! ```
 //!
 //! [`BlockRngCore`]: crate::block::BlockRngCore
@@ -54,7 +57,8 @@ use crate::impls::{fill_via_u32_chunks, fill_via_u64_chunks};
 use crate::{CryptoRng, Error, RngCore, SeedableRng};
 use core::convert::AsRef;
 use core::fmt;
-#[cfg(feature = "serde1")] use serde::{Deserialize, Serialize};
+#[cfg(feature = "serde1")]
+use serde::{Deserialize, Serialize};
 
 /// A trait for RNGs which do not generate random numbers individually, but in
 /// blocks (typically `[u32; N]`). This technique is commonly used by
@@ -73,7 +77,6 @@ pub trait BlockRngCore {
     fn generate(&mut self, results: &mut Self::Results);
 }
 
-
 /// A wrapper type implementing [`RngCore`] for some type implementing
 /// [`BlockRngCore`] with `u32` array buffer; i.e. this can be used to implement
 /// a full RNG from just a `generate` function.
@@ -170,7 +173,8 @@ impl<R: BlockRngCore> BlockRng<R> {
 }
 
 impl<R: BlockRngCore<Item = u32>> RngCore for BlockRng<R>
-where <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>
+where
+    <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>,
 {
     #[inline]
     fn next_u32(&mut self) -> u32 {
@@ -249,7 +253,6 @@ impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng<R> {
     }
 }
 
-
 /// A wrapper type implementing [`RngCore`] for some type implementing
 /// [`BlockRngCore`] with `u64` array buffer; i.e. this can be used to implement
 /// a full RNG from just a `generate` function.
@@ -338,7 +341,8 @@ impl<R: BlockRngCore> BlockRng64<R> {
 }
 
 impl<R: BlockRngCore<Item = u64>> RngCore for BlockRng64<R>
-where <R as BlockRngCore>::Results: AsRef<[u64]> + AsMut<[u64]>
+where
+    <R as BlockRngCore>::Results: AsRef<[u64]> + AsMut<[u64]>,
 {
     #[inline]
     fn next_u32(&mut self) -> u32 {

rand_core/src/error.rs

@@ -11,7 +11,6 @@
 use core::fmt;
 use core::num::NonZeroU32;
 
-
 /// Error type of random number generators
 ///
 /// In order to be compatible with `std` and `no_std`, this type has two
@@ -39,9 +38,12 @@ impl Error {
     ///
     /// See also `From<NonZeroU32>`, which is available with and without `std`.
     #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
     #[inline]
     pub fn new<E>(err: E) -> Self
-    where E: Into<Box<dyn std::error::Error + Send + Sync + 'static>> {
+    where
+        E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
+    {
         Error { inner: err.into() }
     }
 
@@ -50,6 +52,7 @@ impl Error {
     /// When configured with `std`, this is a trivial operation and never
     /// panics. Without `std`, this method is simply unavailable.
     #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
     #[inline]
     pub fn inner(&self) -> &(dyn std::error::Error + Send + Sync + 'static) {
         &*self.inner
@@ -60,6 +63,7 @@ impl Error {
     /// When configured with `std`, this is a trivial operation and never
     /// panics. Without `std`, this method is simply unavailable.
     #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
     #[inline]
     pub fn take_inner(self) -> Box<dyn std::error::Error + Send + Sync + 'static> {
         self.inner

rand_core/src/impls.rs

@@ -23,7 +23,6 @@ use core::mem::size_of;
 use core::ptr::copy_nonoverlapping;
 use core::slice;
 
-
 /// Implement `next_u64` via `next_u32`, little-endian order.
 pub fn next_u64_via_u32<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
     // Use LE; we explicitly generate one value before the next.

rand_core/src/lib.rs

@@ -37,7 +37,7 @@
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![allow(clippy::unreadable_literal)]
 #![cfg_attr(not(feature = "std"), no_std)]
-
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
 
 use core::convert::AsMut;
 use core::default::Default;
@@ -364,6 +364,7 @@ pub trait SeedableRng: Sized {
     ///
     /// [`getrandom`]: https://docs.rs/getrandom
     #[cfg(feature = "getrandom")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "getrandom")))]
     fn from_entropy() -> Self {
         let mut seed = Self::Seed::default();
         if let Err(err) = getrandom::getrandom(seed.as_mut()) {

rand_core/src/os.rs

@@ -43,6 +43,7 @@ use getrandom::getrandom;
 /// ```
 ///
 /// [getrandom]: https://crates.io/crates/getrandom
+#[cfg_attr(doc_cfg, doc(cfg(feature = "getrandom")))]
 #[derive(Clone, Copy, Debug, Default)]
 pub struct OsRng;
 

rand_distr/CHANGELOG.md

@@ -4,16 +4,20 @@ 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
+## [0.3.0] - 2020-08-25
 - Move alias method for `WeightedIndex` from `rand` (#945)
+- Rename `WeightedIndex` to `WeightedAliasIndex` (#1008)
 - Replace custom `Float` trait with `num-traits::Float` (#987)
 - Enable `no_std` support via `num-traits` math functions (#987)
 - 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)
 - Implement inverse Gaussian distribution (#954)
+- Reformatting and use of `rustfmt::skip` (#926)
 - All error types now implement `std::error::Error` (#919)
 - Re-exported `rand::distributions::BernoulliError` (#919)
-- Add case `lambda = 0` in the parametrixation of `Exp` (#972)
+- Add value stability tests for distributions (#891)
 - Improve algorithm for sampling `Beta` (#1000)
 
 ## [0.2.2] - 2019-09-10

rand_distr/src/dirichlet.rs

@@ -31,6 +31,7 @@ use alloc::{boxed::Box, vec, vec::Vec};
 /// 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")))]
 #[derive(Clone, Debug)]
 pub struct Dirichlet<F>
 where
@@ -44,6 +45,7 @@ where
 }
 
 /// Error type returned from `Dirchlet::new`.
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Error {
     /// `alpha.len() < 2`.

rand_distr/src/exponential.rs

@@ -124,7 +124,7 @@ where F: Float, Exp1: Distribution<F>
     /// 
     /// # Remarks
     /// 
-    /// For custom types `N` implementing the [`Float`](crate::Float) trait, 
+    /// For custom types `N` implementing the [`Float`] trait,
     /// the case `lambda = 0` is handled as follows: each sample corresponds
     /// to a sample from an `Exp1` multiplied by `1 / 0`. Primitive types 
     /// yield infinity, since `1 / 0 = infinity`.

rand_distr/src/lib.rs

@@ -20,6 +20,7 @@
 )]
 #![allow(clippy::neg_cmp_op_on_partial_ord)] // suggested fix too verbose
 #![no_std]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
 
 //! Generating random samples from probability distributions.
 //!
@@ -107,13 +108,15 @@ pub use self::unit_disc::UnitDisc;
 pub use self::unit_sphere::UnitSphere;
 pub use self::weibull::{Error as WeibullError, Weibull};
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub use rand::distributions::weighted::{WeightedError, WeightedIndex};
 #[cfg(feature = "alloc")]
 pub use weighted_alias::WeightedAliasIndex;
 
 pub use num_traits;
 
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod weighted_alias;
 
 mod binomial;

rand_distr/src/weighted_alias.rs

@@ -63,6 +63,7 @@ use alloc::{boxed::Box, vec, vec::Vec};
 /// [`Vec<u32>`]: Vec
 /// [`Uniform<u32>::sample`]: Distribution::sample
 /// [`Uniform<W>::sample`]: Distribution::sample
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub struct WeightedAliasIndex<W: AliasableWeight> {
     aliases: Box<[u32]>,
     no_alias_odds: Box<[W]>,
@@ -269,6 +270,7 @@ where Uniform<W>: Clone
 /// Trait that must be implemented for weights, that are used with
 /// [`WeightedAliasIndex`]. Currently no guarantees on the correctness of
 /// [`WeightedAliasIndex`] are given for custom implementations of this trait.
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub trait AliasableWeight:
     Sized
     + Copy

src/distributions/mod.rs

@@ -108,7 +108,9 @@ mod bernoulli;
 pub mod uniform;
 
 #[deprecated(since = "0.8.0", note = "use rand::distributions::{WeightedIndex, WeightedError} instead")]
-#[cfg(feature = "alloc")] pub mod weighted;
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod weighted;
 #[cfg(feature = "alloc")] mod weighted_index;
 
 #[cfg(feature = "serde1")]
@@ -166,7 +168,7 @@ pub trait Distribution<T> {
     /// let v: Vec<f32> = Standard.sample_iter(rng).take(16).collect();
     ///
     /// // String:
-    /// let s: String = Alphanumeric.sample_iter(rng).take(7).collect();
+    /// let s: String = Alphanumeric.sample_iter(rng).take(7).map(char::from).collect();
     ///
     /// // Dice-rolling:
     /// let die_range = Uniform::new_inclusive(1, 6);

src/distributions/other.rs

@@ -19,7 +19,7 @@ use serde::{Serialize, Deserialize};
 
 // ----- Sampling distributions -----
 
-/// Sample a `char`, uniformly distributed over ASCII letters and numbers:
+/// Sample a `u8`, uniformly distributed over ASCII letters and numbers:
 /// a-z, A-Z and 0-9.
 ///
 /// # Example
@@ -32,6 +32,7 @@ use serde::{Serialize, Deserialize};
 /// let mut rng = thread_rng();
 /// let chars: String = iter::repeat(())
 ///         .map(|()| rng.sample(Alphanumeric))
+///         .map(char::from)
 ///         .take(7)
 ///         .collect();
 /// println!("Random chars: {}", chars);
@@ -81,8 +82,8 @@ impl Distribution<char> for Standard {
     }
 }
 
-impl Distribution<char> for Alphanumeric {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> char {
+impl Distribution<u8> for Alphanumeric {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
         const RANGE: u32 = 26 + 26 + 10;
         const GEN_ASCII_STR_CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                 abcdefghijklmnopqrstuvwxyz\
@@ -94,7 +95,7 @@ impl Distribution<char> for Alphanumeric {
         loop {
             let var = rng.next_u32() >> (32 - 6);
             if var < RANGE {
-                return GEN_ASCII_STR_CHARSET[var as usize] as char;
+                return GEN_ASCII_STR_CHARSET[var as usize];
             }
         }
     }
@@ -238,7 +239,7 @@ mod tests {
         // take the rejection sampling path.
         let mut incorrect = false;
         for _ in 0..100 {
-            let c = rng.sample(Alphanumeric);
+            let c: char = rng.sample(Alphanumeric).into();
             incorrect |= !((c >= '0' && c <= '9') ||
                            (c >= 'A' && c <= 'Z') ||
                            (c >= 'a' && c <= 'z') );
@@ -266,7 +267,7 @@ mod tests {
             '\u{ed692}',
             '\u{35888}',
         ]);
-        test_samples(&Alphanumeric, 'a', &['h', 'm', 'e', '3', 'M']);
+        test_samples(&Alphanumeric, 0, &[104, 109, 101, 51, 77]);
         test_samples(&Standard, false, &[true, true, false, true, false]);
         test_samples(&Standard, None as Option<bool>, &[
             Some(true),

src/distributions/utils.rs

@@ -11,7 +11,7 @@
 #[cfg(feature = "simd_support")] use packed_simd::*;
 
 
-pub trait WideningMultiply<RHS = Self> {
+pub(crate) trait WideningMultiply<RHS = Self> {
     type Output;
 
     fn wmul(self, x: RHS) -> Self::Output;
@@ -208,9 +208,6 @@ mod simd_wmul {
     wmul_impl_large! { (u32x16,) u32, 16 }
     wmul_impl_large! { (u64x2, u64x4, u64x8,) u64, 32 }
 }
-#[cfg(all(feature = "simd_support", feature = "nightly"))]
-pub use self::simd_wmul::*;
-
 
 /// Helper trait when dealing with scalar and SIMD floating point types.
 pub(crate) trait FloatSIMDUtils {