F64Context

The slots still running koblas's own portable implementation, in declaration order.

Whether factorBasis answers with a factorization that updates its factors in place. When false a replacement costs a factorization, so a caller pacing its own refactorizations has nothing left to pace.

Apply Q, or Qᵀ when transpose, from qr to a length-m y, into a fresh result (LAPACK dormqr restricted to a single column).

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

The backend installed in slot.

Cholesky factorization A = L·Lᵀ of a symmetric positive-definite a (dpotrf with uplo = 'L'). Reads only the lower triangle of a, so an upper-only matrix factors to silent nonsense.

LU factorization with partial pivoting of a square a (LAPACK dgetrf). a is not modified.

Factorize the square a into something solvable. A singular matrix comes back as a factorization reporting singular rather than as an exception, with a failedAt counting elimination steps rather than naming a column: the step that fails is the one with no acceptable pivot left, so there is no column of a to attribute it to.

Factor a simplex basis for column replacements.

Refactorize a into out's existing buffers, returning out. out must have a's dimension and its previous contents are discarded.

gemm with alpha = 1, beta = 0, into a fresh matrix. A.cols must equal B.rows.

C = alpha · op(A) · op(B) + beta · C (BLAS dgemm), with shapes op(A): m×k, op(B): k×n, C: m×n. beta == 0.0 overwrites c without reading it.

gemv with alpha = 1, beta = 0, into a fresh result.

y = alpha · op(A) · x + beta · y (BLAS dgemv), with op(A) being Aᵀ when transpose. beta == 0.0 overwrites y without reading it.

A · x, or Aᵀ · x when transpose, into a fresh result.

In-place y = alpha · op(A) · x + beta · y, where op(A) is Aᵀ when transpose. Per BLAS convention beta == 0.0 overwrites y without reading it, so it may arrive uninitialized.

A = A + alpha · x · yᵀ (BLAS dger), the dense form a backend can dispatch. The free ger accepts F64VectorView operands and takes a sparse fast path.

Invert an SPD matrix from its Cholesky factorization, returning A⁻¹ given chol (LAPACK dpotri).

Invert a general matrix from its LU factorization, returning A⁻¹ given P·A = L·U (LAPACK dgetri). Prefer solve to apply A⁻¹, which costs less and is more accurate.

Whether slot is filled by something other than koblas's own portable implementation.

Symmetric indefinite factorization A = L·D·Lᵀ with Bunch-Kaufman pivoting (LAPACK dsytrf, lower). Reads only the lower triangle of a, so an upper-only matrix factors to silent nonsense.

QR factorization A = Q·R of an m×n a via Householder reflections (LAPACK dgeqrf). a is not modified, any shape is accepted, and rank deficiency is not detected.

QR with column pivoting, A·P = Q·R (LAPACK dgeqp3), reporting F64PivotedQrDecomposition.rank as the count of leading diagonal entries with |R_kk| > tolerance · |R₀₀|. tolerance is a fraction of |R₀₀|; AUTOMATIC_RANK_TOLERANCE derives one from the shape, max(m, n) · ε, and a negative value is rejected.

Order-of-magnitude estimate of 1 / (anorm · est(‖A⁻¹‖₁)) (LAPACK dgecon), where anorm is the 1-norm of the unfactored matrix (see norm1). Returns 1.0 when n == 0 and 0.0 when singular.

Factor a, reusing compatible state from previous when this backend can. The returned factorization supersedes previous, which must not be solved after this call. Backends that cannot reuse it answer as factor would.

Throws unless every one of slots is filled by an accelerated backend.

Solve A · x = b for the Cholesky factorization chol (LAPACK dpotrs). b is not modified.

Solve A · X = B for all right-hand-side columns of b at once against a symmetric indefinite factorization (LAPACK dsytrs with nrhs).

Solve A · x = b for a symmetric indefinite factorization ldl (LAPACK dsytrs).

Solve A · X = B, or Aᵀ · X = B when transpose, for all right-hand-side columns of b at once (LAPACK dgetrs with nrhs).

Solve A · x = b, or Aᵀ · x = b when transpose, for the factorization lu (LAPACK dgetrs).

Least-squares solve from a pivoted factorization, with the column permutation undone. A rank-deficient factorization returns the basic solution, not the minimum-norm one: zero outside the pivoted rank.

Solve from a QR factorization. By default, finds the least-squares solution min ‖A·x − b‖₂ for a tall or square A; it requires full column rank and returns R⁻¹·(Qᵀb). With minimumNorm, finds the minimum-norm solution of a consistent wide system from qr(Aᵀ); it requires full row rank.

solveInto into a fresh vector.

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

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

solve into out, which is returned.

Solve A · X = B, or Aᵀ · X = B when transpose, into out, which is returned. out may be b, and a workspace lends the transposed direction's n·nrhs staging block.

Solve A · x = b, or Aᵀ · x = b when transpose, into out, which is returned. out may be b, and a workspace lends the transposed direction's staging buffer.

solve into out, which is returned. Its length is n by default and m with minimumNorm. A workspace lends the intermediate for applying Q or Qᵀ.

Solve A·x = b from f into out, Aᵀ·x = b when transpose. The work belongs to the factorization; this is here so the seam reads the same from the sparse side as com.eignex.koblas .dense.F64Decompositions.solveInto does from the dense one.

C = alpha · A · B + beta · C, or C = alpha · B · A + beta · C when right (BLAS dsymm). Only the lower triangle of a is read; beta == 0.0 overwrites c without reading it.

y = alpha · A · x + beta · y for a symmetric a (BLAS dsymv). Only the lower triangle is read, diagonal included; beta == 0.0 overwrites y without reading it.

A += alpha · x · xᵀ (BLAS dsyr), writing the triangles uplo selects. syrk is the rank-k form.

A += alpha · (x · yᵀ + y · xᵀ) (BLAS dsyr2), writing the triangles uplo selects.

C = alpha · (op(A) · op(B)ᵀ + op(B) · op(A)ᵀ) + beta · C (BLAS dsyr2k), where op transposes when transpose. Writes the triangles uplo selects.

C = alpha · A·Aᵀ + beta · C, or alpha · Aᵀ·A + beta · C when transpose (BLAS dsyrk). Uplo.FULL writes both triangles, unlike standard dsyrk; beta == 0.0 overwrites without reading.

B = alpha · op(T) · B, or B = alpha · B · op(T) when right (BLAS dtrmm), the counterpart of trsm.

x = op(T) · x in place (BLAS dtrmv), the product counterpart of trsv.

B = alpha · op(T)⁻¹ · B in place, or B = alpha · B · op(T)⁻¹ when right (BLAS dtrsm). Flags follow trsv; the right-hand sides are the columns of b from the left and its rows from the right.

Solve op(T) · x = b in place (BLAS dtrsv) for the lower or upper triangle of the square a, op transposing when transpose and unitDiag taking the diagonal as 1. x carries b in and x out.

Solve op(T) · x = b in place, op transposing when transpose. x holds the right-hand side on entry and the solution on return. Only the lower or upper triangle of a is read, and unitDiag takes the diagonal as 1 without reading it, as the dense com.eignex.koblas.dense.F64Blas.trsv does.

Invert a triangular matrix into a fresh result (LAPACK dtrtri), returning T⁻¹ for the lower or upper triangle of the square a, taking the diagonal as 1 when unitDiag.