multik-core/org.jetbrains.kotlinx.multik.ndarray.operations

Package org.jetbrains.kotlinx.multik.ndarray.operations

Types

Abs

class Abs<T : Number> : Exp<T>

Arith

interface Arith

Ceil

class Ceil<T : Number> : Exp<T>

CopyStrategy

enum CopyStrategy : Enum<CopyStrategy>

Cos

class Cos<T : Number> : Exp<T>

Div

class Div<T, D : Dimension>(right: MultiArray<T, D>) : Exp<T> , Arith

Exp

sealed class Exp<T>

Inplace

sealed class Inplace<T : Number, D : Dimension>(val base: MutableMultiArray<T, D>)

InplaceDslMarker

@DslMarker

annotation class InplaceDslMarker

InplaceMath

class InplaceMath<T : Number, D : Dimension>(base: MutableMultiArray<T, D>) : InplaceOperation<T, D>

InplaceOperation

open class InplaceOperation<T : Number, D : Dimension>(base: MutableMultiArray<T, D>) : Inplace<T, D>

Log

class Log<T : Number> : Exp<T>

Prod

class Prod<T, D : Dimension>(right: MultiArray<T, D>) : Exp<T> , Arith

Sin

class Sin<T : Number> : Exp<T>

Sub

class Sub<T, D : Dimension>(right: MultiArray<T, D>) : Exp<T> , Arith

Sum

class Sum<T, D : Dimension>(right: MultiArray<T, D>) : Exp<T> , Arith

Tan

class Tan<T : Number> : Exp<T>

Functions

abs

@JvmName(name = "inplaceAbsDouble")

fun <D : Dimension> InplaceMath<Double, D>.abs(): InplaceMath<Double, D>

@JvmName(name = "inplaceAbsFloat")

fun <D : Dimension> InplaceMath<Float, D>.abs(): InplaceMath<Float, D>

@JvmName(name = "inplaceAbsInt")

fun <D : Dimension> InplaceMath<Int, D>.abs(): InplaceMath<Int, D>

@JvmName(name = "inplaceAbsLong")

fun <D : Dimension> InplaceMath<Long, D>.abs(): InplaceMath<Long, D>

all

inline fun <T, D : Dimension> MultiArray<T, D>.all(predicate: (T) -> Boolean): Boolean

Returns true if all elements match the given predicate. If an ndarray is empty, then always returns true.

and

infix fun <T : Number, D : Dimension> MultiArray<T, D>.and(other: MultiArray<T, D>): NDArray<Int, D>

any

fun <T, D : Dimension> MultiArray<T, D>.any(): Boolean

Returns true if collection has at least one element.

inline fun <T, D : Dimension> MultiArray<T, D>.any(predicate: (T) -> Boolean): Boolean

Returns true if at least one element matches the given predicate. If an ndarray is empty, then always returns false.

append

fun <T, D : Dimension> MultiArray<T, D>.append(vararg value: T): D1Array<T>

infix fun <T, D : Dimension, ID : Dimension> MultiArray<T, D>.append(arr: MultiArray<T, ID>): D1Array<T>

fun <T, D : Dimension> MultiArray<T, D>.append(arr: MultiArray<T, D>, axis: Int): NDArray<T, D>

asSequence

fun <T, D : Dimension> MultiArray<T, D>.asSequence(): Sequence<T>

Creates a Sequence instance that wraps the original collection returning its elements when being iterated.

associate

inline fun <T, D : Dimension, K, V> MultiArray<T, D>.associate(transform: (T) -> Pair<K, V>): Map<K, V>

Returns a Map containing key-value pairs provided by transform function applied to elements of the given collection.

associateBy

inline fun <T, D : Dimension, K> MultiArray<T, D>.associateBy(keySelector: (T) -> K): Map<K, T>

Returns a Map containing the elements from the given collection indexed by the key returned from keySelector function applied to each element.

inline fun <T, D : Dimension, K, V> MultiArray<T, D>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>

Returns a Map containing the values provided by valueTransform and indexed by keySelector functions applied to elements of the given collection.

associateByTo

inline fun <T, D : Dimension, K, M : MutableMap<in K, in T>> MultiArray<T, D>.associateByTo(destination: M, keySelector: (T) -> K): M

Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each element of the given collection and value is the element itself.

inline fun <T, D : Dimension, K, V, M : MutableMap<in K, in V>> MultiArray<T, D>.associateByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to elements of the given collection.

associateTo

inline fun <T, D : Dimension, K, V, M : MutableMap<in K, in V>> MultiArray<T, D>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M

Populates and returns the destination mutable map with key-value pairs provided by transform function applied to each element of the given collection.

associateWith

inline fun <K, D : Dimension, V> MultiArray<K, D>.associateWith(valueSelector: (K) -> V): Map<K, V>

Returns a Map where keys are elements from the given collection and values are produced by the valueSelector function applied to each element.

associateWithTo

inline fun <K, D : Dimension, V, M : MutableMap<in K, in V>> MultiArray<K, D>.associateWithTo(destination: M, valueSelector: (K) -> V): M

Populates and returns the destination mutable map with key-value pairs for each element of the given collection, where key is the element itself and value is provided by the valueSelector function applied to that key.

average

fun <T : Number, D : Dimension> MultiArray<T, D>.average(): Double

Returns an average value of elements in the ndarray.

ceil

@JvmName(name = "inplaceCeilDouble")

fun <D : Dimension> InplaceMath<Double, D>.ceil(): InplaceMath<Double, D>

@JvmName(name = "inplaceCeilFloat")

fun <D : Dimension> InplaceMath<Float, D>.ceil(): InplaceMath<Float, D>

chunked

fun <T, D : Dimension> MultiArray<T, D>.chunked(size: Int): NDArray<T, D2>

Splits this ndarray into a 2-D ndarray. The last elements in the resulting ndarray may be zero.

clip

fun <T : Comparable<T>, Number, D : Dimension> MultiArray<T, D>.clip(min: T, max: T): NDArray<T, D>

Clips the values in ndarray if value is not in range min..max

contains

operator fun <T, D : Dimension> MultiArray<T, D>.contains(element: T): Boolean

Returns true if element is found in the collection.

cos

@JvmName(name = "inplaceCosDouble")

fun <D : Dimension> InplaceMath<Double, D>.cos(): InplaceMath<Double, D>

@JvmName(name = "inplaceCosFloat")

fun <D : Dimension> InplaceMath<Float, D>.cos(): InplaceMath<Float, D>

count

inline fun <T, D : Dimension> MultiArray<T, D>.count(): Int

Returns the number of elements in an ndarray.

inline fun <T, D : Dimension> MultiArray<T, D>.count(predicate: (T) -> Boolean): Int

Returns the number of elements matching the given predicate.

distinct

fun <T, D : Dimension> MultiArray<T, D>.distinct(): NDArray<T, D1>

Returns a new array containing only distinct elements from the given array.

distinctBy

inline fun <T, D : Dimension, K> MultiArray<T, D>.distinctBy(selector: (T) -> K): NDArray<T, D1>

Returns a new array containing only elements from the given array having distinct keys returned by the given selector function.

div

operator fun <D : Dimension> Byte.div(other: MultiArray<Byte, D>): NDArray<Byte, D>

operator fun <D : Dimension> Double.div(other: MultiArray<Double, D>): NDArray<Double, D>

operator fun <D : Dimension> Float.div(other: MultiArray<Float, D>): NDArray<Float, D>

operator fun <D : Dimension> Int.div(other: MultiArray<Int, D>): NDArray<Int, D>

operator fun <D : Dimension> Long.div(other: MultiArray<Long, D>): NDArray<Long, D>

operator fun <D : Dimension> Short.div(other: MultiArray<Short, D>): NDArray<Short, D>

operator fun <D : Dimension> ComplexDouble.div(other: MultiArray<ComplexDouble, D>): NDArray<ComplexDouble, D>

operator fun <D : Dimension> ComplexFloat.div(other: MultiArray<ComplexFloat, D>): NDArray<ComplexFloat, D>

operator fun <T, D : Dimension> MultiArray<T, D>.div(other: T): NDArray<T, D>

operator fun <T, D : Dimension> MultiArray<T, D>.div(other: MultiArray<T, D>): NDArray<T, D>

Create a new array as division of this by other.

divAssign

operator fun <T, D : Dimension> MutableMultiArray<T, D>.divAssign(other: T)

Divide by other element-wise. Inplace operator.

operator fun <T, D : Dimension> MutableMultiArray<T, D>.divAssign(other: MultiArray<T, D>)

Divide this by other. Inplace operator.

drop

fun <T> MultiArray<T, D1>.drop(n: Int): D1Array<T>

Drops first n elements.

dropWhile

inline fun <T> MultiArray<T, D1>.dropWhile(predicate: (T) -> Boolean): NDArray<T, D1>

Drops elements that don't satisfy the predicate.

expandDims

@JvmName(name = "expandDimsD1")

fun <T> MultiArray<T, D1>.expandDims(axis: Int): MultiArray<T, D2>

@JvmName(name = "expandDimsD2")

fun <T> MultiArray<T, D2>.expandDims(axis: Int): MultiArray<T, D3>

@JvmName(name = "expandDimsD3")

fun <T> MultiArray<T, D3>.expandDims(axis: Int): MultiArray<T, D4>

@JvmName(name = "expandDimsD4")

fun <T> MultiArray<T, D4>.expandDims(axis: Int): MultiArray<T, DN>

Returns a ndarray with an expanded shape.

expandNDims

@JvmName(name = "expandDimsDN")

fun <T, D : Dimension> MultiArray<T, D>.expandNDims(vararg axes: Int): MultiArray<T, DN>

Returns a ndarray with an expanded shape.

filter

inline fun <T, D : Dimension> MultiArray<T, D>.filter(predicate: (T) -> Boolean): D1Array<T>

Return a new array contains elements matching filter.

filterIndexed

@JvmName(name = "filterD1Indexed")

inline fun <T> MultiArray<T, D1>.filterIndexed(predicate: (index: Int, T) -> Boolean): D1Array<T>

Return a new array contains elements matching filter.

filterMultiIndexed

@JvmName(name = "filterDNIndexed")

inline fun <T, D : Dimension> MultiArray<T, D>.filterMultiIndexed(predicate: (index: IntArray, T) -> Boolean): D1Array<T>

Return a new array contains elements matching filter.

filterNot

inline fun <T, D : Dimension> MultiArray<T, D>.filterNot(predicate: (T) -> Boolean): D1Array<T>

Return a new array contains elements matching filter.

find

inline fun <T, D : Dimension> MultiArray<T, D>.find(predicate: (T) -> Boolean): T?

Returns the first element matching the given predicate, or null if no such element was found.

findLast

inline fun <T, D : Dimension> MultiArray<T, D>.findLast(predicate: (T) -> Boolean): T?

Returns the last element matching the given predicate, or null if no such element was found.

first

fun <T, D : Dimension> MultiArray<T, D>.first(): T

Returns first element.

inline fun <T, D : Dimension> MultiArray<T, D>.first(predicate: (T) -> Boolean): T

Returns the first element matching the given predicate.

firstOrNull

fun <T, D : Dimension> MultiArray<T, D>.firstOrNull(): T?

Returns the first element, or null if the collection is empty.

inline fun <T, D : Dimension> MultiArray<T, D>.firstOrNull(predicate: (T) -> Boolean): T?

Returns the first element matching the given predicate, or null if element was not found.

flatMap

inline fun <T, D : Dimension, R> MultiArray<T, D>.flatMap(transform: (T) -> Iterable<R>): D1Array<R>

Returns a flat ndarray of all elements resulting from calling the transform function on each element in this ndarray.

flatMapIndexed

@JvmName(name = "flatMapD1Indexed")

inline fun <T, R> MultiArray<T, D1>.flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): D1Array<R>

Returns a flat ndarray of all elements resulting from calling the transform function on each element and its single index in this d1 ndarray.

flatMapMultiIndexed

@JvmName(name = "flatMapDNIndexed")

inline fun <T, R> MultiArray<T, D1>.flatMapMultiIndexed(transform: (index: IntArray, T) -> Iterable<R>): D1Array<R>

Returns a flat ndarray of all elements resulting from calling the transform function on each element and its multi index in this dn ndarray.

fold

inline fun <T, D : Dimension, R> MultiArray<T, D>.fold(initial: R, operation: (acc: R, T) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.

foldIndexed

@JvmName(name = "foldD1Indexed")

inline fun <T, R> MultiArray<T, D1>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element with its index in the original ndarray.

foldMultiIndexed

@JvmName(name = "foldDNIndexed")

inline fun <T, D : Dimension, R> MultiArray<T, D>.foldMultiIndexed(initial: R, operation: (index: IntArray, acc: R, T) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element with its index in the original ndarray.

forEach

inline fun <T, D : Dimension> MultiArray<T, D>.forEach(action: (T) -> Unit)

Performs the given action on each element.

forEachIndexed

@JvmName(name = "forEachD1Indexed")

inline fun <T> MultiArray<T, D1>.forEachIndexed(action: (index: Int, T) -> Unit)

Performs the given action on each element, providing sequential index with the element.

forEachMultiIndexed

@JvmName(name = "forEachDNIndexed")

inline fun <T, D : Dimension> MultiArray<T, D>.forEachMultiIndexed(action: (index: IntArray, T) -> Unit)

Performs the given action on each element, providing sequential index with the element.

groupingNDArrayBy

inline fun <T, D : Dimension, K> MultiArray<T, D>.groupingNDArrayBy(crossinline keySelector: (T) -> K): Grouping<T, K>

Creates a Grouping source from an ndarray to be used later with one of group-and-fold operations using the specified keySelector function to extract a key from each element.

groupNDArrayBy

inline fun <T, D : Dimension, K> MultiArray<T, D>.groupNDArrayBy(keySelector: (T) -> K): Map<K, NDArray<T, D1>>

Groups elements of a given ndarray by the key returned by keySelector for each element, and returns a map where each group key is associated with an ndarray of matching elements.

inline fun <T, D : Dimension, K, V : Number> MultiArray<T, D>.groupNDArrayBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, NDArray<V, D1>>

Groups values returned by valueTransform applied to each element of the given ndarray with the key returned by keySelector applied to each element, and returns a map where each group key is associated with an ndarray of matching values.

groupNDArrayByTo

inline fun <T, D : Dimension, K, M : MutableMap<in K, NDArray<T, D1>>> MultiArray<T, D>.groupNDArrayByTo(destination: M, keySelector: (T) -> K): M

Groups elements of the given array by the key returned by keySelector function applied to each element and puts to the destination map each group key associated with an ndarray of corresponding elements.

inline fun <T, D : Dimension, K, V, M : MutableMap<in K, NDArray<V, D1>>> MultiArray<T, D>.groupNDArrayByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

Groups values returned by the valueTransform function applied to each element of the given ndarray by the key returned by keySelector function applied to the element and puts to the destination map each group key associated with an ndarray of corresponding values.

indexOf

fun <T, D : Dimension> MultiArray<T, D>.indexOf(element: T): Int

Returns first index of element, or -1 if the collection does not contain element.

indexOfFirst

inline fun <T, D : Dimension> MultiArray<T, D>.indexOfFirst(predicate: (T) -> Boolean): Int

Returns index of the first element matching the given predicate, or -1 if the collection does not contain such element.

indexOfLast

inline fun <T, D : Dimension> MultiArray<T, D>.indexOfLast(predicate: (T) -> Boolean): Int

Returns index of the last element matching the given predicate, or -1 if the collection does not contain such element.

inplace

fun <T : Number, D : Dimension> NDArray<T, D>.inplace(init: InplaceOperation<T, D>.() -> Unit)

intersect

infix fun <T, D : Dimension> MultiArray<T, D>.intersect(other: Iterable<T>): Set<T>

Returns a set containing all elements that are contained by both this collection and the specified collection.

isTransposed

fun <T, D : Dimension> MultiArray<T, D>.isTransposed(): Boolean

joinTo

fun <T, D : Dimension, A : Appendable> MultiArray<T, D>.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): A

Appends the string from all the elements separated using separator and using the given prefix and postfix if supplied.

joinToString

fun <T, D : Dimension> MultiArray<T, D>.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): String

Creates a string from all the elements separated using separator and using the given prefix and postfix if supplied.

last

fun <T, D : Dimension> MultiArray<T, D>.last(): T

Returns the last element.

inline fun <T, D : Dimension> MultiArray<T, D>.last(predicate: (T) -> Boolean): T

Returns the last element matching the given predicate.

lastIndexOf

fun <T, D : Dimension> MultiArray<T, D>.lastIndexOf(element: T): Int

Returns last index of element, or -1 if the collection does not contain element.

lastOrNull

fun <T, D : Dimension> MultiArray<T, D>.lastOrNull(): T?

Returns the last element, or null if the list is empty.

inline fun <T, D : Dimension> MultiArray<T, D>.lastOrNull(predicate: (T) -> Boolean): T?

Returns the last element matching the given predicate, or null if no such element was found.

log

@JvmName(name = "inplaceLogDouble")

fun <D : Dimension> InplaceMath<Double, D>.log(): InplaceMath<Double, D>

@JvmName(name = "inplaceLogFloat")

fun <D : Dimension> InplaceMath<Float, D>.log(): InplaceMath<Float, D>

map

inline fun <T, D : Dimension, R : Any> MultiArray<T, D>.map(transform: (T) -> R): NDArray<R, D>