numbl 0.1.0 → 0.1.2

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

@@ -0,0 +1,99 @@
+/**
+ * Plot-related operations for the runtime.
+ */
+import { type RuntimeValue } from "../runtime/index.js";
+import type { PlotInstruction } from "../../graphics/types.js";
+import type { ExecOptions } from "../executeCode.js";
+import type { Runtime } from "./runtime.js";
+export declare function plotInstr(plotInstructions: PlotInstruction[], instr: {
+    type: "set_figure_handle";
+    handle: unknown;
+} | {
+    type: "plot";
+    x: unknown;
+    y: unknown;
+} | {
+    type: "set_hold";
+    value: unknown;
+} | {
+    type: "set_title";
+    text: unknown;
+} | {
+    type: "set_xlabel";
+    text: unknown;
+} | {
+    type: "set_ylabel";
+    text: unknown;
+} | {
+    type: "set_shading";
+    shading: unknown;
+} | {
+    type: "close";
+} | {
+    type: "close_all";
+} | {
+    type: "clf";
+} | {
+    type: "set_subplot";
+    rows: unknown;
+    cols: unknown;
+    index: unknown;
+} | {
+    type: "set_sgtitle";
+    text: unknown;
+} | {
+    type: "set_grid";
+    value: unknown;
+} | {
+    type: "set_zlabel";
+    text: unknown;
+} | {
+    type: "set_colorbar";
+    value: unknown;
+} | {
+    type: "set_colormap";
+    name: unknown;
+} | {
+    type: "set_axis";
+    value: unknown;
+}): void;
+export declare function viewCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function plotCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function plot3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function surfCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function imagescCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function contourCall(plotInstructions: PlotInstruction[], args: RuntimeValue[], filled: boolean): void;
+export declare function meshCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function scatterCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function barCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function barhCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function bar3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function bar3hCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function stairsCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function errorbarCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function semilogxCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function semilogyCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function areaCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function loglogCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+/**
+ * fplot(f), fplot(f, xinterval), fplot(funx, funy),
+ * fplot(funx, funy, tinterval), fplot(..., LineSpec)
+ */
+export declare function fplotCall(rt: Runtime, plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+/**
+ * fplot3(funx, funy, funz), fplot3(funx, funy, funz, tinterval),
+ * fplot3(..., LineSpec)
+ */
+export declare function fplot3Call(rt: Runtime, plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function scatter3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function histogramCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function histogram2Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function boxchartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function swarmchartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function swarmchart3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function piechartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function donutchartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function heatmapCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function legendCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function drawnow(plotInstructions: PlotInstruction[], options: ExecOptions): void;
+export declare function pause(seconds: unknown): void;

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

@@ -0,0 +1,4 @@
+/** Sentinel value representing the colon operator (:) in indexing. */
+export declare const COLON_SENTINEL: unique symbol;
+/** Sentinel value representing the `end` keyword in indexing. */
+export declare const END_SENTINEL: unique symbol;

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

@@ -0,0 +1,2 @@
+/** Names of all special builtins. Standalone module to avoid circular imports. */
+export declare const SPECIAL_BUILTIN_NAMES: readonly string[];

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

@@ -0,0 +1,13 @@
+/**
+ * Special builtin functions that require direct runtime access.
+ *
+ * These builtins are registered as IBuiltins (via registerDynamicIBuiltin)
+ * that close over the Runtime instance, unifying them with the standard
+ * IBuiltin dispatch path.
+ */
+import type { Runtime } from "./runtime.js";
+export { SPECIAL_BUILTIN_NAMES } from "./specialBuiltinNames.js";
+/**
+ * Register all special builtins as IBuiltins closing over the runtime instance.
+ */
+export declare function registerSpecialBuiltins(rt: Runtime): void;

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

@@ -0,0 +1,6 @@
+/**
+ * Struct and class instance field access.
+ */
+import { type RuntimeValue } from "./types.js";
+export declare function getRTValueField(base: RuntimeValue, field: string): RuntimeValue;
+export declare function setRTValueField(base: RuntimeValue, field: string, value: RuntimeValue): RuntimeValue;

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

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

package/dist-lib/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-lib/numbl-core/runtime/types.d.ts

@@ -0,0 +1,110 @@
+export declare const USE_FLOAT32: boolean;
+export declare const FloatXArray: Float32ArrayConstructor | Float64ArrayConstructor;
+export type FloatXArrayType = Float32Array | Float64Array;
+export type RuntimeValue = number | boolean | string | RuntimeTensor | RuntimeChar | RuntimeCell | RuntimeStruct | RuntimeFunction | RuntimeClassInstance | RuntimeComplexNumber | RuntimeDummyHandle | RuntimeStructArray | RuntimeSparseMatrix | RuntimeDictionary;
+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 isRuntimeStructArray: (value: RuntimeValue) => value is RuntimeStructArray;
+export declare const isRuntimeSparseMatrix: (value: RuntimeValue) => value is RuntimeSparseMatrix;
+export declare const isRuntimeDictionary: (value: RuntimeValue) => value is RuntimeDictionary;
+export declare const kstr: (value: RuntimeValue) => string;
+export type RuntimeTensor = {
+    kind: "tensor";
+    data: FloatXArrayType;
+    imag?: FloatXArrayType;
+    shape: number[];
+    /** When true, this tensor represents a logical (boolean) array from comparisons/logical ops. */
+    _isLogical?: boolean;
+    /** Reference count for copy-on-write. When > 1, data is shared and must be copied before mutation. */
+    _rc: number;
+};
+export type RuntimeChar = {
+    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[];
+};
+export type RuntimeCell = {
+    kind: "cell";
+    data: RuntimeValue[];
+    shape: number[];
+    /** Reference count for copy-on-write. When > 1, data is shared and must be copied before mutation. */
+    _rc: number;
+};
+export type RuntimeStruct = {
+    kind: "struct";
+    fields: Map<string, RuntimeValue>;
+};
+export type RuntimeFunction = {
+    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;
+    /** When true, jsFn expects nargout as its first argument */
+    jsFnExpectsNargout?: boolean;
+    /** Number of input parameters (for nargin(handle)) */
+    nargin?: number;
+};
+export type RuntimeClassInstance = {
+    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;
+};
+export type RuntimeComplexNumber = {
+    kind: "complex_number";
+    re: number;
+    im: number;
+};
+export type RuntimeDummyHandle = {
+    kind: "dummy_handle";
+};
+/** A 1-D array of structs that all share the same field names. **/
+export type RuntimeStructArray = {
+    kind: "struct_array";
+    fieldNames: string[];
+    elements: RuntimeStruct[];
+};
+/** Sparse matrix in CSC (Compressed Sparse Column) format, matching MATLAB's internal representation. */
+export type RuntimeSparseMatrix = {
+    kind: "sparse_matrix";
+    m: number;
+    n: number;
+    ir: Int32Array;
+    jc: Int32Array;
+    pr: Float64Array;
+    pi?: Float64Array;
+    _rc: number;
+};
+/** Dictionary mapping unique keys to values (MATLAB R2022b+). */
+export type RuntimeDictionary = {
+    kind: "dictionary";
+    /** Entries keyed by a hash string of the RuntimeValue key, preserving insertion order. */
+    entries: Map<string, {
+        key: RuntimeValue;
+        value: RuntimeValue;
+    }>;
+    keyType?: string;
+    valueType?: string;
+};

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

@@ -0,0 +1,20 @@
+/**
+ * Tensor shape/indexing utilities and copy-on-write helpers.
+ */
+import { type RuntimeValue, type RuntimeTensor } from "./types.js";
+/** Get 2D size (rows, cols) from shape, padding with 1s as needed */
+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;
+/**
+ * Share an RuntimeValue for assignment (COW): increments refcount on tensors/cells
+ * so that mIndexStore knows to copy before mutating.
+ * Returns a new wrapper object that shares the same underlying data.
+ */
+export declare function shareRuntimeValue(v: RuntimeValue): RuntimeValue;

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

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

package/dist-lib/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-lib/numbl-core/workspace/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export interface NativeBridge {
+    load(libraryPath: string): unknown;
+}

package/dist-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/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-lib/ts-lapack/src/SRC/dlamch.d.ts

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

package/dist-lib/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;