1 // Copyright 2013-2014 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 //! This release is a compatibility wrapper around `rand` version 0.4. Please 14 //! upgrade. 15 16 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png", 17 html_favicon_url = "https://www.rust-lang.org/favicon.ico", 18 html_root_url = "https://docs.rs/rand/0.3")] 19 20 #![deny(missing_debug_implementations)] 21 22 #![cfg_attr(feature = "i128_support", feature(i128_type))] 23 24 extern crate rand as rand4; 25 26 pub use rand4::OsRng; 27 28 pub use rand4::{IsaacRng, Isaac64Rng}; 29 pub use rand4::ChaChaRng; 30 31 pub mod distributions; 32 pub use rand4::{isaac, chacha, reseeding, os, read}; 33 mod rand_impls; 34 35 pub use rand4::Rng; 36 pub use rand4::Rand; 37 pub use rand4::SeedableRng; 38 39 pub use rand4::{Generator, AsciiGenerator}; 40 pub use rand4::XorShiftRng; 41 pub use rand4::{Open01, Closed01}; 42 pub use rand4::StdRng; 43 pub use rand4::{weak_rng, ThreadRng, thread_rng, random}; 44 45 #[allow(deprecated)] 46 pub use rand4::sample; 47 48 #[allow(deprecated)] 49 #[cfg(test)] 50 mod test { 51 use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample, 52 weak_rng}; 53 use std::iter::repeat; 54 55 pub struct MyRng<R> { inner: R } 56 57 impl<R: Rng> Rng for MyRng<R> { next_u32(&mut self) -> u3258 fn next_u32(&mut self) -> u32 { 59 fn next<T: Rng>(t: &mut T) -> u32 { 60 t.next_u32() 61 } 62 next(&mut self.inner) 63 } 64 } 65 rng() -> MyRng<::ThreadRng>66 pub fn rng() -> MyRng<::ThreadRng> { 67 MyRng { inner: ::thread_rng() } 68 } 69 70 struct ConstRng { i: u64 } 71 impl Rng for ConstRng { next_u32(&mut self) -> u3272 fn next_u32(&mut self) -> u32 { self.i as u32 } next_u64(&mut self) -> u6473 fn next_u64(&mut self) -> u64 { self.i } 74 75 // no fill_bytes on purpose 76 } 77 iter_eq<I, J>(i: I, j: J) -> bool where I: IntoIterator, J: IntoIterator<Item=I::Item>, I::Item: Eq78 pub fn iter_eq<I, J>(i: I, j: J) -> bool 79 where I: IntoIterator, 80 J: IntoIterator<Item=I::Item>, 81 I::Item: Eq 82 { 83 // make sure the iterators have equal length 84 let mut i = i.into_iter(); 85 let mut j = j.into_iter(); 86 loop { 87 match (i.next(), j.next()) { 88 (Some(ref ei), Some(ref ej)) if ei == ej => { } 89 (None, None) => return true, 90 _ => return false, 91 } 92 } 93 } 94 95 #[test] test_fill_bytes_default()96 fn test_fill_bytes_default() { 97 let mut r = ConstRng { i: 0x11_22_33_44_55_66_77_88 }; 98 99 // check every remainder mod 8, both in small and big vectors. 100 let lengths = [0, 1, 2, 3, 4, 5, 6, 7, 101 80, 81, 82, 83, 84, 85, 86, 87]; 102 for &n in lengths.iter() { 103 let mut v = repeat(0u8).take(n).collect::<Vec<_>>(); 104 r.fill_bytes(&mut v); 105 106 // use this to get nicer error messages. 107 for (i, &byte) in v.iter().enumerate() { 108 if byte == 0 { 109 panic!("byte {} of {} is zero", i, n) 110 } 111 } 112 } 113 } 114 115 #[test] test_gen_range()116 fn test_gen_range() { 117 let mut r = thread_rng(); 118 for _ in 0..1000 { 119 let a = r.gen_range(-3, 42); 120 assert!(a >= -3 && a < 42); 121 assert_eq!(r.gen_range(0, 1), 0); 122 assert_eq!(r.gen_range(-12, -11), -12); 123 } 124 125 for _ in 0..1000 { 126 let a = r.gen_range(10, 42); 127 assert!(a >= 10 && a < 42); 128 assert_eq!(r.gen_range(0, 1), 0); 129 assert_eq!(r.gen_range(3_000_000, 3_000_001), 3_000_000); 130 } 131 132 } 133 134 #[test] 135 #[should_panic] test_gen_range_panic_int()136 fn test_gen_range_panic_int() { 137 let mut r = thread_rng(); 138 r.gen_range(5, -2); 139 } 140 141 #[test] 142 #[should_panic] test_gen_range_panic_usize()143 fn test_gen_range_panic_usize() { 144 let mut r = thread_rng(); 145 r.gen_range(5, 2); 146 } 147 148 #[test] test_gen_weighted_bool()149 fn test_gen_weighted_bool() { 150 let mut r = thread_rng(); 151 assert_eq!(r.gen_weighted_bool(0), true); 152 assert_eq!(r.gen_weighted_bool(1), true); 153 } 154 155 #[test] test_gen_ascii_str()156 fn test_gen_ascii_str() { 157 let mut r = thread_rng(); 158 assert_eq!(r.gen_ascii_chars().take(0).count(), 0); 159 assert_eq!(r.gen_ascii_chars().take(10).count(), 10); 160 assert_eq!(r.gen_ascii_chars().take(16).count(), 16); 161 } 162 163 #[test] test_gen_vec()164 fn test_gen_vec() { 165 let mut r = thread_rng(); 166 assert_eq!(r.gen_iter::<u8>().take(0).count(), 0); 167 assert_eq!(r.gen_iter::<u8>().take(10).count(), 10); 168 assert_eq!(r.gen_iter::<f64>().take(16).count(), 16); 169 } 170 171 #[test] test_choose()172 fn test_choose() { 173 let mut r = thread_rng(); 174 assert_eq!(r.choose(&[1, 1, 1]).map(|&x|x), Some(1)); 175 176 let v: &[isize] = &[]; 177 assert_eq!(r.choose(v), None); 178 } 179 180 #[test] test_shuffle()181 fn test_shuffle() { 182 let mut r = thread_rng(); 183 let empty: &mut [isize] = &mut []; 184 r.shuffle(empty); 185 let mut one = [1]; 186 r.shuffle(&mut one); 187 let b: &[_] = &[1]; 188 assert_eq!(one, b); 189 190 let mut two = [1, 2]; 191 r.shuffle(&mut two); 192 assert!(two == [1, 2] || two == [2, 1]); 193 194 let mut x = [1, 1, 1]; 195 r.shuffle(&mut x); 196 let b: &[_] = &[1, 1, 1]; 197 assert_eq!(x, b); 198 } 199 200 #[test] test_thread_rng()201 fn test_thread_rng() { 202 let mut r = thread_rng(); 203 r.gen::<i32>(); 204 let mut v = [1, 1, 1]; 205 r.shuffle(&mut v); 206 let b: &[_] = &[1, 1, 1]; 207 assert_eq!(v, b); 208 assert_eq!(r.gen_range(0, 1), 0); 209 } 210 211 #[test] test_rng_trait_object()212 fn test_rng_trait_object() { 213 let mut rng = thread_rng(); 214 { 215 let mut r = &mut rng as &mut Rng; 216 r.next_u32(); 217 (&mut r).gen::<i32>(); 218 let mut v = [1, 1, 1]; 219 (&mut r).shuffle(&mut v); 220 let b: &[_] = &[1, 1, 1]; 221 assert_eq!(v, b); 222 assert_eq!((&mut r).gen_range(0, 1), 0); 223 } 224 { 225 let mut r = Box::new(rng) as Box<Rng>; 226 r.next_u32(); 227 r.gen::<i32>(); 228 let mut v = [1, 1, 1]; 229 r.shuffle(&mut v); 230 let b: &[_] = &[1, 1, 1]; 231 assert_eq!(v, b); 232 assert_eq!(r.gen_range(0, 1), 0); 233 } 234 } 235 236 #[test] test_random()237 fn test_random() { 238 // not sure how to test this aside from just getting some values 239 let _n : usize = random(); 240 let _f : f32 = random(); 241 let _o : Option<Option<i8>> = random(); 242 let _many : ((), 243 (usize, 244 isize, 245 Option<(u32, (bool,))>), 246 (u8, i8, u16, i16, u32, i32, u64, i64), 247 (f32, (f64, (f64,)))) = random(); 248 } 249 250 #[test] test_sample()251 fn test_sample() { 252 let min_val = 1; 253 let max_val = 100; 254 255 let mut r = thread_rng(); 256 let vals = (min_val..max_val).collect::<Vec<i32>>(); 257 let small_sample = sample(&mut r, vals.iter(), 5); 258 let large_sample = sample(&mut r, vals.iter(), vals.len() + 5); 259 260 assert_eq!(small_sample.len(), 5); 261 assert_eq!(large_sample.len(), vals.len()); 262 263 assert!(small_sample.iter().all(|e| { 264 **e >= min_val && **e <= max_val 265 })); 266 } 267 268 #[test] test_std_rng_seeded()269 fn test_std_rng_seeded() { 270 let s = thread_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>(); 271 let mut ra: StdRng = SeedableRng::from_seed(&s[..]); 272 let mut rb: StdRng = SeedableRng::from_seed(&s[..]); 273 assert!(iter_eq(ra.gen_ascii_chars().take(100), 274 rb.gen_ascii_chars().take(100))); 275 } 276 277 #[test] test_std_rng_reseed()278 fn test_std_rng_reseed() { 279 let s = thread_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>(); 280 let mut r: StdRng = SeedableRng::from_seed(&s[..]); 281 let string1 = r.gen_ascii_chars().take(100).collect::<String>(); 282 283 r.reseed(&s); 284 285 let string2 = r.gen_ascii_chars().take(100).collect::<String>(); 286 assert_eq!(string1, string2); 287 } 288 289 #[test] test_weak_rng()290 fn test_weak_rng() { 291 let s = weak_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>(); 292 let mut ra: StdRng = SeedableRng::from_seed(&s[..]); 293 let mut rb: StdRng = SeedableRng::from_seed(&s[..]); 294 assert!(iter_eq(ra.gen_ascii_chars().take(100), 295 rb.gen_ascii_chars().take(100))); 296 } 297 } 298