@numio/bigmath 1.0.11 → 2.0.0

package/README.md

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

package/index.d.ts

@@ -1,7 +1,7 @@
-import { add } from "./src/mathOperations/add/main.d.ts";
-import { mul } from "./src/mathOperations/mul/main.d.ts";
-import { sub } from "./src/mathOperations/sub/main.d.ts";
-import { div } from "./src/mathOperations/div/main.d.ts";
+import { add } from "./src/operations/add/main.d.ts";
+import { mul } from "./src/operations/mul/main.d.ts";
+import { sub } from "./src/operations/sub/main.d.ts";
+import { div } from "./src/operations/div/main.d.ts";
 import { round } from "./src/round/main.d.ts";
 import { pipe } from "./src/pipe/main.d.ts";
 import { quartile } from "./src/quartile/main.d.ts";
@@ -10,4 +10,5 @@ import { mean } from "./src/mean/main.d.ts";
 import { isEqual, isLeftGreater, max, min } from "./src/compare/main.d.ts";
 import { IQR } from "./src/IQR/main.d.ts";
 import { MAD } from "./src/MAD/main.d.ts";
-export { add, div, IQR, isEqual, isLeftGreater, MAD, max, mean, min, mul, pipe, quartile, round, sort, sub, };
+import { sqrt } from "./src/sqrt/main.d.ts";
+export { add, div, IQR, isEqual, isLeftGreater, MAD, max, mean, min, mul, pipe, quartile, round, sort, sub, sqrt, };

package/index.js

@@ -1,7 +1,7 @@
-import { add } from "./src/mathOperations/add/main.js";
-import { mul } from "./src/mathOperations/mul/main.js";
-import { sub } from "./src/mathOperations/sub/main.js";
-import { div } from "./src/mathOperations/div/main.js";
+import { add } from "./src/operations/add/main.js";
+import { mul } from "./src/operations/mul/main.js";
+import { sub } from "./src/operations/sub/main.js";
+import { div } from "./src/operations/div/main.js";
 import { round } from "./src/round/main.js";
 import { pipe } from "./src/pipe/main.js";
 import { quartile } from "./src/quartile/main.js";
@@ -10,4 +10,5 @@ import { mean } from "./src/mean/main.js";
 import { isEqual, isLeftGreater, max, min } from "./src/compare/main.js";
 import { IQR } from "./src/IQR/main.js";
 import { MAD } from "./src/MAD/main.js";
-export { add, div, IQR, isEqual, isLeftGreater, MAD, max, mean, min, mul, pipe, quartile, round, sort, sub, };
+import { sqrt } from "./src/sqrt/main.js";
+export { add, div, IQR, isEqual, isLeftGreater, MAD, max, mean, min, mul, pipe, quartile, round, sort, sub, sqrt, };

package/package.json

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

package/src/IQR/main.js

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

package/src/IQR/types.d.ts

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

package/src/IQR/utils.js

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

package/src/MAD/main.js

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

package/src/MAD/types.d.ts

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

package/src/MAD/utils.js

@@ -1,14 +1,12 @@
-import { subRoute } from "../mathOperations/sub/utils.js";
+import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-import { DEFAULT } from "../shared/constant.js";
 import { ASC } from "../sort/constants.js";
 import { sortInner } from "../sort/utils.js";
 export var MADInner = function (array) {
     var median = quartileInner(array).Q2;
     var madArray = array.map(function (el) {
-        var res = subRoute([structuredClone(el), structuredClone(median)], DEFAULT);
-        res.isNegative = false;
-        return res;
+        var _a = new PipeInner().sub([el, median]).calc(), bi = _a[0], fpe = _a[1];
+        return bi < 0n ? [bi * -1n, fpe] : [bi, fpe];
     });
     var sorted = sortInner(madArray, ASC);
     return quartileInner(sorted).Q2;

package/src/compare/main.js

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

package/src/compare/types.d.ts

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

package/src/compare/utils.js

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

package/src/mean/main.js

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

package/src/mean/types.d.ts

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

package/src/mean/utils.js

@@ -1,10 +1,6 @@
-import { addRoute } from "../mathOperations/add/utils.js";
-import { divInner } from "../mathOperations/div/utils.js";
-import { DEFAULT } from "../shared/constant.js";
-import { s2a } from "../shared/utils.js";
+import { PipeInner } from "../pipe/utils.js";
 export var meanInner = function (array) {
-    var left = addRoute(array, DEFAULT);
-    var right = s2a(array.length.toString());
-    var res = divInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, 20);
-    return res;
+    var left = new PipeInner().add(array).calc();
+    var right = [BigInt(array.length), 0];
+    return new PipeInner().div([left, right]).calc();
 };

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

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

package/src/operations/add/main.js

@@ -0,0 +1,8 @@
+import { bi2s, s2bi } from "../../shared/utils.js";
+import { calcInner } from "../../shared/utils.js";
+/** This function adds numbers (as string). */
+export var add = function (array) {
+    var arrayInner = array.map(function (str) { return s2bi(str); });
+    var _a = calcInner(arrayInner, function (a, b) { return a + b; }), bigInt = _a[0], fpe = _a[1];
+    return bi2s(bigInt, fpe);
+};

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

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

package/src/operations/div/main.js

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

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

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

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

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

package/src/operations/div/utils.js

@@ -0,0 +1,39 @@
+export var divInner = function (array, limit, def) {
+    var bigInt = def ? def[0] : array[0][0];
+    var fpe = def ? def[1] : array[0][1];
+    var isNeg = bigInt < 0n;
+    for (var i = def ? 0 : 1; i < array.length; i++) {
+        var _a = array[i], bigCurrent = _a[0], dpLen = _a[1];
+        var r = 0n;
+        if (bigInt === 0n && fpe === 0)
+            return [0n, 0];
+        if (fpe === dpLen) {
+            fpe = 0;
+            dpLen = 0;
+        }
+        if (dpLen > 0 && fpe < dpLen) {
+            bigInt *= Math.pow(10n, BigInt(dpLen - fpe));
+            fpe = 0;
+        }
+        if (dpLen > 0 && fpe > dpLen)
+            fpe = fpe - dpLen;
+        while ((bigInt < 0 ? bigInt * -1n : bigInt) < bigCurrent) {
+            if (limit <= fpe)
+                return [bigInt / bigCurrent, fpe];
+            fpe += 1;
+            bigInt *= 10n;
+        }
+        var q = bigInt / bigCurrent;
+        r = bigInt - q * bigCurrent;
+        bigInt = q;
+        while ((isNeg ? r < 0n : r > 0n) && fpe < limit) {
+            var nextBigInt = r * 10n;
+            var nextQ = nextBigInt / bigCurrent;
+            var nextRemained = nextBigInt - nextQ * bigCurrent;
+            bigInt = bigInt * 10n + nextQ;
+            r = nextRemained;
+            fpe += 1;
+        }
+    }
+    return [bigInt, fpe];
+};

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

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

package/src/operations/mul/main.js

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

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

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

package/src/operations/sub/main.js

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

package/src/pipe/main.d.ts

@@ -1,13 +1,12 @@
-import type { A2S } from "../shared/types.d.ts";
-import type { InputData } from "../types.d.ts";
+import type { BI2S } from "../shared/types.d.ts";
 export declare class Pipe {
-    result: InputData;
-    constructor(array: InputData);
-    add(strs: string[]): Pipe;
-    sub(strs: string[]): Pipe;
-    div(strs: string[], limit?: number): Pipe;
-    mul(strs: string[]): Pipe;
-    calc(): ReturnType<A2S>;
+    #private;
+    constructor();
+    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;