src/libstd/rand/mod.rs

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Utilities for random number generation
  12 //!
  13 //! The key functions are `random()` and `Rng::gen()`. These are polymorphic
  14 //! and so can be used to generate any type that implements `Rand`. Type inference
  15 //! means that often a simple call to `rand::random()` or `rng.gen()` will
  16 //! suffice, but sometimes an annotation is required, e.g. `rand::random::<f64>()`.
  17 //!
  18 //! See the `distributions` submodule for sampling random numbers from
  19 //! distributions like normal and exponential.
  20 //!
  21 //! # Thread-local RNG
  22 //!
  23 //! There is built-in support for a RNG associated with each thread stored
  24 //! in thread-local storage. This RNG can be accessed via `thread_rng`, or
  25 //! used implicitly via `random`. This RNG is normally randomly seeded
  26 //! from an operating-system source of randomness, e.g. `/dev/urandom` on
  27 //! Unix systems, and will automatically reseed itself from this source
  28 //! after generating 32 KiB of random data.
  29 //!
  30 //! # Cryptographic security
  31 //!
  32 //! An application that requires an entropy source for cryptographic purposes
  33 //! must use `OsRng`, which reads randomness from the source that the operating
  34 //! system provides (e.g. `/dev/urandom` on Unixes or `CryptGenRandom()` on Windows).
  35 //! The other random number generators provided by this module are not suitable
  36 //! for such purposes.
  37 //!
  38 //! *Note*: many Unix systems provide `/dev/random` as well as `/dev/urandom`.
  39 //! This module uses `/dev/urandom` for the following reasons:
  40 //!
  41 //! -   On Linux, `/dev/random` may block if entropy pool is empty; `/dev/urandom` will not block.
  42 //!     This does not mean that `/dev/random` provides better output than
  43 //!     `/dev/urandom`; the kernel internally runs a cryptographically secure pseudorandom
  44 //!     number generator (CSPRNG) based on entropy pool for random number generation,
  45 //!     so the "quality" of `/dev/random` is not better than `/dev/urandom` in most cases.
  46 //!     However, this means that `/dev/urandom` can yield somewhat predictable randomness
  47 //!     if the entropy pool is very small, such as immediately after first booting.
  48 //!     Linux 3.17 added the `getrandom(2)` system call which solves the issue: it blocks if entropy
  49 //!     pool is not initialized yet, but it does not block once initialized.
  50 //!     `OsRng` tries to use `getrandom(2)` if available, and use `/dev/urandom` fallback if not.
  51 //!     If an application does not have `getrandom` and likely to be run soon after first booting,
  52 //!     or on a system with very few entropy sources, one should consider using `/dev/random` via
  53 //!     `ReaderRng`.
  54 //! -   On some systems (e.g. FreeBSD, OpenBSD and Mac OS X) there is no difference
  55 //!     between the two sources. (Also note that, on some systems e.g. FreeBSD, both `/dev/random`
  56 //!     and `/dev/urandom` may block once if the CSPRNG has not seeded yet.)
  57 //!
  58 //! # Examples
  59 //!
  60 //! ```rust
  61 //! use std::rand;
  62 //! use std::rand::Rng;
  63 //!
  64 //! let mut rng = rand::thread_rng();
  65 //! if rng.gen() { // random bool
  66 //!     println!("int: {}, uint: {}", rng.gen::<int>(), rng.gen::<uint>())
  67 //! }
  68 //! ```
  69 //!
  70 //! ```rust
  71 //! use std::rand;
  72 //!
  73 //! let tuple = rand::random::<(f64, char)>();
  74 //! println!("{}", tuple)
  75 //! ```
  76 //!
  77 //! ## Monte Carlo estimation of π
  78 //!
  79 //! For this example, imagine we have a square with sides of length 2 and a unit
  80 //! circle, both centered at the origin. Since the area of a unit circle is π,
  81 //! we have:
  82 //!
  83 //! ```text
  84 //!     (area of unit circle) / (area of square) = π / 4
  85 //! ```
  86 //!
  87 //! So if we sample many points randomly from the square, roughly π / 4 of them
  88 //! should be inside the circle.
  89 //!
  90 //! We can use the above fact to estimate the value of π: pick many points in the
  91 //! square at random, calculate the fraction that fall within the circle, and
  92 //! multiply this fraction by 4.
  93 //!
  94 //! ```
  95 //! use std::rand;
  96 //! use std::rand::distributions::{IndependentSample, Range};
  97 //!
  98 //! fn main() {
  99 //!    let between = Range::new(-1f64, 1.);
 100 //!    let mut rng = rand::thread_rng();
 101 //!
 102 //!    let total = 1_000_000u;
 103 //!    let mut in_circle = 0u;
 104 //!
 105 //!    for _ in range(0u, total) {
 106 //!        let a = between.ind_sample(&mut rng);
 107 //!        let b = between.ind_sample(&mut rng);
 108 //!        if a*a + b*b <= 1. {
 109 //!            in_circle += 1;
 110 //!        }
 111 //!    }
 112 //!
 113 //!    // prints something close to 3.14159...
 114 //!    println!("{}", 4. * (in_circle as f64) / (total as f64));
 115 //! }
 116 //! ```
 117 //!
 118 //! ## Monty Hall Problem
 119 //!
 120 //! This is a simulation of the [Monty Hall Problem][]:
 121 //!
 122 //! > Suppose you're on a game show, and you're given the choice of three doors:
 123 //! > Behind one door is a car; behind the others, goats. You pick a door, say No. 1,
 124 //! > and the host, who knows what's behind the doors, opens another door, say No. 3,
 125 //! > which has a goat. He then says to you, "Do you want to pick door No. 2?"
 126 //! > Is it to your advantage to switch your choice?
 127 //!
 128 //! The rather unintuitive answer is that you will have a 2/3 chance of winning if
 129 //! you switch and a 1/3 chance of winning if you don't, so it's better to switch.
 130 //!
 131 //! This program will simulate the game show and with large enough simulation steps
 132 //! it will indeed confirm that it is better to switch.
 133 //!
 134 //! [Monty Hall Problem]: http://en.wikipedia.org/wiki/Monty_Hall_problem
 135 //!
 136 //! ```
 137 //! use std::rand;
 138 //! use std::rand::Rng;
 139 //! use std::rand::distributions::{IndependentSample, Range};
 140 //!
 141 //! struct SimulationResult {
 142 //!     win: bool,
 143 //!     switch: bool,
 144 //! }
 145 //!
 146 //! // Run a single simulation of the Monty Hall problem.
 147 //! fn simulate<R: Rng>(random_door: &Range<uint>, rng: &mut R) -> SimulationResult {
 148 //!     let car = random_door.ind_sample(rng);
 149 //!
 150 //!     // This is our initial choice
 151 //!     let mut choice = random_door.ind_sample(rng);
 152 //!
 153 //!     // The game host opens a door
 154 //!     let open = game_host_open(car, choice, rng);
 155 //!
 156 //!     // Shall we switch?
 157 //!     let switch = rng.gen();
 158 //!     if switch {
 159 //!         choice = switch_door(choice, open);
 160 //!     }
 161 //!
 162 //!     SimulationResult { win: choice == car, switch: switch }
 163 //! }
 164 //!
 165 //! // Returns the door the game host opens given our choice and knowledge of
 166 //! // where the car is. The game host will never open the door with the car.
 167 //! fn game_host_open<R: Rng>(car: uint, choice: uint, rng: &mut R) -> uint {
 168 //!     let choices = free_doors(&[car, choice]);
 169 //!     rand::sample(rng, choices.into_iter(), 1)[0]
 170 //! }
 171 //!
 172 //! // Returns the door we switch to, given our current choice and
 173 //! // the open door. There will only be one valid door.
 174 //! fn switch_door(choice: uint, open: uint) -> uint {
 175 //!     free_doors(&[choice, open])[0]
 176 //! }
 177 //!
 178 //! fn free_doors(blocked: &[uint]) -> Vec<uint> {
 179 //!     range(0u, 3).filter(|x| !blocked.contains(x)).collect()
 180 //! }
 181 //!
 182 //! fn main() {
 183 //!     // The estimation will be more accurate with more simulations
 184 //!     let num_simulations = 10000u;
 185 //!
 186 //!     let mut rng = rand::thread_rng();
 187 //!     let random_door = Range::new(0u, 3);
 188 //!
 189 //!     let (mut switch_wins, mut switch_losses) = (0u, 0u);
 190 //!     let (mut keep_wins, mut keep_losses) = (0u, 0u);
 191 //!
 192 //!     println!("Running {} simulations...", num_simulations);
 193 //!     for _ in range(0, num_simulations) {
 194 //!         let result = simulate(&random_door, &mut rng);
 195 //!
 196 //!         match (result.win, result.switch) {
 197 //!             (true, true) => switch_wins += 1,
 198 //!             (true, false) => keep_wins += 1,
 199 //!             (false, true) => switch_losses += 1,
 200 //!             (false, false) => keep_losses += 1,
 201 //!         }
 202 //!     }
 203 //!
 204 //!     let total_switches = switch_wins + switch_losses;
 205 //!     let total_keeps = keep_wins + keep_losses;
 206 //!
 207 //!     println!("Switched door {} times with {} wins and {} losses",
 208 //!              total_switches, switch_wins, switch_losses);
 209 //!
 210 //!     println!("Kept our choice {} times with {} wins and {} losses",
 211 //!              total_keeps, keep_wins, keep_losses);
 212 //!
 213 //!     // With a large number of simulations, the values should converge to
 214 //!     // 0.667 and 0.333 respectively.
 215 //!     println!("Estimated chance to win if we switch: {}",
 216 //!              switch_wins as f32 / total_switches as f32);
 217 //!     println!("Estimated chance to win if we don't: {}",
 218 //!              keep_wins as f32 / total_keeps as f32);
 219 //! }
 220 //! ```
 221
 222 #![experimental]
 223
 224 use cell::RefCell;
 225 use clone::Clone;
 226 use io::IoResult;
 227 use iter::{Iterator, IteratorExt};
 228 use mem;
 229 use rc::Rc;
 230 use result::Result::{Ok, Err};
 231 use vec::Vec;
 232
 233 #[cfg(not(target_word_size="64"))]
 234 use core_rand::IsaacRng as IsaacWordRng;
 235 #[cfg(target_word_size="64")]
 236 use core_rand::Isaac64Rng as IsaacWordRng;
 237
 238 pub use core_rand::{Rand, Rng, SeedableRng, Open01, Closed01};
 239 pub use core_rand::{XorShiftRng, IsaacRng, Isaac64Rng, ChaChaRng};
 240 pub use core_rand::{distributions, reseeding};
 241 pub use rand::os::OsRng;
 242
 243 pub mod os;
 244 pub mod reader;
 245
 246 /// The standard RNG. This is designed to be efficient on the current
 247 /// platform.
 248 #[deriving(Copy, Clone)]
 249 pub struct StdRng {
 250     rng: IsaacWordRng,
 251 }
 252
 253 impl StdRng {
 254     /// Create a randomly seeded instance of `StdRng`.
 255     ///
 256     /// This is a very expensive operation as it has to read
 257     /// randomness from the operating system and use this in an
 258     /// expensive seeding operation. If one is only generating a small
 259     /// number of random numbers, or doesn't need the utmost speed for
 260     /// generating each number, `thread_rng` and/or `random` may be more
 261     /// appropriate.
 262     ///
 263     /// Reading the randomness from the OS may fail, and any error is
 264     /// propagated via the `IoResult` return value.
 265     pub fn new() -> IoResult<StdRng> {
 266         OsRng::new().map(|mut r| StdRng { rng: r.gen() })
 267     }
 268 }
 269
 270 impl Rng for StdRng {
 271     #[inline]
 272     fn next_u32(&mut self) -> u32 {
 273         self.rng.next_u32()
 274     }
 275
 276     #[inline]
 277     fn next_u64(&mut self) -> u64 {
 278         self.rng.next_u64()
 279     }
 280 }
 281
 282 impl<'a> SeedableRng<&'a [uint]> for StdRng {
 283     fn reseed(&mut self, seed: &'a [uint]) {
 284         // the internal RNG can just be seeded from the above
 285         // randomness.
 286         self.rng.reseed(unsafe {mem::transmute(seed)})
 287     }
 288
 289     fn from_seed(seed: &'a [uint]) -> StdRng {
 290         StdRng { rng: SeedableRng::from_seed(unsafe {mem::transmute(seed)}) }
 291     }
 292 }
 293
 294 /// Create a weak random number generator with a default algorithm and seed.
 295 ///
 296 /// It returns the fastest `Rng` algorithm currently available in Rust without
 297 /// consideration for cryptography or security. If you require a specifically
 298 /// seeded `Rng` for consistency over time you should pick one algorithm and
 299 /// create the `Rng` yourself.
 300 ///
 301 /// This will read randomness from the operating system to seed the
 302 /// generator.
 303 pub fn weak_rng() -> XorShiftRng {
 304     match OsRng::new() {
 305         Ok(mut r) => r.gen(),
 306         Err(e) => panic!("weak_rng: failed to create seeded RNG: {}", e)
 307     }
 308 }
 309
 310 /// Controls how the thread-local RNG is reseeded.
 311 struct ThreadRngReseeder;
 312
 313 impl reseeding::Reseeder<StdRng> for ThreadRngReseeder {
 314     fn reseed(&mut self, rng: &mut StdRng) {
 315         *rng = match StdRng::new() {
 316             Ok(r) => r,
 317             Err(e) => panic!("could not reseed thread_rng: {}", e)
 318         }
 319     }
 320 }
 321 static THREAD_RNG_RESEED_THRESHOLD: uint = 32_768;
 322 type ThreadRngInner = reseeding::ReseedingRng<StdRng, ThreadRngReseeder>;
 323
 324 /// The thread-local RNG.
 325 #[deriving(Clone)]
 326 pub struct ThreadRng {
 327     rng: Rc<RefCell<ThreadRngInner>>,
 328 }
 329
 330 /// Retrieve the lazily-initialized thread-local random number
 331 /// generator, seeded by the system. Intended to be used in method
 332 /// chaining style, e.g. `thread_rng().gen::<int>()`.
 333 ///
 334 /// The RNG provided will reseed itself from the operating system
 335 /// after generating a certain amount of randomness.
 336 ///
 337 /// The internal RNG used is platform and architecture dependent, even
 338 /// if the operating system random number generator is rigged to give
 339 /// the same sequence always. If absolute consistency is required,
 340 /// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
 341 pub fn thread_rng() -> ThreadRng {
 342     // used to make space in TLS for a random number generator
 343     thread_local!(static THREAD_RNG_KEY: Rc<RefCell<ThreadRngInner>> = {
 344         let r = match StdRng::new() {
 345             Ok(r) => r,
 346             Err(e) => panic!("could not initialize thread_rng: {}", e)
 347         };
 348         let rng = reseeding::ReseedingRng::new(r,
 349                                                THREAD_RNG_RESEED_THRESHOLD,
 350                                                ThreadRngReseeder);
 351         Rc::new(RefCell::new(rng))
 352     });
 353
 354     ThreadRng { rng: THREAD_RNG_KEY.with(|t| t.clone()) }
 355 }
 356
 357 impl Rng for ThreadRng {
 358     fn next_u32(&mut self) -> u32 {
 359         self.rng.borrow_mut().next_u32()
 360     }
 361
 362     fn next_u64(&mut self) -> u64 {
 363         self.rng.borrow_mut().next_u64()
 364     }
 365
 366     #[inline]
 367     fn fill_bytes(&mut self, bytes: &mut [u8]) {
 368         self.rng.borrow_mut().fill_bytes(bytes)
 369     }
 370 }
 371
 372 /// Generates a random value using the thread-local random number generator.
 373 ///
 374 /// `random()` can generate various types of random things, and so may require
 375 /// type hinting to generate the specific type you want.
 376 ///
 377 /// # Examples
 378 ///
 379 /// ```rust
 380 /// use std::rand;
 381 ///
 382 /// let x = rand::random();
 383 /// println!("{}", 2u * x);
 384 ///
 385 /// let y = rand::random::<f64>();
 386 /// println!("{}", y);
 387 ///
 388 /// if rand::random() { // generates a boolean
 389 ///     println!("Better lucky than good!");
 390 /// }
 391 /// ```
 392 #[inline]
 393 pub fn random<T: Rand>() -> T {
 394     thread_rng().gen()
 395 }
 396
 397 /// Randomly sample up to `amount` elements from an iterator.
 398 ///
 399 /// # Example
 400 ///
 401 /// ```rust
 402 /// use std::rand::{thread_rng, sample};
 403 ///
 404 /// let mut rng = thread_rng();
 405 /// let sample = sample(&mut rng, range(1i, 100), 5);
 406 /// println!("{}", sample);
 407 /// ```
 408 pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R,
 409                                          mut iter: I,
 410                                          amount: uint) -> Vec<T> {
 411     let mut reservoir: Vec<T> = iter.by_ref().take(amount).collect();
 412     for (i, elem) in iter.enumerate() {
 413         let k = rng.gen_range(0, i + 1 + amount);
 414         if k < amount {
 415             reservoir[k] = elem;
 416         }
 417     }
 418     return reservoir;
 419 }
 420
 421 #[cfg(test)]
 422 mod test {
 423     use prelude::v1::*;
 424     use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample};
 425     use iter::{order, repeat};
 426
 427     struct ConstRng { i: u64 }
 428     impl Rng for ConstRng {
 429         fn next_u32(&mut self) -> u32 { self.i as u32 }
 430         fn next_u64(&mut self) -> u64 { self.i }
 431
 432         // no fill_bytes on purpose
 433     }
 434
 435     #[test]
 436     fn test_fill_bytes_default() {
 437         let mut r = ConstRng { i: 0x11_22_33_44_55_66_77_88 };
 438
 439         // check every remainder mod 8, both in small and big vectors.
 440         let lengths = [0, 1, 2, 3, 4, 5, 6, 7,
 441                        80, 81, 82, 83, 84, 85, 86, 87];
 442         for &n in lengths.iter() {
 443             let mut v = repeat(0u8).take(n).collect::<Vec<_>>();
 444             r.fill_bytes(v.as_mut_slice());
 445
 446             // use this to get nicer error messages.
 447             for (i, &byte) in v.iter().enumerate() {
 448                 if byte == 0 {
 449                     panic!("byte {} of {} is zero", i, n)
 450                 }
 451             }
 452         }
 453     }
 454
 455     #[test]
 456     fn test_gen_range() {
 457         let mut r = thread_rng();
 458         for _ in range(0u, 1000) {
 459             let a = r.gen_range(-3i, 42);
 460             assert!(a >= -3 && a < 42);
 461             assert_eq!(r.gen_range(0i, 1), 0);
 462             assert_eq!(r.gen_range(-12i, -11), -12);
 463         }
 464
 465         for _ in range(0u, 1000) {
 466             let a = r.gen_range(10i, 42);
 467             assert!(a >= 10 && a < 42);
 468             assert_eq!(r.gen_range(0i, 1), 0);
 469             assert_eq!(r.gen_range(3_000_000u, 3_000_001), 3_000_000);
 470         }
 471
 472     }
 473
 474     #[test]
 475     #[should_fail]
 476     fn test_gen_range_panic_int() {
 477         let mut r = thread_rng();
 478         r.gen_range(5i, -2);
 479     }
 480
 481     #[test]
 482     #[should_fail]
 483     fn test_gen_range_panic_uint() {
 484         let mut r = thread_rng();
 485         r.gen_range(5u, 2u);
 486     }
 487
 488     #[test]
 489     fn test_gen_f64() {
 490         let mut r = thread_rng();
 491         let a = r.gen::<f64>();
 492         let b = r.gen::<f64>();
 493         debug!("{}", (a, b));
 494     }
 495
 496     #[test]
 497     fn test_gen_weighted_bool() {
 498         let mut r = thread_rng();
 499         assert_eq!(r.gen_weighted_bool(0u), true);
 500         assert_eq!(r.gen_weighted_bool(1u), true);
 501     }
 502
 503     #[test]
 504     fn test_gen_ascii_str() {
 505         let mut r = thread_rng();
 506         assert_eq!(r.gen_ascii_chars().take(0).count(), 0u);
 507         assert_eq!(r.gen_ascii_chars().take(10).count(), 10u);
 508         assert_eq!(r.gen_ascii_chars().take(16).count(), 16u);
 509     }
 510
 511     #[test]
 512     fn test_gen_vec() {
 513         let mut r = thread_rng();
 514         assert_eq!(r.gen_iter::<u8>().take(0).count(), 0u);
 515         assert_eq!(r.gen_iter::<u8>().take(10).count(), 10u);
 516         assert_eq!(r.gen_iter::<f64>().take(16).count(), 16u);
 517     }
 518
 519     #[test]
 520     fn test_choose() {
 521         let mut r = thread_rng();
 522         assert_eq!(r.choose(&[1i, 1, 1]).map(|&x|x), Some(1));
 523
 524         let v: &[int] = &[];
 525         assert_eq!(r.choose(v), None);
 526     }
 527
 528     #[test]
 529     fn test_shuffle() {
 530         let mut r = thread_rng();
 531         let empty: &mut [int] = &mut [];
 532         r.shuffle(empty);
 533         let mut one = [1i];
 534         r.shuffle(&mut one);
 535         let b: &[_] = &[1];
 536         assert_eq!(one, b);
 537
 538         let mut two = [1i, 2];
 539         r.shuffle(&mut two);
 540         assert!(two == [1, 2] || two == [2, 1]);
 541
 542         let mut x = [1i, 1, 1];
 543         r.shuffle(&mut x);
 544         let b: &[_] = &[1, 1, 1];
 545         assert_eq!(x, b);
 546     }
 547
 548     #[test]
 549     fn test_thread_rng() {
 550         let mut r = thread_rng();
 551         r.gen::<int>();
 552         let mut v = [1i, 1, 1];
 553         r.shuffle(&mut v);
 554         let b: &[_] = &[1, 1, 1];
 555         assert_eq!(v, b);
 556         assert_eq!(r.gen_range(0u, 1u), 0u);
 557     }
 558
 559     #[test]
 560     fn test_random() {
 561         // not sure how to test this aside from just getting some values
 562         let _n : uint = random();
 563         let _f : f32 = random();
 564         let _o : Option<Option<i8>> = random();
 565         let _many : ((),
 566                      (uint,
 567                       int,
 568                       Option<(u32, (bool,))>),
 569                      (u8, i8, u16, i16, u32, i32, u64, i64),
 570                      (f32, (f64, (f64,)))) = random();
 571     }
 572
 573     #[test]
 574     fn test_sample() {
 575         let min_val = 1i;
 576         let max_val = 100i;
 577
 578         let mut r = thread_rng();
 579         let vals = range(min_val, max_val).collect::<Vec<int>>();
 580         let small_sample = sample(&mut r, vals.iter(), 5);
 581         let large_sample = sample(&mut r, vals.iter(), vals.len() + 5);
 582
 583         assert_eq!(small_sample.len(), 5);
 584         assert_eq!(large_sample.len(), vals.len());
 585
 586         assert!(small_sample.iter().all(|e| {
 587             **e >= min_val && **e <= max_val
 588         }));
 589     }
 590
 591     #[test]
 592     fn test_std_rng_seeded() {
 593         let s = thread_rng().gen_iter::<uint>().take(256).collect::<Vec<uint>>();
 594         let mut ra: StdRng = SeedableRng::from_seed(s.as_slice());
 595         let mut rb: StdRng = SeedableRng::from_seed(s.as_slice());
 596         assert!(order::equals(ra.gen_ascii_chars().take(100),
 597                               rb.gen_ascii_chars().take(100)));
 598     }
 599
 600     #[test]
 601     fn test_std_rng_reseed() {
 602         let s = thread_rng().gen_iter::<uint>().take(256).collect::<Vec<uint>>();
 603         let mut r: StdRng = SeedableRng::from_seed(s.as_slice());
 604         let string1 = r.gen_ascii_chars().take(100).collect::<String>();
 605
 606         r.reseed(s.as_slice());
 607
 608         let string2 = r.gen_ascii_chars().take(100).collect::<String>();
 609         assert_eq!(string1, string2);
 610     }
 611 }
 612
 613 #[cfg(test)]
 614 static RAND_BENCH_N: u64 = 100;
 615
 616 #[cfg(test)]
 617 mod bench {
 618     extern crate test;
 619     use prelude::v1::*;
 620
 621     use self::test::Bencher;
 622     use super::{XorShiftRng, StdRng, IsaacRng, Isaac64Rng, Rng, RAND_BENCH_N};
 623     use super::{OsRng, weak_rng};
 624     use mem::size_of;
 625
 626     #[bench]
 627     fn rand_xorshift(b: &mut Bencher) {
 628         let mut rng: XorShiftRng = OsRng::new().unwrap().gen();
 629         b.iter(|| {
 630             for _ in range(0, RAND_BENCH_N) {
 631                 rng.gen::<uint>();
 632             }
 633         });
 634         b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
 635     }
 636
 637     #[bench]
 638     fn rand_isaac(b: &mut Bencher) {
 639         let mut rng: IsaacRng = OsRng::new().unwrap().gen();
 640         b.iter(|| {
 641             for _ in range(0, RAND_BENCH_N) {
 642                 rng.gen::<uint>();
 643             }
 644         });
 645         b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
 646     }
 647
 648     #[bench]
 649     fn rand_isaac64(b: &mut Bencher) {
 650         let mut rng: Isaac64Rng = OsRng::new().unwrap().gen();
 651         b.iter(|| {
 652             for _ in range(0, RAND_BENCH_N) {
 653                 rng.gen::<uint>();
 654             }
 655         });
 656         b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
 657     }
 658
 659     #[bench]
 660     fn rand_std(b: &mut Bencher) {
 661         let mut rng = StdRng::new().unwrap();
 662         b.iter(|| {
 663             for _ in range(0, RAND_BENCH_N) {
 664                 rng.gen::<uint>();
 665             }
 666         });
 667         b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
 668     }
 669
 670     #[bench]
 671     fn rand_shuffle_100(b: &mut Bencher) {
 672         let mut rng = weak_rng();
 673         let x : &mut[uint] = &mut [1; 100];
 674         b.iter(|| {
 675             rng.shuffle(x);
 676         })
 677     }
 678 }