@danielsimonjr/mathts-functions 0.69.2 → 0.70.0

package/dist/scalar-batch-task-CZd6LPg9.js

@@ -0,0 +1,2587 @@
+import { BigNumber, Complex, DUAL_UNARY_RULES, Dual, Fraction, equal, fix, mathTyped, neumaierSum, norm2, pairwiseDot, pairwiseSum, pow, round, sumSquaredDeviations } from "@danielsimonjr/mathts-core";
+import { DenseMatrix, backendManager, singularValues } from "@danielsimonjr/mathts-matrix";
+import { computePool } from "@danielsimonjr/mathts-parallel";
+import { WasmModuleLoader, allocAsHeader, defaultWasmLocation, resolvePackagedWasm } from "@danielsimonjr/mathts-core/internal";
+import { ScalarBuildError, createScalarBuilder } from "@danielsimonjr/mathts-expression";
+//#region src/typed/euclid.ts
+function euclidSnap(a, b, snap) {
+	a = Math.abs(snap(a));
+	b = Math.abs(snap(b));
+	while (b !== 0) {
+		const t = b;
+		b = a % b;
+		a = t;
+	}
+	return a;
+}
+//#endregion
+//#region src/factories/matrix-bridge.ts
+backendManager.initialize().catch(() => {});
+function matrixIndexSelectors(index) {
+	const nDims = index.size().length;
+	const out = [];
+	for (let d = 0; d < nDims; d++) {
+		const sel = index.dimension(d);
+		if (typeof sel === "number") out.push([sel]);
+		else if (sel && typeof sel.toArray === "function") out.push(sel.toArray());
+		else out.push([Number(sel)]);
+	}
+	return out;
+}
+function _adaptCallbackArity(callback) {
+	const t = mathTyped;
+	if (t.isTypedFunction(callback)) {
+		let arity;
+		return (...args) => {
+			if (arity === void 0) {
+				for (let k = args.length; k >= 1; k--) if (t.resolve(callback, args.slice(0, k))) {
+					arity = k;
+					break;
+				}
+				if (arity === void 0) arity = args.length;
+			}
+			return callback(...args.slice(0, arity));
+		};
+	}
+	const declared = callback.length;
+	if (declared >= 1 && declared < 3) return (...args) => callback(...args.slice(0, declared));
+	return callback;
+}
+var MathJSDenseMatrix = class MathJSDenseMatrix {
+	_data;
+	_size;
+	_datatype;
+	constructor(data) {
+		if (!data) {
+			this._data = [];
+			this._size = [0, 0];
+		} else if (Array.isArray(data)) {
+			this._data = data;
+			this._size = inferSize(data);
+		} else {
+			this._data = data.data;
+			this._size = data.size;
+		}
+	}
+	get rows() {
+		return this._size[0] ?? 0;
+	}
+	get cols() {
+		return this._size[1] ?? 0;
+	}
+	storage() {
+		return "dense";
+	}
+	datatype() {
+		return this._datatype;
+	}
+	valueOf() {
+		return this._data;
+	}
+	size() {
+		return [...this._size];
+	}
+	toArray() {
+		if (this._size.length === 1) return [...this._data];
+		return this._data.map((row) => [...row]);
+	}
+	toJSON() {
+		return {
+			mathjs: "DenseMatrix",
+			data: this._data,
+			size: this._size
+		};
+	}
+	create(data, datatype) {
+		const m = new MathJSDenseMatrix(data);
+		m._datatype = datatype;
+		return m;
+	}
+	createDenseMatrix(opts) {
+		const m = new MathJSDenseMatrix(opts.data);
+		m._size = opts.size;
+		m._datatype = opts.datatype;
+		return m;
+	}
+	map(callback) {
+		const cb = _adaptCallbackArity(callback);
+		if (this._size.length === 1) {
+			const flat = this._data.map((val, i) => cb(val, [i], this));
+			return new MathJSDenseMatrix({
+				data: flat,
+				size: [...this._size]
+			});
+		}
+		const result = this._data.map((row, i) => row.map((val, j) => cb(val, [i, j], this)));
+		return new MathJSDenseMatrix(result);
+	}
+	forEach(callback) {
+		const cb = _adaptCallbackArity(callback);
+		if (this._size.length === 1) {
+			this._data.forEach((val, i) => cb(val, [i], this));
+			return;
+		}
+		this._data.forEach((row, i) => {
+			row.forEach((val, j) => cb(val, [i, j], this));
+		});
+	}
+	get(indexOrRow, col) {
+		const row = Array.isArray(indexOrRow) ? indexOrRow[0] : indexOrRow;
+		if (this._size.length === 1) return this._data[row];
+		const j = Array.isArray(indexOrRow) ? indexOrRow[1] : col;
+		return this._data[row][j];
+	}
+	set(index, value, _defaultValue) {
+		if (this._size.length === 1) this._data[index[0]] = value;
+		else this._data[index[0]][index[1]] = value;
+		return this;
+	}
+	subset(index, replacement, defaultValue) {
+		if (Array.isArray(index)) return replacement === void 0 ? this.get(index) : this.set(index, replacement, defaultValue);
+		const dims = matrixIndexSelectors(index);
+		return replacement === void 0 ? this._getSubset(index, dims) : this._setSubset(index, dims, replacement);
+	}
+	_getSubset(index, dims) {
+		if (index.isScalar()) return dims.length === 1 ? this._data[dims[0][0]] : this._data[dims[0][0]][dims[1][0]];
+		if (dims.length === 1) {
+			const picked = dims[0].map((i) => this._data[i]);
+			const m = new MathJSDenseMatrix(picked);
+			m._size = [dims[0].length];
+			return m;
+		}
+		const [rowSel, colSel] = dims;
+		return new MathJSDenseMatrix(rowSel.map((i) => colSel.map((j) => this._data[i][j])));
+	}
+	_setSubset(index, dims, replacement) {
+		if (index.isScalar()) {
+			if (dims.length === 1) this._data[dims[0][0]] = replacement;
+			else this._data[dims[0][0]][dims[1][0]] = replacement;
+			return this;
+		}
+		const rep = replacement.toArray ? replacement.toArray() : replacement;
+		const [rowSel, colSel] = dims.length === 2 ? dims : [dims[0], [0]];
+		for (let ri = 0; ri < rowSel.length; ri++) for (let ci = 0; ci < colSel.length; ci++) {
+			const row = rep[ri];
+			const v = Array.isArray(row) ? row[ci] : row;
+			this._data[rowSel[ri]][colSel[ci]] = v;
+		}
+		return this;
+	}
+	clone() {
+		const copy = this._size.length === 1 ? [...this._data] : this._data.map((row) => [...row]);
+		const m = new MathJSDenseMatrix(copy);
+		m._size = [...this._size];
+		m._datatype = this._datatype;
+		return m;
+	}
+	resize(newSize, defaultValue) {
+		const fill = defaultValue ?? 0;
+		if (newSize.length === 1) {
+			const len = newSize[0];
+			const flat = [];
+			const oldData = this._data;
+			for (let i = 0; i < len; i++) flat.push(i < (this._size[0] ?? 0) ? oldData[i] ?? fill : fill);
+			this._data = flat;
+			this._size = [len];
+			return this;
+		}
+		const [rows, cols] = newSize;
+		const data = [];
+		const oldRows = this._size[0] ?? 0;
+		const oldCols = this._size[1] ?? 0;
+		for (let i = 0; i < rows; i++) {
+			const row = [];
+			for (let j = 0; j < cols; j++) row.push(i < oldRows && j < oldCols && this._data[i] ? this._data[i][j] ?? fill : fill);
+			data.push(row);
+		}
+		this._data = data;
+		this._size = [rows, cols];
+		return this;
+	}
+	reshape(newSize) {
+		const flat = [];
+		for (const row of this._data) for (const val of row) flat.push(val);
+		const [rows, cols] = newSize;
+		const data = [];
+		for (let i = 0; i < rows; i++) {
+			const row = [];
+			for (let j = 0; j < cols; j++) row.push(flat[i * cols + j] ?? 0);
+			data.push(row);
+		}
+		return new MathJSDenseMatrix({
+			data,
+			size: [rows, cols]
+		});
+	}
+	diagonal(k = 0) {
+		const [rows, cols] = this._size;
+		const kRow = k < 0 ? -k : 0;
+		const kCol = k > 0 ? k : 0;
+		const diagLen = Math.min(rows - kRow, cols - kCol);
+		const values = [];
+		for (let i = 0; i < diagLen; i++) values.push(this._data[kRow + i][kCol + i]);
+		const m = new MathJSDenseMatrix();
+		m._data = values;
+		m._size = [diagLen];
+		return m;
+	}
+	getDataType() {
+		return this._datatype ?? "number";
+	}
+	multiply(other) {
+		const result = backendManager.multiply(this.toNative(), other.toNative());
+		return MathJSDenseMatrix.fromNative(result);
+	}
+	transpose() {
+		const result = backendManager.transpose(this.toNative());
+		return MathJSDenseMatrix.fromNative(result);
+	}
+	toNative() {
+		return DenseMatrix.fromArray(this._data);
+	}
+	static fromNative(dm) {
+		return new MathJSDenseMatrix(dm.toArray());
+	}
+	static _swapRows(i, j, data) {
+		const vi = data[i];
+		data[i] = data[j];
+		data[j] = vi;
+	}
+	static diagonal(size, value, k = 0, defaultValue = 0) {
+		const [rows, cols] = size;
+		const data = Array.from({ length: rows }, () => new Array(cols).fill(defaultValue));
+		const kRow = k < 0 ? -k : 0;
+		const kCol = k > 0 ? k : 0;
+		const diagLen = Math.min(rows - kRow, cols - kCol);
+		for (let i = 0; i < diagLen; i++) {
+			const val = Array.isArray(value) ? value[i] : value;
+			data[kRow + i][kCol + i] = val;
+		}
+		return new MathJSDenseMatrix({
+			data,
+			size: [rows, cols]
+		});
+	}
+};
+Object.defineProperty(MathJSDenseMatrix.prototype, "isDenseMatrix", {
+	value: true,
+	writable: false,
+	enumerable: false
+});
+Object.defineProperty(MathJSDenseMatrix.prototype, "isMatrix", {
+	value: true,
+	writable: false,
+	enumerable: false
+});
+Object.defineProperty(MathJSDenseMatrix.prototype, "type", {
+	value: "DenseMatrix",
+	writable: true,
+	configurable: true,
+	enumerable: false
+});
+var MathJSSparseMatrix = class MathJSSparseMatrix {
+	_values;
+	_index;
+	_ptr;
+	_size;
+	_datatype;
+	constructor(data) {
+		if (!data) {
+			this._values = [];
+			this._index = [];
+			this._ptr = [0];
+			this._size = [0, 0];
+			return;
+		}
+		if (Array.isArray(data)) {
+			this._values = [];
+			this._index = [];
+			this._ptr = [];
+			this._size = [];
+			this._fromDenseArray(data);
+			return;
+		}
+		if (data.data) {
+			this._values = [];
+			this._index = [];
+			this._ptr = [];
+			this._size = [];
+			this._fromDenseArray(data.data);
+			this._datatype = data.datatype ?? data._datatype;
+			return;
+		}
+		const values = data.values !== void 0 ? data.values : data._values;
+		const index = data.index ?? data._index;
+		const ptr = data.ptr ?? data._ptr;
+		const size = data.size ?? data._size;
+		this._values = values != null ? values : null;
+		this._index = index ?? [];
+		this._ptr = ptr ?? [0];
+		this._size = size ?? [0, 0];
+		this._datatype = data.datatype ?? data._datatype;
+	}
+	_fromDenseArray(data) {
+		const rows = data.length;
+		const cols = rows > 0 && Array.isArray(data[0]) ? data[0].length : 0;
+		this._values = [];
+		this._index = [];
+		this._ptr = [0];
+		this._size = [rows, cols];
+		for (let j = 0; j < cols; j++) {
+			for (let i = 0; i < rows; i++) {
+				const v = data[i][j];
+				if (v !== 0 && v != null) {
+					this._values.push(v);
+					this._index.push(i);
+				}
+			}
+			this._ptr.push(this._values.length);
+		}
+	}
+	get rows() {
+		return this._size[0] ?? 0;
+	}
+	get cols() {
+		return this._size[1] ?? 0;
+	}
+	storage() {
+		return "sparse";
+	}
+	datatype() {
+		return this._datatype;
+	}
+	size() {
+		return [...this._size];
+	}
+	get(index) {
+		const [i, j] = index;
+		if (j < 0 || j >= this._size[1] || i < 0 || i >= this._size[0]) throw new RangeError(`Index out of range (${i}, ${j}) for matrix of size [${this._size}]`);
+		for (let k = this._ptr[j]; k < this._ptr[j + 1]; k++) if (this._index[k] === i) return this._values ? this._values[k] : 1;
+		return 0;
+	}
+	set(index, value, _defaultValue) {
+		const [i, j] = index;
+		if (i >= this._size[0]) this._size[0] = i + 1;
+		if (j >= this._size[1]) {
+			while (this._ptr.length <= j + 1) this._ptr.push(this._ptr[this._ptr.length - 1]);
+			this._size[1] = j + 1;
+		}
+		const start = this._ptr[j];
+		const end = this._ptr[j + 1];
+		let pos = start;
+		while (pos < end && this._index[pos] < i) pos++;
+		if (pos < end && this._index[pos] === i) {
+			if (value === 0) {
+				this._index.splice(pos, 1);
+				if (this._values) this._values.splice(pos, 1);
+				for (let c = j + 1; c < this._ptr.length; c++) this._ptr[c]--;
+			} else if (this._values) this._values[pos] = value;
+		} else if (value !== 0) {
+			this._index.splice(pos, 0, i);
+			if (this._values) this._values.splice(pos, 0, value);
+			for (let c = j + 1; c < this._ptr.length; c++) this._ptr[c]++;
+		}
+		return this;
+	}
+	valueOf() {
+		const [rows, cols] = this._size;
+		const result = Array.from({ length: rows }, () => new Array(cols).fill(0));
+		for (let j = 0; j < cols; j++) for (let k = this._ptr[j]; k < this._ptr[j + 1]; k++) result[this._index[k]][j] = this._values ? this._values[k] : 1;
+		return result;
+	}
+	toArray() {
+		return this.valueOf();
+	}
+	clone() {
+		const m = new MathJSSparseMatrix({
+			values: this._values ? [...this._values] : null,
+			index: [...this._index],
+			ptr: [...this._ptr],
+			size: [...this._size]
+		});
+		m._datatype = this._datatype;
+		return m;
+	}
+	create(data, datatype) {
+		const m = new MathJSSparseMatrix(data);
+		m._datatype = datatype;
+		return m;
+	}
+	createSparseMatrix(opts) {
+		return new MathJSSparseMatrix(opts);
+	}
+	map(callback) {
+		const [rows, cols] = this._size;
+		const newValues = [];
+		const newIndex = [];
+		const newPtr = [0];
+		for (let j = 0; j < cols; j++) {
+			for (let k = this._ptr[j]; k < this._ptr[j + 1]; k++) {
+				const i = this._index[k];
+				const result = callback(this._values ? this._values[k] : 1, [i, j], this);
+				if (result !== 0) {
+					newValues.push(result);
+					newIndex.push(i);
+				}
+			}
+			newPtr.push(newValues.length);
+		}
+		const m = new MathJSSparseMatrix({
+			values: newValues,
+			index: newIndex,
+			ptr: newPtr,
+			size: [rows, cols]
+		});
+		m._datatype = this._datatype;
+		return m;
+	}
+	forEach(callback) {
+		const cols = this._size[1];
+		for (let j = 0; j < cols; j++) for (let k = this._ptr[j]; k < this._ptr[j + 1]; k++) {
+			const i = this._index[k];
+			callback(this._values ? this._values[k] : 1, [i, j], this);
+		}
+	}
+	resize(newSize, _defaultValue) {
+		const [newRows, newCols] = newSize;
+		const oldCols = this._size[1];
+		if (newCols < oldCols) {
+			const nnzKeep = this._ptr[newCols];
+			this._values = this._values ? this._values.slice(0, nnzKeep) : null;
+			this._index = this._index.slice(0, nnzKeep);
+			this._ptr = this._ptr.slice(0, newCols + 1);
+		} else if (newCols > oldCols) {
+			const lastNnz = this._ptr[this._ptr.length - 1];
+			while (this._ptr.length <= newCols) this._ptr.push(lastNnz);
+		}
+		if (newRows < this._size[0]) {
+			const vals = [];
+			const idx = [];
+			const ptr = [0];
+			const cols = Math.min(newCols, this._ptr.length - 1);
+			for (let j = 0; j < cols; j++) {
+				for (let k = this._ptr[j]; k < this._ptr[j + 1]; k++) if (this._index[k] < newRows) {
+					if (this._values) vals.push(this._values[k]);
+					idx.push(this._index[k]);
+				}
+				ptr.push(idx.length);
+			}
+			this._values = this._values ? vals : null;
+			this._index = idx;
+			this._ptr = ptr;
+		}
+		this._size = [newRows, newCols];
+		return this;
+	}
+	toJSON() {
+		return {
+			mathjs: "SparseMatrix",
+			values: this._values,
+			index: this._index,
+			ptr: this._ptr,
+			size: this._size
+		};
+	}
+	toString() {
+		const lines = [];
+		const cols = this._size[1];
+		for (let j = 0; j < cols; j++) for (let k = this._ptr[j]; k < this._ptr[j + 1]; k++) {
+			const v = this._values ? this._values[k] : 1;
+			lines.push(`    (${this._index[k]}, ${j}) ==> ${v}`);
+		}
+		return `Sparse Matrix [${this._size[0]} x ${this._size[1]}] (${this._index.length} non-zero)\n` + lines.join("\n");
+	}
+	static diagonal(size, value, k = 0, defaultValue = 0, _datatype) {
+		const [rows, cols] = size;
+		const kRow = k < 0 ? -k : 0;
+		const kCol = k > 0 ? k : 0;
+		const diagLen = Math.min(rows - kRow, cols - kCol);
+		const values = [];
+		const index = [];
+		const ptr = [0];
+		for (let j = 0; j < cols; j++) {
+			const diagIdx = j - kCol;
+			if (diagIdx >= 0 && diagIdx < diagLen) {
+				const v = Array.isArray(value) ? value[diagIdx] : value;
+				if (v !== 0 && v !== defaultValue) {
+					values.push(v);
+					index.push(kRow + diagIdx);
+				}
+			}
+			ptr.push(values.length);
+		}
+		return new MathJSSparseMatrix({
+			values,
+			index,
+			ptr,
+			size: [rows, cols]
+		});
+	}
+	static _swapRows(j, pi, n, values, index, ptr) {
+		for (let c = 0; c < n; c++) {
+			let jPos = -1;
+			let piPos = -1;
+			for (let k = ptr[c]; k < ptr[c + 1]; k++) {
+				if (index[k] === j) jPos = k;
+				if (index[k] === pi) piPos = k;
+			}
+			if (jPos !== -1 && piPos !== -1) {
+				if (values) {
+					const tmp = values[jPos];
+					values[jPos] = values[piPos];
+					values[piPos] = tmp;
+				}
+			} else if (jPos !== -1) {
+				const vj = values ? values[jPos] : void 0;
+				index.splice(jPos, 1);
+				if (values) values.splice(jPos, 1);
+				let insertPos = ptr[c];
+				const endPos = ptr[c + 1] - 1;
+				while (insertPos <= endPos && index[insertPos] < pi) insertPos++;
+				index.splice(insertPos, 0, pi);
+				if (values) values.splice(insertPos, 0, vj);
+			} else if (piPos !== -1) {
+				const vpi = values ? values[piPos] : void 0;
+				index.splice(piPos, 1);
+				if (values) values.splice(piPos, 1);
+				let insertPos = ptr[c];
+				const endPos = ptr[c + 1] - 1;
+				while (insertPos <= endPos && index[insertPos] < j) insertPos++;
+				index.splice(insertPos, 0, j);
+				if (values) values.splice(insertPos, 0, vpi);
+			}
+		}
+	}
+	static _forEachRow(j, values, index, ptr, callback) {
+		const n = ptr.length - 1;
+		for (let c = 0; c < n; c++) for (let k = ptr[c]; k < ptr[c + 1]; k++) if (index[k] === j) callback(c, values ? values[k] : 1);
+	}
+};
+Object.defineProperty(MathJSSparseMatrix.prototype, "isDenseMatrix", {
+	value: false,
+	writable: false,
+	enumerable: false
+});
+Object.defineProperty(MathJSSparseMatrix.prototype, "isSparseMatrix", {
+	value: true,
+	writable: false,
+	enumerable: false
+});
+Object.defineProperty(MathJSSparseMatrix.prototype, "isMatrix", {
+	value: true,
+	writable: false,
+	enumerable: false
+});
+Object.defineProperty(MathJSSparseMatrix.prototype, "type", {
+	value: "SparseMatrix",
+	writable: false,
+	enumerable: false
+});
+function createMatrixBridge() {
+	return function matrix(data, storageType) {
+		if (typeof data === "string") return data === "sparse" ? new MathJSSparseMatrix() : new MathJSDenseMatrix();
+		if (!data) return storageType === "sparse" ? new MathJSSparseMatrix() : new MathJSDenseMatrix();
+		if (data instanceof MathJSSparseMatrix) return data;
+		if (data instanceof MathJSDenseMatrix) {
+			if (storageType === "sparse") return new MathJSSparseMatrix(data._data);
+			return data;
+		}
+		return storageType === "sparse" ? new MathJSSparseMatrix(data) : new MathJSDenseMatrix(data);
+	};
+}
+function inferSize(data) {
+	if (data.length === 0) return [0];
+	if (Array.isArray(data[0])) return [data.length, data[0].length];
+	return [data.length];
+}
+//#endregion
+//#region src/wasm/resolve.ts
+async function resolveBrowserWasm(metaUrl, wasmFile) {
+	let dir = new URL(".", metaUrl);
+	for (let depth = 0; depth < 8; depth++) {
+		const candidates = [new URL(`wasm/${wasmFile}`, dir), new URL(`dist/wasm/${wasmFile}`, dir)];
+		for (const candidate of candidates) try {
+			if ((await fetch(candidate.href, { method: "HEAD" })).ok) return candidate.href;
+		} catch {}
+		const parent = new URL("../", dir);
+		if (parent.href === dir.href) break;
+		dir = parent;
+	}
+	return new URL(`./wasm/${wasmFile}`, metaUrl).href;
+}
+const wasmLoader = class WasmLoader extends WasmModuleLoader {
+	static instance = null;
+	constructor() {
+		super();
+	}
+	static getInstance() {
+		if (!WasmLoader.instance) WasmLoader.instance = new WasmLoader();
+		return WasmLoader.instance;
+	}
+	async getDefaultWasmPath() {
+		const wasmFile = "mathts-as.wasm";
+		if (this.isNode) {
+			const packaged = await resolvePackagedWasm(import.meta.url, wasmFile);
+			if (packaged) return packaged;
+			return defaultWasmLocation(import.meta.url, wasmFile);
+		}
+		return resolveBrowserWasm(import.meta.url, wasmFile);
+	}
+	getModule() {
+		return this.wasmModule;
+	}
+	getCompiledModule() {
+		return this.compiledModule;
+	}
+	isLoaded() {
+		return this.wasmModule !== null;
+	}
+	isPrecompiled() {
+		return this.compiledModule !== null;
+	}
+	getLoadingMetrics() {
+		return this.lastMetrics;
+	}
+	collect() {
+		const module = this.wasmModule;
+		if (!module) return;
+		module.__collect();
+	}
+	reset() {
+		this.wasmModule = null;
+		this.compiledModule = null;
+		this.loading = null;
+		this.lastMetrics = null;
+	}
+}.getInstance();
+const INTEGRITY_FAILURE = "WASM integrity check failed";
+async function loadWasm(wasmPath) {
+	try {
+		await wasmLoader.load(wasmPath);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith(INTEGRITY_FAILURE)) throw error;
+		return false;
+	}
+}
+function isWasmLoaded() {
+	return wasmLoader.isLoaded();
+}
+//#endregion
+//#region src/wasm/policy.ts
+const WASM_DISPATCH_POLICY = {
+	array_abs_ptr: { min: 1024 },
+	array_log10_ptr: { min: 1024 },
+	array_sin_ptr: {
+		min: 1024,
+		max: 131072
+	},
+	array_log1p_ptr: {
+		min: 1024,
+		max: 16384
+	},
+	array_cos_ptr: { min: 16384 },
+	array_atanh_ptr: { min: 16384 },
+	array_log_ptr: { min: 16384 },
+	array_sec_ptr: {
+		min: 16384,
+		max: 1048576
+	},
+	fused_chain: { min: 1024 },
+	poly_fit_f64: { min: 1024 },
+	cheb_fit_f64: { min: 1024 },
+	legendre_fit_f64: { min: 1024 },
+	lgamma_f64: { min: 1048576 },
+	sort_f64: { min: 1048576 }
+};
+function wasmPolicyAllows(kernel, n) {
+	const band = WASM_DISPATCH_POLICY[kernel];
+	return band != null && n >= band.min && (band.max === void 0 || n < band.max);
+}
+//#endregion
+//#region src/wasm/bridges/common.ts
+function getWasm() {
+	try {
+		return wasmLoader.getModule();
+	} catch {
+		return null;
+	}
+}
+function isAsWasm(wasm) {
+	return !!wasm && typeof wasm["array_sin_ptr"] === "function";
+}
+let scratchBase = -1;
+function ensureScratch(mem, need) {
+	if (scratchBase < 0) scratchBase = mem.buffer.byteLength;
+	if (scratchBase + need > mem.buffer.byteLength) mem.grow(Math.ceil((scratchBase + need - mem.buffer.byteLength) / 65536));
+	return scratchBase;
+}
+function runUnaryPtr(mem, fn, xs) {
+	return runChainPtr(mem, [fn], xs);
+}
+function runChainPtr(mem, fns, xs) {
+	const n = xs.length;
+	try {
+		const base = ensureScratch(mem, 2 * n * 8);
+		const bufA = base;
+		const bufB = base + n * 8;
+		new Float64Array(mem.buffer, bufA, n).set(xs);
+		let cur = bufA;
+		let other = bufB;
+		for (const fn of fns) {
+			fn(cur, other, n);
+			const t = cur;
+			cur = other;
+			other = t;
+		}
+		const result = new Float64Array(n);
+		result.set(new Float64Array(mem.buffer, cur, n));
+		return result;
+	} catch {
+		return null;
+	}
+}
+const AS_ID_FLOAT64_ARRAY = 5;
+const AS_ID_INT32_ARRAY = 6;
+function resetAsHeap(mod) {
+	if (typeof mod.heap_reset === "function") mod.heap_reset();
+}
+function asUnpin(mod, a) {
+	mod.__unpin(a.headerPtr);
+	mod.__unpin(a.bufferPtr);
+}
+function asReadReturned(mod, headerPtr, Ctor, shift) {
+	const dv = new DataView(mod.memory.buffer);
+	const dataStart = dv.getUint32((headerPtr >>> 0) + 4, true);
+	const len = dv.getUint32((headerPtr >>> 0) + 8, true) >>> shift;
+	return new Ctor(new Ctor(mod.memory.buffer, dataStart, len));
+}
+function asReadReturnedF64(mod, headerPtr) {
+	return asReadReturned(mod, headerPtr, Float64Array, 3);
+}
+function asReadReturnedI32(mod, headerPtr) {
+	return asReadReturned(mod, headerPtr, Int32Array, 2);
+}
+function withAsTyped(wasm, inputs, body, opts) {
+	const mod = wasm;
+	if (typeof mod.__new !== "function" || typeof mod.__unpin !== "function") return null;
+	const allocs = [];
+	try {
+		const headers = [];
+		for (const arr of inputs) {
+			const a = allocAsHeader(mod, arr.length * opts.bytes, opts.typeId);
+			new opts.Ctor(mod.memory.buffer, a.bufferPtr, arr.length).set(arr);
+			allocs.push(a);
+			headers.push(a.headerPtr);
+		}
+		return body(mod, headers);
+	} catch {
+		return null;
+	} finally {
+		for (const a of allocs) try {
+			asUnpin(mod, a);
+		} catch {}
+		try {
+			resetAsHeap(mod);
+		} catch {}
+	}
+}
+function withAsF64(wasm, inputs, body) {
+	return withAsTyped(wasm, inputs, body, {
+		bytes: 8,
+		typeId: AS_ID_FLOAT64_ARRAY,
+		Ctor: Float64Array
+	});
+}
+function withAsI32(wasm, inputs, body) {
+	return withAsTyped(wasm, inputs, body, {
+		bytes: 4,
+		typeId: AS_ID_INT32_ARRAY,
+		Ctor: Int32Array
+	});
+}
+function makeUnaryArrayDispatch(cfg) {
+	return (xs) => {
+		if (xs.length >= cfg.threshold && wasmPolicyAllows(cfg.name, xs.length)) {
+			const wasm = getWasm();
+			if (wasm && isAsWasm(wasm)) {
+				const out = withAsF64(wasm, [xs], (mod, [h]) => asReadReturnedF64(mod, mod[cfg.name](h)));
+				if (out) return out;
+			}
+		}
+		return cfg.js(xs);
+	};
+}
+const kernelName = (op) => `array_${op}_ptr`;
+function elementwiseUnaryDispatch(op, xs) {
+	const n = xs.length;
+	if (n < 1024 || !wasmPolicyAllows(kernelName(op), n)) return null;
+	const wasm = getWasm();
+	if (!wasm) return null;
+	const fn = wasm[kernelName(op)];
+	const mem = wasm.memory;
+	if (typeof fn !== "function" || !(mem instanceof WebAssembly.Memory)) return null;
+	return runUnaryPtr(mem, fn, xs);
+}
+function elementwiseChainDispatch(ops, xs) {
+	const n = xs.length;
+	if (ops.length === 0 || n < 1024) return null;
+	if (!wasmPolicyAllows("fused_chain", n)) return null;
+	const wasm = getWasm();
+	if (!wasm) return null;
+	const mem = wasm.memory;
+	if (!(mem instanceof WebAssembly.Memory)) return null;
+	const kernels = [];
+	for (const op of ops) {
+		const fn = wasm[kernelName(op)];
+		if (typeof fn !== "function") return null;
+		kernels.push(fn);
+	}
+	return runChainPtr(mem, kernels, xs);
+}
+//#endregion
+//#region src/typed/arithmetic.ts
+function elementwise(op, a, b) {
+	const aArr = Array.isArray(a);
+	const bArr = Array.isArray(b);
+	if (aArr && bArr) {
+		if (a.length !== b.length) throw new RangeError(`Dimension mismatch (${a.length} != ${b.length}) in element-wise operation`);
+		return a.map((x, i) => elementwise(op, x, b[i]));
+	}
+	if (aArr) return a.map((x) => elementwise(op, x, b));
+	if (bArr) return b.map((y) => elementwise(op, a, y));
+	return op(a, b);
+}
+const numberBinCache = /* @__PURE__ */ new WeakMap();
+function getNumberBin(tf, fallback) {
+	let f = numberBinCache.get(tf);
+	if (!f) {
+		let found = null;
+		try {
+			found = mathTyped.find(tf, ["number", "number"]);
+		} catch {
+			found = null;
+		}
+		f = found ?? ((a, b) => fallback(a, b));
+		numberBinCache.set(tf, f);
+	}
+	return f;
+}
+function arrayAllNumbersFlat(a) {
+	for (let i = 0; i < a.length; i++) if (typeof a[i] !== "number") return false;
+	return true;
+}
+function arrayAllNumbersPair(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (typeof a[i] !== "number" || typeof b[i] !== "number") return false;
+	return true;
+}
+function elementwiseNumber(tf, fallback, a, b) {
+	const f = getNumberBin(tf, fallback);
+	const aArr = Array.isArray(a);
+	const bArr = Array.isArray(b);
+	if (aArr && bArr) {
+		if (a.length !== b.length) throw new RangeError(`Dimension mismatch (${a.length} != ${b.length}) in element-wise operation`);
+		if (a.constructor !== Array || b.constructor !== Array) return elementwise(fallback, a, b);
+		if (a.length > 0 && (Array.isArray(a[0]) || Array.isArray(b[0]))) {
+			const out = new Array(a.length);
+			for (let i = 0; i < a.length; i++) out[i] = elementwiseNumber(tf, fallback, a[i], b[i]);
+			return out;
+		}
+		if (arrayAllNumbersPair(a, b)) {
+			const n = a.length;
+			const out = new Array(n);
+			for (let i = 0; i < n; i++) out[i] = f(a[i], b[i]);
+			return out;
+		}
+		return elementwise(fallback, a, b);
+	}
+	if (aArr) {
+		if (a.constructor !== Array || typeof b !== "number") return elementwise(fallback, a, b);
+		if (a.length > 0 && Array.isArray(a[0])) return a.map((x) => elementwiseNumber(tf, fallback, x, b));
+		if (arrayAllNumbersFlat(a)) {
+			const out = new Array(a.length);
+			for (let i = 0; i < a.length; i++) out[i] = f(a[i], b);
+			return out;
+		}
+		return elementwise(fallback, a, b);
+	}
+	if (bArr) {
+		if (b.constructor !== Array || typeof a !== "number") return elementwise(fallback, a, b);
+		if (b.length > 0 && Array.isArray(b[0])) return b.map((y) => elementwiseNumber(tf, fallback, a, y));
+		if (arrayAllNumbersFlat(b)) {
+			const out = new Array(b.length);
+			for (let i = 0; i < b.length; i++) out[i] = f(a, b[i]);
+			return out;
+		}
+		return elementwise(fallback, a, b);
+	}
+	return fallback(a, b);
+}
+function elementwiseMatrixNumber(tf, fallback, a, b) {
+	const data = elementwiseNumber(tf, fallback, toNested(a), toNested(b));
+	return isSparseStorage(a) || isSparseStorage(b) ? new MathJSSparseMatrix(data) : new MathJSDenseMatrix(data);
+}
+function isSparseStorage(m) {
+	const s = m.storage;
+	return typeof s === "function" && s.call(m) === "sparse";
+}
+function toNested(m) {
+	const t = m.toArray;
+	return typeof t === "function" ? t.call(m) : m;
+}
+const addOp = (x, y) => add(x, y);
+const subOp = (x, y) => subtract(x, y);
+const mulOp = (x, y) => multiply(x, y);
+const addForNumberPath = {};
+const subtractForNumberPath = {};
+const multiplyForNumberPath = {};
+const asUnit = (u) => u;
+function unitSameDimension(a, b) {
+	return asUnit(a).equalBase(b);
+}
+function unitCmp(a, b) {
+	if (!unitSameDimension(a, b)) throw new Error("Cannot compare units with different dimensions");
+	const va = asUnit(a).value;
+	const vb = asUnit(b).value;
+	return va > vb ? 1 : va < vb ? -1 : 0;
+}
+function unitAddSub(a, b, op) {
+	const ua = asUnit(a);
+	const ub = asUnit(b);
+	if (!ua.equalBase(b)) throw new Error("Cannot add/subtract units with different dimensions");
+	if (ua.value == null || ub.value == null) throw new Error("Cannot add/subtract a valueless unit");
+	const res = ua.clone();
+	res.value = op(ua.value, ub.value);
+	return res;
+}
+const unitAdd = (a, b) => unitAddSub(a, b, addOp);
+const unitSub = (a, b) => unitAddSub(a, b, (x, y) => subtract(x, y));
+const unitMul = (a, b) => asUnit(a).multiply(b);
+const unitDiv = (a, b) => asUnit(a).divide(b);
+const add = mathTyped("add", {
+	"number, number": (a, b) => a + b,
+	"bigint, bigint": (a, b) => a + b,
+	"Complex, Complex": (a, b) => a.add(b),
+	"Fraction, Fraction": (a, b) => a.add(b),
+	"BigNumber, BigNumber": (a, b) => a.add(b),
+	"Unit, Unit": (a, b) => unitAdd(a, b),
+	"Dual, Dual": (a, b) => a.add(b),
+	"Dual, number": (a, b) => a.add(Dual.constant(b)),
+	"number, Dual": (a, b) => Dual.constant(a).add(b),
+	"number, Complex": (a, b) => Complex.fromNumber(a).add(b),
+	"Complex, number": (a, b) => a.add(Complex.fromNumber(b)),
+	"number, Fraction": (a, b) => Fraction.fromNumber(a).add(b),
+	"Fraction, number": (a, b) => a.add(Fraction.fromNumber(b)),
+	"number, BigNumber": (a, b) => BigNumber.fromNumber(a).add(b),
+	"BigNumber, number": (a, b) => a.add(BigNumber.fromNumber(b)),
+	"Float64Array, Float64Array": async (a, b) => {
+		return (await computePool.add(a, b)).result;
+	},
+	"Array, Array": (a, b) => elementwiseNumber(addForNumberPath.fn, addOp, a, b),
+	"Array, number": (a, b) => elementwiseNumber(addForNumberPath.fn, addOp, a, b),
+	"number, Array": (a, b) => elementwiseNumber(addForNumberPath.fn, addOp, a, b),
+	"DenseMatrix, DenseMatrix": (a, b) => elementwiseMatrixNumber(addForNumberPath.fn, addOp, a, b),
+	"SparseMatrix, SparseMatrix": (a, b) => elementwiseMatrixNumber(addForNumberPath.fn, addOp, a, b),
+	"DenseMatrix, number": (a, b) => elementwiseMatrixNumber(addForNumberPath.fn, addOp, a, b),
+	"number, DenseMatrix": (a, b) => elementwiseMatrixNumber(addForNumberPath.fn, addOp, a, b),
+	"SparseMatrix, number": (a, b) => elementwiseMatrixNumber(addForNumberPath.fn, addOp, a, b),
+	"number, SparseMatrix": (a, b) => elementwiseMatrixNumber(addForNumberPath.fn, addOp, a, b),
+	"any, any, ...any": (a, b, rest) => {
+		const op = add;
+		let result = op(a, b);
+		for (let i = 0; i < rest.length; i++) result = op(result, rest[i]);
+		return result;
+	}
+});
+addForNumberPath.fn = add;
+const subtract = mathTyped("subtract", {
+	"number, number": (a, b) => a - b,
+	"bigint, bigint": (a, b) => a - b,
+	"Complex, Complex": (a, b) => a.subtract(b),
+	"Fraction, Fraction": (a, b) => a.subtract(b),
+	"BigNumber, BigNumber": (a, b) => a.subtract(b),
+	"Unit, Unit": (a, b) => unitSub(a, b),
+	"Dual, Dual": (a, b) => a.sub(b),
+	"Dual, number": (a, b) => a.sub(Dual.constant(b)),
+	"number, Dual": (a, b) => Dual.constant(a).sub(b),
+	"number, Complex": (a, b) => Complex.fromNumber(a).subtract(b),
+	"Complex, number": (a, b) => a.subtract(Complex.fromNumber(b)),
+	"number, Fraction": (a, b) => Fraction.fromNumber(a).subtract(b),
+	"Fraction, number": (a, b) => a.subtract(Fraction.fromNumber(b)),
+	"number, BigNumber": (a, b) => BigNumber.fromNumber(a).subtract(b),
+	"BigNumber, number": (a, b) => a.subtract(BigNumber.fromNumber(b)),
+	"Float64Array, Float64Array": async (a, b) => {
+		return (await computePool.subtract(a, b)).result;
+	},
+	"Array, Array": (a, b) => elementwiseNumber(subtractForNumberPath.fn, subOp, a, b),
+	"Array, number": (a, b) => elementwiseNumber(subtractForNumberPath.fn, subOp, a, b),
+	"number, Array": (a, b) => elementwiseNumber(subtractForNumberPath.fn, subOp, a, b),
+	"DenseMatrix, DenseMatrix": (a, b) => elementwiseMatrixNumber(subtractForNumberPath.fn, subOp, a, b),
+	"SparseMatrix, SparseMatrix": (a, b) => elementwiseMatrixNumber(subtractForNumberPath.fn, subOp, a, b),
+	"DenseMatrix, number": (a, b) => elementwiseMatrixNumber(subtractForNumberPath.fn, subOp, a, b),
+	"number, DenseMatrix": (a, b) => elementwiseMatrixNumber(subtractForNumberPath.fn, subOp, a, b),
+	"SparseMatrix, number": (a, b) => elementwiseMatrixNumber(subtractForNumberPath.fn, subOp, a, b),
+	"number, SparseMatrix": (a, b) => elementwiseMatrixNumber(subtractForNumberPath.fn, subOp, a, b)
+});
+subtractForNumberPath.fn = subtract;
+const multiply = mathTyped("multiply", {
+	"number, number": (a, b) => a * b,
+	"bigint, bigint": (a, b) => a * b,
+	"Complex, Complex": (a, b) => a.multiply(b),
+	"Fraction, Fraction": (a, b) => a.multiply(b),
+	"BigNumber, BigNumber": (a, b) => a.multiply(b),
+	"Unit, Unit": (a, b) => unitMul(a, b),
+	"Unit, number": (a, b) => unitMul(a, b),
+	"number, Unit": (a, b) => unitMul(b, a),
+	"Dual, Dual": (a, b) => a.mul(b),
+	"Dual, number": (a, b) => a.mul(Dual.constant(b)),
+	"number, Dual": (a, b) => Dual.constant(a).mul(b),
+	"Array, Array": (a, b) => {
+		if (!Array.isArray(a[0]) || !Array.isArray(b[0])) throw new TypeError("multiply(Array, Array) requires two 2-D matrices; use dot() for vector dot products");
+		const A = DenseMatrix.fromArray(a);
+		const B = DenseMatrix.fromArray(b);
+		return backendManager.multiply(A, B).toArray();
+	},
+	"DenseMatrix, DenseMatrix": (a, b) => {
+		const A = DenseMatrix.fromArray(a.toArray());
+		const B = DenseMatrix.fromArray(b.toArray());
+		return new MathJSDenseMatrix(backendManager.multiply(A, B).toArray());
+	},
+	"number, Complex": (a, b) => b.multiply(Complex.fromNumber(a)),
+	"Complex, number": (a, b) => a.multiply(Complex.fromNumber(b)),
+	"number, Fraction": (a, b) => b.multiply(Fraction.fromNumber(a)),
+	"Fraction, number": (a, b) => a.multiply(Fraction.fromNumber(b)),
+	"number, BigNumber": (a, b) => b.multiply(BigNumber.fromNumber(a)),
+	"BigNumber, number": (a, b) => a.multiply(BigNumber.fromNumber(b)),
+	"Float64Array, Float64Array": async (a, b) => {
+		return (await computePool.multiply(a, b)).result;
+	},
+	"Float64Array, number": async (a, scalar) => {
+		return (await computePool.scale(a, scalar)).result;
+	},
+	"number, Float64Array": async (scalar, a) => {
+		return (await computePool.scale(a, scalar)).result;
+	},
+	"Array, number": (a, b) => elementwiseNumber(multiplyForNumberPath.fn, mulOp, a, b),
+	"number, Array": (a, b) => elementwiseNumber(multiplyForNumberPath.fn, mulOp, a, b),
+	"DenseMatrix, number": (a, b) => elementwiseMatrixNumber(multiplyForNumberPath.fn, mulOp, a, b),
+	"number, DenseMatrix": (a, b) => elementwiseMatrixNumber(multiplyForNumberPath.fn, mulOp, a, b),
+	"SparseMatrix, number": (a, b) => elementwiseMatrixNumber(multiplyForNumberPath.fn, mulOp, a, b),
+	"number, SparseMatrix": (a, b) => elementwiseMatrixNumber(multiplyForNumberPath.fn, mulOp, a, b),
+	"any, any, ...any": (a, b, rest) => {
+		const op = multiply;
+		let result = op(a, b);
+		for (let i = 0; i < rest.length; i++) result = op(result, rest[i]);
+		return result;
+	}
+});
+multiplyForNumberPath.fn = multiply;
+const divide = mathTyped("divide", {
+	"number, number": (a, b) => a / b,
+	"bigint, bigint": (a, b) => a / b,
+	"Complex, Complex": (a, b) => a.divide(b),
+	"Fraction, Fraction": (a, b) => a.divide(b),
+	"BigNumber, BigNumber": (a, b) => a.divide(b),
+	"Unit, Unit": (a, b) => unitDiv(a, b),
+	"Unit, number": (a, b) => unitDiv(a, b),
+	"Dual, Dual": (a, b) => a.div(b),
+	"Dual, number": (a, b) => a.div(Dual.constant(b)),
+	"number, Dual": (a, b) => Dual.constant(a).div(b),
+	"number, Complex": (a, b) => Complex.fromNumber(a).divide(b),
+	"Complex, number": (a, b) => a.divide(Complex.fromNumber(b)),
+	"number, Fraction": (a, b) => Fraction.fromNumber(a).divide(b),
+	"Fraction, number": (a, b) => a.divide(Fraction.fromNumber(b)),
+	"number, BigNumber": (a, b) => BigNumber.fromNumber(a).divide(b),
+	"BigNumber, number": (a, b) => a.divide(BigNumber.fromNumber(b)),
+	"Float64Array, Float64Array": async (a, b) => {
+		return (await computePool.divide(a, b)).result;
+	}
+});
+const unaryMinus = mathTyped("unaryMinus", {
+	number: (a) => -a,
+	bigint: (a) => -a,
+	Complex: (a) => a.negate(),
+	Fraction: (a) => a.negate(),
+	BigNumber: (a) => a.negate(),
+	Float64Array: async (a) => {
+		return (await computePool.negate(a)).result;
+	}
+});
+const unaryPlus = mathTyped("unaryPlus", {
+	number: (a) => +a,
+	bigint: (a) => a,
+	Complex: (a) => a,
+	Fraction: (a) => a,
+	BigNumber: (a) => a,
+	Float64Array: (a) => a
+});
+const abs = mathTyped("abs", {
+	number: (a) => Math.abs(a),
+	bigint: (a) => a < 0n ? -a : a,
+	Complex: (a) => a.abs(),
+	Fraction: (a) => a.abs(),
+	BigNumber: (a) => a.abs(),
+	Dual: (a) => a.abs(),
+	Unit: (a) => asUnit(a).abs(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("abs", a);
+		if (wasm) return wasm;
+		return (await computePool.abs(a)).result;
+	}
+});
+const sign = mathTyped("sign", {
+	number: (a) => Math.sign(a),
+	bigint: (a) => a > 0n ? 1n : a < 0n ? -1n : 0n,
+	Fraction: (a) => new Fraction(BigInt(a.sign()), 1n),
+	BigNumber: (a) => BigNumber.fromNumber(a.sign()),
+	Complex: (a) => {
+		const m = Math.hypot(a.re, a.im);
+		return m === 0 ? new Complex(0, 0) : new Complex(a.re / m, a.im / m);
+	},
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.sign(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.sign(a[i]);
+		return out;
+	}
+});
+const pow$1 = mathTyped("pow", {
+	"number, number": (a, b) => Math.pow(a, b),
+	"bigint, bigint": (a, b) => a ** b,
+	"Complex, number": (a, b) => pow(a, b),
+	"Complex, Complex": (a, b) => pow(a, b),
+	"Fraction, number": (a, b) => pow(a, b),
+	"BigNumber, number": (a, b) => pow(a, b),
+	"BigNumber, BigNumber": (a, b) => pow(a, b),
+	"Dual, number": (a, b) => a.powConst(b),
+	"Dual, Dual": (a, b) => a.pow(b),
+	"Unit, number": (a, b) => a.pow(b),
+	"Array, number": (a, b) => {
+		if (!Array.isArray(a[0])) throw new TypeError("pow(Array, number): expected a square 2-D matrix; use dotPow for element-wise power");
+		const m = a;
+		const n = m.length;
+		if (m.some((row) => row.length !== n)) throw new RangeError(`pow: matrix must be square (got ${n}×${m[0]?.length ?? 0})`);
+		if (!Number.isInteger(b) || b < 0) throw new Error("pow: only non-negative integer exponents are supported for matrices here; use matrixPower(A, p) for negative or fractional powers");
+		let result = DenseMatrix.identity(n);
+		let base = DenseMatrix.fromArray(m);
+		let e = b;
+		while (e > 0) {
+			if (e % 2 === 1) result = backendManager.multiply(result, base);
+			e = Math.floor(e / 2);
+			if (e > 0) base = backendManager.multiply(base, base);
+		}
+		return result.toArray();
+	}
+});
+const sqrt = mathTyped("sqrt", {
+	number: (a) => {
+		if (a < 0) return new Complex(0, Math.sqrt(-a));
+		return Math.sqrt(a);
+	},
+	Complex: (a) => a.sqrt(),
+	BigNumber: (a) => a.sqrt(),
+	Dual: (a) => a.sqrt(),
+	Float64Array: async (a) => {
+		return (await computePool.sqrt(a)).result;
+	}
+});
+const square = mathTyped("square", {
+	number: (a) => a * a,
+	bigint: (a) => a * a,
+	Complex: (a) => a.multiply(a),
+	Fraction: (a) => a.multiply(a),
+	BigNumber: (a) => a.multiply(a),
+	Dual: (a) => a.square(),
+	Float64Array: async (a) => {
+		return (await computePool.square(a)).result;
+	}
+});
+const cube = mathTyped("cube", {
+	number: (a) => a * a * a,
+	bigint: (a) => a * a * a,
+	Complex: (a) => a.multiply(a).multiply(a),
+	Fraction: (a) => a.multiply(a).multiply(a),
+	BigNumber: (a) => a.multiply(a).multiply(a),
+	Dual: (a) => a.powConst(3),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => x * x * x")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = a[i] * a[i] * a[i];
+		return out;
+	}
+});
+function cbrtAllRoots(z) {
+	const arg3 = z.arg() / 3;
+	const r = Math.cbrt(z.abs());
+	const rotate = (theta) => new Complex(r, 0).mul(new Complex(0, theta).exp());
+	return [
+		rotate(arg3),
+		rotate(arg3 + Math.PI * 2 / 3),
+		rotate(arg3 - Math.PI * 2 / 3)
+	];
+}
+const cbrt = mathTyped("cbrt", {
+	number: (a) => Math.cbrt(a),
+	Complex: (a) => a.pow(1 / 3),
+	BigNumber: (a) => a.cbrt(),
+	Dual: (a) => a.powConst(1 / 3),
+	"number, boolean": (a, allRoots) => {
+		const z = new Complex(a, 0);
+		return allRoots ? cbrtAllRoots(z) : cbrtAllRoots(z)[0];
+	},
+	"Complex, boolean": (a, allRoots) => {
+		return allRoots ? cbrtAllRoots(a) : cbrtAllRoots(a)[0];
+	},
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.cbrt(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.cbrt(a[i]);
+		return out;
+	}
+});
+const nthRoot = mathTyped("nthRoot", {
+	"number, number": (a, n) => Math.pow(a, 1 / n),
+	"Complex, number": (a, n) => a.pow(1 / n),
+	"BigNumber, number": (a, n) => a.pow(1 / n)
+});
+const exp = mathTyped("exp", {
+	number: (a) => Math.exp(a),
+	Complex: (a) => a.exp(),
+	BigNumber: (a) => a.exp(),
+	Dual: (a) => a.exp(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("exp", a);
+		if (wasm) return wasm;
+		return (await computePool.exp(a)).result;
+	}
+});
+const log = mathTyped("log", {
+	number: (a) => Math.log(a),
+	Complex: (a) => a.log(),
+	BigNumber: (a) => a.ln(),
+	Dual: (a) => a.log(),
+	"number, number": (a, base) => Math.log(a) / Math.log(base),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("log", a);
+		if (wasm) return wasm;
+		return (await computePool.log(a)).result;
+	}
+});
+const log10 = mathTyped("log10", {
+	number: (a) => Math.log10(a),
+	Complex: (a) => a.log().divide(Complex.fromNumber(Math.LN10)),
+	BigNumber: (a) => a.log10(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("log10", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.log10(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.log10(a[i]);
+		return out;
+	}
+});
+const log2 = mathTyped("log2", {
+	number: (a) => Math.log2(a),
+	Complex: (a) => a.log().divide(Complex.fromNumber(Math.LN2)),
+	BigNumber: (a) => a.log2(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("log2", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.log2(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.log2(a[i]);
+		return out;
+	}
+});
+const log1p = mathTyped("log1p", {
+	number: (a) => Math.log1p(a),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("log1p", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.log1p(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.log1p(a[i]);
+		return out;
+	}
+});
+const expm1 = mathTyped("expm1", {
+	number: (a) => Math.expm1(a),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("expm1", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.expm1(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.expm1(a[i]);
+		return out;
+	}
+});
+const round$1 = mathTyped("round", {
+	number: (a) => Math.round(a),
+	Fraction: (a) => round(a),
+	BigNumber: (a) => round(a),
+	Complex: (a) => round(a),
+	"number, number": (a, decimals) => {
+		const factor = Math.pow(10, decimals);
+		return Math.round(a * factor) / factor;
+	},
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.round(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.round(a[i]);
+		return out;
+	}
+});
+const floor = mathTyped("floor", {
+	number: (a) => Math.floor(a),
+	Fraction: (a) => a.floor(),
+	BigNumber: (a) => a.floor(),
+	Complex: (a) => new Complex(Math.floor(a.re), Math.floor(a.im)),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.floor(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.floor(a[i]);
+		return out;
+	}
+});
+const ceil = mathTyped("ceil", {
+	number: (a) => Math.ceil(a),
+	Fraction: (a) => a.ceil(),
+	BigNumber: (a) => a.ceil(),
+	Complex: (a) => new Complex(Math.ceil(a.re), Math.ceil(a.im)),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.ceil(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.ceil(a[i]);
+		return out;
+	}
+});
+const fix$1 = mathTyped("fix", {
+	number: (a) => Math.trunc(a),
+	Fraction: (a) => fix(a),
+	BigNumber: (a) => fix(a),
+	Complex: (a) => fix(a),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.trunc(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.trunc(a[i]);
+		return out;
+	}
+});
+const mod = mathTyped("mod", {
+	"number, number": (a, b) => (a % b + b) % b,
+	"bigint, bigint": (a, b) => (a % b + b) % b,
+	"Fraction, Fraction": (a, b) => a.mod(b),
+	"BigNumber, BigNumber": (a, b) => a.mod(b)
+});
+const gcd = mathTyped("gcd", {
+	"number, number": (a, b) => euclidSnap(a, b, Math.floor),
+	"bigint, bigint": (a, b) => {
+		a = a < 0n ? -a : a;
+		b = b < 0n ? -b : b;
+		while (b !== 0n) {
+			const t = b;
+			b = a % b;
+			a = t;
+		}
+		return a;
+	},
+	"BigNumber, BigNumber": (a, b) => {
+		let x = a.abs();
+		let y = b.abs();
+		while (!y.isZero()) {
+			const t = y;
+			y = x.mod(y);
+			x = t;
+		}
+		return x;
+	}
+});
+const lcm = mathTyped("lcm", {
+	"number, number": (a, b) => {
+		const g = gcd(a, b);
+		return Math.abs(a * b) / g;
+	},
+	"bigint, bigint": (a, b) => {
+		const g = gcd(a, b);
+		return (a < 0n ? -a : a) * (b < 0n ? -b : b) / g;
+	},
+	"BigNumber, BigNumber": (a, b) => {
+		const g = gcd(a, b);
+		if (g.isZero()) return BigNumber.fromNumber(0);
+		return a.abs().multiply(b.abs()).divide(g);
+	}
+});
+const xgcd = mathTyped("xgcd", {
+	"number, number": (a, b) => {
+		a = Math.floor(a);
+		b = Math.floor(b);
+		let x = 0, lastX = 1;
+		let y = 1, lastY = 0;
+		while (b !== 0) {
+			const q = Math.floor(a / b);
+			[a, b] = [b, a % b];
+			[x, lastX] = [lastX - q * x, x];
+			[y, lastY] = [lastY - q * y, y];
+		}
+		return a < 0 ? [
+			-a,
+			-lastX,
+			-lastY
+		] : [
+			a,
+			lastX,
+			lastY
+		];
+	},
+	"bigint, bigint": (a, b) => {
+		let x = 0n, lastX = 1n;
+		let y = 1n, lastY = 0n;
+		while (b !== 0n) {
+			const q = a / b;
+			[a, b] = [b, a % b];
+			[x, lastX] = [lastX - q * x, x];
+			[y, lastY] = [lastY - q * y, y];
+		}
+		return a < 0n ? [
+			-a,
+			-lastX,
+			-lastY
+		] : [
+			a,
+			lastX,
+			lastY
+		];
+	},
+	"Fraction, Fraction": (a, b) => {
+		if (!a.isInteger() || !b.isInteger()) throw new Error("Parameters in function xgcd must be integer numbers");
+		const zero = new Fraction(0n, 1n);
+		const one = new Fraction(1n, 1n);
+		let x = zero, lastX = one;
+		let y = one, lastY = zero;
+		while (!b.isZero()) {
+			const q = a.divide(b).floor();
+			const r = a.mod(b);
+			const nextX = lastX.subtract(q.multiply(x));
+			const nextY = lastY.subtract(q.multiply(y));
+			lastX = x;
+			x = nextX;
+			lastY = y;
+			y = nextY;
+			a = b;
+			b = r;
+		}
+		return a.lessThan(zero) ? [
+			a.negate(),
+			lastX.negate(),
+			lastY.negate()
+		] : [
+			a,
+			!a.isZero() ? lastX : zero,
+			lastY
+		];
+	}
+});
+function is2DArray(arr) {
+	return Array.isArray(arr[0]);
+}
+function vectorNorm(arr, p = 2) {
+	if (p === Infinity) return Math.max(...arr.map((x) => Math.abs(x)));
+	if (p === -Infinity) return Math.min(...arr.map((x) => Math.abs(x)));
+	if (p === 0) return arr.filter((x) => x !== 0).length;
+	if (p === 2) return norm2(arr);
+	const terms = new Array(arr.length);
+	for (let i = 0; i < arr.length; i++) terms[i] = Math.pow(Math.abs(arr[i]), p);
+	return Math.pow(pairwiseSum(terms), 1 / p);
+}
+function matrixNorm(data, p = "fro") {
+	const rows = data.length;
+	const cols = rows > 0 ? data[0].length : 0;
+	if (p === "fro" || p === "frobenius") {
+		let s = 0;
+		for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) s += data[i][j] * data[i][j];
+		return Math.sqrt(s);
+	}
+	if (p === 1) {
+		let max = 0;
+		for (let j = 0; j < cols; j++) {
+			let s = 0;
+			for (let i = 0; i < rows; i++) s += Math.abs(data[i][j]);
+			if (s > max) max = s;
+		}
+		return max;
+	}
+	if (p === Infinity) {
+		let max = 0;
+		for (let i = 0; i < rows; i++) {
+			let s = 0;
+			for (let j = 0; j < cols; j++) s += Math.abs(data[i][j]);
+			if (s > max) max = s;
+		}
+		return max;
+	}
+	if (p === 2) {
+		const sv = singularValues(data);
+		return sv.length > 0 ? Math.max(...sv) : 0;
+	}
+	throw new Error(`Unsupported matrix norm p=${String(p)} (use 'fro', 1, 2, or Infinity)`);
+}
+const matrixLike = (m) => m.toArray();
+const norm = mathTyped("norm", {
+	number: (a) => Math.abs(a),
+	Complex: (a) => a.abs(),
+	BigNumber: (a) => a.abs(),
+	Array: (arr) => is2DArray(arr) ? matrixNorm(arr) : vectorNorm(arr),
+	"Array, number": (arr, p) => is2DArray(arr) ? matrixNorm(arr, p) : vectorNorm(arr, p),
+	"Array, string": (arr, p) => matrixNorm(arr, p),
+	DenseMatrix: (m) => matrixNorm(matrixLike(m)),
+	"DenseMatrix, number": (m, p) => matrixNorm(matrixLike(m), p),
+	"DenseMatrix, string": (m, p) => matrixNorm(matrixLike(m), p),
+	SparseMatrix: (m) => matrixNorm(matrixLike(m)),
+	"SparseMatrix, number": (m, p) => matrixNorm(matrixLike(m), p),
+	"SparseMatrix, string": (m, p) => matrixNorm(matrixLike(m), p),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length, "norm")) return (await computePool.norm(a)).result;
+		return norm2(a);
+	}
+});
+const sinh = mathTyped("sinh", {
+	number: (a) => Math.sinh(a),
+	Complex: (a) => a.sinh(),
+	BigNumber: (a) => a.sinh(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("sinh", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.sinh(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.sinh(a[i]);
+		return out;
+	}
+});
+const cosh = mathTyped("cosh", {
+	number: (a) => Math.cosh(a),
+	Complex: (a) => a.cosh(),
+	BigNumber: (a) => a.cosh(),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.cosh(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.cosh(a[i]);
+		return out;
+	}
+});
+const tanh = mathTyped("tanh", {
+	number: (a) => Math.tanh(a),
+	Complex: (a) => a.tanh(),
+	BigNumber: (a) => a.tanh(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("tanh", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.tanh(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.tanh(a[i]);
+		return out;
+	}
+});
+const equal$1 = mathTyped("equal", {
+	"number, number": (a, b) => equal(a, b),
+	"bigint, bigint": (a, b) => a === b,
+	"Complex, Complex": (a, b) => equal(a, b),
+	"Fraction, Fraction": (a, b) => equal(a, b),
+	"BigNumber, BigNumber": (a, b) => equal(a, b),
+	"Unit, Unit": (a, b) => unitSameDimension(a, b) && asUnit(a).value === asUnit(b).value
+});
+const smaller = mathTyped("smaller", {
+	"number, number": (a, b) => a < b,
+	"bigint, bigint": (a, b) => a < b,
+	"Fraction, Fraction": (a, b) => a.compare(b) < 0,
+	"BigNumber, BigNumber": (a, b) => a.compare(b) < 0,
+	"Unit, Unit": (a, b) => unitCmp(a, b) < 0
+});
+const larger = mathTyped("larger", {
+	"number, number": (a, b) => a > b,
+	"bigint, bigint": (a, b) => a > b,
+	"Fraction, Fraction": (a, b) => a.compare(b) > 0,
+	"BigNumber, BigNumber": (a, b) => a.compare(b) > 0,
+	"Unit, Unit": (a, b) => unitCmp(a, b) > 0
+});
+const smallerEq = mathTyped("smallerEq", {
+	"number, number": (a, b) => a <= b,
+	"bigint, bigint": (a, b) => a <= b,
+	"Fraction, Fraction": (a, b) => a.compare(b) <= 0,
+	"BigNumber, BigNumber": (a, b) => a.compare(b) <= 0,
+	"Unit, Unit": (a, b) => unitCmp(a, b) <= 0
+});
+const largerEq = mathTyped("largerEq", {
+	"number, number": (a, b) => a >= b,
+	"bigint, bigint": (a, b) => a >= b,
+	"Fraction, Fraction": (a, b) => a.compare(b) >= 0,
+	"BigNumber, BigNumber": (a, b) => a.compare(b) >= 0,
+	"Unit, Unit": (a, b) => unitCmp(a, b) >= 0
+});
+const compare = mathTyped("compare", {
+	"number, number": (a, b) => a > b ? 1 : a < b ? -1 : 0,
+	"bigint, bigint": (a, b) => a > b ? 1 : a < b ? -1 : 0,
+	"Fraction, Fraction": (a, b) => a.compare(b),
+	"BigNumber, BigNumber": (a, b) => a.compare(b),
+	"Unit, Unit": (a, b) => unitCmp(a, b)
+});
+const min = mathTyped("min", {
+	"bigint, bigint": (a, b) => a < b ? a : b,
+	"Fraction, Fraction": (a, b) => a.compare(b) < 0 ? a : b,
+	"BigNumber, BigNumber": (a, b) => a.compare(b) < 0 ? a : b,
+	Array: (arr) => {
+		let m = Infinity;
+		for (let i = 0; i < arr.length; i++) m = Math.min(m, arr[i]);
+		return m;
+	},
+	number: (a) => a,
+	"number, number": (a, b) => Math.min(a, b),
+	"number, number, ...number": (a, b, rest) => Math.min(a, b, ...rest),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length, "min")) return (await computePool.min(a)).result;
+		let m = Infinity;
+		for (let i = 0; i < a.length; i++) if (a[i] < m) m = a[i];
+		return m;
+	}
+});
+const max = mathTyped("max", {
+	"bigint, bigint": (a, b) => a > b ? a : b,
+	"Fraction, Fraction": (a, b) => a.compare(b) > 0 ? a : b,
+	"BigNumber, BigNumber": (a, b) => a.compare(b) > 0 ? a : b,
+	Array: (arr) => {
+		let m = -Infinity;
+		for (let i = 0; i < arr.length; i++) m = Math.max(m, arr[i]);
+		return m;
+	},
+	number: (a) => a,
+	"number, number": (a, b) => Math.max(a, b),
+	"number, number, ...number": (a, b, rest) => Math.max(a, b, ...rest),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length, "max")) return (await computePool.max(a)).result;
+		let m = -Infinity;
+		for (let i = 0; i < a.length; i++) if (a[i] > m) m = a[i];
+		return m;
+	}
+});
+const fsum = mathTyped("fsum", {
+	Array: (arr) => neumaierSum(arr),
+	Float64Array: (a) => neumaierSum(a)
+});
+const sum = mathTyped("sum", {
+	Array: (arr) => pairwiseSum(arr),
+	Float64Array: async (a) => {
+		return (await computePool.sum(a)).result;
+	}
+});
+const mean = mathTyped("mean", {
+	Array: (arr) => {
+		if (arr.length === 0) return NaN;
+		return pairwiseSum(arr) / arr.length;
+	},
+	Float64Array: async (a) => {
+		return (await computePool.mean(a)).result;
+	}
+});
+function varianceFromM2(m2, n, norm) {
+	if (n === 0) return NaN;
+	switch (norm) {
+		case "biased": return m2 / (n + 1);
+		case "uncorrected": return m2 / n;
+		default: return n > 1 ? m2 / (n - 1) : 0;
+	}
+}
+function m2OfArray(arr) {
+	return sumSquaredDeviations(arr);
+}
+const variance = mathTyped("variance", {
+	Array: (arr) => varianceFromM2(m2OfArray(arr), arr.length, "unbiased"),
+	"Array, string": (arr, norm) => varianceFromM2(m2OfArray(arr), arr.length, norm),
+	Float64Array: async (a) => {
+		return varianceFromM2((await computePool.variance(a)).result.variance * a.length, a.length, "unbiased");
+	},
+	"Float64Array, string": async (a, norm) => {
+		return varianceFromM2((await computePool.variance(a)).result.variance * a.length, a.length, norm);
+	}
+});
+const std = mathTyped("std", {
+	Array: (arr) => Math.sqrt(varianceFromM2(m2OfArray(arr), arr.length, "unbiased")),
+	"Array, string": (arr, norm) => Math.sqrt(varianceFromM2(m2OfArray(arr), arr.length, norm)),
+	Float64Array: async (a) => {
+		const result = await computePool.variance(a);
+		return Math.sqrt(varianceFromM2(result.result.variance * a.length, a.length, "unbiased"));
+	},
+	"Float64Array, string": async (a, norm) => {
+		const result = await computePool.variance(a);
+		return Math.sqrt(varianceFromM2(result.result.variance * a.length, a.length, norm));
+	}
+});
+const dot = mathTyped("dot", {
+	"Array, Array": (a, b) => {
+		if (a.length !== b.length) throw new Error(`Vector lengths must match: ${a.length} vs ${b.length}`);
+		return pairwiseDot(a, b);
+	},
+	"Float64Array, Float64Array": async (a, b) => {
+		return (await computePool.dot(a, b)).result;
+	}
+});
+async function matmul(a, aRows, aCols, b, bCols) {
+	return (await computePool.matmul(a, aRows, aCols, b, bCols)).result;
+}
+async function transpose(data, rows, cols) {
+	return (await computePool.transpose(data, rows, cols)).result;
+}
+async function matvec(matrix, rows, cols, vector) {
+	return (await computePool.matvec(matrix, rows, cols, vector)).result;
+}
+async function outer(a, b) {
+	return (await computePool.outer(a, b)).result;
+}
+async function initializePool() {
+	await computePool.initialize();
+}
+async function terminatePool() {
+	await computePool.terminate();
+}
+function shouldParallelize(elementCount) {
+	return computePool.shouldParallelize(elementCount);
+}
+function getComputePool() {
+	return computePool;
+}
+const typedArithmetic = {
+	add,
+	subtract,
+	multiply,
+	divide,
+	unaryMinus,
+	unaryPlus,
+	abs,
+	sign,
+	pow: pow$1,
+	sqrt,
+	square,
+	cube,
+	cbrt,
+	nthRoot,
+	exp,
+	log,
+	log10,
+	log2,
+	log1p,
+	expm1,
+	round: round$1,
+	floor,
+	ceil,
+	fix: fix$1,
+	mod,
+	gcd,
+	lcm,
+	xgcd,
+	norm,
+	sinh,
+	cosh,
+	tanh,
+	equal: equal$1,
+	smaller,
+	larger,
+	smallerEq,
+	largerEq,
+	compare,
+	min,
+	max,
+	sum,
+	mean,
+	variance,
+	std,
+	dot,
+	matmul,
+	transpose,
+	matvec,
+	outer,
+	initializePool,
+	terminatePool,
+	shouldParallelize,
+	getComputePool
+};
+//#endregion
+//#region src/typed/trigonometry.ts
+const sin = mathTyped("sin", {
+	number: (a) => Math.sin(a),
+	Complex: (a) => a.sin(),
+	BigNumber: (a) => a.sin(),
+	Dual: (a) => a.sin(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("sin", a);
+		if (wasm) return wasm;
+		return (await computePool.sin(a)).result;
+	}
+});
+const cos = mathTyped("cos", {
+	number: (a) => Math.cos(a),
+	Complex: (a) => a.cos(),
+	BigNumber: (a) => a.cos(),
+	Dual: (a) => a.cos(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("cos", a);
+		if (wasm) return wasm;
+		return (await computePool.cos(a)).result;
+	}
+});
+const tan = mathTyped("tan", {
+	number: (a) => Math.tan(a),
+	Complex: (a) => a.tan(),
+	BigNumber: (a) => a.tan(),
+	Dual: (a) => a.tan(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("tan", a);
+		if (wasm) return wasm;
+		return (await computePool.tan(a)).result;
+	}
+});
+const csc = mathTyped("csc", {
+	number: (a) => 1 / Math.sin(a),
+	Complex: (a) => a.sin().inverse(),
+	BigNumber: (a) => BigNumber.fromNumber(1).divide(a.sin()),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("csc", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => 1 / Math.sin(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = 1 / Math.sin(a[i]);
+		return out;
+	}
+});
+const sec = mathTyped("sec", {
+	number: (a) => 1 / Math.cos(a),
+	Complex: (a) => a.cos().inverse(),
+	BigNumber: (a) => BigNumber.fromNumber(1).divide(a.cos()),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("sec", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => 1 / Math.cos(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = 1 / Math.cos(a[i]);
+		return out;
+	}
+});
+const cot = mathTyped("cot", {
+	number: (a) => 1 / Math.tan(a),
+	Complex: (a) => a.tan().inverse(),
+	BigNumber: (a) => BigNumber.fromNumber(1).divide(a.tan()),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("cot", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => 1 / Math.tan(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = 1 / Math.tan(a[i]);
+		return out;
+	}
+});
+const asin = mathTyped("asin", {
+	number: (a) => {
+		if (a < -1 || a > 1) return new Complex(a, 0).asin();
+		return Math.asin(a);
+	},
+	Complex: (a) => a.asin(),
+	BigNumber: (a) => a.asin(),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.asin(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.asin(a[i]);
+		return out;
+	}
+});
+const acos = mathTyped("acos", {
+	number: (a) => {
+		if (a < -1 || a > 1) return new Complex(a, 0).acos();
+		return Math.acos(a);
+	},
+	Complex: (a) => a.acos(),
+	BigNumber: (a) => a.acos(),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.acos(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.acos(a[i]);
+		return out;
+	}
+});
+const atan = mathTyped("atan", {
+	number: (a) => Math.atan(a),
+	Complex: (a) => a.atan(),
+	BigNumber: (a) => a.atan(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("atan", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.atan(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.atan(a[i]);
+		return out;
+	}
+});
+const atan2 = mathTyped("atan2", {
+	"number, number": (y, x) => Math.atan2(y, x),
+	"BigNumber, BigNumber": (y, x) => y.atan2(x)
+});
+const acsc = mathTyped("acsc", {
+	number: (a) => Math.asin(1 / a),
+	Complex: (a) => a.inverse().asin(),
+	BigNumber: (a) => BigNumber.fromNumber(1).divide(a).asin()
+});
+const asec = mathTyped("asec", {
+	number: (a) => Math.acos(1 / a),
+	Complex: (a) => a.inverse().acos(),
+	BigNumber: (a) => BigNumber.fromNumber(1).divide(a).acos()
+});
+const acot = mathTyped("acot", {
+	number: (a) => Math.atan(1 / a),
+	Complex: (a) => a.inverse().atan(),
+	BigNumber: (a) => BigNumber.fromNumber(1).divide(a).atan()
+});
+const asinh = mathTyped("asinh", {
+	number: (a) => Math.asinh(a),
+	Complex: (a) => a.asinh(),
+	BigNumber: (a) => a.asinh(),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.asinh(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.asinh(a[i]);
+		return out;
+	}
+});
+const acosh = mathTyped("acosh", {
+	number: (a) => Math.acosh(a),
+	Complex: (a) => a.acosh(),
+	BigNumber: (a) => a.acosh(),
+	Float64Array: async (a) => {
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.acosh(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.acosh(a[i]);
+		return out;
+	}
+});
+const atanh = mathTyped("atanh", {
+	number: (a) => Math.atanh(a),
+	Complex: (a) => a.atanh(),
+	BigNumber: (a) => a.atanh(),
+	Float64Array: async (a) => {
+		const wasm = elementwiseUnaryDispatch("atanh", a);
+		if (wasm) return wasm;
+		if (computePool.shouldParallelize(a.length)) return (await computePool.applyKernel(a, "(x) => Math.atanh(x)")).result;
+		const out = new Float64Array(a.length);
+		for (let i = 0; i < a.length; i++) out[i] = Math.atanh(a[i]);
+		return out;
+	}
+});
+const toRadians = mathTyped("toRadians", { number: (deg) => deg * Math.PI / 180 });
+const toDegrees = mathTyped("toDegrees", { number: (rad) => rad * 180 / Math.PI });
+const hypot = mathTyped("hypot", {
+	number: (a) => Math.abs(a),
+	"number, number": (a, b) => Math.hypot(a, b),
+	"number, number, ...number": (a, b, rest) => Math.hypot(a, b, ...rest),
+	Array: (arr) => Math.hypot(...arr)
+});
+const typedTrigonometry = {
+	sin,
+	cos,
+	tan,
+	csc,
+	sec,
+	cot,
+	asin,
+	acos,
+	atan,
+	atan2,
+	acsc,
+	asec,
+	acot,
+	asinh,
+	acosh,
+	atanh,
+	toRadians,
+	toDegrees,
+	hypot
+};
+//#endregion
+//#region src/scalar-eval.ts
+const scalar = createScalarBuilder();
+var ScalarEvalError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ScalarEvalError";
+	}
+};
+const UNARY = {
+	exp,
+	log,
+	log10,
+	log2,
+	sin,
+	cos,
+	tan,
+	sinh,
+	cosh,
+	tanh,
+	abs
+};
+const NUMERIC_LITERAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function requireFinite(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new ScalarEvalError(`evaluateScalar: '${label}' produced a non-finite value (${String(value)}).`);
+	return value;
+}
+function resolveSymbol(name, scope) {
+	if (Object.prototype.hasOwnProperty.call(scope, name)) {
+		const value = scope[name];
+		if (typeof value !== "number") throw new ScalarEvalError(`evaluateScalar: scope['${name}'] is not a number.`);
+		return value;
+	}
+	if (NUMERIC_LITERAL.test(name)) {
+		const literal = Number(name);
+		if (Number.isFinite(literal)) return literal;
+	}
+	throw new ScalarEvalError(`evaluateScalar: symbol '${name}' has no value (not in scope, not a numeric literal).`);
+}
+function combine(op, left, right) {
+	switch (op) {
+		case "+": return add(left, right);
+		case "-": return subtract(left, right);
+		case "*": return multiply(left, right);
+		case "/": return divide(left, right);
+	}
+}
+function evalOp(op, args, scope) {
+	if (op === "^") {
+		if (args.length !== 2) throw new ScalarEvalError(`evaluateScalar: '^' needs exactly 2 args, got ${args.length}.`);
+		const base = evalNode(args[0], scope);
+		const exponent = evalNode(args[1], scope);
+		return requireFinite(pow$1(base, exponent), "^");
+	}
+	if (args.length === 0) return op === "*" || op === "/" ? 1 : 0;
+	let acc = evalNode(args[0], scope);
+	for (let i = 1; i < args.length; i++) {
+		const right = evalNode(args[i], scope);
+		acc = requireFinite(combine(op, acc, right), op);
+	}
+	return requireFinite(acc, op);
+}
+function evalCall(fn, arg) {
+	const impl = UNARY[fn];
+	if (impl === void 0) throw new ScalarEvalError(`evaluateScalar: unknown scalar function '${String(fn)}'.`);
+	return requireFinite(impl(arg), fn);
+}
+function evalNode(node, scope) {
+	switch (node.kind) {
+		case "number": return node.value;
+		case "symbol": return resolveSymbol(node.name, scope);
+		case "op": return evalOp(node.op, node.args, scope);
+		case "call": return evalCall(node.fn, evalNode(node.arg, scope));
+	}
+}
+function normalizeScope(scope) {
+	if (scope === null || typeof scope !== "object" || Array.isArray(scope)) throw new ScalarEvalError("evaluateScalar: scope must be an object of numbers.");
+	return scope;
+}
+function evaluateScalar(node, scope = {}) {
+	const bound = normalizeScope(scope);
+	let canonical;
+	try {
+		canonical = scalar.from(node);
+	} catch (err) {
+		if (err instanceof ScalarBuildError) throw new ScalarEvalError(err.message);
+		throw err;
+	}
+	return evalNode(canonical, bound);
+}
+//#endregion
+//#region src/scalar-compile.ts
+const LOWERED_UNARY_RULES = {
+	exp: DUAL_UNARY_RULES.exp,
+	log: DUAL_UNARY_RULES.log,
+	log10: DUAL_UNARY_RULES.log10,
+	log2: DUAL_UNARY_RULES.log2,
+	sin: DUAL_UNARY_RULES.sin,
+	cos: DUAL_UNARY_RULES.cos,
+	tan: DUAL_UNARY_RULES.tan,
+	sinh: DUAL_UNARY_RULES.sinh,
+	cosh: DUAL_UNARY_RULES.cosh,
+	tanh: DUAL_UNARY_RULES.tanh,
+	abs: DUAL_UNARY_RULES.abs
+};
+function isScalarNode(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const kind = value.kind;
+	return kind === "number" || kind === "symbol" || kind === "op" || kind === "call";
+}
+function assertScalarNode(node, messagePrefix) {
+	if (!isScalarNode(node)) {
+		const kind = node === null || Array.isArray(node) || typeof node !== "object" ? void 0 : node.kind;
+		throw new ScalarEvalError(`${messagePrefix} node kind '${String(kind)}' is not a ScalarNode`);
+	}
+	return node;
+}
+function assertNoDuplicateNames(names, messagePrefix) {
+	for (const name of names) if (names.indexOf(name) !== names.lastIndexOf(name)) throw new ScalarEvalError(`${messagePrefix} symbol '${name}' is listed more than once`);
+}
+function evalStylePrefix(messagePrefix) {
+	return messagePrefix === "compileScalar:" ? "evaluateScalar:" : messagePrefix;
+}
+function copyRegisterGrad(grad, srcReg, destReg, nParams) {
+	const srcBase = srcReg * nParams;
+	const destBase = destReg * nParams;
+	for (let p = 0; p < nParams; p++) grad[destBase + p] = grad[srcBase + p];
+}
+function setRegisterGradNaN(grad, reg, nParams) {
+	const base = reg * nParams;
+	for (let p = 0; p < nParams; p++) grad[base + p] = NaN;
+}
+function powBasePartial(exp, base) {
+	return exp * Math.pow(base, exp - 1);
+}
+function powExpPartial(value, base) {
+	return value * Math.log(base);
+}
+function isFloat64ArrayColumn(col) {
+	if (col instanceof Float64Array) return true;
+	return ArrayBuffer.isView(col) && col.constructor.name === "Float64Array";
+}
+function applyBinary(op, left, right) {
+	switch (op) {
+		case "+": return left + right;
+		case "-": return left - right;
+		case "*": return left * right;
+		case "/": return left / right;
+	}
+}
+function storeChecked(scratch, dest, result, valid) {
+	if (!valid || typeof result !== "number" || !Number.isFinite(result)) {
+		scratch[dest] = NaN;
+		return false;
+	}
+	scratch[dest] = result;
+	return true;
+}
+function runRow(tape, scratch, rootReg, columns, params, row, grad, nParams) {
+	let valid = true;
+	if (grad !== void 0 && nParams > 0) grad.fill(0);
+	for (const instr of tape) switch (instr.tag) {
+		case "const":
+			scratch[instr.dest] = instr.value;
+			break;
+		case "column":
+			scratch[instr.dest] = columns[instr.index][row];
+			break;
+		case "param":
+			scratch[instr.dest] = params[instr.index];
+			if (grad !== void 0 && nParams > 0) {
+				const destBase = instr.dest * nParams;
+				for (let p = 0; p < nParams; p++) grad[destBase + p] = p === instr.index ? 1 : 0;
+			}
+			break;
+		case "mov":
+			if (!valid) {
+				scratch[instr.dest] = NaN;
+				if (grad !== void 0 && nParams > 0) setRegisterGradNaN(grad, instr.dest, nParams);
+				break;
+			}
+			valid = storeChecked(scratch, instr.dest, scratch[instr.src], valid);
+			if (grad !== void 0 && nParams > 0) {
+				if (valid) copyRegisterGrad(grad, instr.src, instr.dest, nParams);
+				else setRegisterGradNaN(grad, instr.dest, nParams);
+			}
+			break;
+		case "bin": {
+			if (!valid) {
+				scratch[instr.dest] = NaN;
+				if (grad !== void 0 && nParams > 0) setRegisterGradNaN(grad, instr.dest, nParams);
+				break;
+			}
+			const left = scratch[instr.left];
+			const right = scratch[instr.right];
+			const result = instr.op === "^" ? Math.pow(left, right) : applyBinary(instr.op, left, right);
+			valid = storeChecked(scratch, instr.dest, result, valid);
+			if (grad !== void 0 && nParams > 0) {
+				if (!valid) {
+					setRegisterGradNaN(grad, instr.dest, nParams);
+					break;
+				}
+				const destBase = instr.dest * nParams;
+				const leftBase = instr.left * nParams;
+				const rightBase = instr.right * nParams;
+				if (instr.op === "^") {
+					const base = left;
+					const exp = right;
+					const val = scratch[instr.dest];
+					for (let p = 0; p < nParams; p++) {
+						let g = 0;
+						const dl = grad[leftBase + p];
+						const dr = grad[rightBase + p];
+						if (dl !== 0) {
+							const factor = powBasePartial(exp, base);
+							if (!Number.isFinite(factor)) {
+								valid = false;
+								scratch[instr.dest] = NaN;
+								setRegisterGradNaN(grad, instr.dest, nParams);
+								break;
+							}
+							g += dl * factor;
+						}
+						if (dr !== 0) {
+							const factor = powExpPartial(val, base);
+							if (!Number.isFinite(factor)) {
+								valid = false;
+								scratch[instr.dest] = NaN;
+								setRegisterGradNaN(grad, instr.dest, nParams);
+								break;
+							}
+							g += dr * factor;
+						}
+						grad[destBase + p] = g;
+					}
+				} else for (let p = 0; p < nParams; p++) {
+					const gl = grad[leftBase + p];
+					const gr = grad[rightBase + p];
+					switch (instr.op) {
+						case "+":
+							grad[destBase + p] = gl + gr;
+							break;
+						case "-":
+							grad[destBase + p] = gl - gr;
+							break;
+						case "*":
+							grad[destBase + p] = gl * right + left * gr;
+							break;
+						case "/": {
+							const denom = right * right;
+							grad[destBase + p] = (gl * right - left * gr) / denom;
+							break;
+						}
+					}
+				}
+			}
+			break;
+		}
+		case "unary": {
+			if (!valid) {
+				scratch[instr.dest] = NaN;
+				if (grad !== void 0 && nParams > 0) setRegisterGradNaN(grad, instr.dest, nParams);
+				break;
+			}
+			const x = scratch[instr.arg];
+			const rule = LOWERED_UNARY_RULES[instr.fn];
+			const result = rule.primal(x);
+			valid = storeChecked(scratch, instr.dest, result, valid);
+			if (grad !== void 0 && nParams > 0) {
+				if (!valid) {
+					setRegisterGradNaN(grad, instr.dest, nParams);
+					break;
+				}
+				const destBase = instr.dest * nParams;
+				const argBase = instr.arg * nParams;
+				const y = scratch[instr.dest];
+				for (let p = 0; p < nParams; p++) {
+					const al = grad[argBase + p];
+					if (al === 0) {
+						grad[destBase + p] = 0;
+						continue;
+					}
+					const d = rule.deriv(x, y);
+					if (!Number.isFinite(d)) {
+						valid = false;
+						scratch[instr.dest] = NaN;
+						setRegisterGradNaN(grad, instr.dest, nParams);
+						break;
+					}
+					grad[destBase + p] = al * d;
+				}
+			}
+			break;
+		}
+	}
+	return {
+		value: scratch[rootReg],
+		valid
+	};
+}
+function allocReg(ctx) {
+	return ctx.nextReg++;
+}
+function bindSymbol(ctx, name, dest) {
+	const inVars = ctx.variables.indexOf(name);
+	const inParams = ctx.parameters.indexOf(name);
+	const inConsts = Object.prototype.hasOwnProperty.call(ctx.constants, name);
+	if ((inVars >= 0 ? 1 : 0) + (inParams >= 0 ? 1 : 0) + (inConsts ? 1 : 0) >= 2) throw new ScalarEvalError(`${ctx.messagePrefix} symbol '${name}' is listed more than once`);
+	if (inParams >= 0) {
+		ctx.tape.push({
+			tag: "param",
+			dest,
+			index: inParams
+		});
+		return;
+	}
+	if (inVars >= 0) {
+		ctx.tape.push({
+			tag: "column",
+			dest,
+			index: inVars
+		});
+		return;
+	}
+	if (inConsts) {
+		const value = ctx.constants[name];
+		if (typeof value !== "number") throw new ScalarEvalError(`${ctx.messagePrefix} constant '${name}' is not a number`);
+		ctx.tape.push({
+			tag: "const",
+			dest,
+			value
+		});
+		return;
+	}
+	if (NUMERIC_LITERAL.test(name)) {
+		const literal = Number(name);
+		if (Number.isFinite(literal)) {
+			ctx.tape.push({
+				tag: "const",
+				dest,
+				value: literal
+			});
+			return;
+		}
+	}
+	throw new ScalarEvalError(`${evalStylePrefix(ctx.messagePrefix)} symbol '${name}' has no value (not in scope, not a numeric literal).`);
+}
+function compileNode(ctx, node) {
+	const canonical = assertScalarNode(node, ctx.messagePrefix);
+	const dest = allocReg(ctx);
+	switch (canonical.kind) {
+		case "number":
+			ctx.tape.push({
+				tag: "const",
+				dest,
+				value: canonical.value
+			});
+			ctx.rootReg = dest;
+			return dest;
+		case "symbol":
+			bindSymbol(ctx, canonical.name, dest);
+			ctx.rootReg = dest;
+			return dest;
+		case "call": {
+			if (!Object.prototype.hasOwnProperty.call(LOWERED_UNARY_RULES, canonical.fn)) throw new ScalarEvalError(`${evalStylePrefix(ctx.messagePrefix)} unknown scalar function '${String(canonical.fn)}'.`);
+			const argReg = compileNode(ctx, canonical.arg);
+			ctx.tape.push({
+				tag: "unary",
+				dest,
+				fn: canonical.fn,
+				arg: argReg
+			});
+			ctx.rootReg = dest;
+			return dest;
+		}
+		case "op": {
+			const { op, args } = canonical;
+			if (op === "^") {
+				if (args.length !== 2) throw new ScalarEvalError(`${evalStylePrefix(ctx.messagePrefix)} '^' needs exactly 2 args, got ${args.length}.`);
+				const left = compileNode(ctx, args[0]);
+				const right = compileNode(ctx, args[1]);
+				ctx.tape.push({
+					tag: "bin",
+					dest,
+					op: "^",
+					left,
+					right
+				});
+				ctx.rootReg = dest;
+				return dest;
+			}
+			if (args.length === 0) {
+				const value = op === "*" || op === "/" ? 1 : 0;
+				ctx.tape.push({
+					tag: "const",
+					dest,
+					value
+				});
+				ctx.rootReg = dest;
+				return dest;
+			}
+			if (args.length === 1) {
+				const src = compileNode(ctx, args[0]);
+				if (src !== dest) ctx.tape.push({
+					tag: "mov",
+					dest,
+					src
+				});
+				ctx.rootReg = dest;
+				return dest;
+			}
+			let acc = compileNode(ctx, args[0]);
+			for (let i = 1; i < args.length; i++) {
+				const right = compileNode(ctx, args[i]);
+				const stepDest = i === args.length - 1 ? dest : acc;
+				ctx.tape.push({
+					tag: "bin",
+					dest: stepDest,
+					op,
+					left: acc,
+					right
+				});
+				acc = stepDest;
+			}
+			ctx.rootReg = dest;
+			return dest;
+		}
+	}
+}
+function checkCompileParams(params, parameters, messagePrefix) {
+	const nParams = parameters.length;
+	if (params === void 0) {
+		if (nParams > 0) throw new ScalarEvalError(`${messagePrefix} expected ${nParams} parameters, got 0`);
+		return [];
+	}
+	if (params.length !== nParams) throw new ScalarEvalError(`${messagePrefix} expected ${nParams} parameters, got ${params.length}`);
+	for (let i = 0; i < nParams; i++) if (typeof params[i] !== "number") throw new ScalarEvalError(`${messagePrefix} parameter ${i} is not a number`);
+	return params;
+}
+function compileRowCount(columns, variables, messagePrefix) {
+	const nVars = variables.length;
+	if (columns.length !== nVars) throw new ScalarEvalError(`${messagePrefix} expected ${nVars} columns, got ${columns.length}`);
+	for (let i = 0; i < columns.length; i++) if (!isFloat64ArrayColumn(columns[i])) throw new ScalarEvalError(`${messagePrefix} column ${i} must be a Float64Array`);
+	if (nVars === 0) return 1;
+	const n = columns[0].length;
+	for (let i = 1; i < columns.length; i++) if (columns[i].length !== n) throw new ScalarEvalError(`${messagePrefix} columns must have the same length`);
+	return n;
+}
+function evaluateScalarTape(tape, rootReg, nRegs, columns, variables, params, parameters, messagePrefix, out, scratch = new Float64Array(nRegs)) {
+	const n = compileRowCount(columns, variables, messagePrefix);
+	const boundParams = checkCompileParams(params, parameters, messagePrefix);
+	let values;
+	if (out !== void 0) {
+		if (out.length !== n) throw new ScalarEvalError(`${messagePrefix} out length ${out.length} does not match row count ${n}`);
+		values = out;
+	} else values = new Float64Array(n);
+	const valid = new Uint8Array(n);
+	let allValid = true;
+	for (let row = 0; row < n; row++) {
+		const { value, valid: rowValid } = runRow(tape, scratch, rootReg, columns, boundParams, row, void 0, 0);
+		values[row] = rowValid ? value : NaN;
+		valid[row] = rowValid ? 1 : 0;
+		if (!rowValid) allValid = false;
+	}
+	return {
+		values,
+		valid,
+		allValid
+	};
+}
+function buildTape(node, options, messagePrefix) {
+	const canonical = assertScalarNode(node, messagePrefix);
+	const variables = options.variables.slice();
+	const parameters = (options.parameters ?? []).slice();
+	const constants = options.constants ?? {};
+	assertNoDuplicateNames(variables, messagePrefix);
+	assertNoDuplicateNames(parameters, messagePrefix);
+	const ctx = {
+		variables,
+		parameters,
+		constants,
+		messagePrefix,
+		tape: [],
+		nextReg: 0,
+		rootReg: 0
+	};
+	compileNode(ctx, canonical);
+	return {
+		tape: ctx.tape,
+		rootReg: ctx.rootReg,
+		nRegs: ctx.nextReg,
+		variables,
+		parameters
+	};
+}
+function compileScalar(node, options) {
+	const messagePrefix = "compileScalar:";
+	const { tape, rootReg, nRegs, variables, parameters } = buildTape(node, options, messagePrefix);
+	const scratch = new Float64Array(nRegs);
+	return {
+		variables,
+		parameters,
+		evaluate(columns, params, out) {
+			return evaluateScalarTape(tape, rootReg, nRegs, columns, variables, params ?? [], parameters, messagePrefix, out, scratch);
+		},
+		evaluateRow(row, params) {
+			const nVars = variables.length;
+			if (row.length !== nVars) throw new ScalarEvalError(`compileScalar: expected ${nVars} row entries, got ${row.length}`);
+			for (let i = 0; i < nVars; i++) if (typeof row[i] !== "number") throw new ScalarEvalError(`compileScalar: row entry ${i} is not a number`);
+			const boundParams = checkCompileParams(params, parameters, messagePrefix);
+			const columns = [];
+			for (let i = 0; i < nVars; i++) {
+				const col = /* @__PURE__ */ new Float64Array(1);
+				col[0] = row[i];
+				columns.push(col);
+			}
+			const { value, valid: rowValid } = runRow(tape, scratch, rootReg, columns, boundParams, 0, void 0, 0);
+			if (!rowValid) throw new ScalarEvalError("compileScalar: row produced a non-finite value.");
+			return value;
+		}
+	};
+}
+function compileScalarGradient(node, options) {
+	const messagePrefix = "compileScalarGradient:";
+	const { tape, rootReg, nRegs, variables, parameters } = buildTape(node, options, messagePrefix);
+	const scratch = new Float64Array(nRegs);
+	const nParams = parameters.length;
+	const gradScratch = nParams > 0 ? new Float64Array(nRegs * nParams) : /* @__PURE__ */ new Float64Array(0);
+	return {
+		variables,
+		parameters,
+		evaluate(columns, params, out) {
+			const n = compileRowCount(columns, variables, messagePrefix);
+			const boundParams = checkCompileParams(params, parameters, messagePrefix);
+			let values;
+			if (out?.values !== void 0) {
+				if (out.values.length !== n) throw new ScalarEvalError(`${messagePrefix} out values length ${out.values.length} does not match row count ${n}`);
+				values = out.values;
+			} else values = new Float64Array(n);
+			let grad;
+			const gradLen = n * nParams;
+			if (out?.grad !== void 0) {
+				if (out.grad.length !== gradLen) throw new ScalarEvalError(`${messagePrefix} out grad length ${out.grad.length} does not match ${gradLen}`);
+				grad = out.grad;
+			} else grad = new Float64Array(gradLen);
+			const valid = new Uint8Array(n);
+			let allValid = true;
+			const rootBase = rootReg * nParams;
+			for (let row = 0; row < n; row++) {
+				const { value, valid: rowValid } = runRow(tape, scratch, rootReg, columns, boundParams, row, nParams > 0 ? gradScratch : void 0, nParams);
+				values[row] = rowValid ? value : NaN;
+				valid[row] = rowValid ? 1 : 0;
+				const gradRow = row * nParams;
+				if (rowValid && nParams > 0) for (let p = 0; p < nParams; p++) grad[gradRow + p] = gradScratch[rootBase + p];
+				else if (nParams > 0) for (let p = 0; p < nParams; p++) grad[gradRow + p] = NaN;
+				if (!rowValid) allValid = false;
+			}
+			return {
+				values,
+				valid,
+				allValid,
+				grad
+			};
+		}
+	};
+}
+//#endregion
+//#region src/scalar-batch-task.ts
+const SCALAR_BATCH_MESSAGE_PREFIX = "compileScalar:";
+function runScalarBatchTask(task) {
+	const rows = [];
+	for (const item of task.items) {
+		const batch = evaluateScalarTape(item.tape, item.rootReg, item.nRegs, task.columns, task.variables, item.params, item.parameters, SCALAR_BATCH_MESSAGE_PREFIX);
+		rows.push({
+			candidateIndex: item.candidateIndex,
+			values: batch.values,
+			valid: batch.valid,
+			allValid: batch.allValid
+		});
+	}
+	return { rows };
+}
+//#endregion
+export { log1p as $, abs as A, xgcd as At, exp as B, wasmPolicyAllows as Bt, hypot as C, tanh as Ct, toDegrees as D, unaryMinus as Dt, tan as E, typedArithmetic as Et, cosh as F, getWasm as Ft, gcd as G, createMatrixBridge as Gt, fix$1 as H, loadWasm as Ht, cube as I, isAsWasm as It, larger as J, getComputePool as K, euclidSnap as Kt, divide as L, makeUnaryArrayDispatch as Lt, cbrt as M, elementwiseUnaryDispatch as Mt, ceil as N, asReadReturnedF64 as Nt, toRadians as O, unaryPlus as Ot, compare as P, asReadReturnedI32 as Pt, log10 as Q, dot as R, withAsF64 as Rt, csc as S, sum as St, sin as T, transpose as Tt, floor as U, MathJSDenseMatrix as Ut, expm1 as V, isWasmLoaded as Vt, fsum as W, MathJSSparseMatrix as Wt, lcm as X, largerEq as Y, log as Z, atan as _, smallerEq as _t, compileScalarGradient as a, min as at, cos as b, std as bt, evaluateScalar as c, norm as ct, acosh as d, pow$1 as dt, log2 as et, acot as f, round$1 as ft, asinh as g, smaller as gt, asin as h, sinh as ht, compileScalar as i, mean as it, add as j, elementwiseChainDispatch as jt, typedTrigonometry as k, variance as kt, scalar as l, nthRoot as lt, asec as m, sign as mt, runScalarBatchTask as n, matvec as nt, NUMERIC_LITERAL as o, mod as ot, acsc as p, shouldParallelize as pt, initializePool as q, buildTape as r, max as rt, ScalarEvalError as s, multiply as st, SCALAR_BATCH_MESSAGE_PREFIX as t, matmul as tt, acos as u, outer as ut, atan2 as v, sqrt as vt, sec as w, terminatePool as wt, cot as x, subtract as xt, atanh as y, square as yt, equal$1 as z, withAsI32 as zt };