Automated commit of generated code

Author: github-actions[bot]

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt

@@ -7,7 +7,9 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
-import org.jetbrains.kotlinx.dataframe.impl.primitiveNumberTypes
+import org.jetbrains.kotlinx.dataframe.impl.isMixedNumber
+import org.jetbrains.kotlinx.dataframe.impl.isPrimitiveNumber
+import org.jetbrains.kotlinx.dataframe.impl.isPrimitiveOrMixedNumber
 import org.jetbrains.kotlinx.dataframe.type
 import org.jetbrains.kotlinx.dataframe.typeClass
 import org.jetbrains.kotlinx.dataframe.util.IS_COMPARABLE
@@ -48,11 +50,23 @@ public inline fun <reified T> AnyCol.isType(): Boolean = type() == typeOf<T>()
 /** Returns `true` when this column's type is a subtype of `Number?` */
 public fun AnyCol.isNumber(): Boolean = isSubtypeOf<Number?>()
 
+/** Returns `true` only when this column's type is exactly `Number` or `Number?`. */
+public fun AnyCol.isMixedNumber(): Boolean = type().isMixedNumber()
+
 /**
  * Returns `true` when this column has the (nullable) type of either:
  * [Byte], [Short], [Int], [Long], [Float], or [Double].
  */
-public fun AnyCol.isPrimitiveNumber(): Boolean = type().withNullability(false) in primitiveNumberTypes
+public fun AnyCol.isPrimitiveNumber(): Boolean = type().isPrimitiveNumber()
+
+/**
+ * Returns `true` when this column has the (nullable) type of either:
+ * [Byte], [Short], [Int], [Long], [Float], [Double], or [Number].
+ *
+ * Careful: Will return `true` if the column contains multiple number types that
+ * might NOT be primitive.
+ */
+public fun AnyCol.isPrimitiveOrMixedNumber(): Boolean = type().isPrimitiveOrMixedNumber()
 
 public fun AnyCol.isList(): Boolean = typeClass == List::class
 

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

@@ -18,17 +18,15 @@ import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfRow
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.primitiveNumberColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.primitiveOrMixedNumberColumns
 import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
-import org.jetbrains.kotlinx.dataframe.impl.primitiveNumberTypes
+import org.jetbrains.kotlinx.dataframe.impl.isPrimitiveOrMixedNumber
 import kotlin.reflect.KProperty
-import kotlin.reflect.full.withNullability
 import kotlin.reflect.typeOf
 
-/*
- * TODO KDocs:
+/* TODO KDocs:
  * Calculating the mean is supported for all primitive number types.
- * Nulls are filtered from columns.
+ * Nulls are filtered out.
  * The return type is always Double, Double.NaN for empty input, never null.
  * (May introduce loss of precision for Longs).
  * For mixed primitive number types, [TwoStepNumbersAggregator] unifies the numbers before calculating the mean.
@@ -48,24 +46,21 @@ public inline fun <T, reified R : Number> DataColumn<T>.meanOf(
 // region DataRow
 
 public fun AnyRow.rowMean(skipNA: Boolean = skipNA_default): Double =
-    Aggregators.mean(skipNA).aggregateOfRow(this) {
-        colsOf<Number?> { it.isPrimitiveNumber() }
-    }
+    Aggregators.mean(skipNA).aggregateOfRow(this, primitiveOrMixedNumberColumns())
 
 public inline fun <reified T : Number?> AnyRow.rowMeanOf(skipNA: Boolean = skipNA_default): Double {
-    require(typeOf<T>().withNullability(false) in primitiveNumberTypes) {
+    require(typeOf<T>().isPrimitiveOrMixedNumber()) {
         "Type ${T::class.simpleName} is not a primitive number type. Mean only supports primitive number types."
     }
-    return Aggregators.mean(skipNA)
-        .aggregateOfRow(this) { colsOf<T>() }
+    return Aggregators.mean(skipNA).aggregateOfRow(this) { colsOf<T>() }
 }
 
 // endregion
 
 // region DataFrame
 
 public fun <T> DataFrame<T>.mean(skipNA: Boolean = skipNA_default): DataRow<T> =
-    meanFor(skipNA, primitiveNumberColumns())
+    meanFor(skipNA, primitiveOrMixedNumberColumns())
 
 public fun <T, C : Number> DataFrame<T>.meanFor(
     skipNA: Boolean = skipNA_default,
@@ -116,7 +111,7 @@ public inline fun <T, reified D : Number> DataFrame<T>.meanOf(
 @Refine
 @Interpretable("GroupByMean1")
 public fun <T> Grouped<T>.mean(skipNA: Boolean = skipNA_default): DataFrame<T> =
-    meanFor(skipNA, primitiveNumberColumns())
+    meanFor(skipNA, primitiveOrMixedNumberColumns())
 
 @Refine
 @Interpretable("GroupByMean0")
@@ -181,7 +176,7 @@ public inline fun <T, reified R : Number> Grouped<T>.meanOf(
 // region Pivot
 
 public fun <T> Pivot<T>.mean(skipNA: Boolean = skipNA_default, separate: Boolean = false): DataRow<T> =
-    meanFor(skipNA, separate, primitiveNumberColumns())
+    meanFor(skipNA, separate, primitiveOrMixedNumberColumns())
 
 public fun <T, C : Number> Pivot<T>.meanFor(
     skipNA: Boolean = skipNA_default,
@@ -224,7 +219,7 @@ public inline fun <T, reified R : Number> Pivot<T>.meanOf(
 // region PivotGroupBy
 
 public fun <T> PivotGroupBy<T>.mean(separate: Boolean = false, skipNA: Boolean = skipNA_default): DataFrame<T> =
-    meanFor(skipNA, separate, primitiveNumberColumns())
+    meanFor(skipNA, separate, primitiveOrMixedNumberColumns())
 
 public fun <T, C : Number> PivotGroupBy<T>.meanFor(
     skipNA: Boolean = skipNA_default,

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt

@@ -1,3 +1,6 @@
+@file:OptIn(ExperimentalTypeInference::class)
+@file:Suppress("LocalVariableName")
+
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyRow
@@ -13,50 +16,97 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.columns.toColumnsSetOf
-import org.jetbrains.kotlinx.dataframe.columns.values
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfRow
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.primitiveOrMixedNumberColumns
 import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
-import org.jetbrains.kotlinx.dataframe.impl.zero
-import org.jetbrains.kotlinx.dataframe.math.sum
-import org.jetbrains.kotlinx.dataframe.math.sumOf
+import org.jetbrains.kotlinx.dataframe.impl.isPrimitiveOrMixedNumber
+import kotlin.experimental.ExperimentalTypeInference
+import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
-import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
+/* TODO KDocs
+ * Calculating the sum is supported for all primitive number types.
+ * Nulls are filtered out.
+ * The return type is always the same as the input type (never null), except for `Byte` and `Short`,
+ * which are converted to `Int`.
+ * Empty input will result in 0 in the supplied number type.
+ * For mixed primitive number types, [TwoStepNumbersAggregator] unifies the numbers before calculating the sum.
+ */
+
 // region DataColumn
 
-@JvmName("sumT")
-public fun <T : Number> DataColumn<T>.sum(): T = values.sum(type())
+@JvmName("sumShort")
+public fun DataColumn<Short?>.sum(): Int = Aggregators.sum.aggregate(this) as Int
+
+@JvmName("sumByte")
+public fun DataColumn<Byte?>.sum(): Int = Aggregators.sum.aggregate(this) as Int
 
-@JvmName("sumTNullable")
-public fun <T : Number> DataColumn<T?>.sum(): T = values.sum(type())
+@Suppress("UNCHECKED_CAST")
+@JvmName("sumNumber")
+public fun <T : Number> DataColumn<T?>.sum(): T = Aggregators.sum.aggregate(this) as T
 
-public inline fun <T, reified R : Number> DataColumn<T>.sumOf(noinline expression: (T) -> R): R? =
-    (Aggregators.sum as Aggregator<*, *>).cast<R>().aggregateOf(this, expression)
+@JvmName("sumOfShort")
+@OverloadResolutionByLambdaReturnType
+public fun <C> DataColumn<C>.sumOf(expression: (C) -> Short?): Int =
+    Aggregators.sum.aggregateOf(this, expression) as Int
+
+@JvmName("sumOfByte")
+@OverloadResolutionByLambdaReturnType
+public fun <C> DataColumn<C>.sumOf(expression: (C) -> Byte?): Int = Aggregators.sum.aggregateOf(this, expression) as Int
+
+@JvmName("sumOfNumber")
+@OverloadResolutionByLambdaReturnType
+public inline fun <C, reified V : Number> DataColumn<C>.sumOf(crossinline expression: (C) -> V?): V =
+    Aggregators.sum.aggregateOf(this, expression) as V
 
 // endregion
 
 // region DataRow
 
-public fun AnyRow.rowSum(): Number =
-    Aggregators.sum.aggregateCalculatingType(
-        values = values().filterIsInstance<Number>(),
-        valueTypes = columnTypes().filter { it.isSubtypeOf(typeOf<Number?>()) }.toSet(),
-    ) ?: 0
+public fun AnyRow.rowSum(): Number = Aggregators.sum.aggregateOfRow(this, primitiveOrMixedNumberColumns())
+
+@JvmName("rowSumOfShort")
+public inline fun <reified T : Short?> AnyRow.rowSumOf(_kClass: KClass<Short> = Short::class): Int =
+    rowSumOf(typeOf<T>()) as Int
 
-public inline fun <reified T : Number> AnyRow.rowSumOf(): T = values().filterIsInstance<T>().sum(typeOf<T>())
+@JvmName("rowSumOfByte")
+public inline fun <reified T : Byte?> AnyRow.rowSumOf(_kClass: KClass<Byte> = Byte::class): Int =
+    rowSumOf(typeOf<T>()) as Int
 
+@JvmName("rowSumOfInt")
+public inline fun <reified T : Int?> AnyRow.rowSumOf(_kClass: KClass<Int> = Int::class): Int =
+    rowSumOf(typeOf<T>()) as Int
+
+@JvmName("rowSumOfLong")
+public inline fun <reified T : Long?> AnyRow.rowSumOf(_kClass: KClass<Long> = Long::class): Long =
+    rowSumOf(typeOf<T>()) as Long
+
+@JvmName("rowSumOfFloat")
+public inline fun <reified T : Float?> AnyRow.rowSumOf(_kClass: KClass<Float> = Float::class): Float =
+    rowSumOf(typeOf<T>()) as Float
+
+@JvmName("rowSumOfDouble")
+public inline fun <reified T : Double?> AnyRow.rowSumOf(_kClass: KClass<Double> = Double::class): Double =
+    rowSumOf(typeOf<T>()) as Double
+
+// unfortunately, we cannot make a `reified T : Number?` due to clashes
+public fun AnyRow.rowSumOf(type: KType): Number {
+    require(type.isPrimitiveOrMixedNumber()) {
+        "Type $type is not a primitive number type. Mean only supports primitive number types."
+    }
+    return Aggregators.sum.aggregateOfRow(this) { colsOf(type) }
+}
 // endregion
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.sum(): DataRow<T> = sumFor(numberColumns())
+public fun <T> DataFrame<T>.sum(): DataRow<T> = sumFor(primitiveOrMixedNumberColumns())
 
 public fun <T, C : Number> DataFrame<T>.sumFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> =
     Aggregators.sum.aggregateFor(this, columns)
@@ -71,28 +121,70 @@ public fun <T, C : Number> DataFrame<T>.sumFor(vararg columns: ColumnReference<C
 public fun <T, C : Number> DataFrame<T>.sumFor(vararg columns: KProperty<C?>): DataRow<T> =
     sumFor { columns.toColumnSet() }
 
+@JvmName("sumShort")
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataFrame<T>.sum(columns: ColumnsSelector<T, Short?>): Int =
+    Aggregators.sum.aggregateAll(this, columns) as Int
+
+@JvmName("sumByte")
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataFrame<T>.sum(columns: ColumnsSelector<T, Byte?>): Int =
+    Aggregators.sum.aggregateAll(this, columns) as Int
+
+@JvmName("sumNumber")
+@OverloadResolutionByLambdaReturnType
 public inline fun <T, reified C : Number> DataFrame<T>.sum(noinline columns: ColumnsSelector<T, C?>): C =
-    (Aggregators.sum.aggregateAll(this, columns) as C?) ?: C::class.zero()
+    Aggregators.sum.aggregateAll(this, columns) as C
 
+@JvmName("sumShort")
+@AccessApiOverload
+public fun <T> DataFrame<T>.sum(vararg columns: ColumnReference<Short?>): Int = sum { columns.toColumnSet() }
+
+@JvmName("sumByte")
+@AccessApiOverload
+public fun <T> DataFrame<T>.sum(vararg columns: ColumnReference<Byte?>): Int = sum { columns.toColumnSet() }
+
+@JvmName("sumNumber")
 @AccessApiOverload
 public inline fun <T, reified C : Number> DataFrame<T>.sum(vararg columns: ColumnReference<C?>): C =
     sum { columns.toColumnSet() }
 
-public fun <T> DataFrame<T>.sum(vararg columns: String): Number = sum { columns.toColumnsSetOf() }
+public fun <T> DataFrame<T>.sum(vararg columns: String): Number = sum { columns.toColumnsSetOf<Number?>() }
+
+@JvmName("sumShort")
+@AccessApiOverload
+public fun <T> DataFrame<T>.sum(vararg columns: KProperty<Short?>): Int = sum { columns.toColumnSet() }
 
+@JvmName("sumByte")
+@AccessApiOverload
+public fun <T> DataFrame<T>.sum(vararg columns: KProperty<Byte?>): Int = sum { columns.toColumnSet() }
+
+@JvmName("sumNumber")
 @AccessApiOverload
 public inline fun <T, reified C : Number> DataFrame<T>.sum(vararg columns: KProperty<C?>): C =
     sum { columns.toColumnSet() }
 
-public inline fun <T, reified C : Number?> DataFrame<T>.sumOf(crossinline expression: RowExpression<T, C>): C =
-    rows().sumOf(typeOf<C>()) { expression(it, it) }
+@JvmName("sumOfShort")
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataFrame<T>.sumOf(expression: RowExpression<T, Short?>): Int =
+    Aggregators.sum.aggregateOf(this, expression) as Int
+
+@JvmName("sumOfByte")
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataFrame<T>.sumOf(expression: RowExpression<T, Byte?>): Int =
+    Aggregators.sum.aggregateOf(this, expression) as Int
+
+@JvmName("sumOfNumber")
+@OverloadResolutionByLambdaReturnType
+public inline fun <T, reified C : Number> DataFrame<T>.sumOf(crossinline expression: RowExpression<T, C?>): C =
+    Aggregators.sum.aggregateOf(this, expression) as C
 
 // endregion
 
 // region GroupBy
 @Refine
 @Interpretable("GroupBySum1")
-public fun <T> Grouped<T>.sum(): DataFrame<T> = sumFor(numberColumns())
+public fun <T> Grouped<T>.sum(): DataFrame<T> = sumFor(primitiveOrMixedNumberColumns())
 
 @Refine
 @Interpretable("GroupBySum0")
@@ -136,7 +228,7 @@ public inline fun <T, reified R : Number> Grouped<T>.sumOf(
 
 // region Pivot
 
-public fun <T> Pivot<T>.sum(separate: Boolean = false): DataRow<T> = sumFor(separate, numberColumns())
+public fun <T> Pivot<T>.sum(separate: Boolean = false): DataRow<T> = sumFor(separate, primitiveOrMixedNumberColumns())
 
 public fun <T, R : Number> Pivot<T>.sumFor(
     separate: Boolean = false,
@@ -166,14 +258,15 @@ public fun <T, C : Number> Pivot<T>.sum(vararg columns: ColumnReference<C?>): Da
 @AccessApiOverload
 public fun <T, C : Number> Pivot<T>.sum(vararg columns: KProperty<C?>): DataRow<T> = sum { columns.toColumnSet() }
 
-public inline fun <T, reified R : Number> Pivot<T>.sumOf(crossinline expression: RowExpression<T, R>): DataRow<T> =
+public inline fun <T, reified R : Number> Pivot<T>.sumOf(crossinline expression: RowExpression<T, R?>): DataRow<T> =
     delegate { sumOf(expression) }
 
 // endregion
 
 // region PivotGroupBy
 
-public fun <T> PivotGroupBy<T>.sum(separate: Boolean = false): DataFrame<T> = sumFor(separate, numberColumns())
+public fun <T> PivotGroupBy<T>.sum(separate: Boolean = false): DataFrame<T> =
+    sumFor(separate, primitiveOrMixedNumberColumns())
 
 public fun <T, R : Number> PivotGroupBy<T>.sumFor(
     separate: Boolean = false,
@@ -209,7 +302,7 @@ public fun <T, C : Number> PivotGroupBy<T>.sum(vararg columns: KProperty<C?>): D
     sum { columns.toColumnSet() }
 
 public inline fun <T, reified R : Number> PivotGroupBy<T>.sumOf(
-    crossinline expression: RowExpression<T, R>,
+    crossinline expression: RowExpression<T, R?>,
 ): DataFrame<T> = Aggregators.sum.aggregateOf(this, expression)
 
 // endregion