Rename uniform

CHANGELOG.md

@@ -80,16 +80,16 @@ You may also find the [Update Guide](UPDATING.md) useful.
 ### Distributions
 - New `Distribution` trait. (#256)
 - Deprecate `Rand`, `Sample` and `IndependentSample` traits. (#256)
-- Add a `Uniform` distribution (replaces most `Rand` implementations). (#256)
+- Add a `Standard` distribution (replaces most `Rand` implementations). (#256)
 - Add `Binomial` and `Poisson` distributions. (#96)
 - Add `Alphanumeric` distribution. (#279)
-- Remove `Open01` and `Closed01` distributions, use `Uniform` instead (open distribution). (#274)
+- Remove `Open01` and `Closed01` distributions, use `Standard` instead (open distribution). (#274)
 - Rework `Range` type, making it possible to implement it for user types. (#274)
 - Add `Range::new_inclusive` for inclusive ranges. (#274)
 - Add `Range::sample_single` to allow for optimized implementations. (#274)
 - Use widening multiply method for much faster integer range reduction. (#274)
-- `Uniform` distributions for `bool` uses `Range`. (#274)
-- `Uniform` distributions for `bool` uses sign test. (#274)
+- `Standard` distributions for `bool` uses `Range`. (#274)
+- `Standard` distributions for `bool` uses sign test. (#274)
 
 
 ## [0.4.2] - 2018-01-06

README.md

@@ -84,7 +84,8 @@ The `rand` crate provides:
 -   pseudo-random number generators: `StdRng`, `SmallRng`, `prng` module
 -   convenient, auto-seeded crypto-grade thread-local generator: `thread_rng`
 -   `distributions` producing many different types of random values:
-    -   `Uniform`-ly distributed integers and floats of many types
+    -   a `Standard` distribution for integers, floats,and derived types
+        including tuples, arrays and `Option`
     -   unbiased sampling from specified `Range`s
     -   sampling from exponential/normal/gamma distributions
     -   sampling from binomial/poisson distributions

UPDATING.md

@@ -198,8 +198,8 @@ cryptographic generator, used by `StdRng` and `thread_rng()`.
 ### Helper functions/traits
 
 The `Rand` trait has been deprecated. Instead, users are encouraged to use
-`Uniform` which is a real distribution and supports the same sampling as `Rand`.
-`Rng::gen()` now uses `Uniform` and should work exactly as before.
+`Standard` which is a real distribution and supports the same sampling as
+ `Rand`.`Rng::gen()` now uses `Standard` and should work exactly as before.
 
 The `random()` function has been removed; users may simply use
 `thread_rng().gen()` instead or may choose to cache
@@ -221,18 +221,18 @@ removed in a future release.
 `Distribution::sample` (as well as several other functions) can now be called
 directly on type-erased (unsized) RNGs.
 
-`RandSample` has been removed (see `Rand` deprecation and new `Uniform`
+`RandSample` has been removed (see `Rand` deprecation and new `Standard`
 distribution).
 
 The `Open01` and `Closed01` wrappers have been removed. `Rng::gen()` (via
-`Uniform`) now yields samples from `(0, 1)` for floats; i.e. the same as the old
-`Open01`. This is considered sufficient for most uses.
+`Standard`) now yields samples from `(0, 1)` for floats; i.e. the same as the
+old `Open01`. This is considered sufficient for most uses.
 
 #### Uniform distributions
 
 Two new distributions are available:
 
--   `Uniform` produces uniformly-distributed samples for many different types,
+-   `Standard` produces uniformly-distributed samples for many different types,
     and acts as a replacement for `Rand`
 -   `Alphanumeric` samples `char`s from the ranges `a-z A-Z 0-9`
 

benches/distributions.rs

@@ -82,19 +82,19 @@ distr_float!(distr_range_f32, f32, Range::new(2.26f32, 2.319));
 distr_float!(distr_range_f64, f64, Range::new(2.26f64, 2.319));
 
 // uniform
-distr_int!(distr_uniform_i8, i8, Uniform);
-distr_int!(distr_uniform_i16, i16, Uniform);
-distr_int!(distr_uniform_i32, i32, Uniform);
-distr_int!(distr_uniform_i64, i64, Uniform);
+distr_int!(distr_uniform_i8, i8, Standard);
+distr_int!(distr_uniform_i16, i16, Standard);
+distr_int!(distr_uniform_i32, i32, Standard);
+distr_int!(distr_uniform_i64, i64, Standard);
 #[cfg(feature = "i128_support")]
-distr_int!(distr_uniform_i128, i128, Uniform);
+distr_int!(distr_uniform_i128, i128, Standard);
 
-distr!(distr_uniform_bool, bool, Uniform);
+distr!(distr_uniform_bool, bool, Standard);
 distr!(distr_uniform_alphanumeric, char, Alphanumeric);
-distr!(distr_uniform_codepoint, char, Uniform);
+distr!(distr_uniform_codepoint, char, Standard);
 
-distr_float!(distr_uniform_f32, f32, Uniform);
-distr_float!(distr_uniform_f64, f64, Uniform);
+distr_float!(distr_uniform_f32, f32, Standard);
+distr_float!(distr_uniform_f64, f64, Standard);
 
 // distributions
 distr_float!(distr_exp, f64, Exp::new(1.23 * 4.56));

benches/misc.rs

@@ -113,10 +113,10 @@ fn gen_1k_gen_iter(b: &mut Bencher) {
 
 #[bench]
 fn gen_1k_sample_iter(b: &mut Bencher) {
-    use rand::distributions::{Distribution, Uniform};
+    use rand::distributions::{Distribution, Standard};
     let mut rng = SmallRng::from_rng(&mut thread_rng()).unwrap();
     b.iter(|| {
-        let v: Vec<u64> = Uniform.sample_iter(&mut rng).take(128).collect();
+        let v: Vec<u64> = Standard.sample_iter(&mut rng).take(128).collect();
         black_box(v);
     });
     b.bytes = 1024;

src/distributions/float.rs

@@ -12,7 +12,7 @@
 
 use core::mem;
 use Rng;
-use distributions::{Distribution, Uniform};
+use distributions::{Distribution, Standard};
 
 pub(crate) trait IntoFloat {
     type F;
@@ -42,7 +42,7 @@ macro_rules! float_impls {
             }
         }
 
-        impl Distribution<$ty> for Uniform {
+        impl Distribution<$ty> for Standard {
             /// Generate a floating point number in the open interval `(0, 1)`
             /// (not including either endpoint) with a uniform distribution.
             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {

src/distributions/gamma.rs

@@ -13,9 +13,9 @@
 use self::GammaRepr::*;
 use self::ChiSquaredRepr::*;
 
-use {Rng};
+use Rng;
 use distributions::normal::StandardNormal;
-use distributions::{Distribution, Exp, Uniform};
+use distributions::{Distribution, Exp};
 
 /// The Gamma distribution `Gamma(shape, scale)` distribution.
 ///
@@ -142,7 +142,7 @@ impl Distribution<f64> for Gamma {
 }
 impl Distribution<f64> for GammaSmallShape {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
-        let u: f64 = rng.sample(Uniform);
+        let u: f64 = rng.gen();
 
         self.large_shape.sample(rng) * u.powf(self.inv_shape)
     }
@@ -157,7 +157,7 @@ impl Distribution<f64> for GammaLargeShape {
             }
 
             let v = v_cbrt * v_cbrt * v_cbrt;
-            let u: f64 = rng.sample(Uniform);
+            let u: f64 = rng.gen();
 
             let x_sqr = x * x;
             if u < 1.0 - 0.0331 * x_sqr * x_sqr ||

src/distributions/integer.rs

@@ -8,55 +8,55 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The implementations of the `Uniform` distribution for integer types.
+//! The implementations of the `Standard` distribution for integer types.
 
 use {Rng};
-use distributions::{Distribution, Uniform};
+use distributions::{Distribution, Standard};
 
-impl Distribution<isize> for Uniform {
+impl Distribution<isize> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> isize {
         rng.gen::<usize>() as isize
     }
 }
 
-impl Distribution<i8> for Uniform {
+impl Distribution<i8> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i8 {
         rng.next_u32() as i8
     }
 }
 
-impl Distribution<i16> for Uniform {
+impl Distribution<i16> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i16 {
         rng.next_u32() as i16
     }
 }
 
-impl Distribution<i32> for Uniform {
+impl Distribution<i32> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i32 {
         rng.next_u32() as i32
     }
 }
 
-impl Distribution<i64> for Uniform {
+impl Distribution<i64> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i64 {
         rng.next_u64() as i64
     }
 }
 
 #[cfg(feature = "i128_support")]
-impl Distribution<i128> for Uniform {
+impl Distribution<i128> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i128 {
         rng.gen::<u128>() as i128
     }
 }
 
-impl Distribution<usize> for Uniform {
+impl Distribution<usize> for Standard {
     #[inline]
     #[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {
@@ -70,36 +70,36 @@ impl Distribution<usize> for Uniform {
     }
 }
 
-impl Distribution<u8> for Uniform {
+impl Distribution<u8> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
         rng.next_u32() as u8
     }
 }
 
-impl Distribution<u16> for Uniform {
+impl Distribution<u16> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
         rng.next_u32() as u16
     }
 }
 
-impl Distribution<u32> for Uniform {
+impl Distribution<u32> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
         rng.next_u32()
     }
 }
 
-impl Distribution<u64> for Uniform {
+impl Distribution<u64> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
         rng.next_u64()
     }
 }
 
 #[cfg(feature = "i128_support")]
-impl Distribution<u128> for Uniform {
+impl Distribution<u128> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
         // Use LE; we explicitly generate one value before the next.
@@ -113,26 +113,26 @@ impl Distribution<u128> for Uniform {
 #[cfg(test)]
 mod tests {
     use Rng;
-    use distributions::{Uniform};
+    use distributions::{Standard};
 
     #[test]
     fn test_integers() {
         let mut rng = ::test::rng(806);
 
-        rng.sample::<isize, _>(Uniform);
-        rng.sample::<i8, _>(Uniform);
-        rng.sample::<i16, _>(Uniform);
-        rng.sample::<i32, _>(Uniform);
-        rng.sample::<i64, _>(Uniform);
+        rng.sample::<isize, _>(Standard);
+        rng.sample::<i8, _>(Standard);
+        rng.sample::<i16, _>(Standard);
+        rng.sample::<i32, _>(Standard);
+        rng.sample::<i64, _>(Standard);
         #[cfg(feature = "i128_support")]
-        rng.sample::<i128, _>(Uniform);
+        rng.sample::<i128, _>(Standard);
 
-        rng.sample::<usize, _>(Uniform);
-        rng.sample::<u8, _>(Uniform);
-        rng.sample::<u16, _>(Uniform);
-        rng.sample::<u32, _>(Uniform);
-        rng.sample::<u64, _>(Uniform);
+        rng.sample::<usize, _>(Standard);
+        rng.sample::<u8, _>(Standard);
+        rng.sample::<u16, _>(Standard);
+        rng.sample::<u32, _>(Standard);
+        rng.sample::<u64, _>(Standard);
         #[cfg(feature = "i128_support")]
-        rng.sample::<u128, _>(Uniform);
+        rng.sample::<u128, _>(Standard);
     }
 }

src/distributions/mod.rs

@@ -140,12 +140,12 @@ pub trait Distribution<T> {
     ///
     /// ```rust
     /// use rand::thread_rng;
-    /// use rand::distributions::{Distribution, Alphanumeric, Range, Uniform};
+    /// use rand::distributions::{Distribution, Alphanumeric, Range, Standard};
     ///
     /// let mut rng = thread_rng();
     ///
     /// // Vec of 16 x f32:
-    /// let v: Vec<f32> = Uniform.sample_iter(&mut rng).take(16).collect();
+    /// let v: Vec<f32> = Standard.sample_iter(&mut rng).take(16).collect();
     ///
     /// // String:
     /// let s: String = Alphanumeric.sample_iter(&mut rng).take(7).collect();
@@ -208,7 +208,7 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 ///
 /// ## Built-in Implementations
 ///
-/// This crate implements the distribution `Uniform` for various primitive
+/// This crate implements the distribution `Standard` for various primitive
 /// types.  Assuming the provided `Rng` is well-behaved, these implementations
 /// generate values with the following ranges and distributions:
 ///
@@ -222,32 +222,32 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 /// * Floating point types (`f32` and `f64`): Uniformly distributed in the
 ///   open range `(0, 1)`.
 ///
-/// The following aggregate types also implement the distribution `Uniform` as
+/// The following aggregate types also implement the distribution `Standard` as
 /// long as their component types implement it:
 ///
 /// * Tuples and arrays: Each element of the tuple or array is generated
-///   independently, using the `Uniform` distribution recursively.
+///   independently, using the `Standard` distribution recursively.
 /// * `Option<T>`: Returns `None` with probability 0.5; otherwise generates a
 ///   random `T` and returns `Some(T)`.
 ///
 /// # Example
 /// ```rust
 /// use rand::{NewRng, SmallRng, Rng};
-/// use rand::distributions::Uniform;
+/// use rand::distributions::Standard;
 ///
-/// let val: f32 = SmallRng::new().sample(Uniform);
+/// let val: f32 = SmallRng::new().sample(Standard);
 /// println!("f32 from (0,1): {}", val);
 /// ```
 ///
 /// With dynamic dispatch (type erasure of `Rng`):
 /// 
 /// ```rust
 /// use rand::{thread_rng, Rng, RngCore};
-/// use rand::distributions::Uniform;
+/// use rand::distributions::Standard;
 ///
 /// let mut rng = thread_rng();
 /// let erased_rng: &mut RngCore = &mut rng;
-/// let val: f32 = erased_rng.sample(Uniform);
+/// let val: f32 = erased_rng.sample(Standard);
 /// println!("f32 from (0,1): {}", val);
 /// ```
 ///
@@ -274,12 +274,12 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 /// [`Exp1`]: struct.Exp1.html
 /// [`StandardNormal`]: struct.StandardNormal.html
 #[derive(Debug)]
-pub struct Uniform;
+pub struct Standard;
 
 #[allow(deprecated)]
-impl<T> ::Rand for T where Uniform: Distribution<T> {
+impl<T> ::Rand for T where Standard: Distribution<T> {
     fn rand<R: Rng>(rng: &mut R) -> Self {
-        Uniform.sample(rng)
+        Standard.sample(rng)
     }
 }