expanded sum with float, short, byte, biginteger and some warnings for conversions

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt

@@ -1,6 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.math
 
 import java.math.BigDecimal
+import java.math.BigInteger
 import kotlin.reflect.KType
 
 @PublishedApi
@@ -11,34 +12,77 @@ internal fun <T, R : Number> Iterable<T>.sumOf(type: KType, selector: (T) -> R?)
     }
     return when (type.classifier) {
         Double::class -> sumOf(selector as ((T) -> Double)) as R
+
+        // careful, conversion to Double to Float occurs! TODO
+        Float::class -> sumOf { (selector as ((T) -> Float))(it).toDouble() }.toFloat() as R
+
         Int::class -> sumOf(selector as ((T) -> Int)) as R
+
+        // careful, cast to Int occurs! TODO
+        Short::class -> sumOf { (selector as ((T) -> Short))(it).toInt() } as R
+
+        // careful, cast to Int occurs! TODO
+        Byte::class -> sumOf { (selector as ((T) -> Byte))(it).toInt() } as R
+
         Long::class -> sumOf(selector as ((T) -> Long)) as R
+
         BigDecimal::class -> sumOf(selector as ((T) -> BigDecimal)) as R
-        else -> TODO()
+
+        BigInteger::class -> sumOf(selector as ((T) -> BigInteger)) as R
+
+        Number::class -> sumOf { (selector as ((T) -> Number))(it).toDouble() } as R
+
+        Nothing::class -> 0.0 as R
+
+        else -> throw IllegalArgumentException("sumOf is not supported for $type")
     }
 }
 
 @PublishedApi
 internal fun <T : Number> Iterable<T>.sum(type: KType): T =
     when (type.classifier) {
         Double::class -> (this as Iterable<Double>).sum() as T
+
         Float::class -> (this as Iterable<Float>).sum() as T
+
+        // careful, cast to Int occurs! TODO
         Int::class, Short::class, Byte::class -> (this as Iterable<Int>).sum() as T
+
         Long::class -> (this as Iterable<Long>).sum() as T
+
         BigDecimal::class -> (this as Iterable<BigDecimal>).sum() as T
-        else -> throw IllegalArgumentException("Sum is not supported for $type")
+
+        BigInteger::class -> (this as Iterable<BigInteger>).sum() as T
+
+        Number::class -> (this as Iterable<Number>).map { it.toDouble() }.sum() as T
+
+        Nothing::class -> 0.0 as T
+
+        else -> throw IllegalArgumentException("sum is not supported for $type")
     }
 
 @JvmName("sumNullableT")
 @PublishedApi
 internal fun <T : Number> Iterable<T?>.sum(type: KType): T =
     when (type.classifier) {
         Double::class -> (this as Iterable<Double?>).asSequence().filterNotNull().sum() as T
+
         Float::class -> (this as Iterable<Float?>).asSequence().filterNotNull().sum() as T
+
+        // careful, cast to Int occurs! TODO
         Int::class, Short::class, Byte::class -> (this as Iterable<Int?>).asSequence().filterNotNull().sum() as T
+
         Long::class -> (this as Iterable<Long?>).asSequence().filterNotNull().sum() as T
+
         BigDecimal::class -> (this as Iterable<BigDecimal?>).asSequence().filterNotNull().sum() as T
-        else -> TODO()
+
+        BigInteger::class -> (this as Iterable<BigInteger?>).asSequence().filterNotNull().sum() as T
+
+        Number::class -> (this as Iterable<Number?>).asSequence().filterNotNull().map { it.toDouble() }.sum() as T
+
+        Nothing::class -> 0.0 as T
+
+        else -> throw IllegalArgumentException("sum is not supported for $type")
     }
 
 @PublishedApi
@@ -58,3 +102,21 @@ internal fun Sequence<BigDecimal>.sum(): BigDecimal {
     }
     return sum
 }
+
+@PublishedApi
+internal fun Iterable<BigInteger>.sum(): BigInteger {
+    var sum: BigInteger = BigInteger.ZERO
+    for (element in this) {
+        sum += element
+    }
+    return sum
+}
+
+@PublishedApi
+internal fun Sequence<BigInteger>.sum(): BigInteger {
+    var sum: BigInteger = BigInteger.ZERO
+    for (element in this) {
+        sum += element
+    }
+    return sum
+}