numbl 0.4.18 → 0.4.21

package/dist-browser/numbl-core/executors/jit/callExecutor.d.ts

@@ -25,7 +25,10 @@
  * - **Loop-depth gate.** Declines when `interp.loopDepth > 0` so a
  *   hot loop iterating function calls doesn't pay per-call JIT
  *   propose / spec-cache overhead. Once an outer call is JIT'd, its
- *   loops run inside mtoc2's compiled code anyway.
+ *   loops run inside mtoc2's compiled code anyway. The gate lifts when
+ *   every enclosing loop was itself declined: nothing above will be
+ *   compiled then, and an expensive callee would otherwise run
+ *   interpreted all the way down (`Interpreter.jitDeclinedLoopDepth`).
  */
 import type { Executor } from "../types.js";
 import { type JitType } from "../../jitTypes.js";
@@ -40,6 +43,9 @@ interface JitCallData {
 }
 interface CompiledArtifact {
     readonly specFn: (...args: unknown[]) => unknown;
+    /** The spec's declared output types — needed to convert a returned
+     *  struct back (an untagged JS object otherwise). */
+    readonly outputTypes: ReadonlyArray<CompilerType>;
 }
 export declare const jitCallExecutor: Executor<JitCallData, CompiledArtifact | null>;
 export {};

package/dist-browser/numbl-core/executors/jit/loopExecutor.d.ts

@@ -9,13 +9,15 @@
  * that the synthetic body is a single-element `[loopStmt]` instead of
  * a whole script body.
  *
- * Loop-depth gate: only fires when `interp.loopDepth === 0`. A loop
- * dispatched while the interpreter is iterating an enclosing
- * loop-body would pay per-iter propose/cache overhead with no
- * speedup, because the *outer* loop is the natural JIT entry point
- * (it captures the inner loop's body and runs it natively in mtoc2-
- * emitted code). When the outer loop fires its own JIT, the inner
- * loop never reaches the interpreter dispatcher at all.
+ * Loop-depth gate: fires when `interp.loopDepth === 0`, or when every
+ * enclosing loop has been declined by the JIT. A loop dispatched while the
+ * interpreter iterates an enclosing loop-body would pay per-iter
+ * propose/cache overhead with no speedup, because the *outer* loop is the
+ * natural JIT entry point (it captures the inner loop's body and runs it
+ * natively in mtoc2-emitted code) — but that only holds when the outer loop
+ * actually compiles. If it declined, the interpreter is walking its body and
+ * this loop is the outermost thing still compilable, so the gate lifts
+ * (`Interpreter.jitDeclinedLoopDepth`).
  */
 import type { Executor } from "../types.js";
 import { type JitType } from "../../jitTypes.js";
@@ -36,6 +38,9 @@ interface JitLoopData {
 }
 interface CompiledArtifact {
     readonly specFn: (...args: unknown[]) => unknown;
+    /** The synthetic spec's output types, so a struct written back into the
+     *  env is rebuilt as a struct (the emitted value is an untagged object). */
+    readonly outputTypes: ReadonlyArray<CompilerType>;
 }
 export declare const jitLoopExecutor: Executor<JitLoopData, CompiledArtifact | null>;
 export {};

package/dist-browser/numbl-core/executors/jit/topLevelExecutor.d.ts

@@ -31,6 +31,9 @@ interface JitTopLevelData {
 interface CompiledArtifact {
     readonly specFn: (...args: unknown[]) => unknown;
     readonly nargout: number;
+    /** The synthetic spec's output types, so a struct written back into the
+     *  env is rebuilt as a struct (the emitted value is an untagged object). */
+    readonly outputTypes: ReadonlyArray<CompilerType>;
 }
 export declare const jitTopLevelExecutor: Executor<JitTopLevelData, CompiledArtifact | null>;
 export {};

package/dist-browser/numbl-core/executors/jit/valueAdapter.d.ts

@@ -43,8 +43,15 @@ import type { Type } from "../../jit/index.js";
  *      complex-typed body reads `.re`/`.im`, so a bare number must be
  *      boxed into `{re, im:0}`. */
 export declare function numblToJit(v: RuntimeValue, paramType?: Type): unknown;
-/** mtoc2 emit-JS return value → numbl RuntimeValue. */
-export declare function jitToNumbl(v: unknown): RuntimeValue;
+/** mtoc2 emit-JS return value → numbl RuntimeValue.
+ *
+ *  `retType` is the compiler type the spec declares for this output. It is
+ *  only consulted for plain untagged objects, which is how the emitted code
+ *  represents both a struct and a class instance — the value alone cannot
+ *  tell them apart, so a struct is only rebuilt when the type says Struct
+ *  and anything else untagged is rejected (the executor then bails and the
+ *  interpreter, which has full class semantics, re-runs the call). */
+export declare function jitToNumbl(v: unknown, retType?: Type): RuntimeValue;
 /** True if `e` is the grow-bail sentinel thrown by the emitted JS
  *  store helpers (`mtoc2_idx_*_grow_js` in `scalar_index.js`) — an
  *  indexed store whose index exceeds the runtime extent, which would

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

@@ -110,6 +110,14 @@ export declare class Registry {
      *      pure overhead.
      */
     dispatch(siblings: readonly Stmt[], i: number, ctx: DispatchContext): DispatchResult;
+    /** Run one stmt on the AST interpreter.
+     *
+     *  When that stmt is a loop, the interpreter is about to walk its body,
+     *  which invalidates the "an enclosing loop will capture me" assumption
+     *  behind the executors' `loopDepth` gate. `jitDeclinedLoopDepth` records
+     *  that for the duration of the body so nested loops and calls can bid for
+     *  themselves instead of running interpreted all the way down. */
+    private interpretFallback;
     private runStmtCandidate;
     /** Cache lookup + compile-on-miss + run + bail handling. Returns
      *  the executor's success RunResult, or null when the candidate

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

@@ -0,0 +1,107 @@
+/**
+ * Sparse direct solvers on the CSC representation (real arithmetic):
+ * Kronecker product, structural triangularity checks, triangular solves,
+ * up-looking sparse Cholesky, left-looking sparse LU with partial pivoting
+ * (Gilbert-Peierls), permutations, fill-reducing orderings (minimum degree,
+ * reverse Cuthill-McKee), and the `A \ b` driver used by mldivide.
+ *
+ * Complex sparse matrices are not handled here; callers fall back to the
+ * dense path for them.
+ */
+import { type RuntimeSparseMatrix, type RuntimeTensor, type SparseTriInfo } from "../runtime/types.js";
+type Sp = RuntimeSparseMatrix;
+export declare const SINGULAR_WARNING = "Matrix is singular to working precision.";
+/** Convert a dense tensor to CSC (dropping zeros). */
+export declare function denseToSparse(t: RuntimeTensor): Sp;
+/** Build CSC from column-major dense data, dropping zeros. */
+export declare function denseDataToSparse(data: Float64Array, m: number, n: number): Sp;
+/** Sparse permutation matrix P with P(k, p[k]) = 1, so (P*A)(k,:) = A(p[k],:). */
+export declare function permutationMatrix(p: Int32Array | number[]): Sp;
+/** 1-based row vector from a 0-based permutation. */
+export declare function permVectorTensor(p: Int32Array): RuntimeTensor;
+export declare function invertPerm(p: Int32Array): Int32Array;
+/** C = A(p, q) for 0-based permutations p (rows) and q (columns). */
+export declare function sparsePermute(A: Sp, p: Int32Array, q: Int32Array): Sp;
+export declare function sparseKron(A: Sp, B: Sp): Sp;
+/**
+ * One O(nnz) pass over the pattern: is the matrix upper / lower triangular
+ * (explicitly stored zeros ignored), and where is each diagonal entry. The
+ * result is cached on the matrix object.
+ */
+export declare function triangularInfo(S: Sp): SparseTriInfo;
+/** True if every stored nonzero lies on or above the diagonal. */
+export declare function sparseIsUpper(S: Sp): boolean;
+/** True if every stored nonzero lies on or below the diagonal. */
+export declare function sparseIsLower(S: Sp): boolean;
+/** Exact numerical symmetry (A == A'), real sparse only. */
+export declare function sparseIsSymmetric(S: Sp): boolean;
+/** Solve R * X = B for upper-triangular R (n×n), B column-major n×nrhs.
+ *  Returns the solution in a fresh array and whether a zero pivot was hit. */
+export declare function sparseSolveUpper(R: Sp, B: Float64Array, nrhs: number): {
+    x: Float64Array;
+    singular: boolean;
+};
+/** Solve L * X = B for lower-triangular L (n×n). */
+export declare function sparseSolveLower(L: Sp, B: Float64Array, nrhs: number): {
+    x: Float64Array;
+    singular: boolean;
+};
+export interface CholResult {
+    /** Lower factor with L * L' = A (only when ok). */
+    L: Sp;
+    ok: boolean;
+    /** 0 on success, otherwise the 1-based column at which the pivot failed. */
+    p: number;
+}
+/**
+ * Cholesky factorization of a symmetric positive definite sparse matrix.
+ * Only the upper triangle of A is read; symmetry is not checked. On failure
+ * returns the leading (p-1)×(p-1) factor computed so far.
+ */
+export declare function sparseChol(A: Sp): CholResult;
+export interface LuResult {
+    /** Unit lower triangular, m × min(m,n), rows in pivot order. */
+    L: Sp;
+    /** Upper triangular, min(m,n) × n. */
+    U: Sp;
+    /** Row permutation: row k of P*A*Q is row p[k] of A. */
+    p: Int32Array;
+    /** Column permutation: column k of P*A*Q is column q[k] of A. */
+    q: Int32Array;
+    singular: boolean;
+}
+/**
+ * LU factorization P*A*Q = L*U of a real sparse matrix with threshold
+ * partial pivoting (tol = 1 is plain partial pivoting; smaller values prefer
+ * the diagonal entry when it is at least tol times the largest candidate).
+ */
+export declare function sparseLu(A: Sp, q: Int32Array | null, tol: number): LuResult;
+export declare function identityPerm(n: number): Int32Array;
+/**
+ * Minimum degree ordering on the pattern of A + A', computed on an explicit
+ * elimination graph. Returns a 0-based permutation p such that A(p,p) tends
+ * to have a sparser Cholesky factor. This is a plain minimum-degree
+ * ordering, not MATLAB's approximate minimum degree, so the permutation
+ * differs from MATLAB's `amd` while serving the same purpose.
+ */
+export declare function minimumDegreeOrdering(A: Sp): Int32Array;
+/**
+ * Reverse Cuthill-McKee ordering on the pattern of A + A'. Returns a 0-based
+ * permutation that tends to reduce the bandwidth of A(p,p).
+ */
+export declare function reverseCuthillMcKee(A: Sp): Int32Array;
+/** Column ordering for LU: minimum degree on the pattern of A'*A. */
+export declare function columnOrdering(A: Sp): Int32Array;
+/**
+ * Solve A * X = B for square real sparse A and dense B (n × nrhs,
+ * column-major). Returns null when the caller should use the dense path
+ * (non-square, complex, or nearly full A).
+ */
+export declare function sparseSolve(A: Sp, B: Float64Array, nrhs: number): Float64Array | null;
+/** Solve with precomputed LU factors: X = Q * U \ (L \ (P * B)). */
+export declare function luSolve(lu: LuResult, B: Float64Array, nrhs: number): Float64Array;
+/** Solve with LU factors of A for the transposed system A' * X = B. */
+export declare function luSolveTransposed(lu: LuResult, B: Float64Array, nrhs: number): Float64Array;
+/** Inverse of a square real sparse matrix, returned sparse. */
+export declare function sparseInverse(A: Sp): Sp;
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * MATLAB-style warnings from helper code that has no Runtime handle.
+ *
+ * The Runtime installs a sink that routes messages through its output
+ * channel ("Warning: <msg>"); before a Runtime exists, messages fall back
+ * to console.warn.
+ */
+export declare function setWarningSink(fn: (msg: string) => void): void;
+export declare function emitWarning(msg: string): void;

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

@@ -27,6 +27,7 @@ import "./cell-struct.js";
 import "./time-system.js";
 import "./datetime.js";
 import "./sparse.js";
+import "./sparse-solvers.js";
 import "./graph.js";
 import "./gallery.js";
 import "./special-math.js";

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

@@ -0,0 +1,16 @@
+/**
+ * Sparse direct-solver builtins: fill-reducing orderings (symrcm, amd,
+ * colamd), random sparse matrices (sprand, sprandn, sprandsym), and the
+ * `decomposition` object that stores factors for repeated solves.
+ *
+ * The factorizations themselves live in helpers/sparse-direct.ts; chol, lu,
+ * kron, inv and the operators `\` and `/` dispatch to them from
+ * linear-algebra.ts and helpers/arithmetic.ts.
+ */
+import type { RuntimeValue } from "../../runtime/types.js";
+/**
+ * Hook for the mldivide / mrdivide operator builtins: `dA \ B` and `B / dA`
+ * with a decomposition object. Returns undefined when neither operand is a
+ * decomposition so the ordinary operator runs.
+ */
+export declare function tryDecompositionDivide(name: "mldivide" | "mrdivide", a: RuntimeValue, b: RuntimeValue): RuntimeValue | undefined;

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

@@ -54,6 +54,17 @@ export declare class Interpreter {
      *  interpreter never sees them, so this gate only fires on calls
      *  that genuinely happen at the interpreter level inside a loop. */
     loopDepth: number;
+    /** @internal Number of those enclosing loops that the JIT *declined*, so
+     *  the interpreter is walking their bodies statement by statement. The
+     *  `loopDepth > 0` gate above assumes an enclosing loop will be compiled
+     *  and will swallow whatever is nested inside it; when that loop was
+     *  declined instead, the assumption is false and everything below it would
+     *  run interpreted however expensive it is. The executors therefore gate on
+     *  `loopDepth > 0 && jitDeclinedLoopDepth === 0`: still no per-iteration JIT
+     *  attempts underneath a loop that is about to be compiled, but a nested
+     *  loop or call under a declined one gets its own chance. Bumped by the
+     *  registry around the interpreter fallback for a loop stmt. */
+    jitDeclinedLoopDepth: number;
     /** @internal Number of enclosing conditional blocks (`if` / `switch` /
      *  `try`) whose bodies the interpreter is currently executing. Used by
      *  the loop classifier: when a loop is dispatched with `condBlockDepth >

package/dist-browser/numbl-core/jit/builtins/runtime/system/cscalar.d.ts

@@ -34,7 +34,7 @@ export function mtoc2_cpow(a: any, b: any): {
     im: number;
 };
 export function mtoc2_csqrt(z: any): {
-    re: number;
+    re: any;
     im: number;
 };
 export function mtoc2_cexp(z: any): {
@@ -42,15 +42,15 @@ export function mtoc2_cexp(z: any): {
     im: number;
 };
 export function mtoc2_clog(z: any): {
-    re: number;
+    re: any;
     im: number;
 };
 export function mtoc2_clog2(z: any): {
-    re: number;
+    re: any;
     im: number;
 };
 export function mtoc2_clog10(z: any): {
-    re: number;
+    re: any;
     im: number;
 };
 export function mtoc2_csin(z: any): {

package/dist-browser/numbl-core/jit/codegen/emitIndex.d.ts

@@ -38,7 +38,7 @@ export declare function emitNdScalarOffset(state: RuntimeState, indices: Readonl
  *  the precomputed source-index buffer). The caller is expected to
  *  emit these lines immediately after closing the slot iteration
  *  loops and before the GCC statement-expression's yield expression. */
-export declare function emitSliceSlotSetup(state: RuntimeState, lines: string[], indent: string, slotsTyped: ReadonlyArray<IndexSliceArg>, baseCName: string, cleanups?: string[]): string[];
+export declare function emitSliceSlotSetup(state: RuntimeState, lines: string[], indent: string, slotsTyped: ReadonlyArray<IndexSliceArg>, baseCName: string, cleanups?: string[], grow?: boolean): string[];
 /** Emit an `IndexSlice` as a C statement-expression-style block that
  *  allocates the result tensor, fills it, and evaluates to the result
  *  via a comma expression. The result is consumed at an owned consume

package/dist-browser/numbl-core/jit/compileSpec.d.ts

@@ -79,6 +79,10 @@ export interface CompileSpecResult {
     source: string;
     /** Names of runtime snippets activated by emit. Diagnostic only. */
     activatedSnippets: ReadonlyArray<string>;
+    /** The spec's output types, in order. The host needs them to convert
+     *  returned values back: a struct and a class instance are both plain
+     *  JS objects in the emitted code, so only the type says which is which. */
+    outputTypes: ReadonlyArray<Type>;
 }
 export declare function compileSpec(args: CompileSpecArgs): CompileSpecResult;
 export {};

package/dist-browser/numbl-core/jit/lowering/lower.d.ts

@@ -225,6 +225,19 @@ export declare class Lowerer {
     recordAssignment(name: string, expr: IRExpr, span: Span): Assign;
     private lowerIf;
     private lowerElseChain;
+    /** MATLAB `switch` lowered to the equivalent if/elseif chain.
+     *
+     *  The subject is evaluated once — hoisted to a temp unless it is already a
+     *  plain variable — and each case label becomes an equality test against it:
+     *  `strcmp` for text, `==` for numbers. A `case {a, b}` list is the OR of
+     *  the individual tests. Everything after that is `lowerIf`'s problem, which
+     *  means switch inherits its branch-env merging and cond folding.
+     *
+     *  Declined (leaving the unit to the interpreter, as before this existed):
+     *  a subject that is neither a scalar number nor text, a label whose kind
+     *  does not match the subject's, and an empty `case {}`.
+     */
+    private lowerSwitch;
     private lowerWhile;
     private lowerFor;
     lowerExpr(e: Expr): IRExpr;

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

@@ -23,6 +23,12 @@ export interface JitDecline {
     kind: string;
     /** Which executor declined: "jit-top-level" | "jit-call" | "jit-loop". */
     where: string;
+    /** Source position of the offending construct, when the thrown error
+     *  carried one. Only used for diagnostics. */
+    at?: {
+        file: string;
+        start: number;
+    };
 }
 /** Record a swallowed JIT decline reason (called from executor catch blocks). */
 export declare function recordJitDecline(d: JitDecline): void;

package/dist-browser/numbl-core/native/lapack-bridge.d.ts

@@ -18,7 +18,7 @@
  * Expected native addon version. Bump this whenever the C++ addon API changes
  * (must match ADDON_VERSION in numbl_addon.cpp).
  */
-export declare const NATIVE_ADDON_EXPECTED_VERSION = 8;
+export declare const NATIVE_ADDON_EXPECTED_VERSION = 9;
 export interface LapackBridge {
     /** Returns the native addon's version number. */
     addonVersion?(): number;
@@ -207,6 +207,34 @@ export interface LapackBridge {
         VL?: Float64Array;
         VR?: Float64Array;
     };
+    /**
+     * Eigenvalue decomposition of an n×n real *symmetric* matrix stored in
+     * column-major order. Uses LAPACK dsyev (only the lower triangle is read).
+     * Unlike `eig`, the eigenvalues are real and returned in ascending order and
+     * the eigenvectors are orthonormal, including across repeated eigenvalues.
+     * @param data      Column-major Float64Array of length n*n (not modified).
+     * @param n         Matrix dimension.
+     * @param computeV  true → also compute the orthonormal eigenvectors.
+     * @returns         Object with w (ascending eigenvalues) and optionally V.
+     */
+    eigSym?(data: Float64Array, n: number, computeV: boolean): {
+        w: Float64Array;
+        V?: Float64Array;
+    };
+    /**
+     * Eigenvalue decomposition of an n×n complex *Hermitian* matrix stored in
+     * column-major order. Uses LAPACK zheev (only the lower triangle is read).
+     * @param dataRe    Real parts — column-major Float64Array of length n*n.
+     * @param dataIm    Imaginary parts — column-major Float64Array of length n*n.
+     * @param n         Matrix dimension.
+     * @param computeV  true → also compute the unitary eigenvector basis.
+     * @returns         Object with w (real, ascending) and optionally VRe/VIm.
+     */
+    eigHerm?(dataRe: Float64Array, dataIm: Float64Array, n: number, computeV: boolean): {
+        w: Float64Array;
+        VRe?: Float64Array;
+        VIm?: Float64Array;
+    };
     /**
      * Eigenvalue decomposition of an n×n complex matrix stored in column-major order.
      * Uses LAPACK zgeev.

package/dist-browser/numbl-core/native/ts-lapack-eig-hermitian.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure-TypeScript Hermitian eigensolver — a zheev-equivalent for the ts-lapack
+ * bridge (browser path, no native LAPACK addon).
+ *
+ * Ported from the netlib LAPACK reference (zheev → zhetd2 / zungtr → zsteqr).
+ * One structural deviation: zsteqr accumulates the QL/QR rotations directly
+ * into the complex matrix Q, whereas here DSTEQR is run with COMPZ = 'I' to
+ * get the real orthogonal eigenvector matrix S of the tridiagonal, and the
+ * back-transformation V = Q * S is done as one complex-times-real matrix
+ * product afterwards. Both are O(n^3); this way the tridiagonal QL/QR lives in
+ * exactly one place (src/ts-lapack/src/SRC/dsteqr.ts) instead of two.
+ *
+ * Because zlarfg produces a real beta, the tridiagonal form is real symmetric,
+ * so DSTEQR applies unchanged.
+ *
+ * Eigenvalues come back real and in ascending order; eigenvectors form a
+ * unitary basis (V^H * V = I), matching dsyev/zheev and MATLAB.
+ *
+ * All matrices are column-major with leading dimension n, split into parallel
+ * real/imag Float64Arrays — matching the bridge's eigHerm I/O shape.
+ */
+/**
+ * ZHEEV-equivalent. `dataRe`/`dataIm` hold the full n×n Hermitian matrix in
+ * column-major order (only the lower triangle is read); they are not modified.
+ *
+ * Returns the eigenvalues in ascending order, plus a unitary eigenvector basis
+ * when `computeV` is set.
+ */
+export declare function eigHermTs(dataRe: Float64Array, dataIm: Float64Array, n: number, computeV: boolean): {
+    w: Float64Array;
+    VRe?: Float64Array;
+    VIm?: Float64Array;
+};

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

@@ -173,6 +173,15 @@ export declare class RuntimeStructArray extends Refcounted {
 }
 /** Sparse matrix in CSC (Compressed Sparse Column) format, matching MATLAB's
  *  internal representation. */
+/** Cached structural analysis of a sparse matrix (see helpers/sparse-direct). */
+export interface SparseTriInfo {
+    upper: boolean;
+    lower: boolean;
+    /** Index into ir/pr of the diagonal entry of each column, or -1. */
+    diagPos: Int32Array;
+    /** Diagonal values (0 where absent). */
+    diag: Float64Array;
+}
 export declare class RuntimeSparseMatrix extends Refcounted {
     readonly kind: "sparse_matrix";
     m: number;
@@ -181,6 +190,9 @@ export declare class RuntimeSparseMatrix extends Refcounted {
     jc: Int32Array;
     pr: Float64Array;
     pi: Float64Array | undefined;
+    /** Lazily computed by triangularInfo(); valid because sparse matrices are
+     *  never mutated in place (indexed assignment builds a new matrix). */
+    _triInfo: SparseTriInfo | undefined;
     constructor(m: number, n: number, ir: Int32Array, jc: Int32Array, pr: Float64Array, pi?: Float64Array);
 }
 /** Dictionary mapping unique keys to values (MATLAB R2022b+). */

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

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

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

@@ -0,0 +1 @@
+export declare function dsymv(uplo: 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/dsyr2.d.ts

@@ -0,0 +1 @@
+export declare function dsyr2(uplo: 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/SRC/dlae2.d.ts

@@ -0,0 +1,4 @@
+export declare function dlae2(a: number, b: number, c: number): {
+    rt1: number;
+    rt2: number;
+};

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

@@ -0,0 +1,6 @@
+export declare function dlaev2(a: number, b: number, c: number): {
+    rt1: number;
+    rt2: number;
+    cs1: number;
+    sn1: number;
+};

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

@@ -0,0 +1 @@
+export declare function dlanst(norm: number, n: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number): number;

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

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

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

@@ -0,0 +1 @@
+export declare function dlasrt(id: number, n: number, d: Float64Array, dOff: number): number;

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

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

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

@@ -0,0 +1,4 @@
+export declare const COMPZ_N = 0;
+export declare const COMPZ_V = 1;
+export declare const COMPZ_I = 2;
+export declare function dsteqr(compz: number, n: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, z: Float64Array, zOff: number, ldz: number, work: Float64Array, workOff: number): number;

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

@@ -0,0 +1 @@
+export declare function dsyev(wantz: boolean, uplo: number, n: number, a: Float64Array, aOff: number, lda: number, w: Float64Array, wOff: number): number;

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

@@ -0,0 +1 @@
+export declare function dsytd2(uplo: number, n: number, a: Float64Array, aOff: number, lda: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, tau: Float64Array, tauOff: number): number;