@numio/bigmath 1.1.0 → 2.0.1

package/README.md

@@ -11,6 +11,8 @@
 * **Handle Numbers of Any Size:** Perform calculations on integers and decimals of virtually unlimited length, without the risk of JavaScript's `Number` limitations.
 * **Eliminate Precision Loss:** Achieve accurate results even with numeric literals exceeding 15 significant digits, ensuring the integrity of your calculations.
 * **Precise Decimal Operations:** Execute addition, subtraction, multiplication, and division on decimal numbers with guaranteed accuracy, including scenarios with negative values.
+* ****NEW! Multi-Base Number Support:** Seamlessly perform arithmetic operations involving **hexadecimal (HEX), octal, binary, and decimal numbers**, offering unparalleled flexibility in handling various number formats.
+
 
 **Unlock Advanced Numerical Operations:**
 
@@ -40,16 +42,15 @@ This library is particularly invaluable in applications where numerical accuracy
 * **Cryptography:** Implementing cryptographic algorithms that rely on high-precision arithmetic.
 * **E-commerce and Payments:** Handling precise amounts and avoiding rounding errors in transactions.
 * **Data Analysis and Statistics:** Performing accurate statistical calculations on datasets with varying scales.
+* **Low-Level Operations:** Working with different number representations commonly found in computer systems.
 * **Any Scenario Exceeding JavaScript's Number Limits:** Ensuring the reliability of your calculations when dealing with numbers beyond the safe integer limit or requiring more than 15 significant digits.
 
 With `@numio/bigmath`, you can confidently perform complex arithmetic operations with the assurance of accuracy, regardless of the size or precision of the numbers involved.
 
 ### Latest update
 
-Added `sqrt` - square root of a number\
-Added `isEqual` and `isLeftGreater` - to compare 2 numbers.\
-Added `MAD` - Median Absolute Deviation.\
-Added `IQR` - Interquartile Range.
+The performance was improved. Adding, subtracting, dividing, and multiplying are now **2** to **5** times faster than before.\
+Adding, subtracting, dividing, and multiplying support operations on HEX, octal, binary, and decimal numbers. Mixed-type calculations are allowed, with the final result converted to decimal.
 
 # Install:
 
@@ -128,6 +129,17 @@ const negative = div(["-2", "-3", "2"]); //0.33333333333333333333
 div(["10", "3"], 4); // 3.3333
 ```
 
+### HEX, decimal, octal, binary
+```javascript
+import { add, sub } from "@numio/bigmath";
+
+add(["0xA", "0x5"]) // HEX + HEX, 10 + 5 = 15
+add(["0xA", "2"]) // HEX + decimal, 10 + 2 = 12
+sub(["35", "0b11"]) // decimal - binary, 35 - 3 = 32 
+sub(["0x1A", "0o31", "0b101", ]) // HEX - octal - binary, 26 - 25 - 5 = -4
+
+```
+
 ### Round
 
 ```javascript

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@numio/bigmath",
   "description": "@numio/bigmath is an arbitrary-precision arithmetic library. It can be used for basic operations with decimal numbers (integers and float)",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "keywords": [
     "precision",
     "arithmetic",
@@ -46,7 +46,12 @@
     "isEqual",
     "equality",
     "sqrt",
-    "square root"
+    "square root",
+    "HEX",
+    "octal",
+    "binary",
+    "decimal",
+    "binary"
   ],
   "repository": {
     "type": "git",

package/src/IQR/main.js

@@ -1,7 +1,8 @@
-import { a2s, s2a } from "../shared/utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
 import { IQRInner } from "./utils.js";
 //** This function returns Interquartile Range */
-export var IQR = function (strs, sigNum) {
-    var array = strs.map(function (str) { return s2a(str); });
-    return a2s(IQRInner(array, sigNum));
+export const IQR = (array, sigNum) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = IQRInner(arrayInner, sigNum);
+    return bi2s(bi, fpe);
 };

package/src/IQR/types.d.ts

@@ -1,3 +1,3 @@
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 export type TIQR = (array: string[], sigNum?: boolean) => string;
-export type TIQRInner = (array: InputData[], sigNum?: boolean) => InputData;
+export type TIQRInner = (array: BI[], sigNum?: boolean) => BI;

package/src/IQR/utils.js

@@ -2,16 +2,15 @@ import { isEqualInner } from "../compare/utils.js";
 import { MADInner } from "../MAD/utils.js";
 import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-import { NIL, ONE } from "../shared/constant.js";
-export var MIN_LENGTH_FOR_MAD = 30;
-export var IQRInner = function (array, sigNum) {
-    if (sigNum === void 0) { sigNum = false; }
-    var _a = quartileInner(array), Q1 = _a.Q1, Q3 = _a.Q3;
-    var sub = new PipeInner().subInner([Q3, Q1]).result;
+export const MIN_LENGTH_FOR_MAD = 30;
+export const IQRInner = (array, sigNum = false) => {
+    const { Q1, Q3 } = quartileInner(array);
+    const sub = new PipeInner().sub([Q3, Q1]).calc();
     if (sigNum) {
-        var isEqual = isEqualInner({ left: Q3, right: Q1 });
-        var MAD = MADInner(array);
-        var nonNilMAD = isEqualInner({ left: MAD, right: NIL }) ? ONE : MAD;
+        const isEqual = isEqualInner({ left: Q3, right: Q1 });
+        const MAD = MADInner(array);
+        const isNil = isEqualInner({ left: MAD, right: [0n, 0] });
+        const nonNilMAD = isNil ? [1n, 0] : MAD;
         return isEqual ? nonNilMAD : sub;
     }
     return sub;

package/src/MAD/main.js

@@ -1,7 +1,8 @@
-import { a2s, s2a } from "../shared/utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
 import { MADInner } from "./utils.js";
 //** This function returns Median Absolute Deviation */
-export var MAD = function (strs) {
-    var array = strs.map(function (str) { return s2a(str); });
-    return a2s(MADInner(array));
+export const MAD = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = MADInner(arrayInner);
+    return bi2s(bi, fpe);
 };

package/src/MAD/types.d.ts

@@ -1,3 +1,3 @@
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 export type TMAD = (array: string[]) => string;
-export type TMADInner = (array: InputData[]) => InputData;
+export type TMADInner = (array: BI[]) => BI;

package/src/MAD/utils.js

@@ -1,15 +1,13 @@
 import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-import { cloneInner } from "../shared/utils.js";
 import { ASC } from "../sort/constants.js";
 import { sortInner } from "../sort/utils.js";
-export var MADInner = function (array) {
-    var median = quartileInner(array).Q2;
-    var madArray = array.map(function (el) {
-        var result = new PipeInner().subInner([el, cloneInner(median)]).result;
-        result.isNegative = false;
-        return result;
+export const MADInner = (array) => {
+    const median = quartileInner(array).Q2;
+    const madArray = array.map((el) => {
+        const [bi, fpe] = new PipeInner().sub([el, median]).calc();
+        return bi < 0n ? [bi * -1n, fpe] : [bi, fpe];
     });
-    var sorted = sortInner(madArray, ASC);
+    const sorted = sortInner(madArray, ASC);
     return quartileInner(sorted).Q2;
 };

package/src/compare/main.js

@@ -1,22 +1,22 @@
-import { a2s, s2a } from "../shared/utils.js";
-import { isEqualInner, isLeftGreaterInner, maxInner, minInner } from "./utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
+import { isEqualInner, isLeftGreaterInner, maxInner, minInner, } from "./utils.js";
 /** This function returns max value. */
-export var max = function (strs) {
-    var array = strs.map(function (str) { return s2a(str); });
-    return a2s(maxInner(array));
+export const max = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = maxInner(arrayInner);
+    return bi2s(bi, fpe);
 };
 /** This function returns min value. */
-export var min = function (strs) {
-    var array = strs.map(function (str) { return s2a(str); });
-    return a2s(minInner(array));
+export const min = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = minInner(arrayInner);
+    return bi2s(bi, fpe);
 };
 /** This function returns if left value is greater than right value */
-export var isLeftGreater = function (_a) {
-    var left = _a.left, right = _a.right;
-    return isLeftGreaterInner({ left: s2a(left), right: s2a(right) });
+export const isLeftGreater = ({ left, right }) => {
+    return isLeftGreaterInner({ left: s2bi(left), right: s2bi(right) });
 };
 /** This function returns if left and right values are equal */
-export var isEqual = function (_a) {
-    var left = _a.left, right = _a.right;
-    return isEqualInner({ left: s2a(left), right: s2a(right) });
+export const isEqual = ({ left, right }) => {
+    return isEqualInner({ left: s2bi(left), right: s2bi(right) });
 };

package/src/compare/types.d.ts

@@ -1,4 +1,4 @@
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 export type Min = (strs: string[]) => string;
 export type Max = Min;
 export type IsLeftGreater = (attr: {
@@ -6,11 +6,11 @@ export type IsLeftGreater = (attr: {
     right: string;
 }) => boolean;
 export type IsEqual = IsLeftGreater;
-export type CompareInner = (left: InputData, right: InputData) => [InputData, number];
-export type MinInner = (array: InputData[]) => InputData;
+export type CompareInner = (left: BI, right: BI) => [BI, number];
+export type MinInner = (array: BI[]) => BI;
 export type MaxInner = MinInner;
 export type IsEqualInner = (attr: {
-    left: InputData;
-    right: InputData;
+    left: BI;
+    right: BI;
 }) => boolean;
 export type IsLeftGreaterInner = IsEqualInner;

package/src/compare/utils.js

@@ -1,98 +1,75 @@
-export var maxInner = function (array) {
-    var max = array[0];
-    for (var i = 1; i < array.length; i++) {
+export const maxInner = (array) => {
+    let max = array[0];
+    for (let i = 1; i < array.length; i++) {
         if (compareInner(array[i], max)[1] === 1)
             max = array[i];
     }
     return max;
 };
-export var minInner = function (array) {
-    var min = array[0];
-    for (var i = 1; i < array.length; i++) {
+export const minInner = (array) => {
+    let min = array[0];
+    for (let i = 1; i < array.length; i++) {
         if (compareInner(array[i], min)[1] === -1)
             min = array[i];
     }
     return min;
 };
-export var compareInner = function (l, r) {
-    var _a;
-    var idx = 0;
-    var _b = [l, r], left = _b[0], right = _b[1];
-    var lIsNeg = l.isNegative, lIntLen = l.intLength;
-    var rIsNeg = r.isNegative, rIntLen = r.intLength;
-    var lenL = l.array.length;
-    var lenR = r.array.length;
-    var bothNeg = lIsNeg && rIsNeg;
-    var bothPos = !lIsNeg && !rIsNeg;
-    var bothIntPos = lIntLen > 0 && rIntLen > 0;
-    var bothIntNeg = lIntLen <= 0 && rIntLen <= 0;
-    var isNilL = l.array.length === 1 && l.array[0] === 48;
-    var isNilR = r.array.length === 1 && r.array[0] === 48;
-    if (!lIsNeg && rIsNeg)
+export const compareInner = (l, r) => {
+    const [biL, fpeL] = l;
+    const [biR, fpeR] = r;
+    if (biL > 0n && biR < 0n)
         return [l, 1];
-    if (lIsNeg && !rIsNeg)
+    if (biL < 0n && biR > 0n)
         return [r, -1];
-    if (bothPos && !isNilL && isNilR)
-        return [l, 1];
-    if (bothPos && isNilL && !isNilR)
-        return [r, -1];
-    if (bothNeg && isNilL && !isNilR)
-        return [l, 1];
-    if (bothNeg && !isNilL && isNilR)
-        return [r, -1];
-    if (bothPos && lIntLen > rIntLen)
-        return [l, 1];
-    if (bothPos && lIntLen < rIntLen)
-        return [r, -1];
-    if (bothPos && lIntLen > 0 && rIntLen === 0)
-        return [l, 1];
-    if (bothPos && lIntLen === 0 && rIntLen > 0)
-        return [r, -1];
-    if (!bothPos && lIntLen === 0 && rIntLen > 0)
-        return [l, 1];
-    if (!bothPos && lIntLen > 0 && rIntLen === 0)
-        return [r, -1];
-    if (bothPos && bothIntPos && lIntLen > rIntLen)
-        return [l, 1];
-    if (bothPos && bothIntPos && lIntLen < rIntLen)
-        return [r, -1];
-    if (bothNeg && bothIntNeg && lIntLen < rIntLen)
-        return [l, 1];
-    if (bothNeg && bothIntNeg && lIntLen > rIntLen)
-        return [r, -1];
-    if (bothNeg && bothIntPos && lIntLen < rIntLen)
-        return [l, 1];
-    if (bothNeg && bothIntPos && lIntLen > rIntLen)
-        return [r, -1];
-    if (bothPos && bothIntNeg && lIntLen > rIntLen)
-        return [l, 1];
-    if (bothPos && bothIntNeg && lIntLen < rIntLen)
-        return [r, -1];
-    if (bothNeg)
-        _a = [r, l], left = _a[0], right = _a[1];
-    while (idx < (lenL > lenR ? lenL : lenR)) {
-        var numL = left.array[idx];
-        var numR = right.array[idx];
-        if (!numL && bothPos)
-            return [r, -1];
-        if (!numR && bothPos)
+    if (biL === 0n || biR === 0n) {
+        if (biL > biR)
             return [l, 1];
-        if (!numL && bothNeg)
+        if (biL < biR)
+            return [r, -1];
+    }
+    if (biL < 0n && biR < 0n) {
+        if (biL === biR) {
+            if (fpeL > fpeR)
+                return [l, 1];
+            if (fpeL < fpeR)
+                return [r, -1];
+            if (fpeL === fpeR)
+                return [l, 0];
+        }
+        const fpeBiL = BigInt(fpeL);
+        const fpeBiR = BigInt(fpeR);
+        const max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
+        const powL = biL * 10n ** (max - fpeBiL);
+        const powR = biR * 10n ** (max - fpeBiR);
+        if (powL > powR)
             return [l, 1];
-        if (!numR && bothNeg)
+        if (powL < powR)
             return [r, -1];
-        if (numL !== numR) {
-            return numL > numR ? [l, 1] : [r, -1];
+    }
+    if (biL > 0n && biR > 0n) {
+        if (biL === biR) {
+            if (fpeL > fpeR)
+                return [r, -1];
+            if (fpeL < fpeR)
+                return [l, 1];
+            if (fpeL === fpeR)
+                return [l, 0];
         }
-        idx += 1;
+        const fpeBiL = BigInt(fpeL);
+        const fpeBiR = BigInt(fpeR);
+        const max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
+        const powL = biL * 10n ** (max - fpeBiL);
+        const powR = biR * 10n ** (max - fpeBiR);
+        if (powL > powR)
+            return [l, 1];
+        if (powL < powR)
+            return [r, -1];
     }
     return [l, 0];
 };
-export var isEqualInner = function (_a) {
-    var left = _a.left, right = _a.right;
+export const isEqualInner = ({ left, right }) => {
     return compareInner(left, right)[1] === 0;
 };
-export var isLeftGreaterInner = function (_a) {
-    var left = _a.left, right = _a.right;
+export const isLeftGreaterInner = ({ left, right }) => {
     return compareInner(left, right)[1] > 0;
 };

package/src/mean/main.js

@@ -1,8 +1,8 @@
-import { a2s, s2a } from "../shared/utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
 import { meanInner } from "./utils.js";
 /** This function returns mean of an array. */
-export var mean = function (strs) {
-    var array = strs.map(function (str) { return s2a(str); });
-    var res = meanInner(array);
-    return a2s(res);
+export const mean = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = meanInner(arrayInner);
+    return bi2s(bi, fpe);
 };

package/src/mean/types.d.ts

@@ -1,3 +1,3 @@
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 export type Mean = (array: string[]) => string;
-export type MeanInner = (array: InputData[]) => InputData;
+export type MeanInner = (array: BI[]) => BI;

package/src/mean/utils.js

@@ -1,9 +1,6 @@
-import { addRoute } from "../operations/add/utils.js";
 import { PipeInner } from "../pipe/utils.js";
-import { DEFAULT } from "../shared/constant.js";
-import { s2a } from "../shared/utils.js";
-export var meanInner = function (array) {
-    var left = addRoute(array, DEFAULT);
-    var right = s2a(array.length.toString());
-    return new PipeInner().divInner([left, right]).result;
+export const meanInner = (array) => {
+    const left = new PipeInner().add(array).calc();
+    const right = [BigInt(array.length), 0];
+    return new PipeInner().div([left, right]).calc();
 };

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

@@ -1,2 +1,2 @@
 /** This function adds numbers (as string). */
-export declare function add(strs: string[]): string;
+export declare const add: (array: string[]) => string;

package/src/operations/add/main.js

@@ -1,7 +1,8 @@
-import { DEFAULT } from "../../shared/constant.js";
-import { a2s, s2a } from "../../shared/utils.js";
-import { addRoute } from "./utils.js";
+import { bi2s, s2bi } from "../../shared/utils.js";
+import { calcInner } from "../../shared/utils.js";
 /** This function adds numbers (as string). */
-export function add(strs) {
-    return a2s(addRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
-}
+export const add = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a + b);
+    return bi2s(bigInt, fpe);
+};

package/src/operations/div/main.d.ts

@@ -1,2 +1,2 @@
 /** This function should divide numbers (as string). */
-export declare const div: (strs: string[], limit?: number) => string;
+export declare const div: (array: string[], limit?: number) => string;

package/src/operations/div/main.js

@@ -1,10 +1,8 @@
-import { DEFAULT } from "../../shared/constant.js";
-import { a2s, s2a } from "../../shared/utils.js";
-import { divRoute } from "./utils.js";
+import { bi2s, s2bi } from "../../shared/utils.js";
+import { divInner } from "./utils.js";
 /** This function should divide numbers (as string). */
-export var div = function (strs, limit) {
-    if (limit === void 0) { limit = 20; }
-    if (strs[0] === "0")
-        return strs[0];
-    return a2s(divRoute(strs.map(function (str) { return s2a(str); }), DEFAULT, limit));
+export const div = (array, limit = 20) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = divInner(arrayInner, limit !== null && limit !== void 0 ? limit : 20);
+    return bi2s(bigInt, fpe);
 };

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

@@ -1,3 +1,2 @@
-import type { InputData } from "../../types.d.ts";
-export type DivInner = (L: [number[], number], R: [number[], number], isNegative: boolean, initLimit: number) => InputData;
-export type DivRoute = (input: InputData[], initValue: InputData, limit: number) => InputData;
+import type { BI } from "../../shared/types.d.ts";
+export type DivInner = (array: BI[], limit: number, def?: BI) => BI;

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

@@ -1,3 +1,2 @@
-import type { DivInner, DivRoute } from "./types.d.ts";
+import type { DivInner } from "./types.d.ts";
 export declare const divInner: DivInner;
-export declare const divRoute: DivRoute;

package/src/operations/div/utils.js

@@ -1,99 +1,39 @@
-import { NIL } from "../../shared/constant.js";
-export var divInner = function (_a, _b, isNegative, initLimit) {
-    var arrL = _a[0], intL = _a[1];
-    var arrR = _b[0], intR = _b[1];
-    var decDiff = (arrL.length - intL) - (arrR.length - intR);
-    var _c = [[arrR, 1], [arrL, -1]], L = _c[0], R = _c[1];
-    var _d = decDiff > 0 ? L : R, arr = _d[0], abs = _d[1];
-    for (var i = 0; i < decDiff * abs; i++) {
-        arr.push(48);
-    }
-    var digit = 48;
-    var limit = initLimit;
-    var isFloat = false;
-    var l = 0;
-    var r = arrR.length - 1;
-    var intLength = 0;
-    var result = [];
-    var lenArrayL = r - arrL.length;
-    for (var i = 0; i <= lenArrayL; i++) {
-        if (i === 0) {
-            isFloat = true;
-            intLength = 1;
-        }
-        result.push(48);
-        arrL.push(48);
-        limit -= 1;
-    }
-    while (r < arrL.length && limit >= 0) {
-        var comp = false;
-        if (arrL[l] === 48)
-            l += 1;
-        for (var i = 0; i < arrR.length; i++) {
-            if ((r - l + 1) < arrR.length)
-                comp = true;
-            if ((r - l + 1) !== arrR.length)
-                break;
-            if (arrL[l + i] !== arrR[i]) {
-                comp = arrL[l + i] < arrR[i];
-                break;
-            }
+export const divInner = (array, limit, def) => {
+    let bigInt = def ? def[0] : array[0][0];
+    let fpe = def ? def[1] : array[0][1];
+    const isNeg = bigInt < 0n;
+    for (let i = def ? 0 : 1; i < array.length; i++) {
+        let [bigCurrent, dpLen] = array[i];
+        let r = 0n;
+        if (bigInt === 0n && fpe === 0)
+            return [0n, 0];
+        if (fpe === dpLen) {
+            fpe = 0;
+            dpLen = 0;
         }
-        if (comp) {
-            if (r < arrL.length && (result.length > 0 || digit !== 48)) {
-                if (!isFloat)
-                    intLength += 1;
-                result.push(digit);
-            }
-            if (r >= arrL.length - 1) {
-                if (initLimit === limit)
-                    isFloat = true;
-                arrL.push(48);
-                limit -= 1;
-            }
-            r += 1;
-            digit = 48;
-            continue;
+        if (dpLen > 0 && fpe < dpLen) {
+            bigInt *= 10n ** BigInt(dpLen - fpe);
+            fpe = 0;
         }
-        for (var i = arrR.length - 1; i >= 0; i--) {
-            var idx = r - (arrR.length - 1 - i);
-            if (arrL[idx] < arrR[i]) {
-                arrL[idx] = arrL[idx] - arrR[i] + 58;
-                arrL[idx - 1] -= 1;
-            }
-            else {
-                arrL[idx] = arrL[idx] - arrR[i] + 48;
-            }
+        if (dpLen > 0 && fpe > dpLen)
+            fpe = fpe - dpLen;
+        while ((bigInt < 0 ? bigInt * -1n : bigInt) < bigCurrent) {
+            if (limit <= fpe)
+                return [bigInt / bigCurrent, fpe];
+            fpe += 1;
+            bigInt *= 10n;
         }
-        digit += 1;
-    }
-    var multipliedResult = [];
-    var count = 0;
-    if (result[0] === 48) {
-        var isGrZero = false;
-        for (var i = 0; i < result.length; i++) {
-            if (!isGrZero)
-                result[i] > 48 ? isGrZero = true : count += 1;
-            isGrZero && multipliedResult.push(result[i]);
-        }
-        for (var i = 0; i < count; i++) {
-            multipliedResult.push(48);
-            intLength -= 1;
+        const q = bigInt / bigCurrent;
+        r = bigInt - q * bigCurrent;
+        bigInt = q;
+        while ((isNeg ? r < 0n : r > 0n) && fpe < limit) {
+            const nextBigInt = r * 10n;
+            const nextQ = nextBigInt / bigCurrent;
+            const nextRemained = nextBigInt - nextQ * bigCurrent;
+            bigInt = bigInt * 10n + nextQ;
+            r = nextRemained;
+            fpe += 1;
         }
     }
-    return result.length === count
-        ? NIL
-        : {
-            array: result[0] === 48 ? multipliedResult : result,
-            isFloat: isFloat,
-            isNegative: isNegative,
-            intLength: intLength,
-        };
-};
-export var divRoute = function (input, initValue, limit) {
-    return input.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        return divInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, limit);
-    }, initValue);
+    return [bigInt, fpe];
 };

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

@@ -1,2 +1,2 @@
 /** This function multiplies numbers (as string). */
-export declare const mul: (strs: string[]) => string;
+export declare const mul: (array: string[]) => string;

package/src/operations/mul/main.js

@@ -1,7 +1,7 @@
-import { DEFAULT } from "../../shared/constant.js";
-import { a2s, s2a } from "../../shared/utils.js";
-import { mulRoute } from "./utils.js";
+import { bi2s, calcInner, s2bi } from "../../shared/utils.js";
 /** This function multiplies numbers (as string). */
-export var mul = function (strs) {
-    return a2s(mulRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
+export const mul = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a * b);
+    return bi2s(bigInt, fpe);
 };

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

@@ -1,2 +1,2 @@
 /** This function subtracts numbers (as string). */
-export declare function sub(strs: string[]): string;
+export declare function sub(array: string[]): string;