@numio/bigmath 1.1.0 → 2.0.1

package/src/operations/sub/main.js

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

package/src/pipe/main.d.ts

@@ -1,12 +1,12 @@
-import type { A2S } from "../shared/types.d.ts";
+import type { BI2S } from "../shared/types.d.ts";
 export declare class Pipe {
     #private;
     constructor();
-    add(strs: string[]): Pipe;
-    sub(strs: string[]): Pipe;
-    div(strs: string[], limit?: number): Pipe;
-    mul(strs: string[]): Pipe;
-    calc(): ReturnType<A2S>;
+    add(array: string[]): Pipe;
+    sub(array: string[]): Pipe;
+    div(array: string[], limit?: number): Pipe;
+    mul(array: string[]): Pipe;
+    calc(): ReturnType<BI2S>;
 }
 /** Using this function you can chain operations (add, sub, div, mul). */
 export declare const pipe: Pipe;

package/src/pipe/main.js

@@ -1,51 +1,49 @@
+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";
-var Pipe = /** @class */ (function () {
-    function Pipe() {
+import { bi2s, calcInner, s2bi } from "../shared/utils.js";
+import { divInner } from "../operations/div/utils.js";
+export class Pipe {
+    constructor() {
         _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");
+    add(array) {
+        const arrayInner = array.map((str) => s2bi(str));
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => 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");
+    }
+    sub(array) {
+        const arrayInner = array.map((str) => s2bi(str));
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => a - b, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
-    };
-    Pipe.prototype.div = function (strs, 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");
+    }
+    div(array, limit = 20) {
+        const arrayInner = array.map((str) => 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");
+    }
+    mul(array) {
+        const arrayInner = array.map((str) => s2bi(str));
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => 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");
+    }
+    calc() {
+        var _a;
+        const [bi, fpe] = (_a = __classPrivateFieldGet(this, _Pipe_result, "f")) !== null && _a !== void 0 ? _a : [0n, 0];
+        const result = bi2s(bi, fpe);
+        __classPrivateFieldSet(this, _Pipe_result, undefined, "f");
         return result;
-    };
-    return Pipe;
-}());
-export { Pipe };
+    }
+}
 _Pipe_result = new WeakMap();
 /** Using this function you can chain operations (add, sub, div, mul). */
-export var pipe = new Pipe();
+export const pipe = new 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,34 +1,26 @@
-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";
-var PipeInner = /** @class */ (function () {
-    function PipeInner() {
-        this.result = DEFAULT;
-    }
-    PipeInner.prototype.addInner = function (array) {
-        this.result = addRoute(array, cloneInner(this.result));
+import { calcInner } from "../shared/utils.js";
+import { divInner } from "../operations/div/utils.js";
+export class PipeInner {
+    constructor() { }
+    add(array) {
+        this.result = calcInner(array, (a, b) => a + b, this.result);
         return this;
-    };
-    PipeInner.prototype.subInner = function (array) {
-        this.result = subRoute(array, cloneInner(this.result));
+    }
+    sub(array) {
+        this.result = calcInner(array, (a, b) => a - b, this.result);
         return this;
-    };
-    PipeInner.prototype.divInner = function (array) {
-        this.result = divRoute(array, cloneInner(this.result), 20);
+    }
+    div(array, limit = 20) {
+        this.result = divInner(array, limit, this.result);
         return this;
-    };
-    PipeInner.prototype.mulInner = function (array) {
-        this.result = mulRoute(array, cloneInner(this.result));
+    }
+    mul(array) {
+        this.result = calcInner(array, (a, b) => a * b, this.result);
         return this;
-    };
-    PipeInner.prototype.calc = function () {
-        var result = a2s(this.result);
-        this.result = DEFAULT;
-        return result;
-    };
-    return PipeInner;
-}());
-export { PipeInner };
+    }
+    calc() {
+        var _a;
+        const res = (_a = this.result) !== null && _a !== void 0 ? _a : [0n, 0];
+        return res;
+    }
+}

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 const quartile = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const { Q1: [Q1bi, Q1fpe], Q2: [Q2bi, Q2fpe], Q3: [Q3bi, Q3fpe] } = quartileInner(arrayInner);
     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,25 +1,17 @@
 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;
+const meanQ = (idx, array) => {
+    const left = new PipeInner().add([array[idx], array[idx - 1]]).calc();
+    return new PipeInner().div([left, [2n, 0]]).calc();
 };
-export var quartileInner = function (array) {
+export const quartileInner = (array) => {
     if (array.length < 3) {
         throw Error("To calculate quartile you need at least 3 elements");
     }
-    var length = array.length;
-    var Q2Idx = length >> 1;
-    var Q1Idx = Q2Idx >> 1;
-    var Q3Idx = length - Q1Idx;
-    var isEvenHalf = Q2Idx % 2 !== 0;
+    const { length } = array;
+    const Q2Idx = length >> 1;
+    const Q1Idx = Q2Idx >> 1;
+    const Q3Idx = length - Q1Idx;
+    const isEvenHalf = Q2Idx % 2 !== 0;
     return {
         Q1: isEvenHalf ? array[Q1Idx] : meanQ(Q1Idx, array),
         Q2: length % 2 !== 0 ? array[Q2Idx] : meanQ(Q2Idx, array),

package/src/round/constants.js

@@ -1,10 +1,10 @@
-export var UP = "up";
-export var DOWN = "down";
-export var HALF_UP = "half-up";
-export var HALF_DOWN = "half-down";
-export var HALF_EVEN = "half-even";
-export var HALF_ODD = "half-odd";
-export var ROUND_MODE = [
+export const UP = "up";
+export const DOWN = "down";
+export const HALF_UP = "half-up";
+export const HALF_DOWN = "half-down";
+export const HALF_EVEN = "half-even";
+export const HALF_ODD = "half-odd";
+export const ROUND_MODE = [
     UP,
     DOWN,
     HALF_UP,

package/src/round/main.js

@@ -1,17 +1,16 @@
 import { HALF_UP } from "./constants.js";
 import { calcLast, handleCarryOver, handleTail } from "./utils.js";
 /** This function round number. */
-export var round = function (value, options) {
-    var _a;
-    var _b, _c, _d, _e;
-    var roundMode = (_b = options === null || options === void 0 ? void 0 : options.roundMode) !== null && _b !== void 0 ? _b : HALF_UP;
-    var array = [];
-    var sigFig = (_c = options === null || options === void 0 ? void 0 : options.sigFig) !== null && _c !== void 0 ? _c : false;
-    var decimals = (_d = options === null || options === void 0 ? void 0 : options.decimals) !== null && _d !== void 0 ? _d : 0;
-    var isFloat = false;
-    var isNil = true;
-    for (var i = 0; i < value.length; i++) {
-        var charCode = value.charCodeAt(i);
+export const round = (value, options) => {
+    var _a, _b, _c, _d;
+    const roundMode = (_a = options === null || options === void 0 ? void 0 : options.roundMode) !== null && _a !== void 0 ? _a : HALF_UP;
+    let array = [];
+    let sigFig = (_b = options === null || options === void 0 ? void 0 : options.sigFig) !== null && _b !== void 0 ? _b : false;
+    let decimals = (_c = options === null || options === void 0 ? void 0 : options.decimals) !== null && _c !== void 0 ? _c : 0;
+    let isFloat = false;
+    let isNil = true;
+    for (let i = 0; i < value.length; i++) {
+        const charCode = value.charCodeAt(i);
         if (sigFig && charCode > 48)
             sigFig = false;
         if (isNil && charCode > 48)
@@ -21,14 +20,14 @@ export var round = function (value, options) {
         if (charCode === 46)
             isFloat = true;
         if (isFloat && decimals === 0) {
-            var next = (_e = value.charCodeAt(i + 1)) !== null && _e !== void 0 ? _e : 0;
-            var prev = value.charCodeAt(i - 1);
-            var curr = charCode === 46 ? prev : charCode;
-            var _f = calcLast(curr, next, roundMode), last = _f[0], hasCarryOver = _f[1];
+            const next = (_d = value.charCodeAt(i + 1)) !== null && _d !== void 0 ? _d : 0;
+            const prev = value.charCodeAt(i - 1);
+            const curr = charCode === 46 ? prev : charCode;
+            const [last, hasCarryOver] = calcLast(curr, next, roundMode);
             if (charCode === 46)
                 isFloat = false;
             if (hasCarryOver) {
-                _a = handleCarryOver(array, isFloat), array = _a[0], isFloat = _a[1];
+                [array, isFloat] = handleCarryOver(array, isFloat);
                 break;
             }
             charCode === 46
@@ -41,5 +40,5 @@ export var round = function (value, options) {
     handleTail(array, isFloat);
     return (isNil && array[array.length - 1] <= 48)
         ? "0"
-        : String.fromCharCode.apply(String, array);
+        : String.fromCharCode(...array);
 };

package/src/round/utils.js

@@ -1,6 +1,6 @@
 import { DOWN, HALF_DOWN, HALF_EVEN, HALF_ODD, HALF_UP, UP, } from "./constants.js";
-export var handleTail = function (array, isFloat) {
-    var lastIdx = array.length - 1;
+export const handleTail = (array, isFloat) => {
+    let lastIdx = array.length - 1;
     while (isFloat && array[lastIdx] <= 48) {
         if (array[lastIdx] === 46 || array.length === 1)
             isFloat = false;
@@ -8,53 +8,52 @@ export var handleTail = function (array, isFloat) {
         lastIdx -= 1;
     }
 };
-export var handleCarryOver = function (array, isFloat) {
+export const handleCarryOver = (array, isFloat) => {
     var _a;
-    var hasCarryOver = true;
-    var idx = array.length - 1;
-    var mapFloat = new Map([
-        [57, function () {
+    let hasCarryOver = true;
+    let idx = array.length - 1;
+    const mapFloat = new Map([
+        [57, () => {
                 array.pop();
                 idx -= 1;
             }],
-        [46, function () {
+        [46, () => {
                 array.pop();
                 idx -= 1;
                 isFloat = false;
             }],
-        [0, function () {
+        [0, () => {
                 array[idx] += 1;
                 hasCarryOver = false;
             }],
     ]);
-    var mapInt = new Map([
-        [57, function () {
+    const mapInt = new Map([
+        [57, () => {
                 array[idx] = 48;
                 idx -= 1;
             }],
-        [0, function () {
+        [0, () => {
                 array[idx] += 1;
                 hasCarryOver = false;
             }],
     ]);
     while (hasCarryOver && idx >= 0) {
-        var map = isFloat ? mapFloat : mapInt;
-        var key = map.has(array[idx]) ? array[idx] : 0;
+        const map = isFloat ? mapFloat : mapInt;
+        const key = map.has(array[idx]) ? array[idx] : 0;
         (_a = map.get(key)) === null || _a === void 0 ? void 0 : _a();
     }
     hasCarryOver && array.unshift(49);
     return [array, isFloat];
 };
-export var calcLast = function (current, next, roundMode) {
-    var _a;
-    var isEven = current % 2 === 1;
-    var map = (_a = {},
-        _a[UP] = current + (next > 48 ? 1 : 0),
-        _a[DOWN] = current,
-        _a[HALF_UP] = current + (next >= 53 ? 1 : 0),
-        _a[HALF_DOWN] = current + (next > 53 ? 1 : 0),
-        _a[HALF_EVEN] = current + ((isEven && next >= 53) ? 1 : 0),
-        _a[HALF_ODD] = current + ((!isEven && next >= 53) ? 1 : 0),
-        _a);
+export const calcLast = (current, next, roundMode) => {
+    const isEven = current % 2 === 1;
+    const map = {
+        [UP]: current + (next > 48 ? 1 : 0),
+        [DOWN]: current,
+        [HALF_UP]: current + (next >= 53 ? 1 : 0),
+        [HALF_DOWN]: current + (next > 53 ? 1 : 0),
+        [HALF_EVEN]: current + ((isEven && next >= 53) ? 1 : 0),
+        [HALF_ODD]: current + ((!isEven && next >= 53) ? 1 : 0),
+    };
     return map[roundMode] > 57 ? [48, true] : [map[roundMode], false];
 };

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 = {
+export const 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;