Used decimal.js to sanity-check own implementation in tests; wrote primitive fuzzer

Author: AnyhowStep

package-lock.json

@@ -28,6 +28,7 @@
   "devDependencies": {
     "@types/diff": "^4.0.2",
     "@types/tape": "^4.2.33",
+    "decimal.js": "^10.2.0",
     "diff": "^4.0.1",
     "tape": "^4.10.2",
     "ts-node": "^8.1.0",

package.json

@@ -1,4 +1,5 @@
 import {ParseResult} from "./try-parse";
+import * as BigIntUtil from "../bigint-util";
 
 export enum ZeroEqualityAlgorithm {
     NEGATIVE_AND_POSITIVE_ZERO_ARE_EQUAL = "NEGATIVE_AND_POSITIVE_ZERO_ARE_EQUAL",
@@ -26,13 +27,13 @@ export function isEqual (
     if (a.isZero != b.isZero) {
         return false;
     }
-    if (a.fixedPointIntegerPartLength != b.fixedPointIntegerPartLength) {
+    if (!BigIntUtil.equal(a.fixedPointIntegerPartLength, b.fixedPointIntegerPartLength)) {
         return false;
     }
-    if (a.fixedPointFractionalPartLength != b.fixedPointFractionalPartLength) {
+    if (!BigIntUtil.equal(a.fixedPointFractionalPartLength, b.fixedPointFractionalPartLength)) {
         return false;
     }
-    if (a.fixedPointLength != b.fixedPointLength) {
+    if (!BigIntUtil.equal(a.fixedPointLength, b.fixedPointLength)) {
         return false;
     }
     return (

src/fixed-point-util/is-equal.ts

@@ -19,6 +19,8 @@ export function toIntegerAndExponent (
         BigInt(arg.fractionalPart.length)
     );
     const integerPart = (
+        arg.integerPart == "0" ?
+        arg.fractionalPart.replace(/^(0+)/, "") :
         arg.integerPart + arg.fractionalPart
     );
     return {

src/floating-point-util/to-integer-and-exponent.ts

@@ -1,7 +1,7 @@
 import {getBigIntFactoryFunctionOrError} from "../type-util";
 import * as BigIntUtil from "../bigint-util";
 
-export const floatingPointRegex = /^([-+])?([0-9]*\.?[0-9]+)([eE]([-+])?([0-9]+))?$/;
+export const floatingPointRegex = /^([-+])?([0-9]+\.?[0-9]*|[0-9]*\.?[0-9]+)([eE]([-+])?([0-9]+))?$/;
 
 export interface ParseResult {
     /**

src/floating-point-util/try-parse.ts

@@ -0,0 +1,171 @@
+import * as tape from "tape";
+import * as tm from "../../../../../dist";
+import * as decimalJs from "decimal.js";
+
+function test (t : tape.Test, str : string) {
+    const parsedStr = tm.FixedPointUtil.tryParse(str);
+    if (parsedStr == undefined) {
+        t.throws(() => {
+            new decimalJs.Decimal(str)
+        }, str);
+        return;
+    }
+    try {
+        new decimalJs.Decimal(str)
+    } catch (_err) {
+        t.fail(`Should parse ${str}`);
+        return;
+    }
+    const decimal = new decimalJs.Decimal(str);
+    /**
+     * + str -> FixedPointUtil.tryParse()
+     * + str -> new Decimal() -> FixedPointUtil.tryParse()
+     *
+     * Then, we check if the output is the same.
+     */
+    const parsedDecimal = tm.FixedPointUtil.tryParse(decimal.toString());
+    if (parsedDecimal == undefined) {
+        t.fail(`Could not parse ${str} -> ${decimal.toString()}`);
+        return;
+    }
+
+    t.true(
+        tm.FixedPointUtil.isEqual(
+            parsedStr,
+            parsedDecimal,
+            tm.FixedPointUtil.ZeroEqualityAlgorithm.NEGATIVE_AND_POSITIVE_ZERO_ARE_EQUAL
+        ),
+        str
+    );
+    t.deepEqual(
+        parsedStr.getFixedPointString(),
+        (
+            parsedDecimal.isZero ?
+            "-" + parsedDecimal.getFixedPointString() :
+            parsedDecimal.getFixedPointString()
+        ),
+        str
+    );
+    t.deepEqual(
+        parsedStr.isInteger,
+        decimal.isInteger(),
+        str
+    );
+    t.deepEqual(
+        parsedStr.isNegative,
+        decimal.isNegative(),
+        str
+    );
+    t.deepEqual(
+        parsedStr.isZero,
+        decimal.isZero(),
+        str
+    );
+}
+function findAllPermutations (
+    possiblePermutations : string[][],
+    callback : (str : string) => void
+) {
+    let permutationIndex = 0;
+
+    while (true) {
+        let num = permutationIndex;
+        let str : string[] = [];
+        for (let i=possiblePermutations.length-1; i>=0; --i) {
+            const arr = possiblePermutations[i];
+            const arrIndex = num%arr.length;
+            const ele = arr[arrIndex];
+            str.push(ele);
+
+            num = Math.floor(num / arr.length);
+        }
+        if (num != 0) {
+            return;
+        }
+        callback(str.reverse().join(""));
+        ++permutationIndex;
+    }
+}
+tape(__filename, t => {
+    const possiblePermutations = [
+        ["-"],
+        [
+            "",
+            "0",
+            "1",
+
+            "00",
+            "01",
+            "10",
+            "11",
+
+            "000",
+            "001",
+            "010",
+            "011",
+
+            "100",
+            "101",
+            "110",
+            "111",
+        ],
+        ["", "."],
+        [
+            "",
+            "0",
+            "1",
+
+            "00",
+            "01",
+            "10",
+            "11",
+
+            "000",
+            "001",
+            "010",
+            "011",
+
+            "100",
+            "101",
+            "110",
+            "111",
+        ],
+        [
+            "",
+            "e",
+            "E",
+
+            "e+",
+            "E+",
+
+            "e-",
+            "E-",
+        ],
+        [
+            "",
+            "0",
+            "1",
+
+            "00",
+            "01",
+            "10",
+            "11",
+
+            "000",
+            "001",
+            "010",
+            "011",
+
+            "100",
+            "101",
+            "110",
+            "111",
+        ],
+    ];
+    findAllPermutations(
+        possiblePermutations,
+        (str) => test(t, str)
+    );
+
+    t.end();
+});