@numio/bigmath 2.1.1 → 2.1.3

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+### 2.1.3
+Optimize performance for small numbers
+
+### 2.1.2
+Renamed main.ts files
+Changed import path in test files
+Change build config - run test on JSR and NPM versions
+
+### 2.1.1
+Fixed lib crash (NPM version)
+
+### 2.1.0 
+Added `toBase` - convert number to another base
+Added `abs` - absolute value
+Added `isLeftGreaterOrEqual` - Is the left-hand side value greater than or equal to the right-hand side value
+Added `cbrt` - cube root of a number
+
+Added `Pipe().abs` - absolute value in pipe
+Added `Pipe().resultToBase` - convert number to another base in pipe
+
+### 2.0.0
+The performance was improved. Adding, subtracting, dividing, and multiplying are now **2** to **5** times faster than before.\
+Adding, subtracting, dividing, and multiplying support operations on HEX, octal, binary, and decimal numbers. Mixed-type calculations are allowed, with the final result converted to decimal.
+
+### 1.1.0
+Added `sqrt` - square root of a number\
+Added `isEqual` and `isLeftGreater` - to compare 2 numbers.\
+Added `MAD` - Median Absolute Deviation.\
+Added `IQR` - Interquartile Range.

package/index.d.ts

@@ -1,17 +1,21 @@
-import { add } from "./src/operations/add/main.d.ts";
-import { mul } from "./src/operations/mul/main.d.ts";
-import { sub } from "./src/operations/sub/main.d.ts";
-import { div } from "./src/operations/div/main.d.ts";
-import { round } from "./src/round/main.d.ts";
-import { Pipe } from "./src/pipe/main.d.ts";
-import { quartile } from "./src/quartile/main.d.ts";
-import { sort } from "./src/sort/main.d.ts";
-import { mean } from "./src/mean/main.d.ts";
-import { isEqual, isLeftGreater, isLeftGreaterOrEqual, max, min } from "./src/compare/main.d.ts";
-import { IQR } from "./src/IQR/main.d.ts";
-import { MAD } from "./src/MAD/main.d.ts";
-import { sqrt } from "./src/sqrt/main.d.ts";
-import { cbrt } from "./src/cbrt/main.d.ts";
-import { abs } from "./src/abs/main.d.ts";
-import { toBase } from "./src/toBase/main.d.ts";
+import { add } from "./src/operations/add/add.d.ts";
+import { mul } from "./src/operations/mul/mul.d.ts";
+import { sub } from "./src/operations/sub/sub.d.ts";
+import { div } from "./src/operations/div/div.d.ts";
+import { round } from "./src/round/round.d.ts";
+import { Pipe } from "./src/pipe/pipe.d.ts";
+import { quartile } from "./src/quartile/quartile.d.ts";
+import { sort } from "./src/sort/sort.d.ts";
+import { mean } from "./src/mean/mean.d.ts";
+import { isEqual } from "./src/compare/isEqual.d.ts";
+import { min } from "./src/compare/min.d.ts";
+import { max } from "./src/compare/max.d.ts";
+import { isLeftGreaterOrEqual } from "./src/compare/isLeftGreaterOrEqual.d.ts";
+import { isLeftGreater } from "./src/compare/isLeftGreater.d.ts";
+import { IQR } from "./src/IQR/iqr.d.ts";
+import { MAD } from "./src/MAD/mad.d.ts";
+import { sqrt } from "./src/sqrt/sqrt.d.ts";
+import { cbrt } from "./src/cbrt/cbrt.d.ts";
+import { abs } from "./src/abs/abs.d.ts";
+import { toBase } from "./src/toBase/toBase.d.ts";
 export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, };

package/index.js

@@ -1,17 +1,21 @@
-import { add } from "./src/operations/add/main.js";
-import { mul } from "./src/operations/mul/main.js";
-import { sub } from "./src/operations/sub/main.js";
-import { div } from "./src/operations/div/main.js";
-import { round } from "./src/round/main.js";
-import { Pipe } from "./src/pipe/main.js";
-import { quartile } from "./src/quartile/main.js";
-import { sort } from "./src/sort/main.js";
-import { mean } from "./src/mean/main.js";
-import { isEqual, isLeftGreater, isLeftGreaterOrEqual, max, min, } from "./src/compare/main.js";
-import { IQR } from "./src/IQR/main.js";
-import { MAD } from "./src/MAD/main.js";
-import { sqrt } from "./src/sqrt/main.js";
-import { cbrt } from "./src/cbrt/main.js";
-import { abs } from "./src/abs/main.js";
-import { toBase } from "./src/toBase/main.js";
+import { add } from "./src/operations/add/add.js";
+import { mul } from "./src/operations/mul/mul.js";
+import { sub } from "./src/operations/sub/sub.js";
+import { div } from "./src/operations/div/div.js";
+import { round } from "./src/round/round.js";
+import { Pipe } from "./src/pipe/pipe.js";
+import { quartile } from "./src/quartile/quartile.js";
+import { sort } from "./src/sort/sort.js";
+import { mean } from "./src/mean/mean.js";
+import { isEqual } from "./src/compare/isEqual.js";
+import { min } from "./src/compare/min.js";
+import { max } from "./src/compare/max.js";
+import { isLeftGreaterOrEqual } from "./src/compare/isLeftGreaterOrEqual.js";
+import { isLeftGreater } from "./src/compare/isLeftGreater.js";
+import { IQR } from "./src/IQR/iqr.js";
+import { MAD } from "./src/MAD/mad.js";
+import { sqrt } from "./src/sqrt/sqrt.js";
+import { cbrt } from "./src/cbrt/cbrt.js";
+import { abs } from "./src/abs/abs.js";
+import { toBase } from "./src/toBase/toBase.js";
 export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, };

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": "2.1.1",
+  "version": "2.1.3",
   "keywords": [
     "precision",
     "arithmetic",

package/src/abs/{main.d.ts → abs.d.ts}

@@ -1,2 +1,3 @@
 import type { Abs } from "./types.d.ts";
+/** Get absolute value of a number */
 export declare const abs: Abs;

package/src/abs/{main.js → abs.js}

@@ -1,5 +1,6 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { absInner } from "./utils.js";
+/** Get absolute value of a number */
 export const abs = (value) => {
     const [bi, fpe] = absInner(s2bi(value));
     return bi2s(bi, fpe);

package/src/cbrt/{main.js → cbrt.js}

@@ -1,4 +1,4 @@
-import { round } from "../round/main.js";
+import { round } from "../round/round.js";
 import { bi2s, s2bi } from "../shared/utils.js";
 import { cbrtInner } from "./utils.js";
 /** Find cube root of a number */

package/src/compare/isEqual.d.ts

@@ -0,0 +1,3 @@
+import type { IsEqual } from "./types.d.ts";
+/** This function returns if left and right values are equal */
+export declare const isEqual: IsEqual;

package/src/compare/isEqual.js

@@ -0,0 +1,6 @@
+import { s2bi } from "../shared/utils.js";
+import { isEqualInner } from "./utils.js";
+/** This function returns if left and right values are equal */
+export const isEqual = ({ left, right }) => {
+    return isEqualInner({ left: s2bi(left), right: s2bi(right) });
+};

package/src/compare/isLeftGreater.d.ts

@@ -0,0 +1,3 @@
+import type { IsLeftGreater } from "./types.d.ts";
+/** This function returns if left value is greater than right value */
+export declare const isLeftGreater: IsLeftGreater;

package/src/compare/isLeftGreater.js

@@ -0,0 +1,6 @@
+import { s2bi } from "../shared/utils.js";
+import { isLeftGreaterInner } from "./utils.js";
+/** This function returns if left value is greater than right value */
+export const isLeftGreater = ({ left, right }) => {
+    return isLeftGreaterInner({ left: s2bi(left), right: s2bi(right) });
+};

package/src/compare/isLeftGreaterOrEqual.d.ts

@@ -0,0 +1,3 @@
+import type { IsLeftGreaterOrEqual } from "./types.d.ts";
+/** This function returns if left value is greater than right value or equal*/
+export declare const isLeftGreaterOrEqual: IsLeftGreaterOrEqual;

package/src/compare/isLeftGreaterOrEqual.js

@@ -0,0 +1,6 @@
+import { s2bi } from "../shared/utils.js";
+import { isLeftGreaterOrEqualInner } from "./utils.js";
+/** This function returns if left value is greater than right value or equal*/
+export const isLeftGreaterOrEqual = ({ left, right }) => {
+    return isLeftGreaterOrEqualInner({ left: s2bi(left), right: s2bi(right) });
+};

package/src/compare/max.d.ts

@@ -0,0 +1,3 @@
+import type { Max } from "./types.d.ts";
+/** This function returns max value. */
+export declare const max: Max;

package/src/compare/max.js

@@ -0,0 +1,8 @@
+import { bi2s, s2bi } from "../shared/utils.js";
+import { maxInner } from "./utils.js";
+/** This function returns max value. */
+export const max = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = maxInner(arrayInner);
+    return bi2s(bi, fpe);
+};

package/src/compare/min.d.ts

@@ -0,0 +1,3 @@
+import type { Min } from "./types.d.ts";
+/** This function returns min value. */
+export declare const min: Min;

package/src/compare/min.js

@@ -0,0 +1,8 @@
+import { bi2s, s2bi } from "../shared/utils.js";
+import { minInner } from "./utils.js";
+/** This function returns min value. */
+export const min = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = minInner(arrayInner);
+    return bi2s(bi, fpe);
+};

package/src/shared/utils.js

@@ -20,40 +20,46 @@ export const s2bi = (str) => {
     const fpi = str.indexOf(".");
     if (fpi === -1)
         return [BigInt(str), 0];
+    if (str.length < 15 && str[0] !== "0") {
+        return [
+            BigInt(+(str.slice(0, fpi) + str.slice(fpi + 1))),
+            str.length - 1 - fpi,
+        ];
+    }
     return [
         BigInt(str.slice(0, fpi) + str.slice(fpi + 1)),
-        fpi === -1 ? 0 : str.length - 1 - fpi,
+        str.length - 1 - fpi,
     ];
 };
 export const calcInner = (array, op, def) => {
-    let bigInt = def ? def[0] : array[0][0];
-    let fpe = def ? def[1] : array[0][1];
+    let totalBi = def ? def[0] : array[0][0];
+    let totalFpe = def ? def[1] : array[0][1];
     const opm = op(1n, 1n);
     for (let i = def ? 0 : 1; i < array.length; i++) {
-        const [bigCurrent, dpLen] = array[i];
-        if (dpLen === 0 && fpe === 0) {
-            bigInt = op(bigInt, bigCurrent);
+        const [bi, fpe] = array[i];
+        if (fpe === 0 && totalFpe === 0) {
+            totalBi = op(totalBi, bi);
             continue;
         }
         if (opm === 1n) {
-            bigInt = op(bigInt, bigCurrent);
-            fpe += dpLen;
+            totalBi = op(totalBi, bi);
+            totalFpe += fpe;
         }
         else {
-            if (fpe < dpLen) {
-                const fpDiff = dpLen - fpe;
-                bigInt = op(bigInt * (10n ** BigInt(fpDiff)), bigCurrent);
+            if (totalFpe < fpe) {
+                const fpDiff = fpe - totalFpe;
+                totalBi = op(totalBi * (10n ** BigInt(fpDiff)), bi);
             }
-            if (fpe > dpLen) {
-                bigInt = op(bigInt, bigCurrent * (10n ** BigInt(fpe - dpLen)));
+            if (totalFpe > fpe) {
+                totalBi = op(totalBi, bi * (10n ** BigInt(totalFpe - fpe)));
             }
-            if (fpe === dpLen)
-                bigInt = op(bigInt, bigCurrent);
-            if (fpe < dpLen)
-                fpe = dpLen;
+            if (totalFpe === fpe)
+                totalBi = op(totalBi, bi);
+            if (totalFpe < fpe)
+                totalFpe = fpe;
         }
     }
-    return [bigInt, fpe];
+    return [totalBi, totalFpe];
 };
 export const fillHead = (len, fpe, isNeg, hasBefore) => {
     let head = (isNeg ? "-" : "") + (hasBefore ? "" : "0.");

package/src/sqrt/{main.js → sqrt.js}

@@ -1,4 +1,4 @@
-import { round } from "../round/main.js";
+import { round } from "../round/round.js";
 import { bi2s, s2bi } from "../shared/utils.js";
 import { sqrtInner } from "./utils.js";
 /** Find square root of a number */

package/src/toBase/{main.d.ts → toBase.d.ts}

@@ -1,2 +1,3 @@
 import type { ToBase } from "./types.d.ts";
+/** Convert number to another base */
 export declare const toBase: ToBase;

package/src/toBase/{main.js → toBase.js}

@@ -1,3 +1,4 @@
+/** Convert number to another base */
 export const toBase = ({ value, toBase }) => {
     return BigInt(value).toString(toBase);
 };

package/src/compare/main.d.ts

@@ -1,11 +0,0 @@
-import type { IsEqual, IsLeftGreater, IsLeftGreaterOrEqual, Max, Min } from "./types.d.ts";
-/** This function returns max value. */
-export declare const max: Max;
-/** This function returns min value. */
-export declare const min: Min;
-/** This function returns if left value is greater than right value */
-export declare const isLeftGreater: IsLeftGreater;
-/** This function returns if left value is greater than right value */
-export declare const isLeftGreaterOrEqual: IsLeftGreaterOrEqual;
-/** This function returns if left and right values are equal */
-export declare const isEqual: IsEqual;

package/src/compare/main.js

@@ -1,26 +0,0 @@
-import { bi2s, s2bi } from "../shared/utils.js";
-import { isEqualInner, isLeftGreaterInner, isLeftGreaterOrEqualInner, maxInner, minInner, } from "./utils.js";
-/** This function returns max value. */
-export const max = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
-    const [bi, fpe] = maxInner(arrayInner);
-    return bi2s(bi, fpe);
-};
-/** This function returns min value. */
-export const min = (array) => {
-    const arrayInner = array.map((str) => s2bi(str));
-    const [bi, fpe] = minInner(arrayInner);
-    return bi2s(bi, fpe);
-};
-/** This function returns if left value is greater than right value */
-export const isLeftGreater = ({ left, right }) => {
-    return isLeftGreaterInner({ left: s2bi(left), right: s2bi(right) });
-};
-/** This function returns if left value is greater than right value */
-export const isLeftGreaterOrEqual = ({ left, right }) => {
-    return isLeftGreaterOrEqualInner({ left: s2bi(left), right: s2bi(right) });
-};
-/** This function returns if left and right values are equal */
-export const isEqual = ({ left, right }) => {
-    return isEqualInner({ left: s2bi(left), right: s2bi(right) });
-};

package/src/shared/constant.d.ts

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

package/src/shared/constant.js

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