numbl 0.4.6 → 0.4.7

package/dist-lib/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-lib/numbl-core/interpreter/builtins/geometry.d.ts

@@ -1,9 +1,9 @@
 /**
  * Interpreter IBuiltins for computational geometry functions: delaunay,
- * delaunayn, inpolygon.
+ * delaunayn, convhull, convhulln, inpolygon.
  *
- * delaunay/delaunayn are backed by the qhull WASM module, installed as the
- * Delaunay backend at startup (see geometry-bridge.ts and the qhull-node /
+ * 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.
  */

package/dist-lib/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-lib/numbl-core/interpreter/builtins/index.d.ts

@@ -27,6 +27,8 @@ 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";

package/dist-lib/numbl-core/interpreter/interpreter.d.ts

@@ -34,6 +34,10 @@ export declare class Interpreter {
     workspaceEnv: Environment | undefined;
     /** @internal The caller's environment — for evalin/assignin('caller', ...) */
     callerEnv: Environment | undefined;
+    /** @internal Call-site variable names for the next user-function call, set
+     *  by `evalFuncCall` and consumed by `callUserFunction` to support
+     *  `inputname`. One-shot: cleared as soon as it is consumed. */
+    pendingInputNames: string[] | undefined;
     /** @internal Stack of [base, dimIndex, numIndices] for resolving `end` keyword in indexing. */
     endContextStack: Array<{
         base: unknown;
@@ -157,6 +161,7 @@ export declare class Interpreter {
     switchMatch: (switchVal: unknown, caseVal: unknown) => boolean;
     isOutputExpr: (expr: Expr) => boolean;
     callFunction: (name: string, args: unknown[], nargout: number) => unknown;
+    declaredNargin: (name: string) => number | undefined;
     interpretTarget: (target: ResolvedTarget, args: unknown[], nargout: number) => unknown;
     interpretLocalFunction: (target: Extract<ResolvedTarget, {
         kind: "localFunction";

package/dist-lib/numbl-core/interpreter/interpreterExec.d.ts

@@ -4,7 +4,7 @@
  */
 import type { Stmt, Expr, LValue } from "../parser/types.js";
 import type { RuntimeValue } from "../runtime/types.js";
-import { type ControlSignal } from "./types.js";
+import { Environment, type ControlSignal } from "./types.js";
 import type { Interpreter } from "./interpreter.js";
 export declare function execStmt(this: Interpreter, stmt: Stmt): ControlSignal | null;
 export declare function execStmts(this: Interpreter, stmts: Stmt[]): ControlSignal | null;
@@ -16,6 +16,19 @@ export declare function execStmts(this: Interpreter, stmts: Stmt[]): ControlSign
 export declare function execBlockStmts(this: Interpreter, stmts: Stmt[]): ControlSignal | null;
 export declare function evalExpr(this: Interpreter, expr: Expr): unknown;
 export declare function evalExprNargout(this: Interpreter, expr: Expr, nargout: number): unknown;
+/** Compute the call-site variable names for `inputname`, aligned to the
+ *  argument expressions. Entry i is the name of the variable passed as
+ *  argument i+1, or '' if that argument is not a plain workspace variable.
+ *
+ *  Per MATLAB: an argument that uses cell `{}` or dot `.` indexing produces
+ *  a comma-separated list, making the position of every following argument
+ *  dynamic — so that argument and all subsequent ones report ''. Plain
+ *  literals, expressions, and paren-indexing report '' only for themselves.
+ *
+ *  The returned array may be shorter than the flattened arg count (when an
+ *  argument expanded to a CSL); callers treat out-of-range indices as ''.
+ */
+export declare function computeInputNames(argExprs: Expr[], callerEnv: Environment): string[];
 export declare function evalArgs(this: Interpreter, argExprs: Expr[]): unknown[];
 export declare function evalBinary(this: Interpreter, expr: Extract<Expr, {
     type: "Binary";

package/dist-lib/numbl-core/interpreter/interpreterFunctions.d.ts

@@ -8,6 +8,12 @@ import type { ClassInfo } from "../lowering/classInfo.js";
 import { Environment, type FunctionDef } from "./types.js";
 import type { Interpreter } from "./interpreter.js";
 export declare function callFunction(this: Interpreter, name: string, args: unknown[], nargout: number): unknown;
+/** Declared input count of the user function a `@name` handle points to,
+ *  resolved the same way a call to `name` would resolve. Returns undefined
+ *  when the target is a builtin or otherwise has no resolvable user-function
+ *  AST (caller falls back to probing / 0). Used to populate
+ *  `nargin(@name)`. */
+export declare function declaredNargin(this: Interpreter, name: string): number | undefined;
 export declare function interpretTarget(this: Interpreter, target: ResolvedTarget, args: unknown[], nargout: number): unknown;
 export declare function interpretJsUserFunction(this: Interpreter, target: Extract<ResolvedTarget, {
     kind: "jsUserFunction";

package/dist-lib/numbl-core/interpreter/interpreterSpecialBuiltins.d.ts

@@ -25,6 +25,10 @@ export interface InterpreterContext {
         kind: "function" | "jsfunction" | "class";
         source: string;
     } | undefined;
+    /** Public (GetAccess public) property names of a class, including inherited
+     *  ones, in declaration order. Returns undefined if `className` is not a
+     *  known class. Backs `properties(obj)`. */
+    classPublicProperties: (className: string) => string[] | undefined;
 }
 export declare const FALL_THROUGH: unique symbol;
 export type InterpreterSpecialBuiltinHandler = (ctx: InterpreterContext, args: unknown[], nargout: number) => unknown | typeof FALL_THROUGH;

package/dist-lib/numbl-core/interpreter/types.d.ts

@@ -41,12 +41,25 @@ export declare class Environment {
     set persistentNames(v: Set<string>);
     /** Function ID for persistent variable storage */
     persistentFuncId: string | undefined;
+    /** Call-site variable names of this frame's arguments, for `inputname`.
+     *  Entry i is the name of the variable passed as argument i+1, or '' if
+     *  that argument was not a plain variable. Undefined when the call did
+     *  not originate from an interpreted call expression (e.g. feval, JIT).
+     *  Read directly off the executing frame — the interpreter has only
+     *  function-level scoping, so `this.env` is the frame while a body runs. */
+    inputArgNames: string[] | undefined;
     /** Back-reference to the runtime (needed for global/persistent access) */
     rt: Runtime | null;
     /** Set when a `@nestedFn` handle has been created that captures this env
      *  (or an ancestor). Tells the function-exit cleanup that clearing this
      *  env would strand the handle's closure, so locals must be left alive. */
     nestedHandleCreated: boolean;
+    /** For a nested-function frame: the names of this function's own formal
+     *  input/output arguments. These are always local — a write must never be
+     *  redirected to a same-named variable in the parent, even before the
+     *  output has been assigned. (MATLAB scopes a nested function's formal
+     *  arguments to that function; only other variables are shared.) */
+    nestedLocalNames: Set<string> | undefined;
     constructor(parent?: Environment | undefined);
     get(name: string): RuntimeValue | undefined;
     /** Set variable — for nested scopes, writes to parent if variable

package/dist-lib/numbl-core/lowering/classInfo.d.ts

@@ -18,9 +18,10 @@ export interface ClassInfo {
     methodNames: Set<string>;
     staticMethodNames: Set<string>;
     constructorName: string | null;
-    ast: Stmt & {
+    ast: (Stmt & {
         type: "ClassDef";
-    };
+    }) | null;
+    isOldStyle?: boolean;
     inferiorClasses: string[];
     externalMethodFiles: Map<string, {
         fileName: string;
@@ -34,3 +35,19 @@ export interface ClassInfo {
 export declare function extractClassInfo(classDef: Stmt & {
     type: "ClassDef";
 }, qualifiedName: string, fileName: string, source: string): ClassInfo;
+/**
+ * Build ClassInfo for an old-style (pre-classdef) `@ClassName` folder class.
+ * There is no classdef AST: the constructor is the `@Name/Name.m` plain
+ * function (which calls `obj = class(struct, 'Name')`), and every other `.m`
+ * in the folder is an external method dispatched on instances. Fields are
+ * dynamic (defined by the constructor's struct), so there are no declared
+ * property names.
+ */
+export declare function makeOldStyleClassInfo(qualifiedName: string, baseName: string, constructorFile: {
+    fileName: string;
+    source: string;
+}, methodFiles: {
+    name: string;
+    fileName: string;
+    source: string;
+}[]): ClassInfo;

package/dist-lib/numbl-core/native/geometry-bridge.d.ts

@@ -23,7 +23,17 @@
  * point indices.
  */
 export type DelaunayBackend = (points: number[][], dim: number) => number[][];
+/**
+ * Compute the convex hull of `points` (an array of dim-dimensional tuples).
+ * Returns an array of simplicial facets, each a list of `dim` 0-based input
+ * point indices (edges in 2-D, triangles in 3-D).
+ */
+export type ConvexHullBackend = (points: number[][], dim: number) => number[][];
 /** Install (or clear, with null) the Delaunay backend. */
 export declare function setDelaunayBackend(fn: DelaunayBackend | null): void;
 /** Get the current Delaunay backend, or null if none is installed. */
 export declare function getDelaunayBackend(): DelaunayBackend | null;
+/** Install (or clear, with null) the convex-hull backend. */
+export declare function setConvexHullBackend(fn: ConvexHullBackend | null): void;
+/** Get the current convex-hull backend, or null if none is installed. */
+export declare function getConvexHullBackend(): ConvexHullBackend | null;

package/dist-lib/numbl-core/parser/ArgumentsParser.d.ts

@@ -14,7 +14,12 @@ export declare class ArgumentsParser extends ControlFlowParser {
      */
     private parseArgDimensions;
     /**
-     * Parse validator list: {mustBeNumeric, mustBePositive}
+     * Parse validator list: {mustBeNumeric, mustBePositive}. Validators may be
+     * full function calls with arguments, e.g.
+     * `{mustBeMember(x,["a","b"]), mustBeInRange(x,0,7)}`. The validator bodies
+     * are not enforced at runtime, so we capture the top-level validator name
+     * tokens and skip past any nested `(...)`, `[...]`, `{...}` so parsing
+     * resumes correctly at the default value (`= expr`) or end of line.
      */
     private parseArgValidators;
     /**

package/dist-lib/numbl-core/runtime/constructors.d.ts

@@ -2,7 +2,7 @@
  * RuntimeValue constructor helpers (the RTV namespace).
  */
 import { ItemType } from "../lowering/itemTypes.js";
-import { type RuntimeNumber, RuntimeTensor, type RuntimeString, RuntimeChar, type RuntimeLogical, RuntimeCell, RuntimeStruct, RuntimeFunction, RuntimeClassInstance, RuntimeComplexNumber, RuntimeDummyHandle, RuntimeGraphicsHandle, RuntimeStructArray, RuntimeSparseMatrix, RuntimeDictionary, type RuntimeValue } from "./types.js";
+import { type RuntimeNumber, RuntimeTensor, type RuntimeString, RuntimeChar, type RuntimeLogical, RuntimeCell, RuntimeStruct, RuntimeFunction, RuntimeClassInstance, RuntimeClassInstanceArray, RuntimeComplexNumber, RuntimeDummyHandle, RuntimeGraphicsHandle, RuntimeStructArray, RuntimeSparseMatrix, RuntimeDictionary, type RuntimeValue } from "./types.js";
 export declare const RTV: {
     num(value: number): RuntimeNumber;
     tensor(data: Float64Array | number[], shape: number[], imag?: Float64Array | number[]): RuntimeTensor;
@@ -23,6 +23,7 @@ export declare const RTV: {
     struct(fields: Map<string, RuntimeValue> | Record<string, RuntimeValue>): RuntimeStruct;
     func(name: string, impl: "builtin" | "user", captures?: RuntimeValue[]): RuntimeFunction;
     classInstance(className: string, propertyNames: string[], isHandleClass?: boolean, defaults?: Map<string, RuntimeValue>): RuntimeClassInstance;
+    classInstanceArray(className: string, elements: RuntimeClassInstance[], shape?: [number, number]): RuntimeClassInstanceArray;
     complex(re: number, im: number): RuntimeComplexNumber;
     dummyHandle(): RuntimeDummyHandle;
     graphicsHandle(trace: Record<string, unknown>, traceType: string): RuntimeGraphicsHandle;

package/dist-lib/numbl-core/runtime/runtime.d.ts

@@ -12,7 +12,7 @@
  */
 import { type RuntimeValue, type RuntimeLogical, type RuntimeTensor, type RuntimeStruct, type RuntimeString, type RuntimeFunction, RuntimeError, type CallFrame } from "../runtime/index.js";
 import { RefScope } from "./refcount.js";
-import { RuntimeChar, RuntimeCell, type RuntimeComplexNumber, type RuntimeClassInstance } from "../runtime/types.js";
+import { RuntimeChar, RuntimeCell, RuntimeClassInstanceArray, type RuntimeComplexNumber, type RuntimeClassInstance } from "../runtime/types.js";
 import { type ItemType } from "../lowering/itemTypes.js";
 import type { PlotInstruction } from "../../graphics/types.js";
 import type { ExecOptions } from "../executeCode.js";
@@ -84,6 +84,7 @@ export declare class Runtime {
         struct(fields: Map<string, RuntimeValue> | Record<string, RuntimeValue>): RuntimeStruct;
         func(name: string, impl: "builtin" | "user", captures?: RuntimeValue[]): RuntimeFunction;
         classInstance(className: string, propertyNames: string[], isHandleClass?: boolean, defaults?: Map<string, RuntimeValue>): RuntimeClassInstance;
+        classInstanceArray(className: string, elements: RuntimeClassInstance[], shape?: [number, number]): RuntimeClassInstanceArray;
         complex(re: number, im: number): RuntimeComplexNumber;
         dummyHandle(): import("../runtime/types.js").RuntimeDummyHandle;
         graphicsHandle(trace: Record<string, unknown>, traceType: string): import("../runtime/types.js").RuntimeGraphicsHandle;

package/dist-lib/numbl-core/runtime/runtimeMemberAccess.d.ts

@@ -4,7 +4,7 @@
 import { type RuntimeValue } from "../runtime/index.js";
 import type { Runtime } from "./runtime.js";
 export declare function getMember(rt: Runtime, base: unknown, name: string): unknown;
-export declare function getMemberDynamic(base: unknown, nameExpr: unknown): RuntimeValue;
+export declare function getMemberDynamic(rt: Runtime, base: unknown, nameExpr: unknown): RuntimeValue;
 export declare function getMemberOrEmpty(base: unknown, name: string): RuntimeValue;
 export declare function setMemberReturn(rt: Runtime, base: unknown, name: string, rhs: unknown): unknown;
 export declare function setMemberDynamicReturn(rt: Runtime, base: unknown, nameExpr: unknown, rhs: unknown): RuntimeValue;

package/dist-lib/numbl-core/version.d.ts

@@ -1,2 +1,2 @@
 /** Numbl version, used for JIT disk cache invalidation. */
-export declare const NUMBL_VERSION = "0.4.6";
+export declare const NUMBL_VERSION = "0.4.7";