kone.linearAlgebra/dev.lounres.kone.linearAlgebra/SettableMatrix

SettableMatrix

@Serializable(with = SettableMatrixSerializer::class)

class SettableMatrix<N>(val coefficients: SettableMDList2<N>) : Matrix<N> (source)

Constructors

SettableMatrix

constructor(coefficients: SettableMDList2<N>)

Properties

coefficients

open override val coefficients: SettableMDList2<N>

columnIndices

val Matrix<*>.columnIndices: UIntRange

columnNumber

val columnNumber: UInt

det

val <Number> Matrix<Number>.det: <Error class: unknown class>

determinantViaGaussianElimination

val <Number> Matrix<Number>.determinantViaGaussianElimination: Number

determinantViaLeibnizFormula

val <Number> Matrix<Number>.determinantViaLeibnizFormula: Number

isAntisymmetric

val <Number> Matrix<Number>.isAntisymmetric: Boolean

val <N> Matrix<N>.isAntisymmetric: Boolean

isDiagonal

val <Number> Matrix<Number>.isDiagonal: Boolean

isScalar

val <Number> Matrix<Number>.isScalar: Boolean

isSymmetric

val <Number> Matrix<Number>.isSymmetric: Boolean

val <N> Matrix<N>.isSymmetric: Boolean

rowIndices

val Matrix<*>.rowIndices: UIntRange

rowNumber

val rowNumber: UInt

transpose

val <N, A : Ring<N>> Matrix<N>.transpose: Matrix<N>

Functions

adjugateViaGaussianElimination

fun <Number> Matrix<Number>.adjugateViaGaussianElimination(): Matrix<Number>

adjugateViaLeibnizFormula

fun <Number> Matrix<Number>.adjugateViaLeibnizFormula(): Matrix<Number>

all

inline fun <E> Matrix<E>.all(block: (value: E) -> Boolean): Boolean

allIndexed

inline fun <E> Matrix<E>.allIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Boolean): Boolean

any

inline fun <E> Matrix<E>.any(block: (value: E) -> Boolean): Boolean

anyIndexed

inline fun <E> Matrix<E>.anyIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Boolean): Boolean

firstCofactorViaGaussianElimination

fun <Number> Matrix<Number>.firstCofactorViaGaussianElimination(rowIndex: UInt, columnIndex: UInt): Number

firstCofactorViaLeibnizFormula

fun <Number> Matrix<Number>.firstCofactorViaLeibnizFormula(rowIndex: UInt, columnIndex: UInt): Number

firstMinorViaGaussianElimination

fun <Number> Matrix<Number>.firstMinorViaGaussianElimination(rowIndex: UInt, columnIndex: UInt): Number

firstMinorViaLeibnizFormula

fun <Number> Matrix<Number>.firstMinorViaLeibnizFormula(rowIndex: UInt, columnIndex: UInt): Number

fold

inline fun <E, R> Matrix<E>.fold(initial: R, operation: (acc: R, E) -> R): R

foldIndexed

inline fun <E, R> Matrix<E>.foldIndexed(initial: R, operation: (rowIndex: UInt, columnIndex: UInt, acc: R, E) -> R): R

forEach

inline fun <E> Matrix<E>.forEach(block: (value: E) -> Unit)

forEachIndexed

inline fun <E> Matrix<E>.forEachIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Unit)

get

operator fun get(rowIndex: UInt, columnIndex: UInt): N

map

inline fun <E, R> Matrix<E>.map(transform: (E) -> R): Matrix<R>

mapIndexed

inline fun <E, R> Matrix<E>.mapIndexed(transform: (rowIndex: UInt, columnIndex: UInt, E) -> R): Matrix<R>

minorViaGaussianElimination

fun <Number> Matrix<Number>.minorViaGaussianElimination(rowIndices: KoneUIntArray, columnIndices: KoneUIntArray): Number

minorViaLeibnizFormula

fun <Number> Matrix<Number>.minorViaLeibnizFormula(rowIndices: KoneUIntArray, columnIndices: KoneUIntArray): Number

minus

operator fun <N> Matrix<N>.minus(other: Matrix<N>): Matrix<N>

none

inline fun <E> Matrix<E>.none(block: (value: E) -> Boolean): Boolean

noneIndexed

inline fun <E> Matrix<E>.noneIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Boolean): Boolean

plus

operator fun <N> Matrix<N>.plus(other: Matrix<N>): Matrix<N>

set

operator fun set(rowIndex: UInt, columnIndex: UInt, coefficient: N)

sum

fun <E> Matrix<E>.sum(): E

sumOf

inline fun <E, A> Matrix<E>.sumOf(selector: (E) -> A): A

sumOfIndexed

inline fun <E, A> Matrix<E>.sumOfIndexed(selector: (rowIndex: UInt, columnIndex: UInt, E) -> A): A

times

operator fun <N> Matrix<N>.times(other: N): Matrix<N>

operator fun <N> Matrix<N>.times(other: ColumnVector<N>): ColumnVector<N>

operator fun <N> Matrix<N>.times(other: Matrix<N>): Matrix<N>

toString

open override fun toString(): String

transpose

fun <Number> Matrix<Number>.transpose(): Matrix<Number>

unaryMinus

operator fun <N> Matrix<N>.unaryMinus(): Matrix<N>

withEach

inline fun <E> Matrix<E>.withEach(block: E.() -> Unit)

withEachIndexed

inline fun <E> Matrix<E>.withEachIndexed(block: E.(rowIndex: UInt, columnIndex: UInt) -> Unit)