Resize original buffer to a given range using given range, filling additional segments with defaultValue. Range left border could be negative to designate adding new blank segment to the beginning of the buffer

first

fun <T> Buffer<T>.first(): T

fold

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

Fold given buffer according to operation

foldIndexed

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

Fold given buffer according to indexed operation

get

@PerformancePitfall

open operator override fun get(index: IntArray): T

Returns the value at the specified indices.

abstract operator fun get(index: Int): T

Gets element at given index.

get

@PerformancePitfall

operator fun <T> StructureND<T>.get(vararg index: Int): T

Returns the value at the specified indices.

operator fun StructureND<Double>.get(vararg index: Int): Double

operator fun StructureND<Int>.get(vararg index: Int): Int

operator fun <T> Buffer<T>.get(index: UInt): T

getDouble

fun MutableStructureND<Double>.getDouble(index: IntArray): Double

fun StructureND<Double>.getDouble(index: IntArray): Double

Optimized method to access primitive without boxing if possible

@UnstableKMathAPI

fun Buffer<Double>.getDouble(index: Int): Double

Non-boxing access to primitive Double

getFeature

open override fun <F : StructureFeature> getFeature(type: KClass<out F>): F?

Feature is some additional structure information that allows to access it special properties or hints. If the feature is not present, null is returned.

getInt

fun StructureND<Int>.getInt(index: IntArray): Int

@UnstableKMathAPI

fun Buffer<Int>.getInt(index: Int): Int

Non-boxing access to primitive Int

getOrNull

fun <T> Buffer<T>.getOrNull(index: Int): T?

if index is in range of buffer, return the value. Otherwise, return null.

indicesSorted

@UnstableKMathAPI

fun <V : Comparable<V>> Buffer<V>.indicesSorted(): IntArray

Return a new array filled with buffer indices. Indices order is defined by sorting associated buffer value. This feature allows sorting buffer values without reordering its content.

indicesSortedBy

@UnstableKMathAPI

fun <V, C : Comparable<C>> Buffer<V>.indicesSortedBy(selector: (V) -> C): IntArray

indicesSortedByDescending

@UnstableKMathAPI

fun <V, C : Comparable<C>> Buffer<V>.indicesSortedByDescending(selector: (V) -> C): IntArray

indicesSortedDescending

@UnstableKMathAPI

fun <V : Comparable<V>> Buffer<V>.indicesSortedDescending(): IntArray

indicesSortedWith

@UnstableKMathAPI

fun <V> Buffer<V>.indicesSortedWith(comparator: Comparator<V>): IntArray

iterator

open operator override fun iterator(): Iterator<T>

Iterates over all elements.

last

fun <T> Buffer<T>.last(): T

map

@PerformancePitfall(message = "Very slow on remote execution algebras")

open fun StructureND<Int>.map(transform: IntRing.(Int) -> Int): StructureND<Int>

Maps elements from one structure to another one by applying transform to them.

@PerformancePitfall(message = "Very slow on remote execution algebras")

open fun StructureND<Short>.map(transform: ShortRing.(Short) -> Short): StructureND<Short>

Maps elements from one structure to another one by applying transform to them.

open override fun StructureND<Double>.map(transform: DoubleField.(Double) -> Double): BufferND<Double>

Maps elements from one structure to another one by applying transform to them.

inline override fun Buffer<Double>.map(block: DoubleField.(Double) -> Double): DoubleBuffer

mapIndexed

@PerformancePitfall(message = "Very slow on remote execution algebras")

open fun StructureND<Double>.mapIndexed(transform: DoubleField.(index: IntArray, Double) -> Double): StructureND<Double>

Maps elements from one structure to another one by applying transform to them alongside with their indices.

@PerformancePitfall(message = "Very slow on remote execution algebras")

open fun StructureND<Int>.mapIndexed(transform: IntRing.(index: IntArray, Int) -> Int): StructureND<Int>

Maps elements from one structure to another one by applying transform to them alongside with their indices.

@PerformancePitfall(message = "Very slow on remote execution algebras")

open fun StructureND<Short>.mapIndexed(transform: ShortRing.(index: IntArray, Short) -> Short): StructureND<Short>

Maps elements from one structure to another one by applying transform to them alongside with their indices.

inline override fun Buffer<Double>.mapIndexed(block: DoubleField.(index: Int, arg: Double) -> Double): DoubleBuffer

mapIndexedToBuffer

inline fun <T, R> Buffer<T>.mapIndexedToBuffer(bufferFactory: BufferFactory<R>, crossinline block: (index: Int, value: T) -> R): Buffer<R>

Create a new buffer from this one with the given mapping (indexed) function. Provided bufferFactory is used to construct the new buffer.

mapToBuffer

inline fun <T, R> Buffer<T>.mapToBuffer(bufferFactory: BufferFactory<R>, crossinline block: (T) -> R): Buffer<R>

Create a new buffer from this one with the given mapping function. Provided bufferFactory is used to construct the new buffer.

minus

open operator override fun Point<Double>.minus(other: Point<Double>): DoubleBuffer

Vector subtraction

open operator override fun StructureND<Double>.minus(arg: Double): StructureND<Double>

open operator fun StructureND<Int>.minus(arg: Int): StructureND<Int>

open operator fun StructureND<Short>.minus(arg: Short): StructureND<Short>

Subtracts an element from ND structure of it.

open operator override fun StructureND<Double>.minus(arg: StructureND<Double>): DoubleBufferND

open operator override fun Buffer<Double>.minus(arg: Buffer<Double>): DoubleBuffer

open operator fun StructureND<Int>.minus(arg: StructureND<Int>): StructureND<Int>

open operator fun StructureND<Short>.minus(arg: StructureND<Short>): StructureND<Short>

Subtraction of two elements.

permute

fun <T> StructureND<T>.permute(permutation: (IntArray) -> IntArray): PermutedStructureND<T>

fun <T> MutableStructureND<T>.permute(newShape: ShapeND = shape, permutation: (IntArray) -> IntArray): PermutedMutableStructureND<T>

fun <T> Buffer<T>.permute(indices: IntArray): PermutedBuffer<T>

Created a permuted view of given buffer using provided indices

fun <T> MutableBuffer<T>.permute(indices: IntArray): PermutedMutableBuffer<T>

Created a permuted mutable view of given buffer using provided indices

plus

open operator override fun Point<Double>.plus(other: Point<Double>): DoubleBuffer

Vector sum

open operator override fun StructureND<Double>.plus(arg: Double): DoubleBufferND

open operator fun StructureND<Int>.plus(arg: Int): StructureND<Int>

open operator fun StructureND<Short>.plus(arg: Short): StructureND<Short>

Adds an ND structure to an element of it.

open operator override fun StructureND<Double>.plus(arg: StructureND<Double>): DoubleBufferND

open operator override fun Buffer<Double>.plus(arg: Buffer<Double>): DoubleBuffer

open operator fun StructureND<Int>.plus(arg: StructureND<Int>): StructureND<Int>

open operator fun StructureND<Short>.plus(arg: StructureND<Short>): StructureND<Short>

Addition of two elements.

pow

open infix fun StructureND<Double>.pow(pow: Number): StructureND<Double>

Raises this value to the power pow.

open infix fun Buffer<Double>.pow(pow: Number): Buffer<Double>

Raises this value to the power pow.

reduce

inline fun <T> Buffer<T>.reduce(operation: (left: T, value: T) -> T): T

Reduce a buffer from left to right according to operation

requireSorted

fun <T : Comparable<T>> Buffer<T>.requireSorted()

Checks that the Buffer is sorted (ascending) and throws IllegalArgumentException if it is not.

roll

fun <T> StructureND<T>.roll(axis: Int, step: Int = 1): StructureND<T>

fun <T> StructureND<T>.roll(pair: Pair<Int, Int>, vararg others: Pair<Int, Int>): StructureND<T>

set

@PerformancePitfall

open operator override fun set(index: IntArray, value: T)

Inserts an item at the specified indices.

abstract operator fun set(index: Int, value: T)

Sets the array element at the specified index to the specified value.

set

@PerformancePitfall

operator fun <T> MutableStructureND<T>.set(vararg index: Int, value: T)

Set value at specified indices

slice

fun <T> Buffer<T>.slice(range: IntRange): BufferView<T>

Zero-copy select a slice inside the original buffer

sorted

fun <V : Comparable<V>> Buffer<V>.sorted(): Buffer<V>

Create a zero-copy virtual buffer that contains the same elements but in ascending order

sortedBy

fun <V, C : Comparable<C>> Buffer<V>.sortedBy(selector: (V) -> C): Buffer<V>

sortedByDescending

fun <V, C : Comparable<C>> Buffer<V>.sortedByDescending(selector: (V) -> C): Buffer<V>

sortedDescending

fun <V : Comparable<V>> Buffer<V>.sortedDescending(): Buffer<V>

Create a zero-copy virtual buffer that contains the same elements but in descending order

times

open operator override fun Point<Double>.times(value: Double): DoubleBuffer

Multiplies a vector by its element.

open operator override fun StructureND<Double>.times(k: Number): DoubleBufferND

open operator fun Buffer<Double>.times(k: Number): Buffer<Double>

Multiplication of this element by a scalar.

open operator override fun StructureND<Double>.times(arg: StructureND<Double>): DoubleBufferND

open operator fun StructureND<Int>.times(arg: StructureND<Int>): StructureND<Int>

open operator fun StructureND<Short>.times(arg: StructureND<Short>): StructureND<Short>

open operator fun Buffer<Double>.times(arg: Buffer<Double>): Buffer<Double>

Multiplies this element by scalar.

open operator fun StructureND<Double>.times(arg: Double): StructureND<Double>

open operator fun StructureND<Int>.times(arg: Int): StructureND<Int>

open operator fun StructureND<Short>.times(arg: Short): StructureND<Short>

Multiplies an ND structure by an element of it.

toBufferND

open fun StructureND<Int>.toBufferND(): BufferND<Int>

open fun StructureND<Short>.toBufferND(): BufferND<Short>

open override fun StructureND<Double>.toBufferND(): DoubleBufferND

toByteArray

fun Buffer<Byte>.toByteArray(): ByteArray

Returns a new ByteArray containing all the elements of this Buffer.

toDoubleArray

fun Buffer<Double>.toDoubleArray(): DoubleArray

Returns a new DoubleArray containing all the elements of this Buffer.

toDoubleBuffer

fun Buffer<Double>.toDoubleBuffer(): DoubleBuffer

Represent this buffer as DoubleBuffer. Does not guarantee that changes in the original buffer are reflected on this buffer.

toFloatArray

fun Buffer<Float>.toFloatArray(): FloatArray

Returns a new FloatArray containing all the elements of this Buffer.

toIntArray

fun Buffer<Int>.toIntArray(): IntArray

Returns a new IntArray containing all the elements of this Buffer.

toList

fun <T> Buffer<T>.toList(): List<T>

Returns a new List containing all elements of this buffer.

toLongArray

fun Buffer<Long>.toLongArray(): LongArray

Returns a new LongArray containing all the elements of this Buffer.

toMutableList

@UnstableKMathAPI

fun <T> Buffer<T>.toMutableList(): MutableList<T>

Returns a new MutableList filled with all elements of this buffer. NOTE: this method uses a protective copy, so it should not be used in performance-critical code.

toShortArray

fun Buffer<Short>.toShortArray(): ShortArray

Returns a new ShortArray containing all the elements of this Buffer.

toTypedArray

@UnstableKMathAPI

inline fun <T> Buffer<T>.toTypedArray(): Array<T>

Returns a new Array containing all elements of this buffer. NOTE: this method uses a protective copy, so it should not be used in performance-critical code.

unaryMinus