koblas
com.eignex.koblas/sparse/SparseFactorization

SparseFactorization

interface SparseFactorization(source)

A factored sparse matrix you can solve against, whoever produced it.

An interface rather than a class, and that is the whole point. The dense side passes a com.eignex.koblas.dense.LuDecomposition between backends because LAPACK's packed formats are a standard: a factorization from OpenBLAS solves on the reference and back again.

Sparse has no such format. UMFPACK hands back a void **Numeric, KLU a klu_numeric *, CHOLMOD a cholmod_factor * — every host solver keeps its factors in a private structure it will not describe, each bound to the library that made it. A seam demanding a concrete SparseLu could therefore never admit one.

So SparseLapack.factor returns this, SparseLu is the portable implementation, and a host backend would add another holding its own handle. It also keeps SparseLu's internal arrays out of the public seam, which they had no business being part of.

See also

the dense counterpart, a class precisely because its format is shared.

Inheritors

UmfpackFactorization

Properties

failedAt

abstract val failedAt: Int(source)

The pivot position that had no numerically acceptable candidate, or NOT_SINGULAR when the factorization succeeded.

The same convention com.eignex.koblas.dense.LuDecomposition reports, and the position is the actionable half: a simplex whose basis went singular can use it to choose which column to replace.

n

abstract val n: Int(source)

The dimension of the factored matrix.

nnz

abstract val nnz: Int(source)

Nonzeros in the factors — the fill. Zero for a singular factorization, which has none.

singular

open val singular: Boolean(source)

Whether the factorization failed for want of a numerically acceptable pivot. Derived from failedAt, so the two cannot disagree.

Solving against a singular factorization is not meaningful, matching the dense contract. Unlike the dense case it throws rather than returning nonsense: a dense getrf completes and leaves partial factors behind, so garbage is what LAPACK itself would produce, whereas Markowitz pivoting aborts with nothing to solve with. Returning silence would be a lie about having factors.

Functions

determinant

abstract fun determinant(): Double(source)

det(B), or exactly 0.0 when singular. The counterpart of LuDecomposition.determinant.

solve

open fun solve(b: DoubleArray, transpose: Boolean = false): DoubleArray(source)

Solve B x = b, or Bᵀ x = b when transpose, into a fresh result.

solveInto

abstract fun solveInto(b: DoubleArray, out: DoubleArray, transpose: Boolean = false, workspace: Workspace? = null): DoubleArray(source)

Solve B x = b, or Bᵀ x = b when transpose, into out, which is returned.

The two directions are a simplex's FTRAN and BTRAN. Allocates nothing when given a workspace, so an iteration that owns its destination runs without touching the collector. out may be b.