Comprehensive jsnum tests

src/js/base/js-numbers.js

@@ -1201,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);
     });
 
@@ -1453,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);
 
@@ -2046,6 +2049,7 @@ define("pyret-base/js/js-numbers", function() {
 
   // 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)) {
@@ -2070,6 +2074,7 @@ define("pyret-base/js/js-numbers", function() {
       if (beforeDecimalString !== '') {
         beforeDecimal = fromString(beforeDecimalString);
       }
+      // console.log('beforeDecimal =', beforeDecimal);
       //
       var afterDecimalString = aMatch[3];
       var denominatorTen = 1;
@@ -2081,6 +2086,8 @@ define("pyret-base/js/js-numbers", function() {
           afterDecimal = fromString(afterDecimalString);
         }
       }
+      // console.log('afterDecimal =', afterDecimal);
+      // console.log('denominatorTen =', denominatorTen);
       //
       var exponentString = aMatch[4];
       var exponentNegativeP = false;
@@ -2094,21 +2101,36 @@ define("pyret-base/js/js-numbers", function() {
         }
         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);
@@ -2396,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);
@@ -3034,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);
@@ -3622,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

@@ -44,22 +44,84 @@ R(["pyret-base/js/js-numbers"], function(JN) {
       return false;
     }
   }
-  describe("check exceptions in js-numbers methods that can't be tested in Pyret", function() {
+  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 
+      // shd raise exc for too-large
       expect(function() { JN.makeBignum(2).expt(JN.makeBignum(0xffffffff + 1), sampleErrorBacks); }).toThrow('domainError');
 
-      // BigInteger.*.log 
+      // BigInteger.*.log
       // shd raise exc for arg <= 0
       expect(function() { JN.makeBignum(-1).log(sampleErrorBacks); }).toThrow('logNonPositive');
+    });
 
-      // BigInteger.*asin 
-      // shd raise exc for arg < -1 or > 1
+    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 
+      // 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');
@@ -68,6 +130,11 @@ R(["pyret-base/js/js-numbers"], function(JN) {
       // 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);