kone.linearAlgebra/dev.lounres.kone.linearAlgebra/SettableRowVector

SettableRowVector

@Serializable(with = SettableRowVectorSerializer::class)

class SettableRowVector<N>(val coefficients: SettableMDList1<N>) : RowVector<N> (source)

Constructors

SettableRowVector

constructor(coefficients: SettableMDList1<N>)

Properties

coefficients

open override val coefficients: SettableMDList1<N>

indices

val RowVector<*>.indices: UIntRange

size

val size: UInt

Functions

all

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

allIndexed

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

any

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

anyIndexed

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

fold

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

foldIndexed

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

forEach

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

forEachIndexed

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

get

operator fun get(index: UInt): N

map

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

mapIndexed

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

minus

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

none

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

noneIndexed

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

plus

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

set

operator fun set(index: UInt, coefficient: N)

sum

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

sumOf

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

sumOfIndexed

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

times

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

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

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

toString

open override fun toString(): String

unaryMinus

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

withEach

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

withEachIndexed

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