numbl 0.4.7 → 0.4.9

package/dist-browser/numbl-core/runtime/syncChannel.d.ts

@@ -0,0 +1 @@
+export declare function syncSleep(ms: number): void;

package/dist-browser/numbl-core/runtime/tensor-construction.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Range creation and tensor concatenation.
+ */
+import { type RuntimeValue, type RuntimeTensor } from "./types.js";
+/** Create a range start:end or start:step:end */
+export declare function makeRangeTensor(start: number, step: number, end: number): RuntimeTensor;
+/** Horizontal concatenation [A, B] */
+export declare function horzcat(...values: RuntimeValue[]): RuntimeValue;
+/** Vertical concatenation [A; B] */
+export declare function vertcat(...values: RuntimeValue[]): RuntimeValue;

package/dist-browser/numbl-core/runtime/types.d.ts

@@ -0,0 +1,197 @@
+import { Refcounted, type RefcountRuntime } from "./refcount.js";
+export declare const USE_FLOAT32: boolean;
+export type RuntimeValue = number | boolean | string | RuntimeTensor | RuntimeChar | RuntimeCell | RuntimeStruct | RuntimeFunction | RuntimeClassInstance | RuntimeComplexNumber | RuntimeDummyHandle | RuntimeGraphicsHandle | RuntimeStructArray | RuntimeClassInstanceArray | RuntimeSparseMatrix | RuntimeDictionary | RuntimeStringArray;
+export type RuntimeNumber = number;
+export type RuntimeLogical = boolean;
+export type RuntimeString = string;
+export declare const isRuntimeNumber: (value: RuntimeValue) => value is RuntimeNumber;
+export declare const isRuntimeLogical: (value: RuntimeValue) => value is RuntimeLogical;
+export declare const isRuntimeString: (value: RuntimeValue) => value is RuntimeString;
+export declare const isRuntimeChar: (value: RuntimeValue) => value is RuntimeChar;
+export declare const isRuntimeTensor: (value: RuntimeValue) => value is RuntimeTensor;
+export declare const isRuntimeCell: (value: RuntimeValue) => value is RuntimeCell;
+export declare const isRuntimeStruct: (value: RuntimeValue) => value is RuntimeStruct;
+export declare const isRuntimeFunction: (value: RuntimeValue) => value is RuntimeFunction;
+export declare const isRuntimeClassInstance: (value: RuntimeValue) => value is RuntimeClassInstance;
+export declare const isRuntimeComplexNumber: (value: RuntimeValue) => value is RuntimeComplexNumber;
+export declare const isRuntimeDummyHandle: (value: RuntimeValue) => value is RuntimeDummyHandle;
+export declare const isRuntimeGraphicsHandle: (value: RuntimeValue) => value is RuntimeGraphicsHandle;
+export declare const isRuntimeStructArray: (value: RuntimeValue) => value is RuntimeStructArray;
+export declare const isRuntimeClassInstanceArray: (value: RuntimeValue) => value is RuntimeClassInstanceArray;
+export declare const isRuntimeSparseMatrix: (value: RuntimeValue) => value is RuntimeSparseMatrix;
+export declare const isRuntimeDictionary: (value: RuntimeValue) => value is RuntimeDictionary;
+export declare const isRuntimeStringArray: (value: RuntimeValue) => value is RuntimeStringArray;
+export declare const kstr: (value: RuntimeValue) => string;
+export declare class RuntimeTensor extends Refcounted {
+    readonly kind: "tensor";
+    data: Float64Array;
+    imag: Float64Array | undefined;
+    shape: number[];
+    /** When true, this tensor represents a logical (boolean) array from
+     *  comparisons/logical ops. */
+    _isLogical: boolean | undefined;
+    constructor(data: Float64Array, shape: number[], imag?: Float64Array, _isLogical?: boolean);
+}
+export declare class RuntimeChar extends Refcounted {
+    readonly kind: "char";
+    value: string;
+    /** Optional shape for multi-row char arrays. If absent, shape is
+     *  [1, value.length]. For multi-row arrays, value contains all rows
+     *  concatenated (each row is shape[1] chars). */
+    shape: number[] | undefined;
+    constructor(value: string, shape?: number[]);
+}
+export declare class RuntimeStringArray extends Refcounted {
+    readonly kind: "string_array";
+    /** Elements in column-major order (plain JS strings). */
+    data: string[];
+    /** 2-D shape [rows, cols]; data.length === rows*cols. A 1x1 string is
+     *  normally represented as a primitive JS string, not a 1x1 array —
+     *  use stringArrayValue() to build results so scalars collapse. */
+    shape: [number, number];
+    constructor(data: string[], shape: [number, number]);
+}
+/** Build a string-array result, collapsing 1x1 to the primitive string
+ *  representation used for string scalars throughout the runtime. */
+export declare function stringArrayValue(data: string[], shape: [number, number]): RuntimeValue;
+export declare class RuntimeCell extends Refcounted {
+    readonly kind: "cell";
+    data: RuntimeValue[];
+    shape: number[];
+    constructor(data: RuntimeValue[], shape: number[]);
+    /** Replace element at idx, decref-old / incref-new. Caller resizes the
+     *  shape if necessary; this method does not touch shape. */
+    bindElement(rt: RefcountRuntime, idx: number, value: RuntimeValue): void;
+    protected _destroy(rt: RefcountRuntime): void;
+}
+export declare class RuntimeStruct extends Refcounted {
+    readonly kind: "struct";
+    fields: Map<string, RuntimeValue>;
+    constructor(fields: Map<string, RuntimeValue>);
+    /** Set/replace a field value, decref-old / incref-new. */
+    bindField(rt: RefcountRuntime, name: string, value: RuntimeValue): void;
+    protected _destroy(rt: RefcountRuntime): void;
+}
+export declare class RuntimeFunction extends Refcounted {
+    readonly kind: "function";
+    name: string;
+    /** For closures: captured variables */
+    captures: RuntimeValue[];
+    /** The underlying callable — either a builtin or user-defined function name */
+    impl: "builtin" | "user";
+    /** For anonymous functions and user function handles: the underlying JS closure */
+    jsFn: ((...args: unknown[]) => unknown) | undefined;
+    /** When true, jsFn expects nargout as its first argument */
+    jsFnExpectsNargout: boolean | undefined;
+    /** Number of input parameters (for nargin(handle)) */
+    nargin: number | undefined;
+    /** Cleanup hook fired by `_destroy`. Anonymous functions use this to
+     *  decref values held in their captured environment snapshot, since
+     *  those refs live in the JS closure (not in `captures`). */
+    releaseExtra: ((rt: RefcountRuntime) => void) | undefined;
+    /** For anonymous-function snapshots: the captured environment, made
+     *  visible to the alias sweep so a tensor stored both here and in
+     *  the parent env triggers copy-on-write on parent-side mutations.
+     *  (Only the structural shape `{ vars, parent }` is needed; typed
+     *  loosely to avoid a runtime↔interpreter circular import.) */
+    capturedEnv: {
+        vars: Map<string, RuntimeValue>;
+        parent?: unknown;
+    } | undefined;
+    /** The defining AST of this handle — an `AnonFunc` (`@(p) body`) or
+     *  `FuncHandle` (`@name`) parser Expr. Lets the JIT recover the
+     *  handle's source so a capture-free handle that crosses a
+     *  compile boundary (a loop input / call arg) can be inlined as an
+     *  in-scope handle constant. Typed loosely (parser Expr) to avoid a
+     *  runtime→parser layering dependency; consumers cast. Undefined for
+     *  handles created by paths that don't set it (e.g. builtins). */
+    handleAst: unknown;
+    /** Source file the handle was defined in. The inliner only reuses a
+     *  handle's AST when this matches the file being compiled, so a
+     *  named-handle target (`@foo`) resolves to the same `foo` it did at
+     *  definition (file-local functions can shadow across files). */
+    handleDefFile: string | undefined;
+    constructor(name: string, impl: "builtin" | "user", captures: RuntimeValue[], jsFn?: (...args: unknown[]) => unknown, jsFnExpectsNargout?: boolean, nargin?: number);
+    protected _destroy(rt: RefcountRuntime): void;
+}
+export declare class RuntimeClassInstance extends Refcounted {
+    readonly kind: "class_instance";
+    className: string;
+    fields: Map<string, RuntimeValue>;
+    /** True if this class inherits from handle (reference semantics). */
+    isHandleClass: boolean;
+    /** For classes that inherit from built-in types (e.g. classdef Foo < double),
+     *  stores the underlying built-in data. */
+    _builtinData: RuntimeValue | undefined;
+    constructor(className: string, fields: Map<string, RuntimeValue>, isHandleClass: boolean, _builtinData?: RuntimeValue);
+    /** Set/replace a field value (handle-class in-place mutation), with
+     *  proper decref-old / incref-new bookkeeping. Used for handle-class
+     *  field assigns; value-class field assigns construct a new instance. */
+    bindField(rt: RefcountRuntime, name: string, value: RuntimeValue): void;
+    protected _destroy(rt: RefcountRuntime): void;
+}
+/** An array of class instances that all share the same class. Created by
+ *  default horzcat/vertcat when the class doesn't overload them. `elements`
+ *  are stored in column-major order; `shape` is the 2-D `[rows, cols]` size
+ *  (defaults to a `1×N` row vector when omitted). */
+export declare class RuntimeClassInstanceArray extends Refcounted {
+    readonly kind: "class_instance_array";
+    className: string;
+    elements: RuntimeClassInstance[];
+    shape: [number, number];
+    constructor(className: string, elements: RuntimeClassInstance[], shape?: [number, number]);
+    protected _destroy(rt: RefcountRuntime): void;
+}
+export declare class RuntimeComplexNumber extends Refcounted {
+    readonly kind: "complex_number";
+    re: number;
+    im: number;
+    constructor(re: number, im: number);
+}
+export declare class RuntimeDummyHandle extends Refcounted {
+    readonly kind: "dummy_handle";
+    constructor();
+}
+/** Handle to a graphics object (e.g. surface returned by pcolor) with a mutable trace reference. */
+export declare class RuntimeGraphicsHandle extends Refcounted {
+    readonly kind: "graphics_handle";
+    _trace: Record<string, unknown>;
+    _traceType: string;
+    constructor(_trace: Record<string, unknown>, _traceType: string);
+}
+/** A 1-D array of structs that all share the same field names. */
+export declare class RuntimeStructArray extends Refcounted {
+    readonly kind: "struct_array";
+    fieldNames: string[];
+    elements: RuntimeStruct[];
+    constructor(fieldNames: string[], elements: RuntimeStruct[]);
+    protected _destroy(rt: RefcountRuntime): void;
+}
+/** Sparse matrix in CSC (Compressed Sparse Column) format, matching MATLAB's
+ *  internal representation. */
+export declare class RuntimeSparseMatrix extends Refcounted {
+    readonly kind: "sparse_matrix";
+    m: number;
+    n: number;
+    ir: Int32Array;
+    jc: Int32Array;
+    pr: Float64Array;
+    pi: Float64Array | undefined;
+    constructor(m: number, n: number, ir: Int32Array, jc: Int32Array, pr: Float64Array, pi?: Float64Array);
+}
+/** Dictionary mapping unique keys to values (MATLAB R2022b+). */
+export declare class RuntimeDictionary extends Refcounted {
+    readonly kind: "dictionary";
+    /** Entries keyed by a hash string of the RuntimeValue key, preserving insertion order. */
+    entries: Map<string, {
+        key: RuntimeValue;
+        value: RuntimeValue;
+    }>;
+    keyType: string | undefined;
+    valueType: string | undefined;
+    constructor(entries?: Map<string, {
+        key: RuntimeValue;
+        value: RuntimeValue;
+    }>, keyType?: string, valueType?: string);
+    protected _destroy(rt: RefcountRuntime): void;
+}

package/dist-browser/numbl-core/runtime/uihtmlSession.d.ts

@@ -0,0 +1,40 @@
+/**
+ * uihtml reverse channel (HTML → MATLAB) for a finished run.
+ *
+ * When a script creates a `uihtml` component with a callback
+ * (HTMLEventReceivedFcn / DataChangedFcn), the run leaves entries in
+ * `rt.uihtmlCallbacks`. `executeCode` then builds a `UihtmlSession` and returns
+ * it so the host (the worker) can keep the interpreter alive and re-enter it
+ * when an event arrives from the iframe — mirroring MATLAB, where the script
+ * returns but its callbacks keep firing.
+ *
+ * Dispatch re-activates the run's own special-builtin closures (captured at
+ * end-of-run, NOT re-registered — re-registering would reset their counters)
+ * and pushes the runtime so `disp`, plotting, and `sendEventToHTMLSource`
+ * inside the callback reach this runtime. This mirrors executeCode's own
+ * save/restore of SPECIAL_BUILTIN_NAMES.
+ */
+import type { Runtime } from "./runtime.js";
+import type { PlotInstruction } from "../../graphics/types.js";
+import { type IBuiltin } from "../interpreter/builtins/types.js";
+export interface UihtmlSession {
+    /** True while at least one component still has a registered callback. */
+    hasCallbacks(): boolean;
+    /** Dispatch an event from a component's page into MATLAB. `eventType` is
+     *  "HTMLEventReceived" (JS `sendEventToMATLAB`) or "DataChanged" (JS set
+     *  `htmlComponent.Data`). `payload.data` is the structured-clone'd JS value.
+     *  New plot output is flushed via `onDrawnow`; outgoing
+     *  `sendEventToHTMLSource` calls go through `rt.onHtmlSourceEvent`. */
+    dispatchEvent(compId: string, eventType: "HTMLEventReceived" | "DataChanged", payload: {
+        name?: string;
+        data: unknown;
+    }): void;
+    /** Release the retained callback handles (and their refs). */
+    dispose(): void;
+}
+/**
+ * Build a session over a runtime that registered uihtml callbacks.
+ * `activeSpecials` is a snapshot of this runtime's special-builtin closures,
+ * captured at end-of-run while they are still installed globally.
+ */
+export declare function createUihtmlSession(rt: Runtime, activeSpecials: Map<string, IBuiltin>, onDrawnow?: (plotInstructions: PlotInstruction[]) => void): UihtmlSession;

package/dist-browser/numbl-core/runtime/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tensor shape/indexing utilities.
+ */
+import { type RuntimeTensor } from "./types.js";
+/** Get 2D size (rows, cols) from shape, padding with 1s as needed.
+ *  For N-D tensors (N>2), trailing dimensions are collapsed into cols,
+ *  matching MATLAB's behavior when fewer subscripts than dimensions. */
+export declare function tensorSize2D(t: RuntimeTensor): [number, number];
+/** Compute total number of elements from shape */
+export declare function numel(shape: number[]): number;
+/** Column-major index for 2D: element at (row, col) in a matrix with `rows` rows */
+export declare function colMajorIndex(row: number, col: number, rows: number): number;
+/** Convert linear index to subscripts (column-major) */
+export declare function ind2sub(shape: number[], idx: number): number[];
+/** Convert subscripts to linear index (column-major) */
+export declare function sub2ind(shape: number[], subs: number[]): number;
+/** MATLAB num2str/string(double) default formatting: integers exact,
+ *  otherwise 5 significant digits (%.5g with MATLAB exponent padding). */
+export declare function matlabNumToString(n: number): string;

package/dist-browser/numbl-core/stdlib-bundle.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceFile } from "./workspace/types.js";
+export declare const stdlibFiles: WorkspaceFile[];
+export declare const shimFiles: WorkspaceFile[];

package/dist-browser/numbl-core/systemAdapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Platform-agnostic system adapter.
+ *
+ * numbl-core defines this interface but never imports Node.js process.
+ * Concrete implementations are injected from the host environment
+ * via ExecOptions.system.
+ */
+export interface SystemAdapter {
+    /** Get a single env var value, or undefined if not set. */
+    getEnv(name: string): string | undefined;
+    /** Get all env vars as key-value pairs. */
+    getAllEnv(): Record<string, string>;
+    /** Set an env var. */
+    setEnv(name: string, value: string): void;
+    /** Return the current working directory. */
+    cwd(): string;
+    /** Change the current working directory. Throws on failure. */
+    chdir(dir: string): void;
+    /** Return the platform string (e.g. "linux", "darwin", "win32"). */
+    platform(): string;
+    /** Return the CPU architecture string (e.g. "x64", "arm64"). */
+    arch(): string;
+}

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

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

package/dist-browser/numbl-core/workspace/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Workspace — multi-file support for cross-file function calls.
+ */
+export type { WorkspaceFile, NativeBridge } from "./types.js";

package/dist-browser/numbl-core/workspace/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Type definitions for workspace multi-file support.
+ */
+export interface WorkspaceFile {
+    name: string;
+    source: string;
+    data?: Uint8Array;
+}
+/**
+ * Bridge for loading native shared libraries (.so/.dll/.dylib).
+ * Implemented outside numbl-core (e.g. via koffi in the CLI) since
+ * native FFI is not available in browser environments.
+ *
+ * `koffi`, when present, exposes the root koffi module so the
+ * C-JIT executors can call its struct / alloc / encode / decode
+ * helpers. Browser deployments leave `koffi` undefined; the
+ * C-JIT executors decline (numbl falls back to JS-JIT).
+ */
+export interface NativeBridge {
+    load(libraryPath: string): unknown;
+    /** koffi root module — `require("koffi")`'s exports. Only the
+     *  C-JIT path consumes it. Optional so non-Node hosts can omit. */
+    koffi?: unknown;
+}

package/dist-browser/ts-lapack/src/BLAS/daxpy.d.ts

@@ -0,0 +1 @@
+export declare function daxpy(n: number, da: number, dx: Float64Array, dxOff: number, incx: number, dy: Float64Array, dyOff: number, incy: number): void;

package/dist-browser/ts-lapack/src/BLAS/dcopy.d.ts

@@ -0,0 +1 @@
+export declare function dcopy(n: number, dx: Float64Array, dxOff: number, incx: number, dy: Float64Array, dyOff: number, incy: number): void;

package/dist-browser/ts-lapack/src/BLAS/ddot.d.ts

@@ -0,0 +1 @@
+export declare function ddot(n: number, dx: Float64Array, dxOff: number, incx: number, dy: Float64Array, dyOff: number, incy: number): number;

package/dist-browser/ts-lapack/src/BLAS/dgemm.d.ts

@@ -0,0 +1 @@
+export declare function dgemm(transa: number, transb: number, m: number, n: number, k: number, alpha: number, a: Float64Array, aOff: number, lda: number, b: Float64Array, bOff: number, ldb: number, beta: number, c: Float64Array, cOff: number, ldc: number): void;

package/dist-browser/ts-lapack/src/BLAS/dgemm_optimized.d.ts

@@ -0,0 +1 @@
+export declare function dgemm_optimized(transa: number, transb: number, m: number, n: number, k: number, alpha: number, a: Float64Array, aOff: number, lda: number, b: Float64Array, bOff: number, ldb: number, beta: number, c: Float64Array, cOff: number, ldc: number): void;

package/dist-browser/ts-lapack/src/BLAS/dgemv.d.ts

@@ -0,0 +1 @@
+export declare function dgemv(trans: number, m: number, n: number, alpha: number, a: Float64Array, aOff: number, lda: number, x: Float64Array, xOff: number, incx: number, beta: number, y: Float64Array, yOff: number, incy: number): void;

package/dist-browser/ts-lapack/src/BLAS/dger.d.ts

@@ -0,0 +1 @@
+export declare function dger(m: number, n: number, alpha: number, x: Float64Array, xOff: number, incx: number, y: Float64Array, yOff: number, incy: number, a: Float64Array, aOff: number, lda: number): void;

package/dist-browser/ts-lapack/src/BLAS/dnrm2.d.ts

@@ -0,0 +1 @@
+export declare function dnrm2(n: number, x: Float64Array, xOff: number, incx: number): number;

package/dist-browser/ts-lapack/src/BLAS/drot.d.ts

@@ -0,0 +1 @@
+export declare function drot(n: number, dx: Float64Array, dxOff: number, incx: number, dy: Float64Array, dyOff: number, incy: number, c: number, s: number): void;

package/dist-browser/ts-lapack/src/BLAS/dscal.d.ts

@@ -0,0 +1 @@
+export declare function dscal(n: number, da: number, dx: Float64Array, dxOff: number, incx: number): void;

package/dist-browser/ts-lapack/src/BLAS/dswap.d.ts

@@ -0,0 +1 @@
+export declare function dswap(n: number, dx: Float64Array, dxOff: number, incx: number, dy: Float64Array, dyOff: number, incy: number): void;

package/dist-browser/ts-lapack/src/BLAS/dtrmm.d.ts

@@ -0,0 +1 @@
+export declare function dtrmm(side: number, uplo: number, transa: number, diag: number, m: number, n: number, alpha: number, a: Float64Array, aOff: number, lda: number, b: Float64Array, bOff: number, ldb: number): void;

package/dist-browser/ts-lapack/src/BLAS/dtrmv.d.ts

@@ -0,0 +1 @@
+export declare function dtrmv(uplo: number, trans: number, diag: number, n: number, a: Float64Array, aOff: number, lda: number, x: Float64Array, xOff: number, incx: number): void;

package/dist-browser/ts-lapack/src/BLAS/dtrsm.d.ts

@@ -0,0 +1 @@
+export declare function dtrsm(side: number, uplo: number, transa: number, diag: number, m: number, n: number, alpha: number, a: Float64Array, aOff: number, lda: number, b: Float64Array, bOff: number, ldb: number): void;

package/dist-browser/ts-lapack/src/BLAS/idamax.d.ts

@@ -0,0 +1 @@
+export declare function idamax(n: number, dx: Float64Array, dxOff: number, incx: number): number;

package/dist-browser/ts-lapack/src/SRC/dbdsqr.d.ts

@@ -0,0 +1,10 @@
+export declare function dbdsqr(uplo: number, // UPPER=0 or LOWER=1
+n: number, ncvt: number, // number of columns of VT
+nru: number, // number of rows of U
+ncc: number, // number of columns of C
+d: Float64Array, dOff: number, // diagonal (length n)
+e: Float64Array, eOff: number, // off-diagonal (length n-1)
+vt: Float64Array, vtOff: number, ldvt: number, // right singular vectors
+u: Float64Array, uOff: number, ldu: number, // left singular vectors
+c: Float64Array, cOff: number, ldc: number, // additional matrix
+work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgebak.d.ts

@@ -0,0 +1 @@
+export declare function dgebak(job: number, side: number, n: number, ilo: number, ihi: number, scale: Float64Array, scaleOff: number, m: number, v: Float64Array, vOff: number, ldv: number): number;

package/dist-browser/ts-lapack/src/SRC/dgebal.d.ts

@@ -0,0 +1,5 @@
+export declare function dgebal(job: number, n: number, a: Float64Array, aOff: number, lda: number, scale: Float64Array, scaleOff: number): {
+    ilo: number;
+    ihi: number;
+    info: number;
+};

package/dist-browser/ts-lapack/src/SRC/dgebd2.d.ts

@@ -0,0 +1 @@
+export declare function dgebd2(m: number, n: number, a: Float64Array, aOff: number, lda: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, tauq: Float64Array, tauqOff: number, taup: Float64Array, taupOff: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgebrd.d.ts

@@ -0,0 +1 @@
+export declare function dgebrd(m: number, n: number, a: Float64Array, aOff: number, lda: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, tauq: Float64Array, tauqOff: number, taup: Float64Array, taupOff: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-browser/ts-lapack/src/SRC/dgeev.d.ts

@@ -0,0 +1,3 @@
+export declare function dgeev(jobvl: number, // 0='N', 1='V'
+jobvr: number, // 0='N', 1='V'
+n: number, a: Float64Array, aOff: number, lda: number, wr: Float64Array, wrOff: number, wi: Float64Array, wiOff: number, vl: Float64Array, vlOff: number, ldvl: number, vr: Float64Array, vrOff: number, ldvr: number, work: Float64Array, workOff: number, lwork: number, balance?: boolean): number;

package/dist-browser/ts-lapack/src/SRC/dgehd2.d.ts

@@ -0,0 +1 @@
+export declare function dgehd2(n: number, ilo: number, ihi: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgehrd.d.ts

@@ -0,0 +1 @@
+export declare function dgehrd(n: number, ilo: number, ihi: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-browser/ts-lapack/src/SRC/dgelq2.d.ts

@@ -0,0 +1 @@
+export declare function dgelq2(m: number, n: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgelqf.d.ts

@@ -0,0 +1 @@
+export declare function dgelqf(m: number, n: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-browser/ts-lapack/src/SRC/dgeqr2.d.ts

@@ -0,0 +1 @@
+export declare function dgeqr2(m: number, n: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgeqrf.d.ts

@@ -0,0 +1 @@
+export declare function dgeqrf(m: number, n: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgeqrf_optimized.d.ts

@@ -0,0 +1 @@
+export declare function dgeqrf_optimized(m: number, n: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgesvd.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DGESVD computes the singular value decomposition (SVD) of a real
+ * M-by-N matrix A, optionally computing the left and/or right singular
+ * vectors.
+ *
+ * @param jobu  - 0='A' all M columns of U, 1='S' first min(m,n) columns,
+ *                2='O' overwrite A, 3='N' no left vectors
+ * @param jobvt - 0='A' all N rows of V**T, 1='S' first min(m,n) rows,
+ *                2='O' overwrite A, 3='N' no right vectors
+ * @param m     - Number of rows of A (>= 0)
+ * @param n     - Number of columns of A (>= 0)
+ * @param a     - Matrix A, dimension (lda, n), modified on exit
+ * @param aOff  - Offset into a
+ * @param lda   - Leading dimension of a (>= max(1, m))
+ * @param s     - Singular values, dimension min(m,n), descending order
+ * @param sOff  - Offset into s
+ * @param u     - Left singular vectors, dimension (ldu, ucol)
+ * @param uOff  - Offset into u
+ * @param ldu   - Leading dimension of u
+ * @param vt    - Right singular vectors, dimension (ldvt, n)
+ * @param vtOff - Offset into vt
+ * @param ldvt  - Leading dimension of vt
+ * @param work  - Workspace array
+ * @param workOff - Offset into work
+ * @param lwork - Workspace size; -1 for query
+ * @returns info: 0 success, <0 illegal arg, >0 DBDSQR did not converge
+ */
+export declare function dgesvd(jobu: number, jobvt: number, m: number, n: number, a: Float64Array, aOff: number, lda: number, s: Float64Array, sOff: number, u: Float64Array, uOff: number, ldu: number, vt: Float64Array, vtOff: number, ldvt: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-browser/ts-lapack/src/SRC/dgetrf.d.ts

@@ -0,0 +1 @@
+export declare function dgetrf(m: number, n: number, a: Float64Array, lda: number, ipiv: Int32Array): number;

package/dist-browser/ts-lapack/src/SRC/dgetrf2.d.ts

@@ -0,0 +1 @@
+export declare function dgetrf2(m: number, n: number, a: Float64Array, aOff: number, lda: number, ipiv: Int32Array, ipivOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dgetri.d.ts

@@ -0,0 +1 @@
+export declare function dgetri(n: number, a: Float64Array, lda: number, ipiv: Int32Array): number;

package/dist-browser/ts-lapack/src/SRC/dhseqr.d.ts

@@ -0,0 +1,32 @@
+/**
+ * DHSEQR computes the eigenvalues of a Hessenberg matrix H and,
+ * optionally, the matrices T and Z from the Schur decomposition
+ * H = Z T Z**T, where T is an upper quasi-triangular matrix (the
+ * Schur form), and Z is the orthogonal matrix of Schur vectors.
+ *
+ * Optionally Z may be postmultiplied into an input orthogonal
+ * matrix Q so that this routine can give the Schur factorization
+ * of a matrix A which has been reduced to the Hessenberg form H
+ * by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T.
+ *
+ * @param job - 0='E' (eigenvalues only), 1='S' (Schur form)
+ * @param compz - 0='N' (no Schur vectors), 1='I' (initialize Z to identity), 2='V' (input Z given)
+ * @param n - order of the matrix H (>= 0)
+ * @param ilo - 1-based lower index of balanced submatrix
+ * @param ihi - 1-based upper index of balanced submatrix
+ * @param h - Hessenberg matrix, dimension (ldh, n)
+ * @param hOff - offset into h
+ * @param ldh - leading dimension of h
+ * @param wr - real parts of eigenvalues, dimension (n)
+ * @param wrOff - offset into wr
+ * @param wi - imaginary parts of eigenvalues, dimension (n)
+ * @param wiOff - offset into wi
+ * @param z - Schur vectors matrix, dimension (ldz, n)
+ * @param zOff - offset into z
+ * @param ldz - leading dimension of z
+ * @param work - workspace array, dimension (lwork)
+ * @param workOff - offset into work
+ * @param lwork - dimension of workspace (-1 for workspace query)
+ * @returns INFO: 0 = success, < 0 = invalid argument, > 0 = convergence failure
+ */
+export declare function dhseqr(job: number, compz: number, n: number, ilo: number, ihi: number, h: Float64Array, hOff: number, ldh: number, wr: Float64Array, wrOff: number, wi: Float64Array, wiOff: number, z: Float64Array, zOff: number, ldz: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-browser/ts-lapack/src/SRC/dlabrd.d.ts

@@ -0,0 +1 @@
+export declare function dlabrd(m: number, n: number, nb: number, a: Float64Array, aOff: number, lda: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, tauq: Float64Array, tauqOff: number, taup: Float64Array, taupOff: number, x: Float64Array, xOff: number, ldx: number, y: Float64Array, yOff: number, ldy: number): void;

package/dist-browser/ts-lapack/src/SRC/dlacpy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DLACPY copies all or part of a two-dimensional matrix A to another
+ * matrix B.
+ *
+ * @param uplo - Specifies the part of matrix A to copy:
+ *               UPPER (0) = copy upper triangular part,
+ *               LOWER (1) = copy lower triangular part,
+ *               anything else = copy the entire matrix.
+ * @param m - Number of rows of the matrix A. m >= 0.
+ * @param n - Number of columns of the matrix A. n >= 0.
+ * @param a - Source matrix, dimension (lda, n).
+ * @param aOff - Offset into array a.
+ * @param lda - Leading dimension of a. lda >= max(1, m).
+ * @param b - Destination matrix, dimension (ldb, n).
+ * @param bOff - Offset into array b.
+ * @param ldb - Leading dimension of b. ldb >= max(1, m).
+ */
+export declare function dlacpy(uplo: number, m: number, n: number, a: Float64Array, aOff: number, lda: number, b: Float64Array, bOff: number, ldb: number): void;

package/dist-browser/ts-lapack/src/SRC/dladiv.d.ts

@@ -0,0 +1,9 @@
+export declare function dladiv(a: number, b: number, c: number, d: number): {
+    p: number;
+    q: number;
+};
+export declare function dladiv1(a: number, b: number, c: number, d: number): {
+    p: number;
+    q: number;
+};
+export declare function dladiv2(a: number, b: number, c: number, d: number, r: number, t: number): number;

package/dist-browser/ts-lapack/src/SRC/dlaexc.d.ts

@@ -0,0 +1,21 @@
+/**
+ * DLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in
+ * an upper quasi-triangular matrix T by an orthogonal similarity
+ * transformation.
+ *
+ * @param wantq - true: accumulate transformation in Q; false: do not
+ * @param n - order of the matrix T (>= 0)
+ * @param t - upper quasi-triangular matrix, dimension (ldt, n)
+ * @param tOff - offset into t
+ * @param ldt - leading dimension of t
+ * @param q - orthogonal matrix, dimension (ldq, n), updated if wantq
+ * @param qOff - offset into q
+ * @param ldq - leading dimension of q
+ * @param j1 - index of the first row of the first block T11 (1-based)
+ * @param n1 - order of the first block T11 (0, 1, or 2)
+ * @param n2 - order of the second block T22 (0, 1, or 2)
+ * @param work - workspace, dimension (n)
+ * @param workOff - offset into work
+ * @returns INFO: 0 = success, 1 = swap rejected (ill-conditioned)
+ */
+export declare function dlaexc(wantq: boolean, n: number, t: Float64Array, tOff: number, ldt: number, q: Float64Array, qOff: number, ldq: number, j1: number, n1: number, n2: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dlahqr.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DLAHQR computes the eigenvalues and optionally the Schur factorization
+ * of an upper Hessenberg matrix H.
+ *
+ * @param wantt - true: compute full Schur form T; false: only eigenvalues
+ * @param wantz - true: accumulate transformations into Z; false: no Z update
+ * @param n - order of the matrix H (>= 0)
+ * @param ilo - 1-based index, first row/col of active block
+ * @param ihi - 1-based index, last row/col of active block
+ * @param h - Hessenberg matrix, dimension (ldh, n)
+ * @param hOff - offset into h
+ * @param ldh - leading dimension of h
+ * @param wr - real parts of eigenvalues, dimension (n)
+ * @param wrOff - offset into wr
+ * @param wi - imaginary parts of eigenvalues, dimension (n)
+ * @param wiOff - offset into wi
+ * @param iloz - first row of Z to which transformations apply (1-based)
+ * @param ihiz - last row of Z to which transformations apply (1-based)
+ * @param z - Schur vectors matrix, dimension (ldz, n)
+ * @param zOff - offset into z
+ * @param ldz - leading dimension of z
+ * @returns INFO: 0 = success, > 0 = convergence failure at index
+ */
+export declare function dlahqr(wantt: boolean, wantz: boolean, n: number, ilo: number, ihi: number, h: Float64Array, hOff: number, ldh: number, wr: Float64Array, wrOff: number, wi: Float64Array, wiOff: number, iloz: number, ihiz: number, z: Float64Array, zOff: number, ldz: number): number;

package/dist-browser/ts-lapack/src/SRC/dlahr2.d.ts

@@ -0,0 +1 @@
+export declare function dlahr2(n: number, k: number, nb: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, t: Float64Array, tOff: number, ldt: number, y: Float64Array, yOff: number, ldy: number): void;

package/dist-browser/ts-lapack/src/SRC/dlaln2.d.ts

@@ -0,0 +1,5 @@
+export declare function dlaln2(ltrans: boolean, na: number, nw: number, smin: number, ca: number, a: Float64Array, aOff: number, lda: number, d1: number, d2: number, b: Float64Array, bOff: number, ldb: number, wr: number, wi: number, x: Float64Array, xOff: number, ldx: number): {
+    scale: number;
+    xnorm: number;
+    info: number;
+};

package/dist-browser/ts-lapack/src/SRC/dlamch.d.ts

@@ -0,0 +1 @@
+export declare function dlamch(cmach: number): number;

package/dist-browser/ts-lapack/src/SRC/dlange.d.ts

@@ -0,0 +1 @@
+export declare function dlange(norm: number, m: number, n: number, a: Float64Array, aOff: number, lda: number, work: Float64Array, workOff: number): number;