Kubit/kubit.collections.list/DoubleList

DoubleList

@Serializable(with = DoubleListSerializer::class)

DoubleList is a List-like collection for Double values. It allows retrieving the elements without boxing. DoubleList is always backed by a MutableDoubleList, its MutableList-like subclass. The purpose of this class is to avoid the performance overhead of auto-boxing due to generics since Collection classes all operate on objects.

This implementation is not thread-safe: if multiple threads access this container concurrently, and one or more threads modify the structure of the list (insertion or removal for instance), the calling code must provide the appropriate synchronization. It is also not safe to mutate during reentrancy -- in the middle of a forEach, for example. However, concurrent reads are safe.

Inheritors

MutableDoubleList

Properties

indices

val indices: IntRange

Returns an IntRange of the valid indices for this DoubleList.

lastIndex

val lastIndex: Int

Returns the last valid index in the DoubleList. This can be -1 when the list is empty.

size

val size: Int

The number of elements in the DoubleList.

Functions

all

inline fun all(predicate: (element: Double) -> Boolean): Boolean

Returns true if all elements match the given predicate.

any

inline fun any(): Boolean

Returns true if there's at least one element in the collection.

inline fun any(predicate: (element: Double) -> Boolean): Boolean

Returns true if any of the elements give a true return value for predicate.

atLeast

inline fun atLeast(n: Int, predicate: (Double) -> Boolean): Boolean

Returns true if at least n elements in the list match the given predicate.

atMost

inline fun atMost(n: Int, predicate: (Double) -> Boolean): Boolean

Returns true if at most n elements in the list match the given predicate.

binarySearch

@JvmOverloads

fun binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size): Int

Searches this list the specified element in the range defined by fromIndex and toIndex. The list is expected to be sorted into ascending order according to the natural ordering of its elements, otherwise the result is undefined.

chunked

fun chunked(chunkSize: Int): List<DoubleList>

Splits this list into chunks of specified size.

chunkedInPlace

fun DoubleList.chunkedInPlace(chunkSize: Int): WindowedDoubleList

Splits this list into a list of InPlaceDoubleSubList each not exceeding the given chunkSize. The last list may have less elements than the given chunkSize.

contains

operator fun contains(element: Double): Boolean

Returns true if the DoubleList contains element or false otherwise.

containsAll

fun containsAll(elements: DoubleList): Boolean

Returns true if the DoubleList contains all elements in elements or false if one or more are missing.

copy

fun copy(): DoubleList

Returns a new list that is a copy of the current list.

count

inline fun count(): Int

Returns the number of elements in this list.

inline fun count(predicate: (element: Double) -> Boolean): Int

Counts the number of elements matching predicate.

distinct

fun distinct(): DoubleList

Returns a new list containing only distinct elements from the current list.

drop

fun drop(n: Int): DoubleList

Returns a new list containing all elements except first n elements.

dropLast

fun dropLast(n: Int): DoubleList

Returns a new list containing all elements except last n elements.

dropLastWhile

inline fun dropLastWhile(predicate: (Double) -> Boolean): DoubleList

Returns a new DoubleList containing all elements except the last elements that satisfy the given predicate.

dropWhile

inline fun dropWhile(predicate: (Double) -> Boolean): DoubleList

Returns a new list containing all elements except the first elements that satisfy the given predicate.

elementAt

fun elementAt(index: Int): Double

Returns the element at the given index or throws IndexOutOfBoundsException if the index is out of bounds of this collection.

elementAtOrElse

inline fun elementAtOrElse(index: Int, defaultValue: (index: Int) -> Double): Double

Returns the element at the given index or defaultValue if index is out of bounds of the collection.

equals

open operator override fun equals(other: Any?): Boolean

Returns true if other is a DoubleList and the contents of this and other are the same.

filter

inline fun filter(predicate: (Double) -> Boolean): DoubleList

Returns a list containing only elements matching the given predicate.

first

fun first(): Double

Returns the first element in the DoubleList or throws a NoSuchElementException if it isEmpty.

inline fun first(predicate: (element: Double) -> Boolean): Double

Returns the first element in the DoubleList for which predicate returns true or throws NoSuchElementException if nothing matches.

fold

inline fun <R> fold(initial: R, operation: (acc: R, element: Double) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the DoubleList in order.

foldIndexed

inline fun <R> foldIndexed(initial: R, operation: (index: Int, acc: R, element: Double) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the DoubleList in order.

foldRight

inline fun <R> foldRight(initial: R, operation: (element: Double, acc: R) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the DoubleList in reverse order.

foldRightIndexed

inline fun <R> foldRightIndexed(initial: R, operation: (index: Int, element: Double, acc: R) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the DoubleList in reverse order.

forEach

inline fun forEach(block: (element: Double) -> Unit)

Calls block for each element in the DoubleList, in order.

forEachChunk

inline fun DoubleList.forEachChunk(chunkSize: Int, action: (InPlaceDoubleSubList) -> Unit)

Iterates through the windowed chunks of this collection with given chunkSize, where window step is equals to chunkSize and calls action on each chunk.

forEachChunkIndexed

inline fun DoubleList.forEachChunkIndexed(chunkSize: Int, action: (index: Int, InPlaceDoubleSubList) -> Unit)

Iterates through the windowed chunks of this collection with given chunkSize, where window step is equals to chunkSize and calls action on each chunk with its index.

forEachIndexed

inline fun forEachIndexed(block: (index: Int, element: Double) -> Unit)

Calls block for each element in the DoubleList along with its index, in order.

forEachReversed

inline fun forEachReversed(block: (element: Double) -> Unit)

Calls block for each element in the DoubleList in reverse order.

forEachReversedIndexed

inline fun forEachReversedIndexed(block: (index: Int, element: Double) -> Unit)

Calls block for each element in the DoubleList along with its index, in reverse order.

forEachWindow

inline fun DoubleList.forEachWindow(windowSize: Int, step: Int = 1, partialWindows: Boolean = false, action: (InPlaceDoubleSubList) -> Unit)

Iterates through the windows of the list and performs the given action on each window.

forEachWindowIndexed

inline fun DoubleList.forEachWindowIndexed(windowSize: Int, step: Int = 1, partialWindows: Boolean = false, action: (index: Int, InPlaceDoubleSubList) -> Unit)

Iterates through the windows of the list with their indices and performs the given action on each window.

get

operator fun get(index: Int): Double

Returns the element at the given index or throws IndexOutOfBoundsException if the index is out of bounds of this collection.

hashCode

open override fun hashCode(): Int

Returns a hash code based on the contents of the DoubleList.

indexOf

fun indexOf(element: Double): Int

Returns the index of element in the DoubleList or -1 if element is not there.

indexOfFirst

inline fun indexOfFirst(predicate: (element: Double) -> Boolean): Int

Returns the index if the first element in the DoubleList for which predicate returns true.

indexOfLast

inline fun indexOfLast(predicate: (element: Double) -> Boolean): Int

Returns the index if the last element in the DoubleList for which predicate returns true.

isEmpty

inline fun isEmpty(): Boolean

Returns true if the DoubleList has no elements in it or false otherwise.

isNotEmpty

inline fun isNotEmpty(): Boolean

Returns true if there are elements in the DoubleList or false if it is empty.

joinToString

@JvmOverloads

fun joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "..."): String

Creates a String from the elements separated by separator and using prefix before and postfix after, if supplied.

@JvmOverloads

inline fun joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", crossinline transform: (Double) -> CharSequence): String

Creates a String from the elements separated by separator and using prefix before and postfix after, if supplied. transform dictates how each element will be represented.

last

fun last(): Double

Returns the last element in the DoubleList or throws a NoSuchElementException if it isEmpty.

inline fun last(predicate: (element: Double) -> Boolean): Double

Returns the last element in the DoubleList for which predicate returns true or throws NoSuchElementException if nothing matches.

lastIndexOf

fun lastIndexOf(element: Double): Int

Returns the index of the last element in the DoubleList that is the same as element or -1 if no elements match.

map

inline fun <R> DoubleList.map(transform: (Double) -> R): List<R>

Returns an List containing the results of applying the given transform function to each element in the original DoubleList.

inline fun DoubleList.map(transform: (Double) -> Double): DoubleList

Returns a DoubleList containing the results of applying the given transform function to each element in the original DoubleList.

inline fun DoubleList.map(transform: (Double) -> Float): FloatList

Returns a FloatList containing the results of applying the given transform function to each element in the original DoubleList.

inline fun DoubleList.map(transform: (Double) -> Int): IntList

Returns a IntList containing the results of applying the given transform function to each element in the original DoubleList.

inline fun DoubleList.map(transform: (Double) -> Long): LongList

Returns a LongList containing the results of applying the given transform function to each element in the original DoubleList.

mapIndexed

inline fun <R> DoubleList.mapIndexed(transform: (Int, Double) -> R): List<R>

Returns a List containing the results of applying the given transform function to each element and its index in the original DoubleList.

inline fun DoubleList.mapIndexed(transform: (Int, Double) -> Double): DoubleList

Returns a DoubleList containing the results of applying the given transform function to each element and its index in the original DoubleList.

inline fun DoubleList.mapIndexed(transform: (Int, Double) -> Float): FloatList

Returns a FloatList containing the results of applying the given transform function to each element and its index in the original DoubleList.

inline fun DoubleList.mapIndexed(transform: (Int, Double) -> Int): IntList

Returns a IntList containing the results of applying the given transform function to each element and its index in the original DoubleList.

inline fun DoubleList.mapIndexed(transform: (Int, Double) -> Long): LongList

Returns a LongList containing the results of applying the given transform function to each element and its index in the original DoubleList.

none

inline fun none(): Boolean

Returns true if the collection has no elements in it.

inline fun none(predicate: (element: Double) -> Boolean): Boolean

Returns true if none of the elements give a true return value for predicate.

orEmpty

fun DoubleList?.orEmpty(): DoubleList

Returns the DoubleList itself if it's not null; otherwise returns an empty DoubleList.

reversed

fun reversed(): DoubleList

Returns a new list with all elements in reversed order.

reversedAll

inline fun reversedAll(predicate: (element: Double) -> Boolean): Boolean

Returns true if all elements match the given predicate while iterating in the reverse order.

reversedAny

inline fun reversedAny(predicate: (element: Double) -> Boolean): Boolean

Returns true if any of the elements give a true return value for predicate while iterating in the reverse order.

sorted

fun sorted(): DoubleList

Returns a new list of all elements sorted according to natural sort order.

sortedDescending

fun sortedDescending(): DoubleList

Returns a new list of all elements sorted according to descending natural sort order.

sum

fun sum(): Double

Returns the sum of all elements in the list.

sumOf

inline fun sumOf(element: (Double) -> Double): Double

Returns the sum of all elements in the list after transforming them by the given element function.

take

fun take(n: Int): DoubleList

Returns a new list containing the first n elements of this list.

takeLast

fun takeLast(n: Int): DoubleList

Returns a new list containing the last n elements of this list.

takeLastWhile

inline fun takeLastWhile(predicate: (Double) -> Boolean): DoubleList

Returns a new DoubleList containing the last elements that satisfy the given predicate.

takeWhile

inline fun takeWhile(predicate: (Double) -> Boolean): DoubleList

Returns a new DoubleList containing the first elements that satisfy the given predicate.

toDoubleArray

fun toDoubleArray(): DoubleArray

Returns a DoubleArray containing all elements from this list in the same order.

toMutableSet

fun toMutableSet(): MutableSet<Double>

Return a MutableSet of all elements. The returned set does NOT guarantee the element iteration order of the list.

toSet

fun toSet(): Set<Double>

Return a Set of all elements. The returned set does NOT guarantee the element iteration order of the list.

toString

open override fun toString(): String

Returns a String representation of the list, surrounded by "[]" and each element separated by ", ".

windowedInPlace

fun DoubleList.windowedInPlace(windowSize: Int, step: Int = 1, partialWindows: Boolean = false): WindowedDoubleList

Returns a WindowedDoubleList with the given windowSize sliding by step. Each window is a view into the original list.