core/org.jetbrains.kotlinx.dataframe.math

Package-level declarations

Types

internal data class BasicStats(val count: Int, val mean: Double, val variance: Double)

internal data class IndexedComparable<T : Comparable<T>>(val index: Int, val value: T) : Comparable<IndexedComparable<T>>

QuantileEstimationMethod

internal sealed interface QuantileEstimationMethod<Value : Comparable<Value>, Index : Number>

Inspired by Hyndman and Fan (1996) Sample Quantiles in Statistical Packages. The American Statistician, 50, 361-365. DOI:10.1080/00031305.1996.10473566

Properties

cumSumTypeConversion

val cumSumTypeConversion: CalculateReturnType

Double(?) -> Double Float(?) -> Float Short(?), Byte(?) -> Int(?) T : Number(?) -> T(?)

maxTypeConversion

internal val maxTypeConversion: CalculateReturnType

T: Comparable -> T(?)

meanTypeConversion

internal val meanTypeConversion: CalculateReturnType

T: Number? -> Double

medianConversion

internal val medianConversion: CalculateReturnType

Primitive Number -> Double? T : Comparable -> T?

minTypeConversion

internal val minTypeConversion: CalculateReturnType

T: Comparable -> T(?)

percentileConversion

internal val percentileConversion: CalculateReturnType

stdTypeConversion

internal val stdTypeConversion: CalculateReturnType

T: Number? -> Double

sumTypeConversion

internal val sumTypeConversion: CalculateReturnType

T: Number -> T Byte -> Int Short -> Int Nothing -> Double

Functions

calculateBasicStatsOrNull

internal fun Sequence<Double>.calculateBasicStatsOrNull(skipNaN: Boolean = skipNaNDefault): BasicStats?

Creates BasicStats instance for this sequence.

cast

internal fun <T : Comparable<T>> QuantileEstimationMethod.Selecting.cast(): QuantileEstimationMethod<T, Int>

cumSumImpl

@JvmName(name = "byteCumsum")

internal fun DataColumn<Byte>.cumSumImpl(): DataColumn<Int>

@JvmName(name = "intCumsum")

internal fun DataColumn<Int>.cumSumImpl(): DataColumn<Int>

@JvmName(name = "longCumsum")

internal fun DataColumn<Long>.cumSumImpl(): DataColumn<Long>

@JvmName(name = "shortCumsum")

internal fun DataColumn<Short>.cumSumImpl(): DataColumn<Int>

@JvmName(name = "cumsumByteNullable")

internal fun DataColumn<Byte?>.cumSumImpl(skipNA: Boolean): DataColumn<Int?>

@JvmName(name = "cumsumDoubleNullable")

internal fun DataColumn<Double?>.cumSumImpl(skipNA: Boolean): DataColumn<Double>

@JvmName(name = "doubleCumsum")

internal fun DataColumn<Double>.cumSumImpl(skipNA: Boolean): DataColumn<Double>

internal fun DataColumn<Float?>.cumSumImpl(skipNA: Boolean): DataColumn<Float>

@JvmName(name = "floatCumsum")

internal fun DataColumn<Float>.cumSumImpl(skipNA: Boolean): DataColumn<Float>

@JvmName(name = "intCumsum")

internal fun DataColumn<Int?>.cumSumImpl(skipNA: Boolean): DataColumn<Int?>

@JvmName(name = "cumsumLongNullable")

internal fun DataColumn<Long?>.cumSumImpl(skipNA: Boolean): DataColumn<Long?>

@JvmName(name = "cumsumShortNullable")

internal fun DataColumn<Short?>.cumSumImpl(skipNA: Boolean): DataColumn<Int?>

internal fun DataColumn<Number?>.cumSumImpl(type: KType, skipNA: Boolean): DataColumn<Number?>

indexOfMax

internal fun <C : Comparable<C>> Sequence<C?>.indexOfMax(type: KType, skipNaN: Boolean): Int

indexOfMedian

internal fun <T : Comparable<T & Any>?> Sequence<T>.indexOfMedian(type: KType, skipNaN: Boolean): Int

Returns the index of the median in the comparable input:

indexOfMin

internal fun <C : Comparable<C>> Sequence<C?>.indexOfMin(type: KType, skipNaN: Boolean): Int

indexOfPercentile

internal fun <T : Comparable<T & Any>?> Sequence<T>.indexOfPercentile(percentile: Double, type: KType, skipNaN: Boolean): Int

Returns the index of the percentile in the unsorted sequence this. If !skipNaN and the sequence this contains NaN, the index of the first NaN will be returned. Returns -1 if the sequence is empty.

indexOfQuantile

internal fun <IndexType : Number> QuantileEstimationMethod<*, IndexType>.indexOfQuantile(p: Double, count: Int): IndexType

maxOrNull

@PublishedApi

internal fun <T : Comparable<T>> Sequence<T>.maxOrNull(type: KType, skipNaN: Boolean): T?

mean

internal fun Sequence<Double>.mean(skipNaN: Boolean = skipNaNDefault): Double

internal fun <T : Number> Sequence<T>.mean(type: KType, skipNaN: Boolean): Double

medianOrNull

@PublishedApi

internal fun <T : Comparable<T>> Sequence<T>.medianOrNull(type: KType, skipNaN: Boolean): Any?

Returns the median of the comparable input:

minOrNull

@PublishedApi

internal fun <T : Comparable<T>> Sequence<T>.minOrNull(type: KType, skipNaN: Boolean): T?

percentileOrNull

internal fun <T : Comparable<T>> Sequence<T>.percentileOrNull(percentile: Double, type: KType, skipNaN: Boolean): Any?

Uses QuantileEstimationMethod.R8 for primitive numbers, else QuantileEstimationMethod.R3

quantile

internal fun <T : Comparable<T>> QuantileEstimationMethod.Selecting.quantile(p: Double, values: List<T>): T

quantileIndex

internal fun <T : Comparable<T & Any>?> Sequence<T>.quantileIndex(p: Double, type: KType, skipNaN: Boolean, method: QuantileEstimationMethod.Selecting, name: String = "quantile"): Int

Returns the index of the p-quantile in the unsorted sequence this, selected using method.

quantileOrNull

internal fun <T : Comparable<T>> Sequence<Any>.quantileOrNull(p: Double, type: KType, skipNaN: Boolean, method: QuantileEstimationMethod<T, *>, name: String = "quantile"): Any?

Returns the p-quantile: the k'th q-quantile, where p = k/q.

quickSelect

@PublishedApi

internal fun <T : Comparable<T>> List<T>.quickSelect(k: Int): T

Select the k't "smallest" element from list this

std

internal fun BasicStats.std(ddof: Int): Double

Calculates the standard deviation from a BasicStats with optional delta degrees of freedom.

@JvmName(name = "doubleStd")

internal fun Sequence<Double>.std(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): Double

@PublishedApi

internal fun <T : Number> Sequence<T?>.std(type: KType, skipNaN: Boolean, ddof: Int): Double

Calculates the standard deviation from this with optional delta degrees of freedom.

sum

@JvmName(name = "sumNullableT")

@PublishedApi

internal fun Sequence<Number?>.sum(type: KType, skipNaN: Boolean): Number