Support conversions to/from BigInt and Number (#108)

* Convert to BigInt and Number

* Make constructor work with all Numbers

Author: jessealama

CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [14.1.0] - 2024-05-06
+
+### Added
+
+-   Support for converting decimals to BigInts (`toBigInt`) and Numbers (`toNumber`).
+-   Relax the constructor to allow all Number arguments (in addition to BigInts and strings).
+
 ## [14.0.0] - 2024-04-30
 
 ### Removed

src/decimal128.mts

@@ -668,15 +668,6 @@ const DEFAULT_CONSTRUCTOR_OPTIONS: FullySpecifiedConstructorOptions =
         normalize: CONSTRUCTOR_SHOULD_NORMALIZE,
     });
 
-interface FullySpecifiedArithmeticOperationOptions {
-    roundingMode: RoundingMode;
-}
-
-const DEFAULT_ARITHMETIC_OPERATION_OPTIONS: FullySpecifiedArithmeticOperationOptions =
-    Object.freeze({
-        roundingMode: ROUNDING_MODE_DEFAULT,
-    });
-
 type ToStringFormat = "decimal" | "exponential";
 const TOSTRING_FORMATS: string[] = ["decimal", "exponential"];
 
@@ -799,16 +790,7 @@ export class Decimal128 {
             ensureFullySpecifiedConstructorOptions(options);
 
         if ("number" === typeof n) {
-            if (!Number.isInteger(n)) {
-                throw new SyntaxError("Non-integer number not permitted");
-            }
-            if (!Number.isSafeInteger(n)) {
-                throw new RangeError(
-                    "Integer is too large to be exactly represented"
-                );
-            }
-
-            s = n.toString();
+            s = Object.is(n, -0) ? "-0" : n.toString();
         } else if ("bigint" === typeof n) {
             s = n.toString();
         } else {
@@ -938,6 +920,52 @@ export class Decimal128 {
         return this.emitDecimal(options);
     }
 
+    private isInteger(): boolean {
+        let s = this.toString();
+
+        let [_, rhs] = s.split(/[.]/);
+
+        if (rhs === undefined) {
+            return true;
+        }
+
+        return !!rhs.match(/^0+$/);
+    }
+
+    toBigInt(): bigint {
+        if (this.isNaN) {
+            throw new RangeError("NaN cannot be converted to a BigInt");
+        }
+
+        if (!this.isFinite) {
+            throw new RangeError("Infinity cannot be converted to a BigInt");
+        }
+
+        if (!this.isInteger()) {
+            throw new RangeError(
+                "Non-integer decimal cannot be converted to a BigInt"
+            );
+        }
+
+        return BigInt(this.toString());
+    }
+
+    toNumber(): number {
+        if (this.isNaN) {
+            return NaN;
+        }
+
+        if (!this.isFinite) {
+            if (this.isNegative) {
+                return -Infinity;
+            }
+
+            return Infinity;
+        }
+
+        return Number(this.toString());
+    }
+
     /**
      * Compare two values. Return
      *

tests/constructor.test.js

@@ -587,18 +587,18 @@ describe("number arguments", () => {
         expect(new Decimal128(42).toString()).toStrictEqual("42");
     });
     test("non-integer number", () => {
-        expect(() => new Decimal128(42.5)).toThrow(SyntaxError);
+        expect(new Decimal128(42.5).toString()).toStrictEqual("42.5");
     });
     test("NaN", () => {
-        expect(() => new Decimal128(NaN)).toThrow(SyntaxError);
+        expect(new Decimal128(NaN).toString()).toStrictEqual("NaN");
     });
     test("minus zero", () => {
-        expect(new Decimal128(-0).toString()).toStrictEqual("0");
+        expect(new Decimal128(-0).toString()).toStrictEqual("-0");
     });
-    test("too big", () => {
+    test("very large value gets approximated", () => {
         expect(
-            () => new Decimal128(123456789012345678901234567890123456789)
-        ).toThrow(RangeError);
+            new Decimal128(123456789012345678901234567890123456789).toString()
+        ).toStrictEqual("123456789012345680000000000000000000000");
     });
 });
 

tests/tobigint.test.js

@@ -0,0 +1,46 @@
+import { Decimal128 } from "../src/decimal128.mjs";
+import { expectDecimal128 } from "./util.js";
+
+describe("NaN", () => {
+    test("does not work", () => {
+        expect(() => new Decimal128("NaN").toBigInt()).toThrow(RangeError);
+    });
+});
+
+describe("zero", () => {
+    test("positive zero", () => {
+        expect(new Decimal128("0").toBigInt()).toStrictEqual(0n);
+    });
+    test("negative zero", () => {
+        expect(new Decimal128("-0").toBigInt()).toStrictEqual(0n);
+    });
+});
+
+describe("infinity", () => {
+    test("positive", () => {
+        expect(() => new Decimal128("Infinity").toBigInt()).toThrow(RangeError);
+    });
+    test("negative", () => {
+        expect(() => new Decimal128("-Infinity").toBigInt()).toThrow(
+            RangeError
+        );
+    });
+});
+
+describe("non-integer", () => {
+    test("throws", () => {
+        expect(() => new Decimal128("1.2").toBigInt()).toThrow(RangeError);
+    });
+    test("work with mathematical value (ignore trailing zeroes)", () => {
+        expect(new Decimal128("1.00").toBigInt()).toStrictEqual(1n);
+    });
+});
+
+describe("simple examples", () => {
+    test("42", () => {
+        expect(new Decimal128("42").toBigInt()).toStrictEqual(42n);
+    });
+    test("-123", () => {
+        expect(new Decimal128("-123").toBigInt()).toStrictEqual(-123n);
+    });
+});

tests/tonumber.test.js

@@ -0,0 +1,40 @@
+import { Decimal128 } from "../src/decimal128.mjs";
+import { expectDecimal128 } from "./util.js";
+
+describe("NaN", () => {
+    test("works", () => {
+        expect(new Decimal128("NaN").toNumber()).toStrictEqual(NaN);
+    });
+});
+
+describe("zero", () => {
+    test("positive zero", () => {
+        expect(new Decimal128("0").toNumber()).toStrictEqual(0);
+    });
+    test("negative zero", () => {
+        expect(new Decimal128("-0").toNumber()).toStrictEqual(-0);
+    });
+});
+
+describe("infinity", () => {
+    test("positive infinity", () => {
+        expect(new Decimal128("Infinity").toNumber()).toStrictEqual(Infinity);
+    });
+    test("negative infinity", () => {
+        expect(new Decimal128("-Infinity").toNumber()).toStrictEqual(-Infinity);
+    });
+});
+
+describe("simple examples", () => {
+    test("1.25", () => {
+        expect(new Decimal128("1.25").toNumber()).toStrictEqual(1.25);
+    });
+    test("0.1", () => {
+        expect(new Decimal128("0.1").toNumber()).toStrictEqual(0.1);
+    });
+    test("extreme precision", () => {
+        expect(
+            new Decimal128("0." + "0".repeat(100) + "1").toNumber()
+        ).toStrictEqual(1e-101);
+    });
+});