octo-deno/lib/random/random.js

266 lines
5.8 KiB
JavaScript
Raw Normal View History

2017-04-22 22:49:49 +00:00
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
2018-03-17 22:02:23 +00:00
const MersenneTwister = require('./mersennetwister')
const {logger} = require('../logging')
2018-03-17 22:02:23 +00:00
class random {
2017-04-22 22:49:49 +00:00
/**
* Must be called before any other methods can be called to initialize MersenneTwister
* @param {number|null|undefined} seed - Value to initialize MersenneTwister
2017-04-22 22:49:49 +00:00
*/
static init (seed) {
2017-04-25 15:22:15 +00:00
if (seed === null || seed === undefined) {
2018-04-06 22:15:55 +00:00
random.seed = new Date().getTime()
2017-04-22 22:49:49 +00:00
}
2018-04-06 22:15:55 +00:00
random.twister = new MersenneTwister()
random.twister.seed(random.seed)
}
/**
2018-07-26 23:44:34 +00:00
* Returns an integer in [0, limit) (uniform distribution)
* @param {number} limit
*/
static number (limit) {
2018-04-06 22:15:55 +00:00
if (!random.twister) {
throw new Error('random.init must be called first.')
}
2017-04-25 15:22:15 +00:00
if (limit === null || limit === undefined) {
limit = 0xffffffff
2017-04-22 22:49:49 +00:00
}
let x = (0x100000000 / limit) >>> 0
let y = (x * limit) >>> 0
let r
2017-04-22 22:49:49 +00:00
do {
2018-04-06 22:15:55 +00:00
r = random.twister.int32()
} while (y && r >= y) // eslint-disable-line no-unmodified-loop-condition
return (r / x) >>> 0
}
/**
2018-07-26 23:44:34 +00:00
* Returns a float in [0, 1) (uniform distribution)
*/
static float () {
2018-04-06 22:15:55 +00:00
if (!random.twister) {
throw new Error('random.init must be called first.')
}
2018-04-06 22:15:55 +00:00
return random.twister.real2()
}
/**
2018-07-26 23:44:34 +00:00
* Returns an integer in [start, limit) (uniform distribution)
* @param {number} start
* @param {number} limit
*/
static range (start, limit) {
2018-04-06 22:15:55 +00:00
if (!random.twister) {
throw new Error('random.init must be called first.')
}
2018-07-26 23:44:34 +00:00
2017-04-22 22:49:49 +00:00
if (isNaN(start) || isNaN(limit)) {
2017-04-25 22:28:31 +00:00
logger.traceback()
throw new TypeError(`random.range() received non-number type: (${start}, ${limit})`)
2017-04-22 22:49:49 +00:00
}
2018-07-26 23:44:34 +00:00
2018-04-06 22:15:55 +00:00
return random.number(limit - start + 1) + start
}
/**
2018-07-26 23:44:34 +00:00
* Returns a float in [1, limit). The logarithm has uniform distribution.
* @param {number} limit
*/
static ludOneTo (limit) {
2018-04-06 22:15:55 +00:00
return Math.exp(random.float() * Math.log(limit))
}
/**
* Returns a random index from a list
* @param {Array} list
* @returns list[n]
*/
static item (list) {
if (!Array.isArray(list)) {
2017-04-25 22:28:31 +00:00
logger.traceback()
throw new TypeError(`random.item() received invalid object: (${list})`)
2017-04-22 22:49:49 +00:00
}
2018-04-06 22:15:55 +00:00
return list[random.number(list.length)]
}
/**
* Returns a random key of a provided object
* @param {Object} obj
*/
static key (obj) {
return random.item(Object.keys(obj))
}
/**
* Return a random Boolean value
*/
static bool () {
2018-04-06 22:15:55 +00:00
return random.item([true, false])
}
/**
* Recursively iterate over array until non-array item identified
* If item is a function, evaluate it with no args
* @param {*} obj
* @returns {*}
*/
static pick (obj) {
if (typeof obj === 'function') {
return obj()
} else if (Array.isArray(obj)) {
2018-04-06 22:15:55 +00:00
return random.pick(random.item(obj))
2017-04-22 22:49:49 +00:00
}
return obj
}
/**
* Returns a boolean result based on limit
* @param limit
* @returns {boolean}
*/
static chance (limit = 2) {
2017-04-22 22:49:49 +00:00
if (isNaN(limit)) {
logger.traceback()
throw new TypeError(`random.chance() received non-number type: (${limit})`)
2017-04-22 22:49:49 +00:00
}
2018-04-06 22:15:55 +00:00
return random.number(limit) === 1
}
/**
* Return an item from an array of arrays where the first index in each sub-array denotes the weight
* @param {Array} list - Array of arrays
* @param {Boolean} flat - Indicates whether we should iterate over the arrays recursively
* @returns {*}
*/
static choose (list, flat = false) {
if (!(Array.isArray(list))) {
2017-04-25 22:28:31 +00:00
logger.traceback()
throw new TypeError(`random.choose() received non-array type: (${list})`)
2017-04-22 22:49:49 +00:00
}
let total = 0
2017-04-22 22:49:49 +00:00
for (let i = 0; i < list.length; i++) {
total += list[i][0]
2017-04-22 22:49:49 +00:00
}
2018-04-06 22:15:55 +00:00
let n = random.number(total)
2017-04-22 22:49:49 +00:00
for (let i = 0; i < list.length; i++) {
if (n < list[i][0]) {
2017-04-25 15:22:15 +00:00
if (flat === true) {
return list[i][1]
2017-04-22 22:49:49 +00:00
} else {
2018-04-06 22:15:55 +00:00
return random.pick([list[i][1]])
2017-04-22 22:49:49 +00:00
}
}
n = n - list[i][0]
2017-04-22 22:49:49 +00:00
}
if (flat) {
return list[0][1]
2017-04-22 22:49:49 +00:00
}
2018-04-06 22:15:55 +00:00
return random.pick([list[0][1]])
}
/**
* More memory-hungry but hopefully faster than random.choose$flat.
* @param {*} wa
*/
static weighted (wa) {
let a = []
2017-04-22 22:49:49 +00:00
for (let i = 0; i < wa.length; ++i) {
for (let j = 0; j < wa[i].w; ++j) {
a.push(wa[i].v)
2017-04-22 22:49:49 +00:00
}
}
return a
}
static use (obj) {
2018-04-06 22:15:55 +00:00
return random.bool() ? obj : ''
}
/**
* Returns arr shuffled
* @param arr
*/
static shuffle (arr) {
let i = arr.length
2017-04-22 22:49:49 +00:00
while (i--) {
2018-04-06 22:15:55 +00:00
let p = random.number(i + 1)
let t = arr[i]
arr[i] = arr[p]
arr[p] = t
2017-04-22 22:49:49 +00:00
}
}
/**
* Returns a shuffled copy of arr
* @param arr
* @returns {*}
*/
static shuffled (arr) {
let newArray = arr.slice()
2018-04-06 22:15:55 +00:00
random.shuffle(newArray)
return newArray
}
/**
* Select an array containing a subset of 'list'
* @param list
* @param limit
* @returns {Array}
*/
static subset (list, limit) {
if (!(Array.isArray(list))) {
2017-04-25 22:28:31 +00:00
logger.traceback()
throw new TypeError(`random.subset() received non-array type: (${list})`)
2017-04-22 22:49:49 +00:00
}
2017-04-22 22:49:49 +00:00
if (typeof limit !== 'number') {
2018-04-06 22:15:55 +00:00
limit = random.number(list.length + 1)
2017-04-22 22:49:49 +00:00
}
// Deepclone list
const temp = JSON.parse(JSON.stringify(list))
const result = []
while (limit--) {
result.push(random.pop(temp))
2017-04-22 22:49:49 +00:00
}
return result
}
/**
* Removes and returns a random item from an array.
* @param {*} arr
*/
static pop (arr) {
let i, obj
2017-04-22 22:49:49 +00:00
2018-04-06 22:15:55 +00:00
i = random.number(arr.length)
obj = arr[i]
arr.splice(i, 1)
2017-04-22 22:49:49 +00:00
return obj
}
static hex (len) {
2018-04-06 22:15:55 +00:00
return random.number(Math.pow(2, len * 4)).toString(16)
}
}
2018-03-17 22:02:23 +00:00
module.exports = random