Top-level

What every backend reports about itself.

Double-precision F64DenseMatrix, the dense matrix an unqualified DenseMatrix means.

Double-precision F64DenseVector, the dense vector an unqualified DenseVector means.

Operands whose shapes do not fit the routine.

Every backend koblas will use for a piece of work, in one object you can hold. Immutable, and itself a F64LinearAlgebra and a F64SparseLinearAlgebra by delegation.

Double-precision F64Givens, the rotation an unqualified Givens means.

The double-precision F64Context, the context an unqualified KoblasContext means.

What koblas throws when a routine cannot do what was asked. Every one is an IllegalArgumentException.

Double-precision F64MatrixLike, the matrix contract an unqualified MatrixLike means.

Double-precision F64MatrixView, the sealed matrix storage an unqualified MatrixView means.

A Cholesky or a strict L·D·Lᵀ met a pivot that was zero, negative or NaN.

A factorization met an exactly zero pivot, so the matrix it came from has no inverse.

Double-precision F64SparseMatrix, the CSC matrix an unqualified SparseMatrix means.

Double-precision F64SparseVector, the sparse vector an unqualified SparseVector means.

Marks direct access to live structural or factorization storage. Mutating these buffers can invalidate later operations; access is intended for backend interoperability and specialized kernels.

Double-precision F64VectorLike, the vector contract an unqualified VectorLike means.

Double-precision F64VectorView, the sealed vector storage an unqualified VectorView means.

Reusable scratch buffers, pooled by width. Every borrow outstanding at the same time gets a different buffer, so nesting is safe. Not thread-safe, deliberately: sharing one across threads corrupts results.

The priority every host binding koblas ships registers at. A third-party backend is unprobed, and an ILP64 OpenBLAS exports identical symbols while computing wrong answers, caught by reading openblas_get_config.

The process-wide default context: an installBackends override when set, else registered backends, else the portable reference implementations. Every free function in koblas uses this.

What this runtime resolved, for startup logging (e.g. "backend=openblas, kernels=simd(8 lanes)").

Short identifier for the vector kernels the current process resolved, as named by F64PlatformKernels: "scalar", "simd(8 lanes)", or a "+openblas" suffix for a host backend.

The failedAt value of a factorization that succeeded, dense or sparse.

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

A failedAt meaning "singular, but this backend cannot say where". Exists so a host solver like UMFPACK, which counts zero pivots without locating them, need not invent a position or report NOT_SINGULAR.

Sum of absolute values (BLAS dasum). Sparse vectors sum over stored entries only.

y = y + alpha * x. A sparse x touches only the positions it stores.

The backend installed in slot.

Borrows a vector of size for block, allocating one when there is no workspace to lend it.

Column j as a fresh vector, copied rather than viewed.

dst = src (BLAS dcopy). A sparse source zero-fills the destination first, so nothing survives.

Runs automatic platform discovery once, registering whatever host backends are available.

aT * b. Any sparse operand goes through F64SparseKernels, walking the stored entries only.

Visit each stored entry as (index, value), in ascending index order for any storage. A F64SparseVector may present numerical zeros as stored, and any other F64VectorLike has every index visited.

Rank-one update A = A + alpha * x * yT (BLAS dger) in place. Subtract by passing alpha = -1.0.

Index of the entry with maximal absolute value (BLAS idamax), -1 for a zero-length vector. Ties resolve to the lowest index, and a vector with no stored entries returns 0.

Overrides the context koblas returns; null restores automatic selection.

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

Translates a LAPACK info return into a failedAt position. A positive info is the 1-based pivot index; a negative one is an illegal-argument report and maps to NOT_SINGULAR.

A - B, allocating. axpy with alpha = -1.0 accumulates into an existing operand.

a - b, allocating. axpy with alpha = -1.0 accumulates into an existing operand.

Matrix 1-norm, the maximum absolute column sum (LAPACK dlange with norm 1). This is the anorm rcond expects, computed before the matrix is factored.

Euclidean norm (BLAS dnrm2). Rescales when the sum of squares would overflow or underflow, so any finite input gives the correct norm.

Frobenius norm (LAPACK dlange with norm F). Rescales like norm2 against overflow and underflow.

Matrix infinity-norm, the maximum absolute row sum (LAPACK dlange with norm I).

A + B, allocating. axpy accumulates into an existing operand.

a + b, allocating. axpy accumulates into an existing operand.

Offers backend as an explicit choice for every half it implements. Explicit registrations outrank automatically discovered ones; among explicit registrations, Backend.priority selects the winner.

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

Apply a plane rotation (BLAS drot). Each pair (x_i, y_i) becomes (c*x_i + s*y_i, c*y_i - s*x_i), so both x and y are overwritten in place.

Generate the plane rotation that zeroes b against a (BLAS drotg), rescaling so squares that would overflow or vanish still rotate correctly. Netlib sign convention; the all-zero pair gives the identity.

Row i as a fresh vector, gathered across the backing. Prefer column where the algorithm allows.

v = alpha * v.

Scale column j by d(j) in place, the product A * D for the diagonal D with entries d(j).

Scale column j by d(j) in place for a CSC matrix. The pattern is untouched.

Scale row i by d(i) in place, the product D * A for the diagonal D with entries d(i).

Exchange the contents of a and b (BLAS dswap).

Symmetric rank-1 update A += alpha * x * xT (BLAS dsyr) in place. See F64Blas.syr.

Symmetric rank-2 update A += alpha * (x * yT + y * xT) (BLAS dsyr2) in place. See F64Blas.syr2.

A * B (BLAS dgemm), allocating. gemm accumulates into an existing C instead.

alpha * A, allocating. scale multiplies in place.

alpha * x, allocating. scale multiplies in place.

Matrix-vector product into a fresh dense result for any F64MatrixLike against any F64VectorLike. gemv provide transpose and destination-buffer variants.

Fresh transposed matrix. For products, prefer the transpose flags on gemv and gemm, which read the original storage without copying.

Fresh transposed matrix, still CSC, which makes this the CSC-to-CSR conversion as well. Explicitly stored zeros survive.

-A, allocating.

-x, allocating.

Fresh matrix with column column replaced by entering, still CSC. The replacement is structural, so an explicitly stored zero in entering survives as one.