@numio/bigmath 1.1.0 → 2.0.0

package/src/pipe/main.js

@@ -1,46 +1,47 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var _Pipe_result;
-import { DEFAULT } from "../shared/constant.js";
-import { a2s, s2a } from "../shared/utils.js";
-import { subRoute } from "../operations/sub/utils.js";
-import { addRoute } from "../operations/add/utils.js";
-import { divRoute } from "../operations/div/utils.js";
-import { mulRoute } from "../operations/mul/utils.js";
+import { bi2s, calcInner, s2bi } from "../shared/utils.js";
+import { divInner } from "../operations/div/utils.js";
 var Pipe = /** @class */ (function () {
     function Pipe() {
         _Pipe_result.set(this, void 0);
-        __classPrivateFieldSet(this, _Pipe_result, DEFAULT, "f");
     }
-    Pipe.prototype.add = function (strs) {
-        __classPrivateFieldSet(this, _Pipe_result, addRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+    Pipe.prototype.add = function (array) {
+        var arrayInner = array.map(function (str) { return s2bi(str); });
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, function (a, b) { return a + b; }, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
-    Pipe.prototype.sub = function (strs) {
-        __classPrivateFieldSet(this, _Pipe_result, subRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+    Pipe.prototype.sub = function (array) {
+        var arrayInner = array.map(function (str) { return s2bi(str); });
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, function (a, b) { return a - b; }, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
-    Pipe.prototype.div = function (strs, limit) {
+    Pipe.prototype.div = function (array, limit) {
         if (limit === void 0) { limit = 20; }
-        __classPrivateFieldSet(this, _Pipe_result, divRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f"), limit), "f");
+        var arrayInner = array.map(function (str) { return s2bi(str); });
+        __classPrivateFieldSet(this, _Pipe_result, divInner(arrayInner, limit, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
-    Pipe.prototype.mul = function (strs) {
-        __classPrivateFieldSet(this, _Pipe_result, mulRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+    Pipe.prototype.mul = function (array) {
+        var arrayInner = array.map(function (str) { return s2bi(str); });
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, function (a, b) { return a * b; }, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
     Pipe.prototype.calc = function () {
-        var result = a2s(__classPrivateFieldGet(this, _Pipe_result, "f"));
-        __classPrivateFieldSet(this, _Pipe_result, DEFAULT, "f");
+        var _a;
+        var _b = (_a = __classPrivateFieldGet(this, _Pipe_result, "f")) !== null && _a !== void 0 ? _a : [0n, 0], bi = _b[0], fpe = _b[1];
+        var result = bi2s(bi, fpe);
+        __classPrivateFieldSet(this, _Pipe_result, undefined, "f");
         return result;
     };
     return Pipe;

package/src/pipe/utils.d.ts

@@ -1,11 +1,10 @@
-import type { A2S } from "../shared/types.d.ts";
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 export declare class PipeInner {
-    result: InputData;
+    result: BI | undefined;
     constructor();
-    addInner(array: InputData[]): PipeInner;
-    subInner(array: InputData[]): PipeInner;
-    divInner(array: InputData[]): PipeInner;
-    mulInner(array: InputData[]): PipeInner;
-    calc(): ReturnType<A2S>;
+    add(array: BI[]): PipeInner;
+    sub(array: BI[]): PipeInner;
+    div(array: BI[], limit?: number): PipeInner;
+    mul(array: BI[]): PipeInner;
+    calc(): BI;
 }

package/src/pipe/utils.js

@@ -1,33 +1,29 @@
-import { DEFAULT } from "../shared/constant.js";
-import { a2s, cloneInner } from "../shared/utils.js";
-import { subRoute } from "../operations/sub/utils.js";
-import { addRoute } from "../operations/add/utils.js";
-import { divRoute } from "../operations/div/utils.js";
-import { mulRoute } from "../operations/mul/utils.js";
+import { calcInner } from "../shared/utils.js";
+import { divInner } from "../operations/div/utils.js";
 var PipeInner = /** @class */ (function () {
     function PipeInner() {
-        this.result = DEFAULT;
     }
-    PipeInner.prototype.addInner = function (array) {
-        this.result = addRoute(array, cloneInner(this.result));
+    PipeInner.prototype.add = function (array) {
+        this.result = calcInner(array, function (a, b) { return a + b; }, this.result);
         return this;
     };
-    PipeInner.prototype.subInner = function (array) {
-        this.result = subRoute(array, cloneInner(this.result));
+    PipeInner.prototype.sub = function (array) {
+        this.result = calcInner(array, function (a, b) { return a - b; }, this.result);
         return this;
     };
-    PipeInner.prototype.divInner = function (array) {
-        this.result = divRoute(array, cloneInner(this.result), 20);
+    PipeInner.prototype.div = function (array, limit) {
+        if (limit === void 0) { limit = 20; }
+        this.result = divInner(array, limit, this.result);
         return this;
     };
-    PipeInner.prototype.mulInner = function (array) {
-        this.result = mulRoute(array, cloneInner(this.result));
+    PipeInner.prototype.mul = function (array) {
+        this.result = calcInner(array, function (a, b) { return a * b; }, this.result);
         return this;
     };
     PipeInner.prototype.calc = function () {
-        var result = a2s(this.result);
-        this.result = DEFAULT;
-        return result;
+        var _a;
+        var res = (_a = this.result) !== null && _a !== void 0 ? _a : [0n, 0];
+        return res;
     };
     return PipeInner;
 }());

package/src/quartile/main.js

@@ -1,12 +1,12 @@
-import { a2s, s2a } from "../shared/utils.js";
+import { bi2s, s2bi } from "../shared/utils.js";
 import { quartileInner } from "./utils.js";
 /** This function returns Q1, Q2, Q3 (quartile). */
-export var quartile = function (strs) {
-    var array = strs.map(function (str) { return s2a(str); });
-    var Qs = quartileInner(array);
+export var quartile = function (array) {
+    var arrayInner = array.map(function (str) { return s2bi(str); });
+    var _a = quartileInner(arrayInner), _b = _a.Q1, Q1bi = _b[0], Q1fpe = _b[1], _c = _a.Q2, Q2bi = _c[0], Q2fpe = _c[1], _d = _a.Q3, Q3bi = _d[0], Q3fpe = _d[1];
     return {
-        Q1: a2s(Qs.Q1),
-        Q2: a2s(Qs.Q2),
-        Q3: a2s(Qs.Q3),
+        Q1: bi2s(Q1bi, Q1fpe),
+        Q2: bi2s(Q2bi, Q2fpe),
+        Q3: bi2s(Q3bi, Q3fpe),
     };
 };

package/src/quartile/types.d.ts

@@ -1,12 +1,12 @@
-import type { InputData } from "../types.d.ts";
+import type { BI } from "../shared/types.d.ts";
 export type Quartile = (array: string[]) => {
     Q1: string;
     Q2: string;
     Q3: string;
 };
-export type MeanQ = (index: number, array: InputData[]) => InputData;
-export type QuartileInner = (array: InputData[]) => {
-    Q1: InputData;
-    Q2: InputData;
-    Q3: InputData;
+export type MeanQ = (index: number, array: BI[]) => BI;
+export type QuartileInner = (array: BI[]) => {
+    Q1: BI;
+    Q2: BI;
+    Q3: BI;
 };

package/src/quartile/utils.js

@@ -1,15 +1,7 @@
 import { PipeInner } from "../pipe/utils.js";
-import { cloneInner } from "../shared/utils.js";
 var meanQ = function (idx, array) {
-    return new PipeInner().addInner([
-        cloneInner(array[idx]),
-        cloneInner(array[idx - 1]),
-    ]).divInner([{
-            array: [50],
-            intLength: 1,
-            isFloat: false,
-            isNegative: false,
-        }]).result;
+    var left = new PipeInner().add([array[idx], array[idx - 1]]).calc();
+    return new PipeInner().div([left, [2n, 0]]).calc();
 };
 export var quartileInner = function (array) {
     if (array.length < 3) {

package/src/shared/constant.d.ts

@@ -1,18 +1,6 @@
-export declare const DEFAULT: {
-    array: any[];
-    intLength: number;
-    isFloat: boolean;
-    isNegative: boolean;
-};
 export declare const NIL: {
     array: number[];
     isFloat: boolean;
     isNegative: boolean;
     intLength: number;
 };
-export declare const ONE: {
-    array: number[];
-    isFloat: boolean;
-    isNegative: boolean;
-    intLength: number;
-};

package/src/shared/constant.js

@@ -1,18 +1,6 @@
-export var DEFAULT = {
-    array: [],
-    intLength: 0,
-    isFloat: false,
-    isNegative: false,
-};
 export var NIL = {
     array: [48],
     isFloat: false,
     isNegative: false,
     intLength: 1,
 };
-export var ONE = {
-    array: [49],
-    isFloat: false,
-    isNegative: false,
-    intLength: 1,
-};

package/src/shared/types.d.ts

@@ -1,5 +1,6 @@
-import type { InputData } from "../types.d.ts";
-export type A2S = (input: InputData) => string;
-export type S2A = (strings: string) => InputData;
-export type Convert = (isNegative: InputData["isNegative"], array: InputData["array"]) => string;
-export type CloneInner = (inner: InputData) => InputData;
+export type BI = [bigint, number];
+export type FillHead = (len: number, fpe: number, isNeg: boolean, hasBefore: boolean) => string;
+export type TrimTail = (str: string) => string;
+export type CalcInner = (array: BI[], op: (a: bigint, b: bigint) => bigint, def?: BI) => BI;
+export type BI2S = (bigInt: bigint, fpe: number) => string;
+export type S2BI = (str: string) => BI;

package/src/shared/utils.d.ts

@@ -1,4 +1,6 @@
-import type { A2S, CloneInner, S2A } from "./types.d.ts";
-export declare const a2s: A2S;
-export declare const s2a: S2A;
-export declare const cloneInner: CloneInner;
+import type { BI2S, CalcInner, FillHead, S2BI, TrimTail } from "./types.d.ts";
+export declare const bi2s: BI2S;
+export declare const s2bi: S2BI;
+export declare const calcInner: CalcInner;
+export declare const fillHead: FillHead;
+export declare const trimTail: TrimTail;

package/src/shared/utils.js

@@ -1,83 +1,76 @@
-var convert = function (isNegative, array) {
-    return (isNegative ? "-" : "") + String.fromCharCode.apply(String, array);
+export var bi2s = function (bigInt, fpe) {
+    if (bigInt === 0n)
+        return "0";
+    var isNeg = bigInt < 0n;
+    isNeg && (bigInt *= -1n);
+    var dp = bigInt % (Math.pow(10n, BigInt(fpe)));
+    var bigStr = bigInt.toString();
+    var fpIdx = bigStr.length - fpe;
+    if (fpIdx < 0)
+        fpIdx = 0;
+    var before = bigStr.slice(0, fpIdx);
+    var after = bigStr.slice(fpIdx);
+    if (before) {
+        return fillHead(bigStr.length, fpe, isNeg, true) +
+            (fpe > 0 && dp > 0 ? trimTail("".concat(before, ".").concat(after)) : before);
+    }
+    return "".concat(fillHead(bigStr.length, fpe, isNeg, false)).concat(trimTail(after));
+};
+export var s2bi = function (str) {
+    var 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 var calcInner = function (array, op, def) {
+    var bigInt = def ? def[0] : array[0][0];
+    var fpe = def ? def[1] : array[0][1];
+    var opm = op(1n, 1n);
+    for (var i = def ? 0 : 1; i < array.length; i++) {
+        var _a = array[i], bigCurrent = _a[0], dpLen = _a[1];
+        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) {
+                var fpDiff = dpLen - fpe;
+                bigInt = op(bigInt * (Math.pow(10n, BigInt(fpDiff))), bigCurrent);
             }
+            if (fpe > dpLen) {
+                bigInt = op(bigInt, bigCurrent * (Math.pow(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 var fillHead = function (len, fpe, isNeg, hasBefore) {
+    var 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 var trimTail = function (str) {
+    if (str[str.length - 1] !== "0")
+        return str;
+    var count = 0;
+    for (var 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/main.js

@@ -1,10 +1,13 @@
-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); });
+    var arrayInner = array.map(function (str) { return s2bi(str); });
+    sortInner(arrayInner, sorting);
+    return arrayInner.map(function (_a) {
+        var bi = _a[0], fpe = _a[1];
+        return 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/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 });
+    var inputInner = s2bi(str);
+    var _a = sqrtInner(inputInner, precision ? s2bi(precision) : undefined), _b = _a[0], bi = _b[0], fpe = _b[1], decimals = _a[1];
+    var outputStr = bi2s(bi, fpe);
+    return round(outputStr, { decimals: 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,24 @@
 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,
-};
+var halfInner = [5n, 1];
+var precDef = [1n, 13];
 export var sqrtInner = function (input, prec, max) {
     if (prec === void 0) { prec = precDef; }
     if (max === void 0) { max = 100; }
-    var guess = cloneInner(input);
+    var guess = 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];
+            .div([input, guess])
+            .add([guess])
+            .mul([halfInner])
+            .calc();
+        var _a = new PipeInner().sub([nextGuess, guess]).calc(), bi = _a[0], fpe = _a[1];
+        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;