1 // Copyright 2012 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.
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.
12 Random number generation.
14 The key functions are `random()` and `RngUtil::gen()`. These are polymorphic
15 and so can be used to generate any type that implements `Rand`. Type inference
16 means that often a simple call to `rand::random()` or `rng.gen()` will
17 suffice, but sometimes an annotation is required, e.g. `rand::random::<float>()`.
19 See the `distributions` submodule for sampling random numbers from
20 distributions like normal and exponential.
26 use std::rand::RngUtil;
29 let mut rng = rand::rng();
30 if rng.gen() { // bool
31 printfln!("int: %d, uint: %u", rng.gen(), rng.gen())
40 let tuple_ptr = rand::random::<~(f64, char)>();
49 use container::Container;
51 use iterator::{Iterator, range};
63 #[path="rand/distributions.rs"]
64 pub mod distributions;
66 /// A type that can be randomly generated using an Rng
68 /// Generates a random instance of this type using the specified source of
70 fn rand<R: Rng>(rng: &mut R) -> Self;
75 fn rand<R: Rng>(rng: &mut R) -> int {
79 rng.gen::<i64>() as int
86 fn rand<R: Rng>(rng: &mut R) -> i8 {
93 fn rand<R: Rng>(rng: &mut R) -> i16 {
100 fn rand<R: Rng>(rng: &mut R) -> i32 {
107 fn rand<R: Rng>(rng: &mut R) -> i64 {
108 (rng.next() as i64 << 32) | rng.next() as i64
114 fn rand<R: Rng>(rng: &mut R) -> uint {
115 if uint::bits == 32 {
118 rng.gen::<u64>() as uint
125 fn rand<R: Rng>(rng: &mut R) -> u8 {
132 fn rand<R: Rng>(rng: &mut R) -> u16 {
139 fn rand<R: Rng>(rng: &mut R) -> u32 {
146 fn rand<R: Rng>(rng: &mut R) -> u64 {
147 (rng.next() as u64 << 32) | rng.next() as u64
151 impl Rand for float {
153 fn rand<R: Rng>(rng: &mut R) -> float {
154 rng.gen::<f64>() as float
160 fn rand<R: Rng>(rng: &mut R) -> f32 {
161 rng.gen::<f64>() as f32
165 static SCALE : f64 = (u32::max_value as f64) + 1.0f64;
168 fn rand<R: Rng>(rng: &mut R) -> f64 {
169 let u1 = rng.next() as f64;
170 let u2 = rng.next() as f64;
171 let u3 = rng.next() as f64;
173 ((u1 / SCALE + u2) / SCALE + u3) / SCALE
179 fn rand<R: Rng>(rng: &mut R) -> char {
186 fn rand<R: Rng>(rng: &mut R) -> bool {
187 rng.next() & 1u32 == 1u32
191 macro_rules! tuple_impl {
192 // use variables to indicate the arity of the tuple
193 ($($tyvar:ident),* ) => {
194 // the trailing commas are for the 1 tuple
197 > Rand for ( $( $tyvar ),* , ) {
200 fn rand<R: Rng>(_rng: &mut R) -> ( $( $tyvar ),* , ) {
202 // use the $tyvar's to get the appropriate number of
203 // repeats (they're not actually needed)
216 fn rand<R: Rng>(_: &mut R) -> () { () }
221 tuple_impl!{A, B, C, D}
222 tuple_impl!{A, B, C, D, E}
223 tuple_impl!{A, B, C, D, E, F}
224 tuple_impl!{A, B, C, D, E, F, G}
225 tuple_impl!{A, B, C, D, E, F, G, H}
226 tuple_impl!{A, B, C, D, E, F, G, H, I}
227 tuple_impl!{A, B, C, D, E, F, G, H, I, J}
229 impl<T:Rand> Rand for Option<T> {
231 fn rand<R: Rng>(rng: &mut R) -> Option<T> {
240 impl<T: Rand> Rand for ~T {
242 fn rand<R: Rng>(rng: &mut R) -> ~T { ~rng.gen() }
245 impl<T: Rand + 'static> Rand for @T {
247 fn rand<R: Rng>(rng: &mut R) -> @T { @rng.gen() }
255 pub fn rand_seed_size() -> size_t;
256 pub fn rand_gen_seed(buf: *mut u8, sz: size_t);
260 /// A random number generator
262 /// Return the next random integer
263 fn next(&mut self) -> u32;
266 /// A value with a particular weight compared to other values
267 pub struct Weighted<T> {
268 /// The numerical weight of this item
270 /// The actual item which is being weighted
274 /// Helper functions attached to the Rng type
276 /// Return a random value of a Rand type
277 fn gen<T:Rand>(&mut self) -> T;
279 * Return a int randomly chosen from the range [start, end),
280 * failing if start >= end
282 fn gen_int_range(&mut self, start: int, end: int) -> int;
284 * Return a uint randomly chosen from the range [start, end),
285 * failing if start >= end
287 fn gen_uint_range(&mut self, start: uint, end: uint) -> uint;
289 * Return a char randomly chosen from chars, failing if chars is empty
291 fn gen_char_from(&mut self, chars: &str) -> char;
293 * Return a bool with a 1 in n chance of true
300 * use std::rand::RngUtil;
303 * let mut rng = rand::rng();
304 * printfln!("%b", rng.gen_weighted_bool(3));
308 fn gen_weighted_bool(&mut self, n: uint) -> bool;
310 * Return a random string of the specified length composed of A-Z,a-z,0-9
317 * use std::rand::RngUtil;
320 * let mut rng = rand::rng();
321 * println(rng.gen_str(8));
325 fn gen_str(&mut self, len: uint) -> ~str;
327 * Return a random byte string of the specified length
334 * use std::rand::RngUtil;
337 * let mut rng = rand::rng();
338 * printfln!(rng.gen_bytes(8));
342 fn gen_bytes(&mut self, len: uint) -> ~[u8];
344 * Choose an item randomly, failing if values is empty
351 * use std::rand::RngUtil;
354 * let mut rng = rand::rng();
355 * printfln!("%d", rng.choose([1,2,4,8,16,32]));
359 fn choose<T:Clone>(&mut self, values: &[T]) -> T;
360 /// Choose Some(item) randomly, returning None if values is empty
361 fn choose_option<T:Clone>(&mut self, values: &[T]) -> Option<T>;
363 * Choose an item respecting the relative weights, failing if the sum of
371 * use std::rand::RngUtil;
374 * let mut rng = rand::rng();
375 * let x = [rand::Weighted {weight: 4, item: 'a'},
376 * rand::Weighted {weight: 2, item: 'b'},
377 * rand::Weighted {weight: 2, item: 'c'}];
378 * printfln!("%c", rng.choose_weighted(x));
382 fn choose_weighted<T:Clone>(&mut self, v : &[Weighted<T>]) -> T;
384 * Choose Some(item) respecting the relative weights, returning none if
385 * the sum of the weights is 0
392 * use std::rand::RngUtil;
395 * let mut rng = rand::rng();
396 * let x = [rand::Weighted {weight: 4, item: 'a'},
397 * rand::Weighted {weight: 2, item: 'b'},
398 * rand::Weighted {weight: 2, item: 'c'}];
399 * printfln!(rng.choose_weighted_option(x));
403 fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
406 * Return a vec containing copies of the items, in order, where
407 * the weight of the item determines how many copies there are
414 * use std::rand::RngUtil;
417 * let mut rng = rand::rng();
418 * let x = [rand::Weighted {weight: 4, item: 'a'},
419 * rand::Weighted {weight: 2, item: 'b'},
420 * rand::Weighted {weight: 2, item: 'c'}];
421 * printfln!(rng.weighted_vec(x));
425 fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T];
434 * use std::rand::RngUtil;
437 * let mut rng = rand::rng();
438 * printfln!(rng.shuffle([1,2,3]));
442 fn shuffle<T:Clone>(&mut self, values: &[T]) -> ~[T];
444 * Shuffle a mutable vec in place
451 * use std::rand::RngUtil;
454 * let mut rng = rand::rng();
455 * let mut y = [1,2,3];
456 * rng.shuffle_mut(y);
458 * rng.shuffle_mut(y);
463 fn shuffle_mut<T>(&mut self, values: &mut [T]);
466 * Sample up to `n` values from an iterator.
473 * use std::rand::RngUtil;
476 * let mut rng = rand::rng();
477 * let vals = range(1, 100).to_owned_vec();
478 * let sample = rng.sample(vals.iter(), 5);
483 fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A];
486 /// Extension methods for random number generators
487 impl<R: Rng> RngUtil for R {
488 /// Return a random value for a Rand type
490 fn gen<T: Rand>(&mut self) -> T {
495 * Return an int randomly chosen from the range [start, end),
496 * failing if start >= end
498 fn gen_int_range(&mut self, start: int, end: int) -> int {
499 assert!(start < end);
500 start + num::abs(self.gen::<int>() % (end - start))
504 * Return a uint randomly chosen from the range [start, end),
505 * failing if start >= end
507 fn gen_uint_range(&mut self, start: uint, end: uint) -> uint {
508 assert!(start < end);
509 start + (self.gen::<uint>() % (end - start))
513 * Return a char randomly chosen from chars, failing if chars is empty
515 fn gen_char_from(&mut self, chars: &str) -> char {
516 assert!(!chars.is_empty());
518 for c in chars.iter() { cs.push(c) }
522 /// Return a bool with a 1-in-n chance of true
523 fn gen_weighted_bool(&mut self, n: uint) -> bool {
527 self.gen_uint_range(1u, n + 1u) == 1u
532 * Return a random string of the specified length composed of A-Z,a-z,0-9
534 fn gen_str(&mut self, len: uint) -> ~str {
535 let charset = ~"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
536 abcdefghijklmnopqrstuvwxyz\
541 s = s + str::from_char(self.gen_char_from(charset));
547 /// Return a random byte string of the specified length
548 fn gen_bytes(&mut self, len: uint) -> ~[u8] {
549 do vec::from_fn(len) |_i| {
554 /// Choose an item randomly, failing if values is empty
555 fn choose<T:Clone>(&mut self, values: &[T]) -> T {
556 self.choose_option(values).unwrap()
559 /// Choose Some(item) randomly, returning None if values is empty
560 fn choose_option<T:Clone>(&mut self, values: &[T]) -> Option<T> {
561 if values.is_empty() {
564 Some(values[self.gen_uint_range(0u, values.len())].clone())
568 * Choose an item respecting the relative weights, failing if the sum of
571 fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
572 self.choose_weighted_option(v).unwrap()
576 * Choose Some(item) respecting the relative weights, returning none if
577 * the sum of the weights is 0
579 fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
582 for item in v.iter() {
583 total += item.weight;
588 let chosen = self.gen_uint_range(0u, total);
590 for item in v.iter() {
591 so_far += item.weight;
593 return Some(item.item.clone());
600 * Return a vec containing copies of the items, in order, where
601 * the weight of the item determines how many copies there are
603 fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
605 for item in v.iter() {
606 for _ in range(0u, item.weight) {
607 r.push(item.item.clone());
614 fn shuffle<T:Clone>(&mut self, values: &[T]) -> ~[T] {
615 let mut m = values.to_owned();
620 /// Shuffle a mutable vec in place
621 fn shuffle_mut<T>(&mut self, values: &mut [T]) {
622 let mut i = values.len();
624 // invariant: elements with index >= i have been locked in place.
626 // lock element i in place.
627 values.swap(i, self.gen_uint_range(0u, i + 1u));
631 /// Randomly sample up to `n` elements from an iterator
632 fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
633 let mut reservoir : ~[A] = vec::with_capacity(n);
634 for (i, elem) in iter.enumerate() {
636 reservoir.push(elem);
640 let k = self.gen_uint_range(0, i + 1);
641 if k < reservoir.len() {
649 /// Create a random number generator with a default algorithm and seed.
651 /// It returns the cryptographically-safest `Rng` algorithm currently
652 /// available in Rust. If you require a specifically seeded `Rng` for
653 /// consistency over time you should pick one algorithm and create the
655 pub fn rng() -> IsaacRng {
659 /// Create a weak random number generator with a default algorithm and seed.
661 /// It returns the fastest `Rng` algorithm currently available in Rust without
662 /// consideration for cryptography or security. If you require a specifically
663 /// seeded `Rng` for consistency over time you should pick one algorithm and
664 /// create the `Rng` yourself.
665 pub fn weak_rng() -> XorShiftRng {
669 static RAND_SIZE_LEN: u32 = 8;
670 static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN;
672 /// A random number generator that uses the [ISAAC
673 /// algorithm](http://en.wikipedia.org/wiki/ISAAC_%28cipher%29).
675 /// The ISAAC algorithm is suitable for cryptographic purposes.
676 pub struct IsaacRng {
678 priv rsl: [u32, .. RAND_SIZE],
679 priv mem: [u32, .. RAND_SIZE],
686 /// Create an ISAAC random number generator with a random seed.
687 pub fn new() -> IsaacRng {
688 IsaacRng::new_seeded(seed())
691 /// Create an ISAAC random number generator with a seed. This can be any
692 /// length, although the maximum number of bytes used is 1024 and any more
693 /// will be silently ignored. A generator constructed with a given seed
694 /// will generate the same sequence of values as all other generators
695 /// constructed with the same seed.
696 pub fn new_seeded(seed: &[u8]) -> IsaacRng {
697 let mut rng = IsaacRng {
699 rsl: [0, .. RAND_SIZE],
700 mem: [0, .. RAND_SIZE],
704 let array_size = sys::size_of_val(&rng.rsl);
705 let copy_length = cmp::min(array_size, seed.len());
707 // manually create a &mut [u8] slice of randrsl to copy into.
708 let dest = unsafe { cast::transmute((&mut rng.rsl, array_size)) };
709 vec::bytes::copy_memory(dest, seed, copy_length);
714 /// Create an ISAAC random number generator using the default
716 pub fn new_unseeded() -> IsaacRng {
717 let mut rng = IsaacRng {
719 rsl: [0, .. RAND_SIZE],
720 mem: [0, .. RAND_SIZE],
727 /// Initialises `self`. If `use_rsl` is true, then use the current value
728 /// of `rsl` as a seed, otherwise construct one algorithmically (not
730 fn init(&mut self, use_rsl: bool) {
731 let mut a = 0x9e3779b9;
742 a^=b<<11; d+=a; b+=c;
745 d^=e>>16; g+=d; e+=f;
746 e^=f<<10; h+=e; f+=g;
753 do 4.times { mix!(); }
756 macro_rules! memloop (
758 do u32::range_step(0, RAND_SIZE, 8) |i| {
759 a+=$arr[i ]; b+=$arr[i+1];
760 c+=$arr[i+2]; d+=$arr[i+3];
761 e+=$arr[i+4]; f+=$arr[i+5];
762 g+=$arr[i+6]; h+=$arr[i+7];
764 self.mem[i ]=a; self.mem[i+1]=b;
765 self.mem[i+2]=c; self.mem[i+3]=d;
766 self.mem[i+4]=e; self.mem[i+5]=f;
767 self.mem[i+6]=g; self.mem[i+7]=h;
776 do u32::range_step(0, RAND_SIZE, 8) |i| {
778 self.mem[i ]=a; self.mem[i+1]=b;
779 self.mem[i+2]=c; self.mem[i+3]=d;
780 self.mem[i+4]=e; self.mem[i+5]=f;
781 self.mem[i+6]=g; self.mem[i+7]=h;
789 /// Refills the output buffer (`self.rsl`)
791 fn isaac(&mut self) {
795 let mut b = self.b + self.c;
797 static MIDPOINT: uint = RAND_SIZE as uint / 2;
799 macro_rules! ind (($x:expr) => {
800 self.mem[($x >> 2) & (RAND_SIZE - 1)]
802 macro_rules! rngstep(
803 ($j:expr, $shift:expr) => {{
804 let base = base + $j;
805 let mix = if $shift < 0 {
811 let x = self.mem[base + mr_offset];
812 a = (a ^ mix) + self.mem[base + m2_offset];
813 let y = ind!(x) + a + b;
814 self.mem[base + mr_offset] = y;
816 b = ind!(y >> RAND_SIZE_LEN) + x;
817 self.rsl[base + mr_offset] = b;
821 let r = [(0, MIDPOINT), (MIDPOINT, 0)];
822 for &(mr_offset, m2_offset) in r.iter() {
823 do uint::range_step(0, MIDPOINT, 4) |base| {
834 self.cnt = RAND_SIZE;
838 impl Rng for IsaacRng {
840 fn next(&mut self) -> u32 {
842 // make some more numbers
850 /// An [Xorshift random number
851 /// generator](http://en.wikipedia.org/wiki/Xorshift).
853 /// The Xorshift algorithm is not suitable for cryptographic purposes
854 /// but is very fast. If you do not know for sure that it fits your
855 /// requirements, use a more secure one such as `IsaacRng`.
856 pub struct XorShiftRng {
863 impl Rng for XorShiftRng {
865 fn next(&mut self) -> u32 {
867 let t = x ^ (x << 11);
872 self.w = w ^ (w >> 19) ^ (t ^ (t >> 8));
878 /// Create an xor shift random number generator with a random seed.
879 pub fn new() -> XorShiftRng {
880 // generate seeds the same way as seed(), except we have a spceific size
881 let mut s = [0u8, ..16];
883 do s.as_mut_buf |p, sz| {
885 rustrt::rand_gen_seed(p, sz as size_t);
888 if !s.iter().all(|x| *x == 0) {
892 let s: &[u32, ..4] = unsafe { cast::transmute(&s) };
893 XorShiftRng::new_seeded(s[0], s[1], s[2], s[3])
897 * Create a random number generator using the specified seed. A generator
898 * constructed with a given seed will generate the same sequence of values
899 * as all other generators constructed with the same seed.
901 pub fn new_seeded(x: u32, y: u32, z: u32, w: u32) -> XorShiftRng {
911 /// Create a new random seed.
912 pub fn seed() -> ~[u8] {
914 let n = rustrt::rand_seed_size() as uint;
915 let mut s = vec::from_elem(n, 0_u8);
916 do s.as_mut_buf |p, sz| {
917 rustrt::rand_gen_seed(p, sz as size_t)
923 // used to make space in TLS for a random number generator
924 static tls_rng_state: local_data::Key<@@mut IsaacRng> = &local_data::Key;
927 * Gives back a lazily initialized task-local random number generator,
928 * seeded by the system. Intended to be used in method chaining style, ie
929 * `task_rng().gen::<int>()`.
932 pub fn task_rng() -> @mut IsaacRng {
933 let r = local_data::get(tls_rng_state, |k| k.map(|&k| *k));
936 let rng = @@mut IsaacRng::new_seeded(seed());
937 local_data::set(tls_rng_state, rng);
944 // Allow direct chaining with `task_rng`
945 impl<R: Rng> Rng for @mut R {
947 fn next(&mut self) -> u32 {
953 * Returns a random value of a Rand type, using the task's random number
957 pub fn random<T: Rand>() -> T {
963 use iterator::{Iterator, range};
964 use option::{Option, Some};
968 fn test_rng_seeded() {
970 let mut ra = IsaacRng::new_seeded(seed);
971 let mut rb = IsaacRng::new_seeded(seed);
972 assert_eq!(ra.gen_str(100u), rb.gen_str(100u));
976 fn test_rng_seeded_custom_seed() {
977 // much shorter than generated seeds which are 1024 bytes
978 let seed = [2u8, 32u8, 4u8, 32u8, 51u8];
979 let mut ra = IsaacRng::new_seeded(seed);
980 let mut rb = IsaacRng::new_seeded(seed);
981 assert_eq!(ra.gen_str(100u), rb.gen_str(100u));
985 fn test_rng_seeded_custom_seed2() {
986 let seed = [2u8, 32u8, 4u8, 32u8, 51u8];
987 let mut ra = IsaacRng::new_seeded(seed);
988 // Regression test that isaac is actually using the above vector
991 assert!(r == 890007737u32 // on x86_64
992 || r == 2935188040u32); // on x86
996 fn test_gen_int_range() {
998 let a = r.gen_int_range(-3, 42);
999 assert!(a >= -3 && a < 42);
1000 assert_eq!(r.gen_int_range(0, 1), 0);
1001 assert_eq!(r.gen_int_range(-12, -11), -12);
1006 #[ignore(cfg(windows))]
1007 fn test_gen_int_from_fail() {
1009 r.gen_int_range(5, -2);
1013 fn test_gen_uint_range() {
1015 let a = r.gen_uint_range(3u, 42u);
1016 assert!(a >= 3u && a < 42u);
1017 assert_eq!(r.gen_uint_range(0u, 1u), 0u);
1018 assert_eq!(r.gen_uint_range(12u, 13u), 12u);
1023 #[ignore(cfg(windows))]
1024 fn test_gen_uint_range_fail() {
1026 r.gen_uint_range(5u, 2u);
1030 fn test_gen_float() {
1032 let a = r.gen::<float>();
1033 let b = r.gen::<float>();
1038 fn test_gen_weighted_bool() {
1040 assert_eq!(r.gen_weighted_bool(0u), true);
1041 assert_eq!(r.gen_weighted_bool(1u), true);
1047 debug!(r.gen_str(10u));
1048 debug!(r.gen_str(10u));
1049 debug!(r.gen_str(10u));
1050 assert_eq!(r.gen_str(0u).len(), 0u);
1051 assert_eq!(r.gen_str(10u).len(), 10u);
1052 assert_eq!(r.gen_str(16u).len(), 16u);
1056 fn test_gen_bytes() {
1058 assert_eq!(r.gen_bytes(0u).len(), 0u);
1059 assert_eq!(r.gen_bytes(10u).len(), 10u);
1060 assert_eq!(r.gen_bytes(16u).len(), 16u);
1066 assert_eq!(r.choose([1, 1, 1]), 1);
1070 fn test_choose_option() {
1072 let x: Option<int> = r.choose_option([]);
1073 assert!(x.is_none());
1074 assert_eq!(r.choose_option([1, 1, 1]), Some(1));
1078 fn test_choose_weighted() {
1080 assert!(r.choose_weighted([
1081 Weighted { weight: 1u, item: 42 },
1083 assert!(r.choose_weighted([
1084 Weighted { weight: 0u, item: 42 },
1085 Weighted { weight: 1u, item: 43 },
1090 fn test_choose_weighted_option() {
1092 assert!(r.choose_weighted_option([
1093 Weighted { weight: 1u, item: 42 },
1095 assert!(r.choose_weighted_option([
1096 Weighted { weight: 0u, item: 42 },
1097 Weighted { weight: 1u, item: 43 },
1099 let v: Option<int> = r.choose_weighted_option([]);
1100 assert!(v.is_none());
1104 fn test_weighted_vec() {
1106 let empty: ~[int] = ~[];
1107 assert_eq!(r.weighted_vec([]), empty);
1108 assert!(r.weighted_vec([
1109 Weighted { weight: 0u, item: 3u },
1110 Weighted { weight: 1u, item: 2u },
1111 Weighted { weight: 2u, item: 1u },
1112 ]) == ~[2u, 1u, 1u]);
1118 let empty: ~[int] = ~[];
1119 assert_eq!(r.shuffle([]), empty);
1120 assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
1124 fn test_task_rng() {
1125 let mut r = task_rng();
1127 assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
1128 assert_eq!(r.gen_uint_range(0u, 1u), 0u);
1133 // not sure how to test this aside from just getting some values
1134 let _n : uint = random();
1135 let _f : f32 = random();
1136 let _o : Option<Option<i8>> = random();
1138 (~uint, @int, ~Option<~(@char, ~(@bool,))>),
1139 (u8, i8, u16, i16, u32, i32, u64, i64),
1140 (f32, (f64, (float,)))) = random();
1144 fn compare_isaac_implementation() {
1145 // This is to verify that the implementation of the ISAAC rng is
1146 // correct (i.e. matches the output of the upstream implementation,
1147 // which is in the runtime)
1154 #[allow(non_camel_case_types)] // runtime type
1155 pub enum rust_rng {}
1158 pub fn rand_new_seeded(buf: *u8, sz: size_t) -> *rust_rng;
1159 pub fn rand_next(rng: *rust_rng) -> u32;
1160 pub fn rand_free(rng: *rust_rng);
1164 // run against several seeds
1167 let seed = super::seed();
1168 let rt_rng = do seed.as_imm_buf |p, sz| {
1169 rustrt::rand_new_seeded(p, sz as size_t)
1171 let mut rng = IsaacRng::new_seeded(seed);
1174 assert_eq!(rng.next(), rustrt::rand_next(rt_rng));
1176 rustrt::rand_free(rt_rng);
1187 let vals = range(MIN_VAL, MAX_VAL).to_owned_vec();
1188 let small_sample = r.sample(vals.iter(), 5);
1189 let large_sample = r.sample(vals.iter(), vals.len() + 5);
1191 assert_eq!(small_sample.len(), 5);
1192 assert_eq!(large_sample.len(), vals.len());
1194 assert!(small_sample.iter().all(|e| {
1195 **e >= MIN_VAL && **e <= MAX_VAL
1202 use extra::test::BenchHarness;
1207 fn rand_xorshift(bh: &mut BenchHarness) {
1208 let mut rng = XorShiftRng::new();
1212 bh.bytes = size_of::<uint>() as u64;
1216 fn rand_isaac(bh: &mut BenchHarness) {
1217 let mut rng = IsaacRng::new();
1221 bh.bytes = size_of::<uint>() as u64;
1225 fn rand_shuffle_100(bh: &mut BenchHarness) {
1226 let mut rng = XorShiftRng::new();
1227 let x : &mut[uint] = [1,..100];