picocalc 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,10 +1,4 @@
-//#region src/lib/constants.ts
-const PI = Math.PI.toString();
-const constants = {
-	e: Math.E.toString(),
-	pi: PI
-};
-//#endregion
+import "bigint.bitlength";
 //#region src/lib/errors.ts
 var GenericMathErrror = class extends Error {
 	pos;
@@ -15,11 +9,6 @@ var GenericMathErrror = class extends Error {
 		this.name = name;
 	}
 };
-var LexerError = class extends GenericMathErrror {
-	constructor(message, pos) {
-		super("LexerError", message, pos);
-	}
-};
 var InterpreterError = class extends GenericMathErrror {
 	constructor(message, pos) {
 		super("InterpreterError", message, pos);
@@ -30,6 +19,11 @@ var MaximumPrecisionError = class extends InterpreterError {
 		super(`Exceeded maximum precision of ${maxPrecision} digits (${precision})`);
 	}
 };
+var NotImplementedError = class extends InterpreterError {
+	constructor(message, pos) {
+		super(message, pos);
+	}
+};
 var OverflowError = class extends InterpreterError {
 	constructor() {
 		super("Overflow");
@@ -45,56 +39,152 @@ var EmptyExpressionError = class extends InterpreterError {
 		super("Empty expression");
 	}
 };
-var UnexpectedEndOfExpressionError = class extends InterpreterError {
-	constructor() {
-		super("Unexpected end of expression");
-	}
-};
 var MismatchedParenthesisError = class extends InterpreterError {
 	constructor(pos, message = "Mismatched parenthesis") {
 		super(message, pos);
 	}
 };
-var InsufficientOperandsError = class extends InterpreterError {
-	constructor(pos) {
-		super("Insufficient operands for operation", pos);
-	}
+//#endregion
+//#region src/lib/types.ts
+const OverflowValue = { n: "OVERFLOW" };
+//#endregion
+//#region src/lib/utils/constants.ts
+const PI = Math.PI.toString();
+const E = Math.E.toString();
+const ZERO = {
+	n: 0n,
+	d: 1n
 };
-var ParserError = class extends GenericMathErrror {
-	constructor(message, pos) {
-		super("ParserError", message, pos);
-	}
+const ONE = {
+	n: 1n,
+	d: 1n
 };
-var IncompleteExpressionError = class extends ParserError {
-	constructor(message, pos) {
-		super(`Incomplete expression: ${message}`, pos);
-	}
+const constants = {
+	e: E,
+	pi: PI
 };
+function getConst(id) {
+	const c = constants[id];
+	return {
+		n: BigInt(c.replace(".", "")),
+		d: 10n ** BigInt(c.length - c.indexOf(".") - 1)
+	};
+}
 //#endregion
 //#region src/lib/utils/gcd.ts
 /**
-* Fast Binary GCD (Stein's Algorithm) for BigInt.
+* The Euclidean GCD Algorithm for BigInt.
 */
 function gcd(a, b) {
 	if (a === b) return a;
 	if (a === 1n || b === 1n) return 1n;
 	if (a === 0n) return b;
 	if (b === 0n) return a;
-	a = a < 0n ? -a : a;
-	b = b < 0n ? -b : b;
-	let shift = 0n;
-	while (((a | b) & 1n) === 0n) {
-		a >>= 1n;
-		b >>= 1n;
-		shift++;
+	a = a < 0 ? -a : a;
+	b = b < 0 ? -b : b;
+	while (b > 0) {
+		a %= b;
+		[a, b] = [b, a];
 	}
-	while ((a & 1n) === 0n) a >>= 1n;
-	do {
-		while ((b & 1n) === 0n) b >>= 1n;
-		if (a > b) [a, b] = [b, a];
-		b = b - a;
-	} while (b !== 0n);
-	return a << shift;
+	return a;
+}
+//#endregion
+//#region src/lib/utils/multiply.ts
+function multiply(a, b) {
+	const aN = a.n;
+	const bN = b.n;
+	if (aN === 0n || bN === 0n) return ZERO;
+	if (aN === "OVERFLOW") return a;
+	if (bN === "OVERFLOW") return b;
+	const { d: aD, c: aC, e: aE } = a;
+	const { d: bD, c: bC, e: bE } = b;
+	const g1 = gcd(aN, bD);
+	const g2 = gcd(bN, aD);
+	const n = aN / g1 * (bN / g2);
+	const d = aD / g2 * (bD / g1);
+	if (aC === void 0 && bC === void 0) return {
+		n,
+		d
+	};
+	if (aC === bC) return {
+		n,
+		d,
+		c: aC,
+		e: simplify(add({
+			n: aE?.n ?? 1n,
+			d: aE?.d ?? 1n
+		}, {
+			n: bE?.n ?? 1n,
+			d: bE?.d ?? 1n
+		}))
+	};
+	if (aC !== void 0 && bC !== void 0) return multiply(toSimpleFraction(a), toSimpleFraction(b));
+	return {
+		n,
+		d,
+		c: aC ?? bC,
+		e: aE ?? bE
+	};
+}
+//#endregion
+//#region src/lib/utils/nthroot.ts
+/**
+* Calculates the integer nth root of a BigInt.
+*/
+function iNthRoot(value, n) {
+	if (value < 0 && n % 2n === 0n) throw new NotImplementedError(`Even (${n}th) root of negative numbers is not implemented yet.`);
+	if (value < 0) return -iNthRoot(-value, n);
+	if (value < 2n) return value;
+	if (n === 1n) return value;
+	let x = 1n << BigInt.bitLength(value) / n + 1n;
+	const nMinus1 = n - 1n;
+	while (true) {
+		const nextX = (nMinus1 * x + value / x ** nMinus1) / n;
+		if (nextX >= x) break;
+		x = nextX;
+	}
+	return x;
+}
+/**
+* Calculates the n-th root of a fraction.
+*/
+function nthRoot(v, n, precision) {
+	if (n === 0n) throw new DivisionByZeroError();
+	if (n === 1n) return v;
+	if (v.n < 0) {
+		if (n % 2n === 0n) throw new NotImplementedError(`Even (${n}th) root of negative numbers is not implemented yet.`);
+		const positiveResult = nthRoot({
+			n: -v.n,
+			d: v.d
+		}, n, precision);
+		return {
+			n: -positiveResult.n,
+			d: positiveResult.d
+		};
+	}
+	if (v.n === 0n) return ZERO;
+	if (precision.format === "precise") {
+		const rootN = iNthRoot(v.n, n);
+		const rootD = iNthRoot(v.d, n);
+		if (rootN ** n === v.n && rootD ** n === v.d) {
+			const e = simplify({
+				n: v.e?.n ?? 1n,
+				d: (v.e?.d ?? 1n) * n
+			});
+			return simplify({
+				n: rootN,
+				d: rootD,
+				c: v.c,
+				e
+			});
+		}
+	}
+	const precisionDigits = Math.max(10, (precision.maxDecimals ?? 30) * 3);
+	const scaleFactor = 10n ** (BigInt(precisionDigits) * n);
+	return simplify({
+		n: iNthRoot(v.n * scaleFactor / v.d, n),
+		d: 10n ** BigInt(precisionDigits)
+	});
 }
 //#endregion
 //#region src/lib/utils/simplify.ts
@@ -103,34 +193,277 @@ function gcd(a, b) {
 */
 function simplify(v) {
 	if (v.d === 0n) throw new DivisionByZeroError();
-	if (v.n === 0n) return {
-		n: 0n,
-		d: 1n,
-		c: v.c
-	};
-	if (v.d === 1n) return v;
+	if (v.n === 0n) return ZERO;
+	if (v.d === 1n) {
+		if (v.e?.n === 0n) return {
+			n: v.n,
+			d: v.d
+		};
+		return v;
+	}
 	const common = gcd(v.n, v.d);
-	const sign = v.d < 0n ? -1n : 1n;
+	const sign = v.d < 0 ? -1n : 1n;
+	const n = v.n / common * sign;
+	const d = v.d / common * sign;
+	if (v.e?.n === 0n) return {
+		n,
+		d
+	};
 	return {
-		n: v.n / common * sign,
-		d: v.d / common * sign,
-		c: v.c
+		n,
+		d,
+		c: v.c,
+		e: v.e
+	};
+}
+/**
+* Resolves any constants and exponents to return a simple fraction.
+*/
+function toSimpleFraction(val) {
+	if (!val.c) return val;
+	const c = getConst(val.c);
+	const expN = val.e?.n ?? 1n;
+	const expD = val.e?.d ?? 1n;
+	const absExpN = expN < 0 ? -expN : expN;
+	let poweredConstant = {
+		n: expN < 0 ? c.d ** absExpN : c.n ** absExpN,
+		d: expN < 0 ? c.n ** absExpN : c.d ** absExpN
+	};
+	if (expD !== 1n) poweredConstant = nthRoot(poweredConstant, expD, { format: "precise" });
+	return multiply(poweredConstant, {
+		n: val.n,
+		d: val.d
+	});
+}
+//#endregion
+//#region src/lib/utils/add.ts
+function add(left, right, subtract = false) {
+	const lN = left.n;
+	const rN = right.n;
+	if (lN === "OVERFLOW") return left;
+	if (rN === "OVERFLOW") return right;
+	const { d: lD, c, e } = left;
+	const { d: rD, c: rC, e: rE } = right;
+	if (lN === 0n) return {
+		n: subtract ? -rN : rN,
+		d: rD,
+		c: rC,
+		e: rE
+	};
+	if (rN === 0n) return {
+		n: lN,
+		d: lD,
+		c,
+		e
+	};
+	let n;
+	let d;
+	if (lD === rD) {
+		n = subtract ? lN - rN : lN + rN;
+		d = lD;
+	} else {
+		const common = gcd(lD, rD);
+		const mLeft = rD / common;
+		const mRight = lD / common;
+		n = subtract ? lN * mLeft - rN * mRight : lN * mLeft + rN * mRight;
+		d = lD * mLeft;
+	}
+	if (n === 0n) return ZERO;
+	if (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left), toSimpleFraction(right), subtract);
+	return {
+		n,
+		d,
+		c,
+		e
 	};
 }
 //#endregion
 //#region src/lib/utils/ceil.ts
 /**
-* Returns the smallest integer greater than or equal to a Value.
+* Returns the smallest integer greater than or equal to the value.
 */
 function ceil(v) {
 	const { n, d } = simplify(v);
 	if (d === 1n) return n;
-	const isPositive = n > 0n;
+	const isPositive = n > 0;
 	const result = n / d;
 	const hasRemainder = n % d !== 0n;
 	return isPositive && hasRemainder ? result + 1n : result;
 }
 //#endregion
+//#region src/lib/utils/divide.ts
+function divide(left, right) {
+	const lN = left.n;
+	const rN = right.n;
+	if (rN === 0n) throw new DivisionByZeroError();
+	if (lN === 0n) return ZERO;
+	if (lN === "OVERFLOW" || rN === "OVERFLOW") return OverflowValue;
+	const { d: lD, c: lC, e: lE } = left;
+	const { d: rD, c: rC, e: rE } = right;
+	const g1 = gcd(lN, rN);
+	const g2 = gcd(rD, lD);
+	const n = lN / g1 * (rD / g2);
+	const d = lD / g2 * (rN / g1);
+	if (lC !== void 0 && lC === rC) return {
+		n,
+		d,
+		c: lC,
+		e: simplify(add({
+			n: lE?.n ?? 1n,
+			d: lE?.d ?? 1n
+		}, {
+			n: rE?.n ?? 1n,
+			d: rE?.d ?? 1n
+		}, true))
+	};
+	const c = lC ?? rC;
+	let e;
+	if (lC !== void 0) e = lE ? {
+		n: lE.n,
+		d: lE.d ?? 1n
+	} : {
+		n: 1n,
+		d: 1n
+	};
+	else if (rC !== void 0) e = {
+		n: -(rE?.n ?? 1n),
+		d: rE?.d ?? 1n
+	};
+	return {
+		n,
+		d,
+		c,
+		e
+	};
+}
+//#endregion
+//#region src/lib/utils/sqrt.ts
+/**
+* Calculates the integer square root of a BigInt.
+*/
+function isqrt(value) {
+	if (value < 0) throw new NotImplementedError("Square root of negative numbers is not implemented yet.");
+	if (value < 2n) return value;
+	let res = 0n;
+	let bit = 1n << (BigInt.bitLength(value) & -2n);
+	while (bit !== 0n) {
+		if (value >= res + bit) {
+			value -= res + bit;
+			res = (res >> 1n) + bit;
+		} else res >>= 1n;
+		bit >>= 2n;
+	}
+	return res;
+}
+function isPerfectSquare(val) {
+	if (val < 0) return [false, 0n];
+	const root = isqrt(val);
+	return [root * root === val, root];
+}
+function sqrt(v, precision) {
+	if (v.n === "OVERFLOW") return v;
+	if (v.n < 0) throw new NotImplementedError("Square root of negative numbers is not implemented yet.");
+	if (v.n === 0n) return ZERO;
+	if (precision.format === "precise") {
+		const [nIsSquare, n] = isPerfectSquare(v.n);
+		const [dIsSquare, d] = isPerfectSquare(v.d);
+		if (nIsSquare && dIsSquare) {
+			const e = simplify({
+				n: v.e?.n ?? 1n,
+				d: (v.e?.d ?? 1n) * 2n
+			});
+			return simplify({
+				n,
+				d,
+				c: v.c,
+				e
+			});
+		}
+	}
+	const precisionDigits = Math.max(10, (precision.maxDecimals ?? 30) * 3);
+	const scaleFactor = 10n ** BigInt(precisionDigits * 2);
+	return simplify({
+		n: isqrt(v.n * scaleFactor / v.d),
+		d: 10n ** BigInt(precisionDigits)
+	});
+}
+//#endregion
+//#region src/lib/utils/exponentiate.ts
+/**
+* Maximum digits allowed for the result of exponentiation
+*/
+const MAX_EXPONENT_RESULT_DIGITS = 10000000n;
+function exponentiate(left, right, precision) {
+	const rN = right.n;
+	if (rN === 0n) return ONE;
+	const lN = left.n;
+	if (lN === "OVERFLOW") return left;
+	const lD = left.d;
+	const c = left.c;
+	if (lN === lD && c === void 0) return ONE;
+	if (rN === "OVERFLOW") return right;
+	if (lN === -lD && c === void 0) {
+		if (rN % 2n) return {
+			n: -1n,
+			d: 1n
+		};
+		return ONE;
+	}
+	const normalizedExp = toSimpleFraction(simplify(right));
+	let exponent = normalizedExp.n;
+	if (lN === 0n) {
+		if (exponent < 0) throw new DivisionByZeroError();
+		return ZERO;
+	}
+	const dExp = normalizedExp.d;
+	if (dExp >= 100) {
+		let baseFloat = Number(lN) / Number(lD);
+		if (c) baseFloat *= Number(constants[c]);
+		const expFloat = Number(exponent) / Number(dExp);
+		const resultFloat = baseFloat ** expFloat;
+		if (!Number.isFinite(resultFloat)) return OverflowValue;
+		const [integerPart, fractionalPart] = resultFloat.toString().split(".");
+		if (!fractionalPart) return simplify({
+			n: BigInt(integerPart),
+			d: 1n
+		});
+		const denominator = 10n ** BigInt(fractionalPart.length);
+		return simplify({
+			n: BigInt(integerPart + fractionalPart),
+			d: denominator
+		});
+	}
+	const eN = (left.e?.n ?? 1n) * exponent;
+	let baseN = lN;
+	let baseD = lD;
+	if (exponent < 0) {
+		exponent = -exponent;
+		[baseN, baseD] = [baseD, baseN];
+	}
+	const baseNDigits = BigInt.bitLength(baseN);
+	const baseDDigits = BigInt.bitLength(baseD);
+	if (baseNDigits * exponent > MAX_EXPONENT_RESULT_DIGITS || baseDDigits * exponent > MAX_EXPONENT_RESULT_DIGITS || (baseNDigits > 5e3 || baseDDigits > 5e3) && exponent > 10) return OverflowValue;
+	const e = c ? simplify({
+		n: eN,
+		d: left.e?.d ?? 1n
+	}) : void 0;
+	if (dExp === exponent) return {
+		n: baseN,
+		d: baseD,
+		c,
+		e
+	};
+	const v = {
+		n: baseN ** exponent,
+		d: baseD ** exponent,
+		c,
+		e
+	};
+	if (dExp === 1n) return v;
+	if (dExp === 2n) return sqrt(v, precision);
+	return nthRoot(v, dExp, precision);
+}
+//#endregion
 //#region src/lib/utils/factorial.ts
 function binaryProduct(arr, low, high) {
 	if (low > high) return 1n;
@@ -150,7 +483,7 @@ function getPrimes(limit) {
 * Calculates factorial.
 */
 function factorial(n) {
-	if (n < 0n) return null;
+	if (n < 0) return null;
 	if (n === 0n || n === 1n) return 1n;
 	if (n < 1000n) {
 		let result = 1n;
@@ -174,12 +507,12 @@ function factorial(n) {
 //#endregion
 //#region src/lib/utils/floor.ts
 /**
-* Returns the largest integer less than or equal to a Value.
+* Returns the largest integer less than or equal to the value.
 */
 function floor(v) {
 	const { n, d } = simplify(v);
 	if (d === 1n) return n;
-	const isNegative = n < 0n;
+	const isNegative = n < 0;
 	const result = n / d;
 	const hasRemainder = n % d !== 0n;
 	return isNegative && hasRemainder ? result - 1n : result;
@@ -190,6 +523,7 @@ function floor(v) {
 * Calculates remainder of division.
 */
 function mod(a, b) {
+	if (b.n === 0n) throw new DivisionByZeroError();
 	const d = a.d * b.d / gcd(a.d, b.d);
 	const n1 = a.n * (d / a.d);
 	const n2 = b.n * (d / b.d);
@@ -199,131 +533,6 @@ function mod(a, b) {
 	};
 }
 //#endregion
-//#region src/lib/utils/multiply.ts
-function multiply(a, b) {
-	if (a.n === 0n || b.n === 0n) return {
-		n: 0n,
-		d: 1n
-	};
-	let n;
-	let d;
-	let c;
-	if (a.d === 1n && b.d === 1n) {
-		n = a.n * b.n;
-		d = 1n;
-	} else {
-		const g1 = gcd(a.n, b.d);
-		const g2 = gcd(b.n, a.d);
-		n = a.n / g1 * (b.n / g2);
-		d = a.d / g2 * (b.d / g1);
-	}
-	if (a.c === void 0 && b.c !== void 0) c = b.c;
-	else if (a.c !== void 0 && b.c === void 0) c = a.c;
-	return {
-		n,
-		d,
-		c
-	};
-}
-//#endregion
-//#region src/lib/utils/nthroot.ts
-/**
-* Calculates the integer nth root of a BigInt.
-*/
-function iNthRoot(value, n) {
-	if (value < 0n && n % 2n === 0n) throw new InterpreterError("Even root of negative number is not supported yet.");
-	if (value < 0n) return -iNthRoot(-value, n);
-	if (value < 2n) return value;
-	if (n === 1n) return value;
-	let x = 1n << BigInt(value.toString(2).length) / n + 1n;
-	const nMinus1 = n - 1n;
-	while (true) {
-		const nextX = (nMinus1 * x + value / x ** nMinus1) / n;
-		if (nextX >= x) break;
-		x = nextX;
-	}
-	return x;
-}
-/**
-* Calculates the n-th root of a Value (fraction).
-*/
-function nthRoot(v, root, precise = false, precisionDigits = 100) {
-	if (root === 0n) throw new DivisionByZeroError();
-	if (root === 1n) return v;
-	if (v.n < 0n) {
-		if (root % 2n === 0n) throw new InterpreterError(`${root}-th root of negative not supported.`);
-		const positiveResult = nthRoot({
-			n: -v.n,
-			d: v.d
-		}, root, precise, precisionDigits);
-		return {
-			n: -positiveResult.n,
-			d: positiveResult.d
-		};
-	}
-	if (v.n === 0n) return {
-		n: 0n,
-		d: 1n
-	};
-	if (precise) {
-		const rootN = iNthRoot(v.n, root);
-		const rootD = iNthRoot(v.d, root);
-		if (rootN ** root === v.n && rootD ** root === v.d) return simplify({
-			n: rootN,
-			d: rootD
-		});
-	}
-	const scaleFactor = 10n ** (BigInt(precisionDigits) * root);
-	return simplify({
-		n: iNthRoot(v.n * scaleFactor / v.d, root),
-		d: 10n ** BigInt(precisionDigits)
-	});
-}
-//#endregion
-//#region src/lib/utils/sqrt.ts
-/**
-* Calculates the integer square root of a BigInt.
-*/
-function isqrt(value) {
-	if (value < 0n) throw new InterpreterError("Square root of negative not supported yet.");
-	if (value < 2n) return value;
-	let res = 0n;
-	let bit = 1n << BigInt(value.toString(2).length - 1 & -2);
-	while (bit !== 0n) {
-		if (value >= res + bit) {
-			value -= res + bit;
-			res = (res >> 1n) + bit;
-		} else res >>= 1n;
-		bit >>= 2n;
-	}
-	return res;
-}
-function isPerfectSquare(val) {
-	if (val < 0n) return [false, 0n];
-	const root = isqrt(val);
-	return [root * root === val, root];
-}
-function sqrt(v, precise = false, precisionDigits = 100) {
-	if (v.n < 0n) throw new InterpreterError("Square root of negative not supported yet.");
-	if (v.n === 0n) return {
-		n: 0n,
-		d: 1n
-	};
-	if (precise) {
-		const [nIsSquare, nRoot] = isPerfectSquare(v.n);
-		const [dIsSquare, dRoot] = isPerfectSquare(v.d);
-		if (nIsSquare && dIsSquare) return simplify({
-			n: nRoot,
-			d: dRoot
-		});
-	}
-	const scaleFactor = 10n ** BigInt(precisionDigits * 2);
-	return simplify({
-		n: isqrt(v.n * scaleFactor / v.d),
-		d: 10n ** BigInt(precisionDigits)
-	});
-}
-//#endregion
 //#region src/lib/interpreter.ts
 const precedence = {
 	LPAREN: 0,
@@ -346,77 +555,90 @@ const precedence = {
 function isUnaryOperation(op) {
 	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || op === "ABS_FN" || op === "CEIL_FN" || op === "FLOOR_FN" || op === "SQRT_FN";
 }
-function getConst(id) {
-	const c = constants[id];
-	return {
-		n: BigInt(c.replace(".", "")),
-		d: 10n ** BigInt(c.length - c.indexOf(".") - 1)
-	};
-}
 /**
 * Maximum allowed precision
 */
 const MAX_PRECISION = 5e4;
 /**
-* Threshold to prevent denominators from growing infinitely.
+* Maximum allowed factorial
 */
-const SIMPLIFY_THRESHOLD = 10n ** 4000n;
+const MAX_FACTORIAL = 2e4;
+/**
+* Maximum allowed exponent for scientific number notation
+*/
+const MAX_SCIENTIFIC_NUMBER_EXPONENT = 3e5;
 function evaluate(tokens, options = {}) {
 	if (tokens.length === 0) throw new EmptyExpressionError();
-	const { format } = options;
 	const values = [];
 	const ops = [];
 	const applyOp = (pos) => {
 		const op = ops.pop();
 		if (!op || op === "LPAREN" || op === "ABS_OPEN") return;
 		const right = values.pop();
-		if (right === void 0) throw new UnexpectedEndOfExpressionError();
 		if (isUnaryOperation(op)) switch (op) {
 			case "UNARY_PLUS":
 				values.push(right);
 				return;
-			case "UNARY_MINUS":
+			case "UNARY_MINUS": {
+				const rN = right.n;
+				if (rN === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
 				values.push({
-					n: -right.n,
-					d: right.d,
-					c: right.c
+					...right,
+					n: -rN
 				});
 				return;
+			}
 			case "ABS_FN": {
 				const rN = right.n;
+				if (rN === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
+				const n = rN < 0 ? -rN : rN;
 				values.push({
-					n: rN < 0n ? -rN : rN,
-					d: right.d,
-					c: right.c
+					...right,
+					n
 				});
 				return;
 			}
 			case "CEIL_FN":
+				if (right.n === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
 				values.push({
-					n: ceil(right),
+					n: ceil(toSimpleFraction(right)),
 					d: 1n
 				});
 				return;
 			case "FLOOR_FN":
+				if (right.n === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
 				values.push({
-					n: floor(right),
+					n: floor(toSimpleFraction(right)),
 					d: 1n
 				});
 				return;
-			case "SQRT_FN": {
-				if (right.c === void 0) {
-					values.push(sqrt(right, format === "precise"));
-					return;
-				}
-				const v = multiply(right, getConst(right.c));
-				values.push(sqrt(v, format === "precise"));
+			case "SQRT_FN":
+				values.push(sqrt(right, options));
 				return;
-			}
 		}
 		if (op === "FACTORIAL") {
+			if (right.n === "OVERFLOW") {
+				values.push(OverflowValue);
+				return;
+			}
 			const reduced = simplify(right);
-			if (reduced.d !== 1n || reduced.n < 0n) throw new InterpreterError("Factorial is only defined for non-negative integers", pos);
-			if (reduced.n >= 4e5) throw new OverflowError();
+			if (reduced.d !== 1n || reduced.n < 0) throw new NotImplementedError("Factorial is only implemented for non-negative integers.", pos);
+			if (reduced.n >= MAX_FACTORIAL) {
+				values.push(OverflowValue);
+				return;
+			}
 			values.push({
 				n: factorial(reduced.n),
 				d: 1n
@@ -424,153 +646,29 @@ function evaluate(tokens, options = {}) {
 			return;
 		}
 		const left = values.pop();
-		if (left === void 0) throw new InsufficientOperandsError(pos);
-		let resN;
-		let resD;
-		let resC;
-		const lN = left.n;
-		const lD = left.d;
-		const lC = left.c;
-		const rN = right.n;
-		const rD = right.d;
-		const rC = right.c;
 		switch (op) {
 			case "ADD":
-			case "SUBTRACT": {
-				const isSub = op === "SUBTRACT";
-				if (lN === 0n) {
-					resN = isSub ? -rN : rN;
-					resD = rD;
-					resC = rC;
-					break;
-				}
-				if (rN === 0n) {
-					resN = lN;
-					resD = lD;
-					resC = lC;
-					break;
-				}
-				if (lD === rD) {
-					resN = isSub ? lN - rN : lN + rN;
-					resD = lD;
-				} else {
-					const common = gcd(lD, rD);
-					if (common === 1n) {
-						resN = isSub ? lN * rD - rN * lD : lN * rD + rN * lD;
-						resD = lD * rD;
-					} else {
-						const mLeft = rD / common;
-						const mRight = lD / common;
-						resN = isSub ? lN * mLeft - rN * mRight : lN * mLeft + rN * mRight;
-						resD = lD * mLeft;
-					}
-				}
-				if (lC === rC && resN !== 0n) resC = lC;
-				break;
-			}
+			case "SUBTRACT":
+				values.push(add(left, right, op === "SUBTRACT"));
+				return;
 			case "MULTIPLY":
-			case "IMPLICIT_MUL": {
-				const result = multiply(left, right);
-				resN = result.n;
-				resD = result.d;
-				resC = result.c;
-				break;
-			}
-			case "DIVIDE": {
-				const g1 = gcd(lN, rN);
-				const g2 = gcd(rD, lD);
-				resN = lN / g1 * (rD / g2);
-				resD = lD / g2 * (rN / g1);
-				if (lC !== void 0 && rC === void 0) resC = lC;
-				break;
-			}
-			case "MOD": {
-				if (rN === 0n) throw new DivisionByZeroError();
-				const { n, d } = mod({
-					n: lN,
-					d: lD
-				}, {
-					n: rN,
-					d: rD
-				});
-				resN = n;
-				resD = d;
-				break;
-			}
-			case "EXP": {
-				const normalizedExponent = simplify(right);
-				let exponent = normalizedExponent.n;
-				if (exponent === 0n) {
-					resN = 1n;
-					resD = 1n;
-					break;
-				}
-				if (lN === 0n) {
-					if (rN < 0) throw new DivisionByZeroError();
-					resN = 0n;
-					resD = 1n;
-					break;
-				}
-				if (lN === lD && lC === void 0) {
-					resN = 1n;
-					resD = 1n;
-					break;
-				}
-				const exponentD = normalizedExponent.d;
-				if (exponentD === 2n) {
-					const rootResult = sqrt({
-						n: lN ** exponent,
-						d: lD ** exponent
-					}, format === "precise");
-					resN = rootResult.n;
-					resD = rootResult.d;
-					resC = rootResult.c;
-					break;
-				}
-				if (exponentD !== 1n) {
-					const rootResult = nthRoot({
-						n: lN ** exponent,
-						d: lD ** exponent
-					}, exponentD, format === "precise");
-					resN = rootResult.n;
-					resD = rootResult.d;
-					resC = rootResult.c;
-					break;
-				}
-				let baseN = lN;
-				let baseD = lD;
-				if (exponent < 0n) {
-					[baseN, baseD] = [baseD, baseN];
-					exponent = -exponent;
-				}
-				if (exponent === 1n) {
-					resN = baseN;
-					resD = baseD;
-					if (normalizedExponent.c === void 0) resC = lC;
-					break;
-				}
-				if (exponent > 1e4 && (baseN * exponent > 6e6 || baseD * exponent > 6e6)) throw new OverflowError();
-				if (!lC) {
-					resN = baseN ** exponent;
-					resD = baseD ** exponent;
-					break;
+			case "IMPLICIT_MUL":
+				values.push(multiply(left, right));
+				return;
+			case "DIVIDE":
+				values.push(divide(left, right));
+				return;
+			case "MOD":
+				if (left.n === "OVERFLOW" || right.n === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
 				}
-				const c = getConst(lC);
-				resN = (baseN * c.n) ** exponent;
-				resD = (baseD * c.d) ** exponent;
-				break;
-			}
+				values.push(mod(left, right));
+				return;
+			case "EXP":
+				values.push(exponentiate(left, right, options));
+				return;
 		}
-		if (resD > SIMPLIFY_THRESHOLD) values.push(simplify({
-			n: resN,
-			d: resD,
-			c: resC
-		}));
-		else values.push({
-			n: resN,
-			d: resD,
-			c: resC
-		});
 	};
 	const pushOpWithPrecedence = (currentOp, pos) => {
 		const isUnary = isUnaryOperation(currentOp);
@@ -578,126 +676,124 @@ function evaluate(tokens, options = {}) {
 		while (ops.length > 0 && !isUnary && (isRightAssociative ? precedence[ops[ops.length - 1]] > precedence[currentOp] : precedence[ops[ops.length - 1]] >= precedence[currentOp])) applyOp(pos);
 		ops.push(currentOp);
 	};
-	for (let i = 0; i < tokens.length; i++) {
-		const token = tokens[i];
-		switch (token.type) {
-			case "NUMBER": {
-				const frac = token.fraction || "";
-				const fl = frac.length;
-				if (fl > MAX_PRECISION) throw new MaximumPrecisionError(fl, MAX_PRECISION);
-				let n = BigInt(token.whole + frac);
-				let d = fl === 0 ? 1n : 10n ** BigInt(fl);
-				if (token.exponent) {
-					if (token.exponent.length > MAX_PRECISION) throw new MaximumPrecisionError(token.exponent.length, MAX_PRECISION);
-					const expValue = BigInt(token.exponent);
-					if (expValue > 2e6) throw new OverflowError();
-					if (expValue >= 0n) n *= 10n ** expValue;
-					else d *= 10n ** -expValue;
+	for (const token of tokens) switch (token.type) {
+		case "NUMBER": {
+			const frac = token.fraction || "";
+			const fl = frac.length;
+			if (fl > MAX_PRECISION) throw new MaximumPrecisionError(fl, MAX_PRECISION);
+			let n = BigInt(token.whole + frac);
+			let d = fl === 0 ? 1n : 10n ** BigInt(fl);
+			if (token.exponent) {
+				if (token.exponent.length > MAX_PRECISION) throw new MaximumPrecisionError(token.exponent.length, MAX_PRECISION);
+				const expValue = BigInt(token.exponent);
+				if (expValue > MAX_SCIENTIFIC_NUMBER_EXPONENT) {
+					values.push(OverflowValue);
+					break;
 				}
-				if (d === 1n) values.push({
-					n,
-					d: 1n
-				});
-				else values.push(simplify({
-					n,
-					d
-				}));
-				break;
+				if (expValue >= 0) n *= 10n ** expValue;
+				else d *= 10n ** -expValue;
 			}
-			case "CONST":
-				if (format === "precise") values.push({
-					n: 1n,
-					d: 1n,
-					c: token.id
-				});
-				else values.push(getConst(token.id));
-				break;
-			case "LPAREN":
-				ops.push("LPAREN");
-				break;
-			case "RPAREN": {
-				let foundMatch = false;
-				while (ops.length > 0) {
-					if (ops[ops.length - 1] === "LPAREN") {
-						foundMatch = true;
-						break;
-					}
-					applyOp(token.pos);
+			if (d === 1n) values.push({
+				n,
+				d: 1n
+			});
+			else values.push({
+				n,
+				d
+			});
+			break;
+		}
+		case "CONST":
+			if (options.format === "precise") values.push({
+				n: 1n,
+				d: 1n,
+				c: token.id
+			});
+			else values.push(getConst(token.id));
+			break;
+		case "LPAREN":
+			ops.push("LPAREN");
+			break;
+		case "RPAREN": {
+			let foundMatch = false;
+			while (ops.length > 0) {
+				if (ops[ops.length - 1] === "LPAREN") {
+					foundMatch = true;
+					break;
 				}
-				if (!foundMatch) throw new MismatchedParenthesisError(token.pos);
-				ops.pop();
-				break;
+				applyOp(token.pos);
 			}
-			case "ABS_OPEN":
-				ops.push("ABS_OPEN");
-				break;
-			case "ABS_CLOSE": {
-				let foundMatch = false;
-				while (ops.length > 0) {
-					if (ops[ops.length - 1] === "ABS_OPEN") {
-						foundMatch = true;
-						break;
-					}
-					applyOp(token.pos);
-				}
-				if (!foundMatch) throw new InterpreterError("Mismatched absolute value pipe", token.pos);
-				ops.pop();
-				const val = values.pop();
-				if (val === void 0) throw new UnexpectedEndOfExpressionError();
-				values.push({
-					n: val.n < 0n ? -val.n : val.n,
-					d: val.d,
-					c: val.c
-				});
-				break;
+			if (!foundMatch) throw new MismatchedParenthesisError(token.pos);
+			ops.pop();
+			break;
+		}
+		case "ABS_OPEN":
+			ops.push("ABS_OPEN");
+			break;
+		case "ABS_CLOSE": {
+			while (ops.length > 0) {
+				if (ops[ops.length - 1] === "ABS_OPEN") break;
+				applyOp(token.pos);
 			}
-			case "PLUS":
-				pushOpWithPrecedence("ADD", token.pos);
-				break;
-			case "MINUS":
-				pushOpWithPrecedence("SUBTRACT", token.pos);
-				break;
-			case "MUL":
-				pushOpWithPrecedence("MULTIPLY", token.pos);
-				break;
-			case "DIV":
-				pushOpWithPrecedence("DIVIDE", token.pos);
-				break;
-			case "POW":
-				pushOpWithPrecedence("EXP", token.pos);
-				break;
-			case "UNARY_PLUS":
-				pushOpWithPrecedence("UNARY_PLUS", token.pos);
-				break;
-			case "UNARY_MINUS":
-				pushOpWithPrecedence("UNARY_MINUS", token.pos);
-				break;
-			case "IMPLICIT_MUL":
-				pushOpWithPrecedence("IMPLICIT_MUL", token.pos);
-				break;
-			case "FACTORIAL":
-				pushOpWithPrecedence("FACTORIAL", token.pos);
-				break;
-			case "MOD":
-				pushOpWithPrecedence("MOD", token.pos);
-				break;
-			case "FUNC":
-				switch (token.id) {
-					case "abs":
-						pushOpWithPrecedence("ABS_FN", token.pos);
-						break;
-					case "ceil":
-						pushOpWithPrecedence("CEIL_FN", token.pos);
-						break;
-					case "floor":
-						pushOpWithPrecedence("FLOOR_FN", token.pos);
-						break;
-					case "sqrt":
-						pushOpWithPrecedence("SQRT_FN", token.pos);
-						break;
-				}
+			ops.pop();
+			const val = values.pop();
+			if (val.n === "OVERFLOW") {
+				values.push(OverflowValue);
 				break;
+			}
+			values.push({
+				n: val.n < 0 ? -val.n : val.n,
+				d: val.d,
+				c: val.c
+			});
+			break;
 		}
+		case "PLUS":
+			pushOpWithPrecedence("ADD", token.pos);
+			break;
+		case "MINUS":
+			pushOpWithPrecedence("SUBTRACT", token.pos);
+			break;
+		case "MUL":
+			pushOpWithPrecedence("MULTIPLY", token.pos);
+			break;
+		case "DIV":
+			pushOpWithPrecedence("DIVIDE", token.pos);
+			break;
+		case "POW":
+			pushOpWithPrecedence("EXP", token.pos);
+			break;
+		case "UNARY_PLUS":
+			pushOpWithPrecedence("UNARY_PLUS", token.pos);
+			break;
+		case "UNARY_MINUS":
+			pushOpWithPrecedence("UNARY_MINUS", token.pos);
+			break;
+		case "IMPLICIT_MUL":
+			pushOpWithPrecedence("IMPLICIT_MUL", token.pos);
+			break;
+		case "FACTORIAL":
+			pushOpWithPrecedence("FACTORIAL", token.pos);
+			break;
+		case "MOD":
+			pushOpWithPrecedence("MOD", token.pos);
+			break;
+		case "FUNC":
+			switch (token.id) {
+				case "abs":
+					pushOpWithPrecedence("ABS_FN", token.pos);
+					break;
+				case "ceil":
+					pushOpWithPrecedence("CEIL_FN", token.pos);
+					break;
+				case "floor":
+					pushOpWithPrecedence("FLOOR_FN", token.pos);
+					break;
+				case "sqrt":
+					pushOpWithPrecedence("SQRT_FN", token.pos);
+					break;
+			}
+			break;
 	}
 	while (ops.length > 0) {
 		const top = ops[ops.length - 1];
@@ -709,11 +805,16 @@ function evaluate(tokens, options = {}) {
 		applyOp(lastPos);
 	}
 	const finalValue = values.pop();
-	if (finalValue === void 0) throw new UnexpectedEndOfExpressionError();
+	if (finalValue.n === "OVERFLOW") throw new OverflowError();
 	return simplify(finalValue);
 }
 //#endregion
 //#region src/lib/lexer.ts
+var LexerError = class extends GenericMathErrror {
+	constructor(message, pos) {
+		super("LexerError", message, pos);
+	}
+};
 function isWhitespace(ch) {
 	return ch === " ";
 }
@@ -726,6 +827,10 @@ function isAlpha(ch) {
 	return ch >= "a" && ch <= "z";
 }
 /**
+* Maximum allowed expression length
+*/
+const MAX_EXPRESSION_LENGTH = 75e6;
+/**
 * Simple lexer (tokenizer).
 */
 function tokenize(expression, options = {}) {
@@ -733,6 +838,7 @@ function tokenize(expression, options = {}) {
 	const tokens = [];
 	let index = 0;
 	const length = expression.length;
+	if (length > MAX_EXPRESSION_LENGTH) throw new LexerError(`Expression length (${length}) exceeds the maximum allowed limit of ${MAX_EXPRESSION_LENGTH}`, 0);
 	while (index < length) {
 		const ch = expression[index];
 		const startPos = index;
@@ -744,31 +850,22 @@ function tokenize(expression, options = {}) {
 			let whole = "";
 			let fraction = void 0;
 			let exponent = void 0;
+			const startIdx = index;
 			if (ch === decimalSeparator) {
 				whole = "0";
 				index++;
 				const fracStart = index;
-				let fracBuffer = "";
-				while (index < length && isDigit(expression[index])) {
-					fracBuffer += expression[index];
-					index++;
-				}
+				while (index < length && isDigit(expression[index])) index++;
 				if (index === fracStart) throw new LexerError("Expected digit after decimal separator", index);
-				fraction = fracBuffer;
+				fraction = expression.slice(fracStart, index);
 			} else {
-				while (index < length && isDigit(expression[index])) {
-					whole += expression[index];
-					index++;
-				}
+				while (index < length && isDigit(expression[index])) index++;
+				whole = expression.slice(startIdx, index);
 				if (index < length && expression[index] === decimalSeparator) {
 					index++;
-					let fracBuffer = "";
 					const fracStart = index;
-					while (index < length && isDigit(expression[index])) {
-						fracBuffer += expression[index];
-						index++;
-					}
-					fraction = index === fracStart ? "0" : fracBuffer;
+					while (index < length && isDigit(expression[index])) index++;
+					fraction = expression.slice(fracStart, index);
 				}
 			}
 			if (index < length && (expression[index] === "e" || expression[index] === "E")) {
@@ -936,6 +1033,21 @@ function isBinaryOperator(token) {
 function isUnaryContext(last) {
 	return !isOperand(last);
 }
+var ParserError = class extends GenericMathErrror {
+	constructor(message, pos) {
+		super("ParserError", message, pos);
+	}
+};
+var IncompleteExpressionError = class extends ParserError {
+	constructor(message, pos) {
+		super(`Incomplete expression: ${message}`, pos);
+	}
+};
+var UnexpectedOperatorError = class extends ParserError {
+	constructor(message, pos) {
+		super(`Unexpected operator: ${message}`, pos);
+	}
+};
 function resolveIdentifier(token) {
 	if (token.id === "pi" || token.id === "e") return {
 		type: "CONST",
@@ -986,14 +1098,14 @@ function parse(tokens) {
 		}
 		prevParsed = result[result.length - 1];
 		if (isBinaryOperator(token)) {
-			if (isUnaryContext(prevParsed)) throw new ParserError(`Unexpected operator '${getSym(token)}'`, token.pos);
+			if (isUnaryContext(prevParsed)) throw new UnexpectedOperatorError(`Unexpected operator '${getSym(token)}'`, token.pos);
 		}
 		if (token.type === "FACTORIAL") {
-			if (!isOperand(prevParsed) && prevParsed?.type !== "RPAREN") throw new ParserError("Unexpected factorial operator", token.pos);
+			if (!isOperand(prevParsed) && prevParsed?.type !== "RPAREN") throw new UnexpectedOperatorError("Unexpected factorial operator", token.pos);
 		}
 		if (token.type === "RPAREN") {
-			if (prevParsed && (prevParsed.type === "PLUS" || prevParsed.type === "MINUS" || isBinaryOperator(prevParsed))) throw new ParserError(`Unexpected ')' after operator '${getSym(prevParsed)}'`, token.pos);
-			if (prevParsed?.type === "LPAREN") throw new ParserError("Unexpected ')' after '('", token.pos);
+			if (prevParsed && (prevParsed.type === "PLUS" || prevParsed.type === "MINUS" || isBinaryOperator(prevParsed))) throw new UnexpectedOperatorError(`Unexpected ')' after operator '${getSym(prevParsed)}'`, token.pos);
+			if (prevParsed?.type === "LPAREN") throw new UnexpectedOperatorError("Unexpected ')' after '('", token.pos);
 		}
 		if (prev && (prev.type === "NUMBER" || prev.type === "IDENTIFIER" && resolveIdentifier(prev).type === "CONST") && token.type === "NUMBER") throw new ParserError("Missing operator between numbers", token.pos);
 		if ((token.type === "PLUS" || token.type === "MINUS") && isUnaryContext(prevParsed)) result.push({
@@ -1010,33 +1122,55 @@ function parse(tokens) {
 		"UNARY_PLUS",
 		"UNARY_MINUS",
 		"FUNC",
-		"ABS_OPEN"
+		"ABS_OPEN",
+		"LPAREN"
 	].includes(last.type))) throw new IncompleteExpressionError(`trailing operator '${last.type === "FUNC" ? last.id : getSym(last)}'`, last.pos);
 	return result;
 }
 //#endregion
 //#region src/utils/format-result.ts
-const getConstantStr = (coeff, c) => {
-	if (!c) return coeff;
-	if (coeff === "0") return "0";
-	if (coeff === "1") return c;
-	if (coeff === "-1") return `-${c}`;
-	return `${coeff}${c}`;
-};
+function getConstantStr(coeff, c, e) {
+	if (coeff === 0n) return "0";
+	if (!c) return `${coeff}`;
+	const isOne = e && e.n === 1n && (e.d === void 0 || e.d === 1n);
+	if (!e || isOne) {
+		if (coeff === 1n) return c;
+		if (coeff === -1n) return `-${c}`;
+		return `${coeff}${c}`;
+	}
+	const num = e.n;
+	const den = e.d ?? 1n;
+	const expStr = den === 1n ? `${num}` : `(${num}/${den})`;
+	const constantStr = den === 2n * num ? `sqrt(${c})` : `${c}^${expStr}`;
+	if (coeff === 1n) return constantStr;
+	if (coeff === -1n) return `-${constantStr}`;
+	return `${coeff}${constantStr}`;
+}
+function formatPrecise(v) {
+	const { n, d, c, e } = v;
+	if (n === 0n) return "0";
+	const isNegative = n < 0;
+	const absN = isNegative ? -n : n;
+	const numSign = isNegative ? "-" : "";
+	if (c && e && e.n < 0n) return `${numSign}${absN}/${getConstantStr(d, c, {
+		n: -e.n,
+		d: e.d
+	})}`;
+	const numeratorStr = getConstantStr(absN, c, e);
+	if (d === 1n) return `${numSign}${numeratorStr}`;
+	return `${numSign}${numeratorStr}/${d}`;
+}
 /**
 * Converts Result to a Decimal or Fraction String.
 */
 function formatResult(v, options = {}) {
-	const { n, d, c } = v;
+	const { n, d } = v;
 	if (d === 0n) return "NaN";
-	if (options.format === "precise") {
-		if (d === 1n) return getConstantStr(n.toString(), c);
-		return `${getConstantStr(n.toString(), c)}/${d}`;
-	}
-	const maxDecimals = options.maxDecimals ?? 30;
-	const isNegative = n < 0n;
-	const absN = n < 0n ? -n : n;
-	const integerPart = (absN / d).toString();
+	if (options.format === "precise") return formatPrecise(v);
+	const { maxDecimals = 30, roundingMode = "round" } = options;
+	const isNegative = n < 0;
+	const absN = isNegative ? -n : n;
+	let integerPart = (absN / d).toString();
 	let remainder = absN % d;
 	if (remainder === 0n) {
 		const res = (isNegative ? "-" : "") + integerPart;
@@ -1044,12 +1178,25 @@ function formatResult(v, options = {}) {
 	}
 	let fractionalPart = "";
 	let count = 0;
-	while (remainder !== 0n && count < maxDecimals) {
+	const targetLength = maxDecimals + 1;
+	while (remainder !== 0n && count < targetLength) {
 		remainder *= 10n;
 		fractionalPart += (remainder / d).toString();
 		remainder %= d;
 		count++;
 	}
+	const nexDigitStr = fractionalPart[maxDecimals];
+	if (nexDigitStr) {
+		const nextDigit = parseInt(nexDigitStr, 10);
+		fractionalPart = fractionalPart.slice(0, maxDecimals);
+		if (roundingMode === "round" && nextDigit >= 5) {
+			const incremented = (BigInt(fractionalPart) + 1n).toString();
+			if (incremented.length > fractionalPart.length) {
+				integerPart = (BigInt(integerPart) + 1n).toString();
+				fractionalPart = incremented.slice(1);
+			} else fractionalPart = incremented.padStart(fractionalPart.length, "0");
+		}
+	}
 	let lastNonZero = -1;
 	for (let i = fractionalPart.length - 1; i >= 0; i--) if (fractionalPart[i] !== "0") {
 		lastNonZero = i;