numbl 0.1.0 → 0.1.2

package/dist-lib/ts-lapack/src/SRC/dlanv2.d.ts

@@ -0,0 +1,12 @@
+export declare function dlanv2(a: number, b: number, c: number, d: number): {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    rt1r: number;
+    rt1i: number;
+    rt2r: number;
+    rt2i: number;
+    cs: number;
+    sn: number;
+};

package/dist-lib/ts-lapack/src/SRC/dlapy2.d.ts

@@ -0,0 +1 @@
+export declare function dlapy2(x: number, y: number): number;

package/dist-lib/ts-lapack/src/SRC/dlaqr1.d.ts

@@ -0,0 +1 @@
+export declare function dlaqr1(n: number, h: Float64Array, hOff: number, ldh: number, sr1: number, si1: number, sr2: number, si2: number, v: Float64Array, vOff: number): void;

package/dist-lib/ts-lapack/src/SRC/dlaqr30.d.ts

@@ -0,0 +1,81 @@
+/**
+ * DLAQR3 accepts as input an upper Hessenberg matrix H and performs an
+ * orthogonal similarity transformation designed to detect and deflate
+ * fully converged eigenvalues from a trailing principal submatrix.
+ *
+ * This is the "aggressive" variant that calls dlaqr0 recursively for the
+ * QR step inside the deflation window (as opposed to dlaqr2 which uses
+ * dlahqr only).
+ *
+ * @param wantt - true: full Schur form required; false: eigenvalues only
+ * @param wantz - true: accumulate transformations into Z
+ * @param n - order of the matrix H
+ * @param ktop - first row/col of isolated block (1-based)
+ * @param kbot - last row/col of isolated block (1-based)
+ * @param nw - deflation window size
+ * @param h - Hessenberg matrix, dimension (ldh, n)
+ * @param hOff - offset into h
+ * @param ldh - leading dimension of h
+ * @param iloz - first row of Z to update (1-based)
+ * @param ihiz - last row of Z to update (1-based)
+ * @param z - Schur vectors, dimension (ldz, n)
+ * @param zOff - offset into z
+ * @param ldz - leading dimension of z
+ * @param ns - (output) number of unconverged eigenvalues (shifts)
+ * @param nd - (output) number of converged (deflated) eigenvalues
+ * @param sr - real parts of eigenvalues/shifts, dimension (kbot)
+ * @param srOff - offset into sr
+ * @param si - imaginary parts of eigenvalues/shifts, dimension (kbot)
+ * @param siOff - offset into si
+ * @param v - work array, dimension (ldv, nw)
+ * @param vOff - offset into v
+ * @param ldv - leading dimension of v
+ * @param nh - number of columns of t available
+ * @param t - work array, dimension (ldt, nw)
+ * @param tOff - offset into t
+ * @param ldt - leading dimension of t
+ * @param nv - number of rows of wv available
+ * @param wv - work array, dimension (ldwv, nw)
+ * @param wvOff - offset into wv
+ * @param ldwv - leading dimension of wv
+ * @param work - workspace, dimension (lwork)
+ * @param workOff - offset into work
+ * @param lwork - workspace size; if -1, workspace query
+ */
+export declare function dlaqr3(wantt: boolean, wantz: boolean, n: number, ktop: number, kbot: number, nw: number, h: Float64Array, hOff: number, ldh: number, iloz: number, ihiz: number, z: Float64Array, zOff: number, ldz: number, ns: {
+    val: number;
+}, nd: {
+    val: number;
+}, sr: Float64Array, srOff: number, si: Float64Array, siOff: number, v: Float64Array, vOff: number, ldv: number, nh: number, t: Float64Array, tOff: number, ldt: number, nv: number, wv: Float64Array, wvOff: number, ldwv: number, work: Float64Array, workOff: number, lwork: number): void;
+/**
+ * DLAQR0 computes the eigenvalues of a Hessenberg matrix H and,
+ * optionally, the matrices T and Z from the Schur decomposition
+ * H = Z T Z**T.
+ *
+ * For small matrices (n <= NTINY = 15), it dispatches to DLAHQR.
+ * For larger matrices, it uses multi-shift QR with aggressive early
+ * deflation (DLAQR3 + DLAQR5).
+ *
+ * @param wantt - true: compute full Schur form; false: eigenvalues only
+ * @param wantz - true: accumulate transformations into Z
+ * @param n - order of the matrix H
+ * @param ilo - first row/col of active block (1-based)
+ * @param ihi - last row/col of active block (1-based)
+ * @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 (ihi)
+ * @param wrOff - offset into wr
+ * @param wi - imaginary parts of eigenvalues, dimension (ihi)
+ * @param wiOff - offset into wi
+ * @param iloz - first row of Z to update (1-based)
+ * @param ihiz - last row of Z to update (1-based)
+ * @param z - Schur vectors, dimension (ldz, n)
+ * @param zOff - offset into z
+ * @param ldz - leading dimension of z
+ * @param work - workspace, dimension (lwork)
+ * @param workOff - offset into work
+ * @param lwork - workspace size; if -1, workspace query
+ * @returns INFO: 0 = success, > 0 = convergence failure at index
+ */
+export declare function dlaqr0(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, work: Float64Array, workOff: number, lwork: number): number;

package/dist-lib/ts-lapack/src/SRC/dlaqr5.d.ts

@@ -0,0 +1,38 @@
+/**
+ * DLAQR5 performs a single small-bulge multi-shift QR sweep.
+ *
+ * @param wantt - true if the quasi-triangular Schur factor is being computed
+ * @param wantz - true if the orthogonal Schur factor is being computed
+ * @param kacc22 - 0, 1, or 2; specifies computation mode of far-from-diagonal updates
+ * @param n - order of the Hessenberg matrix H
+ * @param ktop - first row/col of isolated diagonal block (1-based)
+ * @param kbot - last row/col of isolated diagonal block (1-based)
+ * @param nshfts - number of simultaneous shifts (must be positive and even)
+ * @param sr - real parts of shifts, dimension (nshfts)
+ * @param srOff - offset into sr
+ * @param si - imaginary parts of shifts, dimension (nshfts)
+ * @param siOff - offset into si
+ * @param h - Hessenberg matrix, dimension (ldh, n)
+ * @param hOff - offset into h
+ * @param ldh - leading dimension of h
+ * @param iloz - first row of Z to update (1-based)
+ * @param ihiz - last row of Z to update (1-based)
+ * @param z - Schur vectors, dimension (ldz, ihiz)
+ * @param zOff - offset into z
+ * @param ldz - leading dimension of z
+ * @param v - workspace for reflectors, dimension (ldv, nshfts/2)
+ * @param vOff - offset into v
+ * @param ldv - leading dimension of v (>= 3)
+ * @param u - workspace for accumulating reflections, dimension (ldu, 2*nshfts)
+ * @param uOff - offset into u
+ * @param ldu - leading dimension of u
+ * @param nv - number of rows in wv available for workspace
+ * @param wv - workspace, dimension (ldwv, 2*nshfts)
+ * @param wvOff - offset into wv
+ * @param ldwv - leading dimension of wv
+ * @param nh - number of columns in wh available for workspace
+ * @param wh - workspace, dimension (ldwh, nh)
+ * @param whOff - offset into wh
+ * @param ldwh - leading dimension of wh
+ */
+export declare function dlaqr5(wantt: boolean, wantz: boolean, kacc22: number, n: number, ktop: number, kbot: number, nshfts: number, sr: Float64Array, srOff: number, si: Float64Array, siOff: number, h: Float64Array, hOff: number, ldh: number, iloz: number, ihiz: number, z: Float64Array, zOff: number, ldz: number, v: Float64Array, vOff: number, ldv: number, u: Float64Array, uOff: number, ldu: number, nv: number, wv: Float64Array, wvOff: number, ldwv: number, nh: number, wh: Float64Array, whOff: number, ldwh: number): void;

package/dist-lib/ts-lapack/src/SRC/dlarf.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DLARF applies a real elementary reflector H to a real m by n matrix C,
+ * from either the left or the right.
+ *
+ * @param side   - LEFT (0) to form H*C, RIGHT (1) to form C*H
+ * @param m      - Number of rows of C
+ * @param n      - Number of columns of C
+ * @param v      - The vector v in H = I - tau*v*v'
+ * @param vOff   - Offset into v for V(1)
+ * @param incv   - Increment between elements of v (incv <> 0)
+ * @param tau    - The scalar tau
+ * @param c      - The m-by-n matrix C (column-major)
+ * @param cOff   - Offset into c for C(1,1)
+ * @param ldc    - Leading dimension of c (ldc >= max(1,m))
+ * @param work   - Workspace of dimension n (if side=LEFT) or m (if side=RIGHT)
+ * @param workOff - Offset into work
+ */
+export declare function dlarf(side: number, m: number, n: number, v: Float64Array, vOff: number, incv: number, tau: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number): void;

package/dist-lib/ts-lapack/src/SRC/dlarf1f.d.ts

@@ -0,0 +1 @@
+export declare function dlarf1f(side: number, m: number, n: number, v: Float64Array, vOff: number, incv: number, tau: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number): void;

package/dist-lib/ts-lapack/src/SRC/dlarfb.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DLARFB applies a real block reflector H or its transpose H**T to a
+ * real m-by-n matrix C, from either the left or the right.
+ *
+ * @param side    - LEFT (0) or RIGHT (1)
+ * @param trans   - NOTRANS (0) to apply H, TRANS (1) to apply H**T
+ * @param direct  - 0=FORWARD, 1=BACKWARD
+ * @param storev  - 0=COLUMNWISE, 1=ROWWISE
+ * @param m       - Number of rows of C
+ * @param n       - Number of columns of C
+ * @param k       - Order of the matrix T (number of elementary reflectors)
+ * @param v       - The matrix V
+ * @param vOff    - Offset into v for V(1,1)
+ * @param ldv     - Leading dimension of V
+ * @param t       - The triangular factor T
+ * @param tOff    - Offset into t for T(1,1)
+ * @param ldt     - Leading dimension of T
+ * @param c       - The m-by-n matrix C
+ * @param cOff    - Offset into c for C(1,1)
+ * @param ldc     - Leading dimension of C
+ * @param work    - Workspace, dimension (ldwork, k)
+ * @param workOff - Offset into work
+ * @param ldwork  - Leading dimension of work (>= n if side=LEFT, >= m if side=RIGHT)
+ */
+export declare function dlarfb(side: number, trans: number, direct: number, storev: number, m: number, n: number, k: number, v: Float64Array, vOff: number, ldv: number, t: Float64Array, tOff: number, ldt: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number, ldwork: number): void;

package/dist-lib/ts-lapack/src/SRC/dlarfg.d.ts

@@ -0,0 +1,4 @@
+export declare function dlarfg(n: number, alpha: number, x: Float64Array, xOff: number, incx: number): {
+    alpha: number;
+    tau: number;
+};

package/dist-lib/ts-lapack/src/SRC/dlarft.d.ts

@@ -0,0 +1,20 @@
+/**
+ * DLARFT forms the triangular factor T of a real block reflector H
+ * of order n, which is defined as a product of k elementary reflectors.
+ *
+ * @param direct  - 0=FORWARD ('F'): T is upper triangular;
+ *                  1=BACKWARD ('B'): T is lower triangular
+ * @param storev  - 0=COLUMNWISE ('C'): reflectors stored in columns of V;
+ *                  1=ROWWISE ('R'): reflectors stored in rows of V
+ * @param n       - Order of the block reflector H (n >= 0)
+ * @param k       - Number of elementary reflectors (k >= 1)
+ * @param v       - The matrix V
+ * @param vOff    - Offset into v for V(1,1)
+ * @param ldv     - Leading dimension of V
+ * @param tau     - TAU(i) = scalar factor of H(i)
+ * @param tauOff  - Offset into tau for TAU(1)
+ * @param t       - Output k-by-k triangular factor T
+ * @param tOff    - Offset into t for T(1,1)
+ * @param ldt     - Leading dimension of T (ldt >= k)
+ */
+export declare function dlarft(direct: number, storev: number, n: number, k: number, v: Float64Array, vOff: number, ldv: number, tau: Float64Array, tauOff: number, t: Float64Array, tOff: number, ldt: number): void;

package/dist-lib/ts-lapack/src/SRC/dlarfx.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DLARFX applies a real elementary reflector H to a real m-by-n matrix C,
+ * from either the left or the right, with loop unrolling for small sizes.
+ *
+ * @param side    - LEFT (0) to form H*C, RIGHT (1) to form C*H
+ * @param m       - Number of rows of C
+ * @param n       - Number of columns of C
+ * @param v       - The vector v in H = I - tau*v*v'
+ * @param vOff    - Offset into v for V(1)
+ * @param tau     - The scalar tau
+ * @param c       - The m-by-n matrix C (column-major)
+ * @param cOff    - Offset into c for C(1,1)
+ * @param ldc     - Leading dimension of c
+ * @param work    - Workspace (not referenced if H has order < 11)
+ * @param workOff - Offset into work
+ */
+export declare function dlarfx(side: number, m: number, n: number, v: Float64Array, vOff: number, tau: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number): void;

package/dist-lib/ts-lapack/src/SRC/dlartg.d.ts

@@ -0,0 +1,5 @@
+export declare function dlartg(f: number, g: number): {
+    cs: number;
+    sn: number;
+    r: number;
+};

package/dist-lib/ts-lapack/src/SRC/dlas2.d.ts

@@ -0,0 +1,4 @@
+export declare function dlas2(f: number, g: number, h: number): {
+    ssmin: number;
+    ssmax: number;
+};

package/dist-lib/ts-lapack/src/SRC/dlascl.d.ts

@@ -0,0 +1 @@
+export declare function dlascl(type: number, kl: number, ku: number, cfrom: number, cto: number, m: number, n: number, a: Float64Array, aOff: number, lda: number): number;

package/dist-lib/ts-lapack/src/SRC/dlaset.d.ts

@@ -0,0 +1,19 @@
+/**
+ * DLASET initializes an m-by-n matrix A to BETA on the diagonal and
+ * ALPHA on the offdiagonals.
+ *
+ * @param uplo - Specifies the part of matrix A to be set:
+ *               UPPER (0) = upper triangular part is set; the strictly
+ *                           lower triangular part is not changed.
+ *               LOWER (1) = lower triangular part is set; the strictly
+ *                           upper triangular part is not changed.
+ *               anything else = all of the matrix A is set.
+ * @param m - Number of rows of the matrix A. m >= 0.
+ * @param n - Number of columns of the matrix A. n >= 0.
+ * @param alpha - The constant to which the offdiagonal elements are set.
+ * @param beta - The constant to which the diagonal elements are set.
+ * @param a - Matrix, dimension (lda, n).
+ * @param aOff - Offset into array a.
+ * @param lda - Leading dimension of a. lda >= max(1, m).
+ */
+export declare function dlaset(uplo: number, m: number, n: number, alpha: number, beta: number, a: Float64Array, aOff: number, lda: number): void;

package/dist-lib/ts-lapack/src/SRC/dlasr.d.ts

@@ -0,0 +1 @@
+export declare function dlasr(side: number, pivot: number, direct: number, m: number, n: number, c: Float64Array, cOff: number, s: Float64Array, sOff: number, a: Float64Array, aOff: number, lda: number): void;

package/dist-lib/ts-lapack/src/SRC/dlassq.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DLASSQ updates a scaled sum of squares.
+ *
+ * Given scl and sumsq, DLASSQ updates them such that
+ *   (scl_out**2)*sumsq_out = x(1)**2 +...+ x(n)**2 + (scl_in**2)*sumsq_in
+ *
+ * @param n - Number of elements in the vector x.
+ * @param x - The vector, dimension (1+(n-1)*|incx|).
+ * @param xOff - Offset into array x.
+ * @param incx - The increment between successive values of x.
+ * @param scl - In/out scaling factor. Wrapped in { val } for pass-by-reference.
+ * @param sumsq - In/out sum of squares. Wrapped in { val } for pass-by-reference.
+ */
+export declare function dlassq(n: number, x: Float64Array, xOff: number, incx: number, scl: {
+    val: number;
+}, sumsq: {
+    val: number;
+}): void;

package/dist-lib/ts-lapack/src/SRC/dlasv2.d.ts

@@ -0,0 +1,8 @@
+export declare function dlasv2(f: number, g: number, h: number): {
+    ssmin: number;
+    ssmax: number;
+    snr: number;
+    csr: number;
+    snl: number;
+    csl: number;
+};

package/dist-lib/ts-lapack/src/SRC/dlaswp.d.ts

@@ -0,0 +1 @@
+export declare function dlaswp(n: number, a: Float64Array, aOff: number, lda: number, k1: number, k2: number, ipiv: Int32Array, ipivOff: number, incx: number): void;

package/dist-lib/ts-lapack/src/SRC/dlasy2.d.ts

@@ -0,0 +1,5 @@
+export declare function dlasy2(ltranl: boolean, ltranr: boolean, isgn: number, n1: number, n2: number, tl: Float64Array, tlOff: number, ldtl: number, tr: Float64Array, trOff: number, ldtr: number, b: Float64Array, bOff: number, ldb: number, x: Float64Array, xOff: number, ldx: number): {
+    scale: number;
+    xnorm: number;
+    info: number;
+};

package/dist-lib/ts-lapack/src/SRC/dorg2r.d.ts

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

package/dist-lib/ts-lapack/src/SRC/dorgbr.d.ts

@@ -0,0 +1 @@
+export declare function dorgbr(vect: number, m: number, n: number, k: 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/dorghr.d.ts

@@ -0,0 +1 @@
+export declare function dorghr(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/dorgl2.d.ts

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

package/dist-lib/ts-lapack/src/SRC/dorglq.d.ts

@@ -0,0 +1 @@
+export declare function dorglq(m: number, n: number, k: 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/dorgqr.d.ts

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

package/dist-lib/ts-lapack/src/SRC/dorgqr_optimized.d.ts

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

package/dist-lib/ts-lapack/src/SRC/dorm2r.d.ts

@@ -0,0 +1 @@
+export declare function dorm2r(side: number, trans: number, m: number, n: number, k: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number): number;

package/dist-lib/ts-lapack/src/SRC/dormhr.d.ts

@@ -0,0 +1 @@
+export declare function dormhr(side: number, trans: number, m: number, n: number, ilo: number, ihi: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-lib/ts-lapack/src/SRC/dormqr.d.ts

@@ -0,0 +1 @@
+export declare function dormqr(side: number, trans: number, m: number, n: number, k: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number, c: Float64Array, cOff: number, ldc: number, work: Float64Array, workOff: number, lwork: number): number;

package/dist-lib/ts-lapack/src/SRC/dpotf2.d.ts

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

package/dist-lib/ts-lapack/src/SRC/dtrevc3.d.ts

@@ -0,0 +1,27 @@
+/**
+ * DTREVC3 computes some or all of the right and/or left eigenvectors of
+ * a real upper quasi-triangular matrix T.
+ *
+ * @param side - LEFT (0), RIGHT (1), or BOTH (2)
+ * @param howmny - 0='A' all, 1='B' backtransform, 2='S' selected
+ * @param select - logical array, only used when howmny=2
+ * @param n - order of matrix T
+ * @param t - upper quasi-triangular matrix T, dimension (ldt, n)
+ * @param tOff - offset into t
+ * @param ldt - leading dimension of t
+ * @param vl - left eigenvector matrix, dimension (ldvl, mm)
+ * @param vlOff - offset into vl
+ * @param ldvl - leading dimension of vl
+ * @param vr - right eigenvector matrix, dimension (ldvr, mm)
+ * @param vrOff - offset into vr
+ * @param ldvr - leading dimension of vr
+ * @param mm - number of columns in VL/VR
+ * @param work - workspace array, dimension (max(1, lwork))
+ * @param workOff - offset into work
+ * @param lwork - dimension of work array
+ * @returns { m: number of eigenvectors computed, info: 0 on success }
+ */
+export declare function dtrevc3(side: number, howmny: number, select: boolean[], n: number, t: Float64Array, tOff: number, ldt: number, vl: Float64Array, vlOff: number, ldvl: number, vr: Float64Array, vrOff: number, ldvr: number, mm: number, work: Float64Array, workOff: number, lwork: number): {
+    m: number;
+    info: number;
+};

package/dist-lib/ts-lapack/src/SRC/dtrexc.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DTREXC reorders the real Schur factorization of a real matrix
+ * A = Q*T*Q**T, so that the diagonal block of T with row index IFST is
+ * moved to row ILST.
+ *
+ * @param compq - 0 ('N'): do not update Q; 1 ('V'): update Q
+ * @param n - order of the matrix T (>= 0)
+ * @param t - upper quasi-triangular matrix in Schur form, dimension (ldt, n)
+ * @param tOff - offset into t
+ * @param ldt - leading dimension of t
+ * @param q - Schur vectors, dimension (ldq, n), updated if compq=1
+ * @param qOff - offset into q
+ * @param ldq - leading dimension of q
+ * @param ifst - index of the first row of the block to move (1-based, in/out)
+ * @param ilst - target index for the block (1-based, in/out)
+ * @param work - workspace, dimension (n)
+ * @param workOff - offset into work
+ * @returns INFO: 0 = success, < 0 = illegal argument, 1 = swap failed
+ */
+export declare function dtrexc(compq: number, n: number, t: Float64Array, tOff: number, ldt: number, q: Float64Array, qOff: number, ldq: number, ifst: {
+    val: number;
+}, ilst: {
+    val: number;
+}, work: Float64Array, workOff: number): number;

package/dist-lib/ts-lapack/src/SRC/dtrti2.d.ts

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

package/dist-lib/ts-lapack/src/SRC/dtrtri.d.ts

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

package/dist-lib/ts-lapack/src/utils/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const NOTRANS = 0;
+export declare const TRANS = 1;
+export declare const CONJTRANS = 2;
+export declare const UPPER = 0;
+export declare const LOWER = 1;
+export declare const NONUNIT = 0;
+export declare const UNIT = 1;
+export declare const LEFT = 0;
+export declare const RIGHT = 1;
+export declare const MACH_EPS = 0;
+export declare const MACH_SFMIN = 1;
+export declare const MACH_BASE = 2;
+export declare const MACH_PREC = 3;
+export declare const MACH_T = 4;
+export declare const MACH_RND = 5;
+export declare const MACH_EMIN = 6;
+export declare const MACH_RMIN = 7;
+export declare const MACH_EMAX = 8;
+export declare const MACH_RMAX = 9;
+export declare const PIVOT_V = 0;
+export declare const PIVOT_T = 1;
+export declare const PIVOT_B = 2;
+export declare const DIRECT_F = 0;
+export declare const DIRECT_B = 1;
+export declare const SORT_INC = 0;
+export declare const SORT_DEC = 1;
+export declare const VECT_Q = 0;
+export declare const VECT_P = 1;

package/dist-lib/ts-lapack/src/utils/iladlc.d.ts

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

package/dist-lib/ts-lapack/src/utils/iladlr.d.ts

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

package/dist-lib/ts-lapack/src/utils/ilaenv.d.ts

@@ -0,0 +1 @@
+export declare function ilaenv(ispec: number, name: string, _opts: string, _n1: number, _n2: number, _n3: number, _n4: number): number;

package/dist-lib/ts-lapack/src/utils/xerbla.d.ts

@@ -0,0 +1 @@
+export declare function xerbla(srname: string, info: number): void;