bn.js 1.2.1 → 1.3.0

package/.jshintrc

@@ -0,0 +1,89 @@
+{
+    // JSHint Default Configuration File (as on JSHint website)
+    // See http://jshint.com/docs/ for more details
+
+    "maxerr"        : 50,       // {int} Maximum error before stopping
+
+    // Enforcing
+    "bitwise"       : false,     // true: Prohibit bitwise operators (&, |, ^, etc.)
+    "camelcase"     : true,      // true: Identifiers must be in camelCase
+    "curly"         : false,     // true: Require {} for every new block or scope
+    "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
+    "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
+    "freeze"        : true,     // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
+    "immed"         : false,    // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
+    "indent"        : 2,        // {int} Number of spaces to use for indentation
+    "latedef"       : false,    // true: Require variables/functions to be defined before being used
+    "newcap"        : true,     // true: Require capitalization of all constructor functions e.g. `new F()`
+    "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
+    "noempty"       : false,    // true: Prohibit use of empty blocks
+    "nonbsp"        : true,     // true: Prohibit "non-breaking whitespace" characters.
+    "nonew"         : false,    // true: Prohibit use of constructors for side-effects (without assignment)
+    "plusplus"      : false,    // true: Prohibit use of `++` & `--`
+    "quotmark"      : "single", // Quotation mark consistency:
+                                //   false    : do nothing (default)
+                                //   true     : ensure whatever is used is consistent
+                                //   "single" : require single quotes
+                                //   "double" : require double quotes
+    "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
+    "unused"        : true,     // true: Require all defined variables be used
+    "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
+    "maxparams"     : false,    // {int} Max number of formal params allowed per function
+    "maxdepth"      : false,    // {int} Max depth of nested blocks (within functions)
+    "maxstatements" : false,    // {int} Max number statements per function
+    "maxcomplexity" : false,    // {int} Max cyclomatic complexity per function
+    "maxlen"        : false,    // {int} Max number of characters per line
+
+    // Relaxing
+    "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
+    "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
+    "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
+    "eqnull"        : false,     // true: Tolerate use of `== null`
+    "es5"           : false,     // true: Allow ES5 syntax (ex: getters and setters)
+    "esnext"        : false,     // true: Allow ES.next (ES6) syntax (ex: `const`)
+    "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
+                                 // (ex: `for each`, multiple try/catch, function expression…)
+    "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
+    "expr"          : false,     // true: Tolerate `ExpressionStatement` as Programs
+    "funcscope"     : false,     // true: Tolerate defining variables inside control statements
+    "globalstrict"  : false,     // true: Allow global "use strict" (also enables 'strict')
+    "iterator"      : false,     // true: Tolerate using the `__iterator__` property
+    "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
+    "laxbreak"      : false,     // true: Tolerate possibly unsafe line breakings
+    "laxcomma"      : false,     // true: Tolerate comma-first style coding
+    "loopfunc"      : false,     // true: Tolerate functions being defined in loops
+    "multistr"      : false,     // true: Tolerate multi-line strings
+    "noyield"       : false,     // true: Tolerate generator functions with no yield statement in them.
+    "notypeof"      : false,     // true: Tolerate invalid typeof operator values
+    "proto"         : false,     // true: Tolerate using the `__proto__` property
+    "scripturl"     : false,     // true: Tolerate script-targeted URLs
+    "shadow"        : true,      // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
+    "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
+    "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
+    "validthis"     : false,     // true: Tolerate using this in a non-constructor function
+
+    // Environments
+    "browser"       : true,     // Web Browser (window, document, etc)
+    "browserify"    : false,    // Browserify (node.js code in the browser)
+    "couch"         : false,    // CouchDB
+    "devel"         : true,     // Development/debugging (alert, confirm, etc)
+    "dojo"          : false,    // Dojo Toolkit
+    "jasmine"       : false,    // Jasmine
+    "jquery"        : false,    // jQuery
+    "mocha"         : true,     // Mocha
+    "mootools"      : false,    // MooTools
+    "node"          : false,    // Node.js
+    "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
+    "prototypejs"   : false,    // Prototype and Scriptaculous
+    "qunit"         : false,    // QUnit
+    "rhino"         : false,    // Rhino
+    "shelljs"       : false,    // ShellJS
+    "worker"        : false,    // Web Workers
+    "wsh"           : false,    // Windows Scripting Host
+    "yui"           : false,    // Yahoo User Interface
+
+    // Custom Globals
+    "globals"       : {
+        "module": true
+    }        // additional predefined global variables
+}

package/README.md

@@ -6,7 +6,7 @@ Just a bike-shed.
 
 This software is licensed under the MIT License.
 
-Copyright Fedor Indutny, 2014.
+Copyright Fedor Indutny, 2015.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the

package/lib/bn.js

@@ -1,3 +1,7 @@
+(function(module, exports) {
+
+'use strict';
+
 // Utils
 
 function assert(val, msg) {
@@ -5,19 +9,14 @@ function assert(val, msg) {
     throw new Error(msg || 'Assertion failed');
 }
 
-function assertEqual(l, r, msg) {
-  if (l != r)
-    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
-}
-
 // Could use `inherits` module, but don't want to move from single file
 // architecture yet.
 function inherits(ctor, superCtor) {
-  ctor.super_ = superCtor
-  var TempCtor = function () {}
-  TempCtor.prototype = superCtor.prototype
-  ctor.prototype = new TempCtor()
-  ctor.prototype.constructor = ctor
+  ctor.super_ = superCtor;
+  var TempCtor = function () {};
+  TempCtor.prototype = superCtor.prototype;
+  ctor.prototype = new TempCtor();
+  ctor.prototype.constructor = ctor;
 }
 
 // BN
@@ -47,6 +46,8 @@ function BN(number, base, endian) {
 }
 if (typeof module === 'object')
   module.exports = BN;
+else
+  exports.BN = BN;
 
 BN.BN = BN;
 BN.wordSize = 26;
@@ -292,7 +293,6 @@ var base = 2 - 1;
 while (++base < 36 + 1) {
   var groupSize = 0;
   var groupBase = 1;
-  // TODO: <=
   while (groupBase < (1 << BN.wordSize) / base) {
     groupBase *= base;
     groupSize += 1;
@@ -481,8 +481,6 @@ BN.prototype.bitLength = function bitLength() {
 };
 
 BN.prototype.byteLength = function byteLength() {
-  var hi = 0;
-  var w = this.words[this.length - 1];
   return Math.ceil(this.bitLength() / 8);
 };
 
@@ -496,6 +494,115 @@ BN.prototype.neg = function neg() {
   return r;
 };
 
+
+// Or `num` with `this` in-place
+BN.prototype.ior = function ior(num) {
+  this.sign = this.sign || num.sign;
+
+  while (this.length < num.length)
+    this.words[this.length++] = 0;
+
+  for (var i = 0; i < num.length; i++)
+    this.words[i] = this.words[i] | num.words[i];
+
+  return this.strip();
+};
+
+
+// Or `num` with `this`
+BN.prototype.or = function or(num) {
+  if (this.length > num.length)
+    return this.clone().ior(num);
+  else
+    return num.clone().ior(this);
+};
+
+
+// And `num` with `this` in-place
+BN.prototype.iand = function iand(num) {
+  this.sign = this.sign && num.sign;
+
+  // b = min-length(num, this)
+  var b;
+  if (this.length > num.length)
+    b = num;
+  else
+    b = this;
+
+  for (var i = 0; i < b.length; i++)
+    this.words[i] = this.words[i] & num.words[i];
+
+  this.length = b.length;
+
+  return this.strip();
+};
+
+
+// And `num` with `this`
+BN.prototype.and = function and(num) {
+  if (this.length > num.length)
+    return this.clone().iand(num);
+  else
+    return num.clone().iand(this);
+};
+
+
+// Xor `num` with `this` in-place
+BN.prototype.ixor = function ixor(num) {
+  this.sign = this.sign || num.sign;
+
+  // a.length > b.length
+  var a;
+  var b;
+  if (this.length > num.length) {
+    a = this;
+    b = num;
+  } else {
+    a = num;
+    b = this;
+  }
+
+  for (var i = 0; i < b.length; i++)
+    this.words[i] = a.words[i] ^ b.words[i];
+
+  if (this !== a)
+    for (; i < a.length; i++)
+      this.words[i] = a.words[i];
+
+  this.length = a.length;
+
+  return this.strip();
+};
+
+
+// Xor `num` with `this`
+BN.prototype.xor = function xor(num) {
+  if (this.length > num.length)
+    return this.clone().ixor(num);
+  else
+    return num.clone().ixor(this);
+};
+
+
+// Set `bit` of `this`
+BN.prototype.setn = function setn(bit, val) {
+  assert(typeof bit === 'number' && bit >= 0);
+
+  var off = (bit / 26) | 0;
+  var wbit = bit % 26;
+
+  while (this.length <= off)
+    this.words[this.length++] = 0;
+
+  if (val)
+    this.words[off] = this.words[off] | (1 << wbit);
+  else
+    this.words[off] = this.words[off] & ~(1 << wbit);
+
+  return this.strip();
+};
+
+
 // Add `num` to `this` in-place
 BN.prototype.iadd = function iadd(num) {
   // negative + positive
@@ -598,12 +705,14 @@ BN.prototype.isub = function isub(num) {
   }
 
   // a > b
+  var a;
+  var b;
   if (cmp > 0) {
-    var a = this;
-    var b = num;
+    a = this;
+    b = num;
   } else {
-    var a = num;
-    var b = this;
+    a = num;
+    b = this;
   }
 
   var carry = 0;
@@ -780,7 +889,6 @@ BN.prototype.imul = function imul(num) {
   this.length = this.length + num.length;
   this.words[this.length - 1] = 0;
 
-  var lastCarry = 0;
   for (var k = this.length - 2; k >= 0; k--) {
     // Sum all words with the same `i + j = k` and accumulate `carry`,
     // note that carry could be >= 0x3ffffff
@@ -855,7 +963,6 @@ BN.prototype.ishln = function ishln(bits) {
   var s = (bits - r) / 26;
   var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
 
-  var o = this.clone();
   if (r !== 0) {
     var carry = 0;
     for (var i = 0; i < this.length; i++) {
@@ -1068,64 +1175,17 @@ BN.prototype.subn = function subn(num) {
 BN.prototype.iabs = function iabs() {
   this.sign = false;
 
-  return this
+  return this;
 };
 
 BN.prototype.abs = function abs() {
   return this.clone().iabs();
 };
 
-BN.prototype._ishlnadd = function _ishlnadd(num, shift) {
-  assert(!num.sign);
-  if (this.sign) {
-    this.sign = false;
-    this._ishlnsub(num, shift);
-    this.sign = !this.sign;
-    return this;
-  }
-
-  // Bigger storage is needed
-  var len = num.length + shift + 1;
-  if (this.words.length < len) {
-    var t = new Array(len);
-    for (var i = 0; i < this.length; i++)
-      t[i] = this.words[i];
-    this.words = t;
-  } else {
-    i = this.length;
-  }
-
-  // Zeroify rest
-  this.length = Math.max(this.length, len);
-  for (; i < this.length; i++)
-    this.words[i] = 0;
-
-  var carry = 0;
-  for (var i = 0; i < num.length; i++) {
-    var w = this.words[i + shift] + num.words[i]  + carry;
-    carry = w >> 26;
-    this.words[i + shift] = w & 0x3ffffff;
-  }
-  for (; i < this.length - shift; i++) {
-    var w = this.words[i + shift] + carry;
-    carry = w >> 26;
-    this.words[i + shift] = w & 0x3ffffff;
-  }
-
-  return this.strip();
-};
-
-BN.prototype._ishlnsub = function _ishlnsub(num, shift) {
-  assert(!num.sign);
-  if (this.sign) {
-    this.sign = false;
-    this._ishlnadd(num, shift);
-    this.sign = !this.sign;
-    return this;
-  }
-
+BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
   // Bigger storage is needed
   var len = num.length + shift;
+  var i;
   if (this.words.length < len) {
     var t = new Array(len);
     for (var i = 0; i < this.length; i++)
@@ -1142,8 +1202,10 @@ BN.prototype._ishlnsub = function _ishlnsub(num, shift) {
 
   var carry = 0;
   for (var i = 0; i < num.length; i++) {
-    var w = this.words[i + shift] - num.words[i]  + carry;
-    carry = w >> 26;
+    var w = this.words[i + shift] + carry;
+    var right = num.words[i] * mul;
+    w -= right & 0x3ffffff;
+    carry = (w >> 26) - ((right / 0x4000000) | 0);
     this.words[i + shift] = w & 0x3ffffff;
   }
   for (; i < this.length - shift; i++) {
@@ -1196,16 +1258,13 @@ BN.prototype._wordDiv = function _wordDiv(num, mode) {
       q.words[i] = 0;
   }
 
-  var diff = a.clone()._ishlnsub(b, m);
+  var diff = a.clone()._ishlnsubmul(b, 1, m);
   if (!diff.sign) {
     a = diff;
     if (q)
       q.words[m] = 1;
   }
 
-  var st = new BN(null);
-  st.words = new Array(b.length + 1);
-  st.length = 0;
   for (var j = m - 1; j >= 0; j--) {
     var qj = a.words[b.length + j] * 0x4000000 + a.words[b.length + j - 1];
 
@@ -1213,13 +1272,12 @@ BN.prototype._wordDiv = function _wordDiv(num, mode) {
     // (0x7ffffff)
     qj = Math.min((qj / bhi) | 0, 0x3ffffff);
 
-    for (var i = 0; i < b.length; i++)
-      st.words[i] = b.words[i];
-    st.length = b.length;
-    a._ishlnsub(st.imuln(qj), j);
+    a._ishlnsubmul(b, qj, j);
     while (a.sign) {
       qj--;
-      a._ishlnadd(b, j);
+      a.sign = false;
+      a._ishlnsubmul(b, 1, j);
+      a.sign = !a.sign;
     }
     if (q)
       q.words[j] = qj;
@@ -1229,7 +1287,7 @@ BN.prototype._wordDiv = function _wordDiv(num, mode) {
   a.strip();
 
   // Denormalize
-  if (shift !== 0)
+  if (mode !== 'div' && shift !== 0)
     a.ishrn(shift);
   return { div: q ? q : null, mod: a };
 };
@@ -1429,11 +1487,11 @@ BN.prototype.invm = function invm(num) {
   return this._egcd(new BN(1), num).mod(num);
 };
 
-BN.prototype.isEven = function isEven(num) {
+BN.prototype.isEven = function isEven() {
   return (this.words[0] & 1) === 0;
 };
 
-BN.prototype.isOdd = function isOdd(num) {
+BN.prototype.isOdd = function isOdd() {
   return (this.words[0] & 1) === 1;
 };
 
@@ -1713,30 +1771,27 @@ K256.prototype.imulK = function imulK(num) {
   num.words[num.length + 1] = 0;
   num.length += 2;
 
-  var uhi = 0;
-  var hi = 0;
+  // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
+  var hi;
   var lo = 0;
   for (var i = 0; i < num.length; i++) {
     var w = num.words[i];
-    hi += w * 0x40;
+    hi = w * 0x40;
     lo += w * 0x3d1;
     hi += (lo / 0x4000000) | 0;
-    uhi += (hi / 0x4000000) | 0;
-    hi &= 0x3ffffff;
     lo &= 0x3ffffff;
 
     num.words[i] = lo;
 
     lo = hi;
-    hi = uhi;
-    uhi = 0;
   }
 
   // Fast length reduction
-  if (num.words[num.length - 1] === 0)
-    num.length--;
-  if (num.words[num.length - 1] === 0)
+  if (num.words[num.length - 1] === 0) {
     num.length--;
+    if (num.words[num.length - 1] === 0)
+      num.length--;
+  }
   return num;
 };
 
@@ -1801,7 +1856,7 @@ BN._prime = function prime(name) {
   primes[name] = prime;
 
   return prime;
-}
+};
 
 //
 // Base reduction engine
@@ -2018,12 +2073,9 @@ function Mont(m) {
   this.r2 = this.imod(this.r.sqr());
   this.rinv = this.r.invm(this.m);
 
-  // TODO(indutny): simplify it
-  this.minv = this.rinv.mul(this.r)
-                       .sub(new BN(1))
-                       .div(this.m)
-                       .neg()
-                       .mod(this.r);
+  this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
+  this.minv.sign = true;
+  this.minv = this.minv.mod(this.r);
 }
 inherits(Mont, Red);
 
@@ -2077,3 +2129,5 @@ Mont.prototype.invm = function invm(a) {
   var res = this.imod(a.invm(this.m).mul(this.r2));
   return res._forceRed(this);
 };
+
+})(typeof module === 'undefined' || module, this);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "bn.js",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Big number implementation in pure javascript",
   "main": "lib/bn.js",
   "scripts": {
-    "test": "mocha --reporter=spec test/*-test.js"
+    "test": "jshint lib/*.js && mocha --reporter=spec test/*-test.js"
   },
   "repository": {
     "type": "git",
@@ -24,6 +24,7 @@
   },
   "homepage": "https://github.com/indutny/bn.js",
   "devDependencies": {
-    "mocha": "^1.18.2"
+    "jshint": "^2.6.0",
+    "mocha": "^2.1.0"
   }
 }

package/test/bn-test.js

@@ -445,4 +445,62 @@ describe('BN', function() {
     assert.equal(new BN(18).gcd(new BN(12)).toString(16), '6');
     assert.equal(new BN(-18).gcd(new BN(12)).toString(16), '6');
   });
+
+  it('should and numbers', function () {
+    assert.equal(new BN('1010101010101010101010101010101010101010', 2)
+                 .and(new BN('101010101010101010101010101010101010101', 2))
+                 .toString(2), '0');
+  });
+  it('should iand numbers', function () {
+    assert.equal(new BN('1010101010101010101010101010101010101010', 2)
+                 .iand(new BN('101010101010101010101010101010101010101', 2))
+                 .toString(2), '0');
+    assert.equal(new BN('1000000000000000000000000000000000000001', 2)
+                 .iand(new BN('1', 2))
+                 .toString(2), '1')
+    assert.equal(new BN('1', 2)
+                 .iand(new BN('1000000000000000000000000000000000000001', 2))
+                 .toString(2), '1')
+  });
+  it('should or numbers', function () {
+    assert.equal(new BN('1010101010101010101010101010101010101010', 2)
+                 .or(new BN('101010101010101010101010101010101010101', 2))
+                 .toString(2), '1111111111111111111111111111111111111111');
+  });
+  it('should ior numbers', function () {
+    assert.equal(new BN('1010101010101010101010101010101010101010', 2)
+                 .ior(new BN('101010101010101010101010101010101010101', 2))
+                 .toString(2), '1111111111111111111111111111111111111111');
+    assert.equal(new BN('1000000000000000000000000000000000000000', 2)
+                 .ior(new BN('1', 2))
+                 .toString(2), '1000000000000000000000000000000000000001');
+    assert.equal(new BN('1', 2)
+                 .ior(new BN('1000000000000000000000000000000000000000', 2))
+                 .toString(2), '1000000000000000000000000000000000000001');
+  });
+  it('should xor numbers', function () {
+    assert.equal(new BN('11001100110011001100110011001100', 2)
+                 .xor(new BN('1100110011001100110011001100110', 2))
+                 .toString(2), '10101010101010101010101010101010');
+  });
+  it('should ixor numbers', function () {
+    assert.equal(new BN('11001100110011001100110011001100', 2)
+                 .ixor(new BN('1100110011001100110011001100110', 2))
+                 .toString(2), '10101010101010101010101010101010');
+    assert.equal(new BN('11001100110011001100110011001100', 2)
+                 .ixor(new BN('1', 2))
+                 .toString(2), '11001100110011001100110011001101');
+    assert.equal(new BN('1', 2)
+                 .ixor(new BN('11001100110011001100110011001100', 2))
+                 .toString(2), '11001100110011001100110011001101');
+  });
+
+  it('should allow single bits to be set', function () {
+    assert.equal(new BN(0).setn(2, true).toString(2), '100');
+    assert.equal(new BN(0).setn(27, true).toString(2),
+                 '1000000000000000000000000000');
+    assert.equal(new BN('1000000000000000000000000001', 2).setn(27, false)
+                 .toString(2), '1');
+    assert.equal(new BN('101', 2).setn(2, false).toString(2), '1');
+  });
 });

package/1.js

@@ -1,8 +0,0 @@
-var BN = require('./');
-
-var a = new BN("6582018229284824168619876730229320890292528855852623664389292032");
-var b = new BN("730750818665451459101842416358132502628711530497");
-console.log(b.words);
-var q = a.div(b);
-var m = a.mod(b);
-console.log(q, m);