1 | // Copyright 2018 Developers of the Rand project. |
---|---|

2 | // Copyright 2013-2017 The Rust Project Developers. |

3 | // |

4 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |

5 | // https://www.apache.org/licenses/LICENSE-2.0> or the MIT license |

6 | // <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your |

7 | // option. This file may not be copied, modified, or distributed |

8 | // except according to those terms. |

9 | |

10 | //! [`Rng`] trait |

11 | |

12 | use rand_core::{Error, RngCore}; |

13 | use crate::distributions::uniform::{SampleRange, SampleUniform}; |

14 | use crate::distributions::{self, Distribution, Standard}; |

15 | use core::num::Wrapping; |

16 | use core::{mem, slice}; |

17 | |

18 | /// An automatically-implemented extension trait on [`RngCore`] providing high-level |

19 | /// generic methods for sampling values and other convenience methods. |

20 | /// |

21 | /// This is the primary trait to use when generating random values. |

22 | /// |

23 | /// # Generic usage |

24 | /// |

25 | /// The basic pattern is `fn foo<R: Rng + ?Sized>(rng: &mut R)`. Some |

26 | /// things are worth noting here: |

27 | /// |

28 | /// - Since `Rng: RngCore` and every `RngCore` implements `Rng`, it makes no |

29 | /// difference whether we use `R: Rng` or `R: RngCore`. |

30 | /// - The `+ ?Sized` un-bounding allows functions to be called directly on |

31 | /// type-erased references; i.e. `foo(r)` where `r: &mut dyn RngCore`. Without |

32 | /// this it would be necessary to write `foo(&mut r)`. |

33 | /// |

34 | /// An alternative pattern is possible: `fn foo<R: Rng>(rng: R)`. This has some |

35 | /// trade-offs. It allows the argument to be consumed directly without a `&mut` |

36 | /// (which is how `from_rng(thread_rng())` works); also it still works directly |

37 | /// on references (including type-erased references). Unfortunately within the |

38 | /// function `foo` it is not known whether `rng` is a reference type or not, |

39 | /// hence many uses of `rng` require an extra reference, either explicitly |

40 | /// (`distr.sample(&mut rng)`) or implicitly (`rng.gen()`); one may hope the |

41 | /// optimiser can remove redundant references later. |

42 | /// |

43 | /// Example: |

44 | /// |

45 | /// ``` |

46 | /// # use rand::thread_rng; |

47 | /// use rand::Rng; |

48 | /// |

49 | /// fn foo<R: Rng + ?Sized>(rng: &mut R) -> f32 { |

50 | /// rng.gen() |

51 | /// } |

52 | /// |

53 | /// # let v = foo(&mut thread_rng()); |

54 | /// ``` |

55 | pub trait Rng: RngCore { |

56 | /// Return a random value supporting the [`Standard`] distribution. |

57 | /// |

58 | /// # Example |

59 | /// |

60 | /// ``` |

61 | /// use rand::{thread_rng, Rng}; |

62 | /// |

63 | /// let mut rng = thread_rng(); |

64 | /// let x: u32 = rng.gen(); |

65 | /// println!("{}", x); |

66 | /// println!("{:?}", rng.gen::<(f64, bool)>()); |

67 | /// ``` |

68 | /// |

69 | /// # Arrays and tuples |

70 | /// |

71 | /// The `rng.gen()` method is able to generate arrays (up to 32 elements) |

72 | /// and tuples (up to 12 elements), so long as all element types can be |

73 | /// generated. |

74 | /// When using `rustc` ≥ 1.51, enable the `min_const_gen` feature to support |

75 | /// arrays larger than 32 elements. |

76 | /// |

77 | /// For arrays of integers, especially for those with small element types |

78 | /// (< 64 bit), it will likely be faster to instead use [`Rng::fill`]. |

79 | /// |

80 | /// ``` |

81 | /// use rand::{thread_rng, Rng}; |

82 | /// |

83 | /// let mut rng = thread_rng(); |

84 | /// let tuple: (u8, i32, char) = rng.gen(); // arbitrary tuple support |

85 | /// |

86 | /// let arr1: [f32; 32] = rng.gen(); // array construction |

87 | /// let mut arr2 = [0u8; 128]; |

88 | /// rng.fill(&mut arr2); // array fill |

89 | /// ``` |

90 | /// |

91 | /// [`Standard`]: distributions::Standard |

92 | #[inline] |

93 | fn gen<T>(&mut self) -> T |

94 | where Standard: Distribution<T> { |

95 | Standard.sample(self) |

96 | } |

97 | |

98 | /// Generate a random value in the given range. |

99 | /// |

100 | /// This function is optimised for the case that only a single sample is |

101 | /// made from the given range. See also the [`Uniform`] distribution |

102 | /// type which may be faster if sampling from the same range repeatedly. |

103 | /// |

104 | /// Only `gen_range(low..high)` and `gen_range(low..=high)` are supported. |

105 | /// |

106 | /// # Panics |

107 | /// |

108 | /// Panics if the range is empty. |

109 | /// |

110 | /// # Example |

111 | /// |

112 | /// ``` |

113 | /// use rand::{thread_rng, Rng}; |

114 | /// |

115 | /// let mut rng = thread_rng(); |

116 | /// |

117 | /// // Exclusive range |

118 | /// let n: u32 = rng.gen_range(0..10); |

119 | /// println!("{}", n); |

120 | /// let m: f64 = rng.gen_range(-40.0..1.3e5); |

121 | /// println!("{}", m); |

122 | /// |

123 | /// // Inclusive range |

124 | /// let n: u32 = rng.gen_range(0..=10); |

125 | /// println!("{}", n); |

126 | /// ``` |

127 | /// |

128 | /// [`Uniform`]: distributions::uniform::Uniform |

129 | fn gen_range<T, R>(&mut self, range: R) -> T |

130 | where |

131 | T: SampleUniform, |

132 | R: SampleRange<T> |

133 | { |

134 | assert!(!range.is_empty(), "cannot sample empty range"); |

135 | range.sample_single(self) |

136 | } |

137 | |

138 | /// Sample a new value, using the given distribution. |

139 | /// |

140 | /// ### Example |

141 | /// |

142 | /// ``` |

143 | /// use rand::{thread_rng, Rng}; |

144 | /// use rand::distributions::Uniform; |

145 | /// |

146 | /// let mut rng = thread_rng(); |

147 | /// let x = rng.sample(Uniform::new(10u32, 15)); |

148 | /// // Type annotation requires two types, the type and distribution; the |

149 | /// // distribution can be inferred. |

150 | /// let y = rng.sample::<u16, _>(Uniform::new(10, 15)); |

151 | /// ``` |

152 | fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T { |

153 | distr.sample(self) |

154 | } |

155 | |

156 | /// Create an iterator that generates values using the given distribution. |

157 | /// |

158 | /// Note that this function takes its arguments by value. This works since |

159 | /// `(&mut R): Rng where R: Rng` and |

160 | /// `(&D): Distribution where D: Distribution`, |

161 | /// however borrowing is not automatic hence `rng.sample_iter(...)` may |

162 | /// need to be replaced with `(&mut rng).sample_iter(...)`. |

163 | /// |

164 | /// # Example |

165 | /// |

166 | /// ``` |

167 | /// use rand::{thread_rng, Rng}; |

168 | /// use rand::distributions::{Alphanumeric, Uniform, Standard}; |

169 | /// |

170 | /// let mut rng = thread_rng(); |

171 | /// |

172 | /// // Vec of 16 x f32: |

173 | /// let v: Vec<f32> = (&mut rng).sample_iter(Standard).take(16).collect(); |

174 | /// |

175 | /// // String: |

176 | /// let s: String = (&mut rng).sample_iter(Alphanumeric) |

177 | /// .take(7) |

178 | /// .map(char::from) |

179 | /// .collect(); |

180 | /// |

181 | /// // Combined values |

182 | /// println!("{:?}", (& mut rng).sample_iter(Standard).take(5) |

183 | /// .collect::<Vec<(f64, bool)>>()); |

184 | /// |

185 | /// // Dice-rolling: |

186 | /// let die_range = Uniform::new_inclusive(1, 6); |

187 | /// let mut roll_die = (&mut rng).sample_iter(die_range); |

188 | /// while roll_die.next().unwrap() != 6 { |

189 | /// println!("Not a 6; rolling again!"); |

190 | /// } |

191 | /// ``` |

192 | fn sample_iter<T, D>(self, distr: D) -> distributions::DistIter<D, Self, T> |

193 | where |

194 | D: Distribution<T>, |

195 | Self: Sized, |

196 | { |

197 | distr.sample_iter(self) |

198 | } |

199 | |

200 | /// Fill any type implementing [`Fill`] with random data |

201 | /// |

202 | /// The distribution is expected to be uniform with portable results, but |

203 | /// this cannot be guaranteed for third-party implementations. |

204 | /// |

205 | /// This is identical to [`try_fill`] except that it panics on error. |

206 | /// |

207 | /// # Example |

208 | /// |

209 | /// ``` |

210 | /// use rand::{thread_rng, Rng}; |

211 | /// |

212 | /// let mut arr = [0i8; 20]; |

213 | /// thread_rng().fill(&mut arr[..]); |

214 | /// ``` |

215 | /// |

216 | /// [`fill_bytes`]: RngCore::fill_bytes |

217 | /// [`try_fill`]: Rng::try_fill |

218 | fn fill<T: Fill + ?Sized>(&mut self, dest: &mut T) { |

219 | dest.try_fill(self).unwrap_or_else(|_| panic!("Rng::fill failed")) |

220 | } |

221 | |

222 | /// Fill any type implementing [`Fill`] with random data |

223 | /// |

224 | /// The distribution is expected to be uniform with portable results, but |

225 | /// this cannot be guaranteed for third-party implementations. |

226 | /// |

227 | /// This is identical to [`fill`] except that it forwards errors. |

228 | /// |

229 | /// # Example |

230 | /// |

231 | /// ``` |

232 | /// # use rand::Error; |

233 | /// use rand::{thread_rng, Rng}; |

234 | /// |

235 | /// # fn try_inner() -> Result<(), Error> { |

236 | /// let mut arr = [0u64; 4]; |

237 | /// thread_rng().try_fill(&mut arr[..])?; |

238 | /// # Ok(()) |

239 | /// # } |

240 | /// |

241 | /// # try_inner().unwrap() |

242 | /// ``` |

243 | /// |

244 | /// [`try_fill_bytes`]: RngCore::try_fill_bytes |

245 | /// [`fill`]: Rng::fill |

246 | fn try_fill<T: Fill + ?Sized>(&mut self, dest: &mut T) -> Result<(), Error> { |

247 | dest.try_fill(self) |

248 | } |

249 | |

250 | /// Return a bool with a probability `p` of being true. |

251 | /// |

252 | /// See also the [`Bernoulli`] distribution, which may be faster if |

253 | /// sampling from the same probability repeatedly. |

254 | /// |

255 | /// # Example |

256 | /// |

257 | /// ``` |

258 | /// use rand::{thread_rng, Rng}; |

259 | /// |

260 | /// let mut rng = thread_rng(); |

261 | /// println!("{}", rng.gen_bool( 1.0 / 3.0)); |

262 | /// ``` |

263 | /// |

264 | /// # Panics |

265 | /// |

266 | /// If `p < 0` or `p > 1`. |

267 | /// |

268 | /// [`Bernoulli`]: distributions::Bernoulli |

269 | #[inline] |

270 | fn gen_bool(&mut self, p: f64) -> bool { |

271 | let d = distributions::Bernoulli::new(p).unwrap(); |

272 | self.sample(d) |

273 | } |

274 | |

275 | /// Return a bool with a probability of `numerator/denominator` of being |

276 | /// true. I.e. `gen_ratio(2, 3)` has chance of 2 in 3, or about 67%, of |

277 | /// returning true. If `numerator == denominator`, then the returned value |

278 | /// is guaranteed to be `true`. If `numerator == 0`, then the returned |

279 | /// value is guaranteed to be `false`. |

280 | /// |

281 | /// See also the [`Bernoulli`] distribution, which may be faster if |

282 | /// sampling from the same `numerator` and `denominator` repeatedly. |

283 | /// |

284 | /// # Panics |

285 | /// |

286 | /// If `denominator == 0` or `numerator > denominator`. |

287 | /// |

288 | /// # Example |

289 | /// |

290 | /// ``` |

291 | /// use rand::{thread_rng, Rng}; |

292 | /// |

293 | /// let mut rng = thread_rng(); |

294 | /// println!("{}", rng.gen_ratio( 2, 3)); |

295 | /// ``` |

296 | /// |

297 | /// [`Bernoulli`]: distributions::Bernoulli |

298 | #[inline] |

299 | fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool { |

300 | let d = distributions::Bernoulli::from_ratio(numerator, denominator).unwrap(); |

301 | self.sample(d) |

302 | } |

303 | } |

304 | |

305 | impl<R: RngCore + ?Sized> Rng for R {} |

306 | |

307 | /// Types which may be filled with random data |

308 | /// |

309 | /// This trait allows arrays to be efficiently filled with random data. |

310 | /// |

311 | /// Implementations are expected to be portable across machines unless |

312 | /// clearly documented otherwise (see the |

313 | /// [Chapter on Portability](https://rust-random.github.io/book/portability.html)). |

314 | pub trait Fill { |

315 | /// Fill self with random data |

316 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error>; |

317 | } |

318 | |

319 | macro_rules! impl_fill_each { |

320 | () => {}; |

321 | ($t:ty) => { |

322 | impl Fill for [$t] { |

323 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> { |

324 | for elt in self.iter_mut() { |

325 | *elt = rng.gen(); |

326 | } |

327 | Ok(()) |

328 | } |

329 | } |

330 | }; |

331 | ($t:ty, $($tt:ty,)*) => { |

332 | impl_fill_each!($t); |

333 | impl_fill_each!($($tt,)*); |

334 | }; |

335 | } |

336 | |

337 | impl_fill_each!(bool, char, f32, f64,); |

338 | |

339 | impl Fill for [u8] { |

340 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> { |

341 | rng.try_fill_bytes(self) |

342 | } |

343 | } |

344 | |

345 | macro_rules! impl_fill { |

346 | () => {}; |

347 | ($t:ty) => { |

348 | impl Fill for [$t] { |

349 | #[inline(never)] // in micro benchmarks, this improves performance |

350 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> { |

351 | if self.len() > 0 { |

352 | rng.try_fill_bytes(unsafe { |

353 | slice::from_raw_parts_mut(self.as_mut_ptr() |

354 | as *mut u8, |

355 | self.len() * mem::size_of::<$t>() |

356 | ) |

357 | })?; |

358 | for x in self { |

359 | *x = x.to_le(); |

360 | } |

361 | } |

362 | Ok(()) |

363 | } |

364 | } |

365 | |

366 | impl Fill for [Wrapping<$t>] { |

367 | #[inline(never)] |

368 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> { |

369 | if self.len() > 0 { |

370 | rng.try_fill_bytes(unsafe { |

371 | slice::from_raw_parts_mut(self.as_mut_ptr() |

372 | as *mut u8, |

373 | self.len() * mem::size_of::<$t>() |

374 | ) |

375 | })?; |

376 | for x in self { |

377 | *x = Wrapping(x.0.to_le()); |

378 | } |

379 | } |

380 | Ok(()) |

381 | } |

382 | } |

383 | }; |

384 | ($t:ty, $($tt:ty,)*) => { |

385 | impl_fill!($t); |

386 | // TODO: this could replace above impl once Rust #32463 is fixed |

387 | // impl_fill!(Wrapping<$t>); |

388 | impl_fill!($($tt,)*); |

389 | } |

390 | } |

391 | |

392 | impl_fill!(u16, u32, u64, usize, u128,); |

393 | impl_fill!(i8, i16, i32, i64, isize, i128,); |

394 | |

395 | #[cfg_attr(doc_cfg, doc(cfg(feature = "min_const_gen")))] |

396 | #[cfg(feature = "min_const_gen")] |

397 | impl<T, const N: usize> Fill for [T; N] |

398 | where [T]: Fill |

399 | { |

400 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> { |

401 | self[..].try_fill(rng) |

402 | } |

403 | } |

404 | |

405 | #[cfg(not(feature = "min_const_gen"))] |

406 | macro_rules! impl_fill_arrays { |

407 | ($n:expr,) => {}; |

408 | ($n:expr, $N:ident) => { |

409 | impl<T> Fill for [T; $n] where [T]: Fill { |

410 | fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> { |

411 | self[..].try_fill(rng) |

412 | } |

413 | } |

414 | }; |

415 | ($n:expr, $N:ident, $($NN:ident,)*) => { |

416 | impl_fill_arrays!($n, $N); |

417 | impl_fill_arrays!($n - 1, $($NN,)*); |

418 | }; |

419 | (!div $n:expr,) => {}; |

420 | (!div $n:expr, $N:ident, $($NN:ident,)*) => { |

421 | impl_fill_arrays!($n, $N); |

422 | impl_fill_arrays!(!div $n / 2, $($NN,)*); |

423 | }; |

424 | } |

425 | #[cfg(not(feature = "min_const_gen"))] |

426 | #[rustfmt::skip] |

427 | impl_fill_arrays!(32, N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,); |

428 | #[cfg(not(feature = "min_const_gen"))] |

429 | impl_fill_arrays!(!div 4096, N,N,N,N,N,N,N,); |

430 | |

431 | #[cfg(test)] |

432 | mod test { |

433 | use super::*; |

434 | use crate::test::rng; |

435 | use crate::rngs::mock::StepRng; |

436 | #[cfg(feature = "alloc")] use alloc::boxed::Box; |

437 | |

438 | #[test] |

439 | fn test_fill_bytes_default() { |

440 | let mut r = StepRng::new(0x11_22_33_44_55_66_77_88, 0); |

441 | |

442 | // check every remainder mod 8, both in small and big vectors. |

443 | let lengths = [0, 1, 2, 3, 4, 5, 6, 7, 80, 81, 82, 83, 84, 85, 86, 87]; |

444 | for &n in lengths.iter() { |

445 | let mut buffer = [0u8; 87]; |

446 | let v = &mut buffer[0..n]; |

447 | r.fill_bytes(v); |

448 | |

449 | // use this to get nicer error messages. |

450 | for (i, &byte) in v.iter().enumerate() { |

451 | if byte == 0 { |

452 | panic!("byte {} of {} is zero", i, n) |

453 | } |

454 | } |

455 | } |

456 | } |

457 | |

458 | #[test] |

459 | fn test_fill() { |

460 | let x = 9041086907909331047; // a random u64 |

461 | let mut rng = StepRng::new(x, 0); |

462 | |

463 | // Convert to byte sequence and back to u64; byte-swap twice if BE. |

464 | let mut array = [0u64; 2]; |

465 | rng.fill(&mut array[..]); |

466 | assert_eq!(array, [x, x]); |

467 | assert_eq!(rng.next_u64(), x); |

468 | |

469 | // Convert to bytes then u32 in LE order |

470 | let mut array = [0u32; 2]; |

471 | rng.fill(&mut array[..]); |

472 | assert_eq!(array, [x as u32, (x >> 32) as u32]); |

473 | assert_eq!(rng.next_u32(), x as u32); |

474 | |

475 | // Check equivalence using wrapped arrays |

476 | let mut warray = [Wrapping(0u32); 2]; |

477 | rng.fill(&mut warray[..]); |

478 | assert_eq!(array[0], warray[0].0); |

479 | assert_eq!(array[1], warray[1].0); |

480 | |

481 | // Check equivalence for generated floats |

482 | let mut array = [0f32; 2]; |

483 | rng.fill(&mut array); |

484 | let gen: [f32; 2] = rng.gen(); |

485 | assert_eq!(array, gen); |

486 | } |

487 | |

488 | #[test] |

489 | fn test_fill_empty() { |

490 | let mut array = [0u32; 0]; |

491 | let mut rng = StepRng::new(0, 1); |

492 | rng.fill(&mut array); |

493 | rng.fill(&mut array[..]); |

494 | } |

495 | |

496 | #[test] |

497 | fn test_gen_range_int() { |

498 | let mut r = rng(101); |

499 | for _ in 0..1000 { |

500 | let a = r.gen_range(-4711..17); |

501 | assert!((-4711..17).contains(&a)); |

502 | let a: i8 = r.gen_range(-3..42); |

503 | assert!((-3..42).contains(&a)); |

504 | let a: u16 = r.gen_range(10..99); |

505 | assert!((10..99).contains(&a)); |

506 | let a: i32 = r.gen_range(-100..2000); |

507 | assert!((-100..2000).contains(&a)); |

508 | let a: u32 = r.gen_range(12..=24); |

509 | assert!((12..=24).contains(&a)); |

510 | |

511 | assert_eq!(r.gen_range(0u32..1), 0u32); |

512 | assert_eq!(r.gen_range(-12i64..-11), -12i64); |

513 | assert_eq!(r.gen_range(3_000_000..3_000_001), 3_000_000); |

514 | } |

515 | } |

516 | |

517 | #[test] |

518 | fn test_gen_range_float() { |

519 | let mut r = rng(101); |

520 | for _ in 0..1000 { |

521 | let a = r.gen_range(-4.5..1.7); |

522 | assert!((-4.5..1.7).contains(&a)); |

523 | let a = r.gen_range(-1.1..=-0.3); |

524 | assert!((-1.1..=-0.3).contains(&a)); |

525 | |

526 | assert_eq!(r.gen_range(0.0f32..=0.0), 0.); |

527 | assert_eq!(r.gen_range(-11.0..=-11.0), -11.); |

528 | assert_eq!(r.gen_range(3_000_000.0..=3_000_000.0), 3_000_000.); |

529 | } |

530 | } |

531 | |

532 | #[test] |

533 | #[should_panic] |

534 | fn test_gen_range_panic_int() { |

535 | #![allow(clippy::reversed_empty_ranges)] |

536 | let mut r = rng(102); |

537 | r.gen_range(5..-2); |

538 | } |

539 | |

540 | #[test] |

541 | #[should_panic] |

542 | fn test_gen_range_panic_usize() { |

543 | #![allow(clippy::reversed_empty_ranges)] |

544 | let mut r = rng(103); |

545 | r.gen_range(5..2); |

546 | } |

547 | |

548 | #[test] |

549 | fn test_gen_bool() { |

550 | #![allow(clippy::bool_assert_comparison)] |

551 | |

552 | let mut r = rng(105); |

553 | for _ in 0..5 { |

554 | assert_eq!(r.gen_bool(0.0), false); |

555 | assert_eq!(r.gen_bool(1.0), true); |

556 | } |

557 | } |

558 | |

559 | #[test] |

560 | fn test_rng_trait_object() { |

561 | use crate::distributions::{Distribution, Standard}; |

562 | let mut rng = rng(109); |

563 | let mut r = &mut rng as &mut dyn RngCore; |

564 | r.next_u32(); |

565 | r.gen::<i32>(); |

566 | assert_eq!(r.gen_range(0..1), 0); |

567 | let _c: u8 = Standard.sample(&mut r); |

568 | } |

569 | |

570 | #[test] |

571 | #[cfg(feature = "alloc")] |

572 | fn test_rng_boxed_trait() { |

573 | use crate::distributions::{Distribution, Standard}; |

574 | let rng = rng(110); |

575 | let mut r = Box::new(rng) as Box<dyn RngCore>; |

576 | r.next_u32(); |

577 | r.gen::<i32>(); |

578 | assert_eq!(r.gen_range(0..1), 0); |

579 | let _c: u8 = Standard.sample(&mut r); |

580 | } |

581 | |

582 | #[test] |

583 | #[cfg_attr(miri, ignore)] // Miri is too slow |

584 | fn test_gen_ratio_average() { |

585 | const NUM: u32 = 3; |

586 | const DENOM: u32 = 10; |

587 | const N: u32 = 100_000; |

588 | |

589 | let mut sum: u32 = 0; |

590 | let mut rng = rng(111); |

591 | for _ in 0..N { |

592 | if rng.gen_ratio(NUM, DENOM) { |

593 | sum += 1; |

594 | } |

595 | } |

596 | // Have Binomial(N, NUM/DENOM) distribution |

597 | let expected = (NUM * N) / DENOM; // exact integer |

598 | assert!(((sum - expected) as i32).abs() < 500); |

599 | } |

600 | } |

601 |