@numio/bigmath 2.2.7 → 2.3.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+### 2.3.1
+Fix import
+
+### 2.2.8
+Better error handling
+Add FDR - Freedman-Diaconis Rule
+MAD - median of the absolute deviations from `median` or `mean`
+
 ### 2.2.7
 Throw an error if input is not valid. In the error show exact invalid input.
 

package/README.md

@@ -1,68 +1,54 @@
 # @numio/bigmath: Precise Arithmetic Beyond JavaScript's Limits
 
-**Do you struggle with inaccurate calculations involving very large or very small numbers, or decimal numbers with high precision in JavaScript?**
-
-`@numio/bigmath` is your solution! This library provides a robust set of functions for performing **arbitrary-precision arithmetic**, effectively overcoming the limitations of JavaScript's built-in `Number` type. Say goodbye to unexpected rounding errors and precision loss when dealing with numbers that exceed 15 significant digits or involve complex decimal operations.
-
-## Why Choose @numio/bigmath?
-
-**Solve Precision Problems:**
-
-* **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.
-* ****NEW! Number Format Validation:** Easily validate if a string represents a valid **hexadecimal (`isHex`)**, **binary (`isBinary`)**, **decimal (`isDecimal`)**, **octal (`isOctal`)**, or any valid **number (`isNumber`)** format supported by the library.
-
-
-
-**Unlock Advanced Numerical Operations:**
-
-* **Control Division Precision:** Specify the exact number of digits after the decimal point for division results, with a default precision of 20 digits for high accuracy.
-* **Flexible Rounding:** Round numbers to the nearest integer or a specific number of decimal places with various rounding modes (up, down, half-up, half-down, half-even, half-odd) to meet your exact requirements.
-* **Round Based on Significant Figures:** Control rounding based on the number of significant figures, crucial for scientific and engineering applications.
-* **Calculate Roots:**
-    * **Calculate Square Root (`sqrt`):** Compute the square root of a number with arbitrary precision. You can also specify the desired precision of the result.
-    * ****NEW! Calculate Cube Root (`cbrt`):** Determine the cube root of a number with arbitrary precision, allowing you to specify the desired accuracy.
-
-* **Chain Operations with Pipe:** Simplify complex calculations by chaining arithmetic operations in a readable and intuitive manner.
-* **Analyze Data Distribution:**
-    * **Calculate Quartiles (Q1, Q2, Q3):** Understand the spread and central tendency of your numerical data, helping identify outliers and the shape of the distribution.
-    * **Calculate Median Absolute Deviation (MAD):** Measure the dispersion of a dataset, providing a robust alternative to standard deviation that is less sensitive to outliers.
-    * **Calculate Interquartile Range (IQR):** Determine the spread of the middle 50% of your data, useful for identifying the central bulk and potential outliers.
-* **Compare Numbers:**
-    * **Check for Equality (`isEqual`):** Accurately determine if two arbitrary-precision numbers are equal.
-    * **Check if Left is Greater (`isLeftGreater`):** Precisely compare two arbitrary-precision numbers to see if the left operand is greater than the right.
-    * ****NEW! Check if Left is Greater or Equal (`isLeftGreaterOrEqual`):** Precisely compare two arbitrary-precision numbers to determine if the left operand is greater than or equal to the right.
-* **Sort Numbers Accurately:** Sort arrays of numbers, including negative and decimal values, in ascending or descending order, correctly handling string representations of numbers that JavaScript's native sort might misinterpret.
-* **Calculate Central Tendency:** Easily compute the mean (average) of a set of numbers.
-* **Identify Extremes:** Find the maximum and minimum values within an array of numbers.
-* ****NEW! Calculate Absolute Value (`abs`):** Determine the non-negative value of a number, regardless of its sign.
-* ****NEW! Convert Number to Another Base (`toBase`):** Seamlessly convert numbers between decimal, hexadecimal (HEX), binary, and octal representations.
-
-## When is @numio/bigmath essential?
-
-This library is particularly invaluable in applications where numerical accuracy and the ability to handle large numbers are paramount:
-
-* **Financial Applications:** Accurate calculations for large sums of money, precise interest rates, and complex financial modeling.
-* **Scientific Computing:** Working with extremely large or small numbers in simulations, data analysis, and research.
-* **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
-
-**New Functions added:**
-
-* `isHex` - Checks if a string is a valid hexadecimal number (prefixed with `0x` or `-0x`).
-* `isBinary` - Checks if a string is a valid binary number (prefixed with `0b` or `-0b`).
-* `isDecimal` - Checks if a string is a valid decimal number.
-* `isOctal` - Checks if a string is a valid octal number (prefixed with `0o` or `-0o`).
-* `isNumber` - Checks if a string is a valid number in any of the formats supported by the library (decimal, hexadecimal, binary, octal).
+@numio/bigmath is a powerful and reliable JavaScript library designed for precise numerical computations, overcoming common limitations of standard JavaScript number handling. It provides a rich set of functionalities for arithmetic, statistical analysis, data manipulation, and number base conversions, ensuring accuracy even with extremely large numbers and solving notorious floating-point precision issues like `0.1 + 0.2 !== 0.3`.
+
+
+## Latest Update
+
+This update introduces several enhancements and new functionalities:
+
+- **Improved Error Handling:** The application now features more robust error handling to provide clearer feedback and prevent unexpected crashes.
+- **Freedman-Diaconis Rule (FDR):** Added the Freedman-Diaconis rule for optimal binwidth estimation in histogram creation.
+- **Median Absolute Deviation (MAD):** Implemented calculation for the Median Absolute Deviation, allowing users to compute it based on either the `median` or the `mean` of the dataset.
+
+## Existing Functionality
+
+The application currently supports the following operations:
+
+- **Arithmetic:**
+    - `add`: Addition of numbers.
+    - `sub`: Subtraction of numbers.
+    - `mul`: Multiplication of numbers.
+    - `div`: Division of numbers.
+- **Rounding:**
+    - `round`: Rounding numbers to a specified number of decimal places.
+- **Data Manipulation:**
+    - `pipe`: Chaining operations together.
+    - `sort`: Sorting arrays.
+- **Statistical Measures:**
+    - `quartile`: Calculating quartiles of a dataset.
+    - `mean`: Calculating the average of a dataset.
+    - `max`: Finding the maximum value in a dataset.
+    - `min`: Finding the minimum value in a dataset.
+    - `MAD`: Calculating the Median Absolute Deviation (based on either median or mean).
+    - `IQR`: Calculating the Interquartile Range.
+- **Comparison:**
+    - `isEqual`: Checking if two values are equal.
+    - `isLeftGreater`: Checking if the left value is greater than the right value.
+    - `isLeftGreaterOrEqual`: Checking if the left value is greater than or equal to the right value.
+- **Mathematical Functions:**
+    - `sqrt`: Calculating the square root of a number.
+    - `cbrt`: Calculating the cube root of a number.
+    - `abs`: Calculating the absolute value of a number.
+- **Number Base Conversion:**
+    - `toBase`: Converting a number to a specified base.
+    - `isHex`: Checking if a string is a valid hexadecimal number.
+    - `isBinary`: Checking if a string is a valid binary number.
+    - `isDecimal`: Checking if a string is a valid decimal number.
+    - `isOctal`: Checking if a string is a valid octal number.
+    - `isNumber`: Checking if a value is a number.
+- **Utility:**
+    - `Benchmark`: Functionality for benchmarking code execution.
 
 # Install:
 

package/index.d.ts

@@ -23,4 +23,5 @@ import { isBinary } from "./src/isValid/isBinary.d.ts";
 import { isDecimal } from "./src/isValid/isDecimal.d.ts";
 import { isOctal } from "./src/isValid/isOctal.d.ts";
 import { isNumber } from "./src/isValid/isNumber.d.ts";
-export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, isHex, isBinary, isDecimal, isOctal, isNumber };
+import { FDR } from "./src/FDR/fdr.d.ts";
+export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, isHex, isBinary, isDecimal, isOctal, isNumber, FDR };

package/index.js

@@ -23,4 +23,5 @@ import { isBinary } from "./src/isValid/isBinary.js";
 import { isDecimal } from "./src/isValid/isDecimal.js";
 import { isOctal } from "./src/isValid/isOctal.js";
 import { isNumber } from "./src/isValid/isNumber.js";
-export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, isHex, isBinary, isDecimal, isOctal, isNumber };
+import { FDR } from "./src/FDR/fdr.js";
+export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, isHex, isBinary, isDecimal, isOctal, isNumber, FDR };

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.7",
+  "version": "2.3.1",
   "keywords": [
     "precision",
     "arithmetic",
@@ -52,7 +52,9 @@
     "binary",
     "decimal",
     "binary",
-    "cube root"
+    "cube root",
+    "FDR",
+    "Freedman-Diaconis Rule"
   ],
   "repository": {
     "type": "git",

package/src/FDR/fdr.d.ts

@@ -0,0 +1,2 @@
+import type { TFDR } from "./types.d.ts";
+export declare const FDR: TFDR;

package/src/FDR/fdr.js

@@ -0,0 +1,18 @@
+import { bi2s, s2bi } from "../shared/utils.js";
+import { fdrInner } from "./utils.js";
+export const FDR = (array, options) => {
+    var _a, _b, _c;
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
+    const { binWidth, binsNum } = fdrInner(arrayInner, {
+        useMadAbove: (_a = options === null || options === void 0 ? void 0 : options.useMadAbove) !== null && _a !== void 0 ? _a : 0,
+        maxBinNumber: (_b = options === null || options === void 0 ? void 0 : options.maxBinNumber) !== null && _b !== void 0 ? _b : 90,
+        madFrom: (_c = options === null || options === void 0 ? void 0 : options.madFrom) !== null && _c !== void 0 ? _c : "median",
+    });
+    return {
+        binsNum: bi2s(binsNum),
+        binWidth: bi2s(binWidth),
+    };
+};

package/src/FDR/types.d.ts

@@ -0,0 +1,21 @@
+import type { MADFrom } from "../MAD/types.d.ts";
+import type { BI } from "../shared/types.d.ts";
+type Options = {
+    useMadAbove?: number;
+    maxBinNumber?: number;
+    madFrom?: MADFrom;
+};
+type OptionsInner = {
+    useMadAbove: number;
+    maxBinNumber: number;
+    madFrom: MADFrom;
+};
+export type FDRInner = (array: BI[], options: OptionsInner) => {
+    binWidth: BI;
+    binsNum: BI;
+};
+export type TFDR = (array: string[], options?: Options) => {
+    binWidth: string;
+    binsNum: string;
+};
+export {};

package/src/FDR/utils.d.ts

@@ -0,0 +1,2 @@
+import type { FDRInner } from "./types.d.ts";
+export declare const fdrInner: FDRInner;

package/src/FDR/utils.js

@@ -0,0 +1,34 @@
+import { cbrtInner } from "../cbrt/utils.js";
+import { isLeftGreaterOrEqualInner } from "../compare/utils.js";
+import { IQRInner } from "../IQR/utils.js";
+import { MADInner } from "../MAD/utils.js";
+import { divInner } from "../operations/div/utils.js";
+import { PipeInner } from "../pipe/utils.js";
+import { tryBigInt } from "../shared/utils.js";
+const getBinsNum = (range, binWidth) => {
+    let binsNum = new PipeInner().div([range, binWidth], 10).bi;
+    if (binsNum[1] > 0) {
+        binsNum = [new PipeInner().div([range, binWidth], 0).bi[0] + 1n, 0];
+    }
+    return binsNum;
+};
+export const fdrInner = (array, options = { useMadAbove: 0, maxBinNumber: 90, madFrom: "mean" }) => {
+    const mad = MADInner(array, { from: options.madFrom });
+    const nonNilMad = mad[0] <= 0n ? [1n, 0] : mad;
+    const IQR = IQRInner(array);
+    const isMadUsed = array.length < options.useMadAbove || IQR[0] === 0n;
+    const validIQR = isMadUsed ? nonNilMad : IQR;
+    const [cbrtLen] = cbrtInner([tryBigInt(array.length), 0]);
+    const binWidth = new PipeInner().mul([[2n, 0], validIQR]).div([cbrtLen]).bi;
+    const range = new PipeInner().sub([array[array.length - 1], array[0]]).bi;
+    const binsNum = getBinsNum(range, binWidth);
+    const maxBinNum = [tryBigInt(options.maxBinNumber), 0];
+    const scale = isLeftGreaterOrEqualInner({ left: binsNum, right: maxBinNum })
+        ? divInner([binsNum, maxBinNum], 20)
+        : [1n, 0];
+    const scaledBinWidth = new PipeInner().mul([binWidth, scale]).bi;
+    return {
+        binWidth: scaledBinWidth,
+        binsNum: getBinsNum(range, scaledBinWidth),
+    };
+};

package/src/IQR/iqr.js

@@ -1,8 +1,11 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { IQRInner } from "./utils.js";
 //** This function returns Interquartile Range */
-export const IQR = (array, sigNum) => {
-    const arrayInner = array.map((str) => s2bi(str));
-    const bi = IQRInner(arrayInner, sigNum);
+export const IQR = (array) => {
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
+    const bi = IQRInner(arrayInner);
     return bi2s(bi);
 };

package/src/IQR/types.d.ts

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

package/src/IQR/utils.d.ts

@@ -1,3 +1,2 @@
 import type { TIQRInner } from "./types.d.ts";
-export declare const MIN_LENGTH_FOR_MAD = 30;
 export declare const IQRInner: TIQRInner;

package/src/IQR/utils.js

@@ -1,20 +1,10 @@
-import { isEqualInner } from "../compare/utils.js";
-import { MADInner } from "../MAD/utils.js";
 import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-export const MIN_LENGTH_FOR_MAD = 30;
-export const IQRInner = (array, sigNum = false) => {
+export const IQRInner = (array) => {
     if (array.length < 3) {
         throw Error("To calculate IQR you need at least 3 elements");
     }
     const { Q1, Q3 } = quartileInner(array);
-    const sub = new PipeInner().sub([Q3, Q1]).calc();
-    if (sigNum) {
-        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;
-    }
+    const { bi: sub } = new PipeInner().sub([Q3, Q1]);
     return sub;
 };

package/src/MAD/mad.js

@@ -1,8 +1,11 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { MADInner } from "./utils.js";
 //** This function returns Median Absolute Deviation */
-export const MAD = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
-    const bi = MADInner(arrayInner);
+export const MAD = (array, options = { from: "median" }) => {
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
+    const bi = MADInner(arrayInner, options);
     return bi2s(bi);
 };

package/src/MAD/types.d.ts

@@ -1,3 +1,8 @@
 import type { BI } from "../shared/types.d.ts";
-export type TMAD = (array: string[]) => string;
-export type TMADInner = (array: BI[]) => BI;
+export type MADFrom = "mean" | "median";
+type Options = {
+    from: MADFrom;
+};
+export type TMAD = (array: string[], options?: Options) => string;
+export type TMADInner = (array: BI[], options: Options) => BI;
+export {};

package/src/MAD/utils.js

@@ -1,15 +1,18 @@
+import { meanInner } from "../mean/utils.js";
 import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
 import { ASC } from "../sort/constants.js";
 import { sortInner } from "../sort/utils.js";
-export const MADInner = (array) => {
+export const MADInner = (array, { from }) => {
     if (array.length < 3) {
         throw Error("To calculate MAD you need at least 3 elements");
     }
-    const median = quartileInner(array).Q2;
+    const fromMap = {
+        median: quartileInner(array).Q2,
+        mean: meanInner(array)
+    };
     const madArray = array.map((el) => {
-        const [bi, fpe] = new PipeInner().sub([el, median]).calc();
-        return bi < 0n ? [bi * -1n, fpe] : [bi, fpe];
+        return new PipeInner().sub([el, fromMap[from]]).abs().bi;
     });
     const sorted = sortInner(madArray, ASC);
     return quartileInner(sorted).Q2;

package/src/cbrt/utils.js

@@ -3,21 +3,18 @@ import { divInner } from "../operations/div/utils.js";
 import { PipeInner } from "../pipe/utils.js";
 import { calcInner } from "../shared/utils.js";
 export const cbrtInner = (value, prec = [1n, 13], max = 100) => {
-    var _a, _b;
     if (value[0] < 0n) {
         throw new Error("Invalid input: Cannot take the cube root of a negative value.");
     }
     let guess = value;
     for (let i = 0; i < max; i++) {
         const mul = calcInner([guess, guess], (a, b) => a * b);
-        const nextGuess = (_a = new PipeInner().add([
+        const { bi: nextGuess } = new PipeInner().add([
             calcInner([guess, [2n, 0]], (a, b) => a * b),
             divInner([value, mul], 20),
-        ]).div([[3n, 0]]).result) !== null && _a !== void 0 ? _a : [0n, 0];
-        let [bi, fpe] = (_b = new PipeInner().sub([nextGuess, guess]).result) !== null && _b !== void 0 ? _b : [0n, 0];
-        if (bi < 0n)
-            bi *= -1n;
-        if (isLeftGreaterInner({ left: prec, right: [bi, fpe] })) {
+        ]).div([[3n, 0]]);
+        const { bi } = new PipeInner().sub([nextGuess, guess]).abs();
+        if (isLeftGreaterInner({ left: prec, right: bi })) {
             return [nextGuess, prec[1]];
         }
         guess = nextGuess;

package/src/compare/max.js

@@ -2,7 +2,11 @@ import { bi2s, s2bi } from "../shared/utils.js";
 import { maxInner } from "./utils.js";
 /** This function returns max value. */
 export const max = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
+    ;
     const bi = maxInner(arrayInner);
     return bi2s(bi);
 };

package/src/compare/min.js

@@ -2,7 +2,11 @@ import { bi2s, s2bi } from "../shared/utils.js";
 import { minInner } from "./utils.js";
 /** This function returns min value. */
 export const min = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
+    ;
     const bi = minInner(arrayInner);
     return bi2s(bi);
 };

package/src/compare/utils.js

@@ -1,3 +1,4 @@
+import { tryBigInt } from "../shared/utils.js";
 export const maxInner = (array) => {
     let max = array[0];
     for (let i = 1; i < array.length; i++) {
@@ -36,8 +37,8 @@ export const compareInner = (l, r) => {
             if (fpeL === fpeR)
                 return [l, 0];
         }
-        const fpeBiL = BigInt(fpeL);
-        const fpeBiR = BigInt(fpeR);
+        const fpeBiL = tryBigInt(fpeL);
+        const fpeBiR = tryBigInt(fpeR);
         const max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
         const powL = biL * 10n ** (max - fpeBiL);
         const powR = biR * 10n ** (max - fpeBiR);
@@ -55,8 +56,8 @@ export const compareInner = (l, r) => {
             if (fpeL === fpeR)
                 return [l, 0];
         }
-        const fpeBiL = BigInt(fpeL);
-        const fpeBiR = BigInt(fpeR);
+        const fpeBiL = tryBigInt(fpeL);
+        const fpeBiR = tryBigInt(fpeR);
         const max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
         const powL = biL * 10n ** (max - fpeBiL);
         const powR = biR * 10n ** (max - fpeBiR);

package/src/mean/mean.js

@@ -2,7 +2,10 @@ import { bi2s, s2bi } from "../shared/utils.js";
 import { meanInner } from "./utils.js";
 /** This function returns mean of an array. */
 export const mean = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
     const bi = meanInner(arrayInner);
     return bi2s(bi);
 };

package/src/mean/utils.js

@@ -1,6 +1,8 @@
 import { PipeInner } from "../pipe/utils.js";
+import { tryBigInt } from "../shared/utils.js";
 export const meanInner = (array) => {
-    const left = new PipeInner().add(array).calc();
-    const right = [BigInt(array.length), 0];
-    return new PipeInner().div([left, right]).calc();
+    return new PipeInner().div([
+        new PipeInner().add(array).bi,
+        [tryBigInt(array.length), 0]
+    ]).bi;
 };

package/src/operations/add/add.js

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

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

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

package/src/operations/div/div.js

@@ -1,8 +1,11 @@
 import { bi2s, s2bi } from "../../shared/utils.js";
 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 bi = divInner(arrayInner, limit !== null && limit !== void 0 ? limit : 20);
+export const div = (array, precision = 20) => {
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
+    const bi = divInner(arrayInner, precision !== null && precision !== void 0 ? precision : 20);
     return bi2s(bi);
 };

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

@@ -1,2 +1,2 @@
 import type { BI } from "../../shared/types.d.ts";
-export type DivInner = (array: BI[], limit: number, def?: BI) => BI;
+export type DivInner = (array: BI[], precision: number, def?: BI) => BI;

package/src/operations/div/utils.js

@@ -1,4 +1,5 @@
-export const divInner = (array, limit, def) => {
+import { tryBigInt } from "../../shared/utils.js";
+export const divInner = (array, precision, def) => {
     let bigInt = def ? def[0] : array[0][0];
     let fpe = def ? def[1] : array[0][1];
     const isNeg = bigInt < 0n;
@@ -12,13 +13,13 @@ export const divInner = (array, limit, def) => {
             dpLen = 0;
         }
         if (dpLen > 0 && fpe < dpLen) {
-            bigInt *= 10n ** BigInt(dpLen - fpe);
+            bigInt *= 10n ** tryBigInt(dpLen - fpe);
             fpe = 0;
         }
         if (dpLen > 0 && fpe > dpLen)
             fpe = fpe - dpLen;
         while ((bigInt < 0 ? bigInt * -1n : bigInt) < bigCurrent) {
-            if (limit <= fpe)
+            if (precision <= fpe)
                 return [bigInt / bigCurrent, fpe];
             fpe += 1;
             bigInt *= 10n;
@@ -26,7 +27,7 @@ export const divInner = (array, limit, def) => {
         const q = bigInt / bigCurrent;
         r = bigInt - q * bigCurrent;
         bigInt = q;
-        while ((isNeg ? r < 0n : r > 0n) && fpe < limit) {
+        while ((isNeg ? r < 0n : r > 0n) && fpe < precision) {
             const nextBigInt = r * 10n;
             const nextQ = nextBigInt / bigCurrent;
             const nextRemained = nextBigInt - nextQ * bigCurrent;

package/src/operations/mul/mul.js

@@ -1,7 +1,10 @@
 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 arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
     const bi = calcInner(arrayInner, (a, b) => a * b);
     return bi2s(bi);
 };

package/src/operations/sub/sub.js

@@ -2,7 +2,10 @@ import { bi2s, s2bi } from "../../shared/utils.js";
 import { calcInner } from "../../shared/utils.js";
 /** This function subtracts numbers (as string). */
 export function sub(array) {
-    const arrayInner = array.map((str) => s2bi(str));
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
     const bi = calcInner(arrayInner, (a, b) => a - b);
     return bi2s(bi);
 }

package/src/pipe/pipe.d.ts

@@ -5,7 +5,7 @@ export declare class Pipe {
     constructor(value?: string);
     add(array: string[]): Pipe;
     sub(array: string[]): Pipe;
-    div(array: string[], limit?: number): Pipe;
+    div(array: string[], precision?: number): Pipe;
     mul(array: string[]): Pipe;
     abs(): Pipe;
     calc(): ReturnType<BI2S>;

package/src/pipe/pipe.js

@@ -29,9 +29,9 @@ export class Pipe {
         __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => a - b, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     }
-    div(array, limit = 20) {
+    div(array, precision = 20) {
         const arrayInner = array.map((str) => s2bi(str));
-        __classPrivateFieldSet(this, _Pipe_result, divInner(arrayInner, limit, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+        __classPrivateFieldSet(this, _Pipe_result, divInner(arrayInner, precision, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     }
     mul(array) {

package/src/pipe/utils.d.ts

@@ -4,7 +4,8 @@ export declare class PipeInner {
     constructor();
     add(array: BI[]): PipeInner;
     sub(array: BI[]): PipeInner;
-    div(array: BI[], limit?: number): PipeInner;
+    div(array: BI[], precision?: number): PipeInner;
     mul(array: BI[]): PipeInner;
-    calc(): BI;
+    abs(): PipeInner;
+    get bi(): BI;
 }

package/src/pipe/utils.js

@@ -1,5 +1,6 @@
 import { calcInner } from "../shared/utils.js";
 import { divInner } from "../operations/div/utils.js";
+import { absInner } from "../abs/utils.js";
 export class PipeInner {
     constructor() { }
     add(array) {
@@ -10,17 +11,20 @@ export class PipeInner {
         this.result = calcInner(array, (a, b) => a - b, this.result);
         return this;
     }
-    div(array, limit = 20) {
-        this.result = divInner(array, limit, this.result);
+    div(array, precision = 20) {
+        this.result = divInner(array, precision, this.result);
         return this;
     }
     mul(array) {
         this.result = calcInner(array, (a, b) => a * b, this.result);
         return this;
     }
-    calc() {
+    abs() {
+        this.result && (this.result = absInner(this.result));
+        return this;
+    }
+    get bi() {
         var _a;
-        const res = (_a = this.result) !== null && _a !== void 0 ? _a : [0n, 0];
-        return res;
+        return (_a = this.result) !== null && _a !== void 0 ? _a : [0n, 0];
     }
 }

package/src/quartile/quartile.js

@@ -2,7 +2,10 @@ import { bi2s, s2bi } from "../shared/utils.js";
 import { quartileInner } from "./utils.js";
 /** This function returns Q1, Q2, Q3 (quartile). */
 export const quartile = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
     const { Q1, Q2, Q3 } = quartileInner(arrayInner);
     return {
         Q1: bi2s(Q1),

package/src/quartile/utils.js

@@ -1,7 +1,7 @@
 import { PipeInner } from "../pipe/utils.js";
 const meanQ = (idx, array) => {
-    const left = new PipeInner().add([array[idx], array[idx - 1]]).calc();
-    return new PipeInner().div([left, [2n, 0]]).calc();
+    const { bi: left } = new PipeInner().add([array[idx], array[idx - 1]]);
+    return new PipeInner().div([left, [2n, 0]]).bi;
 };
 export const quartileInner = (array) => {
     if (array.length < 3) {

package/src/shared/types.d.ts

@@ -4,4 +4,3 @@ export type TrimTail = (str: string) => string;
 export type CalcInner = (array: BI[], op: (a: bigint, b: bigint) => bigint, def?: BI) => 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,7 +1,8 @@
-import type { BI2S, CalcInner, FillHead, GetBigInt, S2BI, TrimTail } from "./types.d.ts";
+import type { BI2S, CalcInner, FillHead, 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;
+export declare const tryBigInt: <T extends number | string>(value: T) => bigint;
+export declare const tryNumber: (value: string, origin?: string) => number;

package/src/shared/utils.js

@@ -3,7 +3,7 @@ export const bi2s = ([bigInt, fpe]) => {
         return "0";
     const isNeg = bigInt < 0n;
     isNeg && (bigInt *= -1n);
-    const dp = bigInt % (10n ** BigInt(fpe));
+    const dp = bigInt % (10n ** tryBigInt(fpe));
     const bigStr = bigInt.toString();
     let fpIdx = bigStr.length - fpe;
     if (fpIdx < 0)
@@ -24,41 +24,24 @@ export const s2bi = (str, _fpi) => {
         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 [getBigInt(str, "di", fpi), 0];
-    }
+    if (fpi === -1 && !isHex && !isOctal && !isBinary)
+        return [tryBigInt(str), 0];
     if (isHex || isBinary || isOctal) {
         const isNegative = str[0] === "-";
-        const bi = getBigInt(str, "hbo", fpi);
+        const bi = tryBigInt(str.slice(isNegative ? 1 : 0));
         return [isNegative ? -1n * bi : bi, 0];
     }
     if (str.length < 15 && str[0] !== "0") {
         return [
-            getBigInt(str, "si", fpi),
+            tryBigInt(tryNumber(str.slice(0, fpi) + str.slice(fpi + 1), str)),
             str.length - 1 - fpi,
         ];
     }
     return [
-        getBigInt(str, "reg", fpi),
+        tryBigInt(str.slice(0, fpi) + str.slice(fpi + 1)),
         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];
@@ -76,10 +59,10 @@ export const calcInner = (array, op, def) => {
         else {
             if (totalFpe < fpe) {
                 const fpDiff = fpe - totalFpe;
-                totalBi = op(totalBi * (10n ** BigInt(fpDiff)), bi);
+                totalBi = op(totalBi * (10n ** tryBigInt(fpDiff)), bi);
             }
             if (totalFpe > fpe) {
-                totalBi = op(totalBi, bi * (10n ** BigInt(totalFpe - fpe)));
+                totalBi = op(totalBi, bi * (10n ** tryBigInt(totalFpe - fpe)));
             }
             if (totalFpe === fpe)
                 totalBi = op(totalBi, bi);
@@ -108,3 +91,19 @@ export const trimTail = (str) => {
     }
     return str;
 };
+export const tryBigInt = (value) => {
+    let bi;
+    try {
+        bi = BigInt(value);
+    }
+    catch (_) {
+        throw new Error(`Invalid input: ${value}`);
+    }
+    return bi;
+};
+export const tryNumber = (value, origin = value) => {
+    const num = +value;
+    if (Number.isNaN(num))
+        throw new Error(`Invalid input: ${origin}`);
+    return num;
+};

package/src/sort/sort.js

@@ -3,7 +3,10 @@ import { ASC } from "./constants.js";
 import { sortInner } from "./utils.js";
 /** Using this function sort an array. */
 export const sort = (array, sorting = ASC) => {
-    const arrayInner = array.map((str) => s2bi(str));
+    const arrayInner = Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        arrayInner[i] = s2bi(array[i]);
+    }
     sortInner(arrayInner, sorting);
     return arrayInner.map((bi) => bi2s(bi));
 };

package/src/sqrt/utils.js

@@ -1,20 +1,17 @@
 import { isLeftGreaterInner } from "../compare/utils.js";
 import { PipeInner } from "../pipe/utils.js";
 export const sqrtInner = (value, prec = [1n, 13], max = 100) => {
-    var _a;
     if (value[0] < 0n) {
         throw new Error("Invalid input: Cannot take the square root of a negative value.");
     }
     let guess = value;
     for (let i = 0; i < max; i++) {
-        const nextGuess = (_a = new PipeInner()
+        const { bi: nextGuess } = new PipeInner()
             .div([value, guess])
             .add([guess])
-            .mul([[5n, 1]]).result) !== null && _a !== void 0 ? _a : [0n, 0];
-        let [bi, fpe] = new PipeInner().sub([nextGuess, guess]).calc();
-        if (bi < 0n)
-            bi *= -1n;
-        if (isLeftGreaterInner({ left: prec, right: [bi, fpe] })) {
+            .mul([[5n, 1]]);
+        const { bi } = new PipeInner().sub([nextGuess, guess]).abs();
+        if (isLeftGreaterInner({ left: prec, right: bi })) {
             return [nextGuess, prec[1]];
         }
         guess = nextGuess;