@numio/bigmath 1.1.0 → 2.0.1

package/src/shared/utils.js

@@ -1,83 +1,76 @@
-var convert = function (isNegative, array) {
-    return (isNegative ? "-" : "") + String.fromCharCode.apply(String, array);
+export const bi2s = (bigInt, fpe) => {
+    if (bigInt === 0n)
+        return "0";
+    const isNeg = bigInt < 0n;
+    isNeg && (bigInt *= -1n);
+    const dp = bigInt % (10n ** BigInt(fpe));
+    const bigStr = bigInt.toString();
+    let fpIdx = bigStr.length - fpe;
+    if (fpIdx < 0)
+        fpIdx = 0;
+    const before = bigStr.slice(0, fpIdx);
+    const after = bigStr.slice(fpIdx);
+    if (before) {
+        return fillHead(bigStr.length, fpe, isNeg, true) +
+            (fpe > 0 && dp > 0 ? trimTail(`${before}.${after}`) : before);
+    }
+    return `${fillHead(bigStr.length, fpe, isNeg, false)}${trimTail(after)}`;
+};
+export const s2bi = (str) => {
+    const fpi = str.indexOf(".");
+    if (fpi === -1)
+        return [BigInt(str), 0];
+    return [
+        BigInt(str.slice(0, fpi) + str.slice(fpi + 1)),
+        fpi === -1 ? 0 : str.length - 1 - fpi,
+    ];
 };
-export var a2s = function (_a) {
-    var array = _a.array, isFloat = _a.isFloat, isNegative = _a.isNegative, intLength = _a.intLength;
-    var result = [];
-    var lastValuableIdx = array.length;
-    var isNil = array.length === 1 && array[0] === 48;
-    if (isNil)
-        return convert(isNegative, array);
-    if (isFloat) {
-        var idx = array.length - 1;
-        while (array[idx] === 48 && idx >= intLength) {
-            lastValuableIdx = idx;
-            idx -= 1;
+export const calcInner = (array, op, def) => {
+    let bigInt = def ? def[0] : array[0][0];
+    let fpe = def ? def[1] : array[0][1];
+    const opm = op(1n, 1n);
+    for (let i = def ? 0 : 1; i < array.length; i++) {
+        const [bigCurrent, dpLen] = array[i];
+        if (dpLen === 0 && fpe === 0) {
+            bigInt = op(bigInt, bigCurrent);
+            continue;
         }
-    }
-    if (intLength !== array.length) {
-        if (intLength <= 0) {
-            result.push(48, 46);
-            for (var i = intLength; i < 0; i++) {
-                result.push(48);
-            }
-            for (var i = 0; i < lastValuableIdx; i++) {
-                result.push(array[i]);
-            }
+        if (opm === 1n) {
+            bigInt = op(bigInt, bigCurrent);
+            fpe += dpLen;
         }
         else {
-            for (var i = 0; i < lastValuableIdx; i++) {
-                i === intLength && result.push(46);
-                result.push(array[i]);
+            if (fpe < dpLen) {
+                const fpDiff = dpLen - fpe;
+                bigInt = op(bigInt * (10n ** BigInt(fpDiff)), bigCurrent);
             }
+            if (fpe > dpLen) {
+                bigInt = op(bigInt, bigCurrent * (10n ** BigInt(fpe - dpLen)));
+            }
+            if (fpe === dpLen)
+                bigInt = op(bigInt, bigCurrent);
+            if (fpe < dpLen)
+                fpe = dpLen;
         }
-        return result.at(-1) === 46 ? "0" : convert(isNegative, result);
     }
-    return convert(isNegative, array);
+    return [bigInt, fpe];
 };
-export var s2a = function (string) {
-    var array = Array(0);
-    var isNegative = string.charCodeAt(0) === 45;
-    var shift = isNegative ? 1 : 0;
-    var dec = 0;
-    var isNil = string.length === 1 && string.charCodeAt(0) === 48;
-    var isNegNil = string.length === 2 && isNegative &&
-        string.charCodeAt(1) === 48;
-    if (isNil || isNegNil) {
-        return {
-            array: [48],
-            intLength: 1,
-            isNegative: isNegNil,
-            isFloat: false,
-        };
-    }
-    for (var idx = 0 + shift; idx < string.length; idx++) {
-        var charCode = string.charCodeAt(idx);
-        if (array.length === 0 && charCode === 48)
-            continue;
-        if (charCode === 46) {
-            dec = string.length - 1 - idx;
-            continue;
-        }
-        array.push(charCode);
+export const fillHead = (len, fpe, isNeg, hasBefore) => {
+    let head = (isNeg ? "-" : "") + (hasBefore ? "" : "0.");
+    while (len < fpe) {
+        head = head + "0";
+        len += 1;
     }
-    return {
-        array: array,
-        intLength: array.length - dec,
-        isNegative: isNegative,
-        isFloat: dec > 0,
-    };
+    return head;
 };
-export var cloneInner = function (inner) {
-    var len = inner.array.length;
-    var clone = Array(len);
-    for (var i = 0; i < len; i++) {
-        clone[i] = inner.array[i];
+export const trimTail = (str) => {
+    if (str[str.length - 1] !== "0")
+        return str;
+    let count = 0;
+    for (let i = str.length - 1; i >= 0; i -= 1) {
+        if (str[i] !== "0")
+            return str.slice(0, str.length - count);
+        count += 1;
     }
-    return {
-        intLength: inner.intLength,
-        isFloat: inner.isFloat,
-        isNegative: inner.isNegative,
-        array: clone,
-    };
+    return str;
 };

package/src/sort/constants.js

@@ -1,3 +1,3 @@
-export var ASC = "asc";
-export var DESC = "desc";
-export var sortingArray = [ASC, DESC];
+export const ASC = "asc";
+export const DESC = "desc";
+export const sortingArray = [ASC, DESC];

package/src/sort/main.js

@@ -1,10 +1,9 @@
-import { a2s, s2a } from "../shared/utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
 import { ASC } from "./constants.js";
 import { sortInner } from "./utils.js";
 /** Using this function sort an array. */
-export var sort = function (array, sorting) {
-    if (sorting === void 0) { sorting = ASC; }
-    var inputDataArray = array.map(function (str) { return s2a(str); });
-    sortInner(inputDataArray, sorting);
-    return inputDataArray.map(function (input) { return a2s(input); });
+export const sort = (array, sorting = ASC) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    sortInner(arrayInner, sorting);
+    return arrayInner.map(([bi, fpe]) => bi2s(bi, fpe));
 };

package/src/sort/types.d.ts

@@ -1,6 +1,6 @@
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 import type { sortingArray } from "./constants.d.ts";
 export type Sorting = typeof sortingArray[number];
 export type Sort = (array: string[], sorting?: Sorting) => string[];
-export type SortInner = (array: InputData[], sorting: Sorting) => InputData[];
-export type Heapify = (array: InputData[], len: number, i: number, sorting: Sorting) => void;
+export type SortInner = (array: BI[], sorting: Sorting) => BI[];
+export type Heapify = (array: BI[], len: number, i: number, sorting: Sorting) => void;

package/src/sort/utils.js

@@ -1,10 +1,9 @@
 import { compareInner } from "../compare/utils.js";
 import { ASC } from "./constants.js";
-var heapify = function (array, len, i, sorting) {
-    var _a;
-    var idxL = 2 * i + 1;
-    var idxR = idxL + 1;
-    var idx = i;
+const heapify = (array, len, i, sorting) => {
+    const idxL = 2 * i + 1;
+    const idxR = idxL + 1;
+    let idx = i;
     if (sorting === ASC) {
         if (idxL < len && compareInner(array[idxL], array[idx])[1] >= 0)
             idx = idxL;
@@ -18,18 +17,17 @@ var heapify = function (array, len, i, sorting) {
             idx = idxR;
     }
     if (idx !== i) {
-        _a = [array[idx], array[i]], array[i] = _a[0], array[idx] = _a[1];
+        [array[i], array[idx]] = [array[idx], array[i]];
         heapify(array, len, idx, sorting);
     }
 };
-export var sortInner = function (array, sorting) {
-    var _a;
-    var len = array.length;
-    for (var i = (len >> 1) - 1; i >= 0; i--) {
+export const sortInner = (array, sorting) => {
+    const { length: len } = array;
+    for (let i = (len >> 1) - 1; i >= 0; i--) {
         heapify(array, len, i, sorting);
     }
-    for (var i = len - 1; i >= 0; i--) {
-        _a = [array[i], array[0]], array[0] = _a[0], array[i] = _a[1];
+    for (let i = len - 1; i >= 0; i--) {
+        [array[0], array[i]] = [array[i], array[0]];
         heapify(array, i, 0, sorting);
     }
     return array;

package/src/sqrt/main.js

@@ -1,10 +1,10 @@
 import { round } from "../round/main.js";
-import { a2s, s2a } from "../shared/utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
 import { sqrtInner } from "./utils.js";
 /** Find square root of a number */
-export var sqrt = function (str, precision) {
-    var inputInner = s2a(str);
-    var _a = sqrtInner(inputInner, precision ? s2a(precision) : undefined), outputInner = _a[0], decimals = _a[1];
-    var outputStr = a2s(outputInner);
-    return round(outputStr, { decimals: decimals + 1 });
+export const sqrt = (str, precision) => {
+    const inputInner = s2bi(str);
+    const [[bi, fpe], decimals] = sqrtInner(inputInner, precision ? s2bi(precision) : undefined);
+    const outputStr = bi2s(bi, fpe);
+    return round(outputStr, { decimals });
 };

package/src/sqrt/types.d.ts

@@ -1,3 +1,3 @@
-import type { InputData } from "../types.d.ts";
-export type SqrtInner = (input: InputData, prec?: InputData, max?: number) => [InputData, number];
+import type { BI } from "../shared/types.d.ts";
+export type SqrtInner = (input: BI, prec?: BI, max?: number) => [BI, number];
 export type Sqrt = (str: string, precision?: string) => string;

package/src/sqrt/utils.js

@@ -1,34 +1,22 @@
 import { isLeftGreaterInner } from "../compare/utils.js";
 import { PipeInner } from "../pipe/utils.js";
-import { cloneInner } from "../shared/utils.js";
-var halfInner = {
-    array: [53],
-    intLength: 0,
-    isNegative: false,
-    isFloat: true,
-};
-var precDef = {
-    array: [49],
-    intLength: -12,
-    isNegative: false,
-    isFloat: true,
-};
-export var sqrtInner = function (input, prec, max) {
-    if (prec === void 0) { prec = precDef; }
-    if (max === void 0) { max = 100; }
-    var guess = cloneInner(input);
-    for (var i = 0; i < max; i++) {
-        var nextGuess = new PipeInner()
-            .divInner([cloneInner(input), cloneInner(guess)])
-            .addInner([guess])
-            .mulInner([halfInner]).result;
-        var candidate = new PipeInner()
-            .subInner([cloneInner(nextGuess), cloneInner(guess)]).result;
-        candidate.isNegative = false;
-        if (isLeftGreaterInner({ left: prec, right: candidate })) {
-            return [nextGuess, prec.intLength * -1];
+const halfInner = [5n, 1];
+const precDef = [1n, 13];
+export const sqrtInner = (input, prec = precDef, max = 100) => {
+    let guess = input;
+    for (let i = 0; i < max; i++) {
+        const nextGuess = new PipeInner()
+            .div([input, guess])
+            .add([guess])
+            .mul([halfInner])
+            .calc();
+        let [bi, fpe] = new PipeInner().sub([nextGuess, guess]).calc();
+        if (bi < 0n)
+            bi *= -1n;
+        if (isLeftGreaterInner({ left: prec, right: [bi, fpe] })) {
+            return [nextGuess, prec[1]];
         }
         guess = nextGuess;
     }
-    return [guess, prec.intLength * -1];
+    return [guess, prec[1]];
 };

package/src/operations/add/types.d.ts

@@ -1,2 +0,0 @@
-import type { InputData } from "../../types.d.ts";
-export type AddInner = (L: [number[], number], R: [number[], number], isNegative: boolean) => InputData;

package/src/operations/add/utils.d.ts

@@ -1,5 +0,0 @@
-import type { Route } from "../../types.d.ts";
-import type { AddInner } from "./types.d.ts";
-/** This function adds 2 numbers (as array). */
-export declare const addInner: AddInner;
-export declare const addRoute: Route;

package/src/operations/add/utils.js

@@ -1,59 +0,0 @@
-import { subInner } from "../sub/utils.js";
-/** This function adds 2 numbers (as array). */
-export var addInner = function (_a, _b, isNegative) {
-    var _c, _d;
-    var arrL = _a[0], intL = _a[1];
-    var arrR = _b[0], intR = _b[1];
-    var _e = intL >= intR
-        ? [arrL, arrR, intL, intR]
-        : [arrR, arrL, intR, intL], left = _e[0], right = _e[1], intLeft = _e[2], intRight = _e[3];
-    var fracLenL = left.length - intLeft;
-    var fracLenR = right.length - intRight;
-    var fracMaxLen = (fracLenL >= fracLenR ? fracLenL : fracLenR) - 1;
-    var pl = (intLeft >= intRight ? intLeft : intRight) + fracMaxLen;
-    var pr = (intLeft >= intRight ? intRight : intLeft) + fracMaxLen;
-    var carryOver = 48;
-    while (pl > left.length - 1) {
-        left.push(48);
-    }
-    while (pr >= 0) {
-        var sum = (((_c = left[pl]) !== null && _c !== void 0 ? _c : 48) + ((_d = right[pr]) !== null && _d !== void 0 ? _d : 48) + carryOver) -
-            3 * 48;
-        if (sum > 9) {
-            left[pl] = (sum % 10) + 48;
-            carryOver = ((sum / 10) | 0) + 48;
-        }
-        else {
-            left[pl] = sum + 48;
-            carryOver = 48;
-        }
-        pr -= 1;
-        pl -= 1;
-    }
-    while (pl >= 0 && carryOver) {
-        var sum = (left[pl] + carryOver) - 2 * 48;
-        left[pl] = (sum % 10) + 48;
-        carryOver = ((sum / 10) | 0) + 48;
-        pl -= 1;
-    }
-    carryOver > 48 && left.unshift(carryOver);
-    return {
-        array: left,
-        intLength: left.length - 1 - fracMaxLen,
-        isNegative: isNegative,
-        isFloat: fracLenL + fracLenR > 0,
-    };
-};
-export var addRoute = function (input, initValue) {
-    return input.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        if (left.isNegative && !right.isNegative) {
-            return subInner([right.array, right.intLength], [left.array, left.intLength]);
-        }
-        if (!left.isNegative && right.isNegative) {
-            return subInner([left.array, left.intLength], [right.array, right.intLength]);
-        }
-        return addInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative && right.isNegative);
-    }, initValue);
-};

package/src/operations/mul/types.d.ts

@@ -1,2 +0,0 @@
-import type { InputData } from "../../types.d.ts";
-export type MulInner = (arrL: [number[], number], arrR: [number[], number], isNegative: boolean) => InputData;

package/src/operations/mul/utils.d.ts

@@ -1,5 +0,0 @@
-import type { Route } from "../../types.d.ts";
-import type { MulInner } from "./types.d.ts";
-/** This function multiplies 2 numbers (as array). */
-export declare const mulInner: MulInner;
-export declare const mulRoute: Route;

package/src/operations/mul/utils.js

@@ -1,50 +0,0 @@
-import { NIL } from "../../shared/constant.js";
-/** This function multiplies 2 numbers (as array). */
-export var mulInner = function (_a, _b, isNegative) {
-    var _c, _d;
-    var arrL = _a[0], intL = _a[1];
-    var arrR = _b[0], intR = _b[1];
-    if (arrL.length === 0 || arrR.length === 0 ||
-        (arrL.length === 1 && arrL[0] === 48) ||
-        (arrR.length === 1 && arrR[0] === 48)) {
-        return NIL;
-    }
-    var dec = (arrL.length - intL) + (arrR.length - intR);
-    var _e = arrL.length >= arrR.length
-        ? [arrL, arrR]
-        : [arrR, arrL], left = _e[0], right = _e[1];
-    var sums = Array(right.length + left.length - 1);
-    for (var i = right.length - 1; i >= 0; i--) {
-        for (var j = left.length - 1; j >= 0; j--) {
-            var idx_1 = j + i;
-            sums[idx_1] = ((_c = sums[idx_1]) !== null && _c !== void 0 ? _c : 0) +
-                (left[j] - 48) * (right[i] - 48);
-        }
-    }
-    var result = Array(sums.length);
-    var idx = sums.length - 1;
-    var carryOver = 0;
-    var currNum = 0;
-    var nextNum = 0;
-    while (idx >= 0) {
-        currNum = (_d = sums[idx]) !== null && _d !== void 0 ? _d : 0;
-        nextNum = (currNum + carryOver) % 10;
-        carryOver = (carryOver + currNum) / 10 | 0;
-        result[idx] = nextNum + 48;
-        idx -= 1;
-    }
-    carryOver > 0 && result.unshift(carryOver + 48);
-    return {
-        array: result,
-        intLength: result.length - dec,
-        isFloat: dec > 0,
-        isNegative: isNegative,
-    };
-};
-export var mulRoute = function (input, initValue) {
-    return input.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        return mulInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative);
-    }, initValue);
-};

package/src/operations/sub/types.d.ts

@@ -1,2 +0,0 @@
-import type { InputData } from "../../types.d.ts";
-export type SubInner = (L: [number[], number], R: [number[], number]) => InputData;

package/src/operations/sub/utils.d.ts

@@ -1,5 +0,0 @@
-import type { Route } from "../../types.d.ts";
-import type { SubInner } from "./types.d.ts";
-/** This function subtracts 2 numbers (as array). */
-export declare const subInner: SubInner;
-export declare const subRoute: Route;

package/src/operations/sub/utils.js

@@ -1,81 +0,0 @@
-import { addInner } from "../add/utils.js";
-/** This function subtracts 2 numbers (as array). */
-export var subInner = function (_a, _b) {
-    var _c, _d;
-    var _e, _f;
-    var arrL = _a[0], intL = _a[1];
-    var arrR = _b[0], intR = _b[1];
-    var lenDiff = (intL - intR) * (intL > intR ? 1 : -1);
-    var _g = intL >= intR
-        ? [arrL, arrR, intL, intR]
-        : [arrR, arrL, intR, intL], left = _g[0], right = _g[1], intLeft = _g[2], intRight = _g[3];
-    var fracLenL = left.length - intLeft;
-    var fracLenR = right.length - intRight;
-    var pl = lenDiff;
-    var pr = 0;
-    var isLeftBigger = lenDiff > 0;
-    var carryOver = false;
-    var isNegative = intLeft !== intL;
-    while (pl > left.length - 1) {
-        left.push(48);
-    }
-    while (pr < right.length) {
-        var sub = (((_e = left[pl]) !== null && _e !== void 0 ? _e : 48) - ((_f = right[pr]) !== null && _f !== void 0 ? _f : 48)) + 48;
-        if (!isLeftBigger && left[pl] > right[pr]) {
-            isLeftBigger = true;
-        }
-        if (!isLeftBigger && sub < 48 && lenDiff === 0) {
-            _c = [right, left], left = _c[0], right = _c[1];
-            _d = [intR, intL], intL = _d[0], intR = _d[1];
-            isLeftBigger = true;
-            isNegative = true;
-            continue;
-        }
-        if (sub < 48) {
-            sub += 10;
-            carryOver = true;
-        }
-        var plReverse = pl - 1;
-        var prReverse = pr - 1;
-        while (carryOver) {
-            if (left[plReverse] !== 48) {
-                plReverse >= 0 && (left[plReverse] -= 1);
-                prReverse >= 0 && (right[prReverse] -= 1);
-                carryOver = false;
-            }
-            else {
-                plReverse >= 0 && (left[plReverse] = 57);
-                prReverse >= 0 && (right[prReverse] = 57);
-            }
-            plReverse -= 1;
-            prReverse -= 1;
-        }
-        left[pl] = sub;
-        right[pr] = sub;
-        pl += 1;
-        pr += 1;
-    }
-    while (left[0] === 48 && left.length > 1) {
-        left.shift();
-        intLeft -= 1;
-    }
-    return {
-        array: left,
-        intLength: intLeft,
-        isNegative: isNegative,
-        isFloat: fracLenL + fracLenR > 0,
-    };
-};
-export var subRoute = function (input, initValue) {
-    return input.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        if (left.isNegative && right.isNegative) {
-            return subInner([right.array, right.intLength], [left.array, left.intLength]);
-        }
-        if (!left.isNegative && !right.isNegative) {
-            return subInner([left.array, left.intLength], [right.array, right.intLength]);
-        }
-        return addInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative);
-    }, initValue);
-};

package/src/types.d.ts

@@ -1,7 +0,0 @@
-export type InputData = {
-    array: number[];
-    intLength: number;
-    isNegative: boolean;
-    isFloat: boolean;
-};
-export type Route = (input: InputData[], initValue: InputData) => InputData;