HostLapack

A short backend identifier for diagnostics (e.g. "reference").

Above the reference (0) and the native dlopen backend (90).

Apply Q (or Qᵀ when transpose) from qr to y into out, which is returned. out may be y.

dpotrf above JVM_CHOLESKY_MIN, portable below it, with three adjustments to match the contract.

LAPACK factorizes in place and leaves the strict upper triangle exactly as the input had it, while koblas returns a factor whose upper triangle is zero, so it is cleared. LAPACK has no equivalent of CholeskyPolicy.Regularize: it reports the failing leading minor instead of clamping the pivot, so info > 0 falls back to the portable path, which is what applies the clamp or throws per the flag. And only the lower triangle of the input is read, matching what koblas promises its callers.

The threshold is where the measurement puts it, not at the LAPACK default: SIMD won 2.19x at n=256, tied at 1024, and lost 1.95x at 2048, so this gate opens late.

LU factorization with partial pivoting of a square a (LAPACK dgetrf); a is not modified. Allocates the factor buffers; factorInto refactorizes into existing ones.

dpotri above JVM_INVERT_SPD_MIN. It writes only the triangle it is given, where koblas returns the full symmetric inverse, so the result is mirrored; and it overwrites the factor with the inverse, so the factor is copied first rather than destroyed.

Symmetric indefinite factorization A = L·D·Lᵀ with Bunch–Kaufman partial pivoting (LAPACK dsytrf, lower). As with Blas.symv, only the lower triangle of a is read — the strictly upper triangle may hold anything — and a is not modified. Use this where the matrix is symmetric but not positive definite (KKT systems); for SPD matrices cholesky is cheaper.

QR factorization A = Q·R of an m×n a via Householder reflections (LAPACK dgeqrf); a is not modified and any shape is accepted. Rank deficiency is not detected — zero diagonal entries of R surface in solveLeastSquares as infinities/NaNs, following the triangular-solve convention.

Reciprocal condition number estimate 1 / (anorm · est(‖A⁻¹‖₁)) from a factorization (LAPACK dgecon). anorm is the 1-norm of the original, unfactored matrix (see norm1), which the caller computes before factoring. Returns 1.0 for the empty factorization and exactly 0.0 when lu is singular or anorm is zero.

This is an order-of-magnitude estimate, not an exact condition number: the estimator never exceeds the true ‖A⁻¹‖₁, so the returned value never understates the conditioning. It is the cheap signal a revised simplex uses to decide when to refactorize. The default implementation is a Hager-style 1-norm estimator over solveInto; backends may substitute a native estimator, so the exact value can differ between backends while agreeing in magnitude.

The estimator needs four vectors and runs several sweeps, so it is the allocation-heaviest routine here — which matters because a simplex calls it to decide when to refactorize. Passing a workspace reuses those buffers across calls and makes it allocation-free.

Delegated to ReferenceLinearAlgebra for the same reason as Blas.gemv: two triangular solves over the n² factor are O(n²) work on O(n²) data, so the per-call cost dominates. Measured at n 256 the portable path takes 25 us against 65-136 us through cblas_dtrsv. The blocked solve below keeps dtrsm, which amortizes the same cost across many right-hand sides.

Solve A · X = B (or Aᵀ · X = B when transpose) into out, which is returned. out may be b. The transposed direction stages a block before scattering its rows through the permutation, so pass a workspace to lend that n·nrhs buffer.

Solve A · X = B into out, which is returned. out may be b.

One dsytrs replay per right-hand side, over the contiguous column it occupies. Under row-major storage this was a single widened pass, because extracting a column meant a strided gather; here a column is already a contiguous run, so reusing the tuned vector solve costs nothing but re-reading the factor and keeps the pivot-block bookkeeping in one place instead of two.

Gated by JVM_LDL_SOLVE_MIN rather than by the LAPACK threshold, and disabled by it.

A vector solve is O(n^2) work over O(n^2) data, so it behaves like level 2 and not like the factorization it belongs to. Measured against SIMD it stayed inside the noise band at every size — 1.10x, 1.02x, 1.08x, 1.02x at n=16..128, and SIMD ahead 1.08x at 256 — so there is nothing to win. The gate exists so that is a value someone can change and re-measure, not a decision welded shut.

Gated by JVM_SOLVE_SPD_MIN, which shuts it: dpotrs lost to the SIMD kernels by 3x at n=256 and 12x at 2048. It is O(n^2) work over O(n^2) data, so there is nothing to amortize a call against.

Those numbers were taken under row-major storage, when a second cause compounded the first: LAPACKE transposed the matrix into a column-major temporary on every call. That cost is gone now that koblas stores what LAPACK wants, so the margin here is narrower than measured and the gate is a stale upper bound rather than a current answer; see the note above the constants below.