@numio/bigmath 1.0.2 → 1.0.4

package/README.md

@@ -1,37 +1,56 @@
 # @numio/bigmath
 
-@numio/bigmath is an arbitrary-precision arithmetic library. This library provides functions for performing arithmetic operations (addition, subtraction, multiplication, and division) on numbers of arbitrary length. It addresses the limitations of JavaScript's built-in number type, which suffers from precision loss when dealing with very large or very small numbers, or numbers with more than 15 significant digits.
-
+@numio/bigmath is an arbitrary-precision arithmetic library. This library
+provides functions for performing arithmetic operations (addition, subtraction,
+multiplication, and division) on numbers of arbitrary length. It addresses the
+limitations of JavaScript's built-in number type, which suffers from precision
+loss when dealing with very large or very small numbers, or numbers with more
+than 15 significant digits.
 
 ## Key Features and Benefits
 
-* **Arbitrary Precision:** Handles numbers of any length, avoiding the limitations of JavaScript's `Number` type. This allows for calculations with extremely large or small numbers without loss of precision.
-* **No Precision Loss:** Eliminates precision errors that occur when using numeric literals with more than 15 significant digits. The library ensures accurate calculations even with very long numbers.
-* **Four Basic Operations:** Provides functions for addition (`add`), subtraction (`sub`), multiplication (`mul`), and division (`div`).
-* **Decimal Handling:** Correctly handles decimal numbers and performs calculations accurately, including scenarios involving negative numbers.
-* **Division Precision Control:** The `div` function allows you to specify the number of digits after the decimal point for the result. The default precision is 20 digits.
-* **Easy to Use:** The library provides simple and intuitive functions for performing arithmetic operations.
-
+- **Arbitrary Precision:** Handles numbers of any length, avoiding the
+  limitations of JavaScript's `Number` type. This allows for calculations with
+  extremely large or small numbers without loss of precision.
+- **No Precision Loss:** Eliminates precision errors that occur when using
+  numeric literals with more than 15 significant digits. The library ensures
+  accurate calculations even with very long numbers.
+- **Four Basic Operations:** Provides functions for addition (`add`),
+  subtraction (`sub`), multiplication (`mul`), and division (`div`).
+- **Decimal Handling:** Correctly handles decimal numbers and performs
+  calculations accurately, including scenarios involving negative numbers.
+- **Division Precision Control:** The `div` function allows you to specify the
+  number of digits after the decimal point for the result. The default precision
+  is 20 digits.
+- **Easy to Use:** The library provides simple and intuitive functions for
+  performing arithmetic operations.
 
 ## How it Solves the Problem
 
-JavaScript's `Number` type uses a 64-bit floating-point representation (IEEE 754), which can lead to precision issues when dealing with numbers that exceed its representable range or require more than 15 significant digits. This library likely uses a different representation internally (e.g., strings or arrays of digits) to store and manipulate numbers, effectively bypassing the limitations of the built-in `Number` type. This allows it to perform calculations on numbers of virtually unlimited size and maintain accuracy.
+JavaScript's `Number` type uses a 64-bit floating-point representation (IEEE
+754), which can lead to precision issues when dealing with numbers that exceed
+its representable range or require more than 15 significant digits. This library
+likely uses a different representation internally (e.g., strings or arrays of
+digits) to store and manipulate numbers, effectively bypassing the limitations
+of the built-in `Number` type. This allows it to perform calculations on numbers
+of virtually unlimited size and maintain accuracy.
 
 ## Use Cases
 
-This library is particularly useful in scenarios where precise calculations with large numbers are essential, such as:
-
-* **Financial applications:** Dealing with large sums of money or precise interest calculations.
-* **Scientific computing:** Working with very large or small numbers in scientific simulations.
-* **Cryptography:** Implementing cryptographic algorithms that require high precision.
-* **Any application** where exceeding JavaScript's number limits is a concern.
+This library is particularly useful in scenarios where precise calculations with
+large numbers are essential, such as:
 
+- **Financial applications:** Dealing with large sums of money or precise
+  interest calculations.
+- **Scientific computing:** Working with very large or small numbers in
+  scientific simulations.
+- **Cryptography:** Implementing cryptographic algorithms that require high
+  precision.
+- **Any application** where exceeding JavaScript's number limits is a concern.
 
 ### Latest update
 
-In version 1.0.0 arguments for calculation changed to array, which increases performance dramatically \
-In version 0.3.0 added handling of negative numbers \
-In version 0.2.0 added division (int & float numbers)
+Added pipe functionality
 
 # Install:
 
@@ -78,6 +97,7 @@ const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
 ```
 
 ### Subtract numbers
+
 ```javascript
 import { sub } from "@numio/bigmath";
 
@@ -87,6 +107,7 @@ const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
 ```
 
 ### Multiply numbers
+
 ```javascript
 import { mul } from "@numio/bigmath";
 
@@ -96,10 +117,11 @@ const negative = mul(["-2", "3"]); // -6
 ```
 
 ### Divide numbers
+
 ```javascript
 import { div } from "@numio/bigmath";
 
-const int = div(["9999", "33"]); // 
+const int = div(["9999", "33"]); //
 const float = div(["0.06", "0.2"]); // 0.3
 const negative = div(["-2", "-3", "2"]); // 3
 
@@ -107,6 +129,88 @@ const negative = div(["-2", "-3", "2"]); // 3
 div("10", "3"); // 3.33333
 ```
 
+### Round
+
+```javascript
+import { round } from "@numio/bigmath";
+
+round("-1.12345"); // -1
+round("1.5"); // 2
+round("1.0"); // 1
+round("0.00001"); // 0
+round("9.9"); // 10
+```
+
+### Round at position
+
+```javascript
+import { round } from "@numio/bigmath";
+
+round("1.12345", { decimals: 1 }); // 1.1
+round("1.12345", { decimals: 2 }); // 1.12
+round("1.12234", { decimals: 0 }); // 1
+round("9.999", { decimals: 2 }); // 10
+```
+
+### Round modes
+
+```javascript
+import { round } from "@numio/bigmath";
+
+round("1.11", { decimals: 1, roundMode: "up" }); // 1.2
+round("1.19", { decimals: 1, roundMode: "up" }); // 1.2
+
+round("1.11", { decimals: 1, roundMode: "down" }); // 1.1
+round("1.19", { decimals: 1, roundMode: "down" }); // 1.1
+
+round("1.15", { decimals: 1, roundMode: "half-up" }); // 1.2
+round("1.15", { decimals: 1, roundMode: "half-down" }); // 1.1
+
+round("1.15", { decimals: 1, roundMode: "half-even" }); // 1.2
+round("1.25", { decimals: 1, roundMode: "half-even" }); // 1.2
+round("1.35", { decimals: 1, roundMode: "half-even" }); // 1.4
+round("1.45", { decimals: 1, roundMode: "half-even" }); // 1.4
+round("1.55", { decimals: 1, roundMode: "half-even" }); // 1.6
+
+round("1.15", { decimals: 1, roundMode: "half-odd" }); // 1.1
+round("1.25", { decimals: 1, roundMode: "half-odd" }); // 1.3
+round("1.35", { decimals: 1, roundMode: "half-odd" }); // 1.3
+round("1.45", { decimals: 1, roundMode: "half-odd" }); // 1.5
+round("1.55", { decimals: 1, roundMode: "half-odd" }); // 1.5
+```
+
+### Round with "significant figures" flag
+
+```javascript
+import { round } from "@numio/bigmath";
+
+round("0.000119", { decimals: 2, sigFig: false }); // 0
+round("0.000119", { decimals: 2, sigFig: true }); // 0.00012
+
+round("0.0019", { decimals: 1, sigFig: true, roundMode: "down" }); // 0.001
+round("0.0011", { decimals: 1, sigFig: true, roundMode: "up" }); // 0.002
+
+round("1.000119", { decimals: 2, sigFig: false }); // 1
+round("1.000119", { decimals: 2, sigFig: true }); // 1
+```
+
+### Pipe
+
+```javascript
+import { pipe } from "@numio/bigmath";
+
+const addNums = ["1", "2", "3"];
+const subNums = ["0.2", "0.3"];
+const divNums = ["4"];
+const mulNums = ["2", "5", "0.2"];
+
+pipe.add(addNums) // 6
+  .div(divNums) // 6 / 4 = 1.5 
+  .sub(subNums) // 1.5 - 0.2 - 0.3 = 1
+  .mul(mulNums) // 1 * 2 * 5 * 0.2 = 2
+  .calc()
+```
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 
@@ -123,7 +227,7 @@ const float = mul(
 ); // 0.00000000000000000000000000000000000000000000000000000000000000000000000000018
 ```
 
-Download from NPM - https://www.npmjs.com/package/@numio/bigmath \
-Download from JSR - https://jsr.io/@numio/bigmath \
-Home page - https://github.com/shpunter/numio-bigmath/blob/main/README.md \
-License - https://github.com/shpunter/numio-bigmath/blob/main/LICENSE
+Download from NPM - https://www.npmjs.com/package/@numio/bigmath\
+Download from JSR - https://jsr.io/@numio/bigmath\
+Home page - https://github.com/shpunter/numio-bigmath/blob/main/README.md\
+License - https://github.com/shpunter/numio-bigmath/blob/main/LICENSE

package/index.d.ts

@@ -2,4 +2,6 @@ import { add } from "./src/add/index.d.ts";
 import { mul } from "./src/mul/index.d.ts";
 import { sub } from "./src/sub/index.d.ts";
 import { div } from "./src/div/index.d.ts";
-export { add, mul, sub, div };
+import { round } from "./src/round/index.d.ts";
+import { pipe } from "./src/pipe/main.d.ts";
+export { add, div, mul, round, sub, pipe };

package/index.js

@@ -2,4 +2,6 @@ import { add } from "./src/add/index.js";
 import { mul } from "./src/mul/index.js";
 import { sub } from "./src/sub/index.js";
 import { div } from "./src/div/index.js";
-export { add, mul, sub, div };
+import { round } from "./src/round/index.js";
+import { pipe } from "./src/pipe/main.js";
+export { add, div, mul, round, sub, pipe };

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.2",
+  "version": "1.0.4",
   "keywords": [
     "precision",
     "arithmetic",

package/src/add/index.d.ts

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

package/src/add/index.js

@@ -1,19 +1,7 @@
-import { a2sSA, s2aSA } from "../shared/utils.js";
-import { subtract } from "../sub/utils.js";
-import { addition } from "./utils.js";
-/** This function adds 2 numbers (as string). */
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { addRoute } from "./utils.js";
+/** This function adds numbers (as string). */
 export function add(strs) {
-    var arrays = strs.map(function (str) { return s2aSA(str); });
-    var inputData = arrays.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        if (left.isNegative && !right.isNegative) {
-            return subtract([right.array, right.intLength], [left.array, left.intLength]);
-        }
-        if (!left.isNegative && right.isNegative) {
-            return subtract([left.array, left.intLength], [right.array, right.intLength]);
-        }
-        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative && right.isNegative);
-    }, { array: [], intLength: 0, isFloat: false, isNegative: false });
-    return a2sSA(inputData.array, inputData.isFloat, inputData.isNegative);
+    return a2s(addRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
 }

package/src/add/utils.d.ts

@@ -1,3 +1,5 @@
+import type { InputData } from "../types.d.ts";
 import type { Addition } from "./types.d.ts";
 /** This function adds 2 numbers (as array). */
 export declare const addition: Addition;
+export declare const addRoute: (input: InputData[], initValue: InputData) => InputData;

package/src/add/utils.js

@@ -1,3 +1,4 @@
+import { subtract } from "../sub/utils.js";
 /** This function adds 2 numbers (as array). */
 export var addition = function (_a, _b, isNegative) {
     var _c, _d;
@@ -12,13 +13,10 @@ export var addition = function (_a, _b, isNegative) {
     var pl = (intLeft >= intRight ? intLeft : intRight) + fracMaxLen;
     var pr = (intLeft >= intRight ? intRight : intLeft) + fracMaxLen;
     var carryOver = 48;
-    if (fracLenL === 0 && fracLenR > 0)
-        left.push(46);
+    while (pl > left.length - 1) {
+        left.push(48);
+    }
     while (pr >= 0) {
-        if (left[pl] === 46 || right[pr] === 46) {
-            pr -= 1;
-            pl -= 1;
-        }
         var sum = (((_c = left[pl]) !== null && _c !== void 0 ? _c : 48) + ((_d = right[pr]) !== null && _d !== void 0 ? _d : 48) + carryOver) -
             3 * 48;
         if (sum > 9) {
@@ -46,3 +44,16 @@ export var addition = function (_a, _b, isNegative) {
         isFloat: fracLenL + fracLenR > 0,
     };
 };
+export var addRoute = function (input, initValue) {
+    return input.reduce(function (left, right) {
+        if (left.array.length === 0)
+            return right;
+        if (left.isNegative && !right.isNegative) {
+            return subtract([right.array, right.intLength], [left.array, left.intLength]);
+        }
+        if (!left.isNegative && right.isNegative) {
+            return subtract([left.array, left.intLength], [right.array, right.intLength]);
+        }
+        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative && right.isNegative);
+    }, initValue);
+};

package/src/div/index.d.ts

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

package/src/div/index.js

@@ -1,15 +1,10 @@
-import { a2sMD, s2aMD } from "../shared/utils.js";
-import { division } from "./utils.js";
-/** This function should divide 2 numbers (as string). */
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { divRoute } from "./utils.js";
+/** This function should divide numbers (as string). */
 export var div = function (strs, limit) {
     if (limit === void 0) { limit = 20; }
     if (strs[0] === "0")
         return strs[0];
-    var arrays = strs.map(function (str) { return s2aMD(str); });
-    var inputData = arrays.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        return division([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, limit);
-    }, { array: [], intLength: 0, isNegative: false, isFloat: false });
-    return a2sMD(inputData.array, inputData.intLength != inputData.array.length, inputData.isNegative, inputData.intLength);
+    return a2s(divRoute(strs.map(function (str) { return s2a(str); }), DEFAULT, limit));
 };

package/src/div/utils.d.ts

@@ -1,2 +1,4 @@
+import type { InputData } from "../types.d.ts";
 import type { Division } from "./types.d.ts";
 export declare const division: Division;
+export declare const divRoute: (input: InputData[], initValue: InputData, limit: number) => InputData;

package/src/div/utils.js

@@ -80,11 +80,24 @@ export var division = function (_a, _b, isNegative, initLimit) {
             intLength -= 1;
         }
     }
-    var isZero = result.length === count;
-    return {
-        array: result[0] === 48 ? multipliedResult : result,
-        isFloat: isZero ? false : isFloat,
-        isNegative: isZero ? false : isNegative,
-        intLength: isZero ? 1 : intLength,
-    };
+    return result.length === count
+        ? {
+            array: [48],
+            isFloat: false,
+            isNegative: false,
+            intLength: 1,
+        }
+        : {
+            array: result[0] === 48 ? multipliedResult : result,
+            isFloat: isFloat,
+            isNegative: isNegative,
+            intLength: intLength,
+        };
+};
+export var divRoute = function (input, initValue, limit) {
+    return input.reduce(function (left, right) {
+        if (left.array.length === 0)
+            return right;
+        return division([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, limit);
+    }, initValue);
 };

package/src/mul/index.d.ts

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

package/src/mul/index.js

@@ -1,12 +1,7 @@
-import { a2sMD, s2aMD } from "../shared/utils.js";
-import { multiplication } from "./utils.js";
-/** This function multiplies 2 numbers (as string). */
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { mulRoute } from "./utils.js";
+/** This function multiplies numbers (as string). */
 export var mul = function (strs) {
-    var arrays = strs.map(function (str) { return s2aMD(str); });
-    var inputData = arrays.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        return multiplication([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative);
-    }, { array: [], intLength: 0, isNegative: false, isFloat: false });
-    return a2sMD(inputData.array, inputData.intLength != inputData.array.length, inputData.isNegative, inputData.intLength);
+    return a2s(mulRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
 };

package/src/mul/utils.d.ts

@@ -1,3 +1,5 @@
+import type { InputData } from "../types.d.ts";
 import type { Multiplication } from "./types.d.ts";
 /** This function multiplies 2 numbers (as array). */
 export declare const multiplication: Multiplication;
+export declare const mulRoute: (input: InputData[], initValue: InputData) => InputData;

package/src/mul/utils.js

@@ -40,3 +40,10 @@ export var multiplication = function (_a, _b, isNegative) {
         isNegative: isNegative,
     };
 };
+export var mulRoute = function (input, initValue) {
+    return input.reduce(function (left, right) {
+        if (left.array.length === 0)
+            return right;
+        return multiplication([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative);
+    }, initValue);
+};

package/src/pipe/main.d.ts

@@ -0,0 +1,13 @@
+import type { A2S } from "../shared/types.d.ts";
+import type { InputData } from "../types.d.ts";
+declare class Pipe {
+    result: InputData;
+    constructor();
+    add(strs: string[]): Pipe;
+    sub(strs: string[]): Pipe;
+    div(strs: string[], limit?: number): Pipe;
+    mul(strs: string[]): Pipe;
+    calc(): ReturnType<A2S>;
+}
+export declare const pipe: Pipe;
+export {};

package/src/pipe/main.js

@@ -0,0 +1,35 @@
+import { addRoute } from "../add/utils.js";
+import { divRoute } from "../div/utils.js";
+import { mulRoute } from "../mul/utils.js";
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { subRoute } from "../sub/utils.js";
+var Pipe = /** @class */ (function () {
+    function Pipe() {
+        this.result = DEFAULT;
+    }
+    Pipe.prototype.add = function (strs) {
+        this.result = addRoute(strs.map(function (str) { return s2a(str); }), this.result);
+        return this;
+    };
+    Pipe.prototype.sub = function (strs) {
+        this.result = subRoute(strs.map(function (str) { return s2a(str); }), this.result);
+        return this;
+    };
+    Pipe.prototype.div = function (strs, limit) {
+        if (limit === void 0) { limit = 20; }
+        this.result = divRoute(strs.map(function (str) { return s2a(str); }), this.result, limit);
+        return this;
+    };
+    Pipe.prototype.mul = function (strs) {
+        this.result = mulRoute(strs.map(function (str) { return s2a(str); }), this.result);
+        return this;
+    };
+    Pipe.prototype.calc = function () {
+        var result = a2s(this.result);
+        this.result = DEFAULT;
+        return result;
+    };
+    return Pipe;
+}());
+export var pipe = new Pipe();

package/src/round/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const UP = "up";
+export declare const DOWN = "down";
+export declare const HALF_UP = "half-up";
+export declare const HALF_DOWN = "half-down";
+export declare const HALF_EVEN = "half-even";
+export declare const HALF_ODD = "half-odd";
+export declare const ROUND_MODE: readonly ["up", "down", "half-up", "half-down", "half-even", "half-odd"];

package/src/round/constants.js

@@ -0,0 +1,14 @@
+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 = [
+    UP,
+    DOWN,
+    HALF_UP,
+    HALF_DOWN,
+    HALF_EVEN,
+    HALF_ODD,
+];

package/src/round/index.d.ts

@@ -0,0 +1,3 @@
+import type { Round } from "./types.d.ts";
+/** This function round number. */
+export declare const round: Round;

package/src/round/index.js

@@ -0,0 +1,45 @@
+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 isNill = true;
+    for (var i = 0; i < value.length; i++) {
+        var charCode = value.charCodeAt(i);
+        if (sigFig && charCode > 48)
+            sigFig = false;
+        if (isNill && charCode > 48)
+            isNill = false;
+        if (isFloat && !sigFig)
+            decimals -= 1;
+        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];
+            if (charCode === 46)
+                isFloat = false;
+            if (hasCarryOver) {
+                _a = handleCarryOver(array, isFloat), array = _a[0], isFloat = _a[1];
+                break;
+            }
+            charCode === 46
+                ? array[array.length - 1] += last - prev
+                : array.push(last);
+            break;
+        }
+        array.push(charCode);
+    }
+    handleTail(array, isFloat);
+    return (isNill && array[array.length - 1] <= 48)
+        ? "0"
+        : String.fromCharCode.apply(String, array);
+};

package/src/round/types.d.ts

@@ -0,0 +1,10 @@
+import type { ROUND_MODE } from "./constants.d.ts";
+export type Round = (value: string, options?: {
+    decimals?: number;
+    roundMode?: RoundMode;
+    sigFig?: boolean;
+}) => string;
+export type RoundMode = typeof ROUND_MODE[number];
+export type HandleTail = (array: number[], isFloat: boolean) => void;
+export type HandleCarryOver = (array: number[], isFloat: boolean) => [number[], boolean];
+export type CalcLast = (current: number, next: number, roundMode: RoundMode) => [number, boolean];

package/src/round/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CalcLast, HandleCarryOver, HandleTail } from "./types.d.ts";
+export declare const handleTail: HandleTail;
+export declare const handleCarryOver: HandleCarryOver;
+export declare const calcLast: CalcLast;

package/src/round/utils.js

@@ -0,0 +1,60 @@
+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;
+    while (isFloat && array[lastIdx] <= 48) {
+        if (array[lastIdx] === 46 || array.length === 1)
+            isFloat = false;
+        array.length > 1 && array.pop();
+        lastIdx -= 1;
+    }
+};
+export var handleCarryOver = function (array, isFloat) {
+    var _a;
+    var hasCarryOver = true;
+    var idx = array.length - 1;
+    var mapFloat = new Map([
+        [57, function () {
+                array.pop();
+                idx -= 1;
+            }],
+        [46, function () {
+                array.pop();
+                idx -= 1;
+                isFloat = false;
+            }],
+        [0, function () {
+                array[idx] += 1;
+                hasCarryOver = false;
+            }],
+    ]);
+    var mapInt = new Map([
+        [57, function () {
+                array[idx] = 48;
+                idx -= 1;
+            }],
+        [0, function () {
+                array[idx] += 1;
+                hasCarryOver = false;
+            }],
+    ]);
+    while (hasCarryOver && idx >= 0) {
+        var map = isFloat ? mapFloat : mapInt;
+        var 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);
+    return map[roundMode] > 57 ? [48, true] : [map[roundMode], false];
+};

package/src/shared/constant.d.ts

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

package/src/shared/constant.js

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

package/src/shared/types.d.ts

@@ -1,4 +1,3 @@
 import type { InputData } from "../types.d.ts";
-export type A2S = (array: number[], isFloat: boolean, isNegative?: boolean, intLength?: number) => string;
-export type S2ASA = (string: string) => InputData;
-export type S2AMD = (strings: string) => InputData;
+export type A2S = (input: InputData) => string;
+export type S2A = (strings: string) => InputData;

package/src/shared/utils.d.ts

@@ -1,5 +1,3 @@
-import type { A2S, S2AMD, S2ASA } from "./types.d.ts";
-export declare const a2sMD: A2S;
-export declare const a2sSA: A2S;
-export declare const s2aSA: S2ASA;
-export declare const s2aMD: S2AMD;
+import type { A2S, S2A } from "./types.d.ts";
+export declare const a2s: A2S;
+export declare const s2a: S2A;

package/src/shared/utils.js

@@ -1,7 +1,5 @@
-// array to string
-export var a2sMD = function (array, isFloat, isNegative, intLength) {
-    if (isNegative === void 0) { isNegative = false; }
-    if (intLength === void 0) { intLength = 0; }
+export var a2s = function (_a) {
+    var array = _a.array, isFloat = _a.isFloat, isNegative = _a.isNegative, intLength = _a.intLength;
     var result = [];
     var lastValuableIdx = array.length;
     if (isFloat) {
@@ -32,49 +30,7 @@ export var a2sMD = function (array, isFloat, isNegative, intLength) {
     }
     return (isNegative ? "-" : "") + String.fromCharCode.apply(String, array).trim();
 };
-export var a2sSA = function (array, isFloat, isNegative) {
-    if (isNegative === void 0) { isNegative = false; }
-    var isToCheckTail = isFloat;
-    for (var i = array.length - 1; i >= 0; i--) {
-        if (isToCheckTail && array[i] === 46) {
-            array[i] = 32;
-            isToCheckTail = false;
-            break;
-        }
-        if (isToCheckTail && array[i] === 48)
-            array[i] = 32;
-        else
-            break;
-    }
-    for (var i = 0; i < array.length; i++) {
-        if (array[i + 1] === 46 || array.length <= 1)
-            break;
-        if (array[i] === 48)
-            array[i] = 32;
-        else
-            break;
-    }
-    return (isNegative ? "-" : "") + String.fromCharCode.apply(String, array).trim();
-};
-// string to array (sub, add)
-export var s2aSA = function (string) {
-    var isNegative = string.charCodeAt(0) === 45;
-    var shift = isNegative ? 1 : 0;
-    var array = Array(string.length - shift);
-    var intLength = string.length - shift;
-    var isFloat = false;
-    for (var idx = 0 + shift; idx < string.length; idx++) {
-        var charCode = string.charCodeAt(idx);
-        if (charCode === 46) {
-            intLength = idx - shift;
-            isFloat || (isFloat = true);
-        }
-        array[idx - shift] = charCode;
-    }
-    return { array: array, intLength: intLength, isNegative: isNegative, isFloat: isFloat };
-};
-// string to array (mul, div)
-export var s2aMD = function (string) {
+export var s2a = function (string) {
     var array = Array(0);
     var isNegative = string.charCodeAt(0) === 45;
     var shift = isNegative ? 1 : 0;

package/src/sub/index.d.ts

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

package/src/sub/index.js

@@ -1,19 +1,7 @@
-import { addition } from "../add/utils.js";
-import { a2sSA, s2aSA } from "../shared/utils.js";
-import { subtract } from "./utils.js";
-/** This function subtracts 2 numbers (as string). */
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { subRoute } from "./utils.js";
+/** This function subtracts numbers (as string). */
 export function sub(strs) {
-    var arrays = strs.map(function (str) { return s2aSA(str); });
-    var inputData = arrays.reduce(function (left, right) {
-        if (left.array.length === 0)
-            return right;
-        if (left.isNegative && right.isNegative) {
-            return subtract([right.array, right.intLength], [left.array, left.intLength]);
-        }
-        if (!left.isNegative && !right.isNegative) {
-            return subtract([left.array, left.intLength], [right.array, right.intLength]);
-        }
-        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative);
-    }, { array: [], intLength: 0, isNegative: false, isFloat: false });
-    return a2sSA(inputData.array, inputData.isFloat, inputData.isNegative);
+    return a2s(subRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
 }

package/src/sub/utils.d.ts

@@ -1,3 +1,5 @@
+import type { InputData } from "../types.d.ts";
 import type { Subtract } from "./types.d.ts";
 /** This function subtracts 2 numbers (as array). */
 export declare const subtract: Subtract;
+export declare const subRoute: (input: InputData[], initValue: InputData) => InputData;

package/src/sub/utils.js

@@ -1,3 +1,4 @@
+import { addition } from "../add/utils.js";
 /** This function subtracts 2 numbers (as array). */
 export var subtract = function (_a, _b) {
     var _c, _d;
@@ -15,15 +16,10 @@ export var subtract = function (_a, _b) {
     var isLeftBigger = lenDiff > 0;
     var carryOver = false;
     var isNegative = intLeft !== intL;
-    if (intLeft === left.length && intRight !== right.length)
-        left.push(46);
-    if (intRight === right.length && intLeft !== left.length)
-        right.push(46);
+    while (pl > left.length - 1) {
+        left.push(48);
+    }
     while (pr < right.length) {
-        if (left[pl] === 46 || right[pr] === 46) {
-            pr += 1;
-            pl += 1;
-        }
         var sub = (((_e = left[pl]) !== null && _e !== void 0 ? _e : 48) - ((_f = right[pr]) !== null && _f !== void 0 ? _f : 48)) + 48;
         if (!isLeftBigger && left[pl] > right[pr]) {
             isLeftBigger = true;
@@ -42,10 +38,6 @@ export var subtract = function (_a, _b) {
         var plReverse = pl - 1;
         var prReverse = pr - 1;
         while (carryOver) {
-            if (left[plReverse] === 46 || right[prReverse] === 46) {
-                plReverse -= 1;
-                prReverse -= 1;
-            }
             if (left[plReverse] !== 48) {
                 plReverse >= 0 && (left[plReverse] -= 1);
                 prReverse >= 0 && (right[prReverse] -= 1);
@@ -63,7 +55,7 @@ export var subtract = function (_a, _b) {
         pl += 1;
         pr += 1;
     }
-    while (left[0] === 48 && left[1] !== 46 && left.length > 1) {
+    while (left[0] === 48 && left.length > 1 && fracLenL < left.length - 1) {
         left.shift();
         intLeft -= 1;
     }
@@ -74,3 +66,16 @@ export var subtract = function (_a, _b) {
         isFloat: fracLenL + fracLenR > 0,
     };
 };
+export var subRoute = function (input, initValue) {
+    return input.reduce(function (left, right) {
+        if (left.array.length === 0)
+            return right;
+        if (left.isNegative && right.isNegative) {
+            return subtract([right.array, right.intLength], [left.array, left.intLength]);
+        }
+        if (!left.isNegative && !right.isNegative) {
+            return subtract([left.array, left.intLength], [right.array, right.intLength]);
+        }
+        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative);
+    }, initValue);
+};