1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
use rand_core::impls::fill_bytes_via_next;
use rand_core::le::read_u64_into;
use rand_core::{RngCore, SeedableRng};
/// A xoroshiro128++ random number generator.
///
/// The xoroshiro128++ algorithm is not suitable for cryptographic purposes, but
/// is very fast and has excellent statistical properties.
///
/// The algorithm used here is translated from [the `xoroshiro128plusplus.c`
/// reference source code](http://xoshiro.di.unimi.it/xoroshiro128plusplus.c) by
/// David Blackman and Sebastiano Vigna.
#[allow(missing_copy_implementations)]
#[cfg_attr(not(target_os = "cuda"), derive(Copy, cust_core::DeviceCopy))]
#[derive(Debug, Clone, PartialEq, Eq)]
#[repr(C)]
pub struct Xoroshiro128PlusPlus {
s0: u64,
s1: u64,
}
impl Xoroshiro128PlusPlus {
/// Jump forward, equivalently to 2^64 calls to `next_u64()`.
///
/// This can be used to generate 2^64 non-overlapping subsequences for
/// parallel computations.
///
/// ```
/// use rand_xoshiro::rand_core::SeedableRng;
/// use rand_xoshiro::Xoroshiro128PlusPlus;
///
/// let rng1 = Xoroshiro128PlusPlus::seed_from_u64(0);
/// let mut rng2 = rng1.clone();
/// rng2.jump();
/// let mut rng3 = rng2.clone();
/// rng3.jump();
/// ```
pub fn jump(&mut self) {
impl_jump!(u64, self, [0x2bd7a6a6e99c2ddc, 0x0992ccaf6a6fca05]);
}
/// Jump forward, equivalently to 2^96 calls to `next_u64()`.
///
/// This can be used to generate 2^32 starting points, from each of which
/// `jump()` will generate 2^32 non-overlapping subsequences for parallel
/// distributed computations.
pub fn long_jump(&mut self) {
impl_jump!(u64, self, [0x360fd5f2cf8d5d99, 0x9c6e6877736c46e3]);
}
/// Initializes multiple RNG states such that each state corresponds to a subsequence
/// separated by `2**64` steps from eachother in the main sequence. This ensures that as long as
/// no state requests more than `2**64` random numbers, the states are guaranteed to be fully independent.
#[cfg(not(target_os = "cuda"))]
pub fn initialize_states(seed: u64, num_states: usize) -> Vec<Self> {
impl_initialize_states!(seed, num_states)
}
}
impl RngCore for Xoroshiro128PlusPlus {
#[inline]
fn next_u32(&mut self) -> u32 {
self.next_u64() as u32
}
#[inline]
fn next_u64(&mut self) -> u64 {
let r = plusplus_u64!(self.s0, self.s1, 17);
impl_xoroshiro_u64_plusplus!(self);
r
}
#[inline]
fn fill_bytes(&mut self, dest: &mut [u8]) {
fill_bytes_via_next(self, dest);
}
#[inline]
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> {
self.fill_bytes(dest);
Ok(())
}
}
impl SeedableRng for Xoroshiro128PlusPlus {
type Seed = [u8; 16];
/// Create a new `Xoroshiro128PlusPlus`. If `seed` is entirely 0, it will be
/// mapped to a different seed.
fn from_seed(seed: [u8; 16]) -> Xoroshiro128PlusPlus {
deal_with_zero_seed!(seed, Self);
let mut s = [0; 2];
read_u64_into(&seed, &mut s);
Xoroshiro128PlusPlus { s0: s[0], s1: s[1] }
}
/// Seed a `Xoroshiro128PlusPlus` from a `u64` using `SplitMix64`.
fn seed_from_u64(seed: u64) -> Xoroshiro128PlusPlus {
from_splitmix!(seed)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reference() {
let mut rng =
Xoroshiro128PlusPlus::from_seed([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0]);
// These values were produced with the reference implementation:
// http://xoshiro.di.unimi.it/xoshiro128plusplus.c
let expected = [
393217,
669327710093319,
1732421326133921491,
11394790081659126983,
9555452776773192676,
3586421180005889563,
1691397964866707553,
10735626796753111697,
15216282715349408991,
14247243556711267923,
];
for &e in &expected {
assert_eq!(rng.next_u64(), e);
}
}
}