document-compute.js 0.0.0 → 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,106 @@
+import { DimensionVector, ExactRational, FormulaBindings, Interval, MathExpression, Quantity, SiBaseDimension, SymbolTable } from "document-schema.js";
+//#region src/compute/rational.d.ts
+interface Rational {
+  readonly n: bigint;
+  readonly d: bigint;
+}
+declare function toRational(value: ExactRational): Rational;
+declare function toExactRational(value: Rational): ExactRational;
+declare function addRational(a: Rational, b: Rational): Rational;
+declare function subtractRational(a: Rational, b: Rational): Rational;
+declare function multiplyRational(a: Rational, b: Rational): Rational;
+declare function divideRational(a: Rational, b: Rational): Rational;
+declare function rationalToNumber(value: Rational): number;
+//#endregion
+//#region src/compute/dimensions.d.ts
+declare function dimensionExponent(dimension: DimensionVector, base: SiBaseDimension): number;
+declare function dimensionsEqual(a: DimensionVector, b: DimensionVector): boolean;
+declare function isDimensionless(dimension: DimensionVector): boolean;
+declare function multiplyDimensions(a: DimensionVector, b: DimensionVector): DimensionVector;
+declare function divideDimensions(a: DimensionVector, b: DimensionVector): DimensionVector;
+declare function scaleDimension(dimension: DimensionVector, k: number): DimensionVector;
+declare function dimensionToString(dimension: DimensionVector): string;
+//#endregion
+//#region src/compute/errors.d.ts
+declare class IncompatibleDimensionsError extends Error {
+  readonly operation: string;
+  readonly left: DimensionVector;
+  readonly right: DimensionVector;
+  constructor(operation: string, left: DimensionVector, right: DimensionVector, detail?: string);
+}
+declare class UnboundSymbolError extends Error {
+  readonly symbol: string;
+  constructor(symbol: string);
+}
+declare class UnknownUnitError extends Error {
+  readonly unit: string;
+  constructor(unit: string);
+}
+declare class DivisionByZeroError extends Error {
+  readonly operation: string;
+  constructor(operation: string, detail: string);
+}
+declare class UnsupportedExpressionError extends Error {
+  readonly context: string;
+  constructor(context: string, detail: string);
+}
+declare class NumericDomainError extends Error {
+  readonly operation: string;
+  constructor(operation: string, detail: string);
+}
+declare class NonConvergentSolveError extends Error {
+  readonly method: 'bisection' | 'newton';
+  readonly iterations: number;
+  constructor(method: 'bisection' | 'newton', iterations: number, detail: string);
+}
+//#endregion
+//#region src/compute/quantity.d.ts
+declare function quantity(magnitude: number, dimension?: DimensionVector): Quantity;
+declare function addQuantities(a: Quantity, b: Quantity): Quantity;
+declare function subtractQuantities(a: Quantity, b: Quantity): Quantity;
+declare function multiplyQuantities(a: Quantity, b: Quantity): Quantity;
+declare function divideQuantities(a: Quantity, b: Quantity): Quantity;
+declare function negateQuantity(a: Quantity): Quantity;
+declare function absQuantity(a: Quantity): Quantity;
+declare function powQuantity(base: Quantity, exponent: Quantity): Quantity;
+declare function sqrtQuantity(a: Quantity): Quantity;
+declare function sinQuantity(a: Quantity): Quantity;
+declare function cosQuantity(a: Quantity): Quantity;
+declare function tanQuantity(a: Quantity): Quantity;
+//#endregion
+//#region src/compute/interval.d.ts
+declare function interval(min: number, max: number, dimension?: DimensionVector): Interval;
+declare function pointInterval(magnitude: number, dimension?: DimensionVector): Interval;
+declare function addIntervals(a: Interval, b: Interval): Interval;
+declare function subtractIntervals(a: Interval, b: Interval): Interval;
+declare function multiplyIntervals(a: Interval, b: Interval): Interval;
+declare function divideIntervals(a: Interval, b: Interval): Interval;
+declare function negateInterval(a: Interval): Interval;
+declare function absInterval(a: Interval): Interval;
+//#endregion
+//#region src/compute/evaluate.d.ts
+type EvaluationResult = Quantity | Interval;
+declare function isInterval(value: EvaluationResult): value is Interval;
+declare function evaluate(expression: MathExpression, bindings: FormulaBindings, context?: SymbolTable): EvaluationResult;
+//#endregion
+//#region src/compute/solve.d.ts
+type SolveMethod = 'bisection' | 'newton';
+interface SolveForOptions {
+  /** Which root-finding algorithm to use. Default: 'bisection' (needs no derivative and cannot diverge the way Newton can, so it is the safer default; Newton converges faster once it has a decent initialGuess). */
+  method?: SolveMethod;
+  /** Convergence threshold on |f(x)| = |evaluate(expression, ...) - targetValue|. Default 1e-9. */
+  tolerance?: number;
+  /** Iteration budget before giving up with NonConvergentSolveError. Default 100. */
+  maxIterations?: number;
+  /** Required for 'bisection': an [low, high] bracket whose residuals at the endpoints have opposite signs (the intermediate value theorem is bisection's entire correctness argument -- there is no bracket to fall back on if this does not hold, so a bad bracket throws rather than guessing one). */
+  bracket?: [number, number];
+  /** Required for 'newton': the starting point the iteration refines from. */
+  initialGuess?: number;
+  /** The dimension the unknown symbol is bound under at each trial point. Default {} (dimensionless) -- set this when the unknown is not dimensionless, e.g. { length: 1 } to solve for a length in SI-coherent metres. */
+  unknownDimension?: DimensionVector;
+  /** Step size h for Newton's central-difference derivative estimate (see newton() below). Default 1e-6. */
+  derivativeStep?: number;
+}
+declare function solveFor(expression: MathExpression, targetValue: number, unknownSymbol: string, bindings: FormulaBindings, options?: SolveForOptions, context?: SymbolTable): number;
+//#endregion
+export { DivisionByZeroError, EvaluationResult, IncompatibleDimensionsError, NonConvergentSolveError, NumericDomainError, Rational, SolveForOptions, SolveMethod, UnboundSymbolError, UnknownUnitError, UnsupportedExpressionError, absInterval, absQuantity, addIntervals, addQuantities, addRational, cosQuantity, dimensionExponent, dimensionToString, dimensionsEqual, divideDimensions, divideIntervals, divideQuantities, divideRational, evaluate, interval, isDimensionless, isInterval, multiplyDimensions, multiplyIntervals, multiplyQuantities, multiplyRational, negateInterval, negateQuantity, pointInterval, powQuantity, quantity, rationalToNumber, scaleDimension, sinQuantity, solveFor, sqrtQuantity, subtractIntervals, subtractQuantities, subtractRational, tanQuantity, toExactRational, toRational };

package/dist/index.d.ts

@@ -0,0 +1,106 @@
+import { DimensionVector, ExactRational, FormulaBindings, Interval, MathExpression, Quantity, SiBaseDimension, SymbolTable } from "document-schema.js";
+//#region src/compute/rational.d.ts
+interface Rational {
+  readonly n: bigint;
+  readonly d: bigint;
+}
+declare function toRational(value: ExactRational): Rational;
+declare function toExactRational(value: Rational): ExactRational;
+declare function addRational(a: Rational, b: Rational): Rational;
+declare function subtractRational(a: Rational, b: Rational): Rational;
+declare function multiplyRational(a: Rational, b: Rational): Rational;
+declare function divideRational(a: Rational, b: Rational): Rational;
+declare function rationalToNumber(value: Rational): number;
+//#endregion
+//#region src/compute/dimensions.d.ts
+declare function dimensionExponent(dimension: DimensionVector, base: SiBaseDimension): number;
+declare function dimensionsEqual(a: DimensionVector, b: DimensionVector): boolean;
+declare function isDimensionless(dimension: DimensionVector): boolean;
+declare function multiplyDimensions(a: DimensionVector, b: DimensionVector): DimensionVector;
+declare function divideDimensions(a: DimensionVector, b: DimensionVector): DimensionVector;
+declare function scaleDimension(dimension: DimensionVector, k: number): DimensionVector;
+declare function dimensionToString(dimension: DimensionVector): string;
+//#endregion
+//#region src/compute/errors.d.ts
+declare class IncompatibleDimensionsError extends Error {
+  readonly operation: string;
+  readonly left: DimensionVector;
+  readonly right: DimensionVector;
+  constructor(operation: string, left: DimensionVector, right: DimensionVector, detail?: string);
+}
+declare class UnboundSymbolError extends Error {
+  readonly symbol: string;
+  constructor(symbol: string);
+}
+declare class UnknownUnitError extends Error {
+  readonly unit: string;
+  constructor(unit: string);
+}
+declare class DivisionByZeroError extends Error {
+  readonly operation: string;
+  constructor(operation: string, detail: string);
+}
+declare class UnsupportedExpressionError extends Error {
+  readonly context: string;
+  constructor(context: string, detail: string);
+}
+declare class NumericDomainError extends Error {
+  readonly operation: string;
+  constructor(operation: string, detail: string);
+}
+declare class NonConvergentSolveError extends Error {
+  readonly method: 'bisection' | 'newton';
+  readonly iterations: number;
+  constructor(method: 'bisection' | 'newton', iterations: number, detail: string);
+}
+//#endregion
+//#region src/compute/quantity.d.ts
+declare function quantity(magnitude: number, dimension?: DimensionVector): Quantity;
+declare function addQuantities(a: Quantity, b: Quantity): Quantity;
+declare function subtractQuantities(a: Quantity, b: Quantity): Quantity;
+declare function multiplyQuantities(a: Quantity, b: Quantity): Quantity;
+declare function divideQuantities(a: Quantity, b: Quantity): Quantity;
+declare function negateQuantity(a: Quantity): Quantity;
+declare function absQuantity(a: Quantity): Quantity;
+declare function powQuantity(base: Quantity, exponent: Quantity): Quantity;
+declare function sqrtQuantity(a: Quantity): Quantity;
+declare function sinQuantity(a: Quantity): Quantity;
+declare function cosQuantity(a: Quantity): Quantity;
+declare function tanQuantity(a: Quantity): Quantity;
+//#endregion
+//#region src/compute/interval.d.ts
+declare function interval(min: number, max: number, dimension?: DimensionVector): Interval;
+declare function pointInterval(magnitude: number, dimension?: DimensionVector): Interval;
+declare function addIntervals(a: Interval, b: Interval): Interval;
+declare function subtractIntervals(a: Interval, b: Interval): Interval;
+declare function multiplyIntervals(a: Interval, b: Interval): Interval;
+declare function divideIntervals(a: Interval, b: Interval): Interval;
+declare function negateInterval(a: Interval): Interval;
+declare function absInterval(a: Interval): Interval;
+//#endregion
+//#region src/compute/evaluate.d.ts
+type EvaluationResult = Quantity | Interval;
+declare function isInterval(value: EvaluationResult): value is Interval;
+declare function evaluate(expression: MathExpression, bindings: FormulaBindings, context?: SymbolTable): EvaluationResult;
+//#endregion
+//#region src/compute/solve.d.ts
+type SolveMethod = 'bisection' | 'newton';
+interface SolveForOptions {
+  /** Which root-finding algorithm to use. Default: 'bisection' (needs no derivative and cannot diverge the way Newton can, so it is the safer default; Newton converges faster once it has a decent initialGuess). */
+  method?: SolveMethod;
+  /** Convergence threshold on |f(x)| = |evaluate(expression, ...) - targetValue|. Default 1e-9. */
+  tolerance?: number;
+  /** Iteration budget before giving up with NonConvergentSolveError. Default 100. */
+  maxIterations?: number;
+  /** Required for 'bisection': an [low, high] bracket whose residuals at the endpoints have opposite signs (the intermediate value theorem is bisection's entire correctness argument -- there is no bracket to fall back on if this does not hold, so a bad bracket throws rather than guessing one). */
+  bracket?: [number, number];
+  /** Required for 'newton': the starting point the iteration refines from. */
+  initialGuess?: number;
+  /** The dimension the unknown symbol is bound under at each trial point. Default {} (dimensionless) -- set this when the unknown is not dimensionless, e.g. { length: 1 } to solve for a length in SI-coherent metres. */
+  unknownDimension?: DimensionVector;
+  /** Step size h for Newton's central-difference derivative estimate (see newton() below). Default 1e-6. */
+  derivativeStep?: number;
+}
+declare function solveFor(expression: MathExpression, targetValue: number, unknownSymbol: string, bindings: FormulaBindings, options?: SolveForOptions, context?: SymbolTable): number;
+//#endregion
+export { DivisionByZeroError, EvaluationResult, IncompatibleDimensionsError, NonConvergentSolveError, NumericDomainError, Rational, SolveForOptions, SolveMethod, UnboundSymbolError, UnknownUnitError, UnsupportedExpressionError, absInterval, absQuantity, addIntervals, addQuantities, addRational, cosQuantity, dimensionExponent, dimensionToString, dimensionsEqual, divideDimensions, divideIntervals, divideQuantities, divideRational, evaluate, interval, isDimensionless, isInterval, multiplyDimensions, multiplyIntervals, multiplyQuantities, multiplyRational, negateInterval, negateQuantity, pointInterval, powQuantity, quantity, rationalToNumber, scaleDimension, sinQuantity, solveFor, sqrtQuantity, subtractIntervals, subtractQuantities, subtractRational, tanQuantity, toExactRational, toRational };

package/dist/index.js

@@ -0,0 +1,451 @@
+import { SI_BASE_DIMENSIONS } from "document-schema.js";
+//#region src/compute/rational.ts
+function bigintOfCanonicalDigits(digits) {
+	return BigInt(digits);
+}
+function toRational(value) {
+	return {
+		n: bigintOfCanonicalDigits(value.numerator),
+		d: bigintOfCanonicalDigits(value.denominator)
+	};
+}
+function gcd(a, b) {
+	let x = a < 0n ? -a : a;
+	let y = b < 0n ? -b : b;
+	while (y !== 0n) [x, y] = [y, x % y];
+	return x === 0n ? 1n : x;
+}
+function reduce(n, d) {
+	if (d === 0n) throw new RangeError("rational.ts: denominator must not be zero");
+	if (n === 0n) return {
+		n: 0n,
+		d: 1n
+	};
+	const sign = d < 0n ? -1n : 1n;
+	const num = n * sign;
+	const den = d * sign;
+	const g = gcd(num, den);
+	return {
+		n: num / g,
+		d: den / g
+	};
+}
+function toExactRational(value) {
+	const reduced = reduce(value.n, value.d);
+	return {
+		numerator: reduced.n.toString(),
+		denominator: reduced.d.toString()
+	};
+}
+function addRational(a, b) {
+	return reduce(a.n * b.d + b.n * a.d, a.d * b.d);
+}
+function subtractRational(a, b) {
+	return reduce(a.n * b.d - b.n * a.d, a.d * b.d);
+}
+function multiplyRational(a, b) {
+	return reduce(a.n * b.n, a.d * b.d);
+}
+function divideRational(a, b) {
+	if (b.n === 0n) throw new RangeError("rational.ts: division by zero");
+	return reduce(a.n * b.d, a.d * b.n);
+}
+function rationalToNumber(value) {
+	return Number(value.n) / Number(value.d);
+}
+//#endregion
+//#region src/compute/dimensions.ts
+function dimensionExponent(dimension, base) {
+	return dimension[base] ?? 0;
+}
+function dimensionsEqual(a, b) {
+	return SI_BASE_DIMENSIONS.every((base) => dimensionExponent(a, base) === dimensionExponent(b, base));
+}
+function isDimensionless(dimension) {
+	return SI_BASE_DIMENSIONS.every((base) => dimensionExponent(dimension, base) === 0);
+}
+function combine(a, b, op) {
+	const result = {};
+	for (const base of SI_BASE_DIMENSIONS) {
+		const value = op(dimensionExponent(a, base), dimensionExponent(b, base));
+		if (value !== 0) result[base] = value;
+	}
+	return result;
+}
+function multiplyDimensions(a, b) {
+	return combine(a, b, (x, y) => x + y);
+}
+function divideDimensions(a, b) {
+	return combine(a, b, (x, y) => x - y);
+}
+function scaleDimension(dimension, k) {
+	const result = {};
+	for (const base of SI_BASE_DIMENSIONS) {
+		const exponent = dimensionExponent(dimension, base);
+		if (exponent === 0) continue;
+		const scaled = exponent * k;
+		if (!Number.isInteger(scaled)) throw new RangeError(`dimensions.ts: scaling '${base}' by ${k} does not land on an integer exponent`);
+		result[base] = scaled;
+	}
+	return result;
+}
+function dimensionToString(dimension) {
+	const parts = SI_BASE_DIMENSIONS.filter((base) => dimensionExponent(dimension, base) !== 0).map((base) => `${base}^${dimensionExponent(dimension, base)}`);
+	return parts.length === 0 ? "dimensionless" : parts.join("·");
+}
+//#endregion
+//#region src/compute/errors.ts
+var IncompatibleDimensionsError = class extends Error {
+	operation;
+	left;
+	right;
+	constructor(operation, left, right, detail) {
+		super(`'${operation}' requires compatible dimensions, got ${dimensionToString(left)} and ${dimensionToString(right)}` + (detail === void 0 ? "." : ` (${detail}).`));
+		this.name = "IncompatibleDimensionsError";
+		this.operation = operation;
+		this.left = left;
+		this.right = right;
+	}
+};
+var UnboundSymbolError = class extends Error {
+	symbol;
+	constructor(symbol) {
+		super(`symbol '${symbol}' has no entry in the supplied bindings.`);
+		this.name = "UnboundSymbolError";
+		this.symbol = symbol;
+	}
+};
+var UnknownUnitError = class extends Error {
+	unit;
+	constructor(unit) {
+		super(`unit '${unit}' is not registered in the supplied symbol table's units.`);
+		this.name = "UnknownUnitError";
+		this.unit = unit;
+	}
+};
+var DivisionByZeroError = class extends Error {
+	operation;
+	constructor(operation, detail) {
+		super(`'${operation}': division by zero (${detail}).`);
+		this.name = "DivisionByZeroError";
+		this.operation = operation;
+	}
+};
+var UnsupportedExpressionError = class extends Error {
+	context;
+	constructor(context, detail) {
+		super(`${context}: ${detail}.`);
+		this.name = "UnsupportedExpressionError";
+		this.context = context;
+	}
+};
+var NumericDomainError = class extends Error {
+	operation;
+	constructor(operation, detail) {
+		super(`'${operation}': ${detail}.`);
+		this.name = "NumericDomainError";
+		this.operation = operation;
+	}
+};
+var NonConvergentSolveError = class extends Error {
+	method;
+	iterations;
+	constructor(method, iterations, detail) {
+		super(`solveFor (${method}) did not converge after ${iterations} iteration(s): ${detail}.`);
+		this.name = "NonConvergentSolveError";
+		this.method = method;
+		this.iterations = iterations;
+	}
+};
+//#endregion
+//#region src/compute/quantity.ts
+function quantity(magnitude, dimension = {}) {
+	return {
+		kind: "quantity",
+		magnitude,
+		dimension
+	};
+}
+function addQuantities(a, b) {
+	if (!dimensionsEqual(a.dimension, b.dimension)) throw new IncompatibleDimensionsError("math:add", a.dimension, b.dimension);
+	return quantity(a.magnitude + b.magnitude, a.dimension);
+}
+function subtractQuantities(a, b) {
+	if (!dimensionsEqual(a.dimension, b.dimension)) throw new IncompatibleDimensionsError("math:subtract", a.dimension, b.dimension);
+	return quantity(a.magnitude - b.magnitude, a.dimension);
+}
+function multiplyQuantities(a, b) {
+	return quantity(a.magnitude * b.magnitude, multiplyDimensions(a.dimension, b.dimension));
+}
+function divideQuantities(a, b) {
+	if (b.magnitude === 0) throw new DivisionByZeroError("math:divide", `divisor magnitude is exactly zero (dividend magnitude ${a.magnitude})`);
+	return quantity(a.magnitude / b.magnitude, divideDimensions(a.dimension, b.dimension));
+}
+function negateQuantity(a) {
+	return quantity(-a.magnitude, a.dimension);
+}
+function absQuantity(a) {
+	return quantity(Math.abs(a.magnitude), a.dimension);
+}
+function powQuantity(base, exponent) {
+	if (!isDimensionless(exponent.dimension)) throw new IncompatibleDimensionsError("math:pow", exponent.dimension, {}, "the exponent must be dimensionless");
+	if (isDimensionless(base.dimension)) return quantity(Math.pow(base.magnitude, exponent.magnitude), {});
+	if (!Number.isInteger(exponent.magnitude)) throw new IncompatibleDimensionsError("math:pow", base.dimension, {}, "a dimensioned base can only be raised to an integer power");
+	return quantity(Math.pow(base.magnitude, exponent.magnitude), scaleDimension(base.dimension, exponent.magnitude));
+}
+function sqrtQuantity(a) {
+	if (a.magnitude < 0) throw new NumericDomainError("math:sqrt", `magnitude must be non-negative, got ${a.magnitude}`);
+	let dimension;
+	try {
+		dimension = scaleDimension(a.dimension, .5);
+	} catch {
+		throw new IncompatibleDimensionsError("math:sqrt", a.dimension, {}, "every exponent must be even for the dimension to have an exact square root");
+	}
+	return quantity(Math.sqrt(a.magnitude), dimension);
+}
+function requireDimensionless(a, operator) {
+	if (!isDimensionless(a.dimension)) throw new IncompatibleDimensionsError(operator, a.dimension, {}, "trigonometric functions take a dimensionless (radian) argument");
+}
+function sinQuantity(a) {
+	requireDimensionless(a, "math:sin");
+	return quantity(Math.sin(a.magnitude), {});
+}
+function cosQuantity(a) {
+	requireDimensionless(a, "math:cos");
+	return quantity(Math.cos(a.magnitude), {});
+}
+function tanQuantity(a) {
+	requireDimensionless(a, "math:tan");
+	return quantity(Math.tan(a.magnitude), {});
+}
+//#endregion
+//#region src/compute/interval.ts
+function interval(min, max, dimension = {}) {
+	if (min > max) throw new RangeError(`interval: min (${min}) must not exceed max (${max})`);
+	return {
+		kind: "interval",
+		min,
+		max,
+		dimension
+	};
+}
+function pointInterval(magnitude, dimension = {}) {
+	return {
+		kind: "interval",
+		min: magnitude,
+		max: magnitude,
+		dimension
+	};
+}
+function addIntervals(a, b) {
+	if (!dimensionsEqual(a.dimension, b.dimension)) throw new IncompatibleDimensionsError("math:add", a.dimension, b.dimension);
+	return interval(a.min + b.min, a.max + b.max, a.dimension);
+}
+function subtractIntervals(a, b) {
+	if (!dimensionsEqual(a.dimension, b.dimension)) throw new IncompatibleDimensionsError("math:subtract", a.dimension, b.dimension);
+	return interval(a.min - b.max, a.max - b.min, a.dimension);
+}
+function multiplyIntervals(a, b) {
+	const corners = [
+		a.min * b.min,
+		a.min * b.max,
+		a.max * b.min,
+		a.max * b.max
+	];
+	return interval(Math.min(...corners), Math.max(...corners), multiplyDimensions(a.dimension, b.dimension));
+}
+function divideIntervals(a, b) {
+	if (b.min <= 0 && b.max >= 0) throw new DivisionByZeroError("math:divide", `divisor interval [${b.min}, ${b.max}] contains zero`);
+	const reciprocalMin = 1 / b.max;
+	const reciprocalMax = 1 / b.min;
+	const corners = [
+		a.min * reciprocalMin,
+		a.min * reciprocalMax,
+		a.max * reciprocalMin,
+		a.max * reciprocalMax
+	];
+	return interval(Math.min(...corners), Math.max(...corners), divideDimensions(a.dimension, b.dimension));
+}
+function negateInterval(a) {
+	return interval(-a.max, -a.min, a.dimension);
+}
+function absInterval(a) {
+	if (a.min >= 0) return a;
+	if (a.max <= 0) return negateInterval(a);
+	return interval(0, Math.max(-a.min, a.max), a.dimension);
+}
+//#endregion
+//#region src/compute/evaluate.ts
+const EMPTY_SYMBOL_TABLE$1 = {
+	symbols: [],
+	units: []
+};
+function isInterval(value) {
+	return value.kind === "interval";
+}
+function toInterval(value) {
+	return isInterval(value) ? value : pointInterval(value.magnitude, value.dimension);
+}
+function asQuantity(value, context) {
+	if (isInterval(value)) throw new UnsupportedExpressionError(context, "this position requires a plain Quantity, not an Interval");
+	return value;
+}
+const BINARY_OPERATORS = {
+	"math:add": {
+		quantity: addQuantities,
+		interval: addIntervals
+	},
+	"math:subtract": {
+		quantity: subtractQuantities,
+		interval: subtractIntervals
+	},
+	"math:multiply": {
+		quantity: multiplyQuantities,
+		interval: multiplyIntervals
+	},
+	"math:divide": {
+		quantity: divideQuantities,
+		interval: divideIntervals
+	}
+};
+const UNARY_OPERATORS = {
+	"math:negate": {
+		quantity: negateQuantity,
+		interval: negateInterval
+	},
+	"math:abs": {
+		quantity: absQuantity,
+		interval: absInterval
+	},
+	"math:sqrt": { quantity: sqrtQuantity },
+	"math:sin": { quantity: sinQuantity },
+	"math:cos": { quantity: cosQuantity },
+	"math:tan": { quantity: tanQuantity }
+};
+function evaluate(expression, bindings, context = EMPTY_SYMBOL_TABLE$1) {
+	switch (expression.kind) {
+		case "num": return quantity(rationalToNumber(toRational(expression)), {});
+		case "qty": return evaluateQty(expression, context);
+		case "sym": {
+			const bound = bindings[expression.id];
+			if (bound === void 0) throw new UnboundSymbolError(expression.id);
+			return bound;
+		}
+		case "app": return evaluateApp(expression, bindings, context);
+		case "sum":
+		case "prod": return evaluateBinder(expression, bindings, context);
+		case "matrix": throw new UnsupportedExpressionError("evaluate", "matrix-valued expressions are out of scope for this pass -- document-compute.js evaluates scalar Quantity/Interval values only");
+		case "unparsed": throw new UnsupportedExpressionError("evaluate", `this node is source LaTeX ("${expression.latex}") document-schema.js's lowering could not represent structurally, so there is nothing to evaluate`);
+	}
+}
+function evaluateQty(node, context) {
+	const unit = context.units.find((entry) => entry.id === node.unit);
+	if (unit === void 0) throw new UnknownUnitError(node.unit);
+	let siValue = multiplyRational(toRational(node.value), toRational(unit.factorToSi));
+	if (unit.offsetToSi !== void 0) siValue = addRational(siValue, toRational(unit.offsetToSi));
+	return quantity(rationalToNumber(siValue), unit.dimension);
+}
+function evaluateApp(node, bindings, context) {
+	const args = node.args.map((arg) => evaluate(arg, bindings, context));
+	const binary = BINARY_OPERATORS[node.operator];
+	if (binary !== void 0) {
+		if (args.length !== 2) throw new UnsupportedExpressionError("evaluate", `operator '${node.operator}' takes exactly 2 arguments, got ${args.length}`);
+		const [left, right] = args;
+		if (isInterval(left) || isInterval(right)) return binary.interval(toInterval(left), toInterval(right));
+		return binary.quantity(left, right);
+	}
+	const unary = UNARY_OPERATORS[node.operator];
+	if (unary !== void 0) {
+		if (args.length !== 1) throw new UnsupportedExpressionError("evaluate", `operator '${node.operator}' takes exactly 1 argument, got ${args.length}`);
+		const [only] = args;
+		if (isInterval(only)) {
+			if (unary.interval === void 0) throw new UnsupportedExpressionError("evaluate", `operator '${node.operator}' has no interval rule in this pass`);
+			return unary.interval(only);
+		}
+		return unary.quantity(only);
+	}
+	if (node.operator === "math:pow") {
+		if (args.length !== 2) throw new UnsupportedExpressionError("evaluate", `'math:pow' takes exactly 2 arguments, got ${args.length}`);
+		const [base, exponent] = args;
+		return powQuantity(asQuantity(base, "evaluate"), asQuantity(exponent, "evaluate"));
+	}
+	throw new UnsupportedExpressionError("evaluate", `unknown operator '${node.operator}'`);
+}
+function evaluateBinder(node, bindings, context) {
+	const lower = asQuantity(evaluate(node.lower, bindings, context), `evaluate:${node.kind}`);
+	const upper = asQuantity(evaluate(node.upper, bindings, context), `evaluate:${node.kind}`);
+	if (!isDimensionless(lower.dimension) || !isDimensionless(upper.dimension)) throw new IncompatibleDimensionsError(`math:${node.kind}`, lower.dimension, upper.dimension, "binder bounds must be dimensionless");
+	if (!Number.isInteger(lower.magnitude) || !Number.isInteger(upper.magnitude)) throw new UnsupportedExpressionError(`evaluate:${node.kind}`, "binder bounds must evaluate to integers");
+	let accumulator = node.kind === "sum" ? quantity(0, {}) : quantity(1, {});
+	for (let i = lower.magnitude; i <= upper.magnitude; i += 1) {
+		const bodyBindings = {
+			...bindings,
+			[node.binder]: quantity(i, {})
+		};
+		const bodyValue = asQuantity(evaluate(node.body, bodyBindings, context), `evaluate:${node.kind}`);
+		accumulator = node.kind === "sum" ? addQuantities(accumulator, bodyValue) : multiplyQuantities(accumulator, bodyValue);
+	}
+	return accumulator;
+}
+//#endregion
+//#region src/compute/solve.ts
+const DEFAULT_TOLERANCE = 1e-9;
+const DEFAULT_MAX_ITERATIONS = 100;
+const DEFAULT_DERIVATIVE_STEP = 1e-6;
+const EMPTY_SYMBOL_TABLE = {
+	symbols: [],
+	units: []
+};
+function residualFn(expression, targetValue, unknownSymbol, bindings, context, dimension) {
+	return (x) => {
+		const result = evaluate(expression, {
+			...bindings,
+			[unknownSymbol]: quantity(x, dimension)
+		}, context);
+		if (result.kind !== "quantity") throw new UnsupportedExpressionError("solveFor", "the expression must evaluate to a plain Quantity, not an Interval");
+		return result.magnitude - targetValue;
+	};
+}
+function solveFor(expression, targetValue, unknownSymbol, bindings, options = {}, context = EMPTY_SYMBOL_TABLE) {
+	const method = options.method ?? "bisection";
+	const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+	const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+	const f = residualFn(expression, targetValue, unknownSymbol, bindings, context, options.unknownDimension ?? {});
+	if (method === "bisection") return bisection(f, options.bracket, tolerance, maxIterations);
+	return newton(f, options.initialGuess, tolerance, maxIterations, options.derivativeStep ?? DEFAULT_DERIVATIVE_STEP);
+}
+function bisection(f, bracket, tolerance, maxIterations) {
+	if (bracket === void 0) throw new UnsupportedExpressionError("solveFor", "method 'bisection' requires options.bracket: [low, high]");
+	let [low, high] = bracket;
+	let fLow = f(low);
+	const fHigh0 = f(high);
+	if (Math.abs(fLow) < tolerance) return low;
+	if (Math.abs(fHigh0) < tolerance) return high;
+	if (fLow > 0 === fHigh0 > 0) throw new NonConvergentSolveError("bisection", 0, `residual at the bracket endpoints does not change sign (f(${low})=${fLow}, f(${high})=${fHigh0}) -- bisection needs a bracket straddling the root`);
+	for (let i = 0; i < maxIterations; i += 1) {
+		const mid = (low + high) / 2;
+		const fMid = f(mid);
+		if (Math.abs(fMid) < tolerance) return mid;
+		if (fMid > 0 === fLow > 0) {
+			low = mid;
+			fLow = fMid;
+		} else high = mid;
+	}
+	throw new NonConvergentSolveError("bisection", maxIterations, `residual still exceeds tolerance ${tolerance} after ${maxIterations} iterations`);
+}
+function newton(f, initialGuess, tolerance, maxIterations, h) {
+	if (initialGuess === void 0) throw new UnsupportedExpressionError("solveFor", "method 'newton' requires options.initialGuess");
+	let x = initialGuess;
+	for (let i = 0; i < maxIterations; i += 1) {
+		const fx = f(x);
+		if (Math.abs(fx) < tolerance) return x;
+		const derivative = (f(x + h) - f(x - h)) / (2 * h);
+		if (!Number.isFinite(derivative) || Math.abs(derivative) < 1e-14) throw new NonConvergentSolveError("newton", i, `the numeric derivative vanished or diverged near x=${x}`);
+		const next = x - fx / derivative;
+		if (!Number.isFinite(next)) throw new NonConvergentSolveError("newton", i, `the iteration diverged to a non-finite value near x=${x}`);
+		x = next;
+	}
+	throw new NonConvergentSolveError("newton", maxIterations, `residual still exceeds tolerance ${tolerance} after ${maxIterations} iterations`);
+}
+//#endregion
+export { DivisionByZeroError, IncompatibleDimensionsError, NonConvergentSolveError, NumericDomainError, UnboundSymbolError, UnknownUnitError, UnsupportedExpressionError, absInterval, absQuantity, addIntervals, addQuantities, addRational, cosQuantity, dimensionExponent, dimensionToString, dimensionsEqual, divideDimensions, divideIntervals, divideQuantities, divideRational, evaluate, interval, isDimensionless, isInterval, multiplyDimensions, multiplyIntervals, multiplyQuantities, multiplyRational, negateInterval, negateQuantity, pointInterval, powQuantity, quantity, rationalToNumber, scaleDimension, sinQuantity, solveFor, sqrtQuantity, subtractIntervals, subtractQuantities, subtractRational, tanQuantity, toExactRational, toRational };