Add buffer getters and setters to binary.js

[Pisces] / numeric.test.js

diff --git a/numeric.test.js b/numeric.test.js
index e82e04b88d6fc7b49086174143e9233d7254c391..4d3d2cb8616cdccacd4594935e80ba8c82e5469b 100644 (file)
--- a/numeric.test.js
+++ b/numeric.test.js
@@ -1,7 +1,7 @@
 // ♓🌟 Piscēs ∷ numeric.test.js
 // ====================================================================
 //
 // ♓🌟 Piscēs ∷ numeric.test.js
 // ====================================================================
 //

-// Copyright © 2022 Lady [@ Lady’s Computer].
+// Copyright © 2022–2023 Lady [@ Lady’s Computer].

 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this


@@ -19,15 +19,33 @@ import {
   clz32,
   max,
   min,
   clz32,
   max,
   min,

+  NEGATIVE_ZERO,
+  POSITIVE_ZERO,

   sgn,
   toBigInt,
   sgn,
   toBigInt,

+  toExponentialNotation,
+  toFixedDecimalNotation,

   toFloat32,
   toFloat32,

-  toIntN,
+  toIntegralNumber,
+  toIntegralNumberOrInfinity,

   toNumber,
   toNumeric,
   toNumber,
   toNumeric,

-  toUintN,
+  toSignedIntegralNumeric,
+  toUnsignedIntegralNumeric,

 } from "./numeric.js";
 
 } from "./numeric.js";
 

+describe("NEGATIVE_ZERO", () => {
+  it("[[Get]] is negative zero", () => {
+    assertStrictEquals(NEGATIVE_ZERO, -0);
+  });
+});
+
+describe("POSITIVE_ZERO", () => {
+  it("[[Get]] is positive zero", () => {
+    assertStrictEquals(POSITIVE_ZERO, 0);
+  });
+});
+

 describe("abs", () => {
   it("[[Call]] returns the absolute value", () => {
     assertStrictEquals(abs(-1), 1);
 describe("abs", () => {
   it("[[Call]] returns the absolute value", () => {
     assertStrictEquals(abs(-1), 1);


@@ -125,6 +143,53 @@ describe("toBigInt", () => {
   });
 });
 
   });
 });
 

+describe("toExponentialNotation", () => {
+  it("[[Call]] converts to exponential notation", () => {
+    assertStrictEquals(toExponentialNotation(231), "2.31e+2");
+  });
+
+  it("[[Call]] works with big·ints", () => {
+    assertStrictEquals(
+      toExponentialNotation(9007199254740993n),
+      "9.007199254740993e+15",
+    );
+  });
+
+  it("[[Call]] respects the specified number of fractional digits", () => {
+    assertStrictEquals(
+      toExponentialNotation(.00000000642, 3),
+      "6.420e-9",
+    );
+    assertStrictEquals(toExponentialNotation(.00691, 1), "6.9e-3");
+    assertStrictEquals(toExponentialNotation(.00685, 1), "6.9e-3");
+    assertStrictEquals(toExponentialNotation(.004199, 2), "4.20e-3");
+    assertStrictEquals(
+      toExponentialNotation(6420000000n, 3),
+      "6.420e+9",
+    );
+    assertStrictEquals(toExponentialNotation(6910n, 1), "6.9e+3");
+    assertStrictEquals(toExponentialNotation(6850n, 1), "6.9e+3");
+    assertStrictEquals(toExponentialNotation(4199n, 2), "4.20e+3");
+  });
+});
+
+describe("toFixedDecimalNotation", () => {
+  it("[[Call]] converts to fixed decimal notation", () => {
+    assertStrictEquals(toFixedDecimalNotation(69.4199, 3), "69.420");
+  });
+
+  it("[[Call]] works with big·ints", () => {
+    assertStrictEquals(
+      toFixedDecimalNotation(9007199254740993n),
+      "9007199254740993",
+    );
+    assertStrictEquals(
+      toFixedDecimalNotation(9007199254740993n, 2),
+      "9007199254740993.00",
+    );
+  });
+});
+

 describe("toFloat32", () => {
   it("[[Call]] returns the 32‐bit floating‐point representation", () => {
     assertStrictEquals(
 describe("toFloat32", () => {
   it("[[Call]] returns the 32‐bit floating‐point representation", () => {
     assertStrictEquals(


@@ -141,13 +206,73 @@ describe("toFloat32", () => {
   });
 });
 
   });
 });
 

-describe("toIntN", () => {
+describe("toSignedIntegralNumeric", () => {

   it("[[Call]] converts to an int·n", () => {
   it("[[Call]] converts to an int·n", () => {

-    assertStrictEquals(toIntN(2, 7n), -1n);
+    assertStrictEquals(toSignedIntegralNumeric(2, 7n), -1n);

   });
 
   it("[[Call]] works with numbers", () => {
   });
 
   it("[[Call]] works with numbers", () => {

-    assertStrictEquals(toIntN(2, 7), -1);
+    assertStrictEquals(toSignedIntegralNumeric(2, 7), -1);
+  });
+
+  it("[[Call]] works with non‐integers", () => {
+    assertStrictEquals(toSignedIntegralNumeric(2, 7.21), -1);
+    assertStrictEquals(toSignedIntegralNumeric(2, Infinity), 0);
+  });
+});
+
+describe("toIntegralNumber", () => {
+  it("[[Call]] converts nan to zero", () => {
+    assertStrictEquals(toIntegralNumber(NaN), 0);
+  });
+
+  it("[[Call]] converts negative zero to positive zero", () => {
+    assertStrictEquals(toIntegralNumber(-0), 0);
+  });
+
+  it("[[Call]] drops the fractional part of negative numbers", () => {
+    assertStrictEquals(toIntegralNumber(-1.79), -1);
+  });
+
+  it("[[Call]] returns zero for infinity", () => {
+    assertStrictEquals(toIntegralNumber(Infinity), 0);
+  });
+
+  it("[[Call]] returns zero for negative infinity", () => {
+    assertStrictEquals(toIntegralNumber(-Infinity), 0);
+  });
+
+  it("[[Call]] works with big·ints", () => {
+    assertStrictEquals(toIntegralNumber(2n), 2);
+  });
+});
+
+describe("toIntegralNumberOrInfinity", () => {
+  it("[[Call]] converts nan to zero", () => {
+    assertStrictEquals(toIntegralNumberOrInfinity(NaN), 0);
+  });
+
+  it("[[Call]] converts negative zero to positive zero", () => {
+    assertStrictEquals(toIntegralNumberOrInfinity(-0), 0);
+  });
+
+  it("[[Call]] drops the fractional part of negative numbers", () => {
+    assertStrictEquals(toIntegralNumberOrInfinity(-1.79), -1);
+  });
+
+  it("[[Call]] returns infinity for infinity", () => {
+    assertStrictEquals(toIntegralNumberOrInfinity(Infinity), Infinity);
+  });
+
+  it("[[Call]] returns negative infinity for negative infinity", () => {
+    assertStrictEquals(
+      toIntegralNumberOrInfinity(-Infinity),
+      -Infinity,
+    );
+  });
+
+  it("[[Call]] works with big·ints", () => {
+    assertStrictEquals(toIntegralNumberOrInfinity(2n), 2);

   });
 });
 
   });
 });
 


@@ -181,12 +306,17 @@ describe("toNumeric", () => {
   });
 });
 
   });
 });
 

-describe("toUintN", () => {
+describe("toUnsignedIntegralNumeric", () => {

   it("[[Call]] converts to an int·n", () => {
   it("[[Call]] converts to an int·n", () => {

-    assertStrictEquals(toUintN(2, 7n), 3n);
+    assertStrictEquals(toUnsignedIntegralNumeric(2, 7n), 3n);

   });
 
   it("[[Call]] works with numbers", () => {
   });
 
   it("[[Call]] works with numbers", () => {

-    assertStrictEquals(toUintN(2, 7), 3);
+    assertStrictEquals(toUnsignedIntegralNumeric(2, 7), 3);
+  });
+
+  it("[[Call]] works with non‐integers", () => {
+    assertStrictEquals(toUnsignedIntegralNumeric(2, 7.21), 3);
+    assertStrictEquals(toUnsignedIntegralNumeric(2, Infinity), 0);

   });
 });
   });
 });