multik-core/org.jetbrains.kotlinx.multik.ndarray.data/MultiArray

MultiArray

interface MultiArray<T, D : Dimension>

A generic ndarray. Methods in this interface support only read-only access to the ndarray.

Functions

cat

abstract infix fun cat(other: MultiArray<T, D>): NDArray<T, D>

Concatenates this ndarray with other.

abstract fun cat(other: List<MultiArray<T, D>>, axis: Int = 0): NDArray<T, D>

Concatenates this ndarray with a list of other ndarrays.

abstract fun cat(other: MultiArray<T, D>, axis: Int = 0): NDArray<T, D>

Concatenates this ndarray with other along the specified axis.

copy

abstract fun copy(): MultiArray<T, D>

Returns new MultiArray which is a copy of the original ndarray.

deepCopy

abstract fun deepCopy(): MultiArray<T, D>

Returns new MultiArray which is a deep copy of the original ndarray.

flatten

abstract fun flatten(): MultiArray<T, D1>

Returns new one-dimensional ndarray which is a copy of the original ndarray.

isEmpty

abstract fun isEmpty(): Boolean

Returns true if this ndarray is empty.

isNotEmpty

abstract fun isNotEmpty(): Boolean

Returns true if this ndarray is not empty.

isScalar

abstract fun isScalar(): Boolean

Returns true if the array contains only one element, otherwise false.

iterator

abstract operator fun iterator(): Iterator<T>

reshape

abstract fun reshape(dim1: Int): MultiArray<T, D1>

Returns an ndarray with a new (dim1) shape without changing data.

abstract fun reshape(dim1: Int, dim2: Int): MultiArray<T, D2>

Returns an ndarray with a new (dim1, dim2) shape without changing data.

abstract fun reshape( dim1: Int, dim2: Int, dim3: Int): MultiArray<T, D3>

Returns an ndarray with a new (dim1, dim2, dim3) shape without changing data.

abstract fun reshape( dim1: Int, dim2: Int, dim3: Int, dim4: Int): MultiArray<T, D4>

Returns an ndarray with a new (dim1, dim2, dim3, dim4) shape without changing data.

abstract fun reshape( dim1: Int, dim2: Int, dim3: Int, dim4: Int, vararg dims: Int): MultiArray<T, DN>

Returns an ndarray with a new (dim1, dim2, dim3, dim4, dims) shape without changing data.

squeeze

abstract fun squeeze(vararg axes: Int): MultiArray<T, DN>

Returns an ndarray with all axes removed equal to one.

transpose

abstract fun transpose(vararg axes: Int): MultiArray<T, D>

Reverse or permute the axes of an array.

unsqueeze

abstract fun unsqueeze(vararg axes: Int): MultiArray<T, DN>

Returns a new ndarray with a dimension of size one inserted at the specified axes.

Properties

base

abstract val base: MultiArray<T, out Dimension>?

Base array if data is taken from other array. Otherwise - null.

consistent

abstract val consistent: Boolean

indicates whether the array data is homogeneous.

data

abstract val data: ImmutableMemoryView<T>

abstract val dim: D

open val dtype: DataType

DataType of an ndarray's data.

indices

abstract val indices: IntRange

indices for a one-dimensional ndarray.

multiIndices

abstract val multiIndices: MultiIndexProgression

indices for a n-dimensional ndarray.

offset

abstract val offset: Int

Offset from the start of an ndarray's data.

shape

abstract val shape: IntArray

IntArray of an ndarray dimensions.

size

abstract val size: Int

number of elements in an ndarray.

strides

abstract val strides: IntArray

IntArray indices to step in each dimension when iterating an ndarray.

Inheritors

MutableMultiArray

Extensions

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>

argMax

fun <T : Number, D : Dimension> MultiArray<T, D>.argMax(): Int

Returns flat index of maximum element in an ndarray.

argMin

fun <T : Number, D : Dimension> MultiArray<T, D>.argMin(): Int

Returns flat index of minimum element in an ndarray.

asDNArray

fun <T, D : Dimension> MultiArray<T, D>.asDNArray(): NDArray<T, DN>

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.

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

conj

@JvmName(name = "conjDouble")

fun <D : Dimension> MultiArray<ComplexDouble, D>.conj(): MultiArray<ComplexDouble, D>

Transforms this MultiArray of ComplexDouble to an NDArray of the conjugated value. Dimensions are preserved.

@JvmName(name = "conjFloat")

fun <D : Dimension> MultiArray<ComplexFloat, D>.conj(): MultiArray<ComplexFloat, D>

Transforms this MultiArray of ComplexFloat to an NDArray of the conjugated value. Dimensions are preserved.

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 = "cosTD")

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

Returns an ndarray of Double from the given ndarray to each element of which a cos function has been applied.

@JvmName(name = "cosFloatD")

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

Returns an ndarray of Float from the given ndarray to each element of which a cos function has been applied.

@JvmName(name = "cosComplexFloatD")

fun <D : Dimension> MultiArray<ComplexFloat, D>.cos(): NDArray<ComplexFloat, D>

@JvmName(name = "cosComplexDoubleD")

fun <D : Dimension> MultiArray<ComplexDouble, D>.cos(): NDArray<ComplexDouble, D>

Returns an ndarray of ComplexFloat from the given ndarray to each element of which a cos function has been applied.

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.

cumSum

fun <T : Number, D : Dimension> MultiArray<T, D>.cumSum(): D1Array<T>

Returns cumulative sum of all elements in the given ndarray.

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 <T, D : Dimension> MultiArray<T, D>.div(other: MultiArray<T, D>): NDArray<T, D>

Create a new array as division of this by other.

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

dot

@JvmName(name = "dotDefMMNumber")

infix fun <T : Number> MultiArray<T, D2>.dot(b: MultiArray<T, D2>): NDArray<T, D2>

Returns the matrix product of two numeric matrices.

@JvmName(name = "dotDefMMComplex")

infix fun <T : Complex> MultiArray<T, D2>.dot(b: MultiArray<T, D2>): NDArray<T, D2>

Returns the matrix product of two complex matrices.

@JvmName(name = "dotDefMVNumber")

infix fun <T : Number> MultiArray<T, D2>.dot(b: MultiArray<T, D1>): NDArray<T, D1>

Returns the matrix product of a numeric matrix and a numeric vector.

@JvmName(name = "dotDefMVComplex")

infix fun <T : Complex> MultiArray<T, D2>.dot(b: MultiArray<T, D1>): NDArray<T, D1>

Returns the matrix product of a complex matrix and a complex vector.

@JvmName(name = "dotDefVVNumber")

infix fun <T : Number> MultiArray<T, D1>.dot(b: MultiArray<T, D1>): T

Returns the product of two numeric vectors.

@JvmName(name = "dotDefVVComplex")

infix fun <T : Complex> MultiArray<T, D1>.dot(b: MultiArray<T, D1>): T

Returns the product of two complex vectors.

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.

exp

@JvmName(name = "expTD")

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

Returns an ndarray of Double from the given ndarray to each element of which an exp function has been applied.

@JvmName(name = "expFloatD")

fun <D : Dimension> MultiArray<Float, D>.exp(): NDArray<Float, D>

Returns an ndarray of Float from the given ndarray to each element of which an exp function has been applied.

@JvmName(name = "expComplexFloatD")

fun <D : Dimension> MultiArray<ComplexFloat, D>.exp(): NDArray<ComplexFloat, D>

Returns an ndarray of ComplexFloat from the given ndarray to each element of which an exp function has been applied.

@JvmName(name = "expComplexDoubleD")

fun <D : Dimension> MultiArray<ComplexDouble, D>.exp(): NDArray<ComplexDouble, D>

Returns an ndarray of ComplexDouble from the given ndarray to each element of which an exp function has been applied.

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.

get

@JvmName(name = "get0")

operator fun <T> MultiArray<T, D1>.get(index: Int): T

@JvmName(name = "get1")

operator fun <T> MultiArray<T, D2>.get(index: Int): MultiArray<T, D1>

@JvmName(name = "get2")

operator fun <T> MultiArray<T, D2>.get(ind1: Int, ind2: Int): T

@JvmName(name = "get3")

operator fun <T> MultiArray<T, D3>.get(index: Int): MultiArray<T, D2>

@JvmName(name = "get4")

operator fun <T> MultiArray<T, D3>.get(ind1: Int, ind2: Int): MultiArray<T, D1>

@JvmName(name = "get5")

operator fun <T> MultiArray<T, D3>.get( ind1: Int, ind2: Int, ind3: Int): T

@JvmName(name = "get6")

operator fun <T> MultiArray<T, D4>.get(index: Int): MultiArray<T, D3>

@JvmName(name = "get7")

operator fun <T> MultiArray<T, D4>.get(ind1: Int, ind2: Int): MultiArray<T, D2>

@JvmName(name = "get8")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: Int, ind3: Int): MultiArray<T, D1>

@JvmName(name = "get9")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: Int, ind3: Int, ind4: Int): T

@JvmName(name = "get10")

operator fun <T> MultiArray<T, DN>.get(vararg index: Int): T

@JvmName(name = "get11")

operator fun <T> MultiArray<T, DN>.get(index: IntArray): T

@JvmName(name = "get12")

operator fun <T> MultiArray<T, D1>.get(index: ClosedRange<Int>): MultiArray<T, D1>

@JvmName(name = "get13")

operator fun <T> MultiArray<T, D2>.get(index: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get14")

operator fun <T> MultiArray<T, D2>.get(ind1: ClosedRange<Int>, ind2: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get15")

operator fun <T> MultiArray<T, D2>.get(ind1: Int, ind2: ClosedRange<Int>): MultiArray<T, D1>

@JvmName(name = "get16")

operator fun <T> MultiArray<T, D2>.get(ind1: ClosedRange<Int>, ind2: Int): MultiArray<T, D1>

@JvmName(name = "get17")

operator fun <T> MultiArray<T, D3>.get(index: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get18")

operator fun <T> MultiArray<T, D3>.get(ind1: ClosedRange<Int>, ind2: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get19")

operator fun <T> MultiArray<T, D3>.get(ind1: Int, ind2: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get20")

operator fun <T> MultiArray<T, D3>.get(ind1: ClosedRange<Int>, ind2: Int): MultiArray<T, D2>

@JvmName(name = "get21")

operator fun <T> MultiArray<T, D3>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get22")

operator fun <T> MultiArray<T, D3>.get( ind1: Int, ind2: Int, ind3: ClosedRange<Int>): MultiArray<T, D1>

@JvmName(name = "get23")

operator fun <T> MultiArray<T, D3>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: Int): MultiArray<T, D1>

@JvmName(name = "get24")

operator fun <T> MultiArray<T, D3>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: Int): MultiArray<T, D1>

@JvmName(name = "get25")

operator fun <T> MultiArray<T, D3>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get26")

operator fun <T> MultiArray<T, D3>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: Int): MultiArray<T, D2>

@JvmName(name = "get27")

operator fun <T> MultiArray<T, D3>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get28")

operator fun <T> MultiArray<T, D4>.get(index: ClosedRange<Int>): MultiArray<T, D4>

@JvmName(name = "get29")

operator fun <T> MultiArray<T, D4>.get(ind1: ClosedRange<Int>, ind2: ClosedRange<Int>): MultiArray<T, D4>

@JvmName(name = "get30")

operator fun <T> MultiArray<T, D4>.get(ind1: Int, ind2: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get31")

operator fun <T> MultiArray<T, D4>.get(ind1: ClosedRange<Int>, ind2: Int): MultiArray<T, D3>

@JvmName(name = "get32")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>): MultiArray<T, D4>

@JvmName(name = "get33")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: Int, ind3: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get34")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: Int): MultiArray<T, D2>

@JvmName(name = "get35")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: Int): MultiArray<T, D2>

@JvmName(name = "get36")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get37")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: Int): MultiArray<T, D3>

@JvmName(name = "get38")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get39")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>, ind4: ClosedRange<Int>): MultiArray<T, D4>

@JvmName(name = "get39")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: Int, ind3: Int, ind4: ClosedRange<Int>): MultiArray<T, D1>

@JvmName(name = "get40")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: Int, ind3: ClosedRange<Int>, ind4: Int): MultiArray<T, D1>

@JvmName(name = "get41")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: Int, ind4: Int): MultiArray<T, D1>

@JvmName(name = "get42")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: Int, ind4: Int): MultiArray<T, D1>

@JvmName(name = "get43")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: Int, ind3: ClosedRange<Int>, ind4: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get44")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>, ind4: Int): MultiArray<T, D2>

@JvmName(name = "get45")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: Int, ind4: Int): MultiArray<T, D2>

@JvmName(name = "get46")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: Int, ind4: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get47")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: Int, ind4: ClosedRange<Int>): MultiArray<T, D2>

@JvmName(name = "get48")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: ClosedRange<Int>, ind4: Int): MultiArray<T, D2>

@JvmName(name = "get49")

operator fun <T> MultiArray<T, D4>.get( ind1: Int, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>, ind4: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get50")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: Int, ind3: ClosedRange<Int>, ind4: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get51")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: Int, ind4: ClosedRange<Int>): MultiArray<T, D3>

@JvmName(name = "get52")

operator fun <T> MultiArray<T, D4>.get( ind1: ClosedRange<Int>, ind2: ClosedRange<Int>, ind3: ClosedRange<Int>, ind4: Int): MultiArray<T, D3>

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.

@get:JvmName(name = "imFloat")

val <D : Dimension> MultiArray<ComplexFloat, D>.im: NDArray<Float, D>

Transforms this NDArray of ComplexFloat to an NDArray of the imaginary part of complex numbers. Dimensions are preserved.

@get:JvmName(name = "imDouble")

val <D : Dimension> MultiArray<ComplexDouble, D>.im: NDArray<Double, D>

Transforms this NDArray of ComplexDouble to an NDArray of the imaginary part of complex numbers. Dimensions are preserved.

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.

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 = "logTD")

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

Returns an ndarray of Double from the given ndarray to each element of which a log function has been applied.

@JvmName(name = "logFloatD")

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

Returns an ndarray of Float from the given ndarray to each element of which a log function has been applied.

@JvmName(name = "logComplexFloatD")

fun <D : Dimension> MultiArray<ComplexFloat, D>.log(): NDArray<ComplexFloat, D>

Returns an ndarray of ComplexFloat from the given ndarray to each element of which a log function has been applied.

@JvmName(name = "logComplexDoubleD")

fun <D : Dimension> MultiArray<ComplexDouble, D>.log(): NDArray<ComplexDouble, D>

Returns an ndarray of ComplexDouble from the given ndarray to each element of which a log function has been applied.

map

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