picocalc 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -1,18 +1,14 @@
 import "bigint.bitlength";
-//#region src/lib/types.d.ts
+type RoundingMode = "round" | "truncate";
 interface PrecisionOptions {
   readonly format?: "decimal" | "precise";
   readonly maxDecimals?: number;
-  readonly roundingMode?: "round" | "truncate";
+  readonly roundingMode?: RoundingMode;
 }
-//#endregion
-//#region src/lib/errors.d.ts
-declare class PicocalcErrror extends Error {
+export declare class PicocalcError extends Error {
   pos?: number;
   constructor(name: string, message: string, pos?: number);
 }
-//#endregion
-//#region src/index.d.ts
 interface CalculateOptions extends PrecisionOptions {
   decimalSeparator?: "." | ",";
 }
@@ -20,5 +16,4 @@ interface CalculateOptions extends PrecisionOptions {
  * The main entry point for the library.
  */
 declare function calculate(expression: string, options?: CalculateOptions): string;
-//#endregion
-export { PicocalcErrror, calculate };
+export { calculate };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import "bigint.bitlength";
-//#region src/lib/errors.ts
-var PicocalcErrror = class extends Error {
+// src/lib/errors.ts
+var PicocalcError = class extends Error {
 	pos;
 	constructor(name, message, pos) {
 		if (pos === void 0) super(message);
@@ -9,7 +9,7 @@ var PicocalcErrror = class extends Error {
 		this.name = name;
 	}
 };
-var InterpreterError = class extends PicocalcErrror {
+var InterpreterError = class extends PicocalcError {
 	constructor(message, pos) {
 		super("InterpreterError", message, pos);
 	}
@@ -39,39 +39,56 @@ var EmptyExpressionError = class extends InterpreterError {
 		super("Empty expression");
 	}
 };
+var InterpreterRangeError = class extends InterpreterError {
+	constructor(message) {
+		super(message);
+	}
+};
 var MismatchedParenthesisError = class extends InterpreterError {
 	constructor(pos, message = "Mismatched parenthesis") {
 		super(message, pos);
 	}
 };
-//#endregion
-//#region src/lib/types.ts
+// src/lib/options.ts
+const ROUNDING_MODE = "round";
+function getPrecisionDigits(maxDecimals) {
+	return Math.max(10, (maxDecimals ?? 30) + 10);
+}
+/**
+* Maximum allowed precision
+*/
+const MAX_PRECISION = 5e4;
+// 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
-};
-const ONE = {
-	n: 1n,
-	d: 1n
-};
-const constants = {
-	e: E,
-	pi: PI
-};
-function getConst(id) {
-	const c = constants[id];
+// src/lib/utils/e.ts
+function splitSeries(a, b) {
+	if (b - a === 1n) return {
+		n: 1n,
+		d: b
+	};
+	const mid = (a + b) / 2n;
+	const left = splitSeries(a, mid);
+	const right = splitSeries(mid, b);
+	return {
+		n: left.n * right.d + right.n,
+		d: left.d * right.d
+	};
+}
+function computeE(maxDecimals) {
+	let b = 1n;
+	let m = 1n;
+	const t = 10n ** BigInt(getPrecisionDigits(maxDecimals));
+	while (m < t) {
+		b++;
+		m *= b;
+	}
+	const { n, d } = splitSeries(0n, b);
 	return {
-		n: BigInt(c.replace(".", "")),
-		d: 10n ** BigInt(c.length - c.indexOf(".") - 1)
+		n: d + n,
+		d
 	};
 }
-//#endregion
-//#region src/lib/utils/gcd.ts
+// src/lib/utils/gcd.ts
 /**
 * The Euclidean GCD Algorithm for BigInt.
 */
@@ -88,9 +105,8 @@ function gcd(a, b) {
 	}
 	return a;
 }
-//#endregion
-//#region src/lib/utils/multiply.ts
-function multiply(a, b) {
+// src/lib/utils/multiply.ts
+function multiply(a, b, maxDecimals = 30) {
 	const aN = a.n;
 	const bN = b.n;
 	if (aN === 0n || bN === 0n) return ZERO;
@@ -116,9 +132,9 @@ function multiply(a, b) {
 		}, {
 			n: bE?.n ?? 1n,
 			d: bE?.d ?? 1n
-		}))
+		}, maxDecimals))
 	};
-	if (aC !== void 0 && bC !== void 0) return multiply(toSimpleFraction(a), toSimpleFraction(b));
+	if (aC !== void 0 && bC !== void 0) return multiply(toSimpleFraction(a, maxDecimals), toSimpleFraction(b, maxDecimals), maxDecimals);
 	return {
 		n,
 		d,
@@ -126,8 +142,7 @@ function multiply(a, b) {
 		e: aE ?? bE
 	};
 }
-//#endregion
-//#region src/lib/utils/nthroot.ts
+// src/lib/utils/nthroot.ts
 /**
 * Calculates the integer nth root of a BigInt.
 */
@@ -179,15 +194,15 @@ function nthRoot(v, n, precision) {
 			});
 		}
 	}
-	const precisionDigits = Math.max(10, (precision.maxDecimals ?? 30) * 3);
+	const precisionDigits = getPrecisionDigits(precision.maxDecimals);
 	const scaleFactor = 10n ** (BigInt(precisionDigits) * n);
+	const s = toSimpleFraction(v);
 	return simplify({
-		n: iNthRoot(v.n * scaleFactor / v.d, n),
+		n: iNthRoot(s.n * scaleFactor / s.d, n),
 		d: 10n ** BigInt(precisionDigits)
 	});
 }
-//#endregion
-//#region src/lib/utils/simplify.ts
+// src/lib/utils/simplify.ts
 /**
 * Reduces a fraction to its simplest form.
 */
@@ -195,7 +210,7 @@ function simplify(v) {
 	if (v.d === 0n) throw new DivisionByZeroError();
 	if (v.n === 0n) return ZERO;
 	if (v.d === 1n) {
-		if (v.e?.n === 0n) return {
+		if (v.e?.n === 0n || !v.c) return {
 			n: v.n,
 			d: v.d
 		};
@@ -205,7 +220,7 @@ function simplify(v) {
 	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 {
+	if (v.e?.n === 0n || !v.c) return {
 		n,
 		d
 	};
@@ -219,9 +234,12 @@ function simplify(v) {
 /**
 * Resolves any constants and exponents to return a simple fraction.
 */
-function toSimpleFraction(val) {
-	if (!val.c) return val;
-	const c = getConst(val.c);
+function toSimpleFraction(val, maxDecimals = 30) {
+	if (!val.c) return {
+		d: val.d,
+		n: val.n
+	};
+	const c = getConst(val.c, { maxDecimals });
 	const expN = val.e?.n ?? 1n;
 	const expD = val.e?.d ?? 1n;
 	const absExpN = expN < 0 ? -expN : expN;
@@ -233,11 +251,120 @@ function toSimpleFraction(val) {
 	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;
+	let currentTerm = xScaled;
+	let totalSum = xScaled;
+	let k = 1n;
+	while (true) {
+		currentTerm = currentTerm * xSqScaled / SCALE;
+		const denominatorFactor = 2n * k + 1n;
+		const termValue = currentTerm / denominatorFactor;
+		if (termValue === 0n) break;
+		if (k % 2n === 1n) totalSum -= termValue;
+		else totalSum += termValue;
+		k++;
+	}
+	return {
+		n: totalSum,
+		d: SCALE
+	};
+}
+function arctan(v, precision) {
+	const { n, d } = v;
+	if (n === 0n) return ZERO;
+	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) {
+		const pi = computePi(precision);
+		const subArctan = arctan({
+			n: absD,
+			d: absN
+		}, precision);
+		const resultNum = pi.n * subArctan.d - 2n * subArctan.n * pi.d;
+		const resultDen = 2n * pi.d * subArctan.d;
+		return simplify({
+			n: isNegative ? -resultNum : resultNum,
+			d: resultDen
+		});
+	}
+	if (absN * 2n > absD) {
+		const halfArctan = arctan({
+			n: 1n,
+			d: 2n
+		}, precision);
+		const remainderArctan = arctan({
+			n: 2n * absN - absD,
+			d: 2n * absD + absN
+		}, precision);
+		const resultNum = halfArctan.n * remainderArctan.d + remainderArctan.n * halfArctan.d;
+		const resultDen = halfArctan.d * remainderArctan.d;
+		return simplify({
+			n: isNegative ? -resultNum : resultNum,
+			d: resultDen
+		});
+	}
+	const r = rawArctanSeries(absN, absD, precision);
+	return simplify({
+		n: isNegative ? -r.n : r.n,
+		d: r.d
+	});
+}
+// src/lib/utils/pi.ts
+function computePi(precision) {
+	const p5 = arctan({
+		n: 1n,
+		d: 5n
+	}, precision);
+	const p239 = arctan({
+		n: 1n,
+		d: 239n
+	}, precision);
+	return simplify({
+		n: 16n * p5.n * p239.d - 4n * p239.n * p5.d,
+		d: p5.d * p239.d
 	});
 }
-//#endregion
-//#region src/lib/utils/add.ts
-function add(left, right, subtract = false) {
+// src/lib/utils/constants.ts
+const ZERO = {
+	n: 0n,
+	d: 1n
+};
+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);
+}
+// src/lib/utils/add.ts
+function add(left, right, maxDecimals = 30, subtract = false) {
 	const lN = left.n;
 	const rN = right.n;
 	if (lN === "OVERFLOW") return left;
@@ -269,7 +396,7 @@ function add(left, right, subtract = false) {
 		d = lD * mLeft;
 	}
 	if (n === 0n) return ZERO;
-	if (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left), toSimpleFraction(right), subtract);
+	if (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left, maxDecimals), toSimpleFraction(right, maxDecimals), maxDecimals, subtract);
 	return {
 		n,
 		d,
@@ -277,8 +404,104 @@ function add(left, right, subtract = false) {
 		e
 	};
 }
-//#endregion
-//#region src/lib/utils/ceil.ts
+// 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) {
+	let currentTerm = xScaled;
+	let totalSum = xScaled;
+	const xSqScaled = xScaled * xScaled / SCALE;
+	let k = 1n;
+	while (true) {
+		currentTerm = currentTerm * xSqScaled / SCALE;
+		const denominatorFactor = 2n * k + 1n;
+		const termValue = currentTerm / denominatorFactor;
+		if (termValue === 0n) break;
+		totalSum += termValue;
+		k++;
+	}
+	return totalSum;
+}
+function arctanh(v, precision) {
+	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;
+	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({
+		n: isNegative ? -sumScaled : sumScaled,
+		d: SCALE
+	});
+}
+// src/lib/utils/ceil.ts
 /**
 * Returns the smallest integer greater than or equal to the value.
 */
@@ -290,9 +513,8 @@ function ceil(v) {
 	const hasRemainder = n % d !== 0n;
 	return isPositive && hasRemainder ? result + 1n : result;
 }
-//#endregion
-//#region src/lib/utils/divide.ts
-function divide(left, right) {
+// src/lib/utils/divide.ts
+function divide(left, right, maxDecimals = 30) {
 	const lN = left.n;
 	const rN = right.n;
 	if (rN === 0n) throw new DivisionByZeroError();
@@ -314,7 +536,7 @@ function divide(left, right) {
 		}, {
 			n: rE?.n ?? 1n,
 			d: rE?.d ?? 1n
-		}, true))
+		}, maxDecimals, true))
 	};
 	const c = lC ?? rC;
 	let e;
@@ -336,59 +558,101 @@ function divide(left, right) {
 		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;
+// src/lib/utils/ln.ts
+function ln(v, precision) {
+	const { n, d, c, e } = v;
+	if (n <= 0n || d <= 0n) throw new InterpreterRangeError("Logarithm of non-positive number");
+	if (c === "e") 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 m = 0;
+	const isReciprocal = currentN * SCALE < currentD * SCALE;
+	if (currentN * SCALE < currentD * SCALE) {
+		currentN = d;
+		currentD = n;
 	}
-	return res;
+	while (currentN * SCALE >= 2n * currentD * SCALE) {
+		const val = sqrt({
+			n: currentN,
+			d: currentD
+		}, precision);
+		currentN = val.n;
+		currentD = val.d;
+		m++;
+	}
+	const at = arctanh({
+		n: currentN - currentD,
+		d: currentN + currentD
+	}, precision);
+	let rN = at.n * 2n;
+	if (m > 0) rN <<= BigInt(m);
+	if (isReciprocal) rN = -rN;
+	return simplify({
+		n: rN,
+		d: at.d
+	});
 }
-function isPerfectSquare(val) {
-	if (val < 0) return [false, 0n];
-	const root = isqrt(val);
-	return [root * root === val, root];
+// src/lib/utils/exp.ts
+function rawExp(v, precision) {
+	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 ln2Val = ln({
+		n: 2n,
+		d: 1n
+	}, precision);
+	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 factorial = 1n;
+	let i = 1n;
+	while (true) {
+		currentTerm = currentTerm * absRScaled / SCALE;
+		if (currentTerm === 0n) break;
+		factorial *= i;
+		const termVal = currentTerm / factorial;
+		if (termVal === 0n) break;
+		if (isNegativeR && i % 2n === 1n) sum -= termVal;
+		else sum += termVal;
+		i += 1n;
+	}
+	let finalNum = sum;
+	let finalDen = SCALE;
+	if (k > 0n) finalNum <<= k;
+	else if (k < 0n) finalDen <<= -k;
+	return {
+		n: finalNum,
+		d: finalDen
+	};
 }
-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
-			});
+function exp(v, precision) {
+	const { n, d, c } = v;
+	if (n === 0n) return ONE;
+	if (!c) return simplify({
+		n: 1n,
+		d: 1n,
+		c: "e",
+		e: {
+			n,
+			d
 		}
-	}
-	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)
 	});
+	return rawExp(toSimpleFraction(v, getPrecisionDigits(precision.maxDecimals)), precision);
 }
-//#endregion
-//#region src/lib/utils/exponentiate.ts
+// src/lib/utils/exponentiate.ts
 /**
 * Maximum digits allowed for the result of exponentiation
 */
@@ -398,40 +662,38 @@ function exponentiate(left, right, precision) {
 	if (rN === 0n) return ONE;
 	const lN = left.n;
 	if (lN === "OVERFLOW") return left;
-	const lD = left.d;
-	const c = left.c;
+	const { c, d: lD } = left;
 	if (lN === lD && c === void 0) return ONE;
 	if (rN === "OVERFLOW") return right;
-	if (lN === -lD && c === void 0) {
-		if (simplify(right).n % 2n) return {
+	const rS = simplify(right);
+	if (lN === -lD && c === void 0 && rS.d % 2n) {
+		if (rS.n % 2n) return {
 			n: -1n,
 			d: 1n
 		};
 		return ONE;
 	}
-	const normalizedExp = toSimpleFraction(simplify(right));
+	const normalizedExp = toSimpleFraction(rS, precision.maxDecimals);
+	const dExp = normalizedExp.d;
 	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 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;
+		}
 	}
 	const eN = (left.e?.n ?? 1n) * exponent;
 	let baseN = lN;
@@ -463,8 +725,7 @@ function exponentiate(left, right, precision) {
 	if (dExp === 2n) return sqrt(v, precision);
 	return nthRoot(v, dExp, precision);
 }
-//#endregion
-//#region src/lib/utils/factorial.ts
+// src/lib/utils/factorial.ts
 function binaryProduct(arr, low, high) {
 	if (low > high) return 1n;
 	if (low === high) return arr[low];
@@ -504,8 +765,7 @@ function factorial(n) {
 	}
 	return binaryProduct(primePowers, 0, primePowers.length - 1);
 }
-//#endregion
-//#region src/lib/utils/floor.ts
+// src/lib/utils/floor.ts
 /**
 * Returns the largest integer less than or equal to the value.
 */
@@ -517,8 +777,7 @@ function floor(v) {
 	const hasRemainder = n % d !== 0n;
 	return isNegative && hasRemainder ? result - 1n : result;
 }
-//#endregion
-//#region src/lib/utils/mod.ts
+// src/lib/utils/mod.ts
 /**
 * Calculates remainder of division.
 */
@@ -532,8 +791,7 @@ function mod(a, b) {
 		d
 	};
 }
-//#endregion
-//#region src/lib/interpreter.ts
+// src/lib/interpreter.ts
 const precedence = {
 	LPAREN: 0,
 	ABS_OPEN: 0,
@@ -546,99 +804,94 @@ const precedence = {
 	UNARY_MINUS: 4,
 	EXP: 6,
 	IMPLICIT_MUL: 6,
-	ABS_FN: 8,
-	CEIL_FN: 8,
-	FLOOR_FN: 8,
-	SQRT_FN: 8,
+	FN_CALL: 8,
 	FACTORIAL: 10
 };
 function isFunctionOp(op) {
-	return op === "ABS_FN" || op === "CEIL_FN" || op === "FLOOR_FN" || op === "SQRT_FN";
+	return typeof op === "object";
 }
 function isUnaryOperation(op) {
 	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || isFunctionOp(op);
 }
-/**
-* Maximum allowed precision
-*/
-const MAX_PRECISION = 5e4;
-/**
-* Maximum allowed factorial
-*/
-const MAX_FACTORIAL = 2e4;
-/**
-* Maximum allowed exponent for scientific number notation
-*/
-const MAX_SCIENTIFIC_NUMBER_EXPONENT = 3e5;
+function getOpPrecedence(op) {
+	if (typeof op === "object") return precedence.FN_CALL;
+	return precedence[op];
+}
 function evaluate(tokens, options = {}) {
 	if (tokens.length === 0) throw new EmptyExpressionError();
+	const { maxDecimals } = options;
 	const values = [];
 	const ops = [];
 	const applyOp = (pos) => {
 		const op = ops.pop();
-		if (!op || op === "LPAREN" || op === "ABS_OPEN") return;
+		if (!op || op === "LPAREN" || op === "ABS_OPEN" || op === "UNARY_PLUS") return;
 		const right = values.pop();
-		if (isUnaryOperation(op)) switch (op) {
-			case "UNARY_PLUS":
-				values.push(right);
-				return;
-			case "UNARY_MINUS": {
-				const rN = right.n;
-				if (rN === "OVERFLOW") {
-					values.push(OverflowValue);
+		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;
-				}
-				values.push({
-					...right,
-					n: -rN
-				});
+			}
+			const { id } = op;
+			if (id === "sqrt") {
+				values.push(sqrt(right, options));
 				return;
 			}
-			case "ABS_FN": {
-				const rN = right.n;
-				if (rN === "OVERFLOW") {
-					values.push(OverflowValue);
-					return;
-				}
-				const n = rN < 0 ? -rN : rN;
-				values.push({
-					...right,
-					n
-				});
+			if (rN === "OVERFLOW") {
+				values.push(OverflowValue);
 				return;
 			}
-			case "CEIL_FN":
-				if (right.n === "OVERFLOW") {
-					values.push(OverflowValue);
+			switch (id) {
+				case "abs": {
+					const n = rN < 0 ? -rN : rN;
+					values.push({
+						...right,
+						n
+					});
 					return;
 				}
-				values.push({
-					n: ceil(toSimpleFraction(right)),
-					d: 1n
-				});
-				return;
-			case "FLOOR_FN":
-				if (right.n === "OVERFLOW") {
-					values.push(OverflowValue);
+				case "ceil":
+					values.push({
+						n: ceil(toSimpleFraction(right, maxDecimals)),
+						d: 1n
+					});
 					return;
-				}
-				values.push({
-					n: floor(toSimpleFraction(right)),
-					d: 1n
-				});
-				return;
-			case "SQRT_FN":
-				values.push(sqrt(right, options));
-				return;
+				case "floor":
+					values.push({
+						n: floor(toSimpleFraction(right, maxDecimals)),
+						d: 1n
+					});
+					return;
+				case "arctan":
+					values.push(arctan(toSimpleFraction(right, maxDecimals), options));
+					return;
+				case "arctanh":
+					values.push(arctanh(toSimpleFraction(right, maxDecimals), options));
+					return;
+				case "ln":
+					values.push(ln(right, options));
+					return;
+				case "exp":
+					values.push(exp(right, options));
+					return;
+			}
 		}
 		if (op === "FACTORIAL") {
 			if (right.n === "OVERFLOW") {
 				values.push(OverflowValue);
 				return;
 			}
-			const reduced = simplify(right);
+			const reduced = toSimpleFraction(simplify(right));
 			if (reduced.d !== 1n || reduced.n < 0) throw new NotImplementedError("Factorial is only implemented for non-negative integers.", pos);
-			if (reduced.n >= MAX_FACTORIAL) {
+			if (reduced.n >= 2e4) {
 				values.push(OverflowValue);
 				return;
 			}
@@ -652,21 +905,21 @@ function evaluate(tokens, options = {}) {
 		switch (op) {
 			case "ADD":
 			case "SUBTRACT":
-				values.push(add(left, right, op === "SUBTRACT"));
+				values.push(add(left, right, maxDecimals, op === "SUBTRACT"));
 				return;
 			case "MULTIPLY":
 			case "IMPLICIT_MUL":
-				values.push(multiply(left, right));
+				values.push(multiply(left, right, maxDecimals));
 				return;
 			case "DIVIDE":
-				values.push(divide(left, right));
+				values.push(divide(left, right, maxDecimals));
 				return;
 			case "MOD":
 				if (left.n === "OVERFLOW" || right.n === "OVERFLOW") {
 					values.push(OverflowValue);
 					return;
 				}
-				values.push(mod(left, right));
+				values.push(mod(toSimpleFraction(left), toSimpleFraction(right)));
 				return;
 			case "EXP":
 				values.push(exponentiate(left, right, options));
@@ -676,20 +929,20 @@ function evaluate(tokens, options = {}) {
 	const pushOpWithPrecedence = (currentOp, pos) => {
 		const isUnary = isUnaryOperation(currentOp);
 		const isRightAssociative = currentOp === "EXP" || currentOp === "IMPLICIT_MUL";
-		while (ops.length > 0 && !isUnary && (isRightAssociative ? precedence[ops.at(-1)] > precedence[currentOp] : precedence[ops.at(-1)] >= precedence[currentOp])) applyOp(pos);
+		while (ops.length > 0 && !isUnary && (isRightAssociative ? getOpPrecedence(ops.at(-1)) > getOpPrecedence(currentOp) : getOpPrecedence(ops.at(-1)) >= getOpPrecedence(currentOp))) applyOp(pos);
 		ops.push(currentOp);
 	};
 	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);
+			if (fl > 5e4) 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);
+				if (token.exponent.length > 5e4) throw new MaximumPrecisionError(token.exponent.length, MAX_PRECISION);
 				const expValue = BigInt(token.exponent);
-				if (expValue > MAX_SCIENTIFIC_NUMBER_EXPONENT) {
+				if (expValue > 3e5) {
 					values.push(OverflowValue);
 					break;
 				}
@@ -707,12 +960,11 @@ function evaluate(tokens, options = {}) {
 			break;
 		}
 		case "CONST":
-			if (options.format === "precise") values.push({
+			values.push({
 				n: 1n,
 				d: 1n,
 				c: token.id
 			});
-			else values.push(getConst(token.id));
 			break;
 		case "LPAREN":
 		case "ABS_OPEN":
@@ -774,22 +1026,7 @@ function evaluate(tokens, options = {}) {
 		case "MOD":
 			pushOpWithPrecedence(token.type, 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;
+		case "FUNC": pushOpWithPrecedence(token, token.pos);
 	}
 	while (ops.length > 0) {
 		const top = ops.at(-1);
@@ -804,9 +1041,8 @@ function evaluate(tokens, options = {}) {
 	if (finalValue.n === "OVERFLOW") throw new OverflowError();
 	return simplify(finalValue);
 }
-//#endregion
-//#region src/lib/lexer.ts
-var LexerError = class extends PicocalcErrror {
+// src/lib/lexer.ts
+var LexerError = class extends PicocalcError {
 	constructor(message, pos) {
 		super("LexerError", message, pos);
 	}
@@ -912,8 +1148,7 @@ function tokenize(expression, options = {}) {
 	}
 	return tokens;
 }
-//#endregion
-//#region src/lib/symbol.ts
+// src/lib/symbol.ts
 const symbolMap = {
 	PLUS: "+",
 	UNARY_PLUS: "+",
@@ -937,8 +1172,20 @@ function getSym(t) {
 	if (t.type === "IDENTIFIER" || t.type === "FUNC" || t.type === "CONST") return t.id;
 	return symbolMap[t.type];
 }
-//#endregion
-//#region src/lib/parser.ts
+// src/lib/parser.ts
+const KNOWN_FUNCTIONS = /* @__PURE__ */ new Set([
+	"abs",
+	"arctan",
+	"arctanh",
+	"ceil",
+	"exp",
+	"floor",
+	"ln",
+	"sqrt"
+]);
+function isKnownFunctionName(name) {
+	return KNOWN_FUNCTIONS.has(name);
+}
 /**
 * Helper: Is the last token an "operand" (something that can be followed by a closing pipe or implicit mul)?
 */
@@ -952,7 +1199,7 @@ function isBinaryOperator(token) {
 function isUnaryContext(last) {
 	return !isOperand(last);
 }
-var ParserError = class extends PicocalcErrror {
+var ParserError = class extends PicocalcError {
 	constructor(message, pos) {
 		super("ParserError", message, pos);
 	}
@@ -974,7 +1221,7 @@ function resolveIdentifier(token) {
 		id: token.id,
 		pos
 	};
-	if (token.id === "abs" || token.id === "ceil" || token.id === "floor" || token.id === "sqrt") return {
+	if (isKnownFunctionName(token.id)) return {
 		type: "FUNC",
 		id: token.id,
 		pos
@@ -1041,8 +1288,20 @@ function parse(tokens) {
 	].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
+// src/lib/decimals.ts
+function toDecimal({ n, d }, { maxDecimals = 30, roundingMode = ROUNDING_MODE }) {
+	if (d === 0n) throw new Error("Division by zero");
+	if (n === 0n) return "0";
+	const isNegative = n < 0n;
+	let resultStr = (((isNegative ? -n : n) * 10n ** BigInt(maxDecimals) + (roundingMode === "round" ? d / 2n : 0n)) / d).toString();
+	if (resultStr.length <= maxDecimals) resultStr = resultStr.padStart(maxDecimals + 1, "0");
+	const splitIdx = resultStr.length - maxDecimals;
+	const integerPart = resultStr.slice(0, splitIdx);
+	const fractionalPart = resultStr.slice(splitIdx).replace(/0+$/, "");
+	const finalResult = fractionalPart ? `${integerPart}.${fractionalPart}` : integerPart;
+	return (isNegative && finalResult !== "0" ? "-" : "") + finalResult;
+}
+// src/utils/format-result.ts
 function getConstantStr(coeff, c, e) {
 	if (coeff === 0n) return "0";
 	if (!c) return `${coeff}`;
@@ -1077,26 +1336,14 @@ function formatPrecise(v) {
 * Converts Result to a Decimal or Fraction String.
 */
 function formatResult(v, options = {}) {
-	const { n, d } = v;
 	if (options.format === "precise") return formatPrecise(v);
-	const { maxDecimals = 30, roundingMode = "round" } = options;
-	const isNegative = n < 0;
-	const factor = 10n ** BigInt(maxDecimals);
-	let resultStr = (((isNegative ? -n : n) * factor + (roundingMode === "round" ? d / 2n : 0n)) / d).toString();
-	if (resultStr.length <= maxDecimals) resultStr = resultStr.padStart(maxDecimals + 1, "0");
-	const splitIdx = resultStr.length - maxDecimals;
-	const integerPart = resultStr.slice(0, splitIdx);
-	const fractionalPart = resultStr.slice(splitIdx).replace(/0+$/, "");
-	const finalResult = fractionalPart ? `${integerPart}.${fractionalPart}` : integerPart;
-	return (isNegative && finalResult !== "0" ? "-" : "") + finalResult;
+	return toDecimal(toSimpleFraction(v, options.maxDecimals), options);
 }
-//#endregion
-//#region src/index.ts
+// src/index.ts
 /**
 * The main entry point for the library.
 */
 function calculate(expression, options) {
 	return formatResult(evaluate(parse(tokenize(expression, options)), options), options);
 }
-//#endregion
-export { PicocalcErrror, calculate };
+export { PicocalcError, calculate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picocalc",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,12 +30,12 @@
     "bigint.bitlength": "0.2.0"
   },
   "devDependencies": {
-    "@gameroman/config": "0.2.5",
-    "@types/bun": "1.3.14",
-    "oxfmt": "0.58.0",
-    "oxlint": "1.73.0",
-    "oxlint-tsgolint": "0.24.0",
-    "tsdown": "0.22.7",
-    "typescript": "6.0.3"
+    "@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",
+    "typescript": "7.0.2"
   }
 }