@numio/bigmath 1.0.1

package/src/shared/types.ts

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

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

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

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

package/src/sub/utils.ts

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

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

package/tsconfig.json

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