mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

rand: simplify rand.PRNG, move to optional types for error handling (#13570)

Browse Source
This commit is contained in:
Subhomoy Haldar
2022-02-23 16:06:14 +05:30
committed by GitHub
parent 5c0b7b0d05
commit 114a341f5f
49 changed files with 609 additions and 1586 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
vlib/rand/dist/dist.v vendored
View File

@@ -49,8 +49,8 @@ pub fn normal_pair(config NormalConfigStruct) (f64, f64) {
// See: https://doi.org/10.1137%2F1006063
// Also: https://en.wikipedia.org/wiki/Marsaglia_polar_method
for {
u := rand.f64_in_range(-1, 1)
v := rand.f64_in_range(-1, 1)
u := rand.f64_in_range(-1, 1) or { 0.0 }
v := rand.f64_in_range(-1, 1) or { 0.0 }
s := u * u + v * v
if s >= 1 || s == 0 {

193
vlib/rand/mt19937/mt19937.v
View File

@@ -3,8 +3,6 @@
// that can be found in the LICENSE file.
module mt19937
import math.bits
/*
C++ functions for MT19937, with initialization improved 2002/2/10.
Coded by Takuji Nishimura and Makoto Matsumoto.
@@ -133,197 +131,6 @@ pub fn (mut rng MT19937RNG) u64() u64 {
return x
}
// int returns a 32-bit signed (possibly negative) `int`.
[inline]
pub fn (mut rng MT19937RNG) int() int {
return int(rng.u32())
}
// i64 returns a 64-bit signed (possibly negative) `i64`.
[inline]
pub fn (mut rng MT19937RNG) i64() i64 {
return i64(rng.u64())
}
// int31 returns a 31bit positive pseudorandom `int`.
[inline]
pub fn (mut rng MT19937RNG) int31() int {
return int(rng.u32() >> 1)
}
// int63 returns a 63bit positive pseudorandom `i64`.
[inline]
pub fn (mut rng MT19937RNG) int63() i64 {
return i64(rng.u64() >> 1)
}
// u32n returns a 32bit `u32` in range `[0, max)`.
[inline]
pub fn (mut rng MT19937RNG) u32n(max u32) u32 {
if max == 0 {
eprintln('max must be positive integer.')
exit(1)
}
// Check SysRNG in system_rng.c.v for explanation
bit_len := bits.len_32(max)
if bit_len == 32 {
for {
value := rng.u32()
if value < max {
return value
}
}
} else {
mask := (u32(1) << (bit_len + 1)) - 1
for {
value := rng.u32() & mask
if value < max {
return value
}
}
}
return u32(0)
}
// u64n returns a 64bit `u64` in range `[0, max)`.
[inline]
pub fn (mut rng MT19937RNG) u64n(max u64) u64 {
if max == 0 {
eprintln('max must be positive integer.')
exit(1)
}
bit_len := bits.len_64(max)
if bit_len == 64 {
for {
value := rng.u64()
if value < max {
return value
}
}
} else {
mask := (u64(1) << (bit_len + 1)) - 1
for {
value := rng.u64() & mask
if value < max {
return value
}
}
}
return u64(0)
}
// u32n returns a pseudorandom `u32` value that is guaranteed to be in range `[min, max)`.
[inline]
pub fn (mut rng MT19937RNG) u32_in_range(min u32, max u32) u32 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.u32n(max - min)
}
// u64n returns a pseudorandom `u64` value that is guaranteed to be in range `[min, max)`.
[inline]
pub fn (mut rng MT19937RNG) u64_in_range(min u64, max u64) u64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.u64n(max - min)
}
// intn returns a 32bit positive `int` in range `[0, max)`.
[inline]
pub fn (mut rng MT19937RNG) intn(max int) int {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return int(rng.u32n(u32(max)))
}
// i64n returns a 64bit positive `i64` in range `[0, max)`.
[inline]
pub fn (mut rng MT19937RNG) i64n(max i64) i64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return i64(rng.u64n(u64(max)))
}
// int_in_range returns a 32bit positive `int` in range `[min, max)`.
[inline]
pub fn (mut rng MT19937RNG) int_in_range(min int, max int) int {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.intn(max - min)
}
// i64_in_range returns a 64bit positive `i64` in range `[min, max)`.
[inline]
pub fn (mut rng MT19937RNG) i64_in_range(min i64, max i64) i64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.i64n(max - min)
}
// f32 returns a 32bit real (`f32`) in range `[0, 1)`.
[inline]
pub fn (mut rng MT19937RNG) f32() f32 {
return f32(rng.f64())
}
// f64 returns 64bit real (`f64`) in range `[0, 1)`.
[inline]
pub fn (mut rng MT19937RNG) f64() f64 {
return f64(rng.u64() >> 11) * mt19937.inv_f64_limit
}
// f32n returns a 32bit real (`f32`) in range [0, max)`.
[inline]
pub fn (mut rng MT19937RNG) f32n(max f32) f32 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f32() * max
}
// f64n returns a 64bit real (`f64`) in range `[0, max)`.
[inline]
pub fn (mut rng MT19937RNG) f64n(max f64) f64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f64() * max
}
// f32_in_range returns a pseudorandom `f32` that lies in range `[min, max)`.
[inline]
pub fn (mut rng MT19937RNG) f32_in_range(min f32, max f32) f32 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.f32n(max - min)
}
// i64_in_range returns a pseudorandom `i64` that lies in range `[min, max)`.
[inline]
pub fn (mut rng MT19937RNG) f64_in_range(min f64, max f64) f64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.f64n(max - min)
}
// free should be called when the generator is no longer needed
[unsafe]
pub fn (mut rng MT19937RNG) free() {

89
vlib/rand/mt19937/mt19937_test.v
View File

@@ -1,4 +1,5 @@
import math
import rand
import rand.mt19937
import rand.seed
@@ -15,7 +16,7 @@ const (
)
fn mt19937_basic_test() {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed([u32(0xdeadbeef)])
target := [u32(956529277), 3842322136, 3319553134, 1843186657, 2704993644, 595827513, 938518626,
1676224337, 3221315650, 1819026461]
@@ -27,10 +28,11 @@ fn mt19937_basic_test() {
fn gen_randoms(seed_data []u32, bound int) []u64 {
bound_u64 := u64(bound)
mut randoms := []u64{len: (20)}
mut rnd := mt19937.MT19937RNG{}
x := mt19937.MT19937RNG{}
mut rnd := rand.PRNG(x)
rnd.seed(seed_data)
for i in 0 .. 20 {
randoms[i] = rnd.u64n(bound_u64)
randoms[i] = rnd.u64n(bound_u64) or { panic("Couldn't obtain random u64") }
}
return randoms
}
@@ -46,40 +48,29 @@ fn test_mt19937_reproducibility() {
}
}
// TODO: use the `in` syntax and remove this function
// after generics has been completely implemented
fn found(value u64, arr []u64) bool {
for item in arr {
if value == item {
return true
}
}
return false
}
fn test_mt19937_variability() {
// If this test fails and if it is certainly not the implementation
// at fault, try changing the seed values. Repeated values are
// improbable but not impossible.
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
mut values := []u64{cap: value_count}
for i in 0 .. value_count {
value := rng.u64()
assert !found(value, values)
assert value !in values
assert values.len == i
values << value
}
}
}
fn check_uniformity_u64(mut rng mt19937.MT19937RNG, range u64) {
fn check_uniformity_u64(mut rng rand.PRNG, range u64) {
range_f64 := f64(range)
expected_mean := range_f64 / 2.0
mut variance := 0.0
for _ in 0 .. sample_size {
diff := f64(rng.u64n(range)) - expected_mean
diff := f64(rng.u64n(range) or { panic("Couldn't obtain random u64") }) - expected_mean
variance += diff * diff
}
variance /= sample_size - 1
@@ -92,7 +83,7 @@ fn check_uniformity_u64(mut rng mt19937.MT19937RNG, range u64) {
fn test_mt19937_uniformity_u64() {
ranges := [14019545, 80240, 130]
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for range in ranges {
check_uniformity_u64(mut rng, u64(range))
@@ -100,7 +91,7 @@ fn test_mt19937_uniformity_u64() {
}
}
fn check_uniformity_f64(mut rng mt19937.MT19937RNG) {
fn check_uniformity_f64(mut rng rand.PRNG) {
expected_mean := 0.5
mut variance := 0.0
for _ in 0 .. sample_size {
@@ -117,7 +108,7 @@ fn check_uniformity_f64(mut rng mt19937.MT19937RNG) {
fn test_mt19937_uniformity_f64() {
// The f64 version
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
check_uniformity_f64(mut rng)
}
@@ -126,10 +117,10 @@ fn test_mt19937_uniformity_f64() {
fn test_mt19937_u32n() {
max := u32(16384)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32n(max)
value := rng.u32n(max) or { panic("Couldn't obtain random u32") }
assert value >= 0
assert value < max
}
@@ -139,10 +130,10 @@ fn test_mt19937_u32n() {
fn test_mt19937_u64n() {
max := u64(379091181005)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64n(max)
value := rng.u64n(max) or { panic("Couldn't obtain random u64") }
assert value >= 0
assert value < max
}
@@ -153,10 +144,10 @@ fn test_mt19937_u32_in_range() {
max := u32(484468466)
min := u32(316846)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32_in_range(min, max)
value := rng.u32_in_range(min, max) or { panic("Couldn't obtain random u32 in range.") }
assert value >= min
assert value < max
}
@@ -167,10 +158,10 @@ fn test_mt19937_u64_in_range() {
max := u64(216468454685163)
min := u64(6848646868)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64_in_range(min, max)
value := rng.u64_in_range(min, max) or { panic("Couldn't obtain random u64 in range.") }
assert value >= min
assert value < max
}
@@ -181,7 +172,7 @@ fn test_mt19937_int31() {
max_u31 := int(0x7FFFFFFF)
sign_mask := int(0x80000000)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int31()
@@ -197,7 +188,7 @@ fn test_mt19937_int63() {
max_u63 := i64(0x7FFFFFFFFFFFFFFF)
sign_mask := i64(0x8000000000000000)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int63()
@@ -211,10 +202,10 @@ fn test_mt19937_int63() {
fn test_mt19937_intn() {
max := 2525642
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.intn(max)
value := rng.intn(max) or { panic("Couldn't obtain random int") }
assert value >= 0
assert value < max
}
@@ -224,10 +215,10 @@ fn test_mt19937_intn() {
fn test_mt19937_i64n() {
max := i64(3246727724653636)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64n(max)
value := rng.i64n(max) or { panic("Couldn't obtain random i64") }
assert value >= 0
assert value < max
}
@@ -238,10 +229,10 @@ fn test_mt19937_int_in_range() {
min := -4252
max := 1034
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int_in_range(min, max)
value := rng.int_in_range(min, max) or { panic("Couldn't obtain random int in range.") }
assert value >= min
assert value < max
}
@@ -252,10 +243,10 @@ fn test_mt19937_i64_in_range() {
min := i64(-24095)
max := i64(324058)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64_in_range(min, max)
value := rng.i64_in_range(min, max) or { panic("Couldn't obtain random i64 in range.") }
assert value >= min
assert value < max
}
@@ -264,7 +255,7 @@ fn test_mt19937_i64_in_range() {
fn test_mt19937_f32() {
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32()
@@ -276,7 +267,7 @@ fn test_mt19937_f32() {
fn test_mt19937_f64() {
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64()
@@ -289,10 +280,10 @@ fn test_mt19937_f64() {
fn test_mt19937_f32n() {
max := f32(357.0)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32n(max)
value := rng.f32n(max) or { panic("Couldn't obtain random f32") }
assert value >= 0.0
assert value < max
}
@@ -302,10 +293,10 @@ fn test_mt19937_f32n() {
fn test_mt19937_f64n() {
max := 1.52e6
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64n(max)
value := rng.f64n(max) or { panic("Couldn't obtain random f64") }
assert value >= 0.0
assert value < max
}
@@ -316,10 +307,10 @@ fn test_mt19937_f32_in_range() {
min := f32(-24.0)
max := f32(125.0)
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32_in_range(min, max)
value := rng.f32_in_range(min, max) or { panic("Couldn't obtain random f32 in range.") }
assert value >= min
assert value < max
}
@@ -330,10 +321,10 @@ fn test_mt19937_f64_in_range() {
min := -548.7
max := 5015.2
for seed in seeds {
mut rng := mt19937.MT19937RNG{}
mut rng := &rand.PRNG(&mt19937.MT19937RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64_in_range(min, max)
value := rng.f64_in_range(min, max) or { panic("Couldn't obtain random f64 in range.") }
assert value >= min
assert value < max
}

193
vlib/rand/musl/musl_rng.v
View File

@@ -3,9 +3,7 @@
// that can be found in the LICENSE file.
module musl
import math.bits
import rand.seed
import rand.constants
// MuslRNG ported from https://git.musl-libc.org/cgit/musl/tree/src/prng/rand_r.c
pub struct MuslRNG {
@@ -49,197 +47,6 @@ pub fn (mut rng MuslRNG) u64() u64 {
return u64(rng.u32()) | (u64(rng.u32()) << 32)
}
// u32n returns a pseudorandom 32-bit unsigned integer `u32` in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) u32n(max u32) u32 {
if max == 0 {
eprintln('max must be positive integer.')
exit(1)
}
// Check SysRNG in system_rng.c.v for explanation
bit_len := bits.len_32(max)
if bit_len == 32 {
for {
value := rng.u32()
if value < max {
return value
}
}
} else {
mask := (u32(1) << (bit_len + 1)) - 1
for {
value := rng.u32() & mask
if value < max {
return value
}
}
}
return u32(0)
}
// u64n returns a pseudorandom 64-bit unsigned integer (`u64`) in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) u64n(max u64) u64 {
if max == 0 {
eprintln('max must be positive integer.')
exit(1)
}
bit_len := bits.len_64(max)
if bit_len == 64 {
for {
value := rng.u64()
if value < max {
return value
}
}
} else {
mask := (u64(1) << (bit_len + 1)) - 1
for {
value := rng.u64() & mask
if value < max {
return value
}
}
}
return u64(0)
}
// u32_in_range returns a pseudorandom 32-bit unsigned integer (`u32`) in range `[min, max)`.
[inline]
pub fn (mut rng MuslRNG) u32_in_range(min u32, max u32) u32 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.u32n(u32(max - min))
}
// u64_in_range returns a pseudorandom 64-bit unsigned integer (`u64`) in range `[min, max)`.
[inline]
pub fn (mut rng MuslRNG) u64_in_range(min u64, max u64) u64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.u64n(max - min)
}
// int returns a 32-bit signed (possibly negative) integer (`int`).
[inline]
pub fn (mut rng MuslRNG) int() int {
return int(rng.u32())
}
// i64 returns a 64-bit signed (possibly negative) integer (`i64`).
[inline]
pub fn (mut rng MuslRNG) i64() i64 {
return i64(rng.u64())
}
// int31 returns a 31-bit positive pseudorandom integer (`int`).
[inline]
pub fn (mut rng MuslRNG) int31() int {
return int(rng.u32() >> 1)
}
// int63 returns a 63-bit positive pseudorandom integer (`i64`).
[inline]
pub fn (mut rng MuslRNG) int63() i64 {
return i64(rng.u64() >> 1)
}
// intn returns a 32-bit positive int in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) intn(max int) int {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return int(rng.u32n(u32(max)))
}
// i64n returns a 64-bit positive integer `i64` in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) i64n(max i64) i64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return i64(rng.u64n(u64(max)))
}
// int_in_range returns a 32-bit positive integer `int` in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) int_in_range(min int, max int) int {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.intn(max - min)
}
// i64_in_range returns a 64-bit positive integer `i64` in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) i64_in_range(min i64, max i64) i64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.i64n(max - min)
}
// f32 returns a pseudorandom `f32` value in range `[0, 1)`.
[inline]
pub fn (mut rng MuslRNG) f32() f32 {
return f32(rng.u32()) / constants.max_u32_as_f32
}
// f64 returns a pseudorandom `f64` value in range `[0, 1)`.
[inline]
pub fn (mut rng MuslRNG) f64() f64 {
return f64(rng.u64()) / constants.max_u64_as_f64
}
// f32n returns a pseudorandom `f32` value in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) f32n(max f32) f32 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f32() * max
}
// f64n returns a pseudorandom `f64` value in range `[0, max)`.
[inline]
pub fn (mut rng MuslRNG) f64n(max f64) f64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f64() * max
}
// f32_in_range returns a pseudorandom `f32` in range `[min, max)`.
[inline]
pub fn (mut rng MuslRNG) f32_in_range(min f32, max f32) f32 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.f32n(max - min)
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng MuslRNG) f64_in_range(min f64, max f64) f64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.f64n(max - min)
}
// free should be called when the generator is no longer needed
[unsafe]
pub fn (mut rng MuslRNG) free() {

86
vlib/rand/musl/musl_rng_test.v
View File

@@ -1,4 +1,5 @@
import math
import rand
import rand.musl
import rand.seed
@@ -17,10 +18,10 @@ const (
fn gen_randoms(seed_data []u32, bound int) []u64 {
bound_u64 := u64(bound)
mut randoms := []u64{len: (20)}
mut rnd := musl.MuslRNG{}
mut rnd := &rand.PRNG(&musl.MuslRNG{})
rnd.seed(seed_data)
for i in 0 .. 20 {
randoms[i] = rnd.u64n(bound_u64)
randoms[i] = rnd.u64n(bound_u64) or { panic("Couldn't obtain u64") }
}
return randoms
}
@@ -36,40 +37,29 @@ fn test_musl_reproducibility() {
}
}
// TODO: use the `in` syntax and remove this function
// after generics has been completely implemented
fn found(value u64, arr []u64) bool {
for item in arr {
if value == item {
return true
}
}
return false
}
fn test_musl_variability() {
// If this test fails and if it is certainly not the implementation
// at fault, try changing the seed values. Repeated values are
// improbable but not impossible.
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
mut values := []u64{cap: value_count}
for i in 0 .. value_count {
value := rng.u64()
assert !found(value, values)
assert value !in values
assert values.len == i
values << value
}
}
}
fn check_uniformity_u64(mut rng musl.MuslRNG, range u64) {
fn check_uniformity_u64(mut rng rand.PRNG, range u64) {
range_f64 := f64(range)
expected_mean := range_f64 / 2.0
mut variance := 0.0
for _ in 0 .. sample_size {
diff := f64(rng.u64n(range)) - expected_mean
diff := f64(rng.u64n(range) or { panic("Couldn't obtain u64") }) - expected_mean
variance += diff * diff
}
variance /= sample_size - 1
@@ -82,7 +72,7 @@ fn check_uniformity_u64(mut rng musl.MuslRNG, range u64) {
fn test_musl_uniformity_u64() {
ranges := [14019545, 80240, 130]
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for range in ranges {
check_uniformity_u64(mut rng, u64(range))
@@ -90,7 +80,7 @@ fn test_musl_uniformity_u64() {
}
}
fn check_uniformity_f64(mut rng musl.MuslRNG) {
fn check_uniformity_f64(mut rng rand.PRNG) {
expected_mean := 0.5
mut variance := 0.0
for _ in 0 .. sample_size {
@@ -107,7 +97,7 @@ fn check_uniformity_f64(mut rng musl.MuslRNG) {
fn test_musl_uniformity_f64() {
// The f64 version
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
check_uniformity_f64(mut rng)
}
@@ -116,10 +106,10 @@ fn test_musl_uniformity_f64() {
fn test_musl_u32n() {
max := u32(16384)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32n(max)
value := rng.u32n(max) or { panic("Couldn't obtain u32") }
assert value >= 0
assert value < max
}
@@ -129,10 +119,10 @@ fn test_musl_u32n() {
fn test_musl_u64n() {
max := u64(379091181005)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64n(max)
value := rng.u64n(max) or { panic("Couldn't obtain u64") }
assert value >= 0
assert value < max
}
@@ -143,10 +133,10 @@ fn test_musl_u32_in_range() {
max := u32(484468466)
min := u32(316846)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32_in_range(min, max)
value := rng.u32_in_range(min, max) or { panic("Couldn't obtain u32 in range") }
assert value >= min
assert value < max
}
@@ -157,10 +147,10 @@ fn test_musl_u64_in_range() {
max := u64(216468454685163)
min := u64(6848646868)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64_in_range(min, max)
value := rng.u64_in_range(min, max) or { panic("Couldn't obtain u64 in range") }
assert value >= min
assert value < max
}
@@ -171,7 +161,7 @@ fn test_musl_int31() {
max_u31 := int(0x7FFFFFFF)
sign_mask := int(0x80000000)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int31()
@@ -187,7 +177,7 @@ fn test_musl_int63() {
max_u63 := i64(0x7FFFFFFFFFFFFFFF)
sign_mask := i64(0x8000000000000000)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int63()
@@ -201,10 +191,10 @@ fn test_musl_int63() {
fn test_musl_intn() {
max := 2525642
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.intn(max)
value := rng.intn(max) or { panic("Couldn't obtain int") }
assert value >= 0
assert value < max
}
@@ -214,10 +204,10 @@ fn test_musl_intn() {
fn test_musl_i64n() {
max := i64(3246727724653636)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64n(max)
value := rng.i64n(max) or { panic("Couldn't obtain i64") }
assert value >= 0
assert value < max
}
@@ -228,10 +218,10 @@ fn test_musl_int_in_range() {
min := -4252
max := 1034
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int_in_range(min, max)
value := rng.int_in_range(min, max) or { panic("Couldn't obtain int in range") }
assert value >= min
assert value < max
}
@@ -242,10 +232,10 @@ fn test_musl_i64_in_range() {
min := i64(-24095)
max := i64(324058)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64_in_range(min, max)
value := rng.i64_in_range(min, max) or { panic("Couldn't obtain i64 in range") }
assert value >= min
assert value < max
}
@@ -254,7 +244,7 @@ fn test_musl_i64_in_range() {
fn test_musl_f32() {
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32()
@@ -266,7 +256,7 @@ fn test_musl_f32() {
fn test_musl_f64() {
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64()
@@ -279,10 +269,10 @@ fn test_musl_f64() {
fn test_musl_f32n() {
max := f32(357.0)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32n(max)
value := rng.f32n(max) or { panic("Couldn't obtain f32") }
assert value >= 0.0
assert value < max
}
@@ -292,10 +282,10 @@ fn test_musl_f32n() {
fn test_musl_f64n() {
max := 1.52e6
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64n(max)
value := rng.f64n(max) or { panic("Couldn't obtain f64") }
assert value >= 0.0
assert value < max
}
@@ -306,10 +296,10 @@ fn test_musl_f32_in_range() {
min := f32(-24.0)
max := f32(125.0)
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32_in_range(min, max)
value := rng.f32_in_range(min, max) or { panic("Couldn't obtain f32 in range") }
assert value >= min
assert value < max
}
@@ -320,10 +310,10 @@ fn test_musl_f64_in_range() {
min := -548.7
max := 5015.2
for seed in seeds {
mut rng := musl.MuslRNG{}
mut rng := &rand.PRNG(&musl.MuslRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64_in_range(min, max)
value := rng.f64_in_range(min, max) or { panic("Couldn't obtain f64 in range") }
assert value >= min
assert value < max
}

177
vlib/rand/pcg32/pcg32.v
View File

@@ -48,183 +48,6 @@ pub fn (mut rng PCG32RNG) u64() u64 {
return u64(rng.u32()) | (u64(rng.u32()) << 32)
}
// u32n returns a pseudorandom 32-bit unsigned `u32` in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) u32n(max u32) u32 {
if max == 0 {
eprintln('max must be positive')
exit(1)
}
// To avoid bias, we need to make the range of the RNG a multiple of
// max, which we do by dropping output less than a threshold.
threshold := (-max % max)
// Uniformity guarantees that loop below will terminate. In practice, it
// should usually terminate quickly; on average (assuming all max's are
// equally likely), 82.25% of the time, we can expect it to require just
// one iteration. In practice, max's are typically small and only a
// tiny amount of the range is eliminated.
for {
r := rng.u32()
if r >= threshold {
return r % max
}
}
return u32(0)
}
// u64n returns a pseudorandom 64-bit unsigned `u64` in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) u64n(max u64) u64 {
if max == 0 {
eprintln('max must be positive')
exit(1)
}
threshold := (-max % max)
for {
r := rng.u64()
if r >= threshold {
return r % max
}
}
return u64(0)
}
// u32_in_range returns a pseudorandom 32-bit unsigned `u32` in range `[min, max)`.
[inline]
pub fn (mut rng PCG32RNG) u32_in_range(min u32, max u32) u32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.u32n(u32(max - min))
}
// u64_in_range returns a pseudorandom 64-bit unsigned `u64` in range `[min, max)`.
[inline]
pub fn (mut rng PCG32RNG) u64_in_range(min u64, max u64) u64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.u64n(max - min)
}
// int returns a 32-bit signed (possibly negative) `int`.
[inline]
pub fn (mut rng PCG32RNG) int() int {
return int(rng.u32())
}
// i64 returns a 64-bit signed (possibly negative) `i64`.
[inline]
pub fn (mut rng PCG32RNG) i64() i64 {
return i64(rng.u64())
}
// int31 returns a 31-bit positive pseudorandom `int`.
[inline]
pub fn (mut rng PCG32RNG) int31() int {
return int(rng.u32() >> 1)
}
// int63 returns a 63-bit positive pseudorandom `i64`.
[inline]
pub fn (mut rng PCG32RNG) int63() i64 {
return i64(rng.u64() >> 1)
}
// intn returns a 32-bit positive `int` in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) intn(max int) int {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return int(rng.u32n(u32(max)))
}
// i64n returns a 64-bit positive `i64` in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) i64n(max i64) i64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return i64(rng.u64n(u64(max)))
}
// int_in_range returns a 32-bit positive `int` in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) int_in_range(min int, max int) int {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.intn(max - min)
}
// i64_in_range returns a 64-bit positive `i64` in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) i64_in_range(min i64, max i64) i64 {
if max <= min {
eprintln('max must be greater than min.')
exit(1)
}
return min + rng.i64n(max - min)
}
// f32 returns a pseudorandom `f32` value in range `[0, 1)`.
[inline]
pub fn (mut rng PCG32RNG) f32() f32 {
return f32(rng.u32()) / constants.max_u32_as_f32
}
// f64 returns a pseudorandom `f64` value in range `[0, 1)`.
[inline]
pub fn (mut rng PCG32RNG) f64() f64 {
return f64(rng.u64()) / constants.max_u64_as_f64
}
// f32n returns a pseudorandom `f32` value in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) f32n(max f32) f32 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f32() * max
}
// f64n returns a pseudorandom `f64` value in range `[0, max)`.
[inline]
pub fn (mut rng PCG32RNG) f64n(max f64) f64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f64() * max
}
// f32_in_range returns a pseudorandom `f32` in range `[min, max)`.
[inline]
pub fn (mut rng PCG32RNG) f32_in_range(min f32, max f32) f32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.f32n(max - min)
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng PCG32RNG) f64_in_range(min f64, max f64) f64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.f64n(max - min)
}
// free should be called when the generator is no longer needed
[unsafe]
pub fn (mut rng PCG32RNG) free() {

89
vlib/rand/pcg32/pcg32_test.v
View File

@@ -17,10 +17,10 @@ const (
fn gen_randoms(seed_data []u32, bound int) []u32 {
mut randoms := []u32{len: 20}
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed_data)
for i in 0 .. 20 {
randoms[i] = rng.u32n(u32(bound))
randoms[i] = rng.u32n(u32(bound)) or { panic("Couldn't obtain u32") }
}
return randoms
}
@@ -38,40 +38,29 @@ fn test_pcg32_reproducibility() {
}
}
// TODO: use the `in` syntax and remove this function
// after generics has been completely implemented
fn found(value u64, arr []u64) bool {
for item in arr {
if value == item {
return true
}
}
return false
}
fn test_pcg32_variability() {
// If this test fails and if it is certainly not the implementation
// at fault, try changing the seed values. Repeated values are
// improbable but not impossible.
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
mut values := []u64{cap: value_count}
for i in 0 .. value_count {
value := rng.u64()
assert !found(value, values)
assert value !in values
assert values.len == i
values << value
}
}
}
fn check_uniformity_u64(mut rng pcg32.PCG32RNG, range u64) {
fn check_uniformity_u64(mut rng rand.PRNG, range u64) {
range_f64 := f64(range)
expected_mean := range_f64 / 2.0
mut variance := 0.0
for _ in 0 .. sample_size {
diff := f64(rng.u64n(range)) - expected_mean
diff := f64(rng.u64n(range) or { panic("Couldn't obtain u64") }) - expected_mean
variance += diff * diff
}
variance /= sample_size - 1
@@ -84,7 +73,7 @@ fn check_uniformity_u64(mut rng pcg32.PCG32RNG, range u64) {
fn test_pcg32_uniformity_u64() {
ranges := [14019545, 80240, 130]
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for range in ranges {
check_uniformity_u64(mut rng, u64(range))
@@ -92,7 +81,7 @@ fn test_pcg32_uniformity_u64() {
}
}
fn check_uniformity_f64(mut rng pcg32.PCG32RNG) {
fn check_uniformity_f64(mut rng rand.PRNG) {
expected_mean := 0.5
mut variance := 0.0
for _ in 0 .. sample_size {
@@ -109,7 +98,7 @@ fn check_uniformity_f64(mut rng pcg32.PCG32RNG) {
fn test_pcg32_uniformity_f64() {
// The f64 version
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
check_uniformity_f64(mut rng)
}
@@ -118,10 +107,10 @@ fn test_pcg32_uniformity_f64() {
fn test_pcg32_u32n() {
max := u32(16384)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32n(max)
value := rng.u32n(max) or { panic("Couldn't obtain u32") }
assert value >= 0
assert value < max
}
@@ -131,10 +120,10 @@ fn test_pcg32_u32n() {
fn test_pcg32_u64n() {
max := u64(379091181005)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64n(max)
value := rng.u64n(max) or { panic("Couldn't obtain u64") }
assert value >= 0
assert value < max
}
@@ -145,10 +134,12 @@ fn test_pcg32_u32_in_range() {
max := u32(484468466)
min := u32(316846)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32_in_range(u32(min), u32(max))
value := rng.u32_in_range(u32(min), u32(max)) or {
panic("Couldn't obtain u32 in range")
}
assert value >= min
assert value < max
}
@@ -159,10 +150,10 @@ fn test_pcg32_u64_in_range() {
max := u64(216468454685163)
min := u64(6848646868)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64_in_range(min, max)
value := rng.u64_in_range(min, max) or { panic("Couldn't obtain u64 in range") }
assert value >= min
assert value < max
}
@@ -173,7 +164,7 @@ fn test_pcg32_int31() {
max_u31 := int(0x7FFFFFFF)
sign_mask := int(0x80000000)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int31()
@@ -189,7 +180,7 @@ fn test_pcg32_int63() {
max_u63 := i64(0x7FFFFFFFFFFFFFFF)
sign_mask := i64(0x8000000000000000)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int63()
@@ -203,10 +194,10 @@ fn test_pcg32_int63() {
fn test_pcg32_intn() {
max := 2525642
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.intn(max)
value := rng.intn(max) or { panic("Couldn't obtain int") }
assert value >= 0
assert value < max
}
@@ -216,10 +207,10 @@ fn test_pcg32_intn() {
fn test_pcg32_i64n() {
max := i64(3246727724653636)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64n(max)
value := rng.i64n(max) or { panic("Couldn't obtain i64") }
assert value >= 0
assert value < max
}
@@ -230,10 +221,10 @@ fn test_pcg32_int_in_range() {
min := -4252
max := 1034
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int_in_range(min, max)
value := rng.int_in_range(min, max) or { panic("Couldn't obtain int in range") }
assert value >= min
assert value < max
}
@@ -244,10 +235,10 @@ fn test_pcg32_i64_in_range() {
min := i64(-24095)
max := i64(324058)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64_in_range(min, max)
value := rng.i64_in_range(min, max) or { panic("Couldn't obtain i64 in range") }
assert value >= min
assert value < max
}
@@ -256,7 +247,7 @@ fn test_pcg32_i64_in_range() {
fn test_pcg32_f32() {
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32()
@@ -268,7 +259,7 @@ fn test_pcg32_f32() {
fn test_pcg32_f64() {
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64()
@@ -281,10 +272,10 @@ fn test_pcg32_f64() {
fn test_pcg32_f32n() {
max := f32(357.0)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32n(max)
value := rng.f32n(max) or { panic("Couldn't obtain f32") }
assert value >= 0.0
assert value < max
}
@@ -294,10 +285,10 @@ fn test_pcg32_f32n() {
fn test_pcg32_f64n() {
max := 1.52e6
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64n(max)
value := rng.f64n(max) or { panic("Couldn't obtain f64") }
assert value >= 0.0
assert value < max
}
@@ -308,10 +299,10 @@ fn test_pcg32_f32_in_range() {
min := f32(-24.0)
max := f32(125.0)
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32_in_range(min, max)
value := rng.f32_in_range(min, max) or { panic("Couldn't obtain f32 in range") }
assert value >= min
assert value < max
}
@@ -322,10 +313,10 @@ fn test_pcg32_f64_in_range() {
min := -548.7
max := 5015.2
for seed in seeds {
mut rng := pcg32.PCG32RNG{}
mut rng := &rand.PRNG(&pcg32.PCG32RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64_in_range(min, max)
value := rng.f64_in_range(min, max) or { panic("Couldn't obtain f64 in range") }
assert value >= min
assert value < max
}
@@ -333,5 +324,5 @@ fn test_pcg32_f64_in_range() {
}
fn test_change_default_random_generator() {
rand.set_rng(pcg32.PCG32RNG{})
rand.set_rng(&rand.PRNG(&pcg32.PCG32RNG{}))
}

2
vlib/rand/rand.c.v
View File

@@ -110,7 +110,7 @@ pub fn string_from_set(charset string, len int) string {
mut buf := unsafe { malloc_noscan(len + 1) }
for i in 0 .. len {
unsafe {
buf[i] = charset[intn(charset.len)]
buf[i] = charset[intn(charset.len) or { 0 }]
}
}
unsafe {

282
vlib/rand/rand.v
View File

@@ -4,7 +4,9 @@
[has_globals]
module rand
import math.bits
import rand.config
import rand.constants
import rand.wyrand
// PRNG is a common interface for all PRNGs that can be used seamlessly with the rand
@@ -13,29 +15,240 @@ import rand.wyrand
pub interface PRNG {
mut:
seed(seed_data []u32)
// TODO: Support buffering for bytes
// byte() byte
// bytes(bytes_needed int) ?[]byte
// u16() u16
u32() u32
u64() u64
u32n(max u32) u32
u64n(max u64) u64
u32_in_range(min u32, max u32) u32
u64_in_range(min u64, max u64) u64
int() int
i64() i64
int31() int
int63() i64
intn(max int) int
i64n(max i64) i64
int_in_range(min int, max int) int
i64_in_range(min i64, max i64) i64
f32() f32
f64() f64
f32n(max f32) f32
f64n(max f64) f64
f32_in_range(min f32, max f32) f32
f64_in_range(min f64, max f64) f64
free()
}
// byte returns a uniformly distributed pseudorandom 8-bit unsigned positive `byte`.
[inline]
pub fn (mut rng PRNG) byte() byte {
// TODO: Reimplement for all PRNGs efficiently
return byte(rng.u32() & 0xff)
}
// bytes returns a buffer of `bytes_needed` random bytes.
[inline]
pub fn (mut rng PRNG) bytes(bytes_needed int) ?[]byte {
// TODO: Reimplement for all PRNGs efficiently
if bytes_needed < 0 {
return error('can not read < 0 random bytes')
}
mut res := []byte{cap: bytes_needed}
mut remaining := bytes_needed
for remaining > 8 {
mut value := rng.u64()
for _ in 0 .. 8 {
res << byte(value & 0xff)
value >>= 8
}
remaining -= 8
}
for remaining > 4 {
mut value := rng.u32()
for _ in 0 .. 4 {
res << byte(value & 0xff)
value >>= 8
}
remaining -= 4
}
for remaining > 0 {
res << rng.byte()
remaining -= 1
}
return res
}
// u32n returns a uniformly distributed pseudorandom 32-bit signed positive `u32` in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) u32n(max u32) ?u32 {
if max == 0 {
return error('max must be positive integer')
}
// Owing to the pigeon-hole principle, we can't simply do
// val := rng.u32() % max.
// It'll wreck the properties of the distribution unless
// max evenly divides 2^32. So we divide evenly to
// the closest power of two. Then we loop until we find
// an int in the required range
bit_len := bits.len_32(max)
if bit_len == 32 {
for {
value := rng.u32()
if value < max {
return value
}
}
} else {
mask := (u32(1) << (bit_len + 1)) - 1
for {
value := rng.u32() & mask
if value < max {
return value
}
}
}
return u32(0)
}
// u64n returns a uniformly distributed pseudorandom 64-bit signed positive `u64` in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) u64n(max u64) ?u64 {
if max == 0 {
return error('max must be positive integer')
}
bit_len := bits.len_64(max)
if bit_len == 64 {
for {
value := rng.u64()
if value < max {
return value
}
}
} else {
mask := (u64(1) << (bit_len + 1)) - 1
for {
value := rng.u64() & mask
if value < max {
return value
}
}
}
return u64(0)
}
// u32_in_range returns a uniformly distributed pseudorandom 32-bit unsigned `u32` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) u32_in_range(min u32, max u32) ?u32 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.u32n(max - min) ?
}
// u64_in_range returns a uniformly distributed pseudorandom 64-bit unsigned `u64` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) u64_in_range(min u64, max u64) ?u64 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.u64n(max - min) ?
}
// int returns a (possibly negative) pseudorandom 32-bit `int`.
[inline]
pub fn (mut rng PRNG) int() int {
return int(rng.u32())
}
// i64 returns a (possibly negative) pseudorandom 64-bit `i64`.
[inline]
pub fn (mut rng PRNG) i64() i64 {
return i64(rng.u64())
}
// int31 returns a positive pseudorandom 31-bit `int`.
[inline]
pub fn (mut rng PRNG) int31() int {
return int(rng.u32() & constants.u31_mask) // Set the 32nd bit to 0.
}
// int63 returns a positive pseudorandom 63-bit `i64`.
[inline]
pub fn (mut rng PRNG) int63() i64 {
return i64(rng.u64() & constants.u63_mask) // Set the 64th bit to 0.
}
// intn returns a pseudorandom `int` in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) intn(max int) ?int {
if max <= 0 {
return error('max has to be positive.')
}
return int(rng.u32n(u32(max)) ?)
}
// i64n returns a pseudorandom int that lies in `[0, max)`.
[inline]
pub fn (mut rng PRNG) i64n(max i64) ?i64 {
if max <= 0 {
return error('max has to be positive.')
}
return i64(rng.u64n(u64(max)) ?)
}
// int_in_range returns a pseudorandom `int` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) int_in_range(min int, max int) ?int {
if max <= min {
return error('max must be greater than min')
}
// This supports negative ranges like [-10, -5) because the difference is positive
return min + rng.intn(max - min) ?
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) i64_in_range(min i64, max i64) ?i64 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.i64n(max - min) ?
}
// f32 returns a pseudorandom `f32` value in range `[0, 1)`.
[inline]
pub fn (mut rng PRNG) f32() f32 {
return f32(rng.u32()) / constants.max_u32_as_f32
}
// f64 returns a pseudorandom `f64` value in range `[0, 1)`.
[inline]
pub fn (mut rng PRNG) f64() f64 {
return f64(rng.u64()) / constants.max_u64_as_f64
}
// f32n returns a pseudorandom `f32` value in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) f32n(max f32) ?f32 {
if max <= 0 {
return error('max has to be positive.')
}
return rng.f32() * max
}
// f64n returns a pseudorandom `f64` value in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) f64n(max f64) ?f64 {
if max <= 0 {
return error('max has to be positive.')
}
return rng.f64() * max
}
// f32_in_range returns a pseudorandom `f32` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) f32_in_range(min f32, max f32) ?f32 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.f32n(max - min) ?
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) f64_in_range(min f64, max f64) ?f64 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.f64n(max - min) ?
}
__global default_rng &PRNG
// new_default returns a new instance of the default RNG. If the seed is not provided, the current time will be used to seed the instance.
@@ -79,22 +292,22 @@ pub fn u64() u64 {
}
// u32n returns a uniformly distributed pseudorandom 32-bit signed positive `u32` in range `[0, max)`.
pub fn u32n(max u32) u32 {
pub fn u32n(max u32) ?u32 {
return default_rng.u32n(max)
}
// u64n returns a uniformly distributed pseudorandom 64-bit signed positive `u64` in range `[0, max)`.
pub fn u64n(max u64) u64 {
pub fn u64n(max u64) ?u64 {
return default_rng.u64n(max)
}
// u32_in_range returns a uniformly distributed pseudorandom 32-bit unsigned `u32` in range `[min, max)`.
pub fn u32_in_range(min u32, max u32) u32 {
pub fn u32_in_range(min u32, max u32) ?u32 {
return default_rng.u32_in_range(min, max)
}
// u64_in_range returns a uniformly distributed pseudorandom 64-bit unsigned `u64` in range `[min, max)`.
pub fn u64_in_range(min u64, max u64) u64 {
pub fn u64_in_range(min u64, max u64) ?u64 {
return default_rng.u64_in_range(min, max)
}
@@ -104,18 +317,18 @@ pub fn int() int {
}
// intn returns a uniformly distributed pseudorandom 32-bit signed positive `int` in range `[0, max)`.
pub fn intn(max int) int {
pub fn intn(max int) ?int {
return default_rng.intn(max)
}
// byte returns a uniformly distributed pseudorandom 8-bit unsigned positive `byte`.
pub fn byte() byte {
return byte(default_rng.u32() & 0xff)
return default_rng.byte()
}
// int_in_range returns a uniformly distributed pseudorandom 32-bit signed int in range `[min, max)`.
// Both `min` and `max` can be negative, but we must have `min < max`.
pub fn int_in_range(min int, max int) int {
pub fn int_in_range(min int, max int) ?int {
return default_rng.int_in_range(min, max)
}
@@ -130,12 +343,12 @@ pub fn i64() i64 {
}
// i64n returns a uniformly distributed pseudorandom 64-bit signed positive `i64` in range `[0, max)`.
pub fn i64n(max i64) i64 {
pub fn i64n(max i64) ?i64 {
return default_rng.i64n(max)
}
// i64_in_range returns a uniformly distributed pseudorandom 64-bit signed `i64` in range `[min, max)`.
pub fn i64_in_range(min i64, max i64) i64 {
pub fn i64_in_range(min i64, max i64) ?i64 {
return default_rng.i64_in_range(min, max)
}
@@ -155,33 +368,28 @@ pub fn f64() f64 {
}
// f32n returns a uniformly distributed 32-bit floating point in range `[0, max)`.
pub fn f32n(max f32) f32 {
pub fn f32n(max f32) ?f32 {
return default_rng.f32n(max)
}
// f64n returns a uniformly distributed 64-bit floating point in range `[0, max)`.
pub fn f64n(max f64) f64 {
pub fn f64n(max f64) ?f64 {
return default_rng.f64n(max)
}
// f32_in_range returns a uniformly distributed 32-bit floating point in range `[min, max)`.
pub fn f32_in_range(min f32, max f32) f32 {
pub fn f32_in_range(min f32, max f32) ?f32 {
return default_rng.f32_in_range(min, max)
}
// f64_in_range returns a uniformly distributed 64-bit floating point in range `[min, max)`.
pub fn f64_in_range(min f64, max f64) f64 {
pub fn f64_in_range(min f64, max f64) ?f64 {
return default_rng.f64_in_range(min, max)
}
// bytes returns a buffer of `bytes_needed` random bytes
pub fn bytes(bytes_needed int) ?[]byte {
if bytes_needed < 0 {
return error('can not read < 0 random bytes')
}
mut res := []byte{len: bytes_needed}
read(mut res)
return res
return default_rng.bytes(bytes_needed)
}
const (

34
vlib/rand/random_numbers_test.v
View File

@@ -12,7 +12,7 @@ fn get_n_random_ints(seed_data []u32, n int) []int {
mut values := []int{cap: n}
rand.seed(seed_data)
for _ in 0 .. n {
values << rand.intn(n)
values << rand.intn(n) or { panic("Couldn't obtain int") }
}
return values
}
@@ -29,7 +29,7 @@ fn test_rand_reproducibility() {
fn test_rand_u32n() {
max := u32(16384)
for _ in 0 .. rnd_count {
value := rand.u32n(max)
value := rand.u32n(max) or { panic("Couldn't obtain u32") }
assert value >= 0
assert value < max
}
@@ -38,7 +38,7 @@ fn test_rand_u32n() {
fn test_rand_u64n() {
max := u64(379091181005)
for _ in 0 .. rnd_count {
value := rand.u64n(max)
value := rand.u64n(max) or { panic("Couldn't obtain u64") }
assert value >= 0
assert value < max
}
@@ -48,7 +48,7 @@ fn test_rand_u32_in_range() {
max := u32(484468466)
min := u32(316846)
for _ in 0 .. rnd_count {
value := rand.u32_in_range(min, max)
value := rand.u32_in_range(min, max) or { panic("Couldn't obtain u32 in range") }
assert value >= min
assert value < max
}
@@ -58,7 +58,7 @@ fn test_rand_u64_in_range() {
max := u64(216468454685163)
min := u64(6848646868)
for _ in 0 .. rnd_count {
value := rand.u64_in_range(min, max)
value := rand.u64_in_range(min, max) or { panic("Couldn't obtain u64 in range") }
assert value >= min
assert value < max
}
@@ -67,7 +67,7 @@ fn test_rand_u64_in_range() {
fn test_rand_intn() {
max := 2525642
for _ in 0 .. rnd_count {
value := rand.intn(max)
value := rand.intn(max) or { panic("Couldn't obtain int") }
assert value >= 0
assert value < max
}
@@ -76,7 +76,7 @@ fn test_rand_intn() {
fn test_rand_i64n() {
max := i64(3246727724653636)
for _ in 0 .. rnd_count {
value := rand.i64n(max)
value := rand.i64n(max) or { panic("Couldn't obtain i64") }
assert value >= 0
assert value < max
}
@@ -86,7 +86,7 @@ fn test_rand_int_in_range() {
min := -4252
max := 23054962
for _ in 0 .. rnd_count {
value := rand.int_in_range(min, max)
value := rand.int_in_range(min, max) or { panic("Couldn't obtain int in range") }
assert value >= min
assert value < max
}
@@ -96,7 +96,7 @@ fn test_rand_i64_in_range() {
min := i64(-24095)
max := i64(324058)
for _ in 0 .. rnd_count {
value := rand.i64_in_range(min, max)
value := rand.i64_in_range(min, max) or { panic("Couldn't obtain i64 in range") }
assert value >= min
assert value < max
}
@@ -144,7 +144,7 @@ fn test_rand_f64() {
fn test_rand_f32n() {
max := f32(357.0)
for _ in 0 .. rnd_count {
value := rand.f32n(max)
value := rand.f32n(max) or { panic("Couldn't obtain f32") }
assert value >= 0.0
assert value < max
}
@@ -153,7 +153,7 @@ fn test_rand_f32n() {
fn test_rand_f64n() {
max := f64(1.52e6)
for _ in 0 .. rnd_count {
value := rand.f64n(max)
value := rand.f64n(max) or { panic("Couldn't obtain f64") }
assert value >= 0.0
assert value < max
}
@@ -163,7 +163,7 @@ fn test_rand_f32_in_range() {
min := f32(-24.0)
max := f32(125.0)
for _ in 0 .. rnd_count {
value := rand.f32_in_range(min, max)
value := rand.f32_in_range(min, max) or { panic("Couldn't obtain f32 in range") }
assert value >= min
assert value < max
}
@@ -173,7 +173,7 @@ fn test_rand_f64_in_range() {
min := f64(-548.7)
max := f64(5015.2)
for _ in 0 .. rnd_count {
value := rand.f64_in_range(min, max)
value := rand.f64_in_range(min, max) or { panic("Couldn't obtain f64 in range") }
assert value >= min
assert value < max
}
@@ -204,7 +204,7 @@ fn test_rand_string_from_set() {
]
for charset in sets {
for _ in 0 .. string_count {
len := rand.intn(rnd_count)
len := rand.intn(rnd_count) or { panic("Couldn't obtain int") }
str := rand.string_from_set(charset, len)
assert str.len == len
for character in str {
@@ -275,17 +275,17 @@ fn test_rand_ascii() {
fn ensure_same_output(mut rng rand.PRNG) {
for _ in 0 .. 100 {
assert rand.int() == rng.int()
assert rand.intn(45) == rng.intn(45)
assert rand.intn(45) or { 0 } == rng.intn(45) or { 0 }
assert rand.u64() == rng.u64()
assert rand.f64() == rng.f64()
assert rand.u32n(25) == rng.u32n(25)
assert rand.u32n(25) or { 0 } == rng.u32n(25) or { 0 }
}
}
fn test_new_global_rng() {
old := rand.get_current_rng()
// MuslRNG
// MuslRNG
mut rng1a := musl.MuslRNG{}
mut rng1b := musl.MuslRNG{}
seed1 := [u32(1234)]

174
vlib/rand/splitmix64/splitmix64.v
View File

@@ -50,180 +50,6 @@ pub fn (mut rng SplitMix64RNG) u64() u64 {
return z ^ (z >> (31))
}
// u32n returns a pseudorandom `u32` less than `bound`.
[inline]
pub fn (mut rng SplitMix64RNG) u32n(bound u32) u32 {
// This function is kept similar to the u64 version
if bound == 0 {
eprintln('max must be non-zero')
exit(1)
}
threshold := -bound % bound
for {
r := rng.u32()
if r >= threshold {
return r % bound
}
}
return u32(0)
}
// u64n returns a pseudorandom `u64` less than `bound`.
[inline]
pub fn (mut rng SplitMix64RNG) u64n(bound u64) u64 {
// See pcg32.v for explanation of comment. This algorithm
// existed before the refactoring.
if bound == 0 {
eprintln('max must be non-zero')
exit(1)
}
threshold := -bound % bound
for {
r := rng.u64()
if r >= threshold {
return r % bound
}
}
return u64(0)
}
// u32n returns a pseudorandom `u32` value that is guaranteed to be in range `[min, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) u32_in_range(min u32, max u32) u32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.u32n(max - min)
}
// u64n returns a pseudorandom `u64` value that is guaranteed to be in range `[min, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) u64_in_range(min u64, max u64) u64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.u64n(max - min)
}
// int returns a pseudorandom 32-bit (possibly negative) `int`.
[inline]
pub fn (mut rng SplitMix64RNG) int() int {
return int(rng.u32())
}
// i64 returns a pseudorandom 64-bit (possibly negative) `i64`.
[inline]
pub fn (mut rng SplitMix64RNG) i64() i64 {
return i64(rng.u64())
}
// int31 returns a positive pseudorandom 31-bit `int`.
[inline]
pub fn (mut rng SplitMix64RNG) int31() int {
return int(rng.u32() & constants.u31_mask) // Set the 32nd bit to 0.
}
// int63 returns a positive pseudorandom 63-bit `i64`.
[inline]
pub fn (mut rng SplitMix64RNG) int63() i64 {
return i64(rng.u64() & constants.u63_mask) // Set the 64th bit to 0.
}
// intn returns a pseudorandom `int` in range `[0, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) intn(max int) int {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return int(rng.u32n(u32(max)))
}
// i64n returns a pseudorandom `i64` in range `[0, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) i64n(max i64) i64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return i64(rng.u64n(u64(max)))
}
// int_in_range returns a pseudorandom `int` in range `[min, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) int_in_range(min int, max int) int {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
// This supports negative ranges like [-10, -5) because the difference is positive
return min + rng.intn(max - min)
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) i64_in_range(min i64, max i64) i64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.i64n(max - min)
}
// f32 returns a pseudorandom `f32` value in range `[0, 1)`.
[inline]
pub fn (mut rng SplitMix64RNG) f32() f32 {
return f32(rng.u32()) / constants.max_u32_as_f32
}
// f64 returns a pseudorandom `f64` value in range `[0, 1)`.
[inline]
pub fn (mut rng SplitMix64RNG) f64() f64 {
return f64(rng.u64()) / constants.max_u64_as_f64
}
// f32n returns a pseudorandom `f32` value in range `[0, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) f32n(max f32) f32 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f32() * max
}
// f64n returns a pseudorandom `f64` value in range `[0, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) f64n(max f64) f64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f64() * max
}
// f32_in_range returns a pseudorandom `f32` in range `[min, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) f32_in_range(min f32, max f32) f32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.f32n(max - min)
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng SplitMix64RNG) f64_in_range(min f64, max f64) f64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.f64n(max - min)
}
// free should be called when the generator is no longer needed
[unsafe]
pub fn (mut rng SplitMix64RNG) free() {

86
vlib/rand/splitmix64/splitmix64_test.v
View File

@@ -1,4 +1,5 @@
import math
import rand
import rand.splitmix64
import rand.seed
@@ -17,10 +18,10 @@ const (
fn gen_randoms(seed_data []u32, bound int) []u64 {
bound_u64 := u64(bound)
mut randoms := []u64{len: (20)}
mut rnd := splitmix64.SplitMix64RNG{}
mut rnd := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rnd.seed(seed_data)
for i in 0 .. 20 {
randoms[i] = rnd.u64n(bound_u64)
randoms[i] = rnd.u64n(bound_u64) or { panic("Couldn't obtain u64") }
}
return randoms
}
@@ -36,40 +37,29 @@ fn test_splitmix64_reproducibility() {
}
}
// TODO: use the `in` syntax and remove this function
// after generics has been completely implemented
fn found(value u64, arr []u64) bool {
for item in arr {
if value == item {
return true
}
}
return false
}
fn test_splitmix64_variability() {
// If this test fails and if it is certainly not the implementation
// at fault, try changing the seed values. Repeated values are
// improbable but not impossible.
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
mut values := []u64{cap: value_count}
for i in 0 .. value_count {
value := rng.u64()
assert !found(value, values)
assert value !in values
assert values.len == i
values << value
}
}
}
fn check_uniformity_u64(mut rng splitmix64.SplitMix64RNG, range u64) {
fn check_uniformity_u64(mut rng rand.PRNG, range u64) {
range_f64 := f64(range)
expected_mean := range_f64 / 2.0
mut variance := 0.0
for _ in 0 .. sample_size {
diff := f64(rng.u64n(range)) - expected_mean
diff := f64(rng.u64n(range) or { panic("Couldn't obtain u64") }) - expected_mean
variance += diff * diff
}
variance /= sample_size - 1
@@ -82,7 +72,7 @@ fn check_uniformity_u64(mut rng splitmix64.SplitMix64RNG, range u64) {
fn test_splitmix64_uniformity_u64() {
ranges := [14019545, 80240, 130]
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for range in ranges {
check_uniformity_u64(mut rng, u64(range))
@@ -90,7 +80,7 @@ fn test_splitmix64_uniformity_u64() {
}
}
fn check_uniformity_f64(mut rng splitmix64.SplitMix64RNG) {
fn check_uniformity_f64(mut rng rand.PRNG) {
expected_mean := 0.5
mut variance := 0.0
for _ in 0 .. sample_size {
@@ -107,7 +97,7 @@ fn check_uniformity_f64(mut rng splitmix64.SplitMix64RNG) {
fn test_splitmix64_uniformity_f64() {
// The f64 version
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
check_uniformity_f64(mut rng)
}
@@ -116,10 +106,10 @@ fn test_splitmix64_uniformity_f64() {
fn test_splitmix64_u32n() {
max := u32(16384)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32n(max)
value := rng.u32n(max) or { panic("Couldn't obtain u32") }
assert value >= 0
assert value < max
}
@@ -129,10 +119,10 @@ fn test_splitmix64_u32n() {
fn test_splitmix64_u64n() {
max := u64(379091181005)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64n(max)
value := rng.u64n(max) or { panic("Couldn't obtain u64") }
assert value >= 0
assert value < max
}
@@ -143,10 +133,10 @@ fn test_splitmix64_u32_in_range() {
max := u32(484468466)
min := u32(316846)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32_in_range(min, max)
value := rng.u32_in_range(min, max) or { panic("Couldn't obtain u32 in range") }
assert value >= min
assert value < max
}
@@ -157,10 +147,10 @@ fn test_splitmix64_u64_in_range() {
max := u64(216468454685163)
min := u64(6848646868)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64_in_range(min, max)
value := rng.u64_in_range(min, max) or { panic("Couldn't obtain u64 in range") }
assert value >= min
assert value < max
}
@@ -171,7 +161,7 @@ fn test_splitmix64_int31() {
max_u31 := int(0x7FFFFFFF)
sign_mask := int(0x80000000)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int31()
@@ -187,7 +177,7 @@ fn test_splitmix64_int63() {
max_u63 := i64(0x7FFFFFFFFFFFFFFF)
sign_mask := i64(0x8000000000000000)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int63()
@@ -201,10 +191,10 @@ fn test_splitmix64_int63() {
fn test_splitmix64_intn() {
max := 2525642
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.intn(max)
value := rng.intn(max) or { panic("Couldn't obtain int") }
assert value >= 0
assert value < max
}
@@ -214,10 +204,10 @@ fn test_splitmix64_intn() {
fn test_splitmix64_i64n() {
max := i64(3246727724653636)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64n(max)
value := rng.i64n(max) or { panic("Couldn't obtain i64") }
assert value >= 0
assert value < max
}
@@ -228,10 +218,10 @@ fn test_splitmix64_int_in_range() {
min := -4252
max := 230549862
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int_in_range(min, max)
value := rng.int_in_range(min, max) or { panic("Couldn't obtain int in range") }
assert value >= min
assert value < max
}
@@ -242,10 +232,10 @@ fn test_splitmix64_i64_in_range() {
min := i64(-24095)
max := i64(324058)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64_in_range(min, max)
value := rng.i64_in_range(min, max) or { panic("Couldn't obtain i64 in range") }
assert value >= min
assert value < max
}
@@ -254,7 +244,7 @@ fn test_splitmix64_i64_in_range() {
fn test_splitmix64_f32() {
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32()
@@ -266,7 +256,7 @@ fn test_splitmix64_f32() {
fn test_splitmix64_f64() {
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64()
@@ -279,10 +269,10 @@ fn test_splitmix64_f64() {
fn test_splitmix64_f32n() {
max := f32(357.0)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32n(max)
value := rng.f32n(max) or { panic("Couldn't obtain f32") }
assert value >= 0.0
assert value < max
}
@@ -292,10 +282,10 @@ fn test_splitmix64_f32n() {
fn test_splitmix64_f64n() {
max := 1.52e6
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64n(max)
value := rng.f64n(max) or { panic("Couldn't obtain f64") }
assert value >= 0.0
assert value < max
}
@@ -306,10 +296,10 @@ fn test_splitmix64_f32_in_range() {
min := f32(-24.0)
max := f32(125.0)
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32_in_range(min, max)
value := rng.f32_in_range(min, max) or { panic("Couldn't obtain f32 in range") }
assert value >= min
assert value < max
}
@@ -320,10 +310,10 @@ fn test_splitmix64_f64_in_range() {
min := -548.7
max := 5015.2
for seed in seeds {
mut rng := splitmix64.SplitMix64RNG{}
mut rng := &rand.PRNG(&splitmix64.SplitMix64RNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64_in_range(min, max)
value := rng.f64_in_range(min, max) or { panic("Couldn't obtain f64 in range") }
assert value >= min
assert value < max
}

199
vlib/rand/sys/system_rng.c.v
View File

@@ -5,7 +5,6 @@ module sys
import math.bits
import rand.seed
import rand.constants
// Implementation note:
// ====================
@@ -76,204 +75,6 @@ pub fn (r SysRNG) u64() u64 {
return result
}
// r.u32n(max) returns a pseudorandom u32 value that is guaranteed to be less than max
[inline]
pub fn (r SysRNG) u32n(max u32) u32 {
if max == 0 {
eprintln('max must be positive integer')
exit(1)
}
// Owing to the pigeon-hole principle, we can't simply do
// val := rng.u32() % max.
// It'll wreck the properties of the distribution unless
// max evenly divides 2^32. So we divide evenly to
// the closest power of two. Then we loop until we find
// an int in the required range
bit_len := bits.len_32(max)
if bit_len == 32 {
for {
value := r.u32()
if value < max {
return value
}
}
} else {
mask := (u32(1) << (bit_len + 1)) - 1
for {
value := r.u32() & mask
if value < max {
return value
}
}
}
return u32(0)
}
// r.u64n(max) returns a pseudorandom u64 value that is guaranteed to be less than max
[inline]
pub fn (r SysRNG) u64n(max u64) u64 {
if max == 0 {
eprintln('max must be positive integer')
exit(1)
}
// Similar procedure for u64s
bit_len := bits.len_64(max)
if bit_len == 64 {
for {
value := r.u64()
if value < max {
return value
}
}
} else {
mask := (u64(1) << (bit_len + 1)) - 1
for {
value := r.u64() & mask
if value < max {
return value
}
}
}
return u64(0)
}
// r.u32n(min, max) returns a pseudorandom u32 value that is guaranteed to be in [min, max)
[inline]
pub fn (r SysRNG) u32_in_range(min u32, max u32) u32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + r.u32n(max - min)
}
// r.u64n(min, max) returns a pseudorandom u64 value that is guaranteed to be in [min, max)
[inline]
pub fn (r SysRNG) u64_in_range(min u64, max u64) u64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + r.u64n(max - min)
}
// r.int() returns a pseudorandom 32-bit int (which may be negative)
[inline]
pub fn (r SysRNG) int() int {
return int(r.u32())
}
// r.i64() returns a pseudorandom 64-bit i64 (which may be negative)
[inline]
pub fn (r SysRNG) i64() i64 {
return i64(r.u64())
}
// r.int31() returns a pseudorandom 31-bit int which is non-negative
[inline]
pub fn (r SysRNG) int31() int {
return int(r.u32() & constants.u31_mask) // Set the 32nd bit to 0.
}
// r.int63() returns a pseudorandom 63-bit int which is non-negative
[inline]
pub fn (r SysRNG) int63() i64 {
return i64(r.u64() & constants.u63_mask) // Set the 64th bit to 0.
}
// r.intn(max) returns a pseudorandom int that lies in [0, max)
[inline]
pub fn (r SysRNG) intn(max int) int {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return int(r.u32n(u32(max)))
}
// r.i64n(max) returns a pseudorandom i64 that lies in [0, max)
[inline]
pub fn (r SysRNG) i64n(max i64) i64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return i64(r.u64n(u64(max)))
}
// r.int_in_range(min, max) returns a pseudorandom int that lies in [min, max)
[inline]
pub fn (r SysRNG) int_in_range(min int, max int) int {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
// This supports negative ranges like [-10, -5) because the difference is positive
return min + r.intn(max - min)
}
// r.i64_in_range(min, max) returns a pseudorandom i64 that lies in [min, max)
[inline]
pub fn (r SysRNG) i64_in_range(min i64, max i64) i64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + r.i64n(max - min)
}
// r.f32() returns a pseudorandom f32 value between 0.0 (inclusive) and 1.0 (exclusive) i.e [0, 1)
[inline]
pub fn (r SysRNG) f32() f32 {
return f32(r.u32()) / constants.max_u32_as_f32
}
// r.f64() returns a pseudorandom f64 value between 0.0 (inclusive) and 1.0 (exclusive) i.e [0, 1)
[inline]
pub fn (r SysRNG) f64() f64 {
return f64(r.u64()) / constants.max_u64_as_f64
}
// r.f32n() returns a pseudorandom f32 value in [0, max)
[inline]
pub fn (r SysRNG) f32n(max f32) f32 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return r.f32() * max
}
// r.f64n() returns a pseudorandom f64 value in [0, max)
[inline]
pub fn (r SysRNG) f64n(max f64) f64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return r.f64() * max
}
// r.f32_in_range(min, max) returns a pseudorandom f32 that lies in [min, max)
[inline]
pub fn (r SysRNG) f32_in_range(min f32, max f32) f32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + r.f32n(max - min)
}
// r.i64_in_range(min, max) returns a pseudorandom i64 that lies in [min, max)
[inline]
pub fn (r SysRNG) f64_in_range(min f64, max f64) f64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + r.f64n(max - min)
}
// free should be called when the generator is no longer needed
[unsafe]
pub fn (mut rng SysRNG) free() {

96
vlib/rand/sys/system_rng_test.v
View File

@@ -1,4 +1,5 @@
import math
import rand
import rand.sys
const (
@@ -13,7 +14,7 @@ const (
inv_sqrt_12 = 1.0 / math.sqrt(12)
)
fn get_n_randoms(n int, r sys.SysRNG) []int {
fn get_n_randoms(n int, mut r rand.PRNG) []int {
mut ints := []int{cap: n}
for _ in 0 .. n {
ints << r.int()
@@ -28,51 +29,40 @@ fn test_sys_rng_reproducibility() {
// seed for another batch of data.
for seed in seeds {
seed_data := [seed]
mut r1 := sys.SysRNG{}
mut r2 := sys.SysRNG{}
mut r1 := &rand.PRNG(&sys.SysRNG{})
mut r2 := &rand.PRNG(&sys.SysRNG{})
r1.seed(seed_data)
ints1 := get_n_randoms(value_count, r1)
ints1 := get_n_randoms(value_count, mut r1)
r2.seed(seed_data)
ints2 := get_n_randoms(value_count, r2)
ints2 := get_n_randoms(value_count, mut r2)
assert ints1 == ints2
}
}
// TODO: use the `in` syntax and remove this function
// after generics has been completely implemented
fn found(value u64, arr []u64) bool {
for item in arr {
if value == item {
return true
}
}
return false
}
fn test_sys_rng_variability() {
// If this test fails and if it is certainly not the implementation
// at fault, try changing the seed values. Repeated values are
// improbable but not impossible.
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
mut values := []u64{cap: value_count}
for i in 0 .. value_count {
value := rng.u64()
assert !found(value, values)
assert value !in values
assert values.len == i
values << value
}
}
}
fn check_uniformity_u64(rng sys.SysRNG, range u64) {
fn check_uniformity_u64(mut rng rand.PRNG, range u64) {
range_f64 := f64(range)
expected_mean := range_f64 / 2.0
mut variance := 0.0
for _ in 0 .. sample_size {
diff := f64(rng.u64n(range)) - expected_mean
diff := f64(rng.u64n(range) or { panic("Couldn't obtain u64") }) - expected_mean
variance += diff * diff
}
variance /= sample_size - 1
@@ -88,15 +78,15 @@ fn test_sys_rng_uniformity_u64() {
ranges := [14019545, 80240, 130]
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for range in ranges {
check_uniformity_u64(rng, u64(range))
check_uniformity_u64(mut rng, u64(range))
}
}
}
fn check_uniformity_f64(rng sys.SysRNG) {
fn check_uniformity_f64(mut rng rand.PRNG) {
expected_mean := 0.5
mut variance := 0.0
for _ in 0 .. sample_size {
@@ -114,9 +104,9 @@ fn test_sys_rng_uniformity_f64() {
// The f64 version
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
check_uniformity_f64(rng)
check_uniformity_f64(mut rng)
}
}
@@ -124,10 +114,10 @@ fn test_sys_rng_u32n() {
max := u32(16384)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.u32n(max)
value := rng.u32n(max) or { panic("Couldn't obtain u32") }
assert value >= 0
assert value < max
}
@@ -138,10 +128,10 @@ fn test_sys_rng_u64n() {
max := u64(379091181005)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.u64n(max)
value := rng.u64n(max) or { panic("Couldn't obtain u64") }
assert value >= 0
assert value < max
}
@@ -153,10 +143,10 @@ fn test_sys_rng_u32_in_range() {
min := u32(316846)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.u32_in_range(min, max)
value := rng.u32_in_range(min, max) or { panic("Couldn't obtain u32 in range") }
assert value >= min
assert value < max
}
@@ -168,10 +158,10 @@ fn test_sys_rng_u64_in_range() {
min := u64(6848646868)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.u64_in_range(min, max)
value := rng.u64_in_range(min, max) or { panic("Couldn't obtain u64 in range") }
assert value >= min
assert value < max
}
@@ -182,10 +172,10 @@ fn test_sys_rng_intn() {
max := 2525642
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.intn(max)
value := rng.intn(max) or { panic("Couldn't obtain int") }
assert value >= 0
assert value < max
}
@@ -196,10 +186,10 @@ fn test_sys_rng_i64n() {
max := i64(3246727724653636)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.i64n(max)
value := rng.i64n(max) or { panic("Couldn't obtain i64") }
assert value >= 0
assert value < max
}
@@ -211,10 +201,10 @@ fn test_sys_rng_int_in_range() {
max := 23054962
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.int_in_range(min, max)
value := rng.int_in_range(min, max) or { panic("Couldn't obtain int in range") }
assert value >= min
assert value < max
}
@@ -226,10 +216,10 @@ fn test_sys_rng_i64_in_range() {
max := i64(324058)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.i64_in_range(min, max)
value := rng.i64_in_range(min, max) or { panic("Couldn't obtain i64 in range") }
assert value >= min
assert value < max
}
@@ -241,7 +231,7 @@ fn test_sys_rng_int31() {
sign_mask := int(0x80000000)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.int31()
@@ -258,7 +248,7 @@ fn test_sys_rng_int63() {
sign_mask := i64(0x8000000000000000)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.int63()
@@ -272,7 +262,7 @@ fn test_sys_rng_int63() {
fn test_sys_rng_f32() {
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.f32()
@@ -285,7 +275,7 @@ fn test_sys_rng_f32() {
fn test_sys_rng_f64() {
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.f64()
@@ -299,10 +289,10 @@ fn test_sys_rng_f32n() {
max := f32(357.0)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.f32n(max)
value := rng.f32n(max) or { panic("Couldn't obtain f32") }
assert value >= 0.0
assert value < max
}
@@ -313,10 +303,10 @@ fn test_sys_rng_f64n() {
max := 1.52e6
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.f64n(max)
value := rng.f64n(max) or { panic("Couldn't obtain f64") }
assert value >= 0.0
assert value < max
}
@@ -328,10 +318,10 @@ fn test_sys_rng_f32_in_range() {
max := f32(125.0)
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.f32_in_range(min, max)
value := rng.f32_in_range(min, max) or { panic("Couldn't obtain f32 in range") }
assert value >= min
assert value < max
}
@@ -343,10 +333,10 @@ fn test_sys_rng_f64_in_range() {
max := 5015.2
for seed in seeds {
seed_data := [seed]
mut rng := sys.SysRNG{}
mut rng := &rand.PRNG(&sys.SysRNG{})
rng.seed(seed_data)
for _ in 0 .. range_limit {
value := rng.f64_in_range(min, max)
value := rng.f64_in_range(min, max) or { panic("Couldn't obtain f64 in range") }
assert value >= min
assert value < max
}

4
vlib/rand/util/util.v
View File

@@ -30,7 +30,7 @@ pub fn sample_r<T>(array []T, k int) []T {
n := array.len
mut results := []T{len: k}
for i in 0 .. k {
results[i] = array[rand.intn(n)]
results[i] = array[rand.intn(n) or { 0 }]
}
return results
}
@@ -43,7 +43,7 @@ pub fn shuffle<T>(mut a []T, n int) {
}
cnt := if n == 0 { a.len - 1 } else { n }
for i in 0 .. cnt {
x := rand.int_in_range(i, a.len)
x := rand.int_in_range(i, a.len) or { 0 }
// swap
a_i := a[i]
a[i] = a[x]

193
vlib/rand/wyrand/wyrand.v
View File

@@ -3,7 +3,6 @@
// that can be found in the LICENSE file.
module wyrand
import math.bits
import rand.seed
import rand.constants
import hash
@@ -58,195 +57,3 @@ pub fn (mut rng WyRandRNG) u64() u64 {
}
return 0
}
// u32n returns a pseudorandom `u32` less than `max`.
[inline]
pub fn (mut rng WyRandRNG) u32n(max u32) u32 {
if max == 0 {
eprintln('max must be positive integer')
exit(1)
}
// Check SysRNG in system_rng.c.v for explanation
bit_len := bits.len_32(max)
if bit_len == 32 {
for {
value := rng.u32()
if value < max {
return value
}
}
} else {
mask := (u32(1) << (bit_len + 1)) - 1
for {
value := rng.u32() & mask
if value < max {
return value
}
}
}
return u32(0)
}
// u64n returns a pseudorandom `u64` less than `max`.
[inline]
pub fn (mut rng WyRandRNG) u64n(max u64) u64 {
if max == 0 {
eprintln('max must be positive integer')
exit(1)
}
bit_len := bits.len_64(max)
if bit_len == 64 {
for {
value := rng.u64()
if value < max {
return value
}
}
} else {
mask := (u64(1) << (bit_len + 1)) - 1
for {
value := rng.u64() & mask
if value < max {
return value
}
}
}
return u64(0)
}
// u32n returns a pseudorandom `u32` value that is guaranteed to be in range `[min, max)`.
[inline]
pub fn (mut rng WyRandRNG) u32_in_range(min u32, max u32) u32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.u32n(max - min)
}
// u64n returns a pseudorandom `u64` value that is guaranteed to be in range `[min, max)`.
[inline]
pub fn (mut rng WyRandRNG) u64_in_range(min u64, max u64) u64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.u64n(max - min)
}
// int returns a (possibly negative) pseudorandom 32-bit `int`.
[inline]
pub fn (mut rng WyRandRNG) int() int {
return int(rng.u32())
}
// i64 returns a (possibly negative) pseudorandom 64-bit `i64`.
[inline]
pub fn (mut rng WyRandRNG) i64() i64 {
return i64(rng.u64())
}
// int31 returns a positive pseudorandom 31-bit `int`.
[inline]
pub fn (mut rng WyRandRNG) int31() int {
return int(rng.u32() & constants.u31_mask) // Set the 32nd bit to 0.
}
// int63 returns a positive pseudorandom 63-bit `i64`.
[inline]
pub fn (mut rng WyRandRNG) int63() i64 {
return i64(rng.u64() & constants.u63_mask) // Set the 64th bit to 0.
}
// intn returns a pseudorandom `int` in range `[0, max)`.
[inline]
pub fn (mut rng WyRandRNG) intn(max int) int {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return int(rng.u32n(u32(max)))
}
// i64n returns a pseudorandom int that lies in `[0, max)`.
[inline]
pub fn (mut rng WyRandRNG) i64n(max i64) i64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return i64(rng.u64n(u64(max)))
}
// int_in_range returns a pseudorandom `int` in range `[min, max)`.
[inline]
pub fn (mut rng WyRandRNG) int_in_range(min int, max int) int {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
// This supports negative ranges like [-10, -5) because the difference is positive
return min + rng.intn(max - min)
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng WyRandRNG) i64_in_range(min i64, max i64) i64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.i64n(max - min)
}
// f32 returns a pseudorandom `f32` value in range `[0, 1)`.
[inline]
pub fn (mut rng WyRandRNG) f32() f32 {
return f32(rng.u32()) / constants.max_u32_as_f32
}
// f64 returns a pseudorandom `f64` value in range `[0, 1)`.
[inline]
pub fn (mut rng WyRandRNG) f64() f64 {
return f64(rng.u64()) / constants.max_u64_as_f64
}
// f32n returns a pseudorandom `f32` value in range `[0, max)`.
[inline]
pub fn (mut rng WyRandRNG) f32n(max f32) f32 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f32() * max
}
// f64n returns a pseudorandom `f64` value in range `[0, max)`.
[inline]
pub fn (mut rng WyRandRNG) f64n(max f64) f64 {
if max <= 0 {
eprintln('max has to be positive.')
exit(1)
}
return rng.f64() * max
}
// f32_in_range returns a pseudorandom `f32` in range `[min, max)`.
[inline]
pub fn (mut rng WyRandRNG) f32_in_range(min f32, max f32) f32 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.f32n(max - min)
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng WyRandRNG) f64_in_range(min f64, max f64) f64 {
if max <= min {
eprintln('max must be greater than min')
exit(1)
}
return min + rng.f64n(max - min)
}

86
vlib/rand/wyrand/wyrand_test.v
View File

@@ -1,4 +1,5 @@
import math
import rand
import rand.seed
import rand.wyrand
@@ -17,10 +18,10 @@ const (
fn gen_randoms(seed_data []u32, bound int) []u64 {
bound_u64 := u64(bound)
mut randoms := []u64{len: (20)}
mut rnd := wyrand.WyRandRNG{}
mut rnd := &rand.PRNG(&wyrand.WyRandRNG{})
rnd.seed(seed_data)
for i in 0 .. 20 {
randoms[i] = rnd.u64n(bound_u64)
randoms[i] = rnd.u64n(bound_u64) or { panic("Couldn't obtain u64") }
}
return randoms
}
@@ -36,40 +37,29 @@ fn test_wyrand_reproducibility() {
}
}
// TODO: use the `in` syntax and remove this function
// after generics has been completely implemented
fn found(value u64, arr []u64) bool {
for item in arr {
if value == item {
return true
}
}
return false
}
fn test_wyrand_variability() {
// If this test fails and if it is certainly not the implementation
// at fault, try changing the seed values. Repeated values are
// improbable but not impossible.
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
mut values := []u64{cap: value_count}
for i in 0 .. value_count {
value := rng.u64()
assert !found(value, values)
assert value !in values
assert values.len == i
values << value
}
}
}
fn check_uniformity_u64(mut rng wyrand.WyRandRNG, range u64) {
fn check_uniformity_u64(mut rng rand.PRNG, range u64) {
range_f64 := f64(range)
expected_mean := range_f64 / 2.0
mut variance := 0.0
for _ in 0 .. sample_size {
diff := f64(rng.u64n(range)) - expected_mean
diff := f64(rng.u64n(range) or { panic("Couldn't obtain u64") }) - expected_mean
variance += diff * diff
}
variance /= sample_size - 1
@@ -82,7 +72,7 @@ fn check_uniformity_u64(mut rng wyrand.WyRandRNG, range u64) {
fn test_wyrand_uniformity_u64() {
ranges := [14019545, 80240, 130]
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for range in ranges {
check_uniformity_u64(mut rng, u64(range))
@@ -90,7 +80,7 @@ fn test_wyrand_uniformity_u64() {
}
}
fn check_uniformity_f64(mut rng wyrand.WyRandRNG) {
fn check_uniformity_f64(mut rng rand.PRNG) {
expected_mean := 0.5
mut variance := 0.0
for _ in 0 .. sample_size {
@@ -107,7 +97,7 @@ fn check_uniformity_f64(mut rng wyrand.WyRandRNG) {
fn test_wyrand_uniformity_f64() {
// The f64 version
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
check_uniformity_f64(mut rng)
}
@@ -116,10 +106,10 @@ fn test_wyrand_uniformity_f64() {
fn test_wyrand_u32n() {
max := u32(16384)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32n(max)
value := rng.u32n(max) or { panic("Couldn't obtain u32") }
assert value >= 0
assert value < max
}
@@ -129,10 +119,10 @@ fn test_wyrand_u32n() {
fn test_wyrand_u64n() {
max := u64(379091181005)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64n(max)
value := rng.u64n(max) or { panic("Couldn't obtain u64") }
assert value >= 0
assert value < max
}
@@ -143,10 +133,10 @@ fn test_wyrand_u32_in_range() {
max := u32(484468466)
min := u32(316846)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u32_in_range(min, max)
value := rng.u32_in_range(min, max) or { panic("Couldn't obtain u32 in range") }
assert value >= min
assert value < max
}
@@ -157,10 +147,10 @@ fn test_wyrand_u64_in_range() {
max := u64(216468454685163)
min := u64(6848646868)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.u64_in_range(min, max)
value := rng.u64_in_range(min, max) or { panic("Couldn't obtain u64 in range") }
assert value >= min
assert value < max
}
@@ -171,7 +161,7 @@ fn test_wyrand_int31() {
max_u31 := int(0x7FFFFFFF)
sign_mask := int(0x80000000)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int31()
@@ -187,7 +177,7 @@ fn test_wyrand_int63() {
max_u63 := i64(0x7FFFFFFFFFFFFFFF)
sign_mask := i64(0x8000000000000000)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int63()
@@ -201,10 +191,10 @@ fn test_wyrand_int63() {
fn test_wyrand_intn() {
max := 2525642
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.intn(max)
value := rng.intn(max) or { panic("Couldn't obtain int") }
assert value >= 0
assert value < max
}
@@ -214,10 +204,10 @@ fn test_wyrand_intn() {
fn test_wyrand_i64n() {
max := i64(3246727724653636)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64n(max)
value := rng.i64n(max) or { panic("Couldn't obtain i64") }
assert value >= 0
assert value < max
}
@@ -228,10 +218,10 @@ fn test_wyrand_int_in_range() {
min := -4252
max := 1034
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.int_in_range(min, max)
value := rng.int_in_range(min, max) or { panic("Couldn't obtain int in range") }
assert value >= min
assert value < max
}
@@ -242,10 +232,10 @@ fn test_wyrand_i64_in_range() {
min := i64(-24095)
max := i64(324058)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.i64_in_range(min, max)
value := rng.i64_in_range(min, max) or { panic("Couldn't obtain i64 in range") }
assert value >= min
assert value < max
}
@@ -254,7 +244,7 @@ fn test_wyrand_i64_in_range() {
fn test_wyrand_f32() {
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32()
@@ -266,7 +256,7 @@ fn test_wyrand_f32() {
fn test_wyrand_f64() {
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64()
@@ -279,10 +269,10 @@ fn test_wyrand_f64() {
fn test_wyrand_f32n() {
max := f32(357.0)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32n(max)
value := rng.f32n(max) or { panic("Couldn't obtain f32") }
assert value >= 0.0
assert value < max
}
@@ -292,10 +282,10 @@ fn test_wyrand_f32n() {
fn test_wyrand_f64n() {
max := 1.52e6
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64n(max)
value := rng.f64n(max) or { panic("Couldn't obtain f64") }
assert value >= 0.0
assert value < max
}
@@ -306,10 +296,10 @@ fn test_wyrand_f32_in_range() {
min := f32(-24.0)
max := f32(125.0)
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f32_in_range(min, max)
value := rng.f32_in_range(min, max) or { panic("Couldn't obtain f32 in range") }
assert value >= min
assert value < max
}
@@ -320,10 +310,10 @@ fn test_wyrand_f64_in_range() {
min := -548.7
max := 5015.2
for seed in seeds {
mut rng := wyrand.WyRandRNG{}
mut rng := &rand.PRNG(&wyrand.WyRandRNG{})
rng.seed(seed)
for _ in 0 .. range_limit {
value := rng.f64_in_range(min, max)
value := rng.f64_in_range(min, max) or { panic("Couldn't obtain f64 in range") }
assert value >= min
assert value < max
}