koblas

F64Decompositions

Dense factorizations as a backend half.

Inheritors

Properties

kernels

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

Link copied to clipboard

Whether this backend can do work on this host. koblas's own implementations always can, so the default is true; a binding reports whether the library it calls resolved.

Link copied to clipboard

Whether this is koblas's own implementation rather than a binding to a host library. The compiled-in SIMD kernels are portable however fast they are; only something calling out counts as accelerated.

Link copied to clipboard
abstract val name: String

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

Link copied to clipboard
open val priority: Int

Relative preference among the backends offered for one half (F64Blas, F64Decompositions, F64Kernels or a sparse counterpart). registerBackend picks the highest; the portable reference is 0.

Functions

applyQ

open fun applyQ(qr: F64QrDecomposition, y: DoubleArray, transpose: Boolean = false): DoubleArray(source)

Apply Q, or Qᵀ when transpose, from qr to a length-m y, into a fresh result (LAPACK dormqr restricted to a single column).

applyQInto

abstract fun applyQInto(qr: F64QrDecomposition, y: DoubleArray, out: DoubleArray, transpose: Boolean = false): DoubleArray(source)

Apply Q, or Qᵀ when transpose, from qr to y into out, which is returned. out may be y.

cholesky

abstract fun cholesky(a: F64DenseMatrix, policy: CholeskyPolicy = CholeskyPolicy.Strict): F64CholeskyDecomposition(source)

Cholesky factorization A = L·Lᵀ of a symmetric positive-definite a (dpotrf with uplo = 'L'). Reads only the lower triangle of a, so an upper-only matrix factors to silent nonsense.

Throws

at the first non-positive pivot unless policy allows it.

factor

LU factorization with partial pivoting of a square a (LAPACK dgetrf). a is not modified.

factorInto

Refactorize a into out's existing buffers, returning out. out must have a's dimension and its previous contents are discarded.

invert

abstract fun invert(lu: F64LuDecomposition, workspace: Workspace? = null): F64DenseMatrix(source)

Invert a general matrix from its LU factorization, returning A⁻¹ given P·A = L·U (LAPACK dgetri). Prefer solve to apply A⁻¹, which costs less and is more accurate.

Throws


abstract fun invert(chol: F64CholeskyDecomposition, workspace: Workspace? = null): F64DenseMatrix(source)

Invert an SPD matrix from its Cholesky factorization, returning A⁻¹ given chol (LAPACK dpotri).

ldl

abstract fun ldl(a: F64DenseMatrix, workspace: Workspace? = null): F64LdlDecomposition(source)

Symmetric indefinite factorization A = L·D·Lᵀ with Bunch-Kaufman pivoting (LAPACK dsytrf, lower). Reads only the lower triangle of a, so an upper-only matrix factors to silent nonsense.

qr

abstract fun qr(a: F64DenseMatrix, workspace: Workspace? = null): F64QrDecomposition(source)

QR factorization A = Q·R of an m×n a via Householder reflections (LAPACK dgeqrf). a is not modified, any shape is accepted, and rank deficiency is not detected.

qrPivoted

abstract fun qrPivoted(a: F64DenseMatrix, tolerance: Double = AUTOMATIC_RANK_TOLERANCE, workspace: Workspace? = null): F64PivotedQrDecomposition(source)

QR with column pivoting, A·P = Q·R (LAPACK dgeqp3), reporting F64PivotedQrDecomposition.rank as the count of leading diagonal entries with |R_kk| > tolerance · |R₀₀|. tolerance is a fraction of |R₀₀|; AUTOMATIC_RANK_TOLERANCE derives one from the shape, max(m, n) · ε, and a negative value is rejected.

Throws

rcond

abstract fun rcond(lu: F64LuDecomposition, anorm: Double, workspace: Workspace? = null): Double(source)

Order-of-magnitude estimate of 1 / (anorm · est(‖A⁻¹‖₁)) (LAPACK dgecon), where anorm is the 1-norm of the unfactored matrix (see norm1). Returns 1.0 when n == 0 and 0.0 when singular.

solve

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

Solve A · x = b, or Aᵀ · x = b when transpose, for the factorization lu (LAPACK dgetrs).


open fun solve(lu: F64LuDecomposition, b: F64DenseMatrix, transpose: Boolean = false): F64DenseMatrix(source)

Solve A · X = B, or Aᵀ · X = B when transpose, for all right-hand-side columns of b at once (LAPACK dgetrs with nrhs).


Solve A · x = b for a symmetric indefinite factorization ldl (LAPACK dsytrs).


Solve A · X = B for all right-hand-side columns of b at once against a symmetric indefinite factorization (LAPACK dsytrs with nrhs).


open fun solve(qr: F64PivotedQrDecomposition, b: DoubleArray, workspace: Workspace? = null): DoubleArray(source)

Least-squares solve from a pivoted factorization, with the column permutation undone. A rank-deficient factorization returns the basic solution, not the minimum-norm one: zero outside the pivoted rank.


open fun solve(qr: F64QrDecomposition, b: DoubleArray, minimumNorm: Boolean = false, workspace: Workspace? = null): DoubleArray(source)

Solve from a QR factorization. By default, finds the least-squares solution min ‖A·x − b‖₂ for a tall or square A; it requires full column rank and returns R⁻¹·(Qᵀb). With minimumNorm, finds the minimum-norm solution of a consistent wide system from qr(Aᵀ); it requires full row rank.


Solve A · x = b for the Cholesky factorization chol (LAPACK dpotrs). b is not modified.

solveInto

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

Solve A · x = b, or Aᵀ · x = b when transpose, into out, which is returned. out may be b, and a workspace lends the transposed direction's staging buffer.


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

Solve A · X = B, or Aᵀ · X = B when transpose, into out, which is returned. out may be b, and a workspace lends the transposed direction's n·nrhs staging block.


Solve A · x = b into out, which is returned. out may be b.


abstract fun solveInto(ldl: F64LdlDecomposition, b: F64DenseMatrix, out: F64DenseMatrix, workspace: Workspace? = null): F64DenseMatrix(source)

Solve A · X = B into out, which is returned. out may be b.


abstract fun solveInto(qr: F64PivotedQrDecomposition, b: DoubleArray, out: DoubleArray, workspace: Workspace? = null): DoubleArray(source)

solve into out, which is returned.


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

solve into out, which is returned. Its length is n by default and m with minimumNorm. A workspace lends the intermediate for applying Q or Qᵀ.

trtri

abstract fun trtri(a: F64DenseMatrix, lower: Boolean, unitDiag: Boolean = false): F64DenseMatrix(source)

Invert a triangular matrix into a fresh result (LAPACK dtrtri), returning T⁻¹ for the lower or upper triangle of the square a, taking the diagonal as 1 when unitDiag.

Throws

naming the first zero diagonal position.