///|
/// MT19937 with the same scalar/array seeding and 53-bit output as Faker JS.
pub struct Randomizer {
state : FixedArray[UInt32]
mut index : Int32
precision32 : Bool
}
///|
pub fn Randomizer::Randomizer(
seed~ : UInt32 = 5489,
precision32~ : Bool = false,
) -> Randomizer {
let self = { state: FixedArray::make(624, 0), index: 624, precision32, }
self.seed(seed)
self
}
///|
pub fn Randomizer::seed(self : Randomizer, seed : UInt32) -> Unit {
self.state[0] = seed
for i in 1..<624 {
let prev = self.state[i - 1]
self.state[i] = 1812433253U * (prev ^ (prev >> 30)) +
i.reinterpret_as_uint()
}
self.index = 624
}
///|
/// Seed with a nonempty sequence of 32-bit words.
/// Panics if the seed array is empty.
pub fn Randomizer::seed_array(
self : Randomizer,
seeds : ArrayView[UInt32],
) -> Unit {
guard !seeds.is_empty() else { abort("seed array must not be empty") }
self.seed(19650218)
let mut i = 1
let mut j = 0
for _ in 0..> 30)) * 1664525U)) +
seeds[j] +
j.reinterpret_as_uint()
i += 1
j += 1
if i >= 624 {
self.state[0] = self.state[623]
i = 1
}
if j >= seeds.length() {
j = 0
}
}
for _ in 0..<623 {
let prev = self.state[i - 1]
self.state[i] = (self.state[i] ^ ((prev ^ (prev >> 30)) * 1566083941U)) -
i.reinterpret_as_uint()
i += 1
if i >= 624 {
self.state[0] = self.state[623]
i = 1
}
}
self.state[0] = 0x80000000
}
///|
fn Randomizer::twist(self : Randomizer) -> Unit {
for i in 0..<624 {
let y = (self.state[i] & 0x80000000U) |
(self.state[(i + 1) % 624] & 0x7fffffffU)
self.state[i] = self.state[(i + 397) % 624] ^
(y >> 1) ^
(if (y & 1U) == 0 { 0U } else { 0x9908b0dfU })
}
self.index = 0
}
///|
pub fn Randomizer::next_u32(self : Randomizer) -> UInt32 {
if self.index == 624 {
self.twist()
}
let mut y = self.state[self.index]
self.index += 1
y = y ^ (y >> 11)
y = y ^ ((y << 7) & 0x9d2c5680U)
y = y ^ ((y << 15) & 0xefc60000U)
y ^ (y >> 18)
}
///|
/// A uniformly distributed value in [0, 1), using 32 random bits.
pub fn Randomizer::next_f32(self : Randomizer) -> Double {
self.next_u32().to_double() / 4294967296.0
}
///|
/// A uniformly distributed value in [0, 1), using 53 random bits.
pub fn Randomizer::next(self : Randomizer) -> Double {
if self.precision32 {
return self.next_f32()
}
let high = self.next_u32() >> 5
let low = self.next_u32() >> 6
(high.to_double() * 67108864.0 + low.to_double()) / 9007199254740992.0
}