@numio/bigmath 1.0.1 → 1.0.2

package/README.md

@@ -29,7 +29,7 @@ This library is particularly useful in scenarios where precise calculations with
 
 ### Latest update
 
-In version 1.0.1 arguments for calculation changed to array, which increases performance dramatically \
+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)
 

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

package/build.ts

@@ -1,45 +0,0 @@
-const rootPath = "./npm";
-const decoder = new TextDecoder("utf-8");
-const encoder = new TextEncoder();
-
-async function walk(path: string, cb: ({ path, fileInfo }: CB) => void) {
-  const fileInfo = await Deno.lstat(path);
-
-  cb({ fileInfo, path });
-
-  if (fileInfo.isDirectory) {
-    const entries = await Deno.readDir(path);
-
-    for await (const entry of entries) {
-      await walk(`${path}/${entry.name}`, cb);
-    }
-  }
-}
-
-await walk(rootPath, ({ path, fileInfo }) => {
-  if (fileInfo.isFile && path.endsWith(".js")) {
-    const content = decoder.decode(Deno.readFileSync(path));
-    const fixed = content.replaceAll(".ts", ".js");
-
-    Deno.writeFileSync(path, encoder.encode(fixed));
-  }
-
-  if (fileInfo.isFile && path.endsWith(".d.ts")) {
-    const content = decoder.decode(Deno.readFileSync(path));
-    const fixed = content.replaceAll(".ts", ".d.ts");
-
-    Deno.writeFileSync(path, encoder.encode(fixed));
-  }
-
-  if (fileInfo.isFile && path.endsWith("types.js")) {
-    Deno.remove(path);
-  }
-});
-
-Deno.copyFileSync("LICENSE", "npm/LICENSE");
-Deno.copyFileSync("README.md", "npm/README.md");
-Deno.copyFileSync("package.json", "npm/package.json");
-Deno.copyFileSync("package-lock.json", "npm/package-lock.json");
-
-
-type CB = { path: string; fileInfo: Deno.FileInfo };

package/index.ts

@@ -1,6 +0,0 @@
-import { add } from "./src/add/index.ts";
-import { mul } from "./src/mul/index.ts";
-import { sub } from "./src/sub/index.ts";
-import { div } from "./src/div/index.ts";
-
-export { add, mul, sub, div };

package/npm/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Oleksandr Brudnovskyi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/npm/README.md

@@ -1,129 +0,0 @@
-# @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.
-
-
-## 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.
-
-
-## 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.
-
-## 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.
-
-
-### Latest update
-
-In version 1.0.1 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)
-
-# Install:
-
-### NPM
-
-```bash
-npm install @numio/bigmath
-```
-
-### YARN
-
-```bash
-yarn add @numio/bigmath
-```
-
-### BUN
-
-```bash
-bun add @numio/bigmath
-```
-
-### PNPM
-
-```bash
-pnpm add @numio/bigmath
-```
-
-### DENO
-
-```bash
-deno add jsr:@numio/bigmath
-```
-
-# Examples:
-
-### Add numbers
-
-```javascript
-import { add } from "@numio/bigmath";
-
-const int = add(["12345", "99"]); // 124444
-const float = add(["0.1", "0.2", "0.3"]); // 0.6
-const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
-```
-
-### Subtract numbers
-```javascript
-import { sub } from "@numio/bigmath";
-
-const int = sub(["150", "99"]); // 51
-const float = sub(["1", "0.99"]); // 0.01
-const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
-```
-
-### Multiply numbers
-```javascript
-import { mul } from "@numio/bigmath";
-
-const int = mul(["15", "11", "2"]); // 330
-const float = mul(["0.01", "0.99"]); // 0.0099
-const negative = mul(["-2", "3"]); // -6
-```
-
-### Divide numbers
-```javascript
-import { div } from "@numio/bigmath";
-
-const int = div(["9999", "33"]); // 
-const float = div(["0.06", "0.2"]); // 0.3
-const negative = div(["-2", "-3", "2"]); // 3
-
-// set number of digit after the decimal. By default it's 20
-div("10", "3"); // 3.33333
-```
-
-Does not have a limitation on the number of digits. You can use any length you'd
-like
-
-```javascript
-// NO precision loss using numeric literals with more than 15 significant digits.
-const int = sub(
-  "999999999999999999999999999999999999999999999999999999999999999",
-  "2",
-); // "1000000000000000000000000000000000000000000000000000000000000001"
-
-const float = mul(
-  "0.00000000000000000000000000000000000000000000000000000000000000000009",
-  "0.000000002",
-); // 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

package/npm/package-lock.json

@@ -1,16 +0,0 @@
-{
-  "name": "@numio/bigmath",
-  "version": "1.0.1",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@numio/bigmath",
-      "version": "1.0.1",
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    }
-  }
-}

package/npm/package.json

@@ -1,57 +0,0 @@
-{
-  "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.1",
-  "keywords": [
-    "precision",
-    "arithmetic",
-    "big",
-    "number",
-    "decimal",
-    "float",
-    "biginteger",
-    "bigdecimal",
-    "bignumber",
-    "bigint",
-    "bignum",
-    "infinite",
-    "longnumbers",
-    "infinitenumbers",
-    "integer",
-    "float",
-    "math",
-    "add",
-    "multiply",
-    "subtract",
-    "plus",
-    "minus",
-    "divide",
-    "long division",
-    "bigmath",
-    "numio"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/shpunter/numio-bigmath.git"
-  },
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "author": {
-    "name": "Oleksandr Brudnovskyi ",
-    "email": "oleksandr.brudnovskyi@gmail.com"
-  },
-  "engines": {
-    "node": "*"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "node test"
-  },
-  "dependencies": {}
-}

package/src/add/index.ts

@@ -1,34 +0,0 @@
-import { a2sSA, s2aSA } from "../shared/utils.ts";
-import { subtract } from "../sub/utils.ts";
-import { addition } from "./utils.ts";
-
-/** This function adds 2 numbers (as string). */
-export function add(strs: string[]): string {
-  const arrays = strs.map((str) => s2aSA(str));
-
-  const inputData = arrays.reduce((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/add/types.ts

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

package/src/add/utils.ts

@@ -1,54 +0,0 @@
-import type { Addition } from "./types.ts";
-
-/** This function adds 2 numbers (as array). */
-export const addition: Addition = ([arrL, intL], [arrR, intR], isNegative) => {
-  const [left, right, intLeft, intRight] = intL >= intR
-    ? [arrL, arrR, intL, intR]
-    : [arrR, arrL, intR, intL];
-  const fracLenL = left.length - intLeft;
-  const fracLenR = right.length - intRight;
-  const fracMaxLen = (fracLenL >= fracLenR ? fracLenL : fracLenR) - 1;
-  let pl = (intLeft >= intRight ? intLeft : intRight) + fracMaxLen;
-  let pr = (intLeft >= intRight ? intRight : intLeft) + fracMaxLen;
-  let carryOver = 48;
-
-  if (fracLenL === 0 && fracLenR > 0) left.push(46);
-
-  while (pr >= 0) {
-    if (left[pl] === 46 || right[pr] === 46) {
-      pr -= 1;
-      pl -= 1;
-    }
-
-    const sum = ((left[pl] ?? 48) + (right[pr] ?? 48) + carryOver) -
-      3 * 48;
-
-    if (sum > 9) {
-      left[pl] = (sum % 10) + 48;
-      carryOver = ((sum / 10) | 0) + 48;
-    } else {
-      left[pl] = sum + 48;
-      carryOver = 48;
-    }
-
-    pr -= 1;
-    pl -= 1;
-  }
-
-  while (pl >= 0 && carryOver) {
-    const sum = (left[pl] + carryOver) - 2 * 48;
-
-    left[pl] = (sum % 10) + 48;
-    carryOver = ((sum / 10) | 0) + 48;
-    pl -= 1;
-  }
-
-  carryOver > 48 && left.unshift(carryOver);
-
-  return {
-    array: left,
-    intLength: left.length -1 - fracMaxLen,
-    isNegative,
-    isFloat: fracLenL + fracLenR > 0,
-  };
-};

package/src/div/index.ts

@@ -1,26 +0,0 @@
-import { a2sMD, s2aMD } from "../shared/utils.ts";
-import { division } from "./utils.ts";
-
-/** This function should divide 2 numbers (as string). */
-export const div = (strs: string[], limit = 20): string => {
-  if (strs[0] === "0") return strs[0];
-
-  const arrays = strs.map((str) => s2aMD(str));
-  const inputData = arrays.reduce((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.ts

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

package/src/div/utils.ts

@@ -1,110 +0,0 @@
-import type { Division } from "./types.ts";
-
-export const division: Division = (
-  [arrL, intL],
-  [arrR, intR],
-  isNegative,
-  initLimit,
-) => {
-  const decDiff = (arrL.length - intL) - (arrR.length - intR);
-  const [L, R] = [[arrR, 1], [arrL, -1]] as const;
-  const [arr, abs] = decDiff > 0 ? L : R;
-
-  for (let i = 0; i < decDiff * abs; i++) {
-    arr.push(48);
-  }
-
-  let digit = 48;
-  let limit = initLimit;
-  let isFloat = false;
-  let l = 0;
-  let r = arrR.length - 1;
-  let intLength = 0;
-  const result: number[] = [];
-  const lenArrayL = r - arrL.length;
-
-  for (let i = 0; i <= lenArrayL; i++) {
-    if (i === 0) {
-      isFloat = true;
-      intLength = 1;
-    }
-
-    result.push(48);
-    arrL.push(48);
-    limit -= 1;
-  }
-
-  while (r < arrL.length && limit >= 0) {
-    let comp = false;
-
-    if (arrL[l] === 48) l += 1;
-
-    for (let i = 0; i < arrR.length; i++) {
-      if ((r - l + 1) < arrR.length) comp = true;
-      if ((r - l + 1) !== arrR.length) break;
-
-      if (arrL[l + i] !== arrR[i]) {
-        comp = arrL[l + i] < arrR[i];
-        break;
-      }
-    }
-
-    if (comp) {
-      if (r < arrL.length && (result.length > 0 || digit !== 48)) {
-        if (!isFloat) intLength += 1;
-        result.push(digit);
-      }
-
-      if (r >= arrL.length - 1) {
-        if (initLimit === limit) isFloat = true;
-        arrL.push(48);
-        limit -= 1;
-      }
-
-      r += 1;
-      digit = 48;
-
-      continue;
-    }
-
-    for (let i = arrR.length - 1; i >= 0; i--) {
-      const idx = r - (arrR.length - 1 - i);
-
-      if (arrL[idx] < arrR[i]) {
-        arrL[idx] = arrL[idx] - arrR[i] + 58;
-        arrL[idx - 1] -= 1;
-      } else {
-        arrL[idx] = arrL[idx] - arrR[i] + 48;
-      }
-    }
-
-    digit += 1;
-  }
-
-  const multipliedResult = [];
-  let count = 0;
-
-  if (result[0] === 48) {
-    let isGrZero = false;
-
-    for (let i = 0; i < result.length; i++) {
-      if (!isGrZero) result[i] > 48 ? isGrZero = true : count += 1;
-
-      isGrZero && multipliedResult.push(result[i]);
-    }
-
-    for (let i = 0; i < count; i++) {
-      multipliedResult.push(48);
-      intLength -= 1;
-    }
-  }
-
-  const isZero = result.length === count;
-
-  return {
-    array: result[0] === 48 ? multipliedResult : result,
-    isFloat: isZero ? false : isFloat,
-    isNegative: isZero ? false : isNegative,
-    intLength: isZero ? 1 : intLength,
-  };
-};

package/src/mul/index.ts

@@ -1,23 +0,0 @@
-import { a2sMD, s2aMD } from "../shared/utils.ts";
-import { multiplication } from "./utils.ts";
-
-/** This function multiplies 2 numbers (as string). */
-export const mul = (strs: string[]): string => {
-  const arrays = strs.map((str) => s2aMD(str));
-  const inputData = arrays.reduce((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/mul/types.ts

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

package/src/mul/utils.ts

@@ -1,56 +0,0 @@
-import type { Multiplication } from "./types.ts";
-
-/** This function multiplies 2 numbers (as array). */
-export const multiplication: Multiplication = (
-  [arrL, intL],
-  [arrR, intR],
-  isNegative,
-) => {
-  if (
-    arrL.length === 0 || arrR.length === 0 ||
-    (arrL.length === 1 && arrL[0] === 48) ||
-    (arrR.length === 1 && arrR[0] === 48)
-  ) {
-    return { array: [48], intLength: 1, isFloat: false, isNegative: false };
-  }
-
-  const dec = (arrL.length - intL) + (arrR.length - intR);
-
-  const [left, right] = arrL.length >= arrR.length
-    ? [arrL, arrR]
-    : [arrR, arrL];
-
-  const sums: number[] = Array(right.length + left.length - 1);
-
-  for (let i = right.length - 1; i >= 0; i--) {
-    for (let j = left.length - 1; j >= 0; j--) {
-      const idx = j + i;
-
-      sums[idx] = (sums[idx] ?? 0) +
-        (left[j] - 48) * (right[i] - 48);
-    }
-  }
-
-  const result = Array(sums.length);
-  let idx = sums.length - 1;
-  let carryOver = 0;
-  let currNum = 0;
-  let nextNum = 0;
-
-  while (idx >= 0) {
-    currNum = sums[idx] ?? 0;
-    nextNum = (currNum + carryOver) % 10;
-    carryOver = (carryOver + currNum) / 10 | 0;
-    result[idx] = nextNum + 48;
-    idx -= 1;
-  }
-
-  carryOver > 0 && result.unshift(carryOver + 48);
-
-  return {
-    array: result,
-    intLength: result.length - dec,
-    isFloat: dec > 0,
-    isNegative,
-  };
-};

package/src/shared/types.ts

@@ -1,16 +0,0 @@
-import type { InputData } from "../types.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;

package/src/shared/utils.ts

@@ -1,130 +0,0 @@
-import type { A2S, S2AMD, S2ASA } from "./types.ts";
-
-// array to string
-export const a2sMD: A2S = (
-  array,
-  isFloat,
-  isNegative = false,
-  intLength = 0,
-) => {
-  const result: number[] = [];
-  let lastValuableIdx = array.length;
-
-  if (isFloat) {
-    let idx = array.length - 1;
-
-    while (array[idx] === 48 && idx >= intLength) {
-      lastValuableIdx = idx;
-      idx -= 1;
-    }
-  }
-
-  if (intLength !== array.length) {
-    if (intLength <= 0) {
-      result.push(48, 46);
-
-      for (let i = intLength; i < 0; i++) {
-        result.push(48);
-      }
-
-      for (let i = 0; i < lastValuableIdx; i++) {
-        result.push(array[i]);
-      }
-    } else {
-      for (let i = 0; i < lastValuableIdx; i++) {
-        if (i === intLength) result.push(46);
-
-        result.push(array[i]);
-      }
-    }
-
-    return (isNegative ? "-" : "") + String.fromCharCode(...result);
-  }
-
-  return (isNegative ? "-" : "") + String.fromCharCode(...array).trim();
-};
-
-export const a2sSA: A2S = (array, isFloat, isNegative = false) => {
-  let isToCheckTail = isFloat;
-
-  for (let 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 (let 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(...array).trim();
-};
-
-// string to array (sub, add)
-export const s2aSA: S2ASA = (string) => {
-  const isNegative = string.charCodeAt(0) === 45;
-  const shift = isNegative ? 1 : 0;
-  const array = Array<number>(string.length - shift);
-  let intLength = string.length - shift;
-  let isFloat = false;
-
-  for (let idx = 0 + shift; idx < string.length; idx++) {
-    const charCode = string.charCodeAt(idx);
-
-    if (charCode === 46) {
-      intLength = idx - shift;
-      isFloat || (isFloat = true);
-    }
-
-    array[idx - shift] = charCode;
-  }
-
-  return { array, intLength, isNegative, isFloat };
-};
-
-// string to array (mul, div)
-export const s2aMD: S2AMD = (string) => {
-  const array = Array<number>(0);
-  const isNegative = string.charCodeAt(0) === 45;
-  const shift = isNegative ? 1 : 0;
-  let dec = 0;
-
-  if (
-    (string.length === 1 && string.charCodeAt(0) === 48) ||
-    string.length === 2 && string.charCodeAt(0) === 45 &&
-      string.charCodeAt(1) === 48
-  ) {
-    return {
-      array: [48],
-      intLength: 1,
-      isNegative: false,
-      isFloat: false,
-    };
-  }
-  for (let idx = 0 + shift; idx < string.length; idx++) {
-    const charCode = string.charCodeAt(idx);
-
-    if (array.length === 0 && charCode === 48) continue;
-    if (charCode === 46) {
-      dec = string.length - 1 - idx;
-      continue;
-    }
-
-    array.push(charCode);
-  }
-
-  return {
-    array,
-    intLength: array.length - dec,
-    isNegative,
-    isFloat: dec > 0,
-  };
-};

package/src/sub/index.ts

@@ -1,35 +0,0 @@
-import { addition } from "../add/utils.ts";
-import { a2sSA, s2aSA } from "../shared/utils.ts";
-import { subtract } from "./utils.ts";
-
-/** This function subtracts 2 numbers (as string). */
-
-export function sub(strs: string[]): string {
-  const arrays = strs.map((str) => s2aSA(str));
-
-  const inputData = arrays.reduce((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);
-}

package/src/sub/types.ts

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

package/src/sub/utils.ts

@@ -1,86 +0,0 @@
-import type { Subtract } from "./types.ts";
-
-/** This function subtracts 2 numbers (as array). */
-export const subtract: Subtract = ([arrL, intL], [arrR, intR]) => {
-  const lenDiff = (intL - intR) * (intL > intR ? 1 : -1);
-  let [left, right, intLeft, intRight] = intL >= intR
-    ? [arrL, arrR, intL, intR]
-    : [arrR, arrL, intR, intL];
-  const fracLenL = left.length - intLeft;
-  const fracLenR = right.length - intRight;
-  let pl = lenDiff;
-  let pr = 0;
-  let isLeftBigger = lenDiff > 0;
-  let carryOver = false;
-  let isNegative = intLeft !== intL;
-
-  if (intLeft === left.length && intRight !== right.length) left.push(46);
-  if (intRight === right.length && intLeft !== left.length) right.push(46);
-
-  while (pr < right.length) {
-    if (left[pl] === 46 || right[pr] === 46) {
-      pr += 1;
-      pl += 1;
-    }
-
-    let sub = ((left[pl] ?? 48) - (right[pr] ?? 48)) + 48;
-
-    if (!isLeftBigger && left[pl] > right[pr]) {
-      isLeftBigger = true;
-    }
-
-    if (!isLeftBigger && sub < 48 && lenDiff === 0) {
-      [left, right] = [right, left];
-      [intL, intR] = [intR, intL];
-      isLeftBigger = true;
-      isNegative = true;
-      continue;
-    }
-
-    if (sub < 48) {
-      sub += 10;
-      carryOver = true;
-    }
-
-    let plReverse = pl - 1;
-    let 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);
-
-        carryOver = false;
-      } else {
-        plReverse >= 0 && (left[plReverse] = 57);
-        prReverse >= 0 && (right[prReverse] = 57);
-      }
-
-      plReverse -= 1;
-      prReverse -= 1;
-    }
-
-    left[pl] = sub;
-    right[pr] = sub;
-
-    pl += 1;
-    pr += 1;
-  }
-
-  while (left[0] === 48 && left[1] !== 46 && left.length > 1) {
-    left.shift();
-    intLeft -= 1;
-  }
-
-  return {
-    array: left,
-    intLength: intLeft,
-    isNegative,
-    isFloat: fracLenL + fracLenR > 0,
-  };
-};

package/src/types.ts

@@ -1,6 +0,0 @@
-export type InputData = { 
-    array: number[]; 
-    intLength: number; 
-    isNegative: boolean; 
-    isFloat: boolean 
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES5",
-    "module": "ES2022",
-    "outDir": "npm",
-    "declaration": true,
-  },
-  "exclude": ["./build.ts", "**/*.test.ts", "npm", "tsconfig.json"]
-}