numbl 0.4.7 → 0.4.9

package/dist-browser/numbl-core/helpers/gmres.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Core GMRES (Generalized Minimum Residual) algorithm.
+ *
+ * Callback-based interface so the same code handles both dense matrices
+ * (dispatched through the LAPACK bridge) and function-handle arguments
+ * (dispatched through the runtime).
+ */
+export interface GmresResult {
+    x: Float64Array;
+    flag: number;
+    relres: number;
+    iter: [number, number];
+    resvec: Float64Array;
+}
+export type MatvecFn = (x: Float64Array) => Float64Array;
+export type PrecSolveFn = (r: Float64Array) => Float64Array;
+/**
+ * Restarted GMRES with left preconditioning and Givens rotations.
+ *
+ * @param matvec    Computes A*x
+ * @param precSolve Computes M\x (or null for no preconditioning)
+ * @param b         Right-hand side (length n)
+ * @param n         System dimension
+ * @param restart   Inner iteration count (use n for no restart)
+ * @param tol       Convergence tolerance on relative preconditioned residual
+ * @param maxit     Maximum number of outer iterations
+ * @param x0        Initial guess (or null for zeros)
+ */
+export declare function gmresCore(matvec: MatvecFn, precSolve: PrecSolveFn | null, b: Float64Array, n: number, restart: number, tol: number, maxit: number, x0: Float64Array | null): GmresResult;
+export interface ComplexVec {
+    re: Float64Array;
+    im: Float64Array;
+}
+export interface GmresComplexResult {
+    x: ComplexVec;
+    flag: number;
+    relres: number;
+    iter: [number, number];
+    resvec: Float64Array;
+}
+export type ComplexMatvecFn = (x: ComplexVec) => ComplexVec;
+export type ComplexPrecSolveFn = (r: ComplexVec) => ComplexVec;
+/** Restarted GMRES for complex systems. */
+export declare function gmresCoreComplex(matvec: ComplexMatvecFn, precSolve: ComplexPrecSolveFn | null, b: ComplexVec, n: number, restart: number, tol: number, maxit: number, x0: ComplexVec | null): GmresComplexResult;
+/** Complex LU solve in-place (split re/im). LU and ipiv from zgetrf-style factorization. */
+export declare function complexLuSolveInPlace(n: number, LURe: Float64Array, LUIm: Float64Array, ipiv: Int32Array, rhsRe: Float64Array, rhsIm: Float64Array): void;
+/**
+ * Apply row permutation + forward/back substitution to solve a pre-factored
+ * LU system in-place.  LU and ipiv come from dgetrf (1-based pivots).
+ */
+export declare function luSolveInPlace(n: number, LU: Float64Array, ipiv: Int32Array, rhs: Float64Array): void;

package/dist-browser/numbl-core/helpers/linsolve.d.ts

@@ -0,0 +1,25 @@
+/**
+ * linsolve(A, B) — solve the linear system A * X = B.
+ *
+ * If A is square (m × m), uses LU factorisation (dgesv / dgetrf+solve).
+ * If A is non-square, uses QR / LQ factorisation (dgels / dgeqrf+solve):
+ *   overdetermined  (m > n): least-squares solution minimising ||A*X - B||₂
+ *   underdetermined (m < n): minimum-norm solution minimising ||X||₂
+ *
+ * Both the native LAPACK addon and the ts-lapack TypeScript fallback are
+ * supported; the native addon is preferred when available.
+ */
+/**
+ * Dispatch linsolve to the native addon (preferred) or ts-lapack fallback.
+ * Returns null only when neither bridge exposes `linsolve` (should not happen
+ * in practice since ts-lapack always has it).
+ */
+export declare function linsolveLapack(A: Float64Array, m: number, n: number, B: Float64Array, nrhs: number): Float64Array | null;
+/**
+ * Dispatch complex linsolve to the native addon (preferred) or ts-lapack fallback.
+ * The ts-lapack fallback throws — native addon is required for complex linsolve.
+ */
+export declare function linsolveComplexLapack(ARe: Float64Array, AIm: Float64Array, m: number, n: number, BRe: Float64Array, BIm: Float64Array, nrhs: number): {
+    re: Float64Array;
+    im: Float64Array;
+};

package/dist-browser/numbl-core/helpers/marching-cubes-tables.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Marching-cubes lookup tables (Paul Bourke / Lorensen-Cline).
+ *
+ * Vendored verbatim from mikolalysenko/isosurface (MIT). Generated from
+ * lib/marchingcubes.js; do not edit by hand.
+ */
+export declare const edgeTable: Uint32Array<ArrayBuffer>;
+export declare const triTable: number[][];
+export declare const cubeVerts: number[][];
+export declare const edgeIndex: number[][];

package/dist-browser/numbl-core/helpers/marching-cubes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Marching cubes over a regular scalar grid, plus the MATLAB `isosurface`
+ * argument parsing. Backs the `isosurface` builtin.
+ *
+ * The 256-case lookup tables are vendored in `marching-cubes-tables.ts`
+ * (MIT, mikolalysenko/isosurface — Paul Bourke's classic table). The loop
+ * here adds the two things that library lacks for our use:
+ *   - vertices interpolated from arbitrary X/Y/Z coordinate arrays (so it is
+ *     correct for ndgrid, meshgrid, vector, and implicit grids), and
+ *   - cross-cell vertex sharing (keyed by grid-edge identity), which MATLAB
+ *     produces by default and which downstream code (e.g. triangle adjacency)
+ *     relies on.
+ */
+import type { RuntimeValue } from "../runtime/types.js";
+export interface IsoMesh {
+    /** Physical vertex coordinates, one `[x, y, z]` per vertex. */
+    vertices: number[][];
+    /** Triangles as 0-based vertex-index triples. */
+    faces: number[][];
+    /** Per-vertex scalar color data (present only when a colors array is given). */
+    colors?: number[];
+}
+type ScalarFn = (i: number, j: number, k: number) => number;
+type CoordFn = (i: number, j: number, k: number) => [number, number, number];
+/**
+ * Extract the isosurface of `getVal` at `iso` over an `m×n×p` grid.
+ * `getCoord` maps a grid corner to its physical position; `getColor` (if
+ * given) supplies a scalar field interpolated onto the surface vertices.
+ */
+export declare function marchingCubes(dims: [number, number, number], getVal: ScalarFn, getCoord: CoordFn, iso: number, opts?: {
+    share?: boolean;
+    getColor?: ScalarFn;
+}): IsoMesh;
+/**
+ * Parse `isosurface(...)` arguments and compute the mesh.
+ *
+ * Forms (by numeric-argument count, after stripping 'verbose'/'noshare'):
+ *   1: isosurface(V)               4: isosurface(X,Y,Z,V)
+ *   2: isosurface(V,iso)           5: isosurface(X,Y,Z,V,iso)
+ *   3: isosurface(V,iso,colors)    6: isosurface(X,Y,Z,V,iso,colors)
+ *
+ * When the isovalue is omitted it is chosen automatically (see autoIsovalue) —
+ * an approximation that does not match MATLAB's exact histogram heuristic.
+ */
+export declare function isosurfaceFromArgs(args: RuntimeValue[]): IsoMesh;
+export {};

package/dist-browser/numbl-core/helpers/ode-rk.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Adaptive explicit Runge-Kutta ODE solvers.
+ *
+ * Algorithm and coefficients follow the scipy RK45 implementation.
+ * See: https://github.com/scipy/scipy/blob/main/scipy/integrate/_ivp/rk.py
+ *
+ * Pure numerical code — no runtime types.
+ */
+export interface RKTableau {
+    name: string;
+    order: number;
+    errorOrder: number;
+    nStages: number;
+    /** Nodes c_i, length nStages */
+    C: number[];
+    /** RK coefficients a_{s,j}, nStages rows, lower-triangular */
+    A: number[][];
+    /** Higher-order weights, length nStages */
+    B: number[];
+    /** Error coefficients E = bhat - b, length nStages + 1 */
+    E: number[];
+    /** Dense output polynomial coefficients, (nStages+1) x nInterp */
+    P: number[][];
+    /** Number of interpolation polynomial columns */
+    nInterp: number;
+}
+/**
+ * Dormand-Prince 5(4) pair — used by ode45.
+ *
+ * Error controlled assuming 4th-order accuracy; steps taken with
+ * 5th-order formula (local extrapolation). Quartic interpolation
+ * polynomial from Shampine [2].
+ */
+export declare const dormandPrince45: RKTableau;
+/**
+ * Bogacki-Shampine 3(2) pair — used by ode23.
+ *
+ * Error controlled assuming 2nd-order accuracy; steps taken with
+ * 3rd-order formula (local extrapolation). Cubic Hermite polynomial
+ * for the dense output.
+ */
+export declare const bogackiShampine23: RKTableau;
+export interface StepData {
+    tOld: number;
+    tNew: number;
+    h: number;
+    yOld: number[];
+    yNew: number[];
+    /** Q = K^T P, dimensions neq x nInterp */
+    Q: number[][];
+}
+/**
+ * Evaluate the dense output polynomial at fractional position x in [0,1].
+ *
+ * Matches scipy RkDenseOutput._call_impl:
+ *   y = y_old + h * Q @ [x, x^2, ..., x^nInterp]
+ */
+export declare function denseOutputEval(yOld: number[], Q: number[][], h: number, x: number): number[];
+export interface OdeOptions {
+    relTol: number;
+    absTol: number;
+    maxStep: number;
+    initialStep: number;
+    events?: (t: number, y: number[]) => [number[], boolean[], number[]];
+}
+export interface OdeResult {
+    t: number[];
+    y: number[][];
+    te: number[];
+    ye: number[][];
+    ie: number[];
+    steps: StepData[];
+}
+/**
+ * Solve y' = f(t,y) using an adaptive embedded Runge-Kutta method.
+ *
+ * Step control follows scipy RungeKutta._step_impl exactly.
+ */
+export declare function solveRK(tableau: RKTableau, f: (t: number, y: number[]) => number[], tspan: number[], y0: number[], opts: Partial<OdeOptions>): OdeResult;
+export declare function interpolateAtPoints(result: OdeResult, tRequested: number[]): {
+    t: number[];
+    y: number[][];
+};

package/dist-browser/numbl-core/helpers/prng.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Seedable PRNG (xoshiro128**) for random number generation
+ */
+import { RuntimeValue } from "../runtime/index.js";
+export declare function setRngShuffle(): void;
+export declare function setRngSeed(seed: number): void;
+export declare function seedRng(seed: number): void;
+/** Return a random float in [0, 1) using seeded or unseeded PRNG */
+export declare function rngRandom(): number;
+export declare function boxMullerRandom(): number;
+/** Fill a typed array with normal random values (bulk polar method) */
+export declare function fillRandn(data: Float64Array): void;
+/** Return the current RNG state as a struct {Type, Seed, State} */
+export declare function getRngStateStruct(): RuntimeValue;
+/** Restore RNG state from a struct previously returned by rng() */
+export declare function restoreRngState(s: {
+    kind: "struct";
+    fields: Map<string, RuntimeValue>;
+}): void;

package/dist-browser/numbl-core/helpers/quadgk.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Adaptive Gauss-Kronrod (7-15) quadrature — a minimal MATLAB-compatible
+ * quadgk implementation sufficient for smooth integrands on a finite real
+ * interval.
+ *
+ * Not supported (yet):
+ *  - complex / contour integration
+ *  - Waypoints
+ *  - infinite limits
+ *
+ * The integrand `fun` must accept a vector of quadrature nodes and return
+ * a vector of the same length (MATLAB's quadgk contract).
+ */
+/** Return the 15 Kronrod nodes of [lo, hi]. */
+export declare function kronrodNodes(lo: number, hi: number): number[];
+export interface QuadgkOptions {
+    relTol?: number;
+    absTol?: number;
+    maxIntervalCount?: number;
+}
+export interface QuadgkResult {
+    value: number;
+    errbnd: number;
+    intervalsUsed: number;
+}
+/**
+ * Adaptive Gauss-Kronrod 7-15 quadrature of `integrand` over `[a, b]`.
+ *
+ * `integrand(pts)` receives a 15-element array of nodes and must return a
+ * 15-element array of function values.
+ */
+export declare function quadgkAdaptive(integrand: (pts: number[]) => number[], a: number, b: number, opts?: QuadgkOptions): QuadgkResult;

package/dist-browser/numbl-core/helpers/reduction/cumulative.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cumulative and difference builtins: cumsum, cumprod, cummax, cummin, diff.
+ */
+import { RuntimeValue } from "../../runtime/index.js";
+/** Generic cumulative operation along a specified or default dimension.
+ *  Supports cumsum(A), cumsum(A, dim), etc. for arbitrary N-D arrays. */
+export declare function cumOp(name: string, args: RuntimeValue[], accumFn: (acc: number, val: number) => number, initial?: number, complexAccumFn?: (accRe: number, accIm: number, valRe: number, valIm: number) => [number, number]): RuntimeValue;
+export declare function diffOnce(v: RuntimeValue, dim?: number): RuntimeValue;

package/dist-browser/numbl-core/helpers/reduction/min-max.d.ts

@@ -0,0 +1,5 @@
+/**
+ * min/max builtin functions.
+ */
+import { RuntimeValue } from "../../runtime/index.js";
+export declare function minMaxImpl(name: string, args: RuntimeValue[], nargout: number, initial: number, isBetter: (candidate: number, current: number) => boolean, twoArgFn: (a: number, b: number) => number): RuntimeValue | RuntimeValue[];

package/dist-browser/numbl-core/helpers/reduction-helpers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared helpers for reduction operations: dimension iteration, type checks,
+ * reduction factories, sparse helpers, and logical/complex scan utilities.
+ */
+import { RuntimeValue } from "../runtime/index.js";
+import { type RuntimeTensor, type RuntimeSparseMatrix } from "../runtime/types.js";
+/** Iterate over all 1-D fibers along `dim` (1-based).
+ * For each fiber, calls `callback(outIndex, srcIndices)` where
+ * `srcIndices` is an array of flat indices into the source data.
+ * Returns `{ resultShape, totalElems }` (resultShape is squeezed).
+ * Returns null if dim exceeds the tensor's rank. */
+export declare function forEachSlice(shape: number[], dim: number, callback: (outIdx: number, srcIndices: number[]) => void): {
+    resultShape: number[];
+    totalElems: number;
+} | null;
+/** Return 1-based dim to reduce along (first dim whose size != 1), or 0 for
+ *  "reduce to scalar". A size-0 dimension counts as non-singleton (MATLAB
+ *  reduces along it), so `sum(zeros(0,3))` is `[0 0 0]` not a scalar — the
+ *  previous `d > 1` test wrongly treated a size-0 dim as singleton. */
+export declare function firstReduceDim(shape: number[]): number;
+/** Return a deep copy of a tensor (data + shape + optional imag). */
+export declare function copyTensor(v: RuntimeTensor): RuntimeValue;
+/**
+ * Complex product reduction. Can't use the independent real/imag approach
+ * because (a+bi)(c+di) = (ac-bd)+(ad+bc)i mixes both parts.
+ */
+export declare function complexProd(v: RuntimeTensor, dim?: number): RuntimeValue;
+/** Scan tensor elements for logical reduction (any/all).
+ * mode 'any': returns true if any element is nonzero.
+ * mode 'all': returns true if all elements are nonzero (true for empty). */
+export declare function scanLogical(data: ArrayLike<number>, imag: ArrayLike<number> | undefined, mode: "any" | "all"): boolean;
+/** Reduce a tensor along a dimension using a logical test (any/all). */
+export declare function logicalAlongDim(v: RuntimeTensor, dim: number, mode: "any" | "all"): RuntimeValue;
+/** Sum a sparse matrix along dim 1 (columns) or dim 2 (rows).
+ *  Returns sparse for dim=1, dense tensor for dim=2. */
+export declare function sparseSum(v: RuntimeSparseMatrix, dim: number): RuntimeValue;
+/** any/all on sparse matrix along a dimension.
+ *  Returns sparse for dim=1, dense for dim=2. */
+export declare function sparseAnyAll(v: RuntimeSparseMatrix, dim: number, mode: "any" | "all"): RuntimeValue;
+/** Type check for reductions that return Num without dim arg, Tensor with dim arg. */
+/** Strip trailing 'omitnan'/'includenan' from args. Returns cleaned args and flag. */
+export declare function parseNanFlag(args: RuntimeValue[]): {
+    args: RuntimeValue[];
+    omitNaN: boolean;
+};
+/** Filter NaN values from a Float64Array, returning a new (possibly shorter) array. */
+export declare function filterNaN(arr: ArrayLike<number>): Float64Array;
+export type ReductionKernel = {
+    reduceAll: (v: RuntimeTensor) => RuntimeValue;
+    reduceDim: (v: RuntimeTensor, dim: number) => RuntimeValue;
+};
+/** Create an accumulator-based reduction kernel (sum, mean, etc.).
+ *
+ * When `opCode` is provided (an OpReduce.* value whose semantics match
+ * `reduceFn`/`initial`), the reduceAll fast path routes Float64 real and
+ * complex tensors through tensorOps.realFlatReduce.  The closure path
+ * is still used as a fallback for non-Float64 data. */
+export declare function accumKernel(reduceFn: (acc: number, val: number) => number, initial: number, finalizeFn?: (acc: number, count: number) => number, opCode?: number): ReductionKernel;
+/** Create a slice-based reduction kernel (median, mode, etc.) */
+export declare function sliceKernel(sliceFn: (slice: ArrayLike<number>) => number): ReductionKernel;
+/** Create an accumulator kernel that skips NaN values. */
+export declare function accumKernelOmitNaN(reduceFn: (acc: number, val: number) => number, initial: number, finalizeFn?: (acc: number, count: number) => number): ReductionKernel;
+/** Create a slice kernel that filters NaN before applying the function. */
+export declare function sliceKernelOmitNaN(sliceFn: (slice: ArrayLike<number>) => number): ReductionKernel;
+/** Helper: extract all numeric values from a RuntimeValue as a plain array. */
+export declare function toNumArray(v: RuntimeValue, name: string): number[];

package/dist-browser/numbl-core/helpers/registry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Builtin name registry: tracks which names are recognized as builtins.
+ */
+/** Register additional builtin names so isBuiltin() recognizes them. */
+export declare function registerExtraBuiltinNames(names: Iterable<string>): void;
+export declare function isBuiltin(name: string): boolean;
+export declare function getAllBuiltinNames(): string[];

package/dist-browser/numbl-core/helpers/scanFormat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared scanning core for sscanf/fscanf: apply a MATLAB format string
+ * cyclically to input text, collecting numeric results.
+ */
+export interface ScanResult {
+    results: number[];
+    /** Number of characters consumed from the input. */
+    consumed: number;
+    matchFailure: boolean;
+}
+export declare function scanFormat(str: string, fmt: string, maxCount: number): ScanResult;

package/dist-browser/numbl-core/helpers/shape-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared shape/size argument parsing and value coercion for builtins.
+ */
+import { type RuntimeValue } from "../runtime/index.js";
+import { type RuntimeTensor } from "../runtime/types.js";
+/** Promote a scalar (number, logical, complex) to a 1×1 tensor. Tensors pass through. */
+export declare function coerceToTensor(v: RuntimeValue, name: string): RuntimeTensor;

package/dist-browser/numbl-core/helpers/sparse-arithmetic.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Sparse matrix arithmetic operations (with complex support).
+ */
+import { type RuntimeValue, type RuntimeSparseMatrix, type RuntimeTensor } from "../runtime/types.js";
+/** Convert a sparse matrix to dense. */
+declare function sparseToDense(S: RuntimeSparseMatrix): RuntimeTensor;
+export declare function sparseNeg(S: RuntimeSparseMatrix): RuntimeSparseMatrix;
+export declare function sparseTranspose(S: RuntimeSparseMatrix): RuntimeSparseMatrix;
+export declare function sparseConjugateTranspose(S: RuntimeSparseMatrix): RuntimeSparseMatrix;
+export declare function mAddSparse(a: RuntimeValue, b: RuntimeValue): RuntimeValue;
+export declare function mSubSparse(a: RuntimeValue, b: RuntimeValue): RuntimeValue;
+export declare function mMulSparse(a: RuntimeValue, b: RuntimeValue): RuntimeValue;
+export declare function mElemMulSparse(a: RuntimeValue, b: RuntimeValue): RuntimeValue;
+export declare function mElemDivSparse(a: RuntimeValue, b: RuntimeValue): RuntimeValue;
+/** Convert sparse to dense RuntimeTensor (exported for use in arithmetic dispatch). */
+export { sparseToDense };

package/dist-browser/numbl-core/helpers/string.d.ts

@@ -0,0 +1,11 @@
+/**
+ * String manipulation builtin functions
+ */
+import { type RuntimeValue } from "../runtime/index.js";
+/** Convert a scalar number to the string form MATLAB's num2str would
+ *  produce.  Unlike numStr (used for sprintf %g), integers always render
+ *  in fixed notation regardless of magnitude, so e.g. 1e15 becomes
+ *  "1000000000000000" rather than "1e+15".  This matches the formatting
+ *  MATLAB applies when concatenating a number to a string via `+`. */
+export declare function num2strScalar(n: number): string;
+export declare function sprintfFormat(fmt: string, args: RuntimeValue[]): string;

package/dist-browser/numbl-core/interpreter/builtins/arithmetic.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Binary scalar builtins: atan2, min, max, mod, rem, power.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/array-construction.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Array construction builtins: zeros, ones, nan/NaN, eye, linspace, logspace.
+ */
+import type { RuntimeValue } from "../../runtime/types.js";
+import type { JitType } from "../../jitTypes.js";
+/** Drop a trailing class-name spec from the JIT arg types (used in `match`
+ *  so the size cases still apply when a class string is present). */
+export declare function stripClassNameTypes(argTypes: JitType[]): JitType[];
+/** Drop a trailing class-name spec from the runtime args (used in `apply`). */
+export declare function stripClassNameArgs(args: RuntimeValue[]): RuntimeValue[];

package/dist-browser/numbl-core/interpreter/builtins/array-extras.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Array extras: colon, tril, triu, toeplitz, magic,
+ * bitwise ops, and coordinate transforms.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/array-manipulation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Array manipulation builtins for the interpreter system:
+ * reshape, diag, cat, horzcat, vertcat, flip, fliplr, flipud, rot90,
+ * repmat, repelem, squeeze, circshift, permute, ipermute,
+ * ndgrid, meshgrid, sub2ind, ind2sub.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/cell-struct.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cell/struct operation builtins: cell2mat, cell2struct, mat2cell, num2cell,
+ * struct2cell, namedargs2cell, rmfield.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/complex.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Complex number builtins: real, imag, conj, angle.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/datetime.d.ts

@@ -0,0 +1,40 @@
+/**
+ * datetime / duration builtins — scalar-only initial implementation.
+ *
+ * datetime:
+ *   datetime()                         current time
+ *   datetime('now' | 'today' | 'yesterday' | 'tomorrow')
+ *   datetime(Y, M, D)
+ *   datetime(Y, M, D, H, MI, S[, MS])
+ *   datetime(X, 'ConvertFrom', 'datenum' | 'posixtime' | 'excel' | 'excel1904')
+ *
+ * datetime values are class_instance with className="datetime" and fields
+ * Year/Month/Day/Hour/Minute/Second. They are display-formatted by
+ * display.ts as "dd-MMM-yyyy [HH:mm:ss]".
+ *
+ * duration:
+ *   Produced by datetime - datetime, or by seconds(N) / minutes(N) / ...
+ *   Represented as class_instance with className="duration" and a single
+ *   Seconds field. Display format "hh:mm:ss".
+ *
+ * Arithmetic:
+ *   datetime - datetime -> duration
+ *   datetime + duration -> datetime
+ *   datetime - duration -> datetime
+ *   duration + duration -> duration
+ *   duration - duration -> duration
+ *
+ * `seconds(d)` returns the numeric seconds of a duration, or wraps a
+ * number as a duration.
+ */
+import type { RuntimeValue } from "../../runtime/types.js";
+import { RuntimeClassInstance } from "../../runtime/types.js";
+export declare function makeDatetime(year: number, month: number, day: number, hour: number, minute: number, second: number): RuntimeClassInstance;
+export declare function makeDuration(totalSeconds: number): RuntimeClassInstance;
+/**
+ * Attempt to handle a named binary operator ("plus", "minus", "lt", ...)
+ * when at least one operand is a datetime or duration class_instance.
+ * Returns the result value on success, or undefined to let the generic
+ * numeric path run.
+ */
+export declare function tryDatetimeDurationBinop(opName: string, a: RuntimeValue, b: RuntimeValue): RuntimeValue | undefined;

package/dist-browser/numbl-core/interpreter/builtins/dictionary.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dictionary builtins: dictionary, configureDictionary, keys, values,
+ * numEntries, isConfigured, isKey, entries, insert, lookup, remove, types.
+ */
+import { type RuntimeValue, type RuntimeDictionary } from "../../runtime/types.js";
+/** Produce a unique string key from a RuntimeValue for Map lookup. */
+export declare function hashKey(v: RuntimeValue): string;
+/** Insert a single key-value pair without expanding arrays. */
+export declare function dictInsertSingle(d: RuntimeDictionary, key: RuntimeValue, value: RuntimeValue): RuntimeDictionary;
+/** Insert key-value pairs into a dictionary, returning a new dictionary. */
+export declare function dictInsert(d: RuntimeDictionary, keysArg: RuntimeValue, valuesArg: RuntimeValue): RuntimeDictionary;
+/** Remove keys from a dictionary, returning a new dictionary. */
+export declare function dictRemove(d: RuntimeDictionary, keysArg: RuntimeValue): RuntimeDictionary;
+/** Lookup values by keys. Returns single value or tensor/cell array. */
+export declare function dictLookup(d: RuntimeDictionary, keysArg: RuntimeValue): RuntimeValue;

package/dist-browser/numbl-core/interpreter/builtins/fft.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Interpreter IBuiltins for FFT functions:
+ * fft, ifft, fftshift, ifftshift.
+ *
+ * Reuses the same algorithmic implementations as the legacy builtins.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/gallery.d.ts

@@ -0,0 +1,7 @@
+/**
+ * gallery — families of test matrices.
+ *
+ * Currently implements the 'tridiag' family (sparse tridiagonal matrices),
+ * which is the variant exercised by library code such as M-M.E.S.S.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/geometry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interpreter IBuiltins for computational geometry functions: delaunay,
+ * delaunayn, convhull, convhulln, inpolygon.
+ *
+ * delaunay/delaunayn/convhull/convhulln are backed by the qhull WASM module,
+ * installed at startup (see geometry-bridge.ts and the qhull-node /
+ * qhull-browser loaders). The backend must be installed before these builtins
+ * run; otherwise they throw.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/graph.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Undirected graph object (`graph`) and a subset of its methods.
+ *
+ * MATLAB's `graph` is a value class representing an undirected graph. Here a
+ * graph is a class_instance with className="graph" and three internal fields:
+ *   _n         number of nodes
+ *   _A         symmetric weighted adjacency as a RuntimeSparseMatrix
+ *   _weighted  whether the graph carries edge weights
+ *
+ * Supported constructors:
+ *   graph()                          empty graph
+ *   graph(A)                         adjacency matrix (A must be symmetric)
+ *   graph(A, 'omitselfloops')        drop the diagonal
+ *   graph(A, 'upper' | 'lower')      read one triangle of A
+ *   graph(s, t)                      edge list (unweighted)
+ *   graph(s, t, w)                   edge list (weighted)
+ *   graph(s, t, w, num)              edge list, num nodes
+ *
+ * Supported methods (called as functions, e.g. conncomp(G)):
+ *   conncomp(G) / [bins, sizes] = conncomp(G)   connected components
+ *   laplacian(G)                                 graph Laplacian (unweighted)
+ *   addedge(G, s, t [, w])                       add edges, returns a new graph
+ *   numnodes(G), numedges(G)                     counts
+ *   degree(G)                                    per-node degree (column vector)
+ *
+ * Note: laplacian ignores edge weights (uses the binary adjacency and the
+ * node-degree count), matching MATLAB.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/help-text.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Help text for builtins. Registered via registerBuiltinHelp so existing
+ * builtin definitions don't need to be modified.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Interpreter builtins: register all and re-export.
+ *
+ * Import order matters — each module registers its builtins on import.
+ */
+import "./math.js";
+import "./arithmetic.js";
+import "./complex.js";
+import "./predicates.js";
+import "./logical.js";
+import "./utility.js";
+import "./introspection.js";
+import "./array-construction.js";
+import "./reductions.js";
+import "./strings.js";
+import "./set-operations.js";
+import "./linear-algebra.js";
+import "./fft.js";
+import "./array-manipulation.js";
+import "./array-extras.js";
+import "./validation.js";
+import "./numerical.js";
+import "./type-constructors.js";
+import "./string-extras.js";
+import "./prng.js";
+import "./cell-struct.js";
+import "./time-system.js";
+import "./datetime.js";
+import "./sparse.js";
+import "./graph.js";
+import "./gallery.js";
+import "./special-math.js";
+import "./geometry.js";
+import "./misc.js";
+import "./dictionary.js";
+import "./help-text.js";
+export { getIBuiltin, getIBuiltinHelp, getIBuiltinNargin, getAllIBuiltinNames, registerBuiltinHelp, inferJitType, } from "./types.js";
+export type { IBuiltin, IBuiltinResolution, BuiltinHelp } from "./types.js";
+export { resetAppdataStore, convertJsonValue } from "./misc.js";

package/dist-browser/numbl-core/interpreter/builtins/introspection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Introspection builtins: size, length, numel, ndims, isempty, isscalar,
+ * isvector, isrow, iscolumn, ismatrix, islogical, isnumeric, isfloat,
+ * isinteger, ischar, isstring, iscell, isstruct, issparse, class.
+ */
+export {};

package/dist-browser/numbl-core/interpreter/builtins/linear-algebra.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Interpreter IBuiltins for linear algebra functions:
+ * norm, vecnorm, dot, det, trace, cross, inv, svd, qr, lu, eig, chol,
+ * linsolve, cond, rank, pinv, kron, blkdiag, pagemtimes, pagetranspose.
+ *
+ * These delegate to the same runtime implementations as the legacy builtins
+ * but provide JitType-level resolve() for the interpreter/JIT pipeline.
+ */
+export {};