@numio/bigmath 2.2.5 → 2.2.7

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 2.2.7
+Throw an error if input is not valid. In the error show exact invalid input.
+
+### 2.2.6
+Optimize performance for small numbers (add operation)
+
 ### 2.2.5
 Handle "0B", "0X", "0O", "-0B", "-0X", "-0O" as a start of the input for toBase function.
 Move documentation from README.md to web-site http://numio.deno.dev

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": "2.2.5",
+  "version": "2.2.7",
   "keywords": [
     "precision",
     "arithmetic",

package/src/IQR/iqr.js

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

package/src/MAD/mad.js

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

package/src/abs/abs.js

@@ -2,6 +2,6 @@ import { bi2s, s2bi } from "../shared/utils.js";
 import { absInner } from "./utils.js";
 /** Get absolute value of a number */
 export const abs = (value) => {
-    const [bi, fpe] = absInner(s2bi(value));
-    return bi2s(bi, fpe);
+    const bi = absInner(s2bi(value));
+    return bi2s(bi);
 };

package/src/cbrt/cbrt.js

@@ -4,6 +4,6 @@ import { cbrtInner } from "./utils.js";
 /** Find cube root of a number */
 export const cbrt = (value, precision) => {
     const valueInner = s2bi(value);
-    const [[bi, fpe], decimals] = cbrtInner(valueInner, precision ? s2bi(precision) : undefined);
-    return round(bi2s(bi, fpe), { decimals });
+    const [bi, decimals] = cbrtInner(valueInner, precision ? s2bi(precision) : undefined);
+    return round(bi2s(bi), { decimals });
 };

package/src/compare/max.js

@@ -3,6 +3,6 @@ import { maxInner } from "./utils.js";
 /** This function returns max value. */
 export const max = (array) => {
     const arrayInner = array.map((str) => s2bi(str));
-    const [bi, fpe] = maxInner(arrayInner);
-    return bi2s(bi, fpe);
+    const bi = maxInner(arrayInner);
+    return bi2s(bi);
 };

package/src/compare/min.js

@@ -3,6 +3,6 @@ import { minInner } from "./utils.js";
 /** This function returns min value. */
 export const min = (array) => {
     const arrayInner = array.map((str) => s2bi(str));
-    const [bi, fpe] = minInner(arrayInner);
-    return bi2s(bi, fpe);
+    const bi = minInner(arrayInner);
+    return bi2s(bi);
 };

package/src/mean/mean.js

@@ -3,6 +3,6 @@ import { meanInner } from "./utils.js";
 /** This function returns mean of an array. */
 export const mean = (array) => {
     const arrayInner = array.map((str) => s2bi(str));
-    const [bi, fpe] = meanInner(arrayInner);
-    return bi2s(bi, fpe);
+    const bi = meanInner(arrayInner);
+    return bi2s(bi);
 };

package/src/operations/add/add.js

@@ -1,8 +1,32 @@
-import { bi2s, s2bi } from "../../shared/utils.js";
-import { calcInner } from "../../shared/utils.js";
+import { bi2s, s2bi, calcInner } from "../../shared/utils.js";
+const MAX_SUM = 8000000000000000;
+const MIN_SUM = -8000000000000000;
 /** This function adds numbers (as string). */
 export const add = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
-    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a + b);
-    return bi2s(bigInt, fpe);
+    const arrayInner = Array(array.length);
+    let sum = 0;
+    let i = 0;
+    let j = 0;
+    let fpi = 0;
+    while (i < array.length) {
+        fpi = array[i].indexOf(".");
+        if (array[i].length <= 15 && fpi === -1) {
+            sum += +array[i];
+        }
+        else {
+            arrayInner[j] = s2bi(array[i], fpi);
+            j += 1;
+        }
+        i += 1;
+        if (sum > MAX_SUM || sum < MIN_SUM) {
+            arrayInner[j] = [BigInt(sum), 0];
+            sum = 0;
+            j += 1;
+        }
+    }
+    if (i !== j)
+        arrayInner.length = j + 1;
+    arrayInner[j] = [BigInt(sum), 0];
+    const bi = calcInner(arrayInner, (a, b) => a + b);
+    return bi2s(bi);
 };

package/src/operations/div/div.js

@@ -3,6 +3,6 @@ import { divInner } from "./utils.js";
 /** This function should divide numbers (as string). */
 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);
+    const bi = divInner(arrayInner, limit !== null && limit !== void 0 ? limit : 20);
+    return bi2s(bi);
 };

package/src/operations/mul/mul.js

@@ -2,6 +2,6 @@ import { bi2s, calcInner, s2bi } from "../../shared/utils.js";
 /** This function multiplies numbers (as string). */
 export const mul = (array) => {
     const arrayInner = array.map((str) => s2bi(str));
-    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a * b);
-    return bi2s(bigInt, fpe);
+    const bi = calcInner(arrayInner, (a, b) => a * b);
+    return bi2s(bi);
 };

package/src/operations/sub/sub.js

@@ -3,6 +3,6 @@ import { calcInner } from "../../shared/utils.js";
 /** This function subtracts numbers (as string). */
 export function sub(array) {
     const arrayInner = array.map((str) => s2bi(str));
-    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a - b);
-    return bi2s(bigInt, fpe);
+    const bi = calcInner(arrayInner, (a, b) => a - b);
+    return bi2s(bi);
 }

package/src/pipe/pipe.js

@@ -50,8 +50,7 @@ export class Pipe {
         if (!__classPrivateFieldGet(this, _Pipe_result, "f")) {
             throw new Error("Cannot calculate based on an undefined input.");
         }
-        const [bi, fpe] = __classPrivateFieldGet(this, _Pipe_result, "f");
-        return bi2s(bi, fpe);
+        return bi2s(__classPrivateFieldGet(this, _Pipe_result, "f"));
     }
     resultToBase(radix) {
         var _a;

package/src/quartile/quartile.js

@@ -3,10 +3,10 @@ import { quartileInner } from "./utils.js";
 /** This function returns Q1, Q2, Q3 (quartile). */
 export const quartile = (array) => {
     const arrayInner = array.map((str) => s2bi(str));
-    const { Q1: [Q1bi, Q1fpe], Q2: [Q2bi, Q2fpe], Q3: [Q3bi, Q3fpe] } = quartileInner(arrayInner);
+    const { Q1, Q2, Q3 } = quartileInner(arrayInner);
     return {
-        Q1: bi2s(Q1bi, Q1fpe),
-        Q2: bi2s(Q2bi, Q2fpe),
-        Q3: bi2s(Q3bi, Q3fpe),
+        Q1: bi2s(Q1),
+        Q2: bi2s(Q2),
+        Q3: bi2s(Q3),
     };
 };

package/src/shared/types.d.ts

@@ -2,5 +2,6 @@ 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;
+export type BI2S = (value: BI) => string;
+export type S2BI = (str: string, fpi?: number) => BI;
+export type GetBigInt = (value: string, type: "di" | "hbo" | "si" | "reg", fpi: number) => bigint;

package/src/shared/utils.d.ts

@@ -1,6 +1,7 @@
-import type { BI2S, CalcInner, FillHead, S2BI, TrimTail } from "./types.d.ts";
+import type { BI2S, CalcInner, FillHead, GetBigInt, S2BI, TrimTail } from "./types.d.ts";
 export declare const bi2s: BI2S;
 export declare const s2bi: S2BI;
+export declare const getBigInt: GetBigInt;
 export declare const calcInner: CalcInner;
 export declare const fillHead: FillHead;
 export declare const trimTail: TrimTail;

package/src/shared/utils.js

@@ -1,4 +1,4 @@
-export const bi2s = (bigInt, fpe) => {
+export const bi2s = ([bigInt, fpe]) => {
     if (bigInt === 0n)
         return "0";
     const isNeg = bigInt < 0n;
@@ -16,32 +16,49 @@ export const bi2s = (bigInt, fpe) => {
     }
     return `${fillHead(bigStr.length, fpe, isNeg, false)}${trimTail(after)}`;
 };
-export const s2bi = (str) => {
-    const fpi = str.indexOf(".");
+export const s2bi = (str, _fpi) => {
+    const fpi = _fpi !== null && _fpi !== void 0 ? _fpi : str.indexOf(".");
     const isHex = str.startsWith("0x") || str.startsWith("-0x") ||
         str.startsWith("-0X") || str.startsWith("0X");
     const isOctal = str.startsWith("0o") || str.startsWith("-0o") ||
         str.startsWith("-0O") || str.startsWith("0O");
     const isBinary = str.startsWith("0b") || str.startsWith("-0b") ||
         str.startsWith("-0B") || str.startsWith("0B");
-    if (fpi === -1 && !isHex && !isOctal && !isBinary)
-        return [BigInt(str), 0];
+    if (fpi === -1 && !isHex && !isOctal && !isBinary) {
+        return [getBigInt(str, "di", fpi), 0];
+    }
     if (isHex || isBinary || isOctal) {
         const isNegative = str[0] === "-";
-        const bi = BigInt(str.slice(isNegative ? 1 : 0));
+        const bi = getBigInt(str, "hbo", fpi);
         return [isNegative ? -1n * bi : bi, 0];
     }
     if (str.length < 15 && str[0] !== "0") {
         return [
-            BigInt(+(str.slice(0, fpi) + str.slice(fpi + 1))),
+            getBigInt(str, "si", fpi),
             str.length - 1 - fpi,
         ];
     }
     return [
-        BigInt(str.slice(0, fpi) + str.slice(fpi + 1)),
+        getBigInt(str, "reg", fpi),
         str.length - 1 - fpi,
     ];
 };
+export const getBigInt = (value, type, fpi) => {
+    let bi = 0n;
+    const typeMap = {
+        di: value,
+        hbo: value.slice(value[0] === "-" ? 1 : 0),
+        si: +(value.slice(0, fpi) + value.slice(fpi + 1)),
+        reg: value.slice(0, fpi) + value.slice(fpi + 1),
+    };
+    try {
+        bi = BigInt(typeMap[type]);
+    }
+    catch (_) {
+        throw new Error(`${value} is not valid input`);
+    }
+    return bi;
+};
 export const calcInner = (array, op, def) => {
     let totalBi = def ? def[0] : array[0][0];
     let totalFpe = def ? def[1] : array[0][1];

package/src/sort/sort.js

@@ -5,5 +5,5 @@ import { sortInner } from "./utils.js";
 export const sort = (array, sorting = ASC) => {
     const arrayInner = array.map((str) => s2bi(str));
     sortInner(arrayInner, sorting);
-    return arrayInner.map(([bi, fpe]) => bi2s(bi, fpe));
+    return arrayInner.map((bi) => bi2s(bi));
 };

package/src/sqrt/sqrt.js

@@ -4,6 +4,6 @@ import { sqrtInner } from "./utils.js";
 /** Find square root of a number */
 export const sqrt = (value, precision) => {
     const valueInner = s2bi(value);
-    const [[bi, fpe], decimals] = sqrtInner(valueInner, precision ? s2bi(precision) : undefined);
-    return round(bi2s(bi, fpe), { decimals });
+    const [bi, decimals] = sqrtInner(valueInner, precision ? s2bi(precision) : undefined);
+    return round(bi2s(bi), { decimals });
 };