@numio/bigmath 1.0.1

package/npm/src/mul/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Multiplication } from "./types.d.ts";
+/** This function multiplies 2 numbers (as array). */
+export declare const multiplication: Multiplication;

package/npm/src/mul/utils.js

@@ -0,0 +1,42 @@
+/** This function multiplies 2 numbers (as array). */
+export var multiplication = function (_a, _b, isNegative) {
+    var _c, _d;
+    var arrL = _a[0], intL = _a[1];
+    var arrR = _b[0], intR = _b[1];
+    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 };
+    }
+    var dec = (arrL.length - intL) + (arrR.length - intR);
+    var _e = arrL.length >= arrR.length
+        ? [arrL, arrR]
+        : [arrR, arrL], left = _e[0], right = _e[1];
+    var sums = Array(right.length + left.length - 1);
+    for (var i = right.length - 1; i >= 0; i--) {
+        for (var j = left.length - 1; j >= 0; j--) {
+            var idx_1 = j + i;
+            sums[idx_1] = ((_c = sums[idx_1]) !== null && _c !== void 0 ? _c : 0) +
+                (left[j] - 48) * (right[i] - 48);
+        }
+    }
+    var result = Array(sums.length);
+    var idx = sums.length - 1;
+    var carryOver = 0;
+    var currNum = 0;
+    var nextNum = 0;
+    while (idx >= 0) {
+        currNum = (_d = sums[idx]) !== null && _d !== void 0 ? _d : 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: isNegative,
+    };
+};

package/npm/src/shared/types.d.ts

@@ -0,0 +1,4 @@
+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;

package/npm/src/shared/utils.d.ts

@@ -0,0 +1,5 @@
+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;

package/npm/src/shared/utils.js

@@ -0,0 +1,108 @@
+// array to string
+export var a2sMD = function (array, isFloat, isNegative, intLength) {
+    if (isNegative === void 0) { isNegative = false; }
+    if (intLength === void 0) { intLength = 0; }
+    var result = [];
+    var lastValuableIdx = array.length;
+    if (isFloat) {
+        var 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 (var i = intLength; i < 0; i++) {
+                result.push(48);
+            }
+            for (var i = 0; i < lastValuableIdx; i++) {
+                result.push(array[i]);
+            }
+        }
+        else {
+            for (var i = 0; i < lastValuableIdx; i++) {
+                if (i === intLength)
+                    result.push(46);
+                result.push(array[i]);
+            }
+        }
+        return (isNegative ? "-" : "") + String.fromCharCode.apply(String, result);
+    }
+    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) {
+    var array = Array(0);
+    var isNegative = string.charCodeAt(0) === 45;
+    var shift = isNegative ? 1 : 0;
+    var 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 (var idx = 0 + shift; idx < string.length; idx++) {
+        var 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: array,
+        intLength: array.length - dec,
+        isNegative: isNegative,
+        isFloat: dec > 0,
+    };
+};

package/npm/src/sub/index.d.ts

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

package/npm/src/sub/index.js

@@ -0,0 +1,19 @@
+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). */
+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);
+}

package/npm/src/sub/types.d.ts

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

package/npm/src/sub/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Subtract } from "./types.d.ts";
+/** This function subtracts 2 numbers (as array). */
+export declare const subtract: Subtract;

package/npm/src/sub/utils.js

@@ -0,0 +1,76 @@
+/** This function subtracts 2 numbers (as array). */
+export var subtract = function (_a, _b) {
+    var _c, _d;
+    var _e, _f;
+    var arrL = _a[0], intL = _a[1];
+    var arrR = _b[0], intR = _b[1];
+    var lenDiff = (intL - intR) * (intL > intR ? 1 : -1);
+    var _g = intL >= intR
+        ? [arrL, arrR, intL, intR]
+        : [arrR, arrL, intR, intL], left = _g[0], right = _g[1], intLeft = _g[2], intRight = _g[3];
+    var fracLenL = left.length - intLeft;
+    var fracLenR = right.length - intRight;
+    var pl = lenDiff;
+    var pr = 0;
+    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 (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;
+        }
+        if (!isLeftBigger && sub < 48 && lenDiff === 0) {
+            _c = [right, left], left = _c[0], right = _c[1];
+            _d = [intR, intL], intL = _d[0], intR = _d[1];
+            isLeftBigger = true;
+            isNegative = true;
+            continue;
+        }
+        if (sub < 48) {
+            sub += 10;
+            carryOver = true;
+        }
+        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);
+                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: isNegative,
+        isFloat: fracLenL + fracLenR > 0,
+    };
+};

package/npm/src/types.d.ts

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

package/package.json

@@ -0,0 +1,57 @@
+{
+  "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

@@ -0,0 +1,34 @@
+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

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

package/src/add/utils.ts

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,23 @@
+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

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

package/src/mul/utils.ts

@@ -0,0 +1,56 @@
+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,
+  };
+};