Comprehensive jsnum tests

src/js/base/js-numbers.js

@@ -160,31 +160,7 @@ define("pyret-base/js/js-numbers", function() {
 
   // fromFixnum: fixnum -> pyretnum
   var fromFixnum = function(x, errbacks) {
-    if (!isFinite(x)) {
-      return Roughnum.makeInstance(x, errbacks);
-    }
-    var nf = Math.floor(x);
-    if (nf === x) {
-      if (isOverflow(nf)) {
-        return makeBignum(expandExponent(x+''));
-      } else {
-        return nf;
-      }
-    } else {
-      //  used to return float, now rational
-      var stringRep = x.toString();
-      var match = stringRep.match(/^(.*)\.(.*)$/);
-      if (match) {
-        var afterDecimal = parseInt(match[2]);
-        var factorToInt = Math.pow(10, match[2].length);
-        var extraFactor = _integerGcd(factorToInt, afterDecimal);
-        var multFactor = factorToInt / extraFactor;
-        return Rational.makeInstance(Math.round(x*multFactor), Math.round(factorToInt/extraFactor), errbacks);
-      } else {
-        return Rational.makeInstance(x, 1, errbacks);
-      }
-
-    }
+    return fromString(String(x), errbacks);
   };
 
   var expandExponent = function(s) {
@@ -1225,9 +1201,11 @@ define("pyret-base/js/js-numbers", function() {
   // _integerMultiply: integer-pyretnum integer-pyretnum -> integer-pyretnum
   var _integerMultiply = makeIntegerBinop(
     function(m, n) {
+      // console.log('doing _integerMultiplyI', m, n);
       return m * n;
     },
     function(m, n) {
+      // console.log('doing _integerMultiplyII[_,40]', m, n['40']);
       return bnMultiply.call(m, n);
     });
 
@@ -1477,6 +1455,7 @@ define("pyret-base/js/js-numbers", function() {
   };
 
   Rational.makeInstance = function(n, d, errbacks) {
+    // console.log('doing rat.makeinst of', n, d);
     if (n === undefined)
       errbacks.throwUndefinedValue("n undefined", n, d);
 
@@ -2066,8 +2045,11 @@ define("pyret-base/js/js-numbers", function() {
 
   var scientificPattern = new RegExp("^([+-]?\\d*\\.?\\d*)[Ee]([+]?\\d+)$");
 
+  var genScientificPattern = new RegExp("^([+-]?\\d*\\.?\\d*)[Ee]([+-]?\\d+)$");
+
   // fromString: string -> (pyretnum | false)
   var fromString = function(x, errbacks) {
+    // console.log('doing fromString', x);
     if (x.match(digitRegexp)) {
       var n = Number(x);
       if (isOverflow(n)) {
@@ -2090,19 +2072,22 @@ define("pyret-base/js/js-numbers", function() {
       var beforeDecimalString = aMatch[2];
       var beforeDecimal = 0;
       if (beforeDecimalString !== '') {
-        beforeDecimal = makeBignum(beforeDecimalString);
+        beforeDecimal = fromString(beforeDecimalString);
       }
+      // console.log('beforeDecimal =', beforeDecimal);
       //
       var afterDecimalString = aMatch[3];
       var denominatorTen = 1;
       var afterDecimal = 0;
       if (afterDecimalString !== '') {
         afterDecimalString = afterDecimalString.substring(1);
-        denominatorTen = makeBignum('1' + new Array(afterDecimalString.length + 1).join('0'));
+        denominatorTen = fromString('1' + new Array(afterDecimalString.length + 1).join('0'));
         if (afterDecimalString !== '') {
-          afterDecimal = makeBignum(afterDecimalString);
+          afterDecimal = fromString(afterDecimalString);
         }
       }
+      // console.log('afterDecimal =', afterDecimal);
+      // console.log('denominatorTen =', denominatorTen);
       //
       var exponentString = aMatch[4];
       var exponentNegativeP = false;
@@ -2114,23 +2099,38 @@ define("pyret-base/js/js-numbers", function() {
         if (exponentSign === '-' || exponentSign === '+') {
           exponentString = exponentString.substring(1);
         }
-        exponent = makeBignum('1' + new Array(Number(exponentString) + 1).join('0'));
+        exponent = fromString('1' + new Array(Number(exponentString) + 1).join('0'));
       }
+      // console.log('exponent[40] =', exponent['40']);
 
       var finalDen = denominatorTen;
+      // console.log('calling _integerMultiply');
       var finalNum = _integerAdd(_integerMultiply(beforeDecimal, denominatorTen), afterDecimal);
+      // console.log('finalNum1 =', finalNum);
       if (negativeP) {
         finalNum = negate(finalNum, errbacks);
       }
+      // console.log('finalNum2 =', finalNum);
       //
       if (!equals(exponent, 1)) {
         if (exponentNegativeP) {
           finalDen = _integerMultiply(finalDen, exponent);
+          // finalDen = canonicalizeBignum(finalDen);
         } else {
           finalNum = _integerMultiply(finalNum, exponent);
+          // finalNum = canonicalizeBignum(finalNum);
         }
       }
-      return Rational.makeInstance(finalNum, finalDen, errbacks);
+      // console.log('finalNum3 =', finalNum);
+      // console.log('finalNum.40 =', finalNum['40']);
+      // console.log('finalDen =', finalDen);
+      var result;
+      if (finalDen === 1) {
+        result = finalNum;
+      } else {
+        result = Rational.makeInstance(finalNum, finalDen, errbacks);
+      }
+      return result;
     }
 
     aMatch = x.match(roughnumRatRegexp);
@@ -2418,6 +2418,7 @@ define("pyret-base/js/js-numbers", function() {
 
   // (public) Constructor
   function BigInteger(a,b,c) {
+    // console.log('doing BigInteger of', a, '(', a? a.length : 'x', ')', b,c);
     if(a != null)
       if("number" == typeof a) this.fromNumber(a,b,c);
     else if(b == null && "string" != typeof a) this.fromString(a,256);
@@ -3056,6 +3057,7 @@ define("pyret-base/js/js-numbers", function() {
 
   // (protected) alternate constructor
   function bnpFromNumber(a,b,c) {
+    // console.log('doing bnpFromNumber', a,b,c);
     if("number" == typeof b) {
       // new BigInteger(int,int,RNG)
       if(a < 2) this.fromInt(1);
@@ -3644,8 +3646,10 @@ define("pyret-base/js/js-numbers", function() {
 
   // makeBignum: string -> BigInteger
   var makeBignum = function(s) {
+    // console.log('doing makeBignum', s);
     if (typeof(s) === 'number') { s = s + ''; }
     s = expandExponent(s);
+    // console.log('s became', s, 'of length', s.length);
     return new BigInteger(s, 10);
   };
 

tests/jsnums-test/jsnums-test.js

@@ -0,0 +1,156 @@
+// 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: {
+    "trove": "../../" + build + "/trove",
+    "js": "../../" + build + "/js",
+    "compiler": "../../" + build + "/arr/compiler",
+    "jglr": "../../lib/jglr",
+    "pyret-base": "../../" + build
+  }
+});
+R(["pyret-base/js/js-numbers"], function(JN) {
+  var sampleErrorBacks = {
+    throwDomainError: function() { throw 'domainError'; },
+    throwLogNonPositive: function() { throw 'logNonPositive'; },
+  };
+  function test(actual, expected, testname, toks) {
+    if (actual === expected) {
+      return true;
+    } else {
+      var allToks = "Str was " + JSON.stringify(testname) + "\n";
+      for (var t = 0; t < toks.length; t++) {
+        if (t > 0) allToks += "\n";
+        allToks += "Tok[" + t + "] = " + toks[t].toString(true)
+          + " at pos " + toks[t].pos.toString(true);
+      }
+      allToks += "Expected " + JSON.stringify(expected) + ", but got " + JSON.stringify(actual)
+        + " in " + JSON.stringify(testname);
+      expect(allToks).toBe("");
+      return false;
+    }
+  }
+  function testPos(tok, expected, str, toks) {
+    if (tok.pos.endChar - tok.pos.startChar == expected.length) {
+      return true;
+    } else {
+      test(str.slice(tok.pos.startChar, tok.pos.endChar), expected, str, toks);
+      return false;
+    }
+  }
+  describe("check functions that don't allow testing via Pyret programs", function() {
+
+    it("fromString", function() {
+      expect(JN.fromString("5", sampleErrorBacks)).toEqual(5);
+
+      var bigIntStr = "1" + new Array(309 + 1).join("0"); // 1 followed by 309 0s
+      expect(JN.fromString(bigIntStr, sampleErrorBacks)).toEqual(JN.makeBignum(bigIntStr));
+
+      // console.log(JN.fromString("1e1", sampleErrorBacks));
+      // console.log(JN.fromString("10", sampleErrorBacks));
+      // console.log(JN.makeBignum("1e1", sampleErrorBacks));
+      // console.log(JN.makeBignum("10", sampleErrorBacks).toFixnum());
+
+      expect(JN.fromString("1e1", sampleErrorBacks)).toBe(10);
+      expect(JN.fromString("1e30", sampleErrorBacks)).toEqual(JN.makeBignum("1e30"));
+      expect(JN.fromString("1e140", sampleErrorBacks)).toEqual(JN.makeBignum("1e140"));
+
+      // for large bignums (> 1e140 ?), fromString() and makeBignum() can give structurally
+      // unequal results. so the following fail:
+      // expect(JN.fromString("1e141", sampleErrorBacks)).toEqual(JN.makeBignum("1e141"));
+      // expect(JN.fromString("1e307", sampleErrorBacks)).toEqual(JN.makeBignum("1e307"));
+      // expect(JN.fromString("1e309", sampleErrorBacks)).toEqual(JN.makeBignum("1e309"));
+
+      // but they're operationally equivalent!
+      expect(JN.equals(JN.fromString("1e141", sampleErrorBacks),
+        JN.makeBignum("1e141"),
+        sampleErrorBacks)).toBe(true);
+
+      // fromString() and makeBignum() give different but operationally same bignums
+      // console.log('*************************');
+      // console.log(JN.fromString("1e307", sampleErrorBacks));
+      // console.log('-------------------------');
+      // console.log(JN.makeBignum("1e307"));
+      // console.log('-------------------------');
+      // console.log(JN.multiply(1, JN.makeBignum("1e307"), sampleErrorBacks)['40']);
+      // console.log('*************************');
+
+      expect(JN.fromString("1e311", sampleErrorBacks)).toEqual(JN.makeBignum("1e311"));
+      expect(JN.fromString("1/2", sampleErrorBacks)).toEqual(JN.makeRational(1, 2));
+      expect(JN.fromString("355/113", sampleErrorBacks)).toEqual(JN.makeRational(355, 113));
+      expect(JN.fromString("1.5e3", sampleErrorBacks)).toEqual(1500);
+      expect(JN.fromString("~2.718281828", sampleErrorBacks)).toEqual(JN.makeRoughnum(2.718281828));
+      expect(JN.fromString("not-a-string", sampleErrorBacks)).toBe(false);
+
+    });
+
+    it("fromFixnum", function() {
+
+      expect(JN.fromFixnum(5, sampleErrorBacks)).toEqual(5);
+      expect(JN.fromFixnum(1/2, sampleErrorBacks)).toEqual(JN.makeRational(1, 2));
+      expect(JN.fromFixnum(1.5e3, sampleErrorBacks)).toEqual(1500);
+      expect(JN.fromFixnum(1e311, sampleErrorBacks)).toBe(false);
+
+    });
+
+    it("bnpExp", function() {
+      // BigInteger.*.expt calls bnPow, wch calls bnpExp
+      // shd raise exc for too-large
+      expect(function() { JN.makeBignum(2).expt(JN.makeBignum(0xffffffff + 1), sampleErrorBacks); }).toThrow('domainError');
+
+      // BigInteger.*.log
+      // shd raise exc for arg <= 0
+      expect(function() { JN.makeBignum(-1).log(sampleErrorBacks); }).toThrow('logNonPositive');
+    });
+
+    it("arithmetic", function() {
+
+    });
+
+    it("trig functions", function() {
+      // BigInteger.*asin
+      // shd raise exception for arg outside [-1, +1]
+      // but this is not testable via Pyret, because args are always sane
+      // by the time this method is called
+      expect(function() { JN.makeBignum(-1.5).asin(sampleErrorBacks); }).toThrow('domainError');
+      expect(function() { JN.makeBignum(+1.5).asin(sampleErrorBacks); }).toThrow('domainError');
+
+      // BigInteger.*acos
+      // shd raise exc for arg < -1 or > 1
+      expect(function() { JN.makeBignum(-1.5).acos(sampleErrorBacks); }).toThrow('domainError');
+      expect(function() { JN.makeBignum(+1.5).acos(sampleErrorBacks); }).toThrow('domainError');
+
+      // BigInteger.*.atan
+      // should work
+      expect(JN.makeBignum(0).atan(sampleErrorBacks)).toEqual(0);
+
+      // atan2 (perhaps Pyret test is enough)
+      expect(function () {
+        JN.atan2(JN.makeBignum(0), JN.makeBignum(0), sampleErrorBacks);
+      }).toThrow('domainError');
+
+      // BigInteger.*.sin
+      // should work
+      expect(JN.makeBignum(0).sin(sampleErrorBacks)).toEqual(0);
+
+      // BigInteger.*.cos
+      // should work
+      expect(JN.makeBignum(0).cos(sampleErrorBacks)).toEqual(1);
+
+      // BigInteger.*.tan
+      // should work
+      expect(JN.makeBignum(0).tan(sampleErrorBacks)).toEqual(0);
+
+
+    });
+  });
+
+  jazz.execute();
+
+});

tests/pyret/tests/test-json.arr

@@ -19,6 +19,9 @@ check "conversion":
   p('[5, null, {"hello": "world"}]') is
     J.j-arr([list: J.j-num(5), J.j-null,
       J.j-obj([SD.string-dict: "hello", J.j-str("world")])])
+
+  p('1E-7').native() is 1e-7
+  p('5E-19').native() is 5e-19
 end
 
 check "native":