Merge pull request #1807 from ds26gte/horizon

Fix for #1799

Author: jpolitz

src/js/base/js-numbers.js

@@ -813,6 +813,8 @@ define("pyret-base/js/js-numbers", function() {
   // NB: all of these trig-gy generic functions should now return roughnum rather than float
   // (except for an arg of 0, etc)
 
+  var ln10 = Math.log(10)
+
   // log: pyretnum -> pyretnum
   var log = function(n, errbacks) {
     if ( eqv(n, 1, errbacks) ) {
@@ -824,7 +826,35 @@ define("pyret-base/js/js-numbers", function() {
     if (typeof(n) === 'number') {
       return Roughnum.makeInstance(Math.log(n), errbacks);
     }
-    return n.log(errbacks);
+    var nFix = n.toFixnum();
+    if (typeof(nFix) === 'number' && nFix !== Infinity) {
+      return Roughnum.makeInstance(Math.log(nFix), errbacks);
+    }
+    // at this point, n must be a very large positive number;
+    // n > 1e308, i.e, has at least 308 digits;
+    // we can safely ignore its fractional part;
+    var nStr = n.round(errbacks).toString();
+    var nLen = nStr.length;
+    // we furthermore need only the integer part's first few digits
+    // although we must remember the number of digits ignored;
+    var firstFewLen = 308; // has to be <= 308
+    // say integer      N = yyy...yyyxxx...xxx
+    // where the number of x's is nx;
+    // So              N ~= yyy...yyy * 10^nx
+    // We'll first find the common (base 10) log of N
+    //          log10(N) ~= log10(yyy...yyy * 10^nx)
+    //                    = log10(yyy...yyy) + nx
+    // Now to convert this to the natural log
+    //              ln(N) = log10(N) / log10(e)
+    //                    = log10(N) * ln(10)
+    //                   ~= [log10(yyy...yyy) + nx] * ln(10)
+    //                    = log10(yyy...yyy) * ln(10) + nx * ln(10)
+    //                    = ln(yyy...yyy)             + nx * ln(10)
+    // JS gives us ln(yyy...yyy) and ln(10) so we have a good
+    // approximation for ln(N)
+    var nFirstFew = parseInt(nStr.substring(0, firstFewLen));
+    var nLog = Math.log(nFirstFew) + (nLen - firstFewLen) * ln10;
+    return Roughnum.makeInstance(nLog, errbacks);
   };
 
   // tan: pyretnum -> pyretnum
@@ -2889,8 +2919,13 @@ define("pyret-base/js/js-numbers", function() {
   function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
 
   // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
-  function bnpExp(e,z) {
-    if(e > 0xffffffff || e < 1) return BigInteger.ONE;
+  function bnpExp(e, z, errbacks) {
+    if (greaterThan(e, 0xffffffff, errbacks)) {
+      errbacks.throwDomainError('expt: exponent ' + e + ' too large');
+    }
+    if (lessThan(e, 1, errbacks)) {
+      return BigInteger.ONE;
+    }
     var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
     g.copyTo(r);
     while(--i >= 0) {
@@ -2902,10 +2937,10 @@ define("pyret-base/js/js-numbers", function() {
   }
 
   // (public) this^e % m, 0 <= e < 2^32
-  function bnModPowInt(e,m) {
+  function bnModPowInt(e, m, errbacks) {
     var z;
     if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
-    return this.bnpExp(e,z);
+    return this.bnpExp(e, z, errbacks);
   }
 
   // protected
@@ -3274,7 +3309,9 @@ define("pyret-base/js/js-numbers", function() {
   NullExp.prototype.sqrTo = nSqrTo;
 
   // (public) this^e
-  function bnPow(e) { return this.bnpExp(e,new NullExp()); }
+  function bnPow(e, errbacks) {
+    return this.bnpExp(e,new NullExp(), errbacks);
+  }
 
   // (protected) r = lower n words of "this * a", a.t <= n
   // "this" should be the larger one if appropriate.
@@ -3774,48 +3811,48 @@ define("pyret-base/js/js-numbers", function() {
 
   // round: -> pyretnum
   // Round to the nearest integer.
-  BigInteger.prototype.round = function(n, errbacks) {
+  BigInteger.prototype.round = function(errbacks) {
     return this;
   };
 
-  BigInteger.prototype.roundEven = function(n, errbacks) {
+  BigInteger.prototype.roundEven = function(errbacks) {
     return this;
   };
 
   // log: -> pyretnum
   // Produce the log.
-  BigInteger.prototype.log = function(n, errbacks) {
+  BigInteger.prototype.log = function(errbacks) {
     return log(this.toFixnum(), errbacks);
   };
 
   // tan: -> pyretnum
   // Produce the tan.
-  BigInteger.prototype.tan = function(n, errbacks) {
+  BigInteger.prototype.tan = function(errbacks) {
     return tan(this.toFixnum(), errbacks);
   };
 
   // atan: -> pyretnum
   // Produce the arc tangent.
-  BigInteger.prototype.atan = function(n, errbacks) {
+  BigInteger.prototype.atan = function(errbacks) {
     return atan(this.toFixnum(), errbacks);
   };
 
   // cos: -> pyretnum
   // Produce the cosine.
-  BigInteger.prototype.cos = function(n, errbacks) {
+  BigInteger.prototype.cos = function(errbacks) {
     return cos(this.toFixnum(), errbacks);
   };
 
   // sin: -> pyretnum
   // Produce the sine.
-  BigInteger.prototype.sin = function(n, errbacks) {
+  BigInteger.prototype.sin = function(errbacks) {
     return sin(this.toFixnum(), errbacks);
   };
 
   // expt: pyretnum -> pyretnum
   // Produce the power to the input.
   BigInteger.prototype.expt = function(n, errbacks) {
-    return bnPow.call(this, n);
+    return bnPow.call(this, n, errbacks);
   };
 
   // exp: -> pyretnum
@@ -3829,13 +3866,13 @@ define("pyret-base/js/js-numbers", function() {
 
   // acos: -> pyretnum
   // Produce the arc cosine.
-  BigInteger.prototype.acos = function(n, errbacks) {
+  BigInteger.prototype.acos = function(errbacks) {
     return acos(this.toFixnum(), errbacks);
   };
 
   // asin: -> pyretnum
   // Produce the arc sine.
-  BigInteger.prototype.asin = function(n, errbacks) {
+  BigInteger.prototype.asin = function(errbacks) {
     return asin(this.toFixnum(), errbacks);
   };
 

tests/jsnums-test/jsnums-test.js

@@ -0,0 +1,44 @@
+// To test: Build Pyret, then cd to this directory, and type
+// node jsnums-test.js
+
+var Jasmine = require('jasmine');
+var jazz = new Jasmine();
+const R = require("requirejs");
+var build = process.env["PHASE"] || "build/phaseA";
+R.config({
+  waitSeconds: 15000,
+  paths: {
+    "pyret-base": "../../" + build
+  }
+});
+R(["pyret-base/js/js-numbers"], function(JN) {
+  var sampleErrorBacks = {
+    throwDomainError: function() { throw 'domainError'; },
+    throwLogNonPositive: function() { throw 'logNonPositive'; },
+  };
+  describe("check exceptions in js-numbers methods that can't be tested in Pyret", function() {
+    it("bnpExp", function() {
+      // BigInteger.*.expt calls bnPow, which calls bnpExp
+      // shd raise exc for too-large
+      expect(function() { JN.makeBignum(2).expt(JN.makeBignum(0xffffffff + 1), sampleErrorBacks); }).toThrow('domainError');
+
+      // BigInteger.*.log
+      // should raise exception for arg <= 0
+      expect(function() { JN.makeBignum(-1).log(sampleErrorBacks); }).toThrow('logNonPositive');
+
+      // BigInteger.*asin
+      // should raise exception for arg ∉ [-1, +1]
+      expect(function() { JN.makeBignum(-1.5).asin(sampleErrorBacks); }).toThrow('domainError');
+      expect(function() { JN.makeBignum(+1.5).asin(sampleErrorBacks); }).toThrow('domainError');
+
+      // BigInteger.*acos
+      // should raise exception for arg ∉ [-1, +1]
+      expect(function() { JN.makeBignum(-1.5).acos(sampleErrorBacks); }).toThrow('domainError');
+      expect(function() { JN.makeBignum(+1.5).acos(sampleErrorBacks); }).toThrow('domainError');
+
+    });
+  });
+
+  jazz.execute();
+
+});

tests/pyret/tests/test-numbers.arr

@@ -71,19 +71,24 @@ check:
   num-abs(0) is 0
   num-abs(1) is 1
 
+  very-bignum = num-expt(10, 23456)
+
   # These are just sanity end the js-nums library has more rigorous tests
   # for the accuracy of the trig functions.  Here we just make sure the
   # Pyret functions are bound to plausible underlying operations
   num-sin(0) is 0
   num-sin(3.14 / 2) satisfies around(1, 0.1)
   num-sin(3.14) satisfies around(0, 0.1)
+  num-sin(very-bignum) raises "roughnum overflow"
 
   num-cos(0) is 1
   num-cos(3.14 / 2) satisfies around(0, 0.1)
   num-cos(3.14) satisfies around(-1, 0.1)
+  num-cos(very-bignum) raises "roughnum overflow"
 
   num-tan(0) is 0
   num-tan(3.14 / 4) satisfies around(1, 0.01)
+  num-tan(very-bignum) raises "roughnum overflow"
 
   num-asin(0) is 0
   num-asin(1) satisfies around(1.57, 0.01)
@@ -163,6 +168,27 @@ check:
   num-log(1) is 0
   num-log(num-exp(1)) satisfies around(1, 0.0001)
 
+  # in following logs, wolframalpha.com gives a lot more digits; rounding to our precision
+
+  # Racket, Wolfram match Pyret
+  num-log(9e15) is-roughly ~36.736000972246906
+
+  # Wolfram gives ~36.841361487904731, Racket matches
+  num-log(1e16) is-roughly ~36.841361487904734
+
+  # Racket, Wolfram match
+  num-log(1e308) is-roughly ~709.1962086421661
+
+  # Racket gives ~711.49879373516, Wolfram matches
+  num-log(1e309) is-roughly ~711.4987937351601
+
+  # Racket gives ~84709.80298615794, Wolfram ~84709.80298615795
+  num-log(1e36789) is-roughly ~84709.80298615796
+
+  # Racket, Wolfram match
+  # commenting because arg calculation takes much time
+  # num-log(num-expt(10, 1e5)) is-roughly ~230258.50929940457
+
   2 is num-exact(2)
   1 / 3 is num-exact(1 / 3)
   # NOTE(joe): This seems a big algorithm-dependent end mainly here
@@ -187,6 +213,7 @@ check:
   num-expt(3, 2) is 9
   num-expt("nan", 2) raises "Number"
   num-expt(2, "nan") raises "Number"
+  num-expt(7, num-expt(10, 36789)) raises "too large"
 
   num-ceiling(2.5) is 3
   num-ceiling("nan") raises "Number"