@numio/bigmath 1.0.3 → 1.0.5

package/README.md

@@ -1,43 +1,58 @@
 # @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
 
-Added rounding
-* round up
-* round down
-* half-up
-* half-down
-* half-even
-* half-odd
-* decimal places to be rounded
-* significant figures decimals to be rounded
+Added quartile functionality. When you might need it?
+Understanding Distribution. Quartiles (Q1, Q2, and Q3) split a dataset into four groups, each representing 25% of the data. 
+Identifying Outliers. They help visualize the shape and spread of the data, revealing whether it's skewed or symmetrical. 
 
 # Install:
 
@@ -84,6 +99,7 @@ const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
 ```
 
 ### Subtract numbers
+
 ```javascript
 import { sub } from "@numio/bigmath";
 
@@ -93,6 +109,7 @@ const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
 ```
 
 ### Multiply numbers
+
 ```javascript
 import { mul } from "@numio/bigmath";
 
@@ -102,10 +119,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
 
@@ -114,7 +132,10 @@ div("10", "3"); // 3.33333
 ```
 
 ### Round
+
 ```javascript
+import { round } from "@numio/bigmath";
+
 round("-1.12345"); // -1
 round("1.5"); // 2
 round("1.0"); // 1
@@ -123,7 +144,10 @@ 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
@@ -131,7 +155,10 @@ 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
 
@@ -155,7 +182,10 @@ 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
 
@@ -166,6 +196,33 @@ 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()
+```
+
+### Quartile
+```javascript
+import { quartile } from "@numio/bigmath";
+
+quartile(["1", "2", "3", "4", "5", "6", "7", "8", "9"]) // { Q1: "2.5", Q2: "5", Q3: "7.5" }
+quartile(["0.001", "0.3", "0.4", "1"]) // { Q1: "0.1505", Q2: "0.35", Q3: "0.7" }
+
+```
+
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 
@@ -182,7 +239,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

@@ -1,6 +1,8 @@
-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";
+import { add } from "./src/mathOperations/add/index.d.ts";
+import { mul } from "./src/mathOperations/mul/index.d.ts";
+import { sub } from "./src/mathOperations/sub/index.d.ts";
+import { div } from "./src/mathOperations/div/index.d.ts";
 import { round } from "./src/round/index.d.ts";
-export { add, div, mul, round, sub };
+import { pipe } from "./src/pipe/main.d.ts";
+import { quartile } from "./src/quartile/main.d.ts";
+export { add, div, mul, pipe, quartile, round, sub };

package/index.js

@@ -1,6 +1,8 @@
-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";
+import { add } from "./src/mathOperations/add/index.js";
+import { mul } from "./src/mathOperations/mul/index.js";
+import { sub } from "./src/mathOperations/sub/index.js";
+import { div } from "./src/mathOperations/div/index.js";
 import { round } from "./src/round/index.js";
-export { add, div, mul, round, sub };
+import { pipe } from "./src/pipe/main.js";
+import { quartile } from "./src/quartile/main.js";
+export { add, div, mul, pipe, quartile, round, sub };

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.3",
+  "version": "1.0.5",
   "keywords": [
     "precision",
     "arithmetic",
@@ -28,7 +28,12 @@
     "divide",
     "long division",
     "bigmath",
-    "numio"
+    "numio",
+    "quartile",
+    "Q1",
+    "Q2",
+    "Q3",
+    "round"
   ],
   "repository": {
     "type": "git",

package/src/mathOperations/add/index.js

@@ -0,0 +1,7 @@
+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) {
+    return a2s(addRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
+}

package/src/{add → mathOperations/add}/types.d.ts

@@ -1,2 +1,2 @@
-import type { InputData } from "../types.d.ts";
+import type { InputData } from "../../types.d.ts";
 export type Addition = (L: [number[], number], R: [number[], number], isNegative: boolean) => InputData;

package/src/{add → mathOperations/add}/utils.d.ts

@@ -1,3 +1,5 @@
+import type { Route } 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: Route;

package/src/{add → mathOperations/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/mathOperations/div/index.js

@@ -0,0 +1,10 @@
+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];
+    return a2s(divRoute(strs.map(function (str) { return s2a(str); }), DEFAULT, limit));
+};

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

@@ -0,0 +1,3 @@
+import type { InputData } from "../../types.d.ts";
+export type Division = (L: [number[], number], R: [number[], number], isNegative: boolean, initLimit: number) => InputData;
+export type DivRoute = (input: InputData[], initValue: InputData, limit: number) => InputData;

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

@@ -0,0 +1,3 @@
+import type { Division, DivRoute } from "./types.d.ts";
+export declare const division: Division;
+export declare const divRoute: DivRoute;

package/src/{div → mathOperations/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/mathOperations/mul/index.js

@@ -0,0 +1,7 @@
+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) {
+    return a2s(mulRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
+};

package/src/{mul → mathOperations/mul}/types.d.ts

@@ -1,2 +1,2 @@
-import type { InputData } from "../types.d.ts";
+import type { InputData } from "../../types.d.ts";
 export type Multiplication = (arrL: [number[], number], arrR: [number[], number], isNegative: boolean) => InputData;

package/src/{mul → mathOperations/mul}/utils.d.ts

@@ -1,3 +1,5 @@
+import type { Route } 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: Route;

package/src/{mul → mathOperations/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/mathOperations/sub/index.js

@@ -0,0 +1,7 @@
+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) {
+    return a2s(subRoute(strs.map(function (str) { return s2a(str); }), DEFAULT));
+}

package/src/{sub → mathOperations/sub}/types.d.ts

@@ -1,2 +1,2 @@
-import type { InputData } from "../types.d.ts";
+import type { InputData } from "../../types.d.ts";
 export type Subtract = (L: [number[], number], R: [number[], number]) => InputData;

package/src/{sub → mathOperations/sub}/utils.d.ts

@@ -1,3 +1,5 @@
+import type { Route } 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: Route;

package/src/{sub → mathOperations/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);
+};

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 { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { subRoute } from "../mathOperations/sub/utils.js";
+import { addRoute } from "../mathOperations/add/utils.js";
+import { divRoute } from "../mathOperations/div/utils.js";
+import { mulRoute } from "../mathOperations/mul/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/quartile/main.d.ts

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

package/src/quartile/main.js

@@ -0,0 +1,19 @@
+import { pipe } from "../pipe/main.js";
+var mean = function (idx, array) {
+    return pipe.add([array[idx], array[idx - 1]]).div(["2"]).calc();
+};
+export var quartile = function (array) {
+    if (array.length < 3) {
+        throw Error("To calculate quartile you need at least 3 elements");
+    }
+    var length = array.length;
+    var Q2Idx = length >> 1;
+    var Q1Idx = Q2Idx >> 1;
+    var Q3Idx = length - Q1Idx;
+    var isEvenHalf = Q2Idx % 2 !== 0;
+    return {
+        Q1: isEvenHalf ? array[Q1Idx] : mean(Q1Idx, array),
+        Q2: length % 2 !== 0 ? array[Q2Idx] : mean(Q2Idx, array),
+        Q3: isEvenHalf ? array[Q3Idx - 1] : mean(Q3Idx, array),
+    };
+};

package/src/quartile/types.d.ts

@@ -0,0 +1,6 @@
+export type Quartile = (array: string[]) => {
+    Q1: string;
+    Q2: string;
+    Q3: string;
+};
+export type Mean = (index: number, array: string[]) => string;

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/types.d.ts

@@ -4,3 +4,4 @@ export type InputData = {
     isNegative: boolean;
     isFloat: boolean;
 };
+export type Route = (input: InputData[], initValue: InputData) => InputData;

package/src/add/index.js

@@ -1,19 +0,0 @@
-import { a2sSA, s2aSA } from "../shared/utils.js";
-import { subtract } from "../sub/utils.js";
-import { addition } 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);
-}

package/src/div/index.js

@@ -1,15 +0,0 @@
-import { a2sMD, s2aMD } from "../shared/utils.js";
-import { division } 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);
-};

package/src/div/types.d.ts

@@ -1,2 +0,0 @@
-import type { InputData } from "../types.d.ts";
-export type Division = (L: [number[], number], R: [number[], number], isNegative: boolean, initLimit: number) => InputData;

package/src/div/utils.d.ts

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

package/src/mul/index.js

@@ -1,12 +0,0 @@
-import { a2sMD, s2aMD } from "../shared/utils.js";
-import { multiplication } 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);
-};

package/src/sub/index.js

@@ -1,19 +0,0 @@
-import { addition } from "../add/utils.js";
-import { a2sSA, s2aSA } from "../shared/utils.js";
-import { subtract } 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);
-}