com.eignex.koblas/dense/host/jvm/F64Cblas

F64Cblas

The host OpenBLAS through CBLAS, bound with java.lang.foreign. Every routine lives in F64BlasAdapter; this supplies the JVM's entry points and the backend's identity.

Constructors

F64Cblas

constructor(config: HostBlasConfig = HostBlasConfig())(source)

Properties

isAvailable

open override val isAvailable: Boolean(source)

The BLAS half needs only CBLAS, which a host can provide without LAPACKE.

name

open override val name: String(source)

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

priority

open override val priority: Int(source)

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

isPortable

open override val isPortable: Boolean

A binding that calls out, whatever the portable instance it falls back to reports.

kernels

open val kernels: F64Kernels

The vector kernels this half's inherited routines run on; the installed ones by default.

Functions

gemm

open fun gemm(a: F64DenseMatrix, b: F64DenseMatrix): F64DenseMatrix

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

open override fun gemm(alpha: Double, a: F64DenseMatrix, transposeA: Boolean, b: F64DenseMatrix, transposeB: Boolean, beta: Double, c: F64DenseMatrix)

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

open fun gemv(a: F64DenseMatrix, x: DoubleArray, transpose: Boolean = false): DoubleArray

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

open override fun gemv(alpha: Double, a: F64DenseMatrix, x: DoubleArray, beta: Double, y: DoubleArray, transpose: Boolean = false)

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

ger

open override fun ger(alpha: Double, x: DoubleArray, y: DoubleArray, a: F64DenseMatrix)

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.

symm

open override fun symm(alpha: Double, a: F64DenseMatrix, b: F64DenseMatrix, beta: Double, c: F64DenseMatrix, lower: Boolean = true, right: Boolean = false)

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.

symv

open override fun symv(alpha: Double, a: F64DenseMatrix, x: DoubleArray, beta: Double, y: DoubleArray, lower: Boolean = true)

The shape is checked ahead of the gate: dsymv takes one dimension and a leading dimension, so a non-square matrix would have it read n² entries from a shorter array, past the end of the buffer.

syr

open override fun syr(alpha: Double, x: F64VectorLike, a: F64DenseMatrix, uplo: Uplo = Uplo.FULL)

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

syr2

open override fun syr2(alpha: Double, x: F64VectorLike, y: F64VectorLike, a: F64DenseMatrix, uplo: Uplo = Uplo.FULL)

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

syr2k

open override fun syr2k(alpha: Double, a: F64DenseMatrix, b: F64DenseMatrix, transpose: Boolean, beta: Double, c: F64DenseMatrix, uplo: Uplo = Uplo.FULL, workspace: Workspace? = null)

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

syrk

open override fun syrk(alpha: Double, a: F64DenseMatrix, transpose: Boolean, beta: Double, c: F64DenseMatrix, uplo: Uplo = Uplo.FULL, workspace: Workspace? = null)

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.

trmm

open override fun trmm(a: F64DenseMatrix, b: F64DenseMatrix, lower: Boolean, transpose: Boolean = false, unitDiag: Boolean = false, right: Boolean = false, alpha: Double = 1.0)

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

trmv

open override fun trmv(a: F64DenseMatrix, x: DoubleArray, lower: Boolean, transpose: Boolean = false, unitDiag: Boolean = false)

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

trsm

open override fun trsm(a: F64DenseMatrix, b: F64DenseMatrix, lower: Boolean, transpose: Boolean = false, unitDiag: Boolean = false, right: Boolean = false, alpha: Double = 1.0)

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.

trsv

open override fun trsv(a: F64DenseMatrix, x: DoubleArray, lower: Boolean, transpose: Boolean = false, unitDiag: Boolean = false)

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.