numbl 0.4.7 → 0.4.9

package/dist-browser/numbl-core/jit/builtins/defs/logical/isnumeric.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `isnumeric(x)` — folds true if the argument's static type is a
+ * Numeric (real or complex, scalar or tensor, double or logical?
+ * MATLAB excludes logical). Matches numbl's introspection.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const isnumeric: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/isreal.d.ts

@@ -0,0 +1,2 @@
+import type { Builtin } from "../../registry.js";
+export declare const isreal: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/isscalar.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `isscalar(x)` — does `x` hold a single element?
+ *
+ * Numbl semantics
+ * (`numbl-core/interpreter/builtins/introspection.ts`, plus the
+ * `jitEmit` shortcut for `string`):
+ *   - Real or logical scalar number → `true`.
+ *   - Complex scalar → `true`.
+ *   - Tensor → `true` iff `numel == 1`.
+ *   - String handle (`"..."`) → `true` (single handle = scalar).
+ *   - Char array (`'...'`) → `false`, even for `'a'` — char arrays
+ *     are 1×N and treated as non-scalar.
+ *   - Struct / class instance / function handle → `false`.
+ *
+ * The result folds at type-check time whenever the shape is known
+ * (which is the common case). When a tensor's shape is opaque the
+ * emit paths fall back to a `numel == 1` runtime check.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const isscalar: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/isstruct.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `isstruct(x)` — folds true if the argument's static type is a
+ * struct, false otherwise. Class instances are NOT structs (matches
+ * MATLAB / numbl `introspection.ts:182`).
+ */
+import type { Builtin } from "../../registry.js";
+export declare const isstruct: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/logical.d.ts

@@ -0,0 +1 @@
+export declare const logical: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/not.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `not` builtin — backs the `~` unary operator.
+ *
+ * Elementwise logical NOT. Numbl's `not(v)` in
+ * `runtime/runtimeOperators.ts` line 100:
+ *   - scalar 0          → logical true
+ *   - scalar nonzero    → logical false
+ *   - tensor            → logical tensor of same shape; element-wise
+ *                         `(x == 0) ? 1 : 0`
+ *
+ * Type result is always logical (mtoc2's `NumericType.elem = "logical"`).
+ * Sign is `nonneg` since outputs are in {0, 1}.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const notBuiltin: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/or.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `or(a, b)` — the function form of `|`. For scalar arguments,
+ * mtoc2 routes this through the same scaffold as `||` (`oror`): the
+ * result type is scalar logical, the codegen uses C's `||` operator,
+ * and the only semantic difference (short-circuit on `||` vs.
+ * eager-evaluate on `|` / `or`) is moot — by the time the function
+ * is called, both arguments have already been computed by the
+ * call-site machinery, so the C-level short-circuit is harmless.
+ * Tensor / elementwise behavior is deferred.
+ */
+export declare const orBuiltin: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/oror.d.ts

@@ -0,0 +1 @@
+export declare const oror: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/strcmp.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `strcmp(a, b)` / `strcmpi(a, b)` — text equality.
+ *
+ * Numbl semantics (`numbl-core/interpreter/builtins/strings.ts`):
+ *   - Both args text (Char / String) → byte-equality (or ASCII
+ *     case-folded equality for `strcmpi`). Length mismatch is not an
+ *     error; the inputs simply compare unequal.
+ *   - Either arg non-text → `false`. Numbl gates the comparison
+ *     behind `isText(a) && isText(b)`; non-text just yields `0`
+ *     silently. We mirror that to keep cross-runner output identical.
+ *   - Cell-of-text vectorization (`strcmp({'a','b'}, 'a')`) is in
+ *     numbl but cells aren't yet a feature class in mtoc2 — that
+ *     overload will fall out naturally when cells land.
+ *
+ * Folds to a literal when both args are exact text. Otherwise emits
+ * the runtime `mtoc2_strcmp` / `mtoc2_strcmpi` helper which compares
+ * byte-for-byte on text views.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const strcmp: Builtin;
+export declare const strcmpi: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/typequery.d.ts

@@ -0,0 +1,10 @@
+import type { Builtin } from "../../registry.js";
+export declare const islogical: Builtin;
+export declare const isfloat: Builtin;
+export declare const ischarBuiltin: Builtin;
+export declare const isstring: Builtin;
+export declare const isinteger: Builtin;
+export declare const ndims: Builtin;
+export declare const ismatrix: Builtin;
+export declare const isrow: Builtin;
+export declare const iscolumn: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/logical/xor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `xor(a, b)` — logical exclusive-or of two real scalars. The result is
+ * a logical scalar that is `true` iff exactly one operand is nonzero.
+ *
+ * Scalar-only: tensor or complex operands throw `UnsupportedConstruct`
+ * so the call falls back to the interpreter (which broadcasts and
+ * handles complex). Booleanization uses `(x != 0)` on the C side and
+ * `Number(x) !== 0` on the JS side so both agree element-for-element —
+ * including `NaN` (nonzero → true on both).
+ */
+import type { Builtin } from "../../registry.js";
+export declare const xorBuiltin: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/_complex_fold.d.ts

@@ -0,0 +1,34 @@
+/**
+ * JS-side scalar-complex fold functions for unary math builtins.
+ *
+ * Mirrors the cscalar.h `mtoc2_c*` helpers — both the C side and
+ * c2js's JS-runtime side must agree with these formulas. Used by
+ * `_unary_real.ts`'s factory at type-system-fold time when an input
+ * has an exact `{re, im}` carrier.
+ *
+ * Real input is projected to `{re: x, im: 0}` upstream of these
+ * helpers via `exactScalarAsComplex`; that case is rare for unary
+ * math since the same builtin's real-path fold already catches it.
+ */
+export type C = {
+    re: number;
+    im: number;
+};
+export declare function cSqrt(z: C): C;
+export declare function cExp(z: C): C;
+export declare function cLog(z: C): C;
+export declare function cLog2(z: C): C;
+export declare function cLog10(z: C): C;
+export declare function cSin(z: C): C;
+export declare function cCos(z: C): C;
+export declare function cTan(z: C): C;
+export declare function cSinh(z: C): C;
+export declare function cCosh(z: C): C;
+export declare function cTanh(z: C): C;
+export declare function cAtan(z: C): C;
+export declare function cFloor(z: C): C;
+export declare function cCeil(z: C): C;
+/** Half-away-from-zero on each component (matches C99 `round`). */
+export declare function cRound(z: C): C;
+export declare function cFix(z: C): C;
+export declare function cSign(z: C): C;

package/dist-browser/numbl-core/jit/builtins/defs/math/_unary_real.d.ts

@@ -0,0 +1,51 @@
+import { type NumericType, type Sign } from "../../../lowering/types.js";
+import type { Builtin } from "../../registry.js";
+export interface UnaryRealMathOpts {
+    /** Source-level builtin name (also the runtime helper suffix). */
+    name: string;
+    /** C `<math.h>` function name for the scalar path (e.g. `"cos"`). */
+    cFnReal: string;
+    /** JS-side scalar fn for compile-time fold (and for the interpreter's
+     *  `call` hook). */
+    jsFn: (x: number) => number;
+    /** Optional JS expression form (textual) for `emitJs`'s scalar real
+     *  path. Defaults to `Math.${name}(arg)` which works for most names
+     *  (sin/cos/tan/sqrt/exp/log/log2/log10/abs/atan/floor/ceil/sign).
+     *  Override for `fix` (`Math.trunc`) and `round`
+     *  (custom half-away-from-zero form). */
+    jsExpr?: (arg: string) => string;
+    /** Sign refinement on the result type. Called with the (validated)
+     *  real-numeric input type. */
+    signRule: (t: NumericType) => Sign;
+    /** Optional real-domain predicate. `true` means the real input stays
+     *  on the real path; `false` means it leaves the real domain (would
+     *  produce NaN / -Inf / complex). When `false` AND `complex.liftOnDomainMiss`
+     *  is set, the call lifts to the complex path (real-input,
+     *  complex-output); otherwise the factory throws `TypeError`. */
+    realDomainOk?: (t: NumericType) => boolean;
+    /** Optional complex-input support. When set, complex scalars route
+     *  through `cFnComplex` (a `mtoc2_c*` helper); complex tensors
+     *  route through `mtoc2_tensor_<name>_complex`. `jsFnComplex`
+     *  folds at the type-system layer when the input has an exact
+     *  `{re, im}` carrier. `liftOnDomainMiss` makes the factory lift
+     *  a real-typed input through the same complex path when
+     *  `realDomainOk` returns false (e.g. `sqrt(-1)`). */
+    complex?: {
+        cFnComplex: string;
+        jsFnComplex: (z: {
+            re: number;
+            im: number;
+        }) => {
+            re: number;
+            im: number;
+        };
+        liftOnDomainMiss?: boolean;
+    };
+}
+/** Sign rule for rounding-toward-zero builtins (`fix`, `round`, `ceil`,
+ *  `floor`). Captures the "may collapse to zero" pattern: if a side of
+ *  the number line can land on 0, its strict-sign input weakens to the
+ *  corresponding non-strict sign. The flags say whether the operation's
+ *  rounding direction can reach 0 from that side. */
+export declare function roundingSignRule(positiveCanLand: boolean, negativeCanLand: boolean): (t: NumericType) => Sign;
+export declare function defineUnaryRealMath(opts: UnaryRealMathOpts): Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/abs.d.ts

@@ -0,0 +1,7 @@
+import { type Builtin } from "../../registry.js";
+/** Complex-aware `abs`. Real inputs route through the existing real
+ *  builtin (preserving its sign refinement and tensor path); complex
+ *  inputs return `hypot(creal, cimag)` per-element, with a REAL result
+ *  type (different shape contract from the rest of the unary-math
+ *  family). */
+export declare const abs: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/angle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `angle(z)` — phase angle in radians. Returns `atan2(im, re)`. For
+ * real input the result is 0 when the value is non-negative, π when
+ * negative; complex input yields `carg(z)`.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const angle: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/asinh.d.ts

@@ -0,0 +1 @@
+export declare const asinh: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/atan.d.ts

@@ -0,0 +1 @@
+export declare const atan: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/atan2.d.ts

@@ -0,0 +1,3 @@
+/** Two-argument arctangent. Result is in (-π, π]; sign is generally
+ *  `unknown`. */
+export declare const atan2: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/besselh.d.ts

@@ -0,0 +1,2 @@
+import type { Builtin } from "../../registry.js";
+export declare const besselh: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/ceil.d.ts

@@ -0,0 +1,4 @@
+/** `ceil(x)` rounds toward +Inf. Complex inputs round each component
+ *  independently. Only `negative` inputs may land on 0
+ *  (e.g. `ceil(-0.5) = 0`); `positive` inputs are bounded away. */
+export declare const ceil: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/conj.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `conj(z)` — complex conjugate. Accepts real or complex, scalar or
+ * tensor. For real input it's the identity; for complex input it
+ * flips the sign of the imaginary part.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const conj: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/constants.d.ts

@@ -0,0 +1,7 @@
+import { type Builtin } from "../../registry.js";
+export declare const pi: Builtin;
+export declare const eps: Builtin;
+export declare const Inf: Builtin;
+export declare const inf: Builtin;
+export declare const NaNBuiltin: Builtin;
+export declare const nan: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/cos.d.ts

@@ -0,0 +1 @@
+export declare const cos: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/cosh.d.ts

@@ -0,0 +1 @@
+export declare const cosh: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/dot.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `dot(a, b)` — real or complex dot product.
+ *
+ * Numbl semantics
+ * (`numbl-core/interpreter/builtins/linear-algebra.ts`):
+ *   - Two same-length 1-D vectors (any combination of row / column /
+ *     scalar) → scalar `sum_i a_i * b_i` (real) or
+ *     `sum_i conj(a_i) * b_i` (complex).
+ *   - Two matrices of the **same** shape M×N → column-wise dot,
+ *     returned as a 1×N row vector.
+ *   - Length / shape mismatch → runtime error.
+ *   - Any complex operand promotes the result to complex (real
+ *     tensors flow through with `imag = 0`).
+ *
+ * Real folding: when both inputs are exact and small enough, the
+ * result is computed at type-check time and lands as `exact` on the
+ * output type, so call sites used in `if`-conds get the static fold.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const dot: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/double.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `double(x)` — numeric conversion to double.
+ *
+ * Matches numbl `type-constructors.ts`:
+ *   - Numeric scalar (double / logical / complex_or_number):
+ *     scalar real number out. For complex scalars, returns the real
+ *     part (numbl's `apply` returns `v.re`).
+ *   - Numeric tensor: same shape; logical lane → double (drop the
+ *     logical flag); complex tensors pass through as complex
+ *     (numbl preserves `isComplex` in the match shape).
+ *   - Char (single-quoted): char-code conversion. Empty → 0×0
+ *     tensor; 1 char → scalar double; N chars → 1×N row.
+ *
+ * Scope notes:
+ *   - The mtoc2 C representation already stores logical and double
+ *     scalars as `double`, and logical tensors as `mtoc2_tensor_t`
+ *     with a `double *` buffer. So a numeric → double conversion is
+ *     either identity (scalar) or a fresh struct copy (tensor); no
+ *     per-element rewrite is needed.
+ *   - Char input is supported only when the char carries `exact`
+ *     (the common case — char literals always carry exact text).
+ *     Non-exact char input (e.g. `double(sprintf(...))`) raises
+ *     `UnsupportedConstruct`. Folding at transfer time avoids
+ *     introducing a new runtime helper for the char-tensor → numeric
+ *     tensor path.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const doubleBuiltin: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/exp.d.ts

@@ -0,0 +1 @@
+export declare const exp: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/fix.d.ts

@@ -0,0 +1,4 @@
+/** `fix(x)` truncates toward zero (C99 `trunc`). Complex inputs truncate
+ *  each component independently. Both `positive` and `negative` inputs
+ *  may collapse to 0 (e.g. `fix(±0.5) = 0`). */
+export declare const fix: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/floor.d.ts

@@ -0,0 +1,4 @@
+/** `floor(x)` rounds toward -Inf. Complex inputs round each component
+ *  independently (MATLAB convention). Only `positive` inputs may land
+ *  on 0 (e.g. `floor(0.5) = 0`); `negative` inputs are bounded away. */
+export declare const floor: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/hypot.d.ts

@@ -0,0 +1,3 @@
+/** `hypot(a, b) = sqrt(a^2 + b^2)`. Always `nonneg` (C99 `hypot`
+ *  guarantees no spurious overflow for finite inputs). */
+export declare const hypot: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/imag.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `imag(z)` — imaginary part. Accepts scalar real or complex; returns
+ * a real double. For real input the result is always 0; for complex
+ * input the result is `cimag(z)`.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const imag: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/linspace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `linspace(a, b)` / `linspace(a, b, n)` — n linearly-spaced values
+ * from `a` to `b` inclusive as a 1×n row tensor.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const linspace: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/log.d.ts

@@ -0,0 +1,4 @@
+/** Natural log. Provably non-negative real inputs stay on the real
+ *  path (`log(0) = -Inf` is still real-typed in MATLAB); anything that
+ *  could be negative lifts to the complex path. */
+export declare const log: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/log10.d.ts

@@ -0,0 +1,3 @@
+/** Base-10 log. Same non-negative real-domain rule as `log`; negative
+ *  inputs lift to the complex path. */
+export declare const log10: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/log2.d.ts

@@ -0,0 +1,5 @@
+/** Base-2 log. Same non-negative real-domain rule as `log`; negative
+ *  inputs lift to the complex path. Single-output form only; two-output
+ *  frexp form `[f,e] = log2(x)` is deferred.
+ */
+export declare const log2: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/logspace.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `logspace(a, b)` / `logspace(a, b, n)` — n logarithmically-spaced
+ * values from 10^a to 10^b as a 1×n row tensor (default n = 50).
+ * Matches numbl's interpreter, including the MATLAB special case where
+ * an upper limit of exactly `pi` makes the last point `pi` (not 10^pi).
+ */
+import type { Builtin } from "../../registry.js";
+export declare const logspace: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/mod.d.ts

@@ -0,0 +1 @@
+export declare const mod: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/norm.d.ts

@@ -0,0 +1,2 @@
+import type { Builtin } from "../../registry.js";
+export declare const norm: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/rand.d.ts

@@ -0,0 +1,2 @@
+import type { Builtin } from "../../registry.js";
+export declare const rand: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/real.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `real(z)` — real part. Accepts scalar real or complex; returns a
+ * real double. For real input it's the identity; for complex input
+ * the result is `creal(z)`.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const real: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/rem.d.ts

@@ -0,0 +1,3 @@
+/** `rem(a, b)`: same as JS `%` and C `fmod` — result sign tracks `a`'s
+ *  sign. */
+export declare const rem: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/round.d.ts

@@ -0,0 +1 @@
+export declare const round: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/sign.d.ts

@@ -0,0 +1,5 @@
+/** `sign(x)`:
+ *   - Real input ∈ {-1, 0, 1}; the result's sign mirrors the input's.
+ *   - Complex input → `z / |z|` for nonzero, `0 + 0i` for `0 + 0i`.
+ *     The complex sign is itself complex. */
+export declare const signBuiltin: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/sin.d.ts

@@ -0,0 +1 @@
+export declare const sin: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/sinh.d.ts

@@ -0,0 +1 @@
+export declare const sinh: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/sqrt.d.ts

@@ -0,0 +1,11 @@
+/** `sqrt(x)`: real input that's provably non-negative stays on the
+ *  real path; everything else lifts to the complex path
+ *  (`mtoc2_csqrt` for scalars, `mtoc2_tensor_sqrt_complex` for
+ *  tensors). Matches MATLAB: `sqrt(-1)` returns `0 + 1i`,
+ *  `sqrt([-1 4])` returns `[0+1i, 2]`.
+ *
+ *  Sign rule on the (real-path) input:
+ *   - `positive` → `positive` (sqrt of strictly positive is strictly positive)
+ *   - everything else (`nonneg` / `zero`) → `nonneg`.
+ */
+export declare const sqrt: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/tan.d.ts

@@ -0,0 +1 @@
+export declare const tan: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/tanh.d.ts

@@ -0,0 +1 @@
+export declare const tanh: import("../../registry.js").Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/math/uniquetol.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `uniquetol(x)` / `uniquetol(x, tol)` — first-occurrence dedup of
+ * a real-double tensor with absolute tolerance.
+ *
+ * Numbl semantics
+ * (`numbl-core/interpreter/builtins/set-operations.ts`):
+ *   - Default `tol = 1e-6` when no second arg.
+ *   - Algorithm: naive pairwise scan against the running unique
+ *     list — first-occurrence order preserved, NOT sorted.
+ *     Transitive chaining is a real consequence (e.g.
+ *     `uniquetol([0 0.6 1.2 1.8], 0.7) == [0 1.2]`).
+ *   - NaN is never within tol of anything; each NaN survives.
+ *   - Output shape: row input (1×N) → row output `[1, ?]`;
+ *     anything else (column / matrix / empty) → column output
+ *     `[?, 1]`. Empty input gives `[0, 1]`.
+ *
+ * The multi-output `[c, ia, ic] = uniquetol(...)` form, the
+ * `'ByRows'` name-value pair, and complex inputs are not yet
+ * supported and raise `UnsupportedConstruct`.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const uniquetol: Builtin;

package/dist-browser/numbl-core/jit/builtins/defs/plot/dispatch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Plot dispatch — every plotting builtin (`plot`, `surf`, `imagesc`,
+ * `bar`, `figure`, `hold`, `xlabel`, …) shares a single lowering.
+ */
+import type { Builtin } from "../../registry.js";
+export declare const plotBuiltins: ReadonlyArray<Builtin>;

package/dist-browser/numbl-core/jit/builtins/defs/reduction/_cumulative.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared scaffold for the `cumsum` / `cumprod` family — prefix-scan
+ * builtins that return a tensor of the SAME shape as the input.
+ *
+ * Mirrors numbl's `cumOp` (helpers/reduction/cumulative.ts) for both
+ * default-axis pick (first dim > 1, else dim 1) and per-fiber column-
+ * major scan. Real and complex inputs both supported; complex routes
+ * through `_complex_dim` runtime helpers that scan both lanes
+ * (cumprod uses per-step complex multiplication).
+ *
+ * Exact-fold rule: when input has an exact data carrier AND the result
+ * fits `EXACT_ARRAY_MAX_ELEMENTS`, scan at translate time and attach
+ * the result as `exact` on the returned type.
+ *
+ * Out of scope: runtime (non-exact) `dim`, and the lattice-only shape
+ * form when no dim is given (`cumsum(A)` on a tensor whose static shape
+ * is unknown raises — pass an explicit dim).
+ */
+import { type Sign } from "../../../lowering/types.js";
+import type { Builtin } from "../../registry.js";
+export interface CumulativeSpec {
+    /** Source-level builtin name (also the runtime helper suffix:
+     *  `mtoc2_tensor_<name>_dim`). */
+    name: string;
+    /** Identity seed (`0` for cumsum, `1` for cumprod). */
+    init: number;
+    /** Per-element accumulator step (real). */
+    step(acc: number, x: number): number;
+    /** Per-element accumulator step (complex). Takes `(accRe, accIm,
+     *  xRe, xIm)` and returns the next `[re, im]` pair. Required when
+     *  `supportsComplex` is not `false`. */
+    stepComplex?(accRe: number, accIm: number, xRe: number, xIm: number): [number, number];
+    /** Sign rule on the result given the input's sign. */
+    signRule(s: Sign): Sign;
+    /** Whether complex input is JIT-compiled. Defaults to `true`
+     *  (cumsum/cumprod). `cummax`/`cummin` set this `false`: numbl's
+     *  complex cummax is a quirky component-wise max that isn't worth
+     *  replicating — complex input declines to the interpreter. */
+    supportsComplex?: boolean;
+}
+export declare function defineCumulative(spec: CumulativeSpec): Builtin;
+/** cumsum: a prefix sum of like-signed values stays in the same sign
+ *  class. (Mixed signs collapse to `unknown` because partial sums can
+ *  cross zero.) */
+export declare function cumsumSign(s: Sign): Sign;
+/** cumprod: products of nonneg stay nonneg; products of positives stay
+ *  positive; everything else (including alternating-sign negative
+ *  inputs) is `unknown`. */
+export declare function cumprodSign(s: Sign): Sign;