picocalc 0.0.5 → 0.0.6

package/dist/index.mjs

@@ -44,15 +44,9 @@ var InterpreterRangeError = class extends InterpreterError {
 		super(message);
 	}
 };
-var MismatchedParenthesisError = class extends InterpreterError {
-	constructor(pos, message = "Mismatched parenthesis") {
-		super(message, pos);
-	}
-};
-// src/lib/options.ts
 const ROUNDING_MODE = "round";
-function getPrecisionDigits(maxDecimals) {
-	return Math.max(10, (maxDecimals ?? 30) + 10);
+function getBitPrecision(maxDecimals = 30) {
+	return BigInt(maxDecimals * 4 + 32);
 }
 /**
 * Maximum allowed precision
@@ -77,7 +71,7 @@ function splitSeries(a, b) {
 function computeE(maxDecimals) {
 	let b = 1n;
 	let m = 1n;
-	const t = 10n ** BigInt(getPrecisionDigits(maxDecimals));
+	const t = 1n << getBitPrecision(maxDecimals);
 	while (m < t) {
 		b++;
 		m *= b;
@@ -106,7 +100,7 @@ function gcd(a, b) {
 	return a;
 }
 // src/lib/utils/multiply.ts
-function multiply(a, b, maxDecimals = 30) {
+function multiply(a, b, maxDecimals) {
 	const aN = a.n;
 	const bN = b.n;
 	if (aN === 0n || bN === 0n) return ZERO;
@@ -163,43 +157,41 @@ function iNthRoot(value, n) {
 /**
 * Calculates the n-th root of a fraction.
 */
-function nthRoot(v, n, precision) {
+function nthRoot(v, n, maxDecimals) {
 	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({
+		const r = nthRoot({
 			n: -v.n,
 			d: v.d
-		}, n, precision);
+		}, n, maxDecimals);
 		return {
-			n: -positiveResult.n,
-			d: positiveResult.d
+			n: -r.n,
+			d: r.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 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 = getPrecisionDigits(precision.maxDecimals);
-	const scaleFactor = 10n ** (BigInt(precisionDigits) * n);
+	const precisionBits = getBitPrecision(maxDecimals);
+	const scaleFactor = 1n << precisionBits * n;
 	const s = toSimpleFraction(v);
 	return simplify({
 		n: iNthRoot(s.n * scaleFactor / s.d, n),
-		d: 10n ** BigInt(precisionDigits)
+		d: 1n << precisionBits
 	});
 }
 // src/lib/utils/simplify.ts
@@ -234,12 +226,12 @@ function simplify(v) {
 /**
 * Resolves any constants and exponents to return a simple fraction.
 */
-function toSimpleFraction(val, maxDecimals = 30) {
+function toSimpleFraction(val, maxDecimals) {
 	if (!val.c) return {
 		d: val.d,
 		n: val.n
 	};
-	const c = getConst(val.c, { maxDecimals });
+	const c = getConst(val.c, maxDecimals);
 	const expN = val.e?.n ?? 1n;
 	const expD = val.e?.d ?? 1n;
 	const absExpN = expN < 0 ? -expN : expN;
@@ -247,27 +239,20 @@ function toSimpleFraction(val, maxDecimals = 30) {
 		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" });
+	if (expD !== 1n) poweredConstant = nthRoot(poweredConstant, expD);
 	return multiply(poweredConstant, {
 		n: val.n,
 		d: val.d
 	}, maxDecimals);
 }
 // src/lib/utils/arctan.ts
-function rawArctanSeries(absN, absD, precision) {
-	const precisionDigits = getPrecisionDigits(precision.maxDecimals);
-	const SCALE = 10n ** BigInt(precisionDigits);
-	const xScaled = absN * SCALE / absD;
-	if (xScaled === 0n) return {
-		n: 0n,
-		d: SCALE
-	};
-	const xSqScaled = xScaled * xScaled / SCALE;
+function rawArctanSeries(xScaled, bitPrecision) {
+	const xSqScaled = xScaled * xScaled >> bitPrecision;
 	let currentTerm = xScaled;
 	let totalSum = xScaled;
 	let k = 1n;
 	while (true) {
-		currentTerm = currentTerm * xSqScaled / SCALE;
+		currentTerm = currentTerm * xSqScaled >> bitPrecision;
 		const denominatorFactor = 2n * k + 1n;
 		const termValue = currentTerm / denominatorFactor;
 		if (termValue === 0n) break;
@@ -275,32 +260,26 @@ function rawArctanSeries(absN, absD, precision) {
 		else totalSum += termValue;
 		k++;
 	}
-	return {
-		n: totalSum,
-		d: SCALE
-	};
+	return totalSum;
 }
-function arctan(v, precision) {
+function arctan(v, maxDecimals) {
 	const { n, d } = v;
 	if (n === 0n) return ZERO;
+	const bitPrecision = getBitPrecision(maxDecimals);
 	const isNegative = n < 0n !== d < 0n;
 	const absN = n < 0n ? -n : n;
 	const absD = d < 0n ? -d : d;
-	if (absN === absD) {
-		const pi = getConst("pi", precision);
-		const n = isNegative ? -pi.n : pi.n;
-		return simplify({
-			c: pi.c,
-			n,
-			d: pi.d * 4n
-		});
-	}
+	if (absN === absD) return {
+		c: "pi",
+		n: isNegative ? -1n : 1n,
+		d: 4n
+	};
 	if (absN > absD) {
-		const pi = computePi(precision);
+		const pi = computePi(maxDecimals);
 		const subArctan = arctan({
 			n: absD,
 			d: absN
-		}, precision);
+		}, maxDecimals);
 		const resultNum = pi.n * subArctan.d - 2n * subArctan.n * pi.d;
 		const resultDen = 2n * pi.d * subArctan.d;
 		return simplify({
@@ -312,11 +291,11 @@ function arctan(v, precision) {
 		const halfArctan = arctan({
 			n: 1n,
 			d: 2n
-		}, precision);
+		}, maxDecimals);
 		const remainderArctan = arctan({
 			n: 2n * absN - absD,
 			d: 2n * absD + absN
-		}, precision);
+		}, maxDecimals);
 		const resultNum = halfArctan.n * remainderArctan.d + remainderArctan.n * halfArctan.d;
 		const resultDen = halfArctan.d * remainderArctan.d;
 		return simplify({
@@ -324,22 +303,22 @@ function arctan(v, precision) {
 			d: resultDen
 		});
 	}
-	const r = rawArctanSeries(absN, absD, precision);
+	const r = rawArctanSeries((absN << bitPrecision) / absD, bitPrecision);
 	return simplify({
-		n: isNegative ? -r.n : r.n,
-		d: r.d
+		n: isNegative ? -r : r,
+		d: 1n << bitPrecision
 	});
 }
 // src/lib/utils/pi.ts
-function computePi(precision) {
+function computePi(maxDecimals) {
 	const p5 = arctan({
 		n: 1n,
 		d: 5n
-	}, precision);
+	}, maxDecimals);
 	const p239 = arctan({
 		n: 1n,
 		d: 239n
-	}, precision);
+	}, maxDecimals);
 	return simplify({
 		n: 16n * p5.n * p239.d - 4n * p239.n * p5.d,
 		d: p5.d * p239.d
@@ -354,37 +333,29 @@ const ONE = {
 	n: 1n,
 	d: 1n
 };
-function getConst(id, options) {
-	if (options.format === "precise") return {
-		n: 1n,
-		d: 1n,
-		c: id
-	};
-	if (id === "pi") return computePi(options);
-	return computeE(options.maxDecimals);
+function getConst(id, maxDecimals) {
+	if (id === "pi") return computePi(maxDecimals);
+	return computeE(maxDecimals);
 }
 // src/lib/utils/add.ts
-function add(left, right, maxDecimals = 30, subtract = false) {
+function negate(v) {
+	if (v.n === "OVERFLOW") return v;
+	const { n, d } = v;
+	return {
+		...v,
+		n: d < 0 ? n : -n,
+		d: d < 0 ? -d : d
+	};
+}
+function add(left, right, maxDecimals, subtract = false) {
 	const lN = left.n;
 	const rN = right.n;
-	if (lN === "OVERFLOW") return left;
-	if (rN === "OVERFLOW") return right;
+	if (lN === "OVERFLOW" || rN === 0n) return left;
+	if (rN === "OVERFLOW" || lN === 0n) return subtract ? negate(right) : 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 (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left, maxDecimals), toSimpleFraction(right, maxDecimals), maxDecimals, subtract);
+	let n, d;
 	if (lD === rD) {
 		n = subtract ? lN - rN : lN + rN;
 		d = lD;
@@ -396,7 +367,10 @@ function add(left, right, maxDecimals = 30, subtract = false) {
 		d = lD * mLeft;
 	}
 	if (n === 0n) return ZERO;
-	if (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left, maxDecimals), toSimpleFraction(right, maxDecimals), maxDecimals, subtract);
+	if (n < 0n && d < 0n) {
+		n = -n;
+		d = -d;
+	}
 	return {
 		n,
 		d,
@@ -404,102 +378,34 @@ function add(left, right, maxDecimals = 30, subtract = false) {
 		e
 	};
 }
-// 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 = getPrecisionDigits(precision.maxDecimals);
-	const scaleFactor = 10n ** BigInt(precisionDigits * 2);
-	const s = toSimpleFraction(v);
-	return simplify({
-		n: isqrt(s.n * scaleFactor / s.d),
-		d: 10n ** BigInt(precisionDigits)
-	});
-}
 // src/lib/utils/arctanh.ts
-function rawArctanhSeries(xScaled, SCALE) {
+function rawArctanhSeries(xScaled, bitPrecision) {
 	let currentTerm = xScaled;
 	let totalSum = xScaled;
-	const xSqScaled = xScaled * xScaled / SCALE;
+	const xSqScaled = xScaled * xScaled >> bitPrecision;
 	let k = 1n;
 	while (true) {
-		currentTerm = currentTerm * xSqScaled / SCALE;
+		currentTerm = currentTerm * xSqScaled >> bitPrecision;
 		const denominatorFactor = 2n * k + 1n;
-		const termValue = currentTerm / denominatorFactor;
-		if (termValue === 0n) break;
-		totalSum += termValue;
+		if (currentTerm < denominatorFactor) break;
+		totalSum += currentTerm / denominatorFactor;
 		k++;
 	}
 	return totalSum;
 }
-function arctanh(v, precision) {
+function arctanh(v, maxDecimals) {
 	const { n, d } = v;
 	if (n === 0n) return ZERO;
-	const precisionDigits = getPrecisionDigits(precision.maxDecimals);
-	const SCALE = 10n ** BigInt(precisionDigits);
-	let currentN = n;
-	let currentD = d;
-	const isNegative = currentN < 0n !== currentD < 0n;
-	currentN = currentN < 0n ? -currentN : currentN;
-	currentD = currentD < 0n ? -currentD : currentD;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const isNegative = n < 0n !== d < 0n;
+	const currentN = n < 0n ? -n : n;
+	const currentD = d < 0n ? -d : d;
 	if (currentN >= currentD) throw new InterpreterRangeError("arctanh argument must be strictly between -1 and 1");
-	let reductions = 0n;
-	const threshold = SCALE / 2n;
-	let xScaled = currentN * SCALE / currentD;
-	while (xScaled > threshold) {
-		const sqrtVal = sqrt({
-			n: SCALE - xScaled * xScaled / SCALE,
-			d: SCALE
-		}, precision);
-		const denom = SCALE + sqrtVal.n * SCALE / sqrtVal.d;
-		xScaled = xScaled * SCALE / denom;
-		reductions++;
-	}
-	let sumScaled = rawArctanhSeries(xScaled, SCALE);
-	sumScaled <<= reductions;
-	return simplify({
+	const sumScaled = rawArctanhSeries((currentN << bitPrecision) / currentD, bitPrecision);
+	return {
 		n: isNegative ? -sumScaled : sumScaled,
-		d: SCALE
-	});
+		d: 1n << bitPrecision
+	};
 }
 // src/lib/utils/ceil.ts
 /**
@@ -514,7 +420,7 @@ function ceil(v) {
 	return isPositive && hasRemainder ? result + 1n : result;
 }
 // src/lib/utils/divide.ts
-function divide(left, right, maxDecimals = 30) {
+function divide(left, right, maxDecimals) {
 	const lN = left.n;
 	const rN = right.n;
 	if (rN === 0n) throw new DivisionByZeroError();
@@ -522,6 +428,7 @@ function divide(left, right, maxDecimals = 30) {
 	if (lN === "OVERFLOW" || rN === "OVERFLOW") return OverflowValue;
 	const { d: lD, c: lC, e: lE } = left;
 	const { d: rD, c: rC, e: rE } = right;
+	if (lC !== void 0 && rC !== void 0 && lC !== rC) return divide(toSimpleFraction(left, maxDecimals), toSimpleFraction(right, maxDecimals), maxDecimals);
 	const g1 = gcd(lN, rN);
 	const g2 = gcd(rD, lD);
 	const n = lN / g1 * (rD / g2);
@@ -543,10 +450,7 @@ function divide(left, right, maxDecimals = 30) {
 	if (lC !== void 0) e = lE ? {
 		n: lE.n,
 		d: lE.d ?? 1n
-	} : {
-		n: 1n,
-		d: 1n
-	};
+	} : ONE;
 	else if (rC !== void 0) e = {
 		n: -(rE?.n ?? 1n),
 		d: rE?.d ?? 1n
@@ -558,37 +462,80 @@ function divide(left, right, maxDecimals = 30) {
 		e
 	};
 }
+// 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, maxDecimals) {
+	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;
+	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 precisionBits = getBitPrecision(maxDecimals);
+	const scaleFactor = 1n << precisionBits * 2n;
+	const s = toSimpleFraction(v);
+	return {
+		n: isqrt(s.n * scaleFactor / s.d),
+		d: 1n << precisionBits
+	};
+}
 // src/lib/utils/ln.ts
-function ln(v, precision) {
+function ln(v, maxDecimals) {
 	const { n, d, c, e } = v;
 	if (n <= 0n || d <= 0n) throw new InterpreterRangeError("Logarithm of non-positive number");
-	if (c === "e") return e ? {
+	if (c === "e" && n === d) return e ? {
 		n: e.n,
 		d: e.d ?? 1n
 	} : ONE;
-	const precisionDigits = getPrecisionDigits(precision.maxDecimals);
-	const SCALE = 10n ** BigInt(precisionDigits);
-	let currentN = n;
-	let currentD = d;
+	let { n: sN, d: sD } = toSimpleFraction(v);
+	const isReciprocal = sN < sD;
+	if (isReciprocal) [sN, sD] = [sD, sN];
 	let m = 0;
-	const isReciprocal = currentN * SCALE < currentD * SCALE;
-	if (currentN * SCALE < currentD * SCALE) {
-		currentN = d;
-		currentD = n;
-	}
-	while (currentN * SCALE >= 2n * currentD * SCALE) {
+	while (sN >= 2n * sD) {
 		const val = sqrt({
-			n: currentN,
-			d: currentD
-		}, precision);
-		currentN = val.n;
-		currentD = val.d;
+			n: sN,
+			d: sD
+		}, maxDecimals);
+		sN = val.n;
+		sD = val.d;
 		m++;
 	}
 	const at = arctanh({
-		n: currentN - currentD,
-		d: currentN + currentD
-	}, precision);
+		n: sN - sD,
+		d: sN + sD
+	}, maxDecimals);
 	let rN = at.n * 2n;
 	if (m > 0) rN <<= BigInt(m);
 	if (isReciprocal) rN = -rN;
@@ -598,29 +545,28 @@ function ln(v, precision) {
 	});
 }
 // src/lib/utils/exp.ts
-function rawExp(v, precision) {
+function rawExp(v, maxDecimals) {
 	const { n, d } = v;
 	if (n === 0n) return ONE;
-	const precisionDigits = getPrecisionDigits(precision.maxDecimals);
-	const SCALE = 10n ** BigInt(precisionDigits);
-	const xScaled = n * SCALE / d;
+	const scale = 1n << getBitPrecision(maxDecimals);
+	const xScaled = n * scale / d;
 	const ln2Val = ln({
 		n: 2n,
 		d: 1n
-	}, precision);
-	const ln2Scaled = ln2Val.n * SCALE / ln2Val.d;
+	}, maxDecimals);
+	const ln2Scaled = ln2Val.n * scale / ln2Val.d;
 	let k;
 	if (xScaled >= 0n) k = (xScaled + ln2Scaled / 2n) / ln2Scaled;
 	else k = (xScaled - ln2Scaled / 2n) / ln2Scaled;
 	const rScaled = xScaled - k * ln2Scaled;
 	const isNegativeR = rScaled < 0n;
 	const absRScaled = isNegativeR ? -rScaled : rScaled;
-	let sum = SCALE;
-	let currentTerm = SCALE;
+	let sum = scale;
+	let currentTerm = scale;
 	let factorial = 1n;
 	let i = 1n;
 	while (true) {
-		currentTerm = currentTerm * absRScaled / SCALE;
+		currentTerm = currentTerm * absRScaled / scale;
 		if (currentTerm === 0n) break;
 		factorial *= i;
 		const termVal = currentTerm / factorial;
@@ -630,7 +576,7 @@ function rawExp(v, precision) {
 		i += 1n;
 	}
 	let finalNum = sum;
-	let finalDen = SCALE;
+	let finalDen = scale;
 	if (k > 0n) finalNum <<= k;
 	else if (k < 0n) finalDen <<= -k;
 	return {
@@ -638,7 +584,7 @@ function rawExp(v, precision) {
 		d: finalDen
 	};
 }
-function exp(v, precision) {
+function exp(v, maxDecimals) {
 	const { n, d, c } = v;
 	if (n === 0n) return ONE;
 	if (!c) return simplify({
@@ -650,14 +596,9 @@ function exp(v, precision) {
 			d
 		}
 	});
-	return rawExp(toSimpleFraction(v, getPrecisionDigits(precision.maxDecimals)), precision);
+	return rawExp(toSimpleFraction(v, maxDecimals), maxDecimals);
 }
-// src/lib/utils/exponentiate.ts
-/**
-* Maximum digits allowed for the result of exponentiation
-*/
-const MAX_EXPONENT_RESULT_DIGITS = 10000000n;
-function exponentiate(left, right, precision) {
+function exponentiate(left, right, maxDecimals) {
 	const rN = right.n;
 	if (rN === 0n) return ONE;
 	const lN = left.n;
@@ -673,27 +614,29 @@ function exponentiate(left, right, precision) {
 		};
 		return ONE;
 	}
-	const normalizedExp = toSimpleFraction(rS, precision.maxDecimals);
+	const normalizedExp = toSimpleFraction(rS, maxDecimals);
 	const dExp = normalizedExp.d;
 	let exponent = normalizedExp.n;
 	if (lN === 0n) {
 		if (exponent < 0) throw new DivisionByZeroError();
 		return ZERO;
 	}
-	if (dExp >= 100) {
-		const maxDecimals = getPrecisionDigits(precision.maxDecimals);
-		const lS = toSimpleFraction(left, maxDecimals);
-		const rS = toSimpleFraction(right, maxDecimals);
-		try {
-			const lnBase = ln(lS, { maxDecimals });
-			const SCALE = 10n ** BigInt(maxDecimals);
-			return rawExp({
-				n: lnBase.n * SCALE / lnBase.d * (rS.n * SCALE / rS.d) / SCALE,
-				d: SCALE
-			}, precision);
-		} catch {
-			return OverflowValue;
-		}
+	if ((dExp >= 100 || lD > 1e3) && (lN !== 1n || rS.c)) {
+		const isNegativeBase = lN < 0;
+		if (isNegativeBase && dExp % 2n === 0n) throw new NotImplementedError(`Even (${dExp}th) root of negative numbers is not implemented yet.`);
+		const l = toSimpleFraction(isNegativeBase ? negate(left) : left, maxDecimals);
+		const r = toSimpleFraction(rS, maxDecimals);
+		const lnBase = ln(l, maxDecimals);
+		const scale = 1n << getBitPrecision(maxDecimals);
+		const p = lnBase.n * scale / lnBase.d * (r.n * scale / r.d) / scale;
+		const pAbs = p < 0 ? -p : p;
+		if (scale > pAbs * 10000000n || pAbs > scale * 10000000n) return OverflowValue;
+		const result = rawExp({
+			n: p,
+			d: scale
+		}, maxDecimals);
+		if (isNegativeBase && normalizedExp.n % 2n !== 0n) return negate(result);
+		return result;
 	}
 	const eN = (left.e?.n ?? 1n) * exponent;
 	let baseN = lN;
@@ -704,7 +647,7 @@ function exponentiate(left, right, precision) {
 	}
 	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;
+	if (baseNDigits * exponent > 10000000n || baseDDigits * exponent > 10000000n || (baseNDigits > 5e3 || baseDDigits > 5e3) && exponent > 10) return OverflowValue;
 	const e = c ? simplify({
 		n: eN,
 		d: left.e?.d ?? 1n
@@ -722,8 +665,8 @@ function exponentiate(left, right, precision) {
 		e
 	};
 	if (dExp === 1n) return v;
-	if (dExp === 2n) return sqrt(v, precision);
-	return nthRoot(v, dExp, precision);
+	if (dExp === 2n) return sqrt(v, maxDecimals);
+	return nthRoot(v, dExp, maxDecimals);
 }
 // src/lib/utils/factorial.ts
 function binaryProduct(arr, low, high) {
@@ -791,6 +734,143 @@ function mod(a, b) {
 		d
 	};
 }
+// src/lib/utils/trig.ts
+function roundDiv(numerator, denominator) {
+	const twice = numerator * 2n;
+	const absTwice = twice < 0n ? -twice : twice;
+	const absDenom = denominator < 0n ? -denominator : denominator;
+	const quotient = (absTwice + absDenom) / (2n * absDenom);
+	return twice < 0n !== denominator < 0n ? -quotient : quotient;
+}
+function rawSinSeries(rScaled, bitPrecision) {
+	const rSqScaled = rScaled * rScaled >> bitPrecision;
+	let termValue = rScaled;
+	let totalSum = rScaled;
+	let k = 1n;
+	while (true) {
+		termValue = (termValue * rSqScaled >> bitPrecision) / (2n * k * (2n * k + 1n));
+		if (termValue === 0n) break;
+		if (k % 2n === 1n) totalSum -= termValue;
+		else totalSum += termValue;
+		k++;
+	}
+	return totalSum;
+}
+function rawCosSeries(rScaled, bitPrecision) {
+	const rSqScaled = rScaled * rScaled >> bitPrecision;
+	const scale = 1n << bitPrecision;
+	let termValue = scale;
+	let totalSum = scale;
+	let k = 1n;
+	while (true) {
+		termValue = (termValue * rSqScaled >> bitPrecision) / ((2n * k - 1n) * (2n * k));
+		if (termValue === 0n) break;
+		if (k % 2n === 1n) totalSum -= termValue;
+		else totalSum += termValue;
+		k++;
+	}
+	return totalSum;
+}
+function getHalfPi(maxDecimals) {
+	const { d, n, c } = computePi(maxDecimals);
+	return {
+		c,
+		n,
+		d: d * 2n
+	};
+}
+function sin(v, maxDecimals) {
+	const { n, d, c, e } = v;
+	if (n === 0n) return ZERO;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const scale = 1n << bitPrecision;
+	const isPiLinear = c === "pi" && (e === void 0 || e.n === 1n);
+	let rScaled;
+	let k;
+	if (isPiLinear) {
+		k = roundDiv(2n * n, d);
+		const rN = 2n * n - k * d;
+		if (rN === 0n) {
+			const quadrant = (k % 4n + 4n) % 4n;
+			if (quadrant === 0n || quadrant === 2n) return ZERO;
+			if (quadrant === 1n) return ONE;
+			return {
+				n: -1n,
+				d: 1n
+			};
+		}
+		const piVal = computePi(maxDecimals);
+		rScaled = rN * piVal.n * scale / (2n * d * piVal.d);
+	} else {
+		const simple = toSimpleFraction(v);
+		const halfPi = getHalfPi(maxDecimals);
+		k = roundDiv(simple.n * halfPi.d, simple.d * halfPi.n);
+		const rN = simple.n * halfPi.d - k * halfPi.n * simple.d;
+		const rD = simple.d * halfPi.d;
+		rScaled = rN * scale / rD;
+	}
+	const quadrant = (k % 4n + 4n) % 4n;
+	let resultScaled;
+	let negate = false;
+	if (quadrant === 0n) resultScaled = rawSinSeries(rScaled, bitPrecision);
+	else if (quadrant === 1n) resultScaled = rawCosSeries(rScaled, bitPrecision);
+	else if (quadrant === 2n) {
+		resultScaled = rawSinSeries(rScaled, bitPrecision);
+		negate = true;
+	} else {
+		resultScaled = rawCosSeries(rScaled, bitPrecision);
+		negate = true;
+	}
+	return {
+		n: negate ? -resultScaled : resultScaled,
+		d: scale
+	};
+}
+function cos(v, maxDecimals) {
+	const { n, d, c, e } = v;
+	if (n === 0n) return ONE;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const scale = 1n << bitPrecision;
+	const isPiLinear = c === "pi" && (e === void 0 || e.n === 1n);
+	let rScaled;
+	let k;
+	if (isPiLinear) {
+		k = roundDiv(2n * n, d);
+		const rN = 2n * n - k * d;
+		if (rN === 0n) {
+			const quadrant = (k % 4n + 4n) % 4n;
+			if (quadrant === 0n || quadrant === 2n) return quadrant === 0n ? ONE : {
+				n: -1n,
+				d: 1n
+			};
+			return ZERO;
+		}
+		const piVal = computePi(maxDecimals);
+		rScaled = rN * piVal.n * scale / (2n * d * piVal.d);
+	} else {
+		const simple = toSimpleFraction(v);
+		const halfPi = getHalfPi(maxDecimals);
+		k = roundDiv(simple.n * halfPi.d, simple.d * halfPi.n);
+		const rN = simple.n * halfPi.d - k * halfPi.n * simple.d;
+		const rD = simple.d * halfPi.d;
+		rScaled = rN * scale / rD;
+	}
+	const quadrant = (k % 4n + 4n) % 4n;
+	let resultScaled;
+	let negate = false;
+	if (quadrant === 0n) resultScaled = rawCosSeries(rScaled, bitPrecision);
+	else if (quadrant === 1n) {
+		resultScaled = rawSinSeries(rScaled, bitPrecision);
+		negate = true;
+	} else if (quadrant === 2n) {
+		resultScaled = rawCosSeries(rScaled, bitPrecision);
+		negate = true;
+	} else resultScaled = rawSinSeries(rScaled, bitPrecision);
+	return {
+		n: negate ? -resultScaled : resultScaled,
+		d: scale
+	};
+}
 // src/lib/interpreter.ts
 const precedence = {
 	LPAREN: 0,
@@ -800,12 +880,12 @@ const precedence = {
 	MULTIPLY: 2,
 	DIVIDE: 2,
 	MOD: 2,
-	UNARY_PLUS: 4,
-	UNARY_MINUS: 4,
-	EXP: 6,
-	IMPLICIT_MUL: 6,
-	FN_CALL: 8,
-	FACTORIAL: 10
+	UNARY_PLUS: 3,
+	UNARY_MINUS: 3,
+	FN_CALL: 4,
+	EXP: 5,
+	IMPLICIT_MUL: 5,
+	FACTORIAL: 6
 };
 function isFunctionOp(op) {
 	return typeof op === "object";
@@ -814,7 +894,7 @@ function isUnaryOperation(op) {
 	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || isFunctionOp(op);
 }
 function getOpPrecedence(op) {
-	if (typeof op === "object") return precedence.FN_CALL;
+	if (isFunctionOp(op)) return precedence.FN_CALL;
 	return precedence[op];
 }
 function evaluate(tokens, options = {}) {
@@ -827,37 +907,27 @@ function evaluate(tokens, options = {}) {
 		if (!op || op === "LPAREN" || op === "ABS_OPEN" || op === "UNARY_PLUS") return;
 		const right = values.pop();
 		if (isUnaryOperation(op)) {
-			const rN = right.n;
-			switch (op) {
-				case "UNARY_MINUS":
-					if (rN === "OVERFLOW") {
-						values.push(OverflowValue);
-						return;
-					}
-					values.push({
-						...right,
-						n: -rN
-					});
-					return;
+			if (op === "UNARY_MINUS") {
+				values.push(negate(right));
+				return;
 			}
 			const { id } = op;
 			if (id === "sqrt") {
-				values.push(sqrt(right, options));
+				values.push(sqrt(right, maxDecimals));
 				return;
 			}
-			if (rN === "OVERFLOW") {
+			const n = right.n;
+			if (n === "OVERFLOW") {
 				values.push(OverflowValue);
 				return;
 			}
 			switch (id) {
-				case "abs": {
-					const n = rN < 0 ? -rN : rN;
+				case "abs":
 					values.push({
 						...right,
-						n
+						n: n < 0 ? -n : n
 					});
 					return;
-				}
 				case "ceil":
 					values.push({
 						n: ceil(toSimpleFraction(right, maxDecimals)),
@@ -871,16 +941,22 @@ function evaluate(tokens, options = {}) {
 					});
 					return;
 				case "arctan":
-					values.push(arctan(toSimpleFraction(right, maxDecimals), options));
+					values.push(arctan(toSimpleFraction(right, maxDecimals), maxDecimals));
 					return;
 				case "arctanh":
-					values.push(arctanh(toSimpleFraction(right, maxDecimals), options));
+					values.push(arctanh(toSimpleFraction(right, maxDecimals), maxDecimals));
 					return;
 				case "ln":
-					values.push(ln(right, options));
+					values.push(ln(right, maxDecimals));
 					return;
 				case "exp":
-					values.push(exp(right, options));
+					values.push(exp(right, maxDecimals));
+					return;
+				case "sin":
+					values.push(sin(right, maxDecimals));
+					return;
+				case "cos":
+					values.push(cos(right, maxDecimals));
 					return;
 			}
 		}
@@ -922,7 +998,7 @@ function evaluate(tokens, options = {}) {
 				values.push(mod(toSimpleFraction(left), toSimpleFraction(right)));
 				return;
 			case "EXP":
-				values.push(exponentiate(left, right, options));
+				values.push(exponentiate(left, right, maxDecimals));
 				return;
 		}
 	};
@@ -971,15 +1047,10 @@ function evaluate(tokens, options = {}) {
 			ops.push(token.type);
 			break;
 		case "RPAREN": {
-			let foundMatch = false;
 			while (ops.length > 0) {
-				if (ops.at(-1) === "LPAREN") {
-					foundMatch = true;
-					break;
-				}
+				if (ops.at(-1) === "LPAREN") break;
 				applyOp(token.pos);
 			}
-			if (!foundMatch) throw new MismatchedParenthesisError(token.pos);
 			ops.pop();
 			const nextOp = ops.at(-1);
 			if (!nextOp) break;
@@ -1178,9 +1249,11 @@ const KNOWN_FUNCTIONS = /* @__PURE__ */ new Set([
 	"arctan",
 	"arctanh",
 	"ceil",
+	"cos",
 	"exp",
 	"floor",
 	"ln",
+	"sin",
 	"sqrt"
 ]);
 function isKnownFunctionName(name) {
@@ -1236,9 +1309,9 @@ function parse(tokens) {
 		let token = tokens[i];
 		const prev = tokens[i - 1];
 		if (token.type === "IDENTIFIER") token = resolveIdentifier(token);
-		const pos = token.pos;
+		const { pos, type } = token;
 		const isPrevOperand = isOperand(result.at(-1));
-		if (token.type === "PIPE") {
+		if (type === "PIPE") {
 			if (absStack > 0 && isPrevOperand) {
 				result.push({
 					type: "ABS_CLOSE",
@@ -1258,19 +1331,19 @@ function parse(tokens) {
 			absStack++;
 			continue;
 		}
-		if ((token.type === "LPAREN" || token.type === "FUNC" || token.type === "NUMBER" || token.type === "CONST") && isPrevOperand) result.push({
+		if ((type === "LPAREN" || type === "FUNC" || type === "NUMBER" || type === "CONST") && isPrevOperand) result.push({
 			type: "IMPLICIT_MUL",
 			pos
 		});
 		const prevParsed = result.at(-1);
 		if (isBinaryOperator(token) && isUnaryContext(prevParsed)) throw new UnexpectedOperatorError(`Unexpected operator '${getSym(token)}'`, token.pos);
-		if ((token.type === "FACTORIAL" || token.type === "RPAREN") && isUnaryContext(prevParsed)) {
+		if ((type === "FACTORIAL" || type === "RPAREN") && isUnaryContext(prevParsed)) {
 			if (!prevParsed) throw new UnexpectedOperatorError(`Unexpected '${getSym(token)}' at the beginning of expression`, token.pos);
 			throw new UnexpectedOperatorError(`Unexpected '${getSym(token)}' after '${getSym(prevParsed)}'`, 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({
-			type: token.type === "PLUS" ? "UNARY_PLUS" : "UNARY_MINUS",
+		if (prev && (prev.type === "NUMBER" || prev.type === "IDENTIFIER" && resolveIdentifier(prev).type === "CONST") && type === "NUMBER") throw new ParserError("Missing operator between numbers", token.pos);
+		if ((type === "PLUS" || type === "MINUS") && isUnaryContext(prevParsed)) result.push({
+			type: type === "PLUS" ? "UNARY_PLUS" : "UNARY_MINUS",
 			pos
 		});
 		else result.push(token);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picocalc",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -32,10 +32,10 @@
   "devDependencies": {
     "@gameroman/config": "0.3.0",
     "@types/bun": "1.4.4",
-    "oxfmt": "0.75.0",
-    "oxlint": "1.90.0",
-    "oxlint-tsgolint": "7.0.2005",
-    "tsdown": "0.23.4",
+    "oxfmt": "0.77.0",
+    "oxlint": "1.92.0",
+    "oxlint-tsgolint": "7.0.2006",
+    "tsdown": "0.23.5",
     "typescript": "7.0.2"
   }
 }