init

README.md

@@ -0,0 +1 @@
+##predictable_random

predictable_random.js

@@ -0,0 +1,251 @@
+module.exports = function nailfactory(boot) {
+    var BOOT = boot || 0xbadebabe;
+
+
+    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)
+        }
+    }
+
+
+
+    var Mash = function() {
+        //	var n = 0xefc8249d;
+        var n = BOOT;
+
+        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 = BOOT;
+            }
+        };
+        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
+
+            // when our "uheprng" is initially invoked our PRNG state is initialized from the
+            // browser's own local PRNG. This is okay since although its generator might not
+            // be wonderful, it's useful for establishing large startup entropy for our usage.
+            var mash = new Mash(); // get a pointer to our high-performance "Mash" hash
+
+            // fill the array with initial mash hash values
+            for (i = 0; i < o; i++) {
+                s[i] = mash(Math.random());
+            }
+
+            // this PRIVATE (internal access only) function is the heart of the multiply-with-carry
+            // (MWC) PRNG algorithm. When called it returns a pseudo-random number in the form of a
+            // 32-bit JavaScript fraction (0.0 to <1.0) it is a PRIVATE function used by the default
+            // [0-1] return function, and by the random 'string(n)' function which returns 'n'
+            // characters from 33 to 126.
+            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);
+            };
+
+            // this EXPORTED function is the default function returned by this library.
+            // The values returned are integers in the range from 0 to range-1. We first
+            // obtain two 32-bit fractions (from rawprng) to synthesize a single high
+            // resolution 53-bit prng (0 to <1), then we multiply this by the caller's
+            // "range" param and take the "floor" to return a equally probable integer.
+            var random = function(range) {
+                return Math.floor(range * (rawprng() + (rawprng() * 0x200000 | 0) * 1.1102230246251565e-16)); // 2^-53
+            };
+
+            // this EXPORTED function 'string(n)' returns a pseudo-random string of
+            // 'n' printable characters ranging from chr(33) to chr(126) inclusive.
+            random.string = function(count) {
+                var i;
+                var s = '';
+                for (i = 0; i < count; i++) {
+                    s += String.fromCharCode(33 + random(94));
+                }
+                return s;
+            };
+
+            // this PRIVATE "hash" function is used to evolve the generator's internal
+            // entropy state. It is also called by the EXPORTED addEntropy() function
+            // which is used to pour entropy into the PRNG.
+            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;
+                        }
+                    }
+                }
+            };
+
+            // this EXPORTED "clean string" function removes leading and trailing spaces and non-printing
+            // control characters, including any embedded carriage-return (CR) and line-feed (LF) characters,
+            // from any string it is handed. this is also used by the 'hashstring' function (below) to help
+            // users always obtain the same EFFECTIVE uheprng seeding key.
+            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
+            };
+
+            // this EXPORTED "hash string" function hashes the provided character string after first removing
+            // any leading or trailing spaces and ignoring any embedded carriage returns (CR) or Line Feeds (LF)
+            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;
+                        }
+                    }
+                }
+            };
+
+            // this EXPORTED function allows you to seed the random generator.
+            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);
+            };
+
+            // this handy exported function is used to add entropy to our uheprng at any time
+            random.addEntropy = function( /* accept zero or more arguments */ ) {
+                var args = [];
+                for (i = 0; i < arguments.length; i++) {
+                    args.push(arguments[i]);
+                }
+                hash(args.join(''));
+            };
+
+            // if we want to provide a deterministic startup context for our PRNG,
+            // but without directly setting the internal state variables, this allows
+            // us to initialize the mash hash and PRNG's internal state before providing
+            // some hashing input
+            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
+            };
+
+            // we use this (optional) exported function to signal the JavaScript interpreter
+            // that we're finished using the "Mash" hash function so that it can free up the
+            // local "instance variables" is will have been maintaining.  It's not strictly
+            // necessary, of course, but it's good JavaScript citizenship.
+            random.done = function() {
+                mash = null;
+            };
+
+            // if we called "uheprng" with a seed value, then execute random.seed() before returning
+            if (typeof seed !== 'undefined') {
+                random.seed(seed);
+            }
+
+            // Returns a random integer between 0 (inclusive) and range (exclusive)
+            random.range = function(range) {
+                return random(range);
+            };
+
+            // Returns a random float between 0 (inclusive) and 1 (exclusive)
+            random.random = function() {
+                return random(Number.MAX_VALUE - 1) / Number.MAX_VALUE;
+            };
+
+            // Returns a random float between min (inclusive) and max (exclusive)
+            random.floatBetween = function(min, max) {
+                return random.random() * (max - min) + min;
+            };
+
+            // Returns a random integer between min (inclusive) and max (inclusive)
+            random.intBetween = function(min, max) {
+                return Math.floor(random.random() * (max - min + 1)) + min;
+            };
+
+            // when our main outer "uheprng" function is called, after setting up our
+            // initial variables and entropic state, we return an "instance pointer"
+            // to the internal anonymous function which can then be used to access
+            // the uheprng's various exported functions.  As with the ".done" function
+            // above, we should set the returned value to 'null' once we're finished
+            // using any of these functions.
+            return random;
+        }());
+    };
+
+    // Modification for use in node:
+    uheprng.create = function(seed) {
+        return new uheprng(seed);
+    };
+
+
+    return uheprng;
+}