[jalviewjs.git] / site / j2s / java / util / Random.js

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