Files
faceclaw/app/apps/calculator/math/expression.ts
T
Kalani Helekunihi fe85846e6f Add calculator and microphone conversation apps
Add symbolic math and graphing tools, dual-microphone audio processing, live captions, translation, speaker diarization, sentiment analysis, and searchable conversation history.

Extend Android voice and BLE support for microphone control, recording, transcoding, and on-device speaker identification, with coverage for calculator and microphone workflows.
2026-08-25 00:22:19 -05:00

488 lines
14 KiB
TypeScript

// The expression tree everything else operates on: evaluation, simplification,
// differentiation, solving, rendering, and plotting. A plain discriminated
// union so the whole tree is a value — simplification and differentiation can
// rebuild subtrees freely, and structural comparison (expressionEquals) gives
// the simplifier the like-term matching it leans on heavily.
import {
type MathNumber,
integer as makeInteger,
fromDecimal,
isZero as numberIsZero,
isOne as numberIsOne,
numberEquals as numbersEqual,
} from "./math-number";
export type MathRelation = "=" | "<" | "<=" | ">" | ">=";
export type MathConstant = "pi" | "e" | "tau";
export type MathFunction =
| "sin"
| "cos"
| "tan"
| "asin"
| "acos"
| "atan"
| "sinh"
| "cosh"
| "tanh"
| "ln"
| "log10"
| "log2"
| "sqrt"
| "cbrt"
| "abs"
| "exp"
| "floor"
| "ceil"
| "round"
| "factorial";
export const ALL_FUNCTIONS: readonly MathFunction[] = [
"sin",
"cos",
"tan",
"asin",
"acos",
"atan",
"sinh",
"cosh",
"tanh",
"ln",
"log10",
"log2",
"sqrt",
"cbrt",
"abs",
"exp",
"floor",
"ceil",
"round",
"factorial",
];
export const ALL_CONSTANTS: readonly MathConstant[] = ["pi", "e", "tau"];
export type MathExpression =
| { type: "number"; value: MathNumber }
/** A free variable — `x`, `y`, `theta`. */
| { type: "variable"; name: string }
/**
* A named constant with a known value (`pi`, `e`). Kept distinct from
* `variable` so "solve for pi" is impossible and `2π` stays exact instead of
* becoming 6.283…
*/
| { type: "constant"; constant: MathConstant }
| { type: "add"; terms: MathExpression[] }
| { type: "multiply"; factors: MathExpression[] }
| { type: "power"; base: MathExpression; exponent: MathExpression }
/**
* Unary negation. Not folded into `multiply([-1, x])` because the renderers
* and the step explanations both want to say "negative x".
*/
| { type: "negate"; inner: MathExpression }
| { type: "function"; fn: MathFunction; args: MathExpression[] }
/** An equation or inequality — the root node of anything solvable. */
| { type: "relation"; relation: MathRelation; lhs: MathExpression; rhs: MathExpression };
// ---------------------------------------------------------------------------
// Convenience constructors
export function num(value: MathNumber): MathExpression {
return { type: "number", value };
}
export function int(value: number): MathExpression {
return num(makeInteger(value));
}
export function realExpr(value: number): MathExpression {
return num(fromDecimal(value));
}
export function variable(name: string): MathExpression {
return { type: "variable", name };
}
export function constant(value: MathConstant): MathExpression {
return { type: "constant", constant: value };
}
export function addExpr(terms: MathExpression[]): MathExpression {
return { type: "add", terms };
}
export function multiplyExpr(factors: MathExpression[]): MathExpression {
return { type: "multiply", factors };
}
export function powerExpr(base: MathExpression, exponent: MathExpression): MathExpression {
return { type: "power", base, exponent };
}
export function negate(inner: MathExpression): MathExpression {
return { type: "negate", inner };
}
export function fn(name: MathFunction, args: MathExpression[]): MathExpression {
return { type: "function", fn: name, args };
}
export function relation(rel: MathRelation, lhs: MathExpression, rhs: MathExpression): MathExpression {
return { type: "relation", relation: rel, lhs, rhs };
}
export function subtractExpr(lhs: MathExpression, rhs: MathExpression): MathExpression {
return addExpr([lhs, negate(rhs)]);
}
/**
* Division is `a * b^-1` in the tree, which is what makes the simplifier and
* the differentiator tractable — the renderers detect the pattern and print a
* real fraction, so nothing user-visible degrades.
*/
export function divideExpr(lhs: MathExpression, rhs: MathExpression): MathExpression {
return multiplyExpr([lhs, powerExpr(rhs, int(-1))]);
}
export const ZERO: MathExpression = int(0);
export const ONE: MathExpression = int(1);
// ---------------------------------------------------------------------------
// Introspection
export function isZeroExpr(expression: MathExpression): boolean {
return expression.type === "number" && numberIsZero(expression.value);
}
export function isOneExpr(expression: MathExpression): boolean {
return expression.type === "number" && numberIsOne(expression.value);
}
export function numberValue(expression: MathExpression): MathNumber | null {
return expression.type === "number" ? expression.value : null;
}
/**
* Every free variable in the tree, in first-appearance order. Order matters:
* it decides which variable "solve for x" defaults to and which axis a
* single-variable graph uses.
*/
export function variablesOf(expression: MathExpression): string[] {
const seen = new Set<string>();
const ordered: string[] = [];
collectVariables(expression, ordered, seen);
return ordered;
}
function collectVariables(expression: MathExpression, ordered: string[], seen: Set<string>): void {
switch (expression.type) {
case "variable":
if (!seen.has(expression.name)) {
seen.add(expression.name);
ordered.push(expression.name);
}
break;
case "number":
case "constant":
break;
case "add":
for (const term of expression.terms) collectVariables(term, ordered, seen);
break;
case "multiply":
for (const factor of expression.factors) collectVariables(factor, ordered, seen);
break;
case "power":
collectVariables(expression.base, ordered, seen);
collectVariables(expression.exponent, ordered, seen);
break;
case "negate":
collectVariables(expression.inner, ordered, seen);
break;
case "function":
for (const argument of expression.args) collectVariables(argument, ordered, seen);
break;
case "relation":
collectVariables(expression.lhs, ordered, seen);
collectVariables(expression.rhs, ordered, seen);
break;
}
}
export function isRelation(expression: MathExpression): boolean {
return expression.type === "relation";
}
/**
* Node count — used to pick the simpler of two equivalent forms and to bound
* runaway expansion in the simplifier.
*/
export function complexity(expression: MathExpression): number {
switch (expression.type) {
case "number":
case "variable":
case "constant":
return 1;
case "add":
return 1 + expression.terms.reduce((total, term) => total + complexity(term), 0);
case "multiply":
return 1 + expression.factors.reduce((total, factor) => total + complexity(factor), 0);
case "power":
return 1 + complexity(expression.base) + complexity(expression.exponent);
case "negate":
return 1 + complexity(expression.inner);
case "function":
return 1 + expression.args.reduce((total, argument) => total + complexity(argument), 0);
case "relation":
return 1 + complexity(expression.lhs) + complexity(expression.rhs);
}
}
/** Replace every occurrence of a variable with an expression. */
export function substituting(
expression: MathExpression,
name: string,
replacement: MathExpression,
): MathExpression {
switch (expression.type) {
case "variable":
return expression.name === name ? replacement : expression;
case "number":
case "constant":
return expression;
case "add":
return addExpr(expression.terms.map((term) => substituting(term, name, replacement)));
case "multiply":
return multiplyExpr(expression.factors.map((factor) => substituting(factor, name, replacement)));
case "power":
return powerExpr(
substituting(expression.base, name, replacement),
substituting(expression.exponent, name, replacement),
);
case "negate":
return negate(substituting(expression.inner, name, replacement));
case "function":
return fn(
expression.fn,
expression.args.map((argument) => substituting(argument, name, replacement)),
);
case "relation":
return relation(
expression.relation,
substituting(expression.lhs, name, replacement),
substituting(expression.rhs, name, replacement),
);
}
}
/**
* Structural equality with value-equal numbers (MathNumber compares by
* value).
*/
export function expressionEquals(a: MathExpression, b: MathExpression): boolean {
if (a === b) return true;
if (a.type !== b.type) return false;
switch (a.type) {
case "number": {
const other = b as Extract<MathExpression, { type: "number" }>;
return numbersEqual(a.value, other.value);
}
case "variable":
return a.name === (b as Extract<MathExpression, { type: "variable" }>).name;
case "constant":
return a.constant === (b as Extract<MathExpression, { type: "constant" }>).constant;
case "add": {
const other = b as Extract<MathExpression, { type: "add" }>;
return listEquals(a.terms, other.terms);
}
case "multiply": {
const other = b as Extract<MathExpression, { type: "multiply" }>;
return listEquals(a.factors, other.factors);
}
case "power": {
const other = b as Extract<MathExpression, { type: "power" }>;
return expressionEquals(a.base, other.base) && expressionEquals(a.exponent, other.exponent);
}
case "negate":
return expressionEquals(a.inner, (b as Extract<MathExpression, { type: "negate" }>).inner);
case "function": {
const other = b as Extract<MathExpression, { type: "function" }>;
return a.fn === other.fn && listEquals(a.args, other.args);
}
case "relation": {
const other = b as Extract<MathExpression, { type: "relation" }>;
return (
a.relation === other.relation &&
expressionEquals(a.lhs, other.lhs) &&
expressionEquals(a.rhs, other.rhs)
);
}
}
}
function listEquals(a: MathExpression[], b: MathExpression[]): boolean {
if (a.length !== b.length) return false;
for (let index = 0; index < a.length; index++) {
if (!expressionEquals(a[index]!, b[index]!)) return false;
}
return true;
}
// ---------------------------------------------------------------------------
// Relations
/**
* The relation you get by multiplying or dividing both sides by a negative —
* the classic inequality mistake, handled explicitly.
*/
export function flippedRelation(rel: MathRelation): MathRelation {
switch (rel) {
case "=":
return "=";
case "<":
return ">";
case "<=":
return ">=";
case ">":
return "<";
case ">=":
return "<=";
}
}
export function spokenRelation(rel: MathRelation): string {
switch (rel) {
case "=":
return "equals";
case "<":
return "is less than";
case "<=":
return "is at most";
case ">":
return "is greater than";
case ">=":
return "is at least";
}
}
// ---------------------------------------------------------------------------
// Constants
export function constantValue(value: MathConstant): number {
switch (value) {
case "pi":
return Math.PI;
case "e":
return Math.E;
case "tau":
return 2 * Math.PI;
}
}
// ---------------------------------------------------------------------------
// Functions
export function evaluateFunction(name: MathFunction, argument: number): number {
switch (name) {
case "sin":
return Math.sin(argument);
case "cos":
return Math.cos(argument);
case "tan":
return Math.tan(argument);
case "asin":
return Math.asin(argument);
case "acos":
return Math.acos(argument);
case "atan":
return Math.atan(argument);
case "sinh":
return Math.sinh(argument);
case "cosh":
return Math.cosh(argument);
case "tanh":
return Math.tanh(argument);
case "ln":
return Math.log(argument);
case "log10":
return Math.log10(argument);
case "log2":
return Math.log2(argument);
case "sqrt":
return Math.sqrt(argument);
case "cbrt":
return Math.cbrt(argument);
case "abs":
return Math.abs(argument);
case "exp":
return Math.exp(argument);
case "floor":
return Math.floor(argument);
case "ceil":
return Math.ceil(argument);
case "round":
return Math.round(argument);
case "factorial":
// Real factorial via the gamma function, so `2.5!` is defined rather
// than an error — and so the evaluator has one code path for both.
return gamma(argument + 1);
}
}
/**
* Domain check used by the plotter to break a curve rather than draw a line
* through a gap (`ln` left of zero, `tan` at its asymptotes).
*/
export function functionIsDefined(name: MathFunction, argument: number): boolean {
switch (name) {
case "ln":
case "log10":
case "log2":
return argument > 0;
case "sqrt":
return argument >= 0;
case "asin":
case "acos":
return argument >= -1 && argument <= 1;
case "factorial":
return argument > -1 || Math.round(argument) !== argument;
default:
return true;
}
}
/**
* Lanczos approximation of the gamma function (JavaScript has no tgamma).
* Accurate to well past the display precision used anywhere in this app.
*/
export function gamma(x: number): number {
if (Number.isNaN(x)) return NaN;
if (x === Math.round(x)) {
if (x <= 0) return NaN; // poles at non-positive integers
if (x <= 171) {
let result = 1;
for (let k = 2; k < x; k++) result *= k;
return result;
}
return Infinity;
}
if (x < 0.5) {
// Reflection formula.
return Math.PI / (Math.sin(Math.PI * x) * gamma(1 - x));
}
const g = 7;
const coefficients = [
0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313,
-176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6,
1.5056327351493116e-7,
];
const z = x - 1;
let sum = coefficients[0]!;
for (let index = 1; index < g + 2; index++) {
sum += coefficients[index]! / (z + index);
}
const t = z + g + 0.5;
return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * sum;
}