@numio/bigmath 2.2.3 → 2.2.5

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+### 2.2.5
+Handle "0B", "0X", "0O", "-0B", "-0X", "-0O" as a start of the input for toBase function.
+Move documentation from README.md to web-site http://numio.deno.dev
+
+### 2.2.4
+Fix handling negative numbers for toBase function.
+
 ### 2.2.3
 Add validation for negative number input in square root function
 Add validation for negative number input in cube root function

package/README.md

@@ -96,336 +96,9 @@ pnpm add @numio/bigmath
 deno add jsr:@numio/bigmath
 ```
 
-# Examples:
-
-### Add numbers
-
-```javascript
-import { add } from "@numio/bigmath";
-
-const int = add(["12345", "99"]); // 12444
-const float = add(["0.1", "0.2", "0.3"]); // 0.6
-const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
-```
-
-### Subtract numbers
-
-```javascript
-import { sub } from "@numio/bigmath";
-
-const int = sub(["150", "99"]); // 51
-const float = sub(["1", "0.99"]); // 0.01
-const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
-```
-
-### Multiply numbers
-
-```javascript
-import { mul } from "@numio/bigmath";
-
-const int = mul(["15", "11", "2"]); // 330
-const float = mul(["0.01", "0.99"]); // 0.0099
-const negative = mul(["-2", "3"]); // -6
-```
-
-### Divide numbers
-
-```javascript
-import { div } from "@numio/bigmath";
-
-const int = div(["9999", "33"]); // 303
-const float = div(["0.06", "0.2"]); // 0.3
-const negative = div(["-2", "-3", "2"]); //0.33333333333333333333
-
-// set number of digit after the decimal. By default it's 20
-div(["10", "3"], 4); // 3.3333
-```
-
-### HEX, decimal, octal, binary
-```javascript
-import { add, sub } from "@numio/bigmath";
-
-add(["0xA", "0x5"]) // HEX + HEX, 10 + 5 = 15
-add(["0xA", "2"]) // HEX + decimal, 10 + 2 = 12
-sub(["35", "0b11"]) // decimal - binary, 35 - 3 = 32 
-sub(["0x1A", "0o31", "0b101", ]) // HEX - octal - binary, 26 - 25 - 5 = -4
-
-```
-
-### Round
-
-```javascript
-import { round } from "@numio/bigmath";
-
-round("-1.12345"); // -1
-round("1.5"); // 2
-round("1.0"); // 1
-round("0.00001"); // 0
-round("9.9"); // 10
-```
-
-### Round at position
-
-```javascript
-import { round } from "@numio/bigmath";
-
-round("1.12345", { decimals: 1 }); // 1.1
-round("1.12345", { decimals: 2 }); // 1.12
-round("1.12234", { decimals: 0 }); // 1
-round("9.999", { decimals: 2 }); // 10
-```
-
-### Round modes
-
-```javascript
-import { round } from "@numio/bigmath";
-
-round("1.11", { decimals: 1, roundMode: "up" }); // 1.2
-round("1.19", { decimals: 1, roundMode: "up" }); // 1.2
-
-round("1.11", { decimals: 1, roundMode: "down" }); // 1.1
-round("1.19", { decimals: 1, roundMode: "down" }); // 1.1
-
-round("1.15", { decimals: 1, roundMode: "half-up" }); // 1.2
-round("1.15", { decimals: 1, roundMode: "half-down" }); // 1.1
-
-round("1.15", { decimals: 1, roundMode: "half-even" }); // 1.2
-round("1.25", { decimals: 1, roundMode: "half-even" }); // 1.2
-round("1.35", { decimals: 1, roundMode: "half-even" }); // 1.4
-round("1.45", { decimals: 1, roundMode: "half-even" }); // 1.4
-round("1.55", { decimals: 1, roundMode: "half-even" }); // 1.6
-
-round("1.15", { decimals: 1, roundMode: "half-odd" }); // 1.1
-round("1.25", { decimals: 1, roundMode: "half-odd" }); // 1.3
-round("1.35", { decimals: 1, roundMode: "half-odd" }); // 1.3
-round("1.45", { decimals: 1, roundMode: "half-odd" }); // 1.5
-round("1.55", { decimals: 1, roundMode: "half-odd" }); // 1.5
-```
-
-### Round with "significant figures" flag
-
-```javascript
-import { round } from "@numio/bigmath";
-
-round("0.000119", { decimals: 2, sigFig: false }); // 0
-round("0.000119", { decimals: 2, sigFig: true }); // 0.00012
-
-round("0.0019", { decimals: 1, sigFig: true, roundMode: "down" }); // 0.001
-round("0.0011", { decimals: 1, sigFig: true, roundMode: "up" }); // 0.002
-
-round("1.000119", { decimals: 2, sigFig: false }); // 1
-round("1.000119", { decimals: 2, sigFig: true }); // 1
-```
-
-### Pipe
-
-```javascript
-import { Pipe } from "@numio/bigmath";
-
-const addNums = ["1", "2", "3"];
-const subNums = ["0.2", "0.3"];
-const divNums = ["4"];
-const mulNums = ["2", "5", "0.2"];
-
-new Pipe().add(addNums) // 6
-  .div(divNums) // 6 / 4 = 1.5 
-  .sub(subNums) // 1.5 - 0.2 - 0.3 = 1
-  .mul(mulNums) // 1 * 2 * 5 * 0.2 = 2
-  .calc() // convert end result to readable string
-
-new Pipe().sub(["1", "5"]) // 1 - 5 = -4
-  .abs() // 4 - returns absolute value
-
-new Pipe().add(["10", "5"]) // 11 + 5 = 15
-  .resultToBase(16) // f - returns result converted to base 16
-```
-
-### Quartile
-```javascript
-import { quartile } from "@numio/bigmath";
-
-quartile(["1", "2", "3", "4", "5", "6", "7", "8", "9"]) // { Q1: "2.5", Q2: "5", Q3: "7.5" }
-quartile(["0.001", "0.3", "0.4", "1"]) // { Q1: "0.1505", Q2: "0.35", Q3: "0.7" }
-
-```
-
-### Sort
-```javascript
-import { sort } from "@numio/bigmath";
-
-// native js sort for strings
-["1", "10", "11", "101", "11", "10", "1"].sort() // ["1", "1", "10", "10", "101", "11", "11"]
-
-// sort from "@numio/bigmath"
-sort(["1", "10", "11", "101", "11", "10", "1"]) // ["1", "1", "10", "10", "11", "11", "101"]
-
-// ASC sorting
-sort(["-0.1", "0.1", "-1"], "asc") // ["-1", "-0.1", "0.1"]
-
-// DESC sorting
-sort(["-0.1", "0.1", "-1"], "desc") // ["0.1", "-0.1", "-1"]
-
-```
-
-### Mean 
-```javascript
-import { mean } from "@numio/bigmath";
-
-mean(["5", "4", "3", "2", "1", "0"]) // "2.5"
-mean(["0.5", "0.4", "0.3", "0.2", "0.1", "0"]) // "0.25"
-```
-
-### Max 
-```javascript
-import { max } from "@numio/bigmath";
-
-max(["2", "-1", "0.1"]) // 2;
-```
-
-### Min
-```javascript
-import { min } from "@numio/bigmath";
-
-min(["2", "-1", "0.1"]) // -1;
-```
-
-### IsEqual
-```javascript
-import { isEqual } from "@numio/bigmath";
-
-isEqual({left: "0.1", right: "0.1"}) // true;
-isEqual({left: "2", right: "0.1"}) // false;
-```
-
-### IsLeftGreater
-```javascript
-import { isLeftGreater } from "@numio/bigmath";
-
-isLeftGreater({left: "0.1", right: "2"}) // false;
-isLeftGreater({left: "2", right: "0.1"}) // true;
-isLeftGreater({left: "0.1", right: "0.1"}) // false;
-isLeftGreater({left: "0.1", right: "-0.1"}) // true;
-```
-
-### IsLeftGreaterOrEqual
-```javascript
-import { isLeftGreaterOrEqual } from "@numio/bigmath";
-
-isLeftGreaterOrEqual({left: "0.1", right: "2"}) // false;
-isLeftGreaterOrEqual({left: "2", right: "0.1"}) // true;
-isLeftGreaterOrEqual({left: "0.1", right: "0.1"}) // true;
-isLeftGreaterOrEqual({left: "0.1", right: "-0.1"}) // true;
-```
-
-### MAD - Median Absolute Deviation
-```javascript
-import { MAD } from "@numio/bigmath";
-
-MAD(["7", "15", "36", "39", "40", "41"]) // 3;
-```
-
-### IQR - Interquartile Range
-```javascript
-import { IQR } from "@numio/bigmath";
-
-IQR(["7", "15", "36", "39", "40", "41"]) // 25;
-```
-
-### SQRT - square root of a number
-```javascript
-import { sqrt } from "@numio/bigmath";
-
-sqrt("81") // 9;
-sqrt("3") // 1.7320508075689;
-
-// you can change precision of a result (second parameter), 
-sqrt("3", "0.01") // 1.732;
-sqrt("3", "0.000000000000000000001") // 1.732050807568877293527;
-```
-
-### CBRT - cube root of a number
-```javascript
-import { cbrt } from "@numio/bigmath";
-
-cbrt("37") // 3;
-cbrt("1000") // 10;
-cbrt("15"), // 2.4662120743305
-
-// you can change precision of a result (second parameter), 
-cbrt("15", "0.001") // 2.466
-```
-
-### ABS - absolute value
-```javascript
-import { abs } from "@numio/bigmath";
-
-abs("-1") // 1;
-abs("1") // 1;
-```
-
-### toBase - convert number to another base
-```javascript
-import { toBase } from "@numio/bigmath";
-
-toBase({ value: "11", toBase: 16 }) // b
-// 0x - HEX
-toBase({ value: "0xb", toBase: 10 }) // 11
-// 0b - binary
-toBase({ value: "0b101", toBase: 10 }) // 5
-toBase({ value: "0b1101", toBase: 16 }) // d
-// 0o - octal
-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
-
-```javascript
-// NO precision loss using numeric literals with more than 15 significant digits.
-const int = add(
-  "999999999999999999999999999999999999999999999999999999999999999",
-  "2",
-); // "1000000000000000000000000000000000000000000000000000000000000001"
-
-const float = mul(
-  "0.00000000000000000000000000000000000000000000000000000000000000000009",
-  "0.000000002",
-); // 0.00000000000000000000000000000000000000000000000000000000000000000000000000018
-```
+##
+### See documentation and examples here: https://numio.deno.dev 
+##
 
 Download from NPM - https://www.npmjs.com/package/@numio/bigmath
 

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

package/src/shared/utils.js

@@ -18,8 +18,19 @@ export const bi2s = (bigInt, fpe) => {
 };
 export const s2bi = (str) => {
     const fpi = str.indexOf(".");
-    if (fpi === -1)
+    const isHex = str.startsWith("0x") || str.startsWith("-0x") ||
+        str.startsWith("-0X") || str.startsWith("0X");
+    const isOctal = str.startsWith("0o") || str.startsWith("-0o") ||
+        str.startsWith("-0O") || str.startsWith("0O");
+    const isBinary = str.startsWith("0b") || str.startsWith("-0b") ||
+        str.startsWith("-0B") || str.startsWith("0B");
+    if (fpi === -1 && !isHex && !isOctal && !isBinary)
         return [BigInt(str), 0];
+    if (isHex || isBinary || isOctal) {
+        const isNegative = str[0] === "-";
+        const bi = BigInt(str.slice(isNegative ? 1 : 0));
+        return [isNegative ? -1n * bi : bi, 0];
+    }
     if (str.length < 15 && str[0] !== "0") {
         return [
             BigInt(+(str.slice(0, fpi) + str.slice(fpi + 1))),

package/src/toBase/toBase.js

@@ -1,4 +1,14 @@
+import { s2bi } from "../shared/utils.js";
 /** Convert number to another base */
 export const toBase = ({ value, toBase }) => {
-    return BigInt(value).toString(toBase);
+    const [bi] = s2bi(value);
+    const isNegative = value[0] === "-";
+    const map = {
+        2: "0b",
+        8: "0o",
+        10: "",
+        16: "0x",
+    };
+    return (isNegative ? "-" : "") + map[toBase] +
+        (isNegative ? -1n * bi : bi).toString(toBase).toUpperCase();
 };

package/src/toBase/types.d.ts

@@ -1,4 +1,4 @@
 export type ToBase = (arg: {
     value: string;
-    toBase: number;
+    toBase: 16 | 10 | 8 | 2;
 }) => string;