overhauling median

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt

@@ -36,12 +36,12 @@ public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(skipNaN: Boolean = skipN
 
 public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
-    noinline selector: (T) -> R,
+    crossinline selector: (T) -> R,
 ): T & Any = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
 
 public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
-    noinline selector: (T) -> R,
+    crossinline selector: (T) -> R,
 ): T? = Aggregators.max<R>(skipNaN).aggregateByOrNull(this, selector)
 
 public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt

@@ -36,12 +36,12 @@ public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(skipNaN: Boolean = skipN
 
 public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
-    noinline selector: (T) -> R,
+    crossinline selector: (T) -> R,
 ): T & Any = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
 
 public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
-    noinline selector: (T) -> R,
+    crossinline selector: (T) -> R,
 ): T? = Aggregators.min<R>(skipNaN).aggregateByOrNull(this, selector)
 
 public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
 import org.jetbrains.kotlinx.dataframe.math.percentile
 import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
 
 // region DataColumn
 
@@ -52,7 +53,7 @@ public fun AnyRow.rowPercentile(percentile: Double): Any =
     rowPercentileOrNull(percentile).suggestIfNull("rowPercentile")
 
 public inline fun <reified T : Comparable<T>> AnyRow.rowPercentileOfOrNull(percentile: Double): T? =
-    valuesOf<T>().percentile(percentile)
+    valuesOf<T>().percentile(percentile, typeOf<T>())
 
 public inline fun <reified T : Comparable<T>> AnyRow.rowPercentileOf(percentile: Double): T =
     rowPercentileOfOrNull<T>(percentile).suggestIfNull("rowPercentileOf")

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt

@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
 
-import org.jetbrains.kotlinx.dataframe.api.skipNaN_default
+import org.jetbrains.kotlinx.dataframe.api.skipNaNDefault
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.aggregationHandlers.ReducingAggregationHandler
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.aggregationHandlers.SelectingAggregationHandler
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.inputHandlers.AnyInputHandler
@@ -153,13 +153,23 @@ internal object Aggregators {
         }
     }
 
-    fun <T> median(): Aggregator<T & Any, T?>
+    // T : primitive Number? -> Double
+    // T : Comparable<T & Any>? -> T?
+    fun <T> medianCommon(skipNaN: Boolean): Aggregator<T & Any, T?>
+        where T : Comparable<T & Any>? =
+        median.invoke(skipNaN).cast2()
+
+    // T : Comparable<T & Any>? -> T?
+    fun <T> medianComparables(): Aggregator<T & Any, T?>
         where T : Comparable<T & Any>? =
-        median.invoke(skipNaN_default).cast2()
+        medianCommon<T>(skipNaNDefault).cast2()
 
-    fun <T> median(skipNaN: Boolean): Aggregator<T & Any, Double>
+    // T : primitive Number? -> Double
+    fun <T> medianNumbers(
+        skipNaN: Boolean,
+    ): Aggregator<T & Any, Double>
         where T : Comparable<T & Any>?, T : Number? =
-        median.invoke(skipNaN).cast2()
+        medianCommon<T>(skipNaN).cast2()
 
     // T: Comparable<T>? -> T
     @Suppress("UNCHECKED_CAST")

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt

@@ -17,9 +17,17 @@ internal inline fun <T> Aggregatable<T>.remainingColumns(
     crossinline predicate: (AnyCol) -> Boolean,
 ): ColumnsSelector<T, Any?> = remainingColumnsSelector().filter { predicate(it.data) }
 
+/**
+ * Emulates selecting all columns whose values are comparable to each other.
+ * These are columns of type `R` where `R : Comparable<R>`.
+ *
+ * There is no way to denote this generically in types, however,
+ * hence the _fake_ type `Comparable<Any>` is used.
+ * (`Comparable<Nothing>` would be more correct, but then the compiler complains)
+ */
 @Suppress("UNCHECKED_CAST")
-internal fun <T> Aggregatable<T>.intraComparableColumns(): ColumnsSelector<T, Comparable<Any?>> =
-    remainingColumns { it.valuesAreComparable() } as ColumnsSelector<T, Comparable<Any?>>
+internal fun <T> Aggregatable<T>.intraComparableColumns(): ColumnsSelector<T, Comparable<Any>?> =
+    remainingColumns { it.valuesAreComparable() } as ColumnsSelector<T, Comparable<Any>?>
 
 @Suppress("UNCHECKED_CAST")
 internal fun <T> Aggregatable<T>.numberColumns(): ColumnsSelector<T, Number?> =

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt

@@ -8,8 +8,10 @@ import org.jetbrains.kotlinx.dataframe.api.groupBy
 import org.jetbrains.kotlinx.dataframe.api.mapToColumn
 import org.jetbrains.kotlinx.dataframe.api.median
 import org.jetbrains.kotlinx.dataframe.api.medianOf
-import org.jetbrains.kotlinx.dataframe.api.rowMedian
+import org.jetbrains.kotlinx.dataframe.api.rowMedianOf
+import org.jetbrains.kotlinx.dataframe.statistics.myFun
 import org.junit.Test
+import kotlin.experimental.ExperimentalTypeInference
 import kotlin.reflect.typeOf
 
 @Suppress("ktlint:standard:argument-list-wrapping")
@@ -36,12 +38,19 @@ class MedianTests {
 
     @Test
     fun `median of two columns`() {
-        val df = dataFrameOf("a", "b")(
-            1, 4,
-            2, 6,
-            7, 7,
+        val df = dataFrameOf("a", "b", "c")(
+            1, 4, "a",
+            2, 6, "b",
+            7, 7, "c",
         )
-        df.median("a", "b") shouldBe 5
+        df.median("a", "b") shouldBe 5.0
+        df.median { "a"<Int>() and "b"<Int>() } shouldBe 5.0
+        df.median("c") shouldBe "b"
+
+        df.median { "c"<String>() } shouldBe "b"
+
+        df.median({ "c"<String>() }) shouldBe "b"
+        df.median<_, String> { "c"<String>() } shouldBe "b"
     }
 
     @Test
@@ -51,6 +60,34 @@ class MedianTests {
             2, 4,
             7, 7,
         )
-        df.mapToColumn("", Infer.Type) { it.rowMedian() } shouldBe columnOf(2, 3, 7)
+        df.mapToColumn("", Infer.Type) { it.rowMedianOf<Int>() } shouldBe columnOf(2, 3, 7)
     }
 }
+
+fun <T> List<T>.myFun(): Int where T : Comparable<T> = TODO()
+fun <T> List<T>.myFun(): Double where T : Comparable<T>, T : Number = TODO()
+
+fun <T> myFun(list: List<T>): Int where T : Comparable<T> = TODO()
+fun <T> myFun(list: List<T>): Double where T : Comparable<T>, T : Number = TODO()
+
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
+//@JvmName("jnkjsdnf")
+fun <T> myFun(get : () -> T): Int where T : Comparable<T> = TODO()
+
+@JvmName("jnkjsdnf")
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
+fun <T> myFun(get : () -> T): Double where T : Comparable<T>, T : Number = TODO()
+
+fun main() {
+val res1 = listOf(1, 2, 3).myFun()
+val res2 = listOf("a", "b", "c").myFun()
+
+val res3 = myFun(listOf(1, 2, 3))
+val res4 = myFun(listOf("a", "b", "c"))
+
+val res5 = myFun { 1 }
+val res6 = myFun { "" }
+val res7 = myFun<String> { "" }
+}