Rename "range" to "uniform"

benches/distributions.rs

@@ -70,31 +70,31 @@ macro_rules! distr {
     }
 }
 
-// range
-distr_int!(distr_range_i8, i8, Range::new(20i8, 100));
-distr_int!(distr_range_i16, i16, Range::new(-500i16, 2000));
-distr_int!(distr_range_i32, i32, Range::new(-200_000_000i32, 800_000_000));
-distr_int!(distr_range_i64, i64, Range::new(3i64, 123_456_789_123));
+// uniform
+distr_int!(distr_uniform_i8, i8, Uniform::new(20i8, 100));
+distr_int!(distr_uniform_i16, i16, Uniform::new(-500i16, 2000));
+distr_int!(distr_uniform_i32, i32, Uniform::new(-200_000_000i32, 800_000_000));
+distr_int!(distr_uniform_i64, i64, Uniform::new(3i64, 123_456_789_123));
 #[cfg(feature = "i128_support")]
-distr_int!(distr_range_i128, i128, Range::new(-123_456_789_123i128, 123_456_789_123_456_789));
+distr_int!(distr_uniform_i128, i128, Uniform::new(-123_456_789_123i128, 123_456_789_123_456_789));
 
-distr_float!(distr_range_f32, f32, Range::new(2.26f32, 2.319));
-distr_float!(distr_range_f64, f64, Range::new(2.26f64, 2.319));
+distr_float!(distr_uniform_f32, f32, Uniform::new(2.26f32, 2.319));
+distr_float!(distr_uniform_f64, f64, Uniform::new(2.26f64, 2.319));
 
-// 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);
+// standard
+distr_int!(distr_standard_i8, i8, Standard);
+distr_int!(distr_standard_i16, i16, Standard);
+distr_int!(distr_standard_i32, i32, Standard);
+distr_int!(distr_standard_i64, i64, Standard);
 #[cfg(feature = "i128_support")]
-distr_int!(distr_uniform_i128, i128, Standard);
+distr_int!(distr_standard_i128, i128, Standard);
 
-distr!(distr_uniform_bool, bool, Standard);
-distr!(distr_uniform_alphanumeric, char, Alphanumeric);
-distr!(distr_uniform_codepoint, char, Standard);
+distr!(distr_standard_bool, bool, Standard);
+distr!(distr_standard_alphanumeric, char, Alphanumeric);
+distr!(distr_standard_codepoint, char, Standard);
 
-distr_float!(distr_uniform_f32, f32, Standard);
-distr_float!(distr_uniform_f64, f64, Standard);
+distr_float!(distr_standard_f32, f32, Standard);
+distr_float!(distr_standard_f64, f64, Standard);
 
 // distributions
 distr_float!(distr_exp, f64, Exp::new(1.23 * 4.56));

examples/monte-carlo.rs

@@ -30,10 +30,10 @@
 
 extern crate rand;
 
-use rand::distributions::{Distribution, Range};
+use rand::distributions::{Distribution, Uniform};
 
 fn main() {
-   let range = Range::new(-1.0f64, 1.0);
+   let range = Uniform::new(-1.0f64, 1.0);
    let mut rng = rand::thread_rng();
 
    let total = 1_000_000;

examples/monty-hall.rs

@@ -33,15 +33,15 @@
 extern crate rand;
 
 use rand::Rng;
-use rand::distributions::{Distribution, Range};
+use rand::distributions::{Distribution, Uniform};
 
 struct SimulationResult {
     win: bool,
     switch: bool,
 }
 
 // Run a single simulation of the Monty Hall problem.
-fn simulate<R: Rng>(random_door: &Range<u32>, rng: &mut R)
+fn simulate<R: Rng>(random_door: &Uniform<u32>, rng: &mut R)
                     -> SimulationResult {
     let car = random_door.sample(rng);
 
@@ -82,7 +82,7 @@ fn main() {
     let num_simulations = 10000;
 
     let mut rng = rand::thread_rng();
-    let random_door = Range::new(0u32, 3);
+    let random_door = Uniform::new(0u32, 3);
 
     let (mut switch_wins, mut switch_losses) = (0, 0);
     let (mut keep_wins, mut keep_losses) = (0, 0);

src/distributions/mod.rs

@@ -13,20 +13,22 @@
 //! Distributions are stateless (i.e. immutable) objects controlling the
 //! production of values of some type `T` from a presumed uniform randomness
 //! source. These objects may have internal parameters set at contruction time
-//! (e.g. [`Range`], which has configurable bounds) or may have no internal
+//! (e.g. [`Uniform`], which has configurable bounds) or may have no internal
 //! parameters (e.g. [`Standard`]).
 //! 
 //! All distributions support the [`Distribution`] trait, and support usage
 //! via `distr.sample(&mut rng)` as well as via `rng.sample(distr)`.
 //! 
 //! [`Distribution`]: trait.Distribution.html
-//! [`Range`]: range/struct.Range.html
+//! [`Uniform`]: uniform/struct.Uniform.html
 //! [`Standard`]: struct.Standard.html
 
 use Rng;
 
 pub use self::other::Alphanumeric;
-pub use self::range::Range;
+pub use self::uniform::Uniform;
+#[deprecated(since="0.5.0", note="use Uniform instead")]
+pub use self::uniform::Uniform as Range;
 #[cfg(feature="std")]
 pub use self::gamma::{Gamma, ChiSquared, FisherF, StudentT};
 #[cfg(feature="std")]
@@ -38,7 +40,7 @@ pub use self::poisson::Poisson;
 #[cfg(feature = "std")]
 pub use self::binomial::Binomial;
 
-pub mod range;
+pub mod uniform;
 #[cfg(feature="std")]
 pub mod gamma;
 #[cfg(feature="std")]
@@ -80,6 +82,13 @@ pub trait IndependentSample<Support>: Sample<Support> {
     fn ind_sample<R: Rng>(&self, &mut R) -> Support;
 }
 
+/// DEPRECATED: Use `distributions::uniform` instead.
+#[deprecated(since="0.5.0", note="use uniform instead")]
+pub mod range {
+    pub use distributions::uniform::Uniform as Range;
+    pub use distributions::uniform::SampleUniform as SampleRange;
+}
+
 #[allow(deprecated)]
 mod impls {
     use Rng;
@@ -152,7 +161,7 @@ pub trait Distribution<T> {
     ///
     /// ```rust
     /// use rand::thread_rng;
-    /// use rand::distributions::{Distribution, Alphanumeric, Range, Standard};
+    /// use rand::distributions::{Distribution, Alphanumeric, Uniform, Standard};
     ///
     /// let mut rng = thread_rng();
     ///
@@ -163,7 +172,7 @@ pub trait Distribution<T> {
     /// let s: String = Alphanumeric.sample_iter(&mut rng).take(7).collect();
     ///
     /// // Dice-rolling:
-    /// let die_range = Range::new_inclusive(1, 6);
+    /// let die_range = Uniform::new_inclusive(1, 6);
     /// let mut roll_die = die_range.sample_iter(&mut rng);
     /// while roll_die.next().unwrap() != 6 {
     ///     println!("Not a 6; rolling again!");
@@ -343,7 +352,7 @@ pub struct Weighted<T> {
 #[derive(Debug)]
 pub struct WeightedChoice<'a, T:'a> {
     items: &'a mut [Weighted<T>],
-    weight_range: Range<u32>,
+    weight_range: Uniform<u32>,
 }
 
 impl<'a, T: Clone> WeightedChoice<'a, T> {
@@ -378,7 +387,7 @@ impl<'a, T: Clone> WeightedChoice<'a, T> {
             items,
             // we're likely to be generating numbers in this range
             // relatively often, so might as well cache it
-            weight_range: Range::new(0, running_total)
+            weight_range: Uniform::new(0, running_total)
         }
     }
 }
@@ -499,7 +508,7 @@ mod tests {
     fn test_weighted_choice() {
         // this makes assumptions about the internal implementation of
         // WeightedChoice. It may fail when the implementation in
-        // `distributions::range::RangeInt changes.
+        // `distributions::uniform::UniformInt` changes.
 
         macro_rules! t {
             ($items:expr, $expected:expr) => {{
@@ -511,7 +520,7 @@ mod tests {
                 let expected = $expected;
 
                 // Use extremely large steps between the random numbers, because
-                // we test with small ranges and RangeInt is designed to prefer
+                // we test with small ranges and `UniformInt` is designed to prefer
                 // the most significant bits.
                 let mut rng = StepRng::new(0, !0 / (total_weight as u64));
 

src/distributions/other.rs

@@ -13,7 +13,7 @@
 use core::char;
 
 use {Rng};
-use distributions::{Distribution, Standard, Range};
+use distributions::{Distribution, Standard, Uniform};
 
 // ----- Sampling distributions -----
 
@@ -43,7 +43,7 @@ pub struct Alphanumeric;
 impl Distribution<char> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> char {
-        let range = Range::new(0u32, 0x11_0000);
+        let range = Uniform::new(0u32, 0x11_0000);
         loop {
             match char::from_u32(range.sample(rng)) {
                 Some(c) => return c,
@@ -63,7 +63,7 @@ impl Distribution<char> for Alphanumeric {
                 abcdefghijklmnopqrstuvwxyz\
                 0123456789";
         // We can pick from 62 characters. This is so close to a power of 2, 64,
-        // that we can do better than `Range`. Use a simple bitshift and
+        // that we can do better than `Uniform`. Use a simple bitshift and
         // rejection sampling. We do not use a bitmask, because for small RNGs
         // the most significant bits are usually of higher quality.
         loop {