#![feature(macro_rules, phase, globs)]
#![feature(unboxed_closures)]
+#![feature(associated_types)]
#![no_std]
#![experimental]
mod rand_impls;
/// A type that can be randomly generated using an `Rng`.
-pub trait Rand {
+pub trait Rand : Sized {
/// Generates a random instance of this type using the specified source of
/// randomness.
fn rand<R: Rng>(rng: &mut R) -> Self;
}
/// A random number generator.
-pub trait Rng {
+pub trait Rng : Sized {
/// Return the next random u32.
///
/// This rarely needs to be called directly, prefer `r.gen()` to
/// these two methods. Similarly to `next_u32`, this rarely needs
/// to be called directly, prefer `r.gen()` to `r.next_u64()`.
fn next_u64(&mut self) -> u64 {
- (self.next_u32() as u64 << 32) | (self.next_u32() as u64)
+ ((self.next_u32() as u64) << 32) | (self.next_u32() as u64)
}
/// Return the next random f32 selected from the half-open
/// # Example
///
/// ```rust
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let mut v = [0u8, .. 13579];
- /// task_rng().fill_bytes(&mut v);
+ /// let mut v = [0u8; 13579];
+ /// thread_rng().fill_bytes(&mut v);
/// println!("{}", v.as_slice());
/// ```
fn fill_bytes(&mut self, dest: &mut [u8]) {
/// # Example
///
/// ```rust
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let mut rng = task_rng();
+ /// let mut rng = thread_rng();
/// let x: uint = rng.gen();
/// println!("{}", x);
/// println!("{}", rng.gen::<(f64, bool)>());
/// # Example
///
/// ```
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let mut rng = task_rng();
+ /// let mut rng = thread_rng();
/// let x = rng.gen_iter::<uint>().take(10).collect::<Vec<uint>>();
/// println!("{}", x);
/// println!("{}", rng.gen_iter::<(f64, bool)>().take(5)
/// # Example
///
/// ```rust
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let mut rng = task_rng();
+ /// let mut rng = thread_rng();
/// let n: uint = rng.gen_range(0u, 10);
/// println!("{}", n);
/// let m: f64 = rng.gen_range(-40.0f64, 1.3e5f64);
/// # Example
///
/// ```rust
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let mut rng = task_rng();
+ /// let mut rng = thread_rng();
/// println!("{}", rng.gen_weighted_bool(3));
/// ```
fn gen_weighted_bool(&mut self, n: uint) -> bool {
- n == 0 || self.gen_range(0, n) == 0
+ n <= 1 || self.gen_range(0, n) == 0
}
/// Return an iterator of random characters from the set A-Z,a-z,0-9.
/// # Example
///
/// ```rust
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let s: String = task_rng().gen_ascii_chars().take(10).collect();
+ /// let s: String = thread_rng().gen_ascii_chars().take(10).collect();
/// println!("{}", s);
/// ```
fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> {
/// # Example
///
/// ```
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let choices = [1i, 2, 4, 8, 16, 32];
- /// let mut rng = task_rng();
+ /// let choices = [1, 2, 4, 8, 16, 32];
+ /// let mut rng = thread_rng();
/// println!("{}", rng.choose(&choices));
- /// assert_eq!(rng.choose(choices[..0]), None);
+ /// # // replace with slicing syntax when it's stable!
+ /// assert_eq!(rng.choose(choices.slice_to(0)), None);
/// ```
fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
if values.is_empty() {
/// # Example
///
/// ```rust
- /// use std::rand::{task_rng, Rng};
+ /// use std::rand::{thread_rng, Rng};
///
- /// let mut rng = task_rng();
- /// let mut y = [1i, 2, 3];
+ /// let mut rng = thread_rng();
+ /// let mut y = [1, 2, 3];
/// rng.shuffle(&mut y);
/// println!("{}", y.as_slice());
/// rng.shuffle(&mut y);
rng: &'a mut R,
}
-impl<'a, T: Rand, R: Rng> Iterator<T> for Generator<'a, T, R> {
+impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R> {
+ type Item = T;
+
fn next(&mut self) -> Option<T> {
Some(self.rng.gen())
}
rng: &'a mut R,
}
-impl<'a, R: Rng> Iterator<char> for AsciiGenerator<'a, R> {
+impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R> {
+ type Item = char;
+
fn next(&mut self) -> Option<char> {
static GEN_ASCII_STR_CHARSET: &'static [u8] =
b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
/// RNGs"](http://www.jstatsoft.org/v08/i14/paper). *Journal of
/// Statistical Software*. Vol. 8 (Issue 14).
#[allow(missing_copy_implementations)]
+#[deriving(Clone)]
pub struct XorShiftRng {
x: u32,
y: u32,
w: u32,
}
-impl Clone for XorShiftRng {
- fn clone(&self) -> XorShiftRng {
- XorShiftRng {
- x: self.x,
- y: self.y,
- z: self.z,
- w: self.w,
- }
- }
-}
-
impl XorShiftRng {
/// Creates a new XorShiftRng instance which is not seeded.
///
}
}
-impl SeedableRng<[u32, .. 4]> for XorShiftRng {
+impl SeedableRng<[u32; 4]> for XorShiftRng {
/// Reseed an XorShiftRng. This will panic if `seed` is entirely 0.
- fn reseed(&mut self, seed: [u32, .. 4]) {
+ fn reseed(&mut self, seed: [u32; 4]) {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng.reseed called with an all zero seed.");
}
/// Create a new XorShiftRng. This will panic if `seed` is entirely 0.
- fn from_seed(seed: [u32, .. 4]) -> XorShiftRng {
+ fn from_seed(seed: [u32; 4]) -> XorShiftRng {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng::from_seed called with an all zero seed.");
#[cfg(not(test))]
mod std {
pub use core::{option, fmt}; // panic!()
+ pub use core::clone; // derive Clone
pub use core::kinds;
}
}
}
- pub fn rng() -> MyRng<rand::TaskRng> {
- MyRng { inner: rand::task_rng() }
+ pub fn rng() -> MyRng<rand::ThreadRng> {
+ MyRng { inner: rand::thread_rng() }
}
pub fn weak_rng() -> MyRng<rand::XorShiftRng> {