Merge branches/quickjs to trunk. This is the way.

git-svn-id: https://www.unprompted.com/svn/projects/tildefriends/trunk@3621 ed5197a5-7fde-0310-b194-c3ffbd925b24
2021-01-02 18:10:00 +00:00
parent d293637741
commit 79022e1e1f
703 changed files with 419987 additions and 30640 deletions
--- a/deps/quickjs/tests/test_bignum.js
+++ b/deps/quickjs/tests/test_bignum.js
@ -1,4 +1,3 @@
-"use math";
 "use strict";

 function assert(actual, expected, message) {
@ -18,48 +17,104 @@ function assert(actual, expected, message) {
                (message ? " (" + message + ")" : ""));
 }

+function assertThrows(err, func)
+{
+    var ex;
+    ex = false;
+    try {
+        func();
+    } catch(e) {
+        ex = true;
+        assert(e instanceof err);
+    }
+    assert(ex, true, "exception expected");
+}
+
 // load more elaborate version of assert if available
 try { __loadScript("test_assert.js"); } catch(e) {}

 /*----------------*/

-function pow(a, n)
+function bigint_pow(a, n)
 {
    var r, i;
-    r = 1;
-    for(i = 0; i < n; i++)
+    r = 1n;
+    for(i = 0n; i < n; i++)
        r *= a;
    return r;
 }

-function test_integer()
+/* a must be < b */
+function test_less(a, b)
+{
+    assert(a < b);
+    assert(!(b < a));
+    assert(a <= b);
+    assert(!(b <= a));
+    assert(b > a);
+    assert(!(a > b));
+    assert(b >= a);
+    assert(!(a >= b));
+    assert(a != b);
+    assert(!(a == b));
+}
+
+/* a must be numerically equal to b */
+function test_eq(a, b)
+{
+    assert(a == b);
+    assert(b == a);
+    assert(!(a != b));
+    assert(!(b != a));
+    assert(a <= b);
+    assert(b <= a);
+    assert(!(a < b));
+    assert(a >= b);
+    assert(b >= a);
+    assert(!(a > b));
+}
+
+function test_bigint1()
 {
    var a, r;
-    a = pow(3, 100);
-    assert((a - 1) != a);
-    assert(a == 515377520732011331036461129765621272702107522001);
-    assert(a == 0x5a4653ca673768565b41f775d6947d55cf3813d1);
-    assert(Integer.isInteger(1) === true);
-    assert(Integer.isInteger(1.0) === false);

-    assert(Integer.floorLog2(0) === -1);
-    assert(Integer.floorLog2(7) === 2);
+    test_less(2n, 3n);
+    test_eq(3n, 3n);

-    r = 1 << 31;
-    assert(r, 2147483648, "1 << 31 === 2147483648");
+    test_less(2, 3n);
+    test_eq(3, 3n);
+
+    test_less(2.1, 3n);
+    test_eq(Math.sqrt(4), 2n);
+
+    a = bigint_pow(3n, 100n);
+    assert((a - 1n) != a);
+    assert(a == 515377520732011331036461129765621272702107522001n);
+    assert(a == 0x5a4653ca673768565b41f775d6947d55cf3813d1n);
+
+    r = 1n << 31n;
+    assert(r, 2147483648n, "1 << 31n === 2147483648n");
    
-    r = 1 << 32;
-    assert(r, 4294967296, "1 << 32 === 4294967296");
-    
-    r = (1 << 31) < 0;
-    assert(r, false, "(1 << 31) < 0 === false");
+    r = 1n << 32n;
+    assert(r, 4294967296n, "1 << 32n === 4294967296n");
+}
+
+function test_bigint2()
+{
+    assert(BigInt(""), 0n);
+    assert(BigInt("  123"), 123n);
+    assert(BigInt("  123   "), 123n);
+    assertThrows(SyntaxError, () => { BigInt("+") } );
+    assertThrows(SyntaxError, () => { BigInt("-") } );
+    assertThrows(SyntaxError, () => { BigInt("\x00a") } );
+    assertThrows(SyntaxError, () => { BigInt("  123  r") } );
 }

 function test_divrem(div1, a, b, q)
 {
    var div, divrem, t;
-    div = Integer[div1];
-    divrem = Integer[div1 + "rem"];
+    div = BigInt[div1];
+    divrem = BigInt[div1 + "rem"];
    assert(div(a, b) == q);
    t = divrem(a, b);
    assert(t[0] == q);
@ -74,196 +129,198 @@ function test_idiv1(div, a, b, r)
    test_divrem(div, -a, -b, r[3]);
 }

-function test_idiv()
+/* QuickJS BigInt extensions */
+function test_bigint_ext()
 {
-    test_idiv1("tdiv", 3, 2, [1, -1, -1, 1]);
-    test_idiv1("fdiv", 3, 2, [1, -2, -2, 1]);
-    test_idiv1("cdiv", 3, 2, [2, -1, -1, 2]);
-    test_idiv1("ediv", 3, 2, [1, -2, -1, 2]);
+    var r;
+    assert(BigInt.floorLog2(0n) === -1n);
+    assert(BigInt.floorLog2(7n) === 2n);
+
+    assert(BigInt.sqrt(0xffffffc000000000000000n) === 17592185913343n);
+    r = BigInt.sqrtrem(0xffffffc000000000000000n);
+    assert(r[0] === 17592185913343n);
+    assert(r[1] === 35167191957503n);
+
+    test_idiv1("tdiv", 3n, 2n, [1n, -1n, -1n, 1n]);
+    test_idiv1("fdiv", 3n, 2n, [1n, -2n, -2n, 1n]);
+    test_idiv1("cdiv", 3n, 2n, [2n, -1n, -1n, 2n]);
+    test_idiv1("ediv", 3n, 2n, [1n, -2n, -1n, 2n]);
 }

-function test_float()
+function test_bigfloat()
 {
    var e, a, b, sqrt2;
    
-    assert(typeof 1 === "bigint");
-    assert(typeof 1.0 === "bigfloat");
-    assert(1 == 1.0);
-    assert(1 !== 1.0);
+    assert(typeof 1n === "bigint");
+    assert(typeof 1l === "bigfloat");
+    assert(1 == 1.0l);
+    assert(1 !== 1.0l);
+
+    test_less(2l, 3l);
+    test_eq(3l, 3l);
+
+    test_less(2, 3l);
+    test_eq(3, 3l);
+
+    test_less(2.1, 3l);
+    test_eq(Math.sqrt(9), 3l);
    
+    test_less(2n, 3l);
+    test_eq(3n, 3l);
+
    e = new BigFloatEnv(128);
    assert(e.prec == 128);
-    a = BigFloat.sqrt(2, e);
-    assert(a == BigFloat.parseFloat("0x1.6a09e667f3bcc908b2fb1366ea957d3e", 0, e));
+    a = BigFloat.sqrt(2l, e);
+    assert(a === BigFloat.parseFloat("0x1.6a09e667f3bcc908b2fb1366ea957d3e", 0, e));
    assert(e.inexact === true);
-    assert(BigFloat.fpRound(a) == 0x1.6a09e667f3bcd);
+    assert(BigFloat.fpRound(a) == 0x1.6a09e667f3bcc908b2fb1366ea95l);
    
    b = BigFloatEnv.setPrec(BigFloat.sqrt.bind(null, 2), 128);
-    assert(a == b);
-}
+    assert(a === b);

-/* jscalc tests */
+    assert(BigFloat.isNaN(BigFloat(NaN)));
+    assert(BigFloat.isFinite(1l));
+    assert(!BigFloat.isFinite(1l/0l));

-function test_modulo()
-{
-    var i, p, a, b;
+    assert(BigFloat.abs(-3l) === 3l);
+    assert(BigFloat.sign(-3l) === -1l);

-    /* Euclidian modulo operator */
-    assert((-3) % 2 == 1);
-    assert(3 % (-2) == 1);
-
-    p = 101;
-    for(i = 1; i < p; i++) {
-        a = Integer.invmod(i, p);
-        assert(a >= 0 && a < p);
-        assert((i * a) % p == 1);
-    }
-
-    assert(Integer.isPrime(2^107-1));
-    assert(!Integer.isPrime((2^107-1) * (2^89-1)));
-    a = Integer.factor((2^89-1)*2^3*11*13^2*1009);
-    assert(a == [ 2,2,2,11,13,13,1009,618970019642690137449562111 ]);
-}
-
-function test_mod()
-{
-    var a, b, p;
+    assert(BigFloat.exp(0.2l) === 1.2214027581601698339210719946396742l);
+    assert(BigFloat.log(3l) === 1.0986122886681096913952452369225256l);
+    assert(BigFloat.pow(2.1l, 1.6l) === 3.277561666451861947162828744873745l);
    
-    a = Mod(3, 101);
-    b = Mod(-1, 101);
-    assert((a + b) == Mod(2, 101));
-    assert(a ^ 100 == Mod(1, 101));
+    assert(BigFloat.sin(-1l) === -0.841470984807896506652502321630299l);
+    assert(BigFloat.cos(1l) === 0.5403023058681397174009366074429766l);
+    assert(BigFloat.tan(0.1l) === 0.10033467208545054505808004578111154l);

-    p = 2 ^ 607 - 1; /* mersenne prime */
-    a = Mod(3, p) ^ (p - 1);
-    assert(a == Mod(1, p));
+    assert(BigFloat.asin(0.3l) === 0.30469265401539750797200296122752915l);
+    assert(BigFloat.acos(0.4l) === 1.1592794807274085998465837940224159l);
+    assert(BigFloat.atan(0.7l) === 0.610725964389208616543758876490236l);
+    assert(BigFloat.atan2(7.1l, -5.1l) === 2.1937053809751415549388104628759813l);
+
+    assert(BigFloat.floor(2.5l) === 2l);
+    assert(BigFloat.ceil(2.5l) === 3l);
+    assert(BigFloat.trunc(-2.5l) === -2l);
+    assert(BigFloat.round(2.5l) === 3l);
+
+    assert(BigFloat.fmod(3l,2l) === 1l);
+    assert(BigFloat.remainder(3l,2l) === -1l);
+
+    /* string conversion */
+    assert((1234.125l).toString(), "1234.125");
+    assert((1234.125l).toFixed(2), "1234.13");
+    assert((1234.125l).toFixed(2, "down"), "1234.12");
+    assert((1234.125l).toExponential(), "1.234125e+3");
+    assert((1234.125l).toExponential(5), "1.23413e+3");
+    assert((1234.125l).toExponential(5, BigFloatEnv.RNDZ), "1.23412e+3");
+    assert((1234.125l).toPrecision(6), "1234.13");
+    assert((1234.125l).toPrecision(6, BigFloatEnv.RNDZ), "1234.12");
+
+    /* string conversion with binary base */
+    assert((0x123.438l).toString(16), "123.438");
+    assert((0x323.438l).toString(16), "323.438");
+    assert((0x723.438l).toString(16), "723.438");
+    assert((0xf23.438l).toString(16), "f23.438");
+    assert((0x123.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "123.44");
+    assert((0x323.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "323.44");
+    assert((0x723.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "723.44");
+    assert((0xf23.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "f23.44");
+    assert((0x0.0000438l).toFixed(6, BigFloatEnv.RNDNA, 16), "0.000044");
+    assert((0x1230000000l).toFixed(1, BigFloatEnv.RNDNA, 16), "1230000000.0");
+    assert((0x123.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "123.44");
+    assert((0x123.438l).toPrecision(5, BigFloatEnv.RNDZ, 16), "123.43");
+    assert((0x323.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "323.44");
+    assert((0x723.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "723.44");
+    assert((-0xf23.438l).toPrecision(5, BigFloatEnv.RNDD, 16), "-f23.44");
+    assert((0x123.438l).toExponential(4, BigFloatEnv.RNDNA, 16), "1.2344p+8");
 }

-function test_polynomial()
+function test_bigdecimal()
 {
-    var a, b, q, r, t, i;
-    a = (1 + X) ^ 4;
-    assert(a == X^4+4*X^3+6*X^2+4*X+1);
+    assert(1m === 1m);
+    assert(1m !== 2m);
+    test_less(1m, 2m);
+    test_eq(2m, 2m);
    
-    r = (1 + X);
-    q = (1+X+X^2);
-    b = (1 - X^2);
-    a = q * b + r;
-    t = Polynomial.divrem(a, b);
-    assert(t[0] == q);
-    assert(t[1] == r);
+    test_less(1, 2m);
+    test_eq(2, 2m);

-    a = 1 + 2*X + 3*X^2;
-    assert(a.apply(0.1) == 1.23);
+    test_less(1.1, 2m);
+    test_eq(Math.sqrt(4), 2m);
+    
+    test_less(2n, 3m);
+    test_eq(3n, 3m);
+    
+    assert(BigDecimal("1234.1") === 1234.1m);
+    assert(BigDecimal("    1234.1") === 1234.1m);
+    assert(BigDecimal("    1234.1  ") === 1234.1m);

-    a = 1-2*X^2+2*X^3;
-    assert(deriv(a) == (6*X^2-4*X));
-    assert(deriv(integ(a)) == a);
+    assert(BigDecimal(0.1) === 0.1m);
+    assert(BigDecimal(123) === 123m);
+    assert(BigDecimal(true) === 1m);

-    a = (X-1)*(X-2)*(X-3)*(X-4)*(X-0.1);
-    r = polroots(a);
-    for(i = 0; i < r.length; i++) {
-        b = abs(a.apply(r[i]));
-        assert(b <= 1e-13);
-    }
+    assert(123m + 1m === 124m);
+    assert(123m - 1m === 122m);
+
+    assert(3.2m * 3m === 9.6m);
+    assert(10m / 2m === 5m);
+    assertThrows(RangeError, () => { 10m / 3m } );
+
+    assert(10m % 3m === 1m);
+    assert(-10m % 3m === -1m);
+
+    assert(1234.5m ** 3m === 1881365963.625m);
+    assertThrows(RangeError, () => { 2m ** 3.1m } );
+    assertThrows(RangeError, () => { 2m ** -3m } );
+    
+    assert(BigDecimal.sqrt(2m,
+                       { roundingMode: "half-even",
+                         maximumSignificantDigits: 4 }) === 1.414m);
+    assert(BigDecimal.sqrt(101m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 3 }) === 10.050m);
+    assert(BigDecimal.sqrt(0.002m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 3 }) === 0.045m);
+    
+    assert(BigDecimal.round(3.14159m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 3 }) === 3.142m);
+
+    assert(BigDecimal.add(3.14159m, 0.31212m,
+                          { roundingMode: "half-even",
+                            maximumFractionDigits: 2 }) === 3.45m);
+    assert(BigDecimal.sub(3.14159m, 0.31212m,
+                          { roundingMode: "down",
+                            maximumFractionDigits: 2 }) === 2.82m);
+    assert(BigDecimal.mul(3.14159m, 0.31212m,
+                          { roundingMode: "half-even",
+                            maximumFractionDigits: 3 }) === 0.981m);
+    assert(BigDecimal.mod(3.14159m, 0.31211m,
+                          { roundingMode: "half-even",
+                            maximumFractionDigits: 4 }) === 0.0205m);
+    assert(BigDecimal.div(20m, 3m,
+                       { roundingMode: "half-even",
+                         maximumSignificantDigits: 3 }) === 6.67m);
+    assert(BigDecimal.div(20m, 3m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 50 }) ===
+           6.66666666666666666666666666666666666666666666666667m);
+
+    /* string conversion */
+    assert((1234.125m).toString(), "1234.125");
+    assert((1234.125m).toFixed(2), "1234.13");
+    assert((1234.125m).toFixed(2, "down"), "1234.12");
+    assert((1234.125m).toExponential(), "1.234125e+3");
+    assert((1234.125m).toExponential(5), "1.23413e+3");
+    assert((1234.125m).toExponential(5, "down"), "1.23412e+3");
+    assert((1234.125m).toPrecision(6), "1234.13");
+    assert((1234.125m).toPrecision(6, "down"), "1234.12");
+    assert((-1234.125m).toPrecision(6, "floor"), "-1234.13");
 }

-function test_poly_mod()
-{
-    var a, p;
-
-    /* modulo using polynomials */
-    p = X^2 + X + 1;
-    a = PolyMod(3+X, p) ^ 10;
-    assert(a == PolyMod(-3725*X-18357, p));
-
-    a = PolyMod(1/X, 1+X^2);
-    assert(a == PolyMod(-X, X^2+1));
-}
-
-function test_rfunc()
-{
-    var a;
-    a = (X+1)/((X+1)*(X-1));
-    assert(a == 1/(X-1));
-    a = (X + 2) / (X - 2);
-    assert(a.apply(1/3) == -7/5);
-
-    assert(deriv((X^2-X+1)/(X-1)) == (X^2-2*X)/(X^2-2*X+1));
-}
-
-function test_series()
-{
-    var a, b;
-    a = 1+X+O(X^5);
-    b = a.inverse();
-    assert(b == 1-X+X^2-X^3+X^4+O(X^5));
-    assert(deriv(b) == -1+2*X-3*X^2+4*X^3+O(X^4));
-    assert(deriv(integ(b)) == b);
-
-    a = Series(1/(1-X), 5);
-    assert(a == 1+X+X^2+X^3+X^4+O(X^5));
-    b = a.apply(0.1);
-    assert(b == 1.1111);
-
-    assert(exp(3*X^2+O(X^10)) == 1+3*X^2+9/2*X^4+9/2*X^6+27/8*X^8+O(X^10));
-    assert(sin(X+O(X^6)) == X-1/6*X^3+1/120*X^5+O(X^6));
-    assert(cos(X+O(X^6)) == 1-1/2*X^2+1/24*X^4+O(X^6));
-    assert(tan(X+O(X^8)) == X+1/3*X^3+2/15*X^5+17/315*X^7+O(X^8));
-    assert((1+X+O(X^6))^(2+X) == 1+2*X+2*X^2+3/2*X^3+5/6*X^4+5/12*X^5+O(X^6));
-}
-
-function test_matrix()
-{
-    var a, b, r;
-    a = [[1, 2],[3, 4]];
-    b = [3, 4];
-    r = a * b;
-    assert(r == [11, 25]);
-    r = (a^-1) * 2;
-    assert(r == [[-4, 2],[3, -1]]);
-
-    assert(norm2([1,2,3]) == 14);
-
-    assert(diag([1,2,3]) == [ [ 1, 0, 0 ], [ 0, 2, 0 ], [ 0, 0, 3 ] ]);
-    assert(trans(a) == [ [ 1, 3 ], [ 2, 4 ] ]);
-    assert(trans([1,2,3]) == [[1,2,3]]);
-    assert(trace(a) == 5);
-
-    assert(charpoly(Matrix.hilbert(4)) == X^4-176/105*X^3+3341/12600*X^2-41/23625*X+1/6048000);
-    assert(det(Matrix.hilbert(4)) == 1/6048000);
-
-    a = [[1,2,1],[-2,-3,1],[3,5,0]];
-    assert(rank(a) == 2);
-    assert(ker(a) == [ [ 5 ], [ -3 ], [ 1 ] ]);
-
-    assert(dp([1, 2, 3], [3, -4, -7]) === -26);
-    assert(cp([1, 2, 3], [3, -4, -7]) == [ -2, 16, -10 ]);
-}
-
-function assert_eq(a, ref)
-{
-    assert(abs(a / ref - 1.0) <= 1e-15);
-}
-
-function test_trig()
-{
-    assert_eq(sin(1/2), 0.479425538604203);
-    assert_eq(sin(2+3*I), 9.154499146911428-4.168906959966565*I);
-    assert_eq(cos(2+3*I), -4.189625690968807-9.109227893755337*I);
-    assert_eq((2+0.5*I)^(1.1-0.5*I), 2.494363021357619-0.23076804554558092*I);
-    assert_eq(sqrt(2*I), 1 + I);
-}
-
-test_integer();
-test_idiv();
-test_float();
-
-test_modulo();
-test_mod();
-test_polynomial();
-test_poly_mod();
-test_rfunc();
-test_series();
-test_matrix();
-test_trig();
+test_bigint1();
+test_bigint2();
+test_bigint_ext();
+test_bigfloat();
+test_bigdecimal();