@numio/bigmath 2.1.2 → 2.2.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+### 2.2.0
+Added `isHex(str: string): boolean` - Checks if a string is a valid hexadecimal number (prefixed with `0x` or `-0x`).
+Added `isBinary(str: string): boolean` - Checks if a string is a valid binary number (prefixed with `0b` or `-0b`).
+Added `isDecimal(str: string): boolean` - Checks if a string is a valid decimal number.
+Added `isOctal(str: string): boolean` - Checks if a string is a valid octal number (prefixed with `0o` or `-0o`).
+Added `isNumber(str: string): boolean` - Checks if a string is a valid number in any of the formats supported by the library (decimal, hexadecimal, binary, octal).
+
+### 2.1.3
+Optimize performance for small numbers
+
 ### 2.1.2
 Renamed main.ts files
 Changed import path in test files

package/README.md

@@ -12,6 +12,8 @@
 * **Eliminate Precision Loss:** Achieve accurate results even with numeric literals exceeding 15 significant digits, ensuring the integrity of your calculations.
 * **Precise Decimal Operations:** Execute addition, subtraction, multiplication, and division on decimal numbers with guaranteed accuracy, including scenarios with negative values.
 * ****NEW! Multi-Base Number Support:** Seamlessly perform arithmetic operations involving **hexadecimal (HEX), octal, binary, and decimal numbers**, offering unparalleled flexibility in handling various number formats.
+* ****NEW! Number Format Validation:** Easily validate if a string represents a valid **hexadecimal (`isHex`)**, **binary (`isBinary`)**, **decimal (`isDecimal`)**, **octal (`isOctal`)**, or any valid **number (`isNumber`)** format supported by the library.
+
 
 
 **Unlock Advanced Numerical Operations:**
@@ -54,8 +56,13 @@ With `@numio/bigmath`, you can confidently perform complex arithmetic operations
 
 ### Latest update
 
-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.
+**New Functions added:**
+
+* `isHex` - Checks if a string is a valid hexadecimal number (prefixed with `0x` or `-0x`).
+* `isBinary` - Checks if a string is a valid binary number (prefixed with `0b` or `-0b`).
+* `isDecimal` - Checks if a string is a valid decimal number.
+* `isOctal` - Checks if a string is a valid octal number (prefixed with `0o` or `-0o`).
+* `isNumber` - Checks if a string is a valid number in any of the formats supported by the library (decimal, hexadecimal, binary, octal).
 
 # Install:
 
@@ -392,4 +399,6 @@ Download from JSR - https://jsr.io/@numio/bigmath
 
 Home page - https://github.com/shpunter/numio-bigmath/blob/main/README.md
 
+Change log - https://github.com/shpunter/numio-bigmath/blob/main/CHANGELOG.md
+
 License - https://github.com/shpunter/numio-bigmath/blob/main/LICENSE

package/index.d.ts

@@ -18,4 +18,9 @@ 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, };
+import { isHex } from "./src/isValid/isHex.d.ts";
+import { isBinary } from "./src/isValid/isBinary.d.ts";
+import { isDecimal } from "./src/isValid/isDecimal.d.ts";
+import { isOctal } from "./src/isValid/isOctal.d.ts";
+import { isNumber } from "./src/isValid/isNumber.d.ts";
+export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, isHex, isBinary, isDecimal, isOctal, isNumber };

package/index.js

@@ -18,4 +18,9 @@ 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, };
+import { isHex } from "./src/isValid/isHex.js";
+import { isBinary } from "./src/isValid/isBinary.js";
+import { isDecimal } from "./src/isValid/isDecimal.js";
+import { isOctal } from "./src/isValid/isOctal.js";
+import { isNumber } from "./src/isValid/isNumber.js";
+export { abs, add, cbrt, div, IQR, isEqual, isLeftGreater, isLeftGreaterOrEqual, MAD, max, mean, min, mul, Pipe, quartile, round, sort, sqrt, sub, toBase, isHex, isBinary, isDecimal, isOctal, isNumber };

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

package/src/isValid/isBinary.d.ts

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

package/src/isValid/isBinary.js

@@ -0,0 +1,3 @@
+export const isBinary = (str) => {
+    return /^-?(0b)[01]+$/i.test(str);
+};

package/src/isValid/isDecimal.d.ts

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

package/src/isValid/isDecimal.js

@@ -0,0 +1,3 @@
+export const isDecimal = (str) => {
+    return /^-?(?![\.])\d+(\.\d+)?$/.test(str);
+};

package/src/isValid/isHex.d.ts

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

package/src/isValid/isHex.js

@@ -0,0 +1,3 @@
+export const isHex = (str) => {
+    return /^-?(0x)[0-9a-fA-F]+$/i.test(str);
+};

package/src/isValid/isNumber.d.ts

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

package/src/isValid/isNumber.js

@@ -0,0 +1,7 @@
+import { isBinary } from "./isBinary.js";
+import { isDecimal } from "./isDecimal.js";
+import { isHex } from "./isHex.js";
+import { isOctal } from "./isOctal.js";
+export const isNumber = (str) => {
+    return isBinary(str) || isHex(str) || isOctal(str) || isDecimal(str);
+};

package/src/isValid/isOctal.d.ts

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

package/src/isValid/isOctal.js

@@ -0,0 +1,3 @@
+export const isOctal = (str) => {
+    return /^-?(0o)[0-7]+$/i.test(str);
+};

package/src/isValid/types.d.ts

@@ -0,0 +1 @@
+export type IsValid = (str: string) => boolean;

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.");