1// Copyright 2018 Developers of the Rand project.
2//
3// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
6// option. This file may not be copied, modified, or distributed
7// except according to those terms.
8
9#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
10use rand_core::impls::fill_bytes_via_next;
11use rand_core::le::read_u64_into;
12use rand_core::{SeedableRng, RngCore, Error};
13
14/// A xoshiro256** random number generator.
15///
16/// The xoshiro256** algorithm is not suitable for cryptographic purposes, but
17/// is very fast and has excellent statistical properties.
18///
19/// The algorithm used here is translated from [the `xoshiro256starstar.c`
20/// reference source code](http://xoshiro.di.unimi.it/xoshiro256starstar.c) by
21/// David Blackman and Sebastiano Vigna.
22#[derive(Debug, Clone, PartialEq, Eq)]
23#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
24pub struct Xoshiro256StarStar {
25 s: [u64; 4],
26}
27
28impl Xoshiro256StarStar {
29 /// Jump forward, equivalently to 2^128 calls to `next_u64()`.
30 ///
31 /// This can be used to generate 2^128 non-overlapping subsequences for
32 /// parallel computations.
33 ///
34 /// ```
35 /// use rand_xoshiro::rand_core::SeedableRng;
36 /// use rand_xoshiro::Xoshiro256StarStar;
37 ///
38 /// let rng1 = Xoshiro256StarStar::seed_from_u64(0);
39 /// let mut rng2 = rng1.clone();
40 /// rng2.jump();
41 /// let mut rng3 = rng2.clone();
42 /// rng3.jump();
43 /// ```
44 pub fn jump(&mut self) {
45 impl_jump!(u64, self, [
46 0x180ec6d33cfd0aba, 0xd5a61266f0c9392c,
47 0xa9582618e03fc9aa, 0x39abdc4529b1661c
48 ]);
49 }
50
51 /// Jump forward, equivalently to 2^192 calls to `next_u64()`.
52 ///
53 /// This can be used to generate 2^64 starting points, from each of which
54 /// `jump()` will generate 2^64 non-overlapping subsequences for parallel
55 /// distributed computations.
56 pub fn long_jump(&mut self) {
57 impl_jump!(u64, self, [
58 0x76e15d3efefdcbbf, 0xc5004e441c522fb3,
59 0x77710069854ee241, 0x39109bb02acbe635
60 ]);
61 }
62}
63
64impl SeedableRng for Xoshiro256StarStar {
65 type Seed = [u8; 32];
66
67 /// Create a new `Xoshiro256StarStar`. If `seed` is entirely 0, it will be
68 /// mapped to a different seed.
69 #[inline]
70 fn from_seed(seed: [u8; 32]) -> Xoshiro256StarStar {
71 deal_with_zero_seed!(seed, Self);
72 let mut state: [u64; 4] = [0; 4];
73 read_u64_into(&seed, &mut state);
74 Xoshiro256StarStar { s: state }
75 }
76
77 /// Seed a `Xoshiro256StarStar` from a `u64` using `SplitMix64`.
78 fn seed_from_u64(seed: u64) -> Xoshiro256StarStar {
79 from_splitmix!(seed)
80 }
81}
82
83impl RngCore for Xoshiro256StarStar {
84 #[inline]
85 fn next_u32(&mut self) -> u32 {
86 // The lowest bits have some linear dependencies, so we use the
87 // upper bits instead.
88 (self.next_u64() >> 32) as u32
89 }
90
91 #[inline]
92 fn next_u64(&mut self) -> u64 {
93 let result_starstar = starstar_u64!(self.s[1]);
94 impl_xoshiro_u64!(self);
95 result_starstar
96 }
97
98 #[inline]
99 fn fill_bytes(&mut self, dest: &mut [u8]) {
100 fill_bytes_via_next(self, dest);
101 }
102
103 #[inline]
104 fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
105 self.fill_bytes(dest);
106 Ok(())
107 }
108}
109
110#[cfg(test)]
111mod tests {
112 use super::*;
113
114 #[test]
115 fn reference() {
116 let mut rng = Xoshiro256StarStar::from_seed(
117 [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
118 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0]);
119 // These values were produced with the reference implementation:
120 // http://xoshiro.di.unimi.it/xoshiro128starstar.c
121 let expected = [
122 11520, 0, 1509978240, 1215971899390074240, 1216172134540287360,
123 607988272756665600, 16172922978634559625, 8476171486693032832,
124 10595114339597558777, 2904607092377533576,
125 ];
126 for &e in &expected {
127 assert_eq!(rng.next_u64(), e);
128 }
129 }
130}
131