Add statistics on DataFrame support (#1153)

* Add mean and standard deviation functions Compiler Plugin support for DataFrame

* Add aggregation functions: min, max, median, and percentile

Implemented new functions for calculating min, max, median, and percentile on DataFrames. Added corresponding tests to ensure proper functionality across different scenarios and ensured refinements with annotations like `@Refine` and `@Interpretable`.

* Finished support for min/max/median

* Refactor percentile handling for specific column scenarios

Replace `percentileArg` with a fixed value of 30.0 in test cases to ensure clearer functionality demonstration. Add `Arguments.percentile` with `ignore()` for improved handling and schema modification alignment in `Percentile0` and `Percentile1` classes.

* Refactor schema generation in statistical operations.

Replaced schema construction to include only newly generated columns instead of merging with existing ones. Updated test cases to validate schema consistency using `compareSchemas`.

* Fix linter and GroupBy ops

* Api Dump

* Fix reivew

Author: zaleslaw

core/api/core.api

@@ -5681,7 +5681,11 @@ public abstract interface class org/jetbrains/kotlinx/dataframe/impl/aggregation
 
 public final class org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators {
 	public static final field INSTANCE Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators;
+	public final fun getMax ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch1;
 	public final fun getMean ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch1;
+	public final fun getMedian ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch1;
+	public final fun getMin ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch1;
+	public final fun getPercentile ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch2;
 	public final fun getStd ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch2;
 	public final fun getSum ()Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch1;
 	public final fun max (Z)Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator;

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

@@ -73,10 +73,13 @@ public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(skipNaN: Boolean =
 // endregion
 
 // region DataFrame
-
+@Refine
+@Interpretable("Max0")
 public fun <T> DataFrame<T>.max(skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     maxFor(skipNaN, intraComparableColumns())
 
+@Refine
+@Interpretable("Max1")
 public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,

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

@@ -60,10 +60,13 @@ public inline fun <reified T : Number> AnyRow.rowMeanOf(skipNaN: Boolean = skipN
 // endregion
 
 // region DataFrame
-
+@Refine
+@Interpretable("Mean0")
 public fun <T> DataFrame<T>.mean(skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     meanFor(skipNaN, primitiveOrMixedNumberColumns())
 
+@Refine
+@Interpretable("Mean1")
 public fun <T, C : Number?> DataFrame<T>.meanFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,

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

@@ -130,10 +130,13 @@ public inline fun <reified T> AnyRow.rowMedianOf(
 // endregion
 
 // region DataFrame
-
+@Refine
+@Interpretable("Median0")
 public fun <T> DataFrame<T>.median(skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     medianFor(skipNaN, intraComparableColumns())
 
+@Refine
+@Interpretable("Median1")
 public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,

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

@@ -73,10 +73,13 @@ public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(skipNaN: Boolean =
 // endregion
 
 // region DataFrame
-
+@Refine
+@Interpretable("Min0")
 public fun <T> DataFrame<T>.min(skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     minFor(skipNaN, intraComparableColumns())
 
+@Refine
+@Interpretable("Min1")
 public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,

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

@@ -144,10 +144,13 @@ public inline fun <reified T> AnyRow.rowPercentileOf(
 // endregion
 
 // region DataFrame
-
+@Refine
+@Interpretable("Percentile0")
 public fun <T> DataFrame<T>.percentile(percentile: Double, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     percentileFor(percentile, skipNaN, intraComparableColumns())
 
+@Refine
+@Interpretable("Percentile1")
 public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileFor(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,

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

@@ -65,10 +65,13 @@ public inline fun <reified T : Number?> AnyRow.rowStdOf(
 // endregion
 
 // region DataFrame
-
+@Refine
+@Interpretable("Std0")
 public fun <T> DataFrame<T>.std(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataRow<T> =
     stdFor(skipNaN, ddof, primitiveOrMixedNumberColumns())
 
+@Refine
+@Interpretable("Std1")
 public fun <T, C : Number?> DataFrame<T>.stdFor(
     skipNaN: Boolean = skipNaNDefault,
     ddof: Int = ddofDefault,

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

@@ -113,25 +113,27 @@ public object Aggregators {
     // T : Comparable<T & Any>? -> T?
     public fun <T : Comparable<T & Any>?> min(skipNaN: Boolean): Aggregator<T & Any, T?> = min.invoke(skipNaN).cast2()
 
-    private val min by withOneOption { skipNaN: Boolean ->
-        twoStepSelectingForAny<Comparable<Any>, Comparable<Any>?>(
-            getReturnType = minTypeConversion,
-            stepOneSelector = { type -> minOrNull(type, skipNaN) },
-            indexOfResult = { type -> indexOfMin(type, skipNaN) },
-        )
-    }
+    public val min: AggregatorOptionSwitch1<Boolean, Comparable<Any>, Comparable<Any>?>
+        by withOneOption { skipNaN: Boolean ->
+            twoStepSelectingForAny<Comparable<Any>, Comparable<Any>?>(
+                getReturnType = minTypeConversion,
+                stepOneSelector = { type -> minOrNull(type, skipNaN) },
+                indexOfResult = { type -> indexOfMin(type, skipNaN) },
+            )
+        }
 
     // T: Comparable<T> -> T?
     // T : Comparable<T & Any>? -> T?
     public fun <T : Comparable<T & Any>?> max(skipNaN: Boolean): Aggregator<T & Any, T?> = max.invoke(skipNaN).cast2()
 
-    private val max by withOneOption { skipNaN: Boolean ->
-        twoStepSelectingForAny<Comparable<Any>, Comparable<Any>?>(
-            getReturnType = maxTypeConversion,
-            stepOneSelector = { type -> maxOrNull(type, skipNaN) },
-            indexOfResult = { type -> indexOfMax(type, skipNaN) },
-        )
-    }
+    public val max: AggregatorOptionSwitch1<Boolean, Comparable<Any>, Comparable<Any>?>
+        by withOneOption { skipNaN: Boolean ->
+            twoStepSelectingForAny<Comparable<Any>, Comparable<Any>?>(
+                getReturnType = maxTypeConversion,
+                stepOneSelector = { type -> maxOrNull(type, skipNaN) },
+                indexOfResult = { type -> indexOfMax(type, skipNaN) },
+            )
+        }
 
     // T: Number? -> Double
     public val std: AggregatorOptionSwitch2<Boolean, Int, Number, Double> by withTwoOptions {
@@ -151,23 +153,23 @@ public object Aggregators {
         }
     }
 
-    // T : primitive Number? -> Double?
-    // T : Comparable<T & Any>? -> T?
+    // T: primitive Number? -> Double?
+    // T: Comparable<T & Any>? -> T?
     public fun <T> percentileCommon(
         percentile: Double,
         skipNaN: Boolean,
     ): Aggregator<T & Any, T?>
         where T : Comparable<T & Any>? =
         this.percentile.invoke(percentile, skipNaN).cast2()
 
-    // T : Comparable<T & Any>? -> T?
+    // T: Comparable<T & Any>? -> T?
     public fun <T> percentileComparables(
         percentile: Double,
     ): Aggregator<T & Any, T?>
         where T : Comparable<T & Any>? =
         percentileCommon<T>(percentile, skipNaNDefault).cast2()
 
-    // T : primitive Number? -> Double?
+    // T: primitive Number? -> Double?
     public fun <T> percentileNumbers(
         percentile: Double,
         skipNaN: Boolean,
@@ -176,40 +178,45 @@ public object Aggregators {
         percentileCommon<T>(percentile, skipNaN).cast2()
 
     @Suppress("UNCHECKED_CAST")
-    private val percentile by withTwoOptions { percentile: Double, skipNaN: Boolean ->
-        flattenHybridForAny<Comparable<Any>, Comparable<Any>?>(
-            getReturnType = percentileConversion,
-            reducer = { type -> percentileOrNull(percentile, type, skipNaN) as Comparable<Any>? },
-            indexOfResult = { type -> indexOfPercentile(percentile, type, skipNaN) },
-        )
-    }
+    public val percentile: AggregatorOptionSwitch2<Double, Boolean, Comparable<Any>, Comparable<Any>?>
+        by withTwoOptions {
+            percentile: Double,
+            skipNaN: Boolean,
+            ->
+            flattenHybridForAny<Comparable<Any>, Comparable<Any>?>(
+                getReturnType = percentileConversion,
+                reducer = { type -> percentileOrNull(percentile, type, skipNaN) as Comparable<Any>? },
+                indexOfResult = { type -> indexOfPercentile(percentile, type, skipNaN) },
+            )
+        }
 
-    // T : primitive Number? -> Double?
-    // T : Comparable<T & Any>? -> T?
+    // T: primitive Number? -> Double?
+    // T: Comparable<T & Any>? -> T?
     public fun <T> medianCommon(skipNaN: Boolean): Aggregator<T & Any, T?>
         where T : Comparable<T & Any>? =
         median.invoke(skipNaN).cast2()
 
-    // T : Comparable<T & Any>? -> T?
+    // T: Comparable<T & Any>? -> T?
     public fun <T> medianComparables(): Aggregator<T & Any, T?>
         where T : Comparable<T & Any>? =
         medianCommon<T>(skipNaNDefault).cast2()
 
-    // T : primitive Number? -> Double?
+    // T: primitive Number? -> Double?
     public fun <T> medianNumbers(
         skipNaN: Boolean,
     ): Aggregator<T & Any, Double?>
         where T : Comparable<T & Any>?, T : Number? =
         medianCommon<T>(skipNaN).cast2()
 
     @Suppress("UNCHECKED_CAST")
-    private val median by withOneOption { skipNaN: Boolean ->
-        flattenHybridForAny<Comparable<Any>, Comparable<Any>?>(
-            getReturnType = medianConversion,
-            reducer = { type -> medianOrNull(type, skipNaN) as Comparable<Any>? },
-            indexOfResult = { type -> indexOfMedian(type, skipNaN) },
-        )
-    }
+    public val median: AggregatorOptionSwitch1<Boolean, Comparable<Any>, Comparable<Any>?>
+        by withOneOption { skipNaN: Boolean ->
+            flattenHybridForAny<Comparable<Any>, Comparable<Any>?>(
+                getReturnType = medianConversion,
+                reducer = { type -> medianOrNull(type, skipNaN) as Comparable<Any>? },
+                indexOfResult = { type -> indexOfMedian(type, skipNaN) },
+            )
+        }
 
     // T: Number -> T
     // Byte -> Int