map: &mut M,
bh: &mut BenchHarness) {
// setup
- let mut rng = rand::XorShiftRng::new();
+ let mut rng = rand::weak_rng();
map.clear();
for _ in range(0, n) {
map: &mut M,
bh: &mut BenchHarness) {
// setup
- let mut rng = rand::XorShiftRng::new();
+ let mut rng = rand::weak_rng();
let mut keys = slice::from_fn(n, |_| rng.gen::<uint>() % n);
for k in keys.iter() {
// worry there.
#[cfg(windows)]
fn new_sched_rng() -> XorShiftRng {
- XorShiftRng::new()
+ match XorShiftRng::new() {
+ Ok(r) => r,
+ Err(e) => {
+ rtabort!("sched: failed to create seeded RNG: {}", e)
+ }
+ }
}
#[cfg(unix)]
fn new_sched_rng() -> XorShiftRng {
#[bench]
fn rand_exp(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
let mut exp = Exp::new(2.71828 * 3.14159);
bh.iter(|| {
use self::test::BenchHarness;
use std::mem::size_of;
use distributions::IndependentSample;
- use {StdRng, RAND_BENCH_N};
+ use {XorShiftRng, RAND_BENCH_N};
use super::Gamma;
#[bench]
fn bench_gamma_large_shape(bh: &mut BenchHarness) {
let gamma = Gamma::new(10., 1.0);
- let mut rng = StdRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| {
for _ in range(0, RAND_BENCH_N) {
#[bench]
fn bench_gamma_small_shape(bh: &mut BenchHarness) {
let gamma = Gamma::new(0.1, 1.0);
- let mut rng = StdRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| {
for _ in range(0, RAND_BENCH_N) {
#[bench]
fn rand_normal(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
let mut normal = Normal::new(-2.71828, 3.14159);
bh.iter(|| {
//! The ISAAC random number generator.
use {Rng, SeedableRng, OSRng};
+use std::io::IoResult;
use std::iter::{range_step, Repeat};
use std::slice::raw;
use std::mem;
impl IsaacRng {
/// Create an ISAAC random number generator with a random seed.
- pub fn new() -> IsaacRng {
+ ///
+ /// This reads randomness from the operating system (via `OSRng`)
+ /// which may fail, any error is propagated via the `IoResult`
+ /// return value.
+ pub fn new() -> IoResult<IsaacRng> {
let mut rng = EMPTY;
- let mut os_rng = match OSRng::new() {
- Ok(r) => r,
- Err(e) => fail!("IsaacRng::new: creating OSRng failed: {}", e)
- };
+ let mut os_rng = try!(OSRng::new());
unsafe {
let ptr = rng.rsl.as_mut_ptr();
}
rng.init(true);
- rng
+ Ok(rng)
}
/// Create an ISAAC random number generator using the default
impl Isaac64Rng {
/// Create a 64-bit ISAAC random number generator with a random
/// seed.
- pub fn new() -> Isaac64Rng {
+ ///
+ /// This reads randomness from the operating system (via `OSRng`)
+ /// which may fail, any error is propagated via the `IoResult`
+ /// return value.
+ pub fn new() -> IoResult<Isaac64Rng> {
let mut rng = EMPTY_64;
- let mut os_rng = match OSRng::new() {
- Ok(r) => r,
- Err(e) => fail!("Isaac64Rng::new: creating OSRng failed: {}", e)
- };
+ let mut os_rng = try!(OSRng::new());
+
unsafe {
let ptr = rng.rsl.as_mut_ptr();
}
rng.init(true);
- rng
+ Ok(rng)
}
/// Create a 64-bit ISAAC random number generator using the
#[cfg(test)]
mod test {
use super::{IsaacRng, Isaac64Rng};
- use {Rng, SeedableRng, OSRng};
+ use {Rng, SeedableRng, task_rng};
use std::slice;
#[test]
fn test_rng_32_rand_seeded() {
- let s = OSRng::new().gen_vec::<u32>(256);
+ let s = task_rng().gen_vec::<u32>(256);
let mut ra: IsaacRng = SeedableRng::from_seed(s.as_slice());
let mut rb: IsaacRng = SeedableRng::from_seed(s.as_slice());
assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
}
#[test]
fn test_rng_64_rand_seeded() {
- let s = OSRng::new().gen_vec::<u64>(256);
+ let s = task_rng().gen_vec::<u64>(256);
let mut ra: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
let mut rb: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
#[test]
fn test_rng_32_reseed() {
- let s = OSRng::new().gen_vec::<u32>(256);
+ let s = task_rng().gen_vec::<u32>(256);
let mut r: IsaacRng = SeedableRng::from_seed(s.as_slice());
let string1 = r.gen_ascii_str(100);
}
#[test]
fn test_rng_64_reseed() {
- let s = OSRng::new().gen_vec::<u64>(256);
+ let s = task_rng().gen_vec::<u64>(256);
let mut r: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
let string1 = r.gen_ascii_str(100);
#[phase(syntax, link)] extern crate log;
use std::cast;
+use std::io::IoResult;
use std::kinds::marker;
use std::local_data;
use std::str;
/// appropriate.
#[deprecated="use `task_rng` or `StdRng::new`"]
pub fn rng() -> StdRng {
- StdRng::new()
+ StdRng::new().unwrap()
}
/// The standard RNG. This is designed to be efficient on the current
/// number of random numbers, or doesn't need the utmost speed for
/// generating each number, `task_rng` and/or `random` may be more
/// appropriate.
+ ///
+ /// Reading the randomness from the OS may fail, and any error is
+ /// propagated via the `IoResult` return value.
#[cfg(not(target_word_size="64"))]
- pub fn new() -> StdRng {
- StdRng { rng: IsaacRng::new() }
+ pub fn new() -> IoResult<StdRng> {
+ IsaacRng::new().map(|r| StdRng { rng: r })
}
/// Create a randomly seeded instance of `StdRng`.
///
/// number of random numbers, or doesn't need the utmost speed for
/// generating each number, `task_rng` and/or `random` may be more
/// appropriate.
+ ///
+ /// Reading the randomness from the OS may fail, and any error is
+ /// propagated via the `IoResult` return value.
#[cfg(target_word_size="64")]
- pub fn new() -> StdRng {
- StdRng { rng: Isaac64Rng::new() }
+ pub fn new() -> IoResult<StdRng> {
+ Isaac64Rng::new().map(|r| StdRng { rng: r })
}
}
/// This will read randomness from the operating system to seed the
/// generator.
pub fn weak_rng() -> XorShiftRng {
- XorShiftRng::new()
+ match XorShiftRng::new() {
+ Ok(r) => r,
+ Err(e) => fail!("weak_rng: failed to create seeded RNG: {}", e)
+ }
}
/// An Xorshift[1] random number
impl XorShiftRng {
/// Create an xor shift random number generator with a random seed.
- pub fn new() -> XorShiftRng {
+ pub fn new() -> IoResult<XorShiftRng> {
let mut s = [0u8, ..16];
+ let mut r = try!(OSRng::new());
loop {
- let mut r = match OSRng::new() {
- Ok(r) => r,
- Err(e) => fail!("XorShiftRng::new: creating OSRng failed: {}", e)
- };
r.fill_bytes(s);
if !s.iter().all(|x| *x == 0) {
}
}
let s: [u32, ..4] = unsafe { cast::transmute(s) };
- SeedableRng::from_seed(s)
+ Ok(SeedableRng::from_seed(s))
}
}
impl reseeding::Reseeder<StdRng> for TaskRngReseeder {
fn reseed(&mut self, rng: &mut StdRng) {
- *rng = StdRng::new();
+ *rng = match StdRng::new() {
+ Ok(r) => r,
+ Err(e) => fail!("could not reseed task_rng: {}", e)
+ }
}
}
static TASK_RNG_RESEED_THRESHOLD: uint = 32_768;
pub fn task_rng() -> TaskRng {
local_data::get_mut(TASK_RNG_KEY, |rng| match rng {
None => {
- let mut rng = ~reseeding::ReseedingRng::new(StdRng::new(),
+ let r = match StdRng::new() {
+ Ok(r) => r,
+ Err(e) => fail!("could not initialize task_rng: {}", e)
+ };
+ let mut rng = ~reseeding::ReseedingRng::new(r,
TASK_RNG_RESEED_THRESHOLD,
TaskRngReseeder);
let ptr = &mut *rng as *mut TaskRngInner;
#[cfg(test)]
mod test {
use std::slice;
- use super::{Rng, task_rng, random, OSRng, SeedableRng, StdRng};
+ use super::{Rng, task_rng, random, SeedableRng, StdRng};
struct ConstRng { i: u64 }
impl Rng for ConstRng {
#[test]
fn test_std_rng_seeded() {
- let s = OSRng::new().gen_vec::<uint>(256);
+ let s = task_rng().gen_vec::<uint>(256);
let mut ra: StdRng = SeedableRng::from_seed(s.as_slice());
let mut rb: StdRng = SeedableRng::from_seed(s.as_slice());
assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
#[test]
fn test_std_rng_reseed() {
- let s = OSRng::new().gen_vec::<uint>(256);
+ let s = task_rng().gen_vec::<uint>(256);
let mut r: StdRng = SeedableRng::from_seed(s.as_slice());
let string1 = r.gen_ascii_str(100);
#[bench]
fn rand_xorshift(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| {
for _ in range(0, RAND_BENCH_N) {
rng.gen::<uint>();
#[bench]
fn rand_isaac(bh: &mut BenchHarness) {
- let mut rng = IsaacRng::new();
+ let mut rng = IsaacRng::new().unwrap();
bh.iter(|| {
for _ in range(0, RAND_BENCH_N) {
rng.gen::<uint>();
#[bench]
fn rand_isaac64(bh: &mut BenchHarness) {
- let mut rng = Isaac64Rng::new();
+ let mut rng = Isaac64Rng::new().unwrap();
bh.iter(|| {
for _ in range(0, RAND_BENCH_N) {
rng.gen::<uint>();
#[bench]
fn rand_std(bh: &mut BenchHarness) {
- let mut rng = StdRng::new();
+ let mut rng = StdRng::new().unwrap();
bh.iter(|| {
for _ in range(0, RAND_BENCH_N) {
rng.gen::<uint>();
#[bench]
fn rand_shuffle_100(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
let x : &mut[uint] = [1,..100];
bh.iter(|| {
rng.shuffle_mut(x);
#[test]
fn test_os_rng() {
- let mut r = OSRng::new();
+ let mut r = OSRng::new().unwrap();
r.next_u32();
r.next_u64();
// deschedule to attempt to interleave things as much
// as possible (XXX: is this a good test?)
- let mut r = OSRng::new();
+ let mut r = OSRng::new().unwrap();
task::deschedule();
let mut v = [0u8, .. 1000];
/// # Example
///
/// ```rust
-/// use rand::{Rng, SeedableRng};
+/// use rand::{Rng, SeedableRng, StdRng};
/// use rand::reseeding::{Reseeder, ReseedingRng};
///
/// struct TickTockReseeder { tick: bool }
-/// impl Reseeder<rand::StdRng> for TickTockReseeder {
-/// fn reseed(&mut self, rng: &mut rand::StdRng) {
+/// impl Reseeder<StdRng> for TickTockReseeder {
+/// fn reseed(&mut self, rng: &mut StdRng) {
/// let val = if self.tick {0} else {1};
/// rng.reseed(&[val]);
/// self.tick = !self.tick;
/// }
/// fn main() {
/// let rsdr = TickTockReseeder { tick: true };
-/// let mut rng = ReseedingRng::new(rand::StdRng::new(), 10, rsdr);
+///
+/// let inner = StdRng::new().unwrap();
+/// let mut rng = ReseedingRng::new(inner, 10, rsdr);
///
/// // this will repeat, because it gets reseeded very regularly.
/// println!("{}", rng.gen_ascii_str(100));
#[bench]
fn format_bin(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:t}", rng.gen::<uint>()); })
}
#[bench]
fn format_oct(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:o}", rng.gen::<uint>()); })
}
#[bench]
fn format_dec(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:u}", rng.gen::<uint>()); })
}
#[bench]
fn format_hex(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:x}", rng.gen::<uint>()); })
}
#[bench]
fn format_base_36(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
}
}
#[bench]
fn format_bin(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:t}", rng.gen::<int>()); })
}
#[bench]
fn format_oct(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:o}", rng.gen::<int>()); })
}
#[bench]
fn format_dec(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:d}", rng.gen::<int>()); })
}
#[bench]
fn format_hex(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{:x}", rng.gen::<int>()); })
}
#[bench]
fn format_base_36(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
}
}
use rand::{StdRng, Rng};
let mut bytes = [0, ..1024];
- StdRng::new().fill_bytes(bytes);
+ StdRng::new().unwrap().fill_bytes(bytes);
let tmpdir = tmpdir();
#[bench]
fn to_str_bin(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<uint>().to_str_radix(2); })
}
#[bench]
fn to_str_oct(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<uint>().to_str_radix(8); })
}
#[bench]
fn to_str_dec(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<uint>().to_str_radix(10); })
}
#[bench]
fn to_str_hex(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<uint>().to_str_radix(16); })
}
#[bench]
fn to_str_base_36(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<uint>().to_str_radix(36); })
}
}
#[bench]
fn to_str_bin(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<int>().to_str_radix(2); })
}
#[bench]
fn to_str_oct(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<int>().to_str_radix(8); })
}
#[bench]
fn to_str_dec(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<int>().to_str_radix(10); })
}
#[bench]
fn to_str_hex(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<int>().to_str_radix(16); })
}
#[bench]
fn to_str_base_36(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { rng.gen::<int>().to_str_radix(36); })
}
}
#[bench]
fn float_to_str(bh: &mut BenchHarness) {
- let mut rng = XorShiftRng::new();
+ let mut rng = XorShiftRng::new().unwrap();
bh.iter(|| { f64::to_str(rng.gen()); })
}
}
#[test]
fn rng() {
use rand::{StdRng, Rng};
- let mut r = StdRng::new();
+ let mut r = StdRng::new().unwrap();
let _ = r.next_u32();
}
impl Noise2DContext {
fn new() -> Noise2DContext {
- let mut rng = StdRng::new();
+ let mut rng = StdRng::new().unwrap();
let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }, ..256];
for x in rgradients.mut_iter() {