mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
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.
306 lines
9.8 KiB
TypeScript
306 lines
9.8 KiB
TypeScript
// Samples an expression into drawable graph data: segments, viewport,
|
||
// roots, and extrema.
|
||
|
||
import { type MathExpression, subtractExpr, variablesOf } from "./expression";
|
||
import { evaluateValue } from "./evaluator";
|
||
import { simplify } from "./simplifier";
|
||
import { Polynomial } from "./polynomial";
|
||
import { numericRoots } from "./solver";
|
||
import { fromDecimal, describeNumber } from "./math-number";
|
||
import { plain } from "./text-renderer";
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Plot model
|
||
|
||
export type GraphViewport = {
|
||
xMin: number;
|
||
xMax: number;
|
||
yMin: number;
|
||
yMax: number;
|
||
};
|
||
|
||
export const STANDARD_VIEWPORT: GraphViewport = { xMin: -10, xMax: 10, yMin: -10, yMax: 10 };
|
||
|
||
export function viewportContainsY(viewport: GraphViewport, y: number): boolean {
|
||
return y >= viewport.yMin && y <= viewport.yMax;
|
||
}
|
||
|
||
export type GraphPoint = { x: number; y: number };
|
||
|
||
/**
|
||
* One continuous run of the curve. A function with a pole produces several,
|
||
* so the renderer can lift the pen instead of drawing a vertical line through
|
||
* the asymptote — which is the single most recognisable "bad graphing app"
|
||
* artefact.
|
||
*/
|
||
export type GraphSegment = { points: GraphPoint[] };
|
||
|
||
export type GraphMarkerKind = "root" | "yIntercept" | "extremum" | "intersection";
|
||
|
||
export type GraphMarker = {
|
||
kind: GraphMarkerKind;
|
||
point: GraphPoint;
|
||
label: string;
|
||
};
|
||
|
||
export type GraphPlot = {
|
||
expression: MathExpression;
|
||
variable: string;
|
||
segments: GraphSegment[];
|
||
markers: GraphMarker[];
|
||
label: string;
|
||
};
|
||
|
||
export type GraphAxis = { ticks: number[]; step: number };
|
||
|
||
export type Graph = {
|
||
plots: GraphPlot[];
|
||
viewport: GraphViewport;
|
||
xAxis: GraphAxis;
|
||
yAxis: GraphAxis;
|
||
};
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Plotter
|
||
|
||
/**
|
||
* Sample count. Matched to the glasses viewport width times a small factor:
|
||
* enough that a curve looks smooth after projection, few enough that plotting
|
||
* stays imperceptible on a phone.
|
||
*/
|
||
export const DEFAULT_SAMPLE_COUNT = 1_200;
|
||
|
||
/** Values beyond this are treated as a pole rather than a steep slope. */
|
||
const POLE_THRESHOLD = 1e7;
|
||
|
||
export function plot(
|
||
expressions: MathExpression[],
|
||
options: {
|
||
variable?: string;
|
||
viewport?: GraphViewport;
|
||
usesDegrees?: boolean;
|
||
sampleCount?: number;
|
||
} = {},
|
||
): Graph {
|
||
const usesDegrees = options.usesDegrees ?? false;
|
||
const sampleCount = options.sampleCount ?? DEFAULT_SAMPLE_COUNT;
|
||
const variable =
|
||
options.variable ??
|
||
expressions.map((expression) => variablesOf(expression)[0]).find((name) => name !== undefined) ??
|
||
"x";
|
||
|
||
// Autoscale y from the data when the caller did not pin a viewport, but
|
||
// keep x at the requested (or standard) window — rescaling both makes a
|
||
// graph that never matches what the user asked to see.
|
||
const xWindow = options.viewport ?? STANDARD_VIEWPORT;
|
||
const plots: GraphPlot[] = [];
|
||
const allY: number[] = [];
|
||
|
||
for (const expression of expressions) {
|
||
const body = functionBody(expression);
|
||
const sampled = sample(body, variable, xWindow.xMin, xWindow.xMax, sampleCount, usesDegrees);
|
||
for (const segment of sampled) {
|
||
for (const point of segment.points) allY.push(point.y);
|
||
}
|
||
plots.push({
|
||
expression: body,
|
||
variable,
|
||
segments: sampled,
|
||
markers: markers(body, variable, xWindow.xMin, xWindow.xMax),
|
||
label: plain(body),
|
||
});
|
||
}
|
||
|
||
const viewport = options.viewport ?? autoscale(xWindow, allY);
|
||
const clipped = plots.map((entry) => ({
|
||
expression: entry.expression,
|
||
variable: entry.variable,
|
||
segments: clip(entry.segments, viewport),
|
||
markers: entry.markers.filter((marker) => viewportContainsY(viewport, marker.point.y)),
|
||
label: entry.label,
|
||
}));
|
||
|
||
return {
|
||
plots: clipped,
|
||
viewport,
|
||
xAxis: axis(viewport.xMin, viewport.xMax),
|
||
yAxis: axis(viewport.yMin, viewport.yMax),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* `y = x^2 + 1` and `x^2 + 1` should plot the same curve, and `x^2 + y = 1`
|
||
* should plot `y = 1 - x^2` where that is easy to see.
|
||
*/
|
||
export function functionBody(expression: MathExpression): MathExpression {
|
||
if (expression.type !== "relation") return expression;
|
||
if (expression.lhs.type === "variable" && expression.lhs.name === "y") return expression.rhs;
|
||
if (expression.rhs.type === "variable" && expression.rhs.name === "y") return expression.lhs;
|
||
// Otherwise plot the difference, whose zero set is the relation — the
|
||
// honest generalisation, and it makes an implicit curve's roots visible on
|
||
// the x-axis.
|
||
return simplify(subtractExpr(expression.lhs, expression.rhs));
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Sampling
|
||
|
||
export function sample(
|
||
expression: MathExpression,
|
||
variable: string,
|
||
xMin: number,
|
||
xMax: number,
|
||
count: number,
|
||
usesDegrees: boolean,
|
||
): GraphSegment[] {
|
||
if (count <= 1 || xMax <= xMin) return [];
|
||
const segments: GraphSegment[] = [];
|
||
let current: GraphPoint[] = [];
|
||
const step = (xMax - xMin) / (count - 1);
|
||
let previousY: number | null = null;
|
||
|
||
for (let index = 0; index < count; index++) {
|
||
const x = xMin + index * step;
|
||
const y = evaluateValue(expression, { [variable]: x }, usesDegrees);
|
||
if (y === null || !Number.isFinite(y) || Math.abs(y) >= POLE_THRESHOLD) {
|
||
// Undefined or blown up: close the run.
|
||
if (current.length > 1) segments.push({ points: current });
|
||
current = [];
|
||
previousY = null;
|
||
continue;
|
||
}
|
||
|
||
// A jump this large between adjacent samples is a pole, not a slope.
|
||
// tan(x) is the canonical case: without this the curve gets a vertical
|
||
// line at every asymptote.
|
||
if (previousY !== null && Math.abs(y - previousY) > (xMax - xMin) * 50) {
|
||
if (current.length > 1) segments.push({ points: current });
|
||
current = [];
|
||
}
|
||
current.push({ x, y });
|
||
previousY = y;
|
||
}
|
||
if (current.length > 1) segments.push({ points: current });
|
||
return segments;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Autoscale
|
||
|
||
/**
|
||
* Percentile-based rather than min/max: one spike near a pole would
|
||
* otherwise compress the interesting part of the curve into a flat line.
|
||
*/
|
||
export function autoscale(xWindow: GraphViewport, yValues: number[]): GraphViewport {
|
||
const finite = yValues.filter((y) => Number.isFinite(y) && Math.abs(y) < POLE_THRESHOLD).sort((a, b) => a - b);
|
||
if (finite.length <= 2) {
|
||
return { xMin: xWindow.xMin, xMax: xWindow.xMax, yMin: -10, yMax: 10 };
|
||
}
|
||
const lowIndex = Math.floor(finite.length * 0.02);
|
||
const highIndex = Math.floor(finite.length * 0.98);
|
||
let low = finite[Math.min(lowIndex, finite.length - 1)]!;
|
||
let high = finite[Math.min(highIndex, finite.length - 1)]!;
|
||
|
||
// Always show the x-axis when the curve comes near it — a graph that omits
|
||
// y = 0 reads as if the function never crosses.
|
||
if (low > 0 && low < high * 0.5) low = 0;
|
||
if (high < 0 && high > low * 0.5) high = 0;
|
||
|
||
if (high - low < 1e-9) {
|
||
const centre = (high + low) / 2;
|
||
low = centre - 1;
|
||
high = centre + 1;
|
||
}
|
||
const padding = (high - low) * 0.1;
|
||
return {
|
||
xMin: xWindow.xMin,
|
||
xMax: xWindow.xMax,
|
||
yMin: low - padding,
|
||
yMax: high + padding,
|
||
};
|
||
}
|
||
|
||
export function clip(segments: GraphSegment[], viewport: GraphViewport): GraphSegment[] {
|
||
const result: GraphSegment[] = [];
|
||
for (const segment of segments) {
|
||
let current: GraphPoint[] = [];
|
||
for (const point of segment.points) {
|
||
if (viewportContainsY(viewport, point.y)) {
|
||
current.push(point);
|
||
} else if (current.length > 0) {
|
||
// Keep one out-of-range point so the line exits the frame rather than
|
||
// stopping short of the edge.
|
||
current.push(point);
|
||
result.push({ points: current });
|
||
current = [];
|
||
}
|
||
}
|
||
if (current.length > 1) result.push({ points: current });
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Axes
|
||
|
||
/**
|
||
* "Nice" tick spacing — 1, 2, 5, 10 × 10^n — so labels are round numbers a
|
||
* person can read at a glance on the lens.
|
||
*/
|
||
export function axis(lower: number, upper: number, targetTicks = 10): GraphAxis {
|
||
const span = upper - lower;
|
||
if (span <= 0 || !Number.isFinite(span)) return { ticks: [], step: 1 };
|
||
const rough = span / targetTicks;
|
||
const magnitude = Math.pow(10, Math.floor(Math.log10(rough)));
|
||
const normalized = rough / magnitude;
|
||
let step: number;
|
||
if (normalized <= 1) step = magnitude;
|
||
else if (normalized <= 2) step = 2 * magnitude;
|
||
else if (normalized <= 5) step = 5 * magnitude;
|
||
else step = 10 * magnitude;
|
||
|
||
const ticks: number[] = [];
|
||
let value = Math.ceil(lower / step) * step;
|
||
while (value <= upper && ticks.length < 64) {
|
||
// Snap a near-zero tick to exactly zero so the axis line and its label
|
||
// agree.
|
||
ticks.push(Math.abs(value) < step * 1e-9 ? 0 : value);
|
||
value += step;
|
||
}
|
||
return { ticks, step };
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Markers
|
||
|
||
export function markers(
|
||
expression: MathExpression,
|
||
variable: string,
|
||
xMin: number,
|
||
xMax: number,
|
||
): GraphMarker[] {
|
||
const result: GraphMarker[] = [];
|
||
|
||
const yIntercept = evaluateValue(expression, { [variable]: 0 });
|
||
if (yIntercept !== null && Number.isFinite(yIntercept) && xMin <= 0 && xMax >= 0) {
|
||
result.push({
|
||
kind: "yIntercept",
|
||
point: { x: 0, y: yIntercept },
|
||
label: `(0, ${describeNumber(fromDecimal(yIntercept))})`,
|
||
});
|
||
}
|
||
|
||
// Roots: exact when the curve is a polynomial, sampled otherwise.
|
||
const polynomial = Polynomial.extract(expression, variable);
|
||
if (polynomial) {
|
||
for (const root of numericRoots(polynomial, [xMin, xMax], 4_000)) {
|
||
result.push({
|
||
kind: "root",
|
||
point: { x: root, y: 0 },
|
||
label: `(${describeNumber(fromDecimal(root))}, 0)`,
|
||
});
|
||
}
|
||
}
|
||
return result.slice(0, 12);
|
||
}
|