You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
96 lines
2.6 KiB
Plaintext
96 lines
2.6 KiB
Plaintext
foreign class Random {
|
|
construct new() {
|
|
seed_()
|
|
}
|
|
|
|
construct new(seed) {
|
|
if (seed is Num) {
|
|
seed_(seed)
|
|
} else if (seed is Sequence) {
|
|
if (seed.isEmpty) Fiber.abort("Sequence cannot be empty.")
|
|
|
|
// TODO: Empty sequence.
|
|
var seeds = []
|
|
for (element in seed) {
|
|
if (!(element is Num)) Fiber.abort("Sequence elements must all be numbers.")
|
|
|
|
seeds.add(element)
|
|
if (seeds.count == 16) break
|
|
}
|
|
|
|
// Cycle the values to fill in any missing slots.
|
|
var i = 0
|
|
while (seeds.count < 16) {
|
|
seeds.add(seeds[i])
|
|
i = i + 1
|
|
}
|
|
|
|
seed_(
|
|
seeds[0], seeds[1], seeds[2], seeds[3],
|
|
seeds[4], seeds[5], seeds[6], seeds[7],
|
|
seeds[8], seeds[9], seeds[10], seeds[11],
|
|
seeds[12], seeds[13], seeds[14], seeds[15])
|
|
} else {
|
|
Fiber.abort("Seed must be a number or a sequence of numbers.")
|
|
}
|
|
}
|
|
|
|
foreign seed_()
|
|
foreign seed_(seed)
|
|
foreign seed_(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13, n14, n15, n16)
|
|
|
|
foreign float()
|
|
float(end) { float() * end }
|
|
float(start, end) { float() * (end - start) + start }
|
|
|
|
foreign int()
|
|
int(end) { (float() * end).floor }
|
|
int(start, end) { (float() * (end - start)).floor + start }
|
|
|
|
sample(list) {
|
|
if (list.count == 0) Fiber.abort("Not enough elements to sample.")
|
|
return list[int(list.count)]
|
|
}
|
|
sample(list, count) {
|
|
if (count > list.count) Fiber.abort("Not enough elements to sample.")
|
|
|
|
var result = []
|
|
|
|
// The algorithm described in "Programming pearls: a sample of brilliance".
|
|
// Use a hash map for sample sizes less than 1/4 of the population size and
|
|
// an array of booleans for larger samples. This simple heuristic improves
|
|
// performance for large sample sizes as well as reduces memory usage.
|
|
if (count * 4 < list.count) {
|
|
var picked = {}
|
|
for (i in list.count - count...list.count) {
|
|
var index = int(i + 1)
|
|
if (picked.containsKey(index)) index = i
|
|
picked[index] = true
|
|
result.add(list[index])
|
|
}
|
|
} else {
|
|
var picked = List.filled(list.count, false)
|
|
for (i in list.count - count...list.count) {
|
|
var index = int(i + 1)
|
|
if (picked[index]) index = i
|
|
picked[index] = true
|
|
result.add(list[index])
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
shuffle(list) {
|
|
if (list.isEmpty) return
|
|
|
|
// Fisher-Yates shuffle.
|
|
for (i in 0...list.count - 1) {
|
|
var from = int(i, list.count)
|
|
var temp = list[from]
|
|
list[from] = list[i]
|
|
list[i] = temp
|
|
}
|
|
}
|
|
}
|