Support minus zero

src/decimal128.mts

@@ -29,9 +29,10 @@ const bigZero = BigInt(0);
  *
  * + removing any initial zeros
  * + removing any trailing zeros
- * + rewriting -0 to 0
  * + rewriting 0.0 to 0
  *
+ * Sign is preserved. Thus, -0.0 (e.g.) gets normalized to -0.
+ *
  * @param s A digit string
  *
  * @example normalize("000123.456000") // => "123.456"
@@ -41,11 +42,7 @@ const bigZero = BigInt(0);
  */
 function normalize(s: string): string {
     if (s.match(/^-/)) {
-        let n = normalize(s.substring(1));
-        if ("0" === n) {
-            return "0";
-        }
-        return "-" + n;
+        return "-" + normalize(s.substring(1));
     }
 
     let a = s.replace(/^0+/, "");
@@ -467,6 +464,8 @@ export class Decimal128 {
                 BigInt((this.isNegative ? "-" : "") + this.significand + "0"),
                 bigOne
             );
+        } else if (this.significand === "") {
+            this.rat = new Rational(0n, 1n);
         } else {
             this.rat = new Rational(
                 BigInt((this.isNegative ? "-" : "") + this.significand),
@@ -483,6 +482,10 @@ export class Decimal128 {
             return "NaN";
         }
 
+        if (this.isZero()) {
+            return (this.isNegative ? "-" : "") + "0";
+        }
+
         return this.rat.toDecimalPlaces(MAX_SIGNIFICANT_DIGITS);
     }
 

tests/cmp.test.js

@@ -84,4 +84,21 @@ describe("many digits", () => {
             ).toStrictEqual(undefined);
         });
     });
+    describe("minus zero", () => {
+        test("left hand", () => {
+            expect(new Decimal128("-0").cmp(new Decimal128("0"))).toStrictEqual(
+                0
+            );
+        });
+        test("right hand", () => {
+            expect(new Decimal128("0").cmp(new Decimal128("-0"))).toStrictEqual(
+                0
+            );
+        });
+        test("both arguments", () => {
+            expect(
+                new Decimal128("-0").cmp(new Decimal128("-0"))
+            ).toStrictEqual(0);
+        });
+    });
 });

tests/constructor.test.js

@@ -153,6 +153,11 @@ describe("constructor", () => {
                 ).toString()
             ).toStrictEqual("0." + "1".repeat(MAX_SIGNIFICANT_DIGITS));
         });
+        test("minus zero", () => {
+            let minusZero = new Decimal128("-0");
+            expect(minusZero.toString()).toStrictEqual("-0");
+            expect(minusZero.isNegative).toStrictEqual(true);
+        });
     });
 
     describe("exponential string syntax", () => {
@@ -225,6 +230,7 @@ describe("exponent and significand", () => {
     let data = [
         ["123.456", "123456", -3],
         ["0", "", 0],
+        ["-0", "", 0],
         ["0.0", "", 0],
         ["5", "5", 0],
         ["-123.456", "123456", -3],

tests/negate.test.js

@@ -0,0 +1,20 @@
+import { Decimal128 } from "../src/decimal128.mjs";
+
+describe("negation", () => {
+    test("positive number", () => {
+        expect(new Decimal128("123.456").negate().toString()).toStrictEqual(
+            "-123.456"
+        );
+    });
+    test("negative number", () => {
+        expect(new Decimal128("-123.456").negate().toString()).toStrictEqual(
+            "123.456"
+        );
+    });
+    test("zero", () => {
+        expect(new Decimal128("0").negate().toString()).toStrictEqual("-0");
+    });
+    test("minus zero", () => {
+        expect(new Decimal128("-0").negate().toString()).toStrictEqual("0");
+    });
+});

tests/string.test.js

@@ -57,11 +57,11 @@ describe("normalization", () => {
         ["123.0", "123"],
         ["00.123", "0.123"],
         ["0.0", "0"],
-        ["-0.0", "0"],
+        ["-0.0", "-0"],
         ["00.0", "0"],
-        ["-00.0", "0"],
+        ["-00.0", "-0"],
         ["0.00", "0"],
-        ["-0.00", "0"],
+        ["-0.00", "-0"],
     ];
     for (let [a, b] of tests) {
         test(`${a} is actually ${b}`, () => {