kmath-core/space.kscience.kmath.linear

Package-level declarations

Types

BufferedLinearSpace

class BufferedLinearSpace<T, out A : Ring<T>>(bufferAlgebra: BufferAlgebra<T, A>) : LinearSpace<T, A>

CholeskyDecompositionFeature

interface CholeskyDecompositionFeature<out T : Any> : MatrixFeature

Matrices with this feature support Cholesky factorization: a = l · l^H where a is the owning matrix.

DeterminantFeature

interface DeterminantFeature<out T : Any> : MatrixFeature

Matrices with this feature can compute their determinant.

DiagonalFeature

interface DiagonalFeature : MatrixFeature

Matrices with this feature are considered to have only diagonal non-null elements.

DoubleLinearSpace

object DoubleLinearSpace : LinearSpace<Double, DoubleField>

InverseMatrixFeature

interface InverseMatrixFeature<out T : Any> : MatrixFeature

Matrices with this feature can be inverted: inverse = a⁻¹ where a is the owning matrix.

LFeature

object LFeature : MatrixFeature

Matrices with this feature are lower triangular ones.

LinearSolver

interface LinearSolver<T : Any>

A group of methods to solve for X in equation X = A⁻¹ · B, where A and B are matrices or vectors.

LinearSpace

interface LinearSpace<T, out A : Ring<T>>

Basic operations on matrices and vectors.

LUDecompositionFeature

interface LUDecompositionFeature<out T : Any> : MatrixFeature

Matrices with this feature support LU factorization: a = l · u where a is the owning matrix.

LupDecomposition

class LupDecomposition<T : Any>(val context: LinearSpace<T, *>, val elementContext: Field<T>, val lu: Matrix<T>, val pivot: IntArray, even: Boolean) : LupDecompositionFeature<T> , DeterminantFeature<T>

Common implementation of LupDecompositionFeature.

LupDecompositionFeature

interface LupDecompositionFeature<out T : Any> : MatrixFeature

Matrices with this feature support LU factorization with partial pivoting: p · a = l · u where a is the owning matrix.

Matrix

typealias Matrix<T> = Structure2D<T>

Alias for Structure2D with more familiar name.

MatrixBuilder

class MatrixBuilder<T : Any, out A : Ring<T>>(val linearSpace: LinearSpace<T, A>, val rows: Int, val columns: Int)

MatrixFeature

interface MatrixFeature : StructureFeature

A marker interface representing some properties of matrices or additional transformations of them. Features are used to optimize matrix operations performance in some cases or retrieve the APIs.

MatrixWrapper

class MatrixWrapper<out T : Any> : Structure2D<T>

A Matrix that holds MatrixFeature objects.

MutableMatrix

typealias MutableMatrix<T> = MutableStructure2D<T>

OrthogonalFeature

object OrthogonalFeature : MatrixFeature

Matrices with this feature are orthogonal ones: a · a^T = u where a is the owning matrix, u is the unit matrix (UnitFeature).

Point

typealias Point<T> = Buffer<T>

Alias or using Buffer as a point/vector in a many-dimensional space.

QRDecompositionFeature

interface QRDecompositionFeature<out T : Any> : MatrixFeature

Matrices with this feature support QR factorization: a = q · r where a is the owning matrix.

SingularValueDecompositionFeature

interface SingularValueDecompositionFeature<out T : Any> : MatrixFeature

Matrices with this feature support SVD: a = u · s · v^H where a is the owning matrix.

SymmetricMatrixFeature

object SymmetricMatrixFeature : MatrixFeature

TransposedFeature

class TransposedFeature<out T : Any>(val original: Matrix<T>) : MatrixFeature

UFeature

object UFeature : MatrixFeature

Matrices with this feature are upper triangular ones.

UnitFeature

object UnitFeature : DiagonalFeature

Matrices with this feature have unit elements on diagonal and zero elements in all other places.

VirtualMatrix

class VirtualMatrix<out T : Any>(val rowNum: Int, val colNum: Int, val generator: (i: Int, j: Int) -> T) : Structure2D<T>

The matrix where each element is evaluated each time when is being accessed.

ZeroFeature

object ZeroFeature : DiagonalFeature

Matrices with this feature have all zero elements.

Functions

asMatrix

fun <T : Any> Point<T>.asMatrix(): VirtualMatrix<T>

Creates an n × 1 VirtualMatrix, where n is the size of the given buffer.

asVector

fun <T : Any> Matrix<T>.asVector(): Point<T>

Convert matrix to vector if it is possible.

column

fun <T : Any> LinearSpace<T, Ring<T>>.column(vararg values: T): Matrix<T>

inline fun <T : Any> LinearSpace<T, Ring<T>>.column(size: Int, crossinline builder: (Int) -> T): Matrix<T>

computeFeature

@UnstableKMathAPI

inline fun <T : Any, F : StructureFeature> LinearSpace<T, *>.computeFeature(structure: Matrix<T>): F?

Get a feature of the structure in this scope. Structure features take precedence other context features.

DeterminantFeature

fun <T : Any> DeterminantFeature(determinant: T): DeterminantFeature<T>

Produces a DeterminantFeature where the DeterminantFeature.determinant is determinant.

invoke

inline operator fun <LS : LinearSpace<*, *>, R> LS.invoke(block: LS.() -> R): R

lup

inline fun <T : Comparable<T>> LinearSpace<T, Field<T>>.lup(matrix: Matrix<T>, noinline checkSingular: (T) -> Boolean): LupDecomposition<T>

fun LinearSpace<Double, DoubleField>.lup(matrix: Matrix<Double>, singularityThreshold: Double = 1.0E-11): LupDecomposition<Double>

fun <T : Comparable<T>> LinearSpace<T, Field<T>>.lup(factory: MutableBufferFactory<T>, matrix: Matrix<T>, checkSingular: (T) -> Boolean): LupDecomposition<T>

Create a lup decomposition of generic matrix.

lupSolver

fun LinearSpace<Double, DoubleField>.lupSolver(singularityThreshold: Double = 1.0E-11): LinearSolver<Double>

fun <T : Comparable<T>, F : Field<T>> LinearSpace<T, F>.lupSolver(bufferFactory: MutableBufferFactory<T>, singularityCheck: (T) -> Boolean): LinearSolver<T>

Produce a generic solver based on LUP decomposition

matrix

@UnstableKMathAPI

fun <T : Any, A : Ring<T>> LinearSpace<T, A>.matrix(rows: Int, columns: Int): MatrixBuilder<T, A>

Create a matrix builder with given number of rows and columns

one

fun <T : Any> LinearSpace<T, Ring<T>>.one(rows: Int, columns: Int): Matrix<T>

Diagonal matrix of ones. The matrix is virtual no actual matrix is created.

plus

operator fun <T : Any> Matrix<T>.~~plus~~(newFeature: MatrixFeature): MatrixWrapper<T>

row

fun <T : Any> LinearSpace<T, Ring<T>>.row(vararg values: T): Matrix<T>

inline fun <T : Any> LinearSpace<T, Ring<T>>.row(size: Int, crossinline builder: (Int) -> T): Matrix<T>

symmetric

fun <T : Any, A : Ring<T>> MatrixBuilder<T, A>.symmetric(builder: (i: Int, j: Int) -> T): Matrix<T>

Naive implementation of a symmetric matrix builder, that adds a SymmetricMatrixFeature tag. The resulting matrix contains full size^2 number of elements, but caches elements during calls to save builder calls. builder is always called in the upper triangle region meaning that i <= j

transpose