@numio/bigmath 1.0.10 → 1.1.0

package/README.md

@@ -17,6 +17,8 @@
 * **Control Division Precision:** Specify the exact number of digits after the decimal point for division results, with a default precision of 20 digits for high accuracy.
 * **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.
+* **Calculate Roots:**
+    * **Calculate Square Root (`sqrt`):** Compute the square root of a number with arbitrary precision. You can also specify the desired precision of the result.
 * **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):** Understand the spread and central tendency of your numerical data, helping identify outliers and the shape of the distribution.
@@ -44,8 +46,9 @@ With `@numio/bigmath`, you can confidently perform complex arithmetic operations
 
 ### Latest update
 
-Added `isEqual` and `isLeftGreater` - to compare 2 numbers.
-Added `MAD` - Median Absolute Deviation.
+Added `sqrt` - square root of a number\
+Added `isEqual` and `isLeftGreater` - to compare 2 numbers.\
+Added `MAD` - Median Absolute Deviation.\
 Added `IQR` - Interquartile Range.
 
 # Install:
@@ -288,6 +291,18 @@ 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;
+```
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 

package/index.d.ts

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

package/index.js

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

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.10",
+  "version": "1.1.0",
   "keywords": [
     "precision",
     "arithmetic",
@@ -44,7 +44,9 @@
     "IQR",
     "Interquartile Range",
     "isEqual",
-    "equality"
+    "equality",
+    "sqrt",
+    "square root"
   ],
   "repository": {
     "type": "git",

package/src/IQR/utils.js

@@ -1,13 +1,13 @@
 import { isEqualInner } from "../compare/utils.js";
 import { MADInner } from "../MAD/utils.js";
-import { subRoute } from "../mathOperations/sub/utils.js";
+import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-import { DEFAULT, NIL, ONE } from "../shared/constant.js";
+import { 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);
+    var sub = new PipeInner().subInner([Q3, Q1]).result;
     if (sigNum) {
         var isEqual = isEqualInner({ left: Q3, right: Q1 });
         var MAD = MADInner(array);

package/src/MAD/utils.js

@@ -1,14 +1,14 @@
-import { subRoute } from "../mathOperations/sub/utils.js";
+import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-import { DEFAULT } from "../shared/constant.js";
+import { cloneInner } from "../shared/utils.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 result = new PipeInner().subInner([el, cloneInner(median)]).result;
+        result.isNegative = false;
+        return result;
     });
     var sorted = sortInner(madArray, ASC);
     return quartileInner(sorted).Q2;

package/src/compare/utils.js

@@ -28,42 +28,46 @@ export var compareInner = function (l, r) {
     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, -1];
     if (!lIsNeg && rIsNeg)
         return [l, 1];
-    if (bothPos && isNilL && !isNilR)
+    if (lIsNeg && !rIsNeg)
         return [r, -1];
     if (bothPos && !isNilL && isNilR)
         return [l, 1];
+    if (bothPos && isNilL && !isNilR)
+        return [r, -1];
     if (bothNeg && isNilL && !isNilR)
         return [l, 1];
     if (bothNeg && !isNilL && isNilR)
         return [r, -1];
+    if (bothPos && lIntLen > rIntLen)
+        return [l, 1];
+    if (bothPos && lIntLen < rIntLen)
+        return [r, -1];
     if (bothPos && lIntLen > 0 && rIntLen === 0)
         return [l, 1];
     if (bothPos && lIntLen === 0 && rIntLen > 0)
         return [r, -1];
+    if (!bothPos && lIntLen === 0 && rIntLen > 0)
+        return [l, 1];
     if (!bothPos && lIntLen > 0 && rIntLen === 0)
         return [r, -1];
-    if (!bothPos && lIntLen === 0 && rIntLen > 0)
+    if (bothPos && bothIntPos && lIntLen > rIntLen)
         return [l, 1];
     if (bothPos && bothIntPos && lIntLen < rIntLen)
         return [r, -1];
-    if (bothPos && bothIntNeg && lIntLen < rIntLen)
-        return [r, -1];
-    if (bothNeg && bothIntPos && lIntLen < rIntLen)
-        return [l, 1];
     if (bothNeg && bothIntNeg && lIntLen < rIntLen)
         return [l, 1];
     if (bothNeg && bothIntNeg && lIntLen > rIntLen)
         return [r, -1];
+    if (bothNeg && bothIntPos && lIntLen < rIntLen)
+        return [l, 1];
     if (bothNeg && bothIntPos && lIntLen > rIntLen)
         return [r, -1];
-    if (bothPos && bothIntPos && lIntLen > rIntLen)
-        return [l, 1];
     if (bothPos && bothIntNeg && lIntLen > rIntLen)
         return [l, 1];
+    if (bothPos && bothIntNeg && lIntLen < rIntLen)
+        return [r, -1];
     if (bothNeg)
         _a = [r, l], left = _a[0], right = _a[1];
     while (idx < (lenL > lenR ? lenL : lenR)) {

package/src/mean/utils.js

@@ -1,10 +1,9 @@
-import { addRoute } from "../mathOperations/add/utils.js";
-import { divInner } from "../mathOperations/div/utils.js";
+import { addRoute } from "../operations/add/utils.js";
+import { PipeInner } from "../pipe/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;
+    return new PipeInner().divInner([left, right]).result;
 };

package/src/{mathOperations → operations}/sub/utils.js

@@ -55,7 +55,7 @@ export var subInner = function (_a, _b) {
         pl += 1;
         pr += 1;
     }
-    while (left[0] === 48 && left.length > 1 && fracLenL < left.length - 1) {
+    while (left[0] === 48 && left.length > 1) {
         left.shift();
         intLeft -= 1;
     }

package/src/pipe/main.d.ts

@@ -1,8 +1,7 @@
 import type { A2S } from "../shared/types.d.ts";
-import type { InputData } from "../types.d.ts";
 export declare class Pipe {
-    result: InputData;
-    constructor(array: InputData);
+    #private;
+    constructor();
     add(strs: string[]): Pipe;
     sub(strs: string[]): Pipe;
     div(strs: string[], limit?: number): Pipe;

package/src/pipe/main.js

@@ -1,37 +1,51 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Pipe_result;
 import { DEFAULT } from "../shared/constant.js";
 import { a2s, s2a } from "../shared/utils.js";
-import { subRoute } from "../mathOperations/sub/utils.js";
-import { addRoute } from "../mathOperations/add/utils.js";
-import { divRoute } from "../mathOperations/div/utils.js";
-import { mulRoute } from "../mathOperations/mul/utils.js";
+import { subRoute } from "../operations/sub/utils.js";
+import { addRoute } from "../operations/add/utils.js";
+import { divRoute } from "../operations/div/utils.js";
+import { mulRoute } from "../operations/mul/utils.js";
 var Pipe = /** @class */ (function () {
-    function Pipe(array) {
-        this.result = array;
+    function Pipe() {
+        _Pipe_result.set(this, void 0);
+        __classPrivateFieldSet(this, _Pipe_result, DEFAULT, "f");
     }
     Pipe.prototype.add = function (strs) {
-        this.result = addRoute(strs.map(function (str) { return s2a(str); }), this.result);
+        __classPrivateFieldSet(this, _Pipe_result, addRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
     Pipe.prototype.sub = function (strs) {
-        this.result = subRoute(strs.map(function (str) { return s2a(str); }), this.result);
+        __classPrivateFieldSet(this, _Pipe_result, subRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
     Pipe.prototype.div = function (strs, limit) {
         if (limit === void 0) { limit = 20; }
-        this.result = divRoute(strs.map(function (str) { return s2a(str); }), this.result, limit);
+        __classPrivateFieldSet(this, _Pipe_result, divRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f"), limit), "f");
         return this;
     };
     Pipe.prototype.mul = function (strs) {
-        this.result = mulRoute(strs.map(function (str) { return s2a(str); }), this.result);
+        __classPrivateFieldSet(this, _Pipe_result, mulRoute(strs.map(function (str) { return s2a(str); }), __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
     };
     Pipe.prototype.calc = function () {
-        var result = a2s(this.result);
-        this.result = DEFAULT;
+        var result = a2s(__classPrivateFieldGet(this, _Pipe_result, "f"));
+        __classPrivateFieldSet(this, _Pipe_result, DEFAULT, "f");
         return result;
     };
     return Pipe;
 }());
 export { Pipe };
+_Pipe_result = new WeakMap();
 /** Using this function you can chain operations (add, sub, div, mul). */
-export var pipe = new Pipe(DEFAULT);
+export var pipe = new Pipe();

package/src/pipe/utils.d.ts

@@ -0,0 +1,11 @@
+import type { A2S } from "../shared/types.d.ts";
+import type { InputData } from "../types.d.ts";
+export declare class PipeInner {
+    result: InputData;
+    constructor();
+    addInner(array: InputData[]): PipeInner;
+    subInner(array: InputData[]): PipeInner;
+    divInner(array: InputData[]): PipeInner;
+    mulInner(array: InputData[]): PipeInner;
+    calc(): ReturnType<A2S>;
+}

package/src/pipe/utils.js

@@ -0,0 +1,34 @@
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, cloneInner } from "../shared/utils.js";
+import { subRoute } from "../operations/sub/utils.js";
+import { addRoute } from "../operations/add/utils.js";
+import { divRoute } from "../operations/div/utils.js";
+import { mulRoute } from "../operations/mul/utils.js";
+var PipeInner = /** @class */ (function () {
+    function PipeInner() {
+        this.result = DEFAULT;
+    }
+    PipeInner.prototype.addInner = function (array) {
+        this.result = addRoute(array, cloneInner(this.result));
+        return this;
+    };
+    PipeInner.prototype.subInner = function (array) {
+        this.result = subRoute(array, cloneInner(this.result));
+        return this;
+    };
+    PipeInner.prototype.divInner = function (array) {
+        this.result = divRoute(array, cloneInner(this.result), 20);
+        return this;
+    };
+    PipeInner.prototype.mulInner = function (array) {
+        this.result = mulRoute(array, cloneInner(this.result));
+        return this;
+    };
+    PipeInner.prototype.calc = function () {
+        var result = a2s(this.result);
+        this.result = DEFAULT;
+        return result;
+    };
+    return PipeInner;
+}());
+export { PipeInner };

package/src/quartile/utils.js

@@ -1,14 +1,15 @@
-import { addRoute } from "../mathOperations/add/utils.js";
-import { divRoute } from "../mathOperations/div/utils.js";
-import { DEFAULT } from "../shared/constant.js";
+import { PipeInner } from "../pipe/utils.js";
+import { cloneInner } from "../shared/utils.js";
 var meanQ = function (idx, array) {
-    var sum = addRoute([structuredClone(array[idx]), structuredClone(array[idx - 1])], DEFAULT);
-    return divRoute([sum, {
+    return new PipeInner().addInner([
+        cloneInner(array[idx]),
+        cloneInner(array[idx - 1]),
+    ]).divInner([{
             array: [50],
             intLength: 1,
             isFloat: false,
             isNegative: false,
-        }], DEFAULT, 20);
+        }]).result;
 };
 export var quartileInner = function (array) {
     if (array.length < 3) {

package/src/shared/types.d.ts

@@ -2,3 +2,4 @@ import type { InputData } from "../types.d.ts";
 export type A2S = (input: InputData) => string;
 export type S2A = (strings: string) => InputData;
 export type Convert = (isNegative: InputData["isNegative"], array: InputData["array"]) => string;
+export type CloneInner = (inner: InputData) => InputData;

package/src/shared/utils.d.ts

@@ -1,3 +1,4 @@
-import type { A2S, S2A } from "./types.d.ts";
+import type { A2S, CloneInner, S2A } from "./types.d.ts";
 export declare const a2s: A2S;
 export declare const s2a: S2A;
+export declare const cloneInner: CloneInner;

package/src/shared/utils.js

@@ -68,3 +68,16 @@ export var s2a = function (string) {
         isFloat: dec > 0,
     };
 };
+export var cloneInner = function (inner) {
+    var len = inner.array.length;
+    var clone = Array(len);
+    for (var i = 0; i < len; i++) {
+        clone[i] = inner.array[i];
+    }
+    return {
+        intLength: inner.intLength,
+        isFloat: inner.isFloat,
+        isNegative: inner.isNegative,
+        array: clone,
+    };
+};

package/src/sqrt/main.d.ts

@@ -0,0 +1,3 @@
+import type { Sqrt } from "./types.d.ts";
+/** Find square root of a number */
+export declare const sqrt: Sqrt;

package/src/sqrt/main.js

@@ -0,0 +1,10 @@
+import { round } from "../round/main.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { sqrtInner } from "./utils.js";
+/** Find square root of a number */
+export var sqrt = function (str, precision) {
+    var inputInner = s2a(str);
+    var _a = sqrtInner(inputInner, precision ? s2a(precision) : undefined), outputInner = _a[0], decimals = _a[1];
+    var outputStr = a2s(outputInner);
+    return round(outputStr, { decimals: decimals + 1 });
+};

package/src/sqrt/types.d.ts

@@ -0,0 +1,3 @@
+import type { InputData } from "../types.d.ts";
+export type SqrtInner = (input: InputData, prec?: InputData, max?: number) => [InputData, number];
+export type Sqrt = (str: string, precision?: string) => string;

package/src/sqrt/utils.d.ts

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

package/src/sqrt/utils.js

@@ -0,0 +1,34 @@
+import { isLeftGreaterInner } from "../compare/utils.js";
+import { PipeInner } from "../pipe/utils.js";
+import { cloneInner } from "../shared/utils.js";
+var halfInner = {
+    array: [53],
+    intLength: 0,
+    isNegative: false,
+    isFloat: true,
+};
+var precDef = {
+    array: [49],
+    intLength: -12,
+    isNegative: false,
+    isFloat: true,
+};
+export var sqrtInner = function (input, prec, max) {
+    if (prec === void 0) { prec = precDef; }
+    if (max === void 0) { max = 100; }
+    var guess = cloneInner(input);
+    for (var i = 0; i < max; i++) {
+        var nextGuess = new PipeInner()
+            .divInner([cloneInner(input), cloneInner(guess)])
+            .addInner([guess])
+            .mulInner([halfInner]).result;
+        var candidate = new PipeInner()
+            .subInner([cloneInner(nextGuess), cloneInner(guess)]).result;
+        candidate.isNegative = false;
+        if (isLeftGreaterInner({ left: prec, right: candidate })) {
+            return [nextGuess, prec.intLength * -1];
+        }
+        guess = nextGuess;
+    }
+    return [guess, prec.intLength * -1];
+};