Top-level

A dense vector that owns its whole buffer, so its entries are exactly values, in order and complete.

Mutable column-major storage with unit row stride, shared by DenseMatrix and DenseMatrixView. Entry A(i, j) is at offset + i + j * leadingDimension in values.

A borrowed rectangle of a DoubleArray, with explicit offset and leadingDimension. No entries are copied or owned. The backing buffer can also be mutated by its owner or other views. Unlike DenseMatrix, values need not have exactly rows * cols entries. Views use reference equality.

A vector that stores every one of its entries, addressed as a buffer, an origin and a step.

Operands whose shapes do not fit the routine.

Immutable dense and sparse BLAS with portable fallbacks.

Read-only matrix contract. Anything that only reads a matrix should take this.

The matrix storages koblas itself defines, DenseMatrix and SparseMatrix.

How a call reached its result.

Compressed-sparse-column form: column j occupies colPointers(j) until colPointers(j + 1) of rowIndices and values, rows strictly ascending. A stored zero is preserved, and a 64-bit-index host library needs a widening copy.

Indices are strictly ascending and in range, validated by the constructor; of sorts and sums instead.

A mutable live window of size entries in values, starting at offset and separated by stride.

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.

Read-only vector contract. Anything that only reads a vector should take this.

The vector storages koblas defines and serializes, ContiguousVector and SparseVector.

Reusable scratch for alias-safe matrix operations.

The immutable platform-selected BLAS engine used by top-level convenience operations.

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

A borrowed view over this whole vector, keeping whatever origin and spacing it already has.

y = y + alpha * x. A sparse x touches only the positions it stores. A dense x with an identical mapping is read directly; other dense overlaps, or sparse values sharing the destination buffer, are snapshotted before writing. Custom Vector implementations are also snapshotted, since their backing storage is opaque.

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

Index counterpart of borrow.

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

Column j as a fresh sparse vector. Runs in O(nnzⱼ) time and allocates copies of its stored indices and values, so later mutations to the returned vector's indices or values cannot affect this matrix. Explicitly stored zeros are preserved.

dst = src (BLAS dcopy). A sparse source zero-fills the destination first, so nothing survives. Identical dense mappings are a no-op. Overlapping dense slices with unit stride use an overlap-safe block move. Other overlapping sources are snapshotted before writing. Custom Vector implementations are also snapshotted, since their backing storage is opaque.

aT * b. Sparse operands walk their stored entries only.

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

Read from at x's stored positions into x (Sparse BLAS usga), the inverse of copy from a sparse source. x keeps its pattern, so a nonzero of from at an unstored position is not read.

gather, and zero in from the positions it read (Sparse BLAS usgz).

Zero-based logical index of the maximum absolute value (BLAS idamax), or -1 when empty. Dense vectors use DenseVectorKernels.iamax; sparse vectors visit only their stored entries. All-zero nonempty inputs return 0, as do sparse inputs whose maximum is an implicit zero. Strided views report their logical index rather than a backing-array offset.

Makes the stored entries match what structure promises, in place.

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.

A - B, allocating an owned CSC structural union.

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

Whether these vectors address at least one common buffer entry.

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

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

A + B, allocating an owned CSC structural union.

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. Dense vectors use the same overlap semantics as the borrowed overload.

rot over borrowed strided storage. Negative strides are supported. If the views overlap, both logical input sequences are snapshotted before writing; at a shared physical entry the final write is from y.

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

Row i as a fresh sparse vector whose stored positions are the source columns. Runs in O(nnz) time, scanning every stored entry in the matrix to gather the ones in this row, and allocates arrays sized to its stored entries. The returned vector is independent of this matrix, and explicitly stored zeros are preserved.

v = alpha * v.

Plain sum of the entries. Distinct from asum, which sums their absolute values.

Exchange the contents of a and b (BLAS dswap), including rows and columns of a dense matrix.

Fresh CSC matrix holding A + alpha * x * xT in its lower or upper triangle. The other triangle is copied unchanged. Unlike dense com.eignex.koblas.dense.DenseBlas.syr, this is not in place: a rank update can introduce entries that the source CSC pattern has no room to store.

Fresh CSC matrix holding A + alpha * (x * yT + y * xT) in its lower or upper triangle. The other triangle is copied unchanged. This structural counterpart of dense com.eignex.koblas.dense.DenseBlas.syr2 never mutates its source, because newly nonzero entries may require CSC fill.

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

Matrix-vector product into a fresh dense result.

A * B for a dense left operand and sparse right operand, allocating dense storage.

alpha * A, allocating. scale multiplies in place.

alpha * x, allocating. scale multiplies in place.

Allocating product through koblas: two sparse operands give CSC storage, any other pairing dense.

A * B for a sparse left operand and dense right operand, allocating dense storage.

A * B for two sparse matrices, allocating the discovered CSC structure.

Fresh transposed matrix, with the active backend (koblas). For products, prefer the transpose flags on gemv and gemm, which read the original storage without copying. See DenseBlas.transpose.

Fresh transposed matrix, still CSC, which makes this the CSC-to-CSR conversion as well. Explicitly stored zeros survive, since the transpose is structural rather than arithmetic.

-A, allocating.

-x, allocating.

A borrowed strided slice, addressed in this vector's logical indices rather than its buffer's positions.

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