@numio/bigmath 2.1.3 → 2.2.1

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+### 2.2.1
+Add Number format validation examples (README.md)
+
+### 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
 

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:
 
@@ -370,6 +377,40 @@ toBase({ value: "0b1101", toBase: 16 }) // d
 toBase({ value: "0o11", toBase: 10 }) // 9
 ```
 
+### Number format validation
+
+```javascript
+import { isHex, isBinary, isDecimal, isOctal, isNumber } from "@numio/bigmath";
+
+console.log(isHex("0x1A")); // true
+console.log(isHex("1A"));    // false (no 0x prefix)
+console.log(isHex("-0x2f")); // true
+console.log(isHex("0xG"));  // false (invalid hex digit)
+
+console.log(isBinary("0b101")); // true
+console.log(isBinary("101"));   // false (no 0b prefix)
+console.log(isBinary("-0b11"));  // true
+console.log(isBinary("0b12"));  // false (invalid binary digit)
+
+console.log(isDecimal("123"));   // true
+console.log(isDecimal("123.45"));// true
+console.log(isDecimal("-0.5"));  // true
+console.log(isDecimal(".5"));   // false (leading dot)
+console.log(isDecimal("10."));  // false (trailing dot)
+
+console.log(isOctal("0o77"));  // true
+console.log(isOctal("77"));    // false (no 0o prefix)
+console.log(isOctal("-0o12")); // true
+console.log(isOctal("0o19"));  // false (invalid octal digit)
+
+console.log(isNumber("0x1A"));  // true (hex)
+console.log(isNumber("0b101")); // true (binary)
+console.log(isNumber("123.45"));// true (decimal)
+console.log(isNumber("0o77"));  // true (octal)
+console.log(isNumber("123"));   // true (decimal)
+console.log(isNumber("abc"));   // false (not a valid number)
+```
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 
@@ -392,4 +433,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.3",
+  "version": "2.2.1",
   "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;