random-seed.js

/*
 * random-seed
 * https://github.com/skratchdot/random-seed
 *
 * This code was originally written by Steve Gibson and can be found here:
 *
 * https://www.grc.com/otg/uheprng.htm
 *
 * It was slightly modified for use in node, to pass jshint, and a few additional
 * helper functions were added.
 *
 * Copyright (c) 2013 skratchdot
 * Dual Licensed under the MIT license and the original GRC copyright/license
 * included below.
 */
/*  ============================================================================
                                    Gibson Research Corporation
                UHEPRNG - Ultra High Entropy Pseudo-Random Number Generator
    ============================================================================
    LICENSE AND COPYRIGHT:  THIS CODE IS HEREBY RELEASED INTO THE PUBLIC DOMAIN
    Gibson Research Corporation releases and disclaims ALL RIGHTS AND TITLE IN
    THIS CODE OR ANY DERIVATIVES. Anyone may be freely use it for any purpose.
    ============================================================================
    This is GRC's cryptographically strong PRNG (pseudo-random number generator)
    for JavaScript. It is driven by 1536 bits of entropy, stored in an array of
    48, 32-bit JavaScript variables.  Since many applications of this generator,
    including ours with the "Off The Grid" Latin Square generator, may require
    the deteriministic re-generation of a sequence of PRNs, this PRNG's initial
    entropic state can be read and written as a static whole, and incrementally
    evolved by pouring new source entropy into the generator's internal state.
    ----------------------------------------------------------------------------
    ENDLESS THANKS are due Johannes Baagoe for his careful development of highly
    robust JavaScript implementations of JS PRNGs.  This work was based upon his
    JavaScript "Alea" PRNG which is based upon the extremely robust Multiply-
    With-Carry (MWC) PRNG invented by George Marsaglia. MWC Algorithm References:
    http://www.GRC.com/otg/Marsaglia_PRNGs.pdf
    http://www.GRC.com/otg/Marsaglia_MWC_Generators.pdf
    ----------------------------------------------------------------------------
    The quality of this algorithm's pseudo-random numbers have been verified by
    multiple independent researchers. It handily passes the fermilab.ch tests as
    well as the "diehard" and "dieharder" test suites.  For individuals wishing
    to further verify the quality of this algorithm's pseudo-random numbers, a
    256-megabyte file of this algorithm's output may be downloaded from GRC.com,
    and a Microsoft Windows scripting host (WSH) version of this algorithm may be
    downloaded and run from the Windows command prompt to generate unique files
    of any size:
    The Fermilab "ENT" tests: http://fourmilab.ch/random/
    The 256-megabyte sample PRN file at GRC: https://www.GRC.com/otg/uheprng.bin
    The Windows scripting host version: https://www.GRC.com/otg/wsh-uheprng.js
    ----------------------------------------------------------------------------
    Qualifying MWC multipliers are: 187884, 686118, 898134, 1104375, 1250205,
    1460910 and 1768863. (We use the largest one that's < 2^21)
    ============================================================================ */


/*  ============================================================================
This is based upon Johannes Baagoe's carefully designed and efficient hash
function for use with JavaScript.  It has a proven "avalanche" effect such
that every bit of the input affects every bit of the output 50% of the time,
which is good.  See: http://baagoe.com/en/RandomMusings/hash/avalanche.xhtml
============================================================================
*/
var Mash = function () {
    var n = 0xefc8249d;
    var mash = function (data) {
        if (data) {
            data = data.toString();
            for (var i = 0; i < data.length; i++) {
                n += data.charCodeAt(i);
                var h = 0.02519603282416938 * n;
                n = h >>> 0;
                h -= n;
                h *= n;
                n = h >>> 0;
                h -= n;
                n += h * 0x100000000; // 2^32
            }
            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
        } else {
            n = 0xefc8249d;
        }
    };
    return mash;
};

var uheprng = function (seed) {
    return (function () {
        var o = 48; // set the 'order' number of ENTROPY-holding 32-bit values
        var c = 1; // init the 'carry' used by the multiply-with-carry (MWC) algorithm
        var p = o; // init the 'phase' (max-1) of the intermediate variable pointer
        var s = new Array(o); // declare our intermediate variables array
        var i; // general purpose local
        var j; // general purpose local
        var k = 0; // general purpose local

        var mash = new Mash(); // get a pointer to our high-performance "Mash" hash

        for (i = 0; i < o; i++) {
            s[i] = mash(Math.random());
        }

        var rawprng = function () {
            if (++p >= o) {
                p = 0;
            }
            var t = 1768863 * s[p] + c * 2.3283064365386963e-10; // 2^-32
            return s[p] = t - (c = t | 0);
        };

        var random = function (range) {
            return Math.floor(range * (rawprng() + (rawprng() * 0x200000 | 0) * 1.1102230246251565e-16)); // 2^-53
        };

        random.string = function (count) {
            var i;
            var s = '';
            for (i = 0; i < count; i++) {
                s += String.fromCharCode(33 + random(94));
            }
            return s;
        };

        var hash = function () {
            var args = Array.prototype.slice.call(arguments);
            for (i = 0; i < args.length; i++) {
                for (j = 0; j < o; j++) {
                    s[j] -= mash(args[i]);
                    if (s[j] < 0) {
                        s[j] += 1;
                    }
                }
            }
        };

        random.cleanString = function (inStr) {
            inStr = inStr.replace(/(^\s*)|(\s*$)/gi, ''); // remove any/all leading spaces
            inStr = inStr.replace(/[\x00-\x1F]/gi, ''); // remove any/all control characters
            inStr = inStr.replace(/\n /, '\n'); // remove any/all trailing spaces
            return inStr; // return the cleaned up result
        };

        random.hashString = function (inStr) {
            inStr = random.cleanString(inStr);
            mash(inStr); // use the string to evolve the 'mash' state
            for (i = 0; i < inStr.length; i++) { // scan through the characters in our string
                k = inStr.charCodeAt(i); // get the character code at the location
                for (j = 0; j < o; j++) { //    "mash" it into the UHEPRNG state
                    s[j] -= mash(k);
                    if (s[j] < 0) {
                        s[j] += 1;
                    }
                }
            }
        };

        random.seed = function (seed) {
            if (typeof seed === 'undefined' || seed === null) {
                seed = Math.random();
            }
            if (typeof seed !== 'string') {
                seed = stringify(seed, function (key, value) {
                    if (typeof value === 'function') {
                        return (value).toString();
                    }
                    return value;
                });
            }
            random.initState();
            random.hashString(seed);
        };

        random.addEntropy = function ( /* accept zero or more arguments */ ) {
            var args = [];
            for (i = 0; i < arguments.length; i++) {
                args.push(arguments[i]);
            }
            hash((k++) + (new Date().getTime()) + args.join('') + Math.random());
        };

        random.initState = function () {
            mash(); // pass a null arg to force mash hash to init
            for (i = 0; i < o; i++) {
                s[i] = mash(' '); // fill the array with initial mash hash values
            }
            c = 1; // init our multiply-with-carry carry
            p = o; // init our phase
        };

        random.done = function () {
            mash = null;
        };

        if (typeof seed !== 'undefined') {
            random.seed(seed);
        }

        random.range = function (range) {
            return random(range);
        };

        random.random = function () {
            return random(Number.MAX_VALUE - 1) / Number.MAX_VALUE;
        };

        random.floatBetween = function (min, max) {
            return random.random() * (max - min) + min;
        };

        random.intBetween = function (min, max) {
            return Math.floor(random.random() * (max - min + 1)) + min;
        };

        return random;
    }());
};

function stringify(obj, replacer, spaces, cycleReplacer) {
    return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)
}

function serializer(replacer, cycleReplacer) {
    var stack = [], keys = []

    if (cycleReplacer == null) cycleReplacer = function(key, value) {
        if (stack[0] === value) return "[Circular ~]"
        return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]"
    }

    return function(key, value) {
        if (stack.length > 0) {
            var thisPos = stack.indexOf(this)
            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
            if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)
        }
        else stack.push(value)

        return replacer == null ? value : replacer.call(this, key, value)
    }
}

const seededRandomNumberGenerator = function (seed) {

    return new uheprng(seed);
};

export {
    seededRandomNumberGenerator,
};