-Clazz.load(null,"java.util.Random",["java.lang.IllegalArgumentException"],function(){\r
-c$=Clazz.decorateAsClass(function(){\r
-this.haveNextNextGaussian=false;\r
-this.seed=0;\r
-this.nextNextGaussian=0;\r
-Clazz.instantialize(this,arguments);\r
-},java.util,"Random",null,java.io.Serializable);\r
-Clazz.makeConstructor(c$,\r
-function(){\r
-this.setSeed(System.currentTimeMillis());\r
-});\r
-Clazz.makeConstructor(c$,\r
-function(seed){\r
-this.setSeed(seed);\r
-},"~N");\r
-Clazz.defineMethod(c$,"next",\r
-function(bits){\r
-this.seed=(this.seed*25214903917+0xb)&(281474976710655);\r
-return(this.seed>>>(48-bits));\r
-},"~N");\r
-Clazz.defineMethod(c$,"nextBoolean",\r
-function(){\r
-return Math.random()>0.5;\r
-});\r
-Clazz.defineMethod(c$,"nextBytes",\r
-function(buf){\r
-for(var i=0;i<bytes.length;i++){\r
-bytes[i]=Math.round(0x100*Math.random());\r
-}\r
-},"~A");\r
-Clazz.defineMethod(c$,"nextDouble",\r
-function(){\r
-return Math.random();\r
-});\r
-Clazz.defineMethod(c$,"nextFloat",\r
-function(){\r
-return Math.random();\r
-});\r
-Clazz.defineMethod(c$,"nextGaussian",\r
-function(){\r
-if(this.haveNextNextGaussian){\r
-this.haveNextNextGaussian=false;\r
-return this.nextNextGaussian;\r
-}var v1;\r
-var v2;\r
-var s;\r
-do{\r
-v1=2*this.nextDouble()-1;\r
-v2=2*this.nextDouble()-1;\r
-s=v1*v1+v2*v2;\r
-}while(s>=1);\r
-var norm=Math.sqrt(-2*Math.log(s)/s);\r
-this.nextNextGaussian=v2*norm;\r
-this.haveNextNextGaussian=true;\r
-return v1*norm;\r
-});\r
-Clazz.defineMethod(c$,"nextInt",\r
-function(){\r
-return Math.ceil(0xffff*Math.random())-0x8000;\r
-});\r
-Clazz.defineMethod(c$,"nextInt",\r
-function(n){\r
-if(n>0){\r
-n = Math.min(n, 31);\r
-return Math.floor((2 << (n - 1)) * Math.random())\r
-\r
-/*\r
-if((n&-n)==n){\r
-return((n*this.next(31))>>31);\r
-}var bits;\r
-var val;\r
-do{\r
-bits=this.next(31);\r
-val=bits%n;\r
-}while(bits-val+(n-1)<0);\r
-\r
-\r
-return val;\r
-\r
-*/\r
-}\r
-throw new IllegalArgumentException();\r
-},"~N");\r
-Clazz.defineMethod(c$,"nextLong",\r
-function(){\r
-return Math.ceil(0xffffffff*Math.random())-0x80000000;\r
-});\r
-Clazz.defineMethod(c$,"setSeed",\r
-function(seed){\r
-Math.seedrandom(seed);\r
-//this.seed=(seed^25214903917)&(281474976710655);\r
-//this.haveNextNextGaussian=false;\r
-},"~N");\r
-Clazz.defineStatics(c$,\r
-"multiplier",0x5deece66d);\r
-});\r
-\r
-// seedrandom.js\r
-// Author: David Bau 3/11/2010\r
-//\r
-// Defines a method Math.seedrandom() that, when called, substitutes\r
-// an explicitly seeded RC4-based algorithm for Math.random(). Also\r
-// supports automatic seeding from local or network sources of entropy.\r
-//\r
-// Usage:\r
-//\r
-// <script src=http://davidbau.com/encode/seedrandom-min.js></script>\r
-//\r
-// Math.seedrandom('yipee'); Sets Math.random to a function that is\r
-// initialized using the given explicit seed.\r
-//\r
-// Math.seedrandom(); Sets Math.random to a function that is\r
-// seeded using the current time, dom state,\r
-// and other accumulated local entropy.\r
-// The generated seed string is returned.\r
-//\r
-// Math.seedrandom('yowza', true);\r
-// Seeds using the given explicit seed mixed\r
-// together with accumulated entropy.\r
-//\r
-// <script src="http://bit.ly/srandom-512"></script>\r
-// Seeds using physical random bits downloaded\r
-// from random.org.\r
-//\r
-// Examples:\r
-//\r
-// Math.seedrandom("hello"); // Use "hello" as the seed.\r
-// document.write(Math.random()); // Always 0.5463663768140734\r
-// document.write(Math.random()); // Always 0.43973793770592234\r
-// var rng1 = Math.random; // Remember the current prng.\r
-//\r
-// var autoseed = Math.seedrandom(); // New prng with an automatic seed.\r
-// document.write(Math.random()); // Pretty much unpredictable.\r
-//\r
-// Math.random = rng1; // Continue "hello" prng sequence.\r
-// document.write(Math.random()); // Always 0.554769432473455\r
-//\r
-// Math.seedrandom(autoseed); // Restart at the previous seed.\r
-// document.write(Math.random()); // Repeat the 'unpredictable' value.\r
-//\r
-// Notes:\r
-//\r
-// Each time seedrandom('arg') is called, entropy from the passed seed\r
-// is accumulated in a pool to help generate future seeds for the\r
-// zero-argument form of Math.seedrandom, so entropy can be injected over\r
-// time by calling seedrandom with explicit data repeatedly.\r
-//\r
-// On speed - This javascript implementation of Math.random() is about\r
-// 3-10x slower than the built-in Math.random() because it is not native\r
-// code, but this is typically fast enough anyway. Seeding is more expensive,\r
-// especially if you use auto-seeding. Some details (timings on Chrome 4):\r
-//\r
-// Our Math.random() - avg less than 0.002 milliseconds per call\r
-// seedrandom('explicit') - avg less than 0.5 milliseconds per call\r
-// seedrandom('explicit', true) - avg less than 2 milliseconds per call\r
-// seedrandom() - avg about 38 milliseconds per call\r
-//\r
-// LICENSE (BSD):\r
-//\r
-// Copyright 2010 David Bau, all rights reserved.\r
-//\r
-// Redistribution and use in source and binary forms, with or without\r
-// modification, are permitted provided that the following conditions are met:\r
-//\r
-// 1. Redistributions of source code must retain the above copyright\r
-// notice, this list of conditions and the following disclaimer.\r
-//\r
-// 2. Redistributions in binary form must reproduce the above copyright\r
-// notice, this list of conditions and the following disclaimer in the\r
-// documentation and/or other materials provided with the distribution.\r
-//\r
-// 3. Neither the name of this module nor the names of its contributors may\r
-// be used to endorse or promote products derived from this software\r
-// without specific prior written permission.\r
-//\r
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-//\r
-/**\r
- * All code is in an anonymous closure to keep the global namespace clean.\r
- *\r
- * @param {number=} overflow\r
- * @param {number=} startdenom\r
- */\r
-(function (pool, math, width, chunks, significance, overflow, startdenom) {\r
-\r
-var copyright = "Copyright 2010 David Bau, all rights reserved. (BSD)"\r
-//\r
-// seedrandom()\r
-// This is the seedrandom function described above.\r
-//\r
-math['seedrandom'] = function seedrandom(seed, use_entropy) {\r
- var key = [];\r
- var arc4;\r
-\r
- // Flatten the seed string or build one from local entropy if needed.\r
- seed = mixkey(flatten(\r
- use_entropy ? [seed, pool] :\r
- arguments.length ? seed :\r
- [new Date().getTime(), pool, window], 3), key);\r
-\r
- // Use the seed to initialize an ARC4 generator.\r
- arc4 = new ARC4(key);\r
-\r
- // Mix the randomness into accumulated entropy.\r
- mixkey(arc4.S, pool);\r
-\r
- // Override Math.random\r
-\r
- // This function returns a random double in [0, 1) that contains\r
- // randomness in every bit of the mantissa of the IEEE 754 value.\r
-\r
- math['random'] = function random() { // Closure to return a random double:\r
- var n = arc4.g(chunks); // Start with a numerator n < 2 ^ 48\r
- var d = startdenom; // and denominator d = 2 ^ 48.\r
- var x = 0; // and no 'extra last byte'.\r
- while (n < significance) { // Fill up all significant digits by\r
- n = (n + x) * width; // shifting numerator and\r
- d *= width; // denominator and generating a\r
- x = arc4.g(1); // new least-significant-byte.\r
- }\r
- while (n >= overflow) { // To avoid rounding up, before adding\r
- n /= 2; // last byte, shift everything\r
- d /= 2; // right using integer math until\r
- x >>>= 1; // we have exactly the desired bits.\r
- }\r
- return (n + x) / d; // Form the number within [0, 1).\r
- };\r
-\r
- // Return the seed that was used\r
- return seed;\r
-};\r
-\r
-//\r
-// ARC4\r
-//\r
-// An ARC4 implementation. The constructor takes a key in the form of\r
-// an array of at most (width) integers that should be 0 <= x < (width).\r
-//\r
-// The g(count) method returns a pseudorandom integer that concatenates\r
-// the next (count) outputs from ARC4. Its return value is a number x\r
-// that is in the range 0 <= x < (width ^ count).\r
-//\r
-/** @constructor */\r
-function ARC4(key) {\r
- var t, u, me = this, keylen = key.length;\r
- var i = 0, j = me.i = me.j = me.m = 0;\r
- me.S = [];\r
- me.c = [];\r
-\r
- // The empty key [] is treated as [0].\r
- if (!keylen) { key = [keylen++]; }\r
-\r
- // Set up S using the standard key scheduling algorithm.\r
- while (i < width) { me.S[i] = i++; }\r
- for (i = 0; i < width; i++) {\r
- t = me.S[i];\r
- j = lowbits(j + t + key[i % keylen]);\r
- u = me.S[j];\r
- me.S[i] = u;\r
- me.S[j] = t;\r
- }\r
-\r
- // The "g" method returns the next (count) outputs as one number.\r
- me.g = function getnext(count) {\r
- var s = me.S;\r
- var i = lowbits(me.i + 1); var t = s[i];\r
- var j = lowbits(me.j + t); var u = s[j];\r
- s[i] = u;\r
- s[j] = t;\r
- var r = s[lowbits(t + u)];\r
- while (--count) {\r
- i = lowbits(i + 1); t = s[i];\r
- j = lowbits(j + t); u = s[j];\r
- s[i] = u;\r
- s[j] = t;\r
- r = r * width + s[lowbits(t + u)];\r
- }\r
- me.i = i;\r
- me.j = j;\r
- return r;\r
- };\r
- // For robust unpredictability discard an initial batch of values.\r
- // See http://www.rsa.com/rsalabs/node.asp?id=2009\r
- me.g(width);\r
-}\r
-\r
-//\r
-// flatten()\r
-// Converts an object tree to nested arrays of strings.\r
-//\r
-/** @param {Object=} result\r
- * @param {string=} prop */\r
-function flatten(obj, depth, result, prop) {\r
- result = [];\r
- if (depth && typeof(obj) == 'object') {\r
- for (prop in obj) {\r
- if (prop.indexOf('S') < 5) { // Avoid FF3 bug (local/sessionStorage)\r
- try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}\r
- }\r
- }\r
- }\r
- return result.length ? result : '' + obj;\r
-}\r
-\r
-//\r
-// mixkey()\r
-// Mixes a string seed into a key that is an array of integers, and\r
-// returns a shortened string seed that is equivalent to the result key.\r
-//\r
-/** @param {number=} smear\r
- * @param {number=} j */\r
-function mixkey(seed, key, smear, j) {\r
- seed += ''; // Ensure the seed is a string\r
- smear = 0;\r
- for (j = 0; j < seed.length; j++) {\r
- key[lowbits(j)] =\r
- lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));\r
- }\r
- seed = '';\r
- for (j in key) { seed += String.fromCharCode(key[j]); }\r
- return seed;\r
-}\r
-\r
-//\r
-// lowbits()\r
-// A quick "n mod width" for width a power of 2.\r
-//\r
-function lowbits(n) { return n & (width - 1); }\r
-\r
-//\r
-// The following constants are related to IEEE 754 limits.\r
-//\r
-startdenom = math.pow(width, chunks);\r
-significance = math.pow(2, significance);\r
-overflow = significance * 2;\r
-\r
-//\r
-// When seedrandom.js is loaded, we immediately mix a few bits\r
-// from the built-in RNG into the entropy pool. Because we do\r
-// not want to intefere with determinstic PRNG state later,\r
-// seedrandom will not call math.random on its own again after\r
-// initialization.\r
-//\r
-mixkey(math.random(), pool);\r
-\r
-// End anonymous scope, and pass initial values.\r
-})(\r
- [], // pool: entropy pool starts empty\r
- Math, // math: package containing random, pow, and seedrandom\r
- 256, // width: each RC4 output is 0 <= x < 256\r
- 6, // chunks: at least six RC4 outputs for each double\r
- 52 // significance: there are 52 significant digits in a double\r
-);\r
-\r
+Clazz.load(null,"java.util.Random",["java.lang.IllegalArgumentException"],function(){
+c$=Clazz.decorateAsClass(function(){
+this.haveNextNextGaussian=false;
+this.seed=0;
+this.nextNextGaussian=0;
+Clazz.instantialize(this,arguments);
+},java.util,"Random",null,java.io.Serializable);
+Clazz.makeConstructor(c$,
+function(){
+this.setSeed(System.currentTimeMillis());
+});
+Clazz.makeConstructor(c$,
+function(seed){
+this.setSeed(seed);
+},"~N");
+Clazz.defineMethod(c$,"next",
+function(bits){
+this.seed=(this.seed*25214903917+0xb)&(281474976710655);
+return(this.seed>>>(48-bits));
+},"~N");
+Clazz.defineMethod(c$,"nextBoolean",
+function(){
+return Math.random()>0.5;
+});
+Clazz.defineMethod(c$,"nextBytes",
+function(buf){
+for(var i=0;i<bytes.length;i++){
+bytes[i]=Math.round(0x100*Math.random());
+}
+},"~A");
+Clazz.defineMethod(c$,"nextDouble",
+function(){
+return Math.random();
+});
+Clazz.defineMethod(c$,"nextFloat",
+function(){
+return Math.random();
+});
+Clazz.defineMethod(c$,"nextGaussian",
+function(){
+if(this.haveNextNextGaussian){
+this.haveNextNextGaussian=false;
+return this.nextNextGaussian;
+}var v1;
+var v2;
+var s;
+do{
+v1=2*this.nextDouble()-1;
+v2=2*this.nextDouble()-1;
+s=v1*v1+v2*v2;
+}while(s>=1);
+var norm=Math.sqrt(-2*Math.log(s)/s);
+this.nextNextGaussian=v2*norm;
+this.haveNextNextGaussian=true;
+return v1*norm;
+});
+Clazz.defineMethod(c$,"nextInt",
+function(){
+return Math.ceil(0xffff*Math.random())-0x8000;
+});
+Clazz.defineMethod(c$,"nextInt",
+function(n){
+if(n>0){
+n = Math.min(n, 31);
+return Math.floor((2 << (n - 1)) * Math.random())
+
+/*
+if((n&-n)==n){
+return((n*this.next(31))>>31);
+}var bits;
+var val;
+do{
+bits=this.next(31);
+val=bits%n;
+}while(bits-val+(n-1)<0);
+
+
+return val;
+
+*/
+}
+throw new IllegalArgumentException();
+},"~N");
+Clazz.defineMethod(c$,"nextLong",
+function(){
+return Math.ceil(0xffffffff*Math.random())-0x80000000;
+});
+Clazz.defineMethod(c$,"setSeed",
+function(seed){
+Math.seedrandom(seed);
+//this.seed=(seed^25214903917)&(281474976710655);
+//this.haveNextNextGaussian=false;
+},"~N");
+Clazz.defineStatics(c$,
+"multiplier",0x5deece66d);
+});
+
+// seedrandom.js
+// Author: David Bau 3/11/2010
+//
+// Defines a method Math.seedrandom() that, when called, substitutes
+// an explicitly seeded RC4-based algorithm for Math.random(). Also
+// supports automatic seeding from local or network sources of entropy.
+//
+// Usage:
+//
+// <script src=http://davidbau.com/encode/seedrandom-min.js></script>
+//
+// Math.seedrandom('yipee'); Sets Math.random to a function that is
+// initialized using the given explicit seed.
+//
+// Math.seedrandom(); Sets Math.random to a function that is
+// seeded using the current time, dom state,
+// and other accumulated local entropy.
+// The generated seed string is returned.
+//
+// Math.seedrandom('yowza', true);
+// Seeds using the given explicit seed mixed
+// together with accumulated entropy.
+//
+// <script src="http://bit.ly/srandom-512"></script>
+// Seeds using physical random bits downloaded
+// from random.org.
+//
+// Examples:
+//
+// Math.seedrandom("hello"); // Use "hello" as the seed.
+// document.write(Math.random()); // Always 0.5463663768140734
+// document.write(Math.random()); // Always 0.43973793770592234
+// var rng1 = Math.random; // Remember the current prng.
+//
+// var autoseed = Math.seedrandom(); // New prng with an automatic seed.
+// document.write(Math.random()); // Pretty much unpredictable.
+//
+// Math.random = rng1; // Continue "hello" prng sequence.
+// document.write(Math.random()); // Always 0.554769432473455
+//
+// Math.seedrandom(autoseed); // Restart at the previous seed.
+// document.write(Math.random()); // Repeat the 'unpredictable' value.
+//
+// Notes:
+//
+// Each time seedrandom('arg') is called, entropy from the passed seed
+// is accumulated in a pool to help generate future seeds for the
+// zero-argument form of Math.seedrandom, so entropy can be injected over
+// time by calling seedrandom with explicit data repeatedly.
+//
+// On speed - This javascript implementation of Math.random() is about
+// 3-10x slower than the built-in Math.random() because it is not native
+// code, but this is typically fast enough anyway. Seeding is more expensive,
+// especially if you use auto-seeding. Some details (timings on Chrome 4):
+//
+// Our Math.random() - avg less than 0.002 milliseconds per call
+// seedrandom('explicit') - avg less than 0.5 milliseconds per call
+// seedrandom('explicit', true) - avg less than 2 milliseconds per call
+// seedrandom() - avg about 38 milliseconds per call
+//
+// LICENSE (BSD):
+//
+// Copyright 2010 David Bau, all rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of this module nor the names of its contributors may
+// be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+/**
+ * All code is in an anonymous closure to keep the global namespace clean.
+ *
+ * @param {number=} overflow
+ * @param {number=} startdenom
+ */
+(function (pool, math, width, chunks, significance, overflow, startdenom) {
+
+var copyright = "Copyright 2010 David Bau, all rights reserved. (BSD)"
+//
+// seedrandom()
+// This is the seedrandom function described above.
+//
+math['seedrandom'] = function seedrandom(seed, use_entropy) {
+ var key = [];
+ var arc4;
+
+ // Flatten the seed string or build one from local entropy if needed.
+ seed = mixkey(flatten(
+ use_entropy ? [seed, pool] :
+ arguments.length ? seed :
+ [new Date().getTime(), pool, window], 3), key);
+
+ // Use the seed to initialize an ARC4 generator.
+ arc4 = new ARC4(key);
+
+ // Mix the randomness into accumulated entropy.
+ mixkey(arc4.S, pool);
+
+ // Override Math.random
+
+ // This function returns a random double in [0, 1) that contains
+ // randomness in every bit of the mantissa of the IEEE 754 value.
+
+ math['random'] = function random() { // Closure to return a random double:
+ var n = arc4.g(chunks); // Start with a numerator n < 2 ^ 48
+ var d = startdenom; // and denominator d = 2 ^ 48.
+ var x = 0; // and no 'extra last byte'.
+ while (n < significance) { // Fill up all significant digits by
+ n = (n + x) * width; // shifting numerator and
+ d *= width; // denominator and generating a
+ x = arc4.g(1); // new least-significant-byte.
+ }
+ while (n >= overflow) { // To avoid rounding up, before adding
+ n /= 2; // last byte, shift everything
+ d /= 2; // right using integer math until
+ x >>>= 1; // we have exactly the desired bits.
+ }
+ return (n + x) / d; // Form the number within [0, 1).
+ };
+
+ // Return the seed that was used
+ return seed;
+};
+
+//
+// ARC4
+//
+// An ARC4 implementation. The constructor takes a key in the form of
+// an array of at most (width) integers that should be 0 <= x < (width).
+//
+// The g(count) method returns a pseudorandom integer that concatenates
+// the next (count) outputs from ARC4. Its return value is a number x
+// that is in the range 0 <= x < (width ^ count).
+//
+/** @constructor */
+function ARC4(key) {
+ var t, u, me = this, keylen = key.length;
+ var i = 0, j = me.i = me.j = me.m = 0;
+ me.S = [];
+ me.c = [];
+
+ // The empty key [] is treated as [0].
+ if (!keylen) { key = [keylen++]; }
+
+ // Set up S using the standard key scheduling algorithm.
+ while (i < width) { me.S[i] = i++; }
+ for (i = 0; i < width; i++) {
+ t = me.S[i];
+ j = lowbits(j + t + key[i % keylen]);
+ u = me.S[j];
+ me.S[i] = u;
+ me.S[j] = t;
+ }
+
+ // The "g" method returns the next (count) outputs as one number.
+ me.g = function getnext(count) {
+ var s = me.S;
+ var i = lowbits(me.i + 1); var t = s[i];
+ var j = lowbits(me.j + t); var u = s[j];
+ s[i] = u;
+ s[j] = t;
+ var r = s[lowbits(t + u)];
+ while (--count) {
+ i = lowbits(i + 1); t = s[i];
+ j = lowbits(j + t); u = s[j];
+ s[i] = u;
+ s[j] = t;
+ r = r * width + s[lowbits(t + u)];
+ }
+ me.i = i;
+ me.j = j;
+ return r;
+ };
+ // For robust unpredictability discard an initial batch of values.
+ // See http://www.rsa.com/rsalabs/node.asp?id=2009
+ me.g(width);
+}
+
+//
+// flatten()
+// Converts an object tree to nested arrays of strings.
+//
+/** @param {Object=} result
+ * @param {string=} prop */
+function flatten(obj, depth, result, prop) {
+ result = [];
+ if (depth && typeof(obj) == 'object') {
+ for (prop in obj) {
+ if (prop.indexOf('S') < 5) { // Avoid FF3 bug (local/sessionStorage)
+ try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
+ }
+ }
+ }
+ return result.length ? result : '' + obj;
+}
+
+//
+// mixkey()
+// Mixes a string seed into a key that is an array of integers, and
+// returns a shortened string seed that is equivalent to the result key.
+//
+/** @param {number=} smear
+ * @param {number=} j */
+function mixkey(seed, key, smear, j) {
+ seed += ''; // Ensure the seed is a string
+ smear = 0;
+ for (j = 0; j < seed.length; j++) {
+ key[lowbits(j)] =
+ lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));
+ }
+ seed = '';
+ for (j in key) { seed += String.fromCharCode(key[j]); }
+ return seed;
+}
+
+//
+// lowbits()
+// A quick "n mod width" for width a power of 2.
+//
+function lowbits(n) { return n & (width - 1); }
+
+//
+// The following constants are related to IEEE 754 limits.
+//
+startdenom = math.pow(width, chunks);
+significance = math.pow(2, significance);
+overflow = significance * 2;
+
+//
+// When seedrandom.js is loaded, we immediately mix a few bits
+// from the built-in RNG into the entropy pool. Because we do
+// not want to intefere with determinstic PRNG state later,
+// seedrandom will not call math.random on its own again after
+// initialization.
+//
+mixkey(math.random(), pool);
+
+// End anonymous scope, and pass initial values.
+})(
+ [], // pool: entropy pool starts empty
+ Math, // math: package containing random, pow, and seedrandom
+ 256, // width: each RC4 output is 0 <= x < 256
+ 6, // chunks: at least six RC4 outputs for each double
+ 52 // significance: there are 52 significant digits in a double
+);
+
git://source.jalview.org / jalviewjs.git / blobdiff