James Sumners avatar James Sumners committed 23dc58e

Initial commit.

Comments (0)

Files changed (6)

Empty file added.

+(function() {
+  /**
+   * Defines a Latin Square object. The square is represented by an array
+   * of size NxN. If a size is not specified, then the size defaults to 3x3.
+   * Elements of the square are addressed from the top left to bottom right.
+   * That is, in the following square:
+   *
+   * | 1 2 3 |
+   * | 2 3 1 |
+   * | 3 1 2 |
+   *
+   * The element at position (2,3) is 1. That is, the value of row 2
+   * position 3 is 1.
+   *
+   * The symbols parameter defines the list of symbols that will be used
+   * in the square. If the parameter is not passed, it is assumed the symbols
+   * are to be the list of integers 1...n (where n is square size).
+   *
+   * The func parameter defines the function for determing the placement of
+   * symbols in the square. This function should be congruent to the size
+   * of the square and return the index of the element in the symbols array.
+   * For example, the default function for the default square size of 3 is:
+   *
+   *   f(x, y) = (x + y) % 3 => f(0, 1) = 1   [symbol = '2']
+   *
+   * where x is the column and y is the row in the square. Any such function
+   * as this can be used, simply pass in a function reference. Otherwise, the
+   * function described above will be used. For a thorough explanation, see
+   * http://www.math.utah.edu/~carlson/mathcircles/magic.pdf
+   *
+   * Note: the function passed in must have the same signature as the default
+   * function. That is, "var yourFunction = function(x, y);".
+   *
+   * @param {number} n       The desired size of the square. 3 is the default.
+   * @param {array}  symbols The list of symbols to use in the square.
+   * @param {function} func  A function to be used for determing symbol placement.
+   */
+  LatinSquare = function(n, symbols, func) {
+    var i = 0;
+
+    if (n && symbols && n !== symbols.length) {
+      throw new Error("Symbols length must match square size.");
+    }
+
+    if ( !(this instanceof LatinSquare) ) {
+      return new LatinSquare(n);
+    }
+
+    this.symbols = [];
+
+    if (n) {
+      this.square = Array(n);
+      for (i = 0; i < n; i += 1) {
+        this.square[i] = Array(n);
+      }
+
+      this.rows = n;
+      this.cols = n;
+    } else {
+      // We will assume the user wants a standard 3x3 square.
+      n = 3;
+      this.square =
+        [
+          [null,null,null],
+          [null,null,null],
+          [null,null,null]
+        ];
+      this.rows = 3;
+      this.cols = 3;
+    }
+
+    if (symbols) {
+      this.symbols = symbols;
+    } else {
+      for (i = 0; i < n; i += 1) {
+        this.symbols.push(i + 1);
+      }
+    }
+
+    if (func && typeof func === 'function') {
+      this.userfunc = func;
+    }
+  };
+
+  /**
+   * Populate the square with values based on the mapping
+   * function and the symbols array.
+   */
+  LatinSquare.prototype.fill = function() {
+    var i, j;
+
+    for (i = 0; i < this.rows; i += 1) {
+      for (j = 0; j < this.cols; j += 1) {
+        this.set(i, j);
+      }
+    }
+  };
+
+  /**
+   * Retrieve a value from the square given its row and column position.
+   * The top left of the square is (0,0).
+   *
+   * @param  {number} row            The x position of the value.
+   * @param  {number} col            The y position of the value.
+   * @return {number,null,undefined} The value.
+   */
+  LatinSquare.prototype.get = function(row, col) {
+    return this.square[row][col];
+  };
+
+  /**
+   * Set the value of a position in the square. The value is normally a lettter
+   * or a number, but it can be any type of object.
+   *
+   * @param {number} row   The x position.
+   * @param {number} col   The y position.
+   */
+  LatinSquare.prototype.set = function(row, col) {
+    if (this.userfunc) {
+      this.square[row][col] = this.symbols[this.userfunc(row, col)];
+    } else {
+      this.square[row][col] = this.symbols[this._f(row, col)];
+    }
+  };
+
+  /**
+   * A private method used to calculate which symbol to set
+   * for a given position. This should be overridden by a user supplied
+   * function.
+   *
+   * @param  {number} x The column part of the position.
+   * @param  {number} y The row part of the position.
+   * @return {object}   The symbol for the position.
+   */
+  LatinSquare.prototype._f = function(x, y) {
+    return (x + y) % this.symbols.length;
+  };
+
+  // Return our LatinSquare object.
+  if (exports) {
+    // node.js
+    exports.LatinSquare = LatinSquare;
+  } else {
+    return LatinSquare;
+  }
+}());
+(function() {
+  var seedRandom, sha1;
+
+  if (exports) {
+    // node.js
+    // If you are not loading this script through node.js, then
+    // the following scripts should be loaded in such a fashion that
+    // they are in this script's scope.
+    seedRandom = require('./seedrandom.js');
+    sha1 = require('./sha1.js');
+  } else {
+    seedRandom = (seedrandom) ? seedrandom : null;
+    sha1 = (Sha1) ? Sha1 : null;
+  }
+
+  if (seedRandom === null || sha1 === null) {
+    throw new ReferenceError(
+      "The seedrandom and Sha1 libraries are required by RandomNumber.");
+  }
+
+  RandomNumber = function() {
+    if ( !(this instanceof RandomNumber) ) {
+      return new RandomNumber();
+    }
+  };
+
+  /**
+   * Indicates if the instance's RNG has been seeded. If you wish to re-seed
+   * the RNG, e.g. to use your own RandomNumber.SEED, then set this to false.
+   * Once the RNG has been seeded, this will be set to true.
+   *
+   * @type {Boolean}
+   */
+  RandomNumber.prototype.isSeeded = false;
+
+  /**
+   * A constant that is used to seed the random number generator. If you wish
+   * to override this seed with your own, then simply define your own
+   * RandomNumber.SEED property and set RandomNumber.isSeeded to false.
+   *
+   * @return {string} A string to be used as a seed.
+   */
+  RandomNumber.prototype.SEED = (function() {
+    // This seed algorithm attempts to make it difficult to re-generate the
+    // same seed multiple times by using three different points in time as the
+    // basis for a calculation.
+    var s = {};
+
+    s.a = (new Date()).getTime();
+    s.b = (new Date()).getTime() + Math.floor(Math.sqrt(s.a));
+    s.c = (new Date()).getTime() + Math.floor(Math.sqrt(s.b));
+
+    // Normalize our values so that they don't overflow the final calculation.
+    s.a = Math.floor(+(s.a.toString().substr(-5)) / 1000);
+    s.b = Math.floor(+(s.b.toString().substr(-5)) / 1000);
+    s.c = Math.floor(+(s.c.toString().substr(-5)) / 1000);
+
+    // This should look very familiar to anyone who has ever taken an
+    // algebra course.
+    s.q = s.a * (s.b * s.b) + s.a * s.b + s.c;
+
+    return sha1.hash(s.q, false);
+  }());
+
+  /**
+   * Get a random integer within a specified range. The range is specified by
+   * an object with the properties "min" and "max".
+   *
+   * @param  {object} range An object with the min and max properties.
+   * @return {number}       An integer within the specified range.
+   */
+  RandomNumber.prototype.randInt = function(range) {
+    if (!range || (!range.min && !range.max)) {
+      throw new ReferenceError("RandomNumber.randInt requires a range.");
+    }
+
+    if (!this.isSeeded) {
+      Math.seedrandom(this.SEED);
+      this.isSeeded = true;
+    }
+
+    return Math.floor(Math.random() * (range.max - range.min + 1)) + range.min;
+  };
+
+  if (exports) {
+    // node.js
+    exports.RandomNumber = RandomNumber;
+  } else {
+    return RandomNumber;
+  }
+}());
+(function() {
+  var LatinSquare = (require('./LatinSquare.js')).LatinSquare,
+      RandomNumber = (require('./RandomNumber.js')).RandomNumber,
+      N = 3,
+      mapper = function(){},
+      randomNumber = new RandomNumber(),
+      randX = randomNumber.randInt({min:1, max:15}),
+      randY = randomNumber.randInt({min:1, max:N}),
+      str = '',
+      square = {};
+
+  mapper = function(x, y) {
+    // This isn't returning a valid Latin Square on every run :-/
+    return (randX*x + randY*y) % N;
+  };
+
+  square = new LatinSquare(N, undefined, mapper);
+  square.fill();
+
+  console.dir(square.square);
+
+  // For prettier, but slower, output:
+  /*for (i = 0; i < square.rows; i += 1) {
+    for (j = 0; j < square.cols; j += 1) {
+      str += square.get(i, j) + ', ';
+    }
+
+    str = str.slice(0, str.length - 2);
+    console.log(str);
+    str = '';
+  }*/
+}());
+// seedrandom.js version 2.0.
+// Author: David Bau 4/2/2011
+//
+// 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.
+//
+//   <script src="https://jsonlib.appspot.com/urandom?callback=Math.seedrandom">
+//   </script>                 Seeds using urandom bits from call.jsonlib.com,
+//                             which is faster than 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) {
+
+
+//
+// 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
+  * @param {string=} typ */
+function flatten(obj, depth, result, prop, typ) {
+  result = [];
+  typ = typeof(obj);
+  if (depth && typ == '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 + (typ != 'string' ? '\0' : ''));
+}
+
+//
+// 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
+);
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+/*  SHA-1 implementation in JavaScript | (c) Chris Veness 2002-2010 | www.movable-type.co.uk      */
+/*   - see http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html                             */
+/*         http://csrc.nist.gov/groups/ST/toolkit/examples.html                                   */
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+
+/**
+ * This code has been modified to work as a node.js module.
+ * Also, linting errors have been cleaned up. ~ James Sumners
+ */
+
+var Sha1 = {};  // Sha1 namespace
+
+/**
+ * Generates SHA-1 hash of string
+ *
+ * @param {String} msg                String to be hashed
+ * @param {Boolean} [utf8encode=true] Encode msg as UTF-8 before generating hash
+ * @returns {String}                  Hash of msg as hex character string
+ */
+Sha1.hash = function(msg, utf8encode) {
+  var a, b, c, d, e,
+      H0, H1, H2, H3, H4,   i, j, K, l, N, M, s, t, T,
+      W;
+
+  utf8encode =  (typeof utf8encode == 'undefined') ? true : utf8encode;
+
+  // convert string to UTF-8, as SHA only deals with byte-streams
+  if (utf8encode) msg = Utf8.encode(msg);
+
+  // constants [§4.2.1]
+  K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+
+  // PREPROCESSING
+
+  msg += String.fromCharCode(0x80);  // add trailing '1' bit (+ 0's padding) to string [§5.1.1]
+
+  // convert string msg into 512-bit/16-integer blocks arrays of ints [§5.2.1]
+  l = msg.length/4 + 2;  // length (in 32-bit integers) of msg + ‘1’ + appended length
+  N = Math.ceil(l/16);   // number of 16-integer-blocks required to hold 'l' ints
+  M = new Array(N);
+
+  for (i = 0; i < N; i += 1) {
+    M[i] = new Array(16);
+    for (j = 0; j < 16; j += 1) {  // encode 4 chars per integer, big-endian encoding
+      M[i][j] = (msg.charCodeAt(i*64+j*4)<<24) | (msg.charCodeAt(i*64+j*4+1)<<16) |
+        (msg.charCodeAt(i*64+j*4+2)<<8) | (msg.charCodeAt(i*64+j*4+3));
+    } // note running off the end of msg is ok 'cos bitwise ops on NaN return 0
+  }
+  // add length (in bits) into final pair of 32-bit integers (big-endian) [§5.1.1]
+  // note: most significant word would be (len-1)*8 >>> 32, but since JS converts
+  // bitwise-op args to 32 bits, we need to simulate this by arithmetic operators
+  M[N-1][14] = ((msg.length-1)*8) / Math.pow(2, 32); M[N-1][14] = Math.floor(M[N-1][14]);
+  M[N-1][15] = ((msg.length-1)*8) & 0xffffffff;
+
+  // set initial hash value [§5.3.1]
+  H0 = 0x67452301;
+  H1 = 0xefcdab89;
+  H2 = 0x98badcfe;
+  H3 = 0x10325476;
+  H4 = 0xc3d2e1f0;
+
+  // HASH COMPUTATION [§6.1.2]
+
+  W = new Array(80);
+  for (i = 0; i < N; i += 1) {
+
+    // 1 - prepare message schedule 'W'
+    for (t = 0;  t < 16; t += 1) {
+      W[t] = M[i][t];
+    }
+    for (t = 16; t < 80; t += 1) {
+      W[t] = Sha1.ROTL(W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16], 1);
+    }
+
+    // 2 - initialise five working variables a, b, c, d, e with previous hash value
+    a = H0; b = H1; c = H2; d = H3; e = H4;
+
+    // 3 - main loop
+    for (t = 0; t < 80; t += 1) {
+      s = Math.floor(t/20); // seq for blocks of 'f' functions and 'K' constants
+      T = (Sha1.ROTL(a,5) + Sha1.f(s,b,c,d) + e + K[s] + W[t]) & 0xffffffff;
+      e = d;
+      d = c;
+      c = Sha1.ROTL(b, 30);
+      b = a;
+      a = T;
+    }
+
+    // 4 - compute the new intermediate hash value
+    H0 = (H0+a) & 0xffffffff;  // note 'addition modulo 2^32'
+    H1 = (H1+b) & 0xffffffff;
+    H2 = (H2+c) & 0xffffffff;
+    H3 = (H3+d) & 0xffffffff;
+    H4 = (H4+e) & 0xffffffff;
+  }
+
+  return Sha1.toHexStr(H0) + Sha1.toHexStr(H1) +
+    Sha1.toHexStr(H2) + Sha1.toHexStr(H3) + Sha1.toHexStr(H4);
+};
+
+//
+// function 'f' [§4.1.1]
+//
+Sha1.f = function(s, x, y, z)  {
+  switch (s) {
+  case 0: return (x & y) ^ (~x & z);           // Ch()
+  case 1: return x ^ y ^ z;                    // Parity()
+  case 2: return (x & y) ^ (x & z) ^ (y & z);  // Maj()
+  case 3: return x ^ y ^ z;                    // Parity()
+  }
+};
+
+//
+// rotate left (circular left shift) value x by n positions [§3.2.5]
+//
+Sha1.ROTL = function(x, n) {
+  return (x<<n) | (x>>>(32-n));
+};
+
+//
+// hexadecimal representation of a number
+//   (note toString(16) is implementation-dependant, and
+//   in IE returns signed numbers when used on full words)
+//
+Sha1.toHexStr = function(n) {
+  var s="", v;
+  for (var i=7; i>=0; i--) { v = (n>>>(i*4)) & 0xf; s += v.toString(16); }
+  return s;
+};
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+
+// node.js
+if (exports) {
+  exports.hash = Sha1.hash;
+  exports.ROTL = Sha1.ROTL;
+  exports.toHexStr = Sha1.toHexStr;
+}
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.