@eternl/big 0.10.16 → 0.10.17

package/dist/index.cjs

@@ -3,6 +3,10 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 //#region src/index.ts
 /************************************** EDITABLE DEFAULTS *****************************************/
 var DP = 20, RM = 1, MAX_DP = 1e6, MAX_POWER = 1e6, NE = -7, PE = 21, STRICT = false, NAME = "[big.js] ", INVALID = NAME + "Invalid ", INVALID_DP = INVALID + "decimal places", INVALID_RM = INVALID + "rounding mode", DIV_BY_ZERO = NAME + "Division by zero", P = {}, UNDEFINED = void 0, NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+const SOURCE_BUFFER = [];
+let SOURCE_C = SOURCE_BUFFER;
+let SOURCE_E = 0;
+let SOURCE_S = 1;
 function _Big_() {
 	function Big(n) {
 		const Ctor = Big;
@@ -39,6 +43,12 @@ function _Big_() {
 function negateSign(s) {
 	return s === 1 ? -1 : 1;
 }
+function mutateFrom(x, y) {
+	x.c = y.c;
+	x.e = y.e;
+	x.s = y.s;
+	return x;
+}
 function parse(x, n) {
 	var e, i, nl;
 	if (!NUMERIC.test(n)) throw Error(INVALID + "number");
@@ -60,6 +70,50 @@ function parse(x, n) {
 	}
 	return x;
 }
+function isInternalBigSource(value) {
+	return typeof value === "object";
+}
+function parseSourceString(n) {
+	let e;
+	let i;
+	let nl;
+	if (!NUMERIC.test(n)) throw Error(INVALID + "number");
+	SOURCE_S = n.charAt(0) == "-" ? (n = n.slice(1), -1) : 1;
+	if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");
+	if ((i = n.search(/e/i)) > 0) {
+		if (e < 0) e = i;
+		e += +n.slice(i + 1);
+		n = n.substring(0, i);
+	} else if (e < 0) e = n.length;
+	nl = n.length;
+	for (i = 0; i < nl && n.charAt(i) == "0";) ++i;
+	if (i == nl) {
+		SOURCE_E = 0;
+		SOURCE_C = SOURCE_BUFFER;
+		SOURCE_C.length = 1;
+		SOURCE_C[0] = 0;
+		return;
+	}
+	for (; nl > 0 && n.charAt(--nl) == "0";);
+	SOURCE_E = e - i - 1;
+	SOURCE_C = SOURCE_BUFFER;
+	SOURCE_C.length = 0;
+	for (e = 0; i <= nl;) SOURCE_C[e++] = +n.charAt(i++);
+}
+function loadSourceParts(Big, value) {
+	if (isInternalBigSource(value)) {
+		SOURCE_C = value.c;
+		SOURCE_E = value.e;
+		SOURCE_S = value.s;
+		return;
+	}
+	let n = value;
+	if (typeof n !== "string") {
+		if (Big.strict === true && typeof n !== "bigint") throw TypeError(INVALID + "value");
+		n = n === 0 && 1 / n < 0 ? "-0" : String(n);
+	}
+	parseSourceString(n);
+}
 function round(x, sd, rm, more) {
 	var xc = x.c;
 	var d0 = xc[0] ?? 0;
@@ -105,6 +159,22 @@ P.abs = function() {
 	x.s = 1;
 	return x;
 };
+P._abs = function() {
+	if (this.s < 0) this.s = 1;
+	return this;
+};
+P._set = function(y) {
+	const x = this;
+	const Big = x.constructor;
+	loadSourceParts(Big, y);
+	const yc = SOURCE_C;
+	const yl = yc.length;
+	x.c.length = yl;
+	for (let i = 0; i < yl; i++) x.c[i] = yc[i] ?? 0;
+	x.e = SOURCE_E;
+	x.s = SOURCE_S;
+	return x;
+};
 P.cmp = function(y) {
 	var i, j, isneg, x = this, xc = x.c, yBig = new x.constructor(y), yc = yBig.c, xs = x.s, ys = yBig.s, k = x.e, l = yBig.e;
 	if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : negateSign(ys) : xs;
@@ -160,6 +230,51 @@ P.div = function(y) {
 	if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);
 	return q;
 };
+P._div = function(y) {
+	var x = this, Big = x.constructor, a = x.c.slice(), yBig = new Big(y), b = yBig.c, sign = x.s == yBig.s ? 1 : -1, dp = Big.DP;
+	if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
+	if (!b[0]) throw Error(DIV_BY_ZERO);
+	if (!a[0]) {
+		x.s = sign;
+		x.c = [x.e = 0];
+		return x;
+	}
+	var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), rl = r.length, q = x, qc = q.c = [], qi = 0, p = dp + (q.e = x.e - yBig.e) + 1, k = p < 0 ? 0 : p;
+	q.s = sign;
+	bz.unshift(0);
+	for (; rl++ < bl;) r.push(0);
+	do {
+		for (n = 0; n < 10; n++) {
+			if (bl != (rl = r.length)) cmp = bl > rl ? 1 : -1;
+			else for (ri = -1, cmp = 0; ++ri < bl;) if (b[ri] != r[ri]) {
+				cmp = b[ri] > r[ri] ? 1 : -1;
+				break;
+			}
+			if (cmp < 0) {
+				for (bt = rl == bl ? b : bz; rl;) {
+					if (r[--rl] < bt[rl]) {
+						ri = rl;
+						for (; ri && !r[--ri];) r[ri] = 9;
+						--r[ri];
+						r[rl] = (r[rl] ?? 0) + 10;
+					}
+					r[rl] = (r[rl] ?? 0) - bt[rl];
+				}
+				for (; !r[0];) r.shift();
+			} else break;
+		}
+		qc[qi++] = cmp ? n : ++n;
+		if (r[0] && cmp) r[rl] = a[ai] || 0;
+		else r = [a[ai]];
+	} while ((ai++ < al || r[0] !== UNDEFINED) && k--);
+	if (!qc[0] && qi != 1) {
+		qc.shift();
+		q.e--;
+		p--;
+	}
+	if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);
+	return q;
+};
 P.eq = function(y) {
 	return this.cmp(y) === 0;
 };
@@ -234,6 +349,67 @@ P.minus = P.sub = function(y) {
 	yBig.e = ye;
 	return yBig;
 };
+P._minus = P._sub = function(y) {
+	var i, j, t, xlty, x = this, Big = x.constructor, yBig = new Big(y), xSign = x.s, ySign = yBig.s, xc = x.c.slice(), xe = x.e, yc = yBig.c, ye = yBig.e, eDiff = xe - ye;
+	if (xSign != ySign) {
+		yBig.s = negateSign(ySign);
+		return x._plus(yBig);
+	}
+	if (!xc[0] || !yc[0]) {
+		if (!yc[0]) return x;
+		x.c = yc.slice();
+		x.e = ye;
+		x.s = negateSign(ySign);
+		if (!x.c[0]) x.s = 1;
+		return x;
+	}
+	if (eDiff) {
+		if (xlty = eDiff < 0) {
+			eDiff = -eDiff;
+			t = xc;
+		} else {
+			ye = xe;
+			t = yc;
+		}
+		t.reverse();
+		for (j = eDiff; j--;) t.push(0);
+		t.reverse();
+	} else {
+		j = ((xlty = xc.length < yc.length) ? xc : yc).length;
+		for (i = 0; i < j; i++) if (xc[i] != yc[i]) {
+			xlty = xc[i] < yc[i];
+			break;
+		}
+	}
+	if (xlty) {
+		t = xc;
+		xc = yc;
+		yc = t;
+		xSign = negateSign(xSign);
+	}
+	if ((j = yc.length - (i = xc.length)) > 0) for (; j--;) xc[i++] = 0;
+	for (j = i; j > eDiff;) {
+		if (xc[--j] < (yc[j] ?? 0)) {
+			for (i = j; i && !xc[--i];) xc[i] = 9;
+			--xc[i];
+			xc[j] = (xc[j] ?? 0) + 10;
+		}
+		xc[j] = (xc[j] ?? 0) - (yc[j] ?? 0);
+	}
+	for (j = xc.length; xc[--j] === 0;) xc.pop();
+	for (; xc[0] === 0;) {
+		xc.shift();
+		--ye;
+	}
+	if (!xc[0]) {
+		xSign = 1;
+		xc = [ye = 0];
+	}
+	x.c = xc;
+	x.e = ye;
+	x.s = xSign;
+	return x;
+};
 P.mod = function(y) {
 	var ygtx, x = this, Big = x.constructor, yBig = new Big(y), xSign = x.s, ySign = yBig.s, dp, rm;
 	if (!yBig.c[0]) throw Error(DIV_BY_ZERO);
@@ -251,11 +427,32 @@ P.mod = function(y) {
 	Big.RM = rm;
 	return this.minus(x.times(yBig));
 };
+P._mod = function(y) {
+	var ygtx, x = this, Big = x.constructor, yBig = new Big(y), xSign = x.s, ySign = yBig.s, dp, rm, quotient;
+	if (!yBig.c[0]) throw Error(DIV_BY_ZERO);
+	x.s = yBig.s = 1;
+	ygtx = yBig.cmp(x) == 1;
+	x.s = xSign;
+	yBig.s = ySign;
+	if (ygtx) return x;
+	dp = Big.DP;
+	rm = Big.RM;
+	Big.DP = 0;
+	Big.RM = 0;
+	quotient = new Big(x).div(yBig);
+	Big.DP = dp;
+	Big.RM = rm;
+	return x._minus(quotient.times(yBig));
+};
 P.neg = function() {
 	var x = new this.constructor(this);
 	x.s = negateSign(x.s);
 	return x;
 };
+P._neg = function() {
+	this.s = negateSign(this.s);
+	return this;
+};
 P.plus = P.add = function(y) {
 	var e, k, t, x = this, Big = x.constructor, yBig = new Big(y);
 	if (x.s != yBig.s) {
@@ -300,6 +497,114 @@ P.plus = P.add = function(y) {
 	yBig.e = ye;
 	return yBig;
 };
+P._plus = P._add = function(y) {
+	const x = this;
+	const Big = x.constructor;
+	loadSourceParts(Big, y);
+	const yc = SOURCE_C;
+	const ye = SOURCE_E;
+	const ys = SOURCE_S;
+	const xc = x.c;
+	const xe = x.e;
+	const xs = x.s;
+	const xLen = xc.length;
+	const yLen = yc.length;
+	if (!xc[0] || !yc[0]) {
+		if (!yc[0]) return x;
+		xc.length = yLen;
+		for (let i = 0; i < yLen; i++) xc[i] = yc[i] ?? 0;
+		x.e = ye;
+		x.s = ys;
+		return x;
+	}
+	const topExponent = xe > ye ? xe : ye;
+	const shiftX = topExponent - xe;
+	const shiftY = topExponent - ye;
+	if (xs == ys) {
+		const lenX = xLen + shiftX;
+		const lenY = yLen + shiftY;
+		let len = lenX > lenY ? lenX : lenY;
+		let carry = 0;
+		xc.length = len;
+		for (let i = len - 1; i >= 0; i--) {
+			const ix = i - shiftX;
+			const iy = i - shiftY;
+			const sum = (ix >= 0 && ix < xLen ? xc[ix] ?? 0 : 0) + (iy >= 0 && iy < yLen ? yc[iy] ?? 0 : 0) + carry;
+			xc[i] = sum % 10;
+			carry = sum / 10 | 0;
+		}
+		if (carry) {
+			xc.length = len + 1;
+			for (let i = len; i > 0; i--) xc[i] = xc[i - 1] ?? 0;
+			xc[0] = carry;
+			len += 1;
+			x.e = topExponent + 1;
+		} else x.e = topExponent;
+		while (len > 1 && xc[len - 1] === 0) --len;
+		xc.length = len;
+		x.s = xs;
+		return x;
+	}
+	let cmp = 0;
+	if (xe != ye) cmp = xe > ye ? 1 : -1;
+	else if (xLen != yLen) cmp = xLen > yLen ? 1 : -1;
+	else for (let i = 0; i < xLen; i++) {
+		const xd = xc[i] ?? 0;
+		const yd = yc[i] ?? 0;
+		if (xd != yd) {
+			cmp = xd > yd ? 1 : -1;
+			break;
+		}
+	}
+	if (cmp === 0) {
+		xc.length = 1;
+		xc[0] = 0;
+		x.e = 0;
+		x.s = 1;
+		return x;
+	}
+	const ac = cmp > 0 ? xc : yc;
+	const ae = cmp > 0 ? xe : ye;
+	const al = cmp > 0 ? xLen : yLen;
+	const bc = cmp > 0 ? yc : xc;
+	const be = cmp > 0 ? ye : xe;
+	const bl = cmp > 0 ? yLen : xLen;
+	const resultSign = cmp > 0 ? xs : ys;
+	const alignedExponent = ae > be ? ae : be;
+	const shiftA = alignedExponent - ae;
+	const shiftB = alignedExponent - be;
+	const lenA = al + shiftA;
+	const lenB = bl + shiftB;
+	let len = lenA > lenB ? lenA : lenB;
+	let borrow = 0;
+	xc.length = len;
+	for (let i = len - 1; i >= 0; i--) {
+		const ia = i - shiftA;
+		const ib = i - shiftB;
+		let da = ia >= 0 && ia < al ? ac[ia] ?? 0 : 0;
+		const db = (ib >= 0 && ib < bl ? bc[ib] ?? 0 : 0) + borrow;
+		if (da < db) {
+			da += 10;
+			borrow = 1;
+		} else borrow = 0;
+		xc[i] = da - db;
+	}
+	let head = 0;
+	while (head < len - 1 && xc[head] === 0) ++head;
+	if (head) {
+		for (let i = 0; i < len - head; i++) xc[i] = xc[i + head] ?? 0;
+		len -= head;
+	}
+	while (len > 1 && xc[len - 1] === 0) --len;
+	xc.length = len;
+	x.e = alignedExponent - head;
+	x.s = resultSign;
+	if (!xc[0]) {
+		x.e = 0;
+		x.s = 1;
+	}
+	return x;
+};
 P.pow = function(n) {
 	var x = this, one = new x.constructor("1"), y = one, isneg = n < 0;
 	if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID + "exponent");
@@ -312,15 +617,36 @@ P.pow = function(n) {
 	}
 	return isneg ? one.div(y) : y;
 };
+P._pow = function(n) {
+	var x = this, one = new x.constructor("1"), y = one, base = new x.constructor(x), isneg = n < 0;
+	if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID + "exponent");
+	if (isneg) n = -n;
+	for (;;) {
+		if (n & 1) y._times(base);
+		n >>= 1;
+		if (!n) break;
+		base._times(base);
+	}
+	return isneg ? mutateFrom(x, one._div(y)) : mutateFrom(x, y);
+};
 P.prec = function(sd, rm) {
 	if (sd !== ~~sd || sd < 1 || sd > MAX_DP) throw Error(INVALID + "precision");
 	return round(new this.constructor(this), sd, rm);
 };
+P._prec = function(sd, rm) {
+	if (sd !== ~~sd || sd < 1 || sd > MAX_DP) throw Error(INVALID + "precision");
+	return round(this, sd, rm);
+};
 P.round = function(dp, rm) {
 	if (dp === UNDEFINED) dp = 0;
 	else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
 	return round(new this.constructor(this), dp + this.e + 1, rm);
 };
+P._round = function(dp, rm) {
+	if (dp === UNDEFINED) dp = 0;
+	else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
+	return round(this, dp + this.e + 1, rm);
+};
 P.sqrt = function() {
 	var r, c, t, x = this, Big = x.constructor, sign = x.s, e = x.e, half = new Big("0.5"), s;
 	if (!x.c[0]) return new Big(x);
@@ -344,6 +670,29 @@ P.sqrt = function() {
 	} while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));
 	return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);
 };
+P._sqrt = function() {
+	var r, c, t, x = this, Big = x.constructor, sign = x.s, e = x.e, half = new Big("0.5"), s;
+	if (!x.c[0]) return x;
+	if (sign < 0) throw Error(NAME + "No square root");
+	s = Math.sqrt(+stringify(x, true, true));
+	if (s === 0 || s === Infinity) {
+		c = x.c.join("");
+		if (!(c.length + e & 1)) c += "0";
+		s = Math.sqrt(+c);
+		e = ((e + 1) / 2 | 0) - (e < 0 || (e & 1) !== 0 ? 1 : 0);
+		if (s == Infinity) r = new Big("5e" + e);
+		else {
+			c = s.toExponential();
+			r = new Big(c.slice(0, c.indexOf("e") + 1) + e);
+		}
+	} else r = new Big(s + "");
+	e = r.e + (Big.DP += 4);
+	do {
+		t = r;
+		r = half.times(t.plus(x.div(t)));
+	} while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));
+	return mutateFrom(x, round(r, (Big.DP -= 4) + r.e + 1, Big.RM));
+};
 P.times = P.mul = function(y) {
 	var c, x = this, Big = x.constructor, xc = x.c, yBig = new Big(y), yc = yBig.c, a = xc.length, b = yc.length, i = x.e, j = yBig.e;
 	yBig.s = x.s == yBig.s ? 1 : -1;
@@ -376,6 +725,39 @@ P.times = P.mul = function(y) {
 	yBig.c = c;
 	return yBig;
 };
+P._times = P._mul = function(y) {
+	var c, x = this, Big = x.constructor, xc = x.c, yBig = new Big(y), yc = yBig.c, a = xc.length, b = yc.length, i = x.e, j = yBig.e, sign = x.s == yBig.s ? 1 : -1;
+	if (!xc[0] || !yc[0]) {
+		x.s = sign;
+		x.c = [x.e = 0];
+		return x;
+	}
+	x.e = i + j;
+	if (a < b) {
+		c = xc;
+		xc = yc;
+		yc = c;
+		j = a;
+		a = b;
+		b = j;
+	}
+	for (c = new Array(j = a + b); j--;) c[j] = 0;
+	for (i = b; i--;) {
+		b = 0;
+		for (j = a + i; j > i;) {
+			b = (c[j] ?? 0) + (yc[i] ?? 0) * (xc[j - i - 1] ?? 0) + b;
+			c[j--] = b % 10;
+			b = b / 10 | 0;
+		}
+		c[j] = b;
+	}
+	if (b) ++x.e;
+	else c.shift();
+	for (i = c.length; !c[--i];) c.pop();
+	x.c = c;
+	x.s = sign;
+	return x;
+};
 P.toExponential = function(dp, rm) {
 	var x = this, n = x.c[0];
 	if (dp !== UNDEFINED) {