@numio/bigmath 1.0.9 → 1.0.10

package/README.md

@@ -18,7 +18,13 @@
 * **Flexible Rounding:** Round numbers to the nearest integer or a specific number of decimal places with various rounding modes (up, down, half-up, half-down, half-even, half-odd) to meet your exact requirements.
 * **Round Based on Significant Figures:** Control rounding based on the number of significant figures, crucial for scientific and engineering applications.
 * **Chain Operations with Pipe:** Simplify complex calculations by chaining arithmetic operations in a readable and intuitive manner.
-* **Analyze Data Distribution:** Calculate quartiles (Q1, Q2, Q3) to understand the spread and central tendency of your numerical data, helping identify outliers and the shape of the distribution.
+* **Analyze Data Distribution:**
+    * **Calculate Quartiles (Q1, Q2, Q3):** Understand the spread and central tendency of your numerical data, helping identify outliers and the shape of the distribution.
+    * **Calculate Median Absolute Deviation (MAD):** Measure the dispersion of a dataset, providing a robust alternative to standard deviation that is less sensitive to outliers.
+    * **Calculate Interquartile Range (IQR):** Determine the spread of the middle 50% of your data, useful for identifying the central bulk and potential outliers.
+* **Compare Numbers:**
+    * **Check for Equality (`isEqual`):** Accurately determine if two arbitrary-precision numbers are equal.
+    * **Check if Left is Greater (`isLeftGreater`):** Precisely compare two arbitrary-precision numbers to see if the left operand is greater than the right.
 * **Sort Numbers Accurately:** Sort arrays of numbers, including negative and decimal values, in ascending or descending order, correctly handling string representations of numbers that JavaScript's native sort might misinterpret.
 * **Calculate Central Tendency:** Easily compute the mean (average) of a set of numbers.
 * **Identify Extremes:** Find the maximum and minimum values within an array of numbers.
@@ -38,11 +44,9 @@ With `@numio/bigmath`, you can confidently perform complex arithmetic operations
 
 ### Latest update
 
-Added sorting, min/max, mean.
-
-Added quartile functionality. When you might need it?
-Understanding Distribution. Quartiles (Q1, Q2, and Q3) split a dataset into four groups, each representing 25% of the data. 
-Identifying Outliers. They help visualize the shape and spread of the data, revealing whether it's skewed or symmetrical. 
+Added `isEqual` and `isLeftGreater` - to compare 2 numbers.
+Added `MAD` - Median Absolute Deviation.
+Added `IQR` - Interquartile Range.
 
 # Install:
 
@@ -83,7 +87,7 @@ deno add jsr:@numio/bigmath
 ```javascript
 import { add } from "@numio/bigmath";
 
-const int = add(["12345", "99"]); // 124444
+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
 ```
@@ -252,6 +256,38 @@ 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;
+```
+
+### 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;
+```
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 

package/index.d.ts

@@ -7,5 +7,7 @@ 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 { min, max } from "./src/compare/main.d.ts";
-export { add, div, max, mean, min, mul, pipe, quartile, round, sort, sub };
+import { isEqual, isLeftGreater, max, min } from "./src/compare/main.d.ts";
+import { IQR } from "./src/IQR/main.d.ts";
+import { MAD } from "./src/MAD/main.d.ts";
+export { add, div, IQR, isEqual, isLeftGreater, MAD, max, mean, min, mul, pipe, quartile, round, sort, sub, };

package/index.js

@@ -7,5 +7,7 @@ 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 { min, max } from "./src/compare/main.js";
-export { add, div, max, mean, min, mul, pipe, quartile, round, sort, sub };
+import { isEqual, isLeftGreater, max, min } from "./src/compare/main.js";
+import { IQR } from "./src/IQR/main.js";
+import { MAD } from "./src/MAD/main.js";
+export { add, div, IQR, isEqual, isLeftGreater, MAD, max, mean, min, mul, pipe, quartile, round, sort, sub, };

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": "1.0.9",
+  "version": "1.0.10",
   "keywords": [
     "precision",
     "arithmetic",
@@ -38,7 +38,13 @@
     "max",
     "sort",
     "mean",
-    "significant figures"
+    "significant figures",
+    "MAD",
+    "Median Absolute Deviation",
+    "IQR",
+    "Interquartile Range",
+    "isEqual",
+    "equality"
   ],
   "repository": {
     "type": "git",

package/src/IQR/main.d.ts

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

package/src/IQR/main.js

@@ -0,0 +1,7 @@
+import { a2s, s2a } from "../shared/utils.js";
+import { IQRInner } from "./utils.js";
+//** This function returns Interquartile Range */
+export var IQR = function (strs, sigNum) {
+    var array = strs.map(function (str) { return s2a(str); });
+    return a2s(IQRInner(array, sigNum));
+};

package/src/IQR/types.d.ts

@@ -0,0 +1,3 @@
+import type { InputData } from "../types.d.ts";
+export type TIQR = (array: string[], sigNum?: boolean) => string;
+export type TIQRInner = (array: InputData[], sigNum?: boolean) => InputData;

package/src/IQR/utils.d.ts

@@ -0,0 +1,3 @@
+import type { TIQRInner } from "./types.d.ts";
+export declare const MIN_LENGTH_FOR_MAD = 30;
+export declare const IQRInner: TIQRInner;

package/src/IQR/utils.js

@@ -0,0 +1,18 @@
+import { isEqualInner } from "../compare/utils.js";
+import { MADInner } from "../MAD/utils.js";
+import { subRoute } from "../mathOperations/sub/utils.js";
+import { quartileInner } from "../quartile/utils.js";
+import { DEFAULT, NIL, ONE } from "../shared/constant.js";
+export var MIN_LENGTH_FOR_MAD = 30;
+export var IQRInner = function (array, sigNum) {
+    if (sigNum === void 0) { sigNum = false; }
+    var _a = quartileInner(array), Q1 = _a.Q1, Q3 = _a.Q3;
+    var sub = subRoute([structuredClone(Q3), structuredClone(Q1)], DEFAULT);
+    if (sigNum) {
+        var isEqual = isEqualInner({ left: Q3, right: Q1 });
+        var MAD = MADInner(array);
+        var nonNilMAD = isEqualInner({ left: MAD, right: NIL }) ? ONE : MAD;
+        return isEqual ? nonNilMAD : sub;
+    }
+    return sub;
+};

package/src/MAD/main.d.ts

@@ -1,2 +1,2 @@
-import type { TMADQ2 } from "./types.d.ts";
-export declare const MADQ2: TMADQ2;
+import type { TMAD } from "./types.d.ts";
+export declare const MAD: TMAD;

package/src/MAD/main.js

@@ -1,18 +1,7 @@
-import { subRoute } from "../mathOperations/sub/utils.js";
-import { mean } from "../mean/main.js";
-import { quartileInner } from "../quartile/utils.js";
-import { DEFAULT } from "../shared/constant.js";
 import { a2s, s2a } from "../shared/utils.js";
-import { ASC } from "../sort/constants.js";
-import { sortInner } from "../sort/utils.js";
-export var MADQ2 = function (array) {
-    var meanOfAnArray = mean(array);
-    var madArray = array
-        .map(function (element) {
-        var res = subRoute([s2a(element), s2a(meanOfAnArray)], DEFAULT);
-        res.isNegative = false;
-        return res;
-    });
-    var sorted = sortInner(madArray, ASC);
-    return a2s(quartileInner(sorted).Q2);
+import { MADInner } from "./utils.js";
+//** This function returns Median Absolute Deviation */
+export var MAD = function (strs) {
+    var array = strs.map(function (str) { return s2a(str); });
+    return a2s(MADInner(array));
 };

package/src/MAD/types.d.ts

@@ -1 +1,3 @@
-export type TMADQ2 = (array: string[]) => string;
+import type { InputData } from "../types.d.ts";
+export type TMAD = (array: string[]) => string;
+export type TMADInner = (array: InputData[]) => InputData;

package/src/MAD/utils.d.ts

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

package/src/MAD/utils.js

@@ -0,0 +1,15 @@
+import { subRoute } from "../mathOperations/sub/utils.js";
+import { quartileInner } from "../quartile/utils.js";
+import { DEFAULT } from "../shared/constant.js";
+import { ASC } from "../sort/constants.js";
+import { sortInner } from "../sort/utils.js";
+export var MADInner = function (array) {
+    var median = quartileInner(array).Q2;
+    var madArray = array.map(function (el) {
+        var res = subRoute([structuredClone(el), structuredClone(median)], DEFAULT);
+        res.isNegative = false;
+        return res;
+    });
+    var sorted = sortInner(madArray, ASC);
+    return quartileInner(sorted).Q2;
+};

package/src/compare/main.d.ts

@@ -1,6 +1,9 @@
-import type { Max, Min } from "./types.d.ts";
-/** This function returns max number. */
+import type { IsEqual, IsLeftGreater, Max, Min } from "./types.d.ts";
+/** This function returns max value. */
 export declare const max: Max;
-/** This function returns min number. */
+/** This function returns min value. */
 export declare const min: Min;
-export declare const isGreater: (l: string, r: string) => boolean;
+/** This function returns if left value is greater than right value */
+export declare const isLeftGreater: IsLeftGreater;
+/** This function returns if left and right values are equal */
+export declare const isEqual: IsEqual;

package/src/compare/main.js

@@ -1,15 +1,22 @@
 import { a2s, s2a } from "../shared/utils.js";
-import { compareInner, maxInner, minInner } from "./utils.js";
-/** This function returns max number. */
+import { isEqualInner, isLeftGreaterInner, maxInner, minInner } from "./utils.js";
+/** This function returns max value. */
 export var max = function (strs) {
     var array = strs.map(function (str) { return s2a(str); });
     return a2s(maxInner(array));
 };
-/** This function returns min number. */
+/** This function returns min value. */
 export var min = function (strs) {
     var array = strs.map(function (str) { return s2a(str); });
     return a2s(minInner(array));
 };
-export var isGreater = function (l, r) {
-    return compareInner(s2a(l), s2a(r))[1];
+/** This function returns if left value is greater than right value */
+export var isLeftGreater = function (_a) {
+    var left = _a.left, right = _a.right;
+    return isLeftGreaterInner({ left: s2a(left), right: s2a(right) });
+};
+/** This function returns if left and right values are equal */
+export var isEqual = function (_a) {
+    var left = _a.left, right = _a.right;
+    return isEqualInner({ left: s2a(left), right: s2a(right) });
 };

package/src/compare/types.d.ts

@@ -1,6 +1,16 @@
 import type { InputData } from "../types.d.ts";
-export type CompareInner = (left: InputData, right: InputData) => [InputData, boolean];
 export type Min = (strs: string[]) => string;
-export type Max = (strs: string[]) => string;
+export type Max = Min;
+export type IsLeftGreater = (attr: {
+    left: string;
+    right: string;
+}) => boolean;
+export type IsEqual = IsLeftGreater;
+export type CompareInner = (left: InputData, right: InputData) => [InputData, number];
 export type MinInner = (array: InputData[]) => InputData;
-export type MaxInner = (array: InputData[]) => InputData;
+export type MaxInner = MinInner;
+export type IsEqualInner = (attr: {
+    left: InputData;
+    right: InputData;
+}) => boolean;
+export type IsLeftGreaterInner = IsEqualInner;

package/src/compare/utils.d.ts

@@ -1,4 +1,6 @@
-import type { CompareInner, MaxInner, MinInner } from "./types.d.ts";
+import type { CompareInner, IsEqualInner, IsLeftGreaterInner, MaxInner, MinInner } from "./types.d.ts";
 export declare const maxInner: MaxInner;
 export declare const minInner: MinInner;
 export declare const compareInner: CompareInner;
+export declare const isEqualInner: IsEqualInner;
+export declare const isLeftGreaterInner: IsLeftGreaterInner;

package/src/compare/utils.js

@@ -1,14 +1,16 @@
 export var maxInner = function (array) {
     var max = array[0];
     for (var i = 1; i < array.length; i++) {
-        compareInner(max, array[i])[1] || (max = array[i]);
+        if (compareInner(array[i], max)[1] === 1)
+            max = array[i];
     }
     return max;
 };
 export var minInner = function (array) {
     var min = array[0];
     for (var i = 1; i < array.length; i++) {
-        compareInner(min, array[i])[1] && (min = array[i]);
+        if (compareInner(array[i], min)[1] === -1)
+            min = array[i];
     }
     return min;
 };
@@ -24,51 +26,69 @@ export var compareInner = function (l, r) {
     var bothPos = !lIsNeg && !rIsNeg;
     var bothIntPos = lIntLen > 0 && rIntLen > 0;
     var bothIntNeg = lIntLen <= 0 && rIntLen <= 0;
+    var isNilL = l.array.length === 1 && l.array[0] === 48;
+    var isNilR = r.array.length === 1 && r.array[0] === 48;
     if (lIsNeg && !rIsNeg)
-        return [r, false];
+        return [r, -1];
     if (!lIsNeg && rIsNeg)
-        return [l, true];
+        return [l, 1];
+    if (bothPos && isNilL && !isNilR)
+        return [r, -1];
+    if (bothPos && !isNilL && isNilR)
+        return [l, 1];
+    if (bothNeg && isNilL && !isNilR)
+        return [l, 1];
+    if (bothNeg && !isNilL && isNilR)
+        return [r, -1];
     if (bothPos && lIntLen > 0 && rIntLen === 0)
-        return [l, true];
+        return [l, 1];
     if (bothPos && lIntLen === 0 && rIntLen > 0)
-        return [r, false];
+        return [r, -1];
     if (!bothPos && lIntLen > 0 && rIntLen === 0)
-        return [r, false];
+        return [r, -1];
     if (!bothPos && lIntLen === 0 && rIntLen > 0)
-        return [l, true];
+        return [l, 1];
     if (bothPos && bothIntPos && lIntLen < rIntLen)
-        return [r, false];
+        return [r, -1];
     if (bothPos && bothIntNeg && lIntLen < rIntLen)
-        return [r, false];
+        return [r, -1];
     if (bothNeg && bothIntPos && lIntLen < rIntLen)
-        return [l, true];
+        return [l, 1];
     if (bothNeg && bothIntNeg && lIntLen < rIntLen)
-        return [l, true];
+        return [l, 1];
     if (bothNeg && bothIntNeg && lIntLen > rIntLen)
-        return [r, false];
+        return [r, -1];
     if (bothNeg && bothIntPos && lIntLen > rIntLen)
-        return [r, false];
+        return [r, -1];
     if (bothPos && bothIntPos && lIntLen > rIntLen)
-        return [l, true];
+        return [l, 1];
     if (bothPos && bothIntNeg && lIntLen > rIntLen)
-        return [l, true];
+        return [l, 1];
     if (bothNeg)
         _a = [r, l], left = _a[0], right = _a[1];
     while (idx < (lenL > lenR ? lenL : lenR)) {
         var numL = left.array[idx];
         var numR = right.array[idx];
         if (!numL && bothPos)
-            return [r, false];
+            return [r, -1];
         if (!numR && bothPos)
-            return [l, true];
+            return [l, 1];
         if (!numL && bothNeg)
-            return [l, true];
+            return [l, 1];
         if (!numR && bothNeg)
-            return [r, false];
+            return [r, -1];
         if (numL !== numR) {
-            return numL > numR ? [l, true] : [r, false];
+            return numL > numR ? [l, 1] : [r, -1];
         }
         idx += 1;
     }
-    return [l, true];
+    return [l, 0];
+};
+export var isEqualInner = function (_a) {
+    var left = _a.left, right = _a.right;
+    return compareInner(left, right)[1] === 0;
+};
+export var isLeftGreaterInner = function (_a) {
+    var left = _a.left, right = _a.right;
+    return compareInner(left, right)[1] > 0;
 };

package/src/mathOperations/div/utils.js

@@ -1,3 +1,4 @@
+import { NIL } from "../../shared/constant.js";
 export var divInner = function (_a, _b, isNegative, initLimit) {
     var arrL = _a[0], intL = _a[1];
     var arrR = _b[0], intR = _b[1];
@@ -81,12 +82,7 @@ export var divInner = function (_a, _b, isNegative, initLimit) {
         }
     }
     return result.length === count
-        ? {
-            array: [48],
-            isFloat: false,
-            isNegative: false,
-            intLength: 1,
-        }
+        ? NIL
         : {
             array: result[0] === 48 ? multipliedResult : result,
             isFloat: isFloat,

package/src/mathOperations/mul/utils.js

@@ -1,3 +1,4 @@
+import { NIL } from "../../shared/constant.js";
 /** This function multiplies 2 numbers (as array). */
 export var mulInner = function (_a, _b, isNegative) {
     var _c, _d;
@@ -6,7 +7,7 @@ export var mulInner = function (_a, _b, isNegative) {
     if (arrL.length === 0 || arrR.length === 0 ||
         (arrL.length === 1 && arrL[0] === 48) ||
         (arrR.length === 1 && arrR[0] === 48)) {
-        return { array: [48], intLength: 1, isFloat: false, isNegative: false };
+        return NIL;
     }
     var dec = (arrL.length - intL) + (arrR.length - intR);
     var _e = arrL.length >= arrR.length

package/src/mean/main.js

@@ -1,5 +1,8 @@
-import { pipe } from "../pipe/main.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { meanInner } from "./utils.js";
 /** This function returns mean of an array. */
-export var mean = function (array) {
-    return pipe.add(array).div([array.length.toString()]).calc();
+export var mean = function (strs) {
+    var array = strs.map(function (str) { return s2a(str); });
+    var res = meanInner(array);
+    return a2s(res);
 };

package/src/mean/types.d.ts

@@ -1 +1,3 @@
+import type { InputData } from "../types.d.ts";
 export type Mean = (array: string[]) => string;
+export type MeanInner = (array: InputData[]) => InputData;

package/src/mean/utils.d.ts

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

package/src/mean/utils.js

@@ -0,0 +1,10 @@
+import { addRoute } from "../mathOperations/add/utils.js";
+import { divInner } from "../mathOperations/div/utils.js";
+import { DEFAULT } from "../shared/constant.js";
+import { s2a } from "../shared/utils.js";
+export var meanInner = function (array) {
+    var left = addRoute(array, DEFAULT);
+    var right = s2a(array.length.toString());
+    var res = divInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, 20);
+    return res;
+};

package/src/quartile/types.d.ts

@@ -4,7 +4,7 @@ export type Quartile = (array: string[]) => {
     Q2: string;
     Q3: string;
 };
-export type Mean = (index: number, array: InputData[]) => InputData;
+export type MeanQ = (index: number, array: InputData[]) => InputData;
 export type QuartileInner = (array: InputData[]) => {
     Q1: InputData;
     Q2: InputData;

package/src/quartile/utils.js

@@ -1,8 +1,8 @@
 import { addRoute } from "../mathOperations/add/utils.js";
 import { divRoute } from "../mathOperations/div/utils.js";
 import { DEFAULT } from "../shared/constant.js";
-var mean = function (idx, array) {
-    var sum = addRoute([structuredClone(array[idx]), array[idx - 1]], DEFAULT);
+var meanQ = function (idx, array) {
+    var sum = addRoute([structuredClone(array[idx]), structuredClone(array[idx - 1])], DEFAULT);
     return divRoute([sum, {
             array: [50],
             intLength: 1,
@@ -20,8 +20,8 @@ export var quartileInner = function (array) {
     var Q3Idx = length - Q1Idx;
     var isEvenHalf = Q2Idx % 2 !== 0;
     return {
-        Q1: isEvenHalf ? array[Q1Idx] : mean(Q1Idx, array),
-        Q2: length % 2 !== 0 ? array[Q2Idx] : mean(Q2Idx, array),
-        Q3: isEvenHalf ? array[Q3Idx - 1] : mean(Q3Idx, array),
+        Q1: isEvenHalf ? array[Q1Idx] : meanQ(Q1Idx, array),
+        Q2: length % 2 !== 0 ? array[Q2Idx] : meanQ(Q2Idx, array),
+        Q3: isEvenHalf ? array[Q3Idx - 1] : meanQ(Q3Idx, array),
     };
 };

package/src/shared/constant.d.ts

@@ -4,3 +4,15 @@ export declare const DEFAULT: {
     isFloat: boolean;
     isNegative: boolean;
 };
+export declare const NIL: {
+    array: number[];
+    isFloat: boolean;
+    isNegative: boolean;
+    intLength: number;
+};
+export declare const ONE: {
+    array: number[];
+    isFloat: boolean;
+    isNegative: boolean;
+    intLength: number;
+};

package/src/shared/constant.js

@@ -4,3 +4,15 @@ export var DEFAULT = {
     isFloat: false,
     isNegative: false,
 };
+export var NIL = {
+    array: [48],
+    isFloat: false,
+    isNegative: false,
+    intLength: 1,
+};
+export var ONE = {
+    array: [49],
+    isFloat: false,
+    isNegative: false,
+    intLength: 1,
+};

package/src/shared/utils.js

@@ -46,7 +46,7 @@ export var s2a = function (string) {
     if (isNil || isNegNil) {
         return {
             array: [48],
-            intLength: 0,
+            intLength: 1,
             isNegative: isNegNil,
             isFloat: false,
         };

package/src/sort/utils.js

@@ -6,15 +6,15 @@ var heapify = function (array, len, i, sorting) {
     var idxR = idxL + 1;
     var idx = i;
     if (sorting === ASC) {
-        if (idxL < len && compareInner(array[idxL], array[idx])[1])
+        if (idxL < len && compareInner(array[idxL], array[idx])[1] >= 0)
             idx = idxL;
-        if (idxR < len && compareInner(array[idxR], array[idx])[1])
+        if (idxR < len && compareInner(array[idxR], array[idx])[1] >= 0)
             idx = idxR;
     }
     else {
-        if (idxL < len && compareInner(array[idx], array[idxL])[1])
+        if (idxL < len && compareInner(array[idx], array[idxL])[1] >= 0)
             idx = idxL;
-        if (idxR < len && compareInner(array[idx], array[idxR])[1])
+        if (idxR < len && compareInner(array[idx], array[idxR])[1] >= 0)
             idx = idxR;
     }
     if (idx !== i) {