@classytic/stage 0.2.0 → 0.4.0

package/dist/math/complex.mjs

@@ -0,0 +1,239 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+
+//#region src/math/complex.ts
+var complex_exports = /* @__PURE__ */ __exportAll({
+	DEG2RAD: () => DEG2RAD,
+	I: () => I,
+	MAX_POW: () => MAX_POW,
+	MAX_ROOTS: () => 360,
+	ONE: () => ONE,
+	RAD2DEG: () => RAD2DEG,
+	TWO_PI: () => TWO_PI,
+	ZERO: () => ZERO,
+	abs: () => abs,
+	add: () => add,
+	arg: () => arg,
+	argDeg: () => argDeg,
+	conj: () => conj,
+	cx: () => cx,
+	div: () => div,
+	eq: () => eq,
+	fromPolar: () => fromPolar,
+	iPow: () => iPow,
+	isFiniteC: () => isFiniteC,
+	mul: () => mul,
+	neg: () => neg,
+	nthRoots: () => nthRoots,
+	omega: () => omega,
+	powInt: () => powInt,
+	rootsOfUnity: () => rootsOfUnity,
+	scale: () => scale,
+	sub: () => sub,
+	toPolar: () => toPolar,
+	toStr: () => toStr,
+	toTex: () => toTex
+});
+const TWO_PI = Math.PI * 2;
+const RAD2DEG = 180 / Math.PI;
+const DEG2RAD = Math.PI / 180;
+/** Hard caps so an authored value can never blow memory or hang a loop. */
+const MAX_POW = 1024;
+const MAX_ROOTS = 360;
+const cx = (re, im = 0) => ({
+	re,
+	im
+});
+const ZERO = {
+	re: 0,
+	im: 0
+};
+const ONE = {
+	re: 1,
+	im: 0
+};
+const I = {
+	re: 0,
+	im: 1
+};
+const isFiniteC = (z) => Number.isFinite(z.re) && Number.isFinite(z.im);
+const add = (a, b) => ({
+	re: a.re + b.re,
+	im: a.im + b.im
+});
+const sub = (a, b) => ({
+	re: a.re - b.re,
+	im: a.im - b.im
+});
+const neg = (a) => ({
+	re: -a.re,
+	im: -a.im
+});
+const conj = (a) => ({
+	re: a.re,
+	im: -a.im
+});
+const scale = (a, k) => ({
+	re: a.re * k,
+	im: a.im * k
+});
+/** (a+bi)(c+di) = (ac − bd) + (ad + bc)i. */
+const mul = (a, b) => ({
+	re: a.re * b.re - a.im * b.im,
+	im: a.re * b.im + a.im * b.re
+});
+/**
+* Complex division via Smith's algorithm: divide through by the LARGER of the
+* denominator's components so the intermediate ratio stays in [−1, 1] (no
+* overflow when |b| is huge, no underflow when tiny). Returns an ∞/NaN complex
+* for a (near-)zero denominator rather than throwing.
+*/
+function div(a, b) {
+	const { re: c, im: d } = b;
+	if (c === 0 && d === 0) return {
+		re: a.re / 0,
+		im: a.im / 0
+	};
+	if (Math.abs(c) >= Math.abs(d)) {
+		const r = d / c, den = c + d * r;
+		return {
+			re: (a.re + a.im * r) / den,
+			im: (a.im - a.re * r) / den
+		};
+	}
+	const r = c / d, den = c * r + d;
+	return {
+		re: (a.re * r + a.im) / den,
+		im: (a.im * r - a.re) / den
+	};
+}
+/** Modulus |z| = √(re² + im²), via hypot so large components don't overflow. */
+const abs = (z) => Math.hypot(z.re, z.im);
+/** Argument arg(z) in RADIANS, in (−π, π]. arg(0) = 0 by convention. */
+const arg = (z) => z.re === 0 && z.im === 0 ? 0 : Math.atan2(z.im, z.re);
+/** Argument in DEGREES, in (−180, 180]. */
+const argDeg = (z) => arg(z) * RAD2DEG;
+/** Polar → rectangular: r·e^{iθ} = r(cosθ + i sinθ), θ in radians. */
+const fromPolar = (r, theta) => ({
+	re: r * Math.cos(theta),
+	im: r * Math.sin(theta)
+});
+/** Rectangular → polar { r, theta(rad) }. */
+const toPolar = (z) => ({
+	r: abs(z),
+	theta: arg(z)
+});
+/**
+* iⁿ for any integer n, EXACTLY (no De Moivre float drift): the 4-cycle
+* 1, i, −1, −i. Negative n handled by the (n mod 4 + 4) mod 4 normalisation.
+*/
+function iPow(n) {
+	if (!Number.isInteger(n)) return {
+		re: NaN,
+		im: NaN
+	};
+	switch ((n % 4 + 4) % 4) {
+		case 0: return {
+			re: 1,
+			im: 0
+		};
+		case 1: return {
+			re: 0,
+			im: 1
+		};
+		case 2: return {
+			re: -1,
+			im: 0
+		};
+		default: return {
+			re: 0,
+			im: -1
+		};
+	}
+}
+/**
+* zⁿ for an INTEGER n via exponentiation-by-squaring (negative n inverts).
+* |n| is capped at MAX_POW; an overflowing magnitude returns an explicit ∞
+* complex (finite check) instead of looping into garbage.
+*/
+function powInt(z, n) {
+	if (!Number.isInteger(n)) return {
+		re: NaN,
+		im: NaN
+	};
+	if (Math.abs(n) > 1024) return {
+		re: Infinity,
+		im: Infinity
+	};
+	if (n === 0) return { ...ONE };
+	let base = n < 0 ? div(ONE, z) : z;
+	let e = Math.abs(n);
+	let acc = { ...ONE };
+	while (e > 0) {
+		if (e & 1) acc = mul(acc, base);
+		e >>= 1;
+		if (e > 0) base = mul(base, base);
+		if (!isFiniteC(acc)) return {
+			re: Infinity,
+			im: Infinity
+		};
+	}
+	return acc;
+}
+/** Clamp an nth-root count to a safe, sane range [1, MAX_ROOTS]. */
+const safeN = (n) => Number.isInteger(n) && n >= 1 ? Math.min(n, 360) : 1;
+/**
+* The n nth-roots of UNITY: e^{2πik/n}, k = 0…n−1 (so ω = roots[1] is the
+* primitive root). For n = 2 → {1, −1}; n = 3 → {1, ω, ω²}; n = 4 → {1, i, −1, −i}.
+* n is clamped to [1, MAX_ROOTS]. The k = n/2 (real −1) and k = 0 (real 1) entries
+* are snapped to exact values so labels read cleanly.
+*/
+function rootsOfUnity(n) {
+	const m = safeN(n);
+	return Array.from({ length: m }, (_, k) => {
+		if (k === 0) return {
+			re: 1,
+			im: 0
+		};
+		if (m % 2 === 0 && k === m / 2) return {
+			re: -1,
+			im: 0
+		};
+		return fromPolar(1, TWO_PI * k / m);
+	});
+}
+/** The n nth-roots of any z: |z|^{1/n} · e^{i(arg z + 2πk)/n}, k = 0…n−1. */
+function nthRoots(z, n) {
+	const m = safeN(n);
+	const { r, theta } = toPolar(z);
+	const root = Math.pow(r, 1 / m);
+	return Array.from({ length: m }, (_, k) => fromPolar(root, (theta + TWO_PI * k) / m));
+}
+/** The primitive nth root of unity ω (default the CUBE root, n = 3): e^{2πi/n}.
+*  For n = 3: ω = −½ + (√3/2)i, with ω³ = 1 and 1 + ω + ω² = 0. */
+const omega = (n = 3) => fromPolar(1, TWO_PI / safeN(n));
+/** Equal within a tolerance (default 1e-9), on both components. */
+const eq = (a, b, eps = 1e-9) => Math.abs(a.re - b.re) <= eps && Math.abs(a.im - b.im) <= eps;
+const numStr = (n, dp) => {
+	if (!Number.isFinite(n)) return n > 0 ? "∞" : "−∞";
+	const r = Math.round(n * 10 ** dp) / 10 ** dp;
+	return Object.is(r, -0) ? "0" : String(r).replace(/^-/, "−");
+};
+/** Plain string, e.g. "3 − 2i", "i", "−1", "0", "2i". */
+function toStr(z, dp = 2) {
+	if (!isFiniteC(z)) return "∞";
+	const re = Math.round(z.re * 10 ** dp) / 10 ** dp;
+	const im = Math.round(z.im * 10 ** dp) / 10 ** dp;
+	if (im === 0) return numStr(re, dp);
+	const imPart = im === 1 ? "i" : im === -1 ? "−i" : `${numStr(Math.abs(im), dp)}i`;
+	if (re === 0) return im < 0 && im !== -1 ? `−${imPart}` : im === -1 ? "−i" : imPart;
+	const sign = im < 0 ? "−" : "+";
+	const mag = Math.abs(im) === 1 ? "i" : `${numStr(Math.abs(im), dp)}i`;
+	return `${numStr(re, dp)} ${sign} ${mag}`;
+}
+/** LaTeX form for <Tex> (uses real minus signs, "i"). */
+function toTex(z, dp = 2) {
+	return toStr(z, dp).replace(/−/g, "-");
+}
+
+//#endregion
+export { ONE, ZERO, abs, add, complex_exports, cx, div, fromPolar, isFiniteC, mul, sub, toStr };

package/dist/math/expr.d.mts

@@ -0,0 +1,23 @@
+import { Node } from "./ast.mjs";
+
+//#region src/math/expr.d.ts
+interface CompiledExpr {
+  /** Evaluate against a scope of variable values (unknown vars → NaN). */
+  readonly fn: (scope: Record<string, number>) => number;
+  /** Free variables referenced (excludes constants & functions), e.g. `['x','a']`. */
+  readonly vars: string[];
+  /** The parsed syntax tree, for differentiation, LaTeX, or analysis. */
+  readonly ast: Node;
+  readonly error?: undefined;
+}
+interface ExprError {
+  readonly error: string;
+  readonly fn?: undefined;
+  readonly vars?: undefined;
+  readonly ast?: undefined;
+}
+type ExprResult = CompiledExpr | ExprError;
+/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
+declare function compileExpr(src: string): ExprResult;
+//#endregion
+export { CompiledExpr, ExprError, ExprResult, compileExpr };

package/dist/math/expr.mjs

@@ -0,0 +1,36 @@
+import { evaluate, freeVars } from "./ast.mjs";
+import { parse } from "./parse.mjs";
+
+//#region src/math/expr.ts
+/**
+* compileExpr, the stable entry point to the engine: a formula string in, a fast evaluator plus
+* the free variables and the parsed AST out.
+*
+* It NEVER THROWS. `parse` throws on bad input, which is correct for a parser and wrong for the
+* call site that matters here: an author or a student typing into a field, where a thrown error
+* would take the lab down mid-keystroke. So the result is a union, `{ fn, vars, ast }` or
+* `{ error }`, discriminated by an optional `error` on both arms so `if (c.error)` narrows without
+* a type guard.
+*
+* This lived in `index.ts` until the answer checker needed it, which would have made the barrel
+* import a file that imports the barrel. Implementation in a barrel is a circular import waiting
+* for its second consumer.
+*/
+/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
+function compileExpr(src) {
+	if (!src || !src.trim()) return { error: "Empty expression" };
+	let ast;
+	try {
+		ast = parse(src);
+	} catch (e) {
+		return { error: e instanceof Error ? e.message : "Parse error" };
+	}
+	return {
+		fn: (scope) => evaluate(ast, scope),
+		vars: [...freeVars(ast)],
+		ast
+	};
+}
+
+//#endregion
+export { compileExpr };

package/dist/math/index.d.mts

@@ -1,27 +1,13 @@
 import { BinOp, Node, compileNode, evaluate, freeVars } from "./ast.mjs";
 import { parse } from "./parse.mjs";
-import { differentiate, simplify } from "./calculus.mjs";
+import { isolate, occurrences } from "./rearrange.mjs";
+import { definiteIntegral, differentiate, integrate, simplify } from "./calculus.mjs";
 import { CompiledFn, compile } from "./compile.mjs";
 import { toLatex } from "./latex.mjs";
-
-//#region src/math/index.d.ts
-interface CompiledExpr {
-  /** Evaluate against a scope of variable values (unknown vars → NaN). */
-  readonly fn: (scope: Record<string, number>) => number;
-  /** Free variables referenced (excludes constants & functions), e.g. `['x','a']`. */
-  readonly vars: string[];
-  /** The parsed syntax tree, for differentiation, LaTeX, or analysis. */
-  readonly ast: Node;
-  readonly error?: undefined;
-}
-interface ExprError {
-  readonly error: string;
-  readonly fn?: undefined;
-  readonly vars?: undefined;
-  readonly ast?: undefined;
-}
-type ExprResult = CompiledExpr | ExprError;
-/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
-declare function compileExpr(src: string): ExprResult;
-//#endregion
-export { type BinOp, CompiledExpr, type CompiledFn, ExprError, ExprResult, type Node, compile, compileExpr, compileNode, differentiate, evaluate, freeVars, parse, simplify, toLatex };
+import { CompiledExpr, ExprError, ExprResult, compileExpr } from "./expr.mjs";
+import { Complex, complex_d_exports } from "./complex.mjs";
+import { Poly, PolyRoots, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, polyRoots, polyTex, poly_d_exports, solveEquation, trim } from "./poly.mjs";
+import { PolySolution, polyCoeffs, solutionTex, solvePoly } from "./solve.mjs";
+import { Fn1, Line, areaBetween, intersections, normalAt, quadrature, roots, tangentAt } from "./analysis.mjs";
+import { AnswerSpec, ExprCheckOpts, checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue } from "./answer-check.mjs";
+export { type AnswerSpec, type BinOp, type CompiledExpr, type CompiledFn, type Complex, type ExprCheckOpts, type ExprError, type ExprResult, type Fn1, type Line, type Node, type Poly, type PolyRoots, type PolySolution, allRoots, areaBetween, checkAnswer, checkExpression, checkNumber, compile, compileExpr, compileNode, complex_d_exports as complex, definiteIntegral, deflate, degree, deriv, differentiate, evalC, evalPoly, evaluate, factorTex, freeVars, fromAst, integrate, intersections, isolate, normalAt, normalizeMathInput, occurrences, parse, parseValue, poly_d_exports as poly, polyCoeffs, polyRoots, polyTex, quadrature, roots, simplify, solutionTex, solveEquation, solvePoly, tangentAt, toLatex, trim };

package/dist/math/index.mjs

@@ -1,43 +1,14 @@
 import { compileNode, evaluate, freeVars } from "./ast.mjs";
 import { parse } from "./parse.mjs";
-import { differentiate, simplify } from "./calculus.mjs";
+import { isolate, occurrences } from "./rearrange.mjs";
+import { definiteIntegral, differentiate, integrate, simplify } from "./calculus.mjs";
 import { compile } from "./compile.mjs";
 import { toLatex } from "./latex.mjs";
+import { compileExpr } from "./expr.mjs";
+import { complex_exports } from "./complex.mjs";
+import { allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, polyRoots, polyTex, poly_exports, solveEquation, trim } from "./poly.mjs";
+import { polyCoeffs, solutionTex, solvePoly } from "./solve.mjs";
+import { areaBetween, intersections, normalAt, quadrature, roots, tangentAt } from "./analysis.mjs";
+import { checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue } from "./answer-check.mjs";
 
-//#region src/math/index.ts
-/**
-* expr, a tiny, safe, dependency-free symbolic math engine.
-*
-* Pipeline: `tokenize → parse (AST) → evaluate`. On top of the AST it offers
-* exact `differentiate`, `simplify`, and `toLatex`, so the same typed formula
-* can be plotted, differentiated for an exact tangent, and rendered beautifully.
-* No `eval`/`new Function`.
-*
-* `compileExpr(src)` is the stable, simple entry point (returns a fast `fn` plus
-* the free `vars` and the parsed `ast`); the lower-level pieces are exported for
-* widgets that need the tree (derivative explorers, LaTeX labels, step-by-step).
-*
-* Supports: numbers (incl. `1.5e3`), variable `x` + named params, constants
-* (`pi`/`e`/`tau`), operators `+ - * / % ^` (^ right-assoc) and unary minus,
-* implicit multiplication (`2x`, `3sin(x)`), and functions `sin cos tan cot sec
-* csc asin acos atan sinh cosh tanh sqrt cbrt abs exp ln log log2 log10 floor
-* ceil round sign` (+ 2-arg `pow atan2 min max mod hypot`).
-*/
-/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
-function compileExpr(src) {
-	if (!src || !src.trim()) return { error: "Empty expression" };
-	let ast;
-	try {
-		ast = parse(src);
-	} catch (e) {
-		return { error: e instanceof Error ? e.message : "Parse error" };
-	}
-	return {
-		fn: (scope) => evaluate(ast, scope),
-		vars: [...freeVars(ast)],
-		ast
-	};
-}
-
-//#endregion
-export { compile, compileExpr, compileNode, differentiate, evaluate, freeVars, parse, simplify, toLatex };
+export { allRoots, areaBetween, checkAnswer, checkExpression, checkNumber, compile, compileExpr, compileNode, complex_exports as complex, definiteIntegral, deflate, degree, deriv, differentiate, evalC, evalPoly, evaluate, factorTex, freeVars, fromAst, integrate, intersections, isolate, normalAt, normalizeMathInput, occurrences, parse, parseValue, poly_exports as poly, polyCoeffs, polyRoots, polyTex, quadrature, roots, simplify, solutionTex, solveEquation, solvePoly, tangentAt, toLatex, trim };

package/dist/math/latex.mjs

@@ -81,8 +81,9 @@ function texP(node) {
 				prec: 2
 			};
 			const sep = node.right.type === "num" ? " \\cdot " : "";
+			const right = node.right.type === "neg" ? `\\left(${texP(node.right).s}\\right)` : wrap(node.right, 2);
 			return {
-				s: `${wrap(node.left, 2)}${sep}${wrap(node.right, 2)}`,
+				s: `${wrap(node.left, 2)}${sep}${right}`,
 				prec: 2
 			};
 		}
@@ -103,6 +104,14 @@ function texCall(node) {
 	if (node.fn === "cbrt") return `\\sqrt[3]{${wrap(a0, 0)}}`;
 	if (node.fn === "abs") return `\\left|${wrap(a0, 0)}\\right|`;
 	if (node.fn === "exp") return `e^{${wrap(a0, 0)}}`;
+	/**
+	* `ln|x|`, not `ln(|x|)`.
+	*
+	* The modulus bars already delimit the argument, so the usual parentheses double up. Every
+	* textbook and mark scheme writes the integral of 1/x as ln|x|, and that is the form a learner
+	* has to reproduce, so it is the form to show.
+	*/
+	if ((node.fn === "ln" || node.fn === "log") && a0.type === "call" && a0.fn === "abs" && a0.args[0]) return `\\${node.fn}\\left|${wrap(a0.args[0], 0)}\\right|`;
 	const args = node.args.map((a) => wrap(a, 0)).join(", ");
 	return `${NAMED_FN.has(node.fn) ? `\\${node.fn}` : `\\operatorname{${node.fn}}`}\\left(${args}\\right)`;
 }

package/dist/math/parse.mjs

@@ -1,6 +1,6 @@
 import { arityOf } from "./defs.mjs";
-import { tokenize } from "./tokenize.mjs";
 import { bin, call, neg, num, variable } from "./ast.mjs";
+import { tokenize } from "./tokenize.mjs";
 
 //#region src/math/parse.ts
 /**

package/dist/math/poly.d.mts

@@ -0,0 +1,55 @@
+import { Node } from "./ast.mjs";
+import { Complex } from "./complex.mjs";
+
+//#region src/math/poly.d.ts
+declare namespace poly_d_exports {
+  export { Poly, PolyRoots, add, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyRoots, polyTex, solveEquation, trim };
+}
+type Poly = number[];
+declare const trim: (p: Poly) => Poly;
+declare const degree: (p: Poly) => number;
+/** Horner evaluation (real). */
+declare function evalPoly(p: Poly, x: number): number;
+/** Horner evaluation (complex). */
+declare function evalC(p: Poly, z: Complex): Complex;
+/** Derivative polynomial. */
+declare const deriv: (p: Poly) => Poly;
+declare function add(a: Poly, b: Poly): Poly;
+declare function mul(a: Poly, b: Poly): Poly;
+/** Synthetic division of p by (x − r); returns the quotient (assumes r is a root,
+ *  i.e. drops the remainder). The "divide out a found factor" step. */
+declare function deflate(p: Poly, r: number): Poly;
+/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
+declare function polyTex(p0: Poly, x?: string): string;
+/** Coefficients of `node` as a polynomial in `x` (other vars from `params`), or
+ *  null if it isn't a polynomial in x (sin(x), 1/x, fractional power, …). */
+declare function fromAst(node: Node, x?: string, params?: Record<string, number>): Poly | null;
+/**
+ * All complex roots of `p` via Durand–Kerner simultaneous iteration (then snapped).
+ * For a degree-n polynomial returns n roots; real roots come back with im = 0.
+ */
+declare function allRoots(p0: Poly): Complex[];
+interface PolyRoots {
+  poly: Poly;
+  degree: number;
+  roots: Complex[];
+  realRoots: number[];
+}
+/**
+ * Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate.
+ *
+ * Named `polyRoots` because `solve` alone said nothing about which roots of what: labs exported
+ * three of them (closed-form polynomial, these numeric ones, and the circuit solver).
+ */
+declare function polyRoots(p0: Poly): PolyRoots | null;
+/** Solve an expression-AST equation `expr = 0` for x, any degree. null if not a
+ *  polynomial in x. (Linear/quadratic also flow through here, exactly.) */
+declare function solveEquation(node: Node, x?: string, params?: Record<string, number>): PolyRoots | null;
+/**
+ * Factored form of the polynomial over the reals: leading coefficient × linear
+ * factors (real roots, with multiplicity) × irreducible quadratics (complex
+ * conjugate pairs). e.g. x³−6x²+11x−6 → "(x − 1)(x − 2)(x − 3)".
+ */
+declare function factorTex(p0: Poly, x?: string): string;
+//#endregion
+export { Poly, PolyRoots, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, polyRoots, polyTex, poly_d_exports, solveEquation, trim };