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