com.eignex.koblas/core/F64SparseMatrix

F64SparseMatrix

@Serializable

@SerialName(value = "F64SparseMatrix")

class F64SparseMatrix : F64MatrixView(source)

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

Types

Companion

object Companion

Factories for sparse matrices.

Properties

colPtr

val colPtr: IntArray(source)

cols

open override val cols: Int(source)

nnz

val nnz: Int(source)

Number of stored nonzeros.

rowIdx

val rowIdx: IntArray(source)

rows

open override val rows: Int(source)

values

val values: DoubleArray(source)

Functions

copyColumnPointers

fun copyColumnPointers(): IntArray(source)

A copy of the CSC column start offsets, of length cols + 1.

copyRowIndices

fun copyRowIndices(): IntArray(source)

A copy of the stored row indices, parallel to values.

equals

open operator override fun equals(other: Any?): Boolean(source)

Structural equality over the shape and the CSC arrays, so two matrices differing only in which explicit zeros they store are not equal.

forEachInColumn

inline fun forEachInColumn(j: Int, action: (row: Int, value: Double) -> Unit)(source)

Visits the stored entries of column j as (row, value), rows ascending.

get

open operator override fun get(i: Int, j: Int): Double(source)

Reads entry (i, j), or 0.0 where nothing is stored. A binary search over the column, so O(log nnzⱼ) and fine for a probe; sweep with forEachInColumn instead.

hashCode

open override fun hashCode(): Int(source)

toArray

open override fun toArray(): Array<DoubleArray>(source)

Materialises into a fresh rows × cols array of rows; unstored entries stay zero.

toString

open override fun toString(): String(source)

gemv

fun F64SparseMatrix.gemv(x: DoubleArray, transpose: Boolean = false): DoubleArray

this · x, or thisᵀ · x when transpose, with the active backend (koblas).

fun F64SparseMatrix.lu(equilibrate: Boolean = false, dropTolerance: Double = NO_DROP): F64SparseFactorization

Factorize this sparse matrix with the active backend (koblas), the counterpart of F64DenseMatrix.lu.

scaleColumns

fun F64SparseMatrix.scaleColumns(d: DoubleArray)

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

times

operator fun F64MatrixLike.times(x: F64VectorLike): F64DenseVector

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

transpose

fun F64SparseMatrix.transpose(): F64SparseMatrix

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

trsv

fun F64SparseMatrix.trsv(x: DoubleArray, lower: Boolean, transpose: Boolean = false, unitDiag: Boolean = false)

Solve op(T) · x = b in place against this matrix's lower or upper triangle, with the active backend (koblas). See F64SparseBlas.trsv.

withColumn

fun F64SparseMatrix.withColumn(column: Int, entering: F64SparseVector): F64SparseMatrix

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