kone.linearAlgebra/dev.lounres.kone.linearAlgebra.utils

Package-level declarations

Types

DeterminantComputer

interface DeterminantComputer<Number>

NonSquareMatrixDeterminantComputationAttemptException

class NonSquareMatrixDeterminantComputationAttemptException : IllegalArgumentException

Properties

det

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

determinantViaGaussianElimination

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

determinantViaGaussianEliminationComputer

val <Number> Field<Number>.determinantViaGaussianEliminationComputer: DeterminantComputer<Number>

determinantViaLeibnizFormula

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

determinantViaLeibnizFormulaComputer

val <Number> Ring<Number>.determinantViaLeibnizFormulaComputer: DeterminantComputer<Number>

isAntisymmetric

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

isSymmetric

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

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> ColumnVector<E>.all(block: (value: E) -> Boolean): Boolean

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

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

allIndexed

inline fun <E> ColumnVector<E>.allIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

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

inline fun <E> RowVector<E>.allIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

any

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

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

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

anyIndexed

inline fun <E> ColumnVector<E>.anyIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

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

inline fun <E> RowVector<E>.anyIndexed(block: (index: 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> ColumnVector<E>.fold(initial: R, operation: (acc: R, E) -> R): R

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

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

foldIndexed

inline fun <E, R> ColumnVector<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R

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

inline fun <E, R> RowVector<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R

forEach

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

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

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

forEachIndexed

inline fun <E> ColumnVector<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)

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

inline fun <E> RowVector<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)

installDeterminantViaGaussianEliminationComputer

fun <Number> KoneContextRegistryBuilder.installDeterminantViaGaussianEliminationComputer(numberType: SuppliedType<Number>)

installDeterminantViaLeibnizFormulaComputer

fun <Number> KoneContextRegistryBuilder.installDeterminantViaLeibnizFormulaComputer(numberType: SuppliedType<Number>)

map

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

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

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

mapIndexed

inline fun <E, R> ColumnVector<E>.mapIndexed(transform: (index: UInt, E) -> R): ColumnVector<R>

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

inline fun <E, R> RowVector<E>.mapIndexed(transform: (index: UInt, E) -> R): RowVector<R>

minorViaGaussianElimination

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

minorViaLeibnizFormula

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

none

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

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

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

noneIndexed

inline fun <E> ColumnVector<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

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

inline fun <E> RowVector<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

nonSquareMatrixDeterminantComputationAttemptException

fun nonSquareMatrixDeterminantComputationAttemptException(): Nothing

sum

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

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

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

sumOf

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

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

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

sumOfIndexed

inline fun <E, A> ColumnVector<E>.sumOfIndexed(selector: (index: UInt, E) -> A): A

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

inline fun <E, A> RowVector<E>.sumOfIndexed(selector: (index: UInt, E) -> A): A

withEach

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

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

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

withEachIndexed

inline fun <E> ColumnVector<E>.withEachIndexed(block: E.(index: UInt) -> Unit)

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

inline fun <E> RowVector<E>.withEachIndexed(block: E.(index: UInt) -> Unit)