|
1 | 1 | package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
|
2 | 2 |
|
3 |
| -import org.jetbrains.kotlinx.dataframe.math.meanOrNull |
4 |
| -import org.jetbrains.kotlinx.dataframe.math.meanTypeResultOrNull |
| 3 | +import org.jetbrains.kotlinx.dataframe.math.mean |
5 | 4 | import org.jetbrains.kotlinx.dataframe.math.median
|
6 | 5 | import org.jetbrains.kotlinx.dataframe.math.percentile
|
7 | 6 | import org.jetbrains.kotlinx.dataframe.math.std
|
8 | 7 | import org.jetbrains.kotlinx.dataframe.math.sum
|
9 |
| -import java.math.BigDecimal |
10 | 8 | import kotlin.reflect.KType
|
11 | 9 | import kotlin.reflect.full.withNullability
|
12 | 10 | import kotlin.reflect.typeOf
|
@@ -92,43 +90,51 @@ internal object Aggregators {
|
92 | 90 | getAggregator: (Param1, Param2) -> AggregatorProvider<AggregatorType>,
|
93 | 91 | ) = AggregatorOptionSwitch2.Factory(getAggregator)
|
94 | 92 |
|
95 |
| - val min by twoStepPreservingType<Comparable<Any?>> { minOrNull() } |
| 93 | + // T: Comparable<T> -> T? |
| 94 | + val min by twoStepPreservingType<Comparable<Any?>> { |
| 95 | + minOrNull() |
| 96 | + } |
96 | 97 |
|
97 |
| - val max by twoStepPreservingType<Comparable<Any?>> { maxOrNull() } |
| 98 | + // T: Comparable<T> -> T? |
| 99 | + val max by twoStepPreservingType<Comparable<Any?>> { |
| 100 | + maxOrNull() |
| 101 | + } |
98 | 102 |
|
| 103 | + // T: Number? -> Double |
99 | 104 | val std by withTwoOptions { skipNA: Boolean, ddof: Int ->
|
100 | 105 | flatteningChangingTypes<Number, Double>(
|
101 |
| - getReturnTypeOrNull = { type, emptyInput -> typeOf<Double>().withNullability(emptyInput) }, |
102 |
| - ) { std(it, skipNA, ddof) } |
| 106 | + getReturnTypeOrNull = { _, emptyInput -> typeOf<Double>().withNullability(emptyInput) }, |
| 107 | + ) { type -> |
| 108 | + std(type, skipNA, ddof) |
| 109 | + } |
103 | 110 | }
|
104 | 111 |
|
105 |
| - @Suppress("ClassName") |
106 |
| - object mean { |
107 |
| - val toNumber = withOneOption { skipNA: Boolean -> |
108 |
| - twoStepForNumbers(::meanTypeResultOrNull) { meanOrNull(it, skipNA) } |
109 |
| - }.create(mean::class.simpleName!!) |
110 |
| - |
111 |
| - val toDouble = withOneOption { skipNA: Boolean -> |
112 |
| - twoStepForNumbers(::meanTypeResultOrNull) { meanOrNull(it, skipNA) as Double? } |
113 |
| - }.create(mean::class.simpleName!!) |
114 |
| - |
115 |
| - val toBigDecimal = |
116 |
| - twoStepForNumbers(::meanTypeResultOrNull) { |
117 |
| - meanOrNull(it) as BigDecimal? |
118 |
| - }.create(mean::class.simpleName!!) |
| 112 | + // step one: T: Number? -> Double |
| 113 | + // step two: Double -> Double |
| 114 | + val mean by withOneOption { skipNA: Boolean -> |
| 115 | + twoStepChangingType( |
| 116 | + getReturnTypeOrNull = { _, _ -> typeOf<Double>() }, |
| 117 | + stepOneAggregator = { type -> mean(type, skipNA) }, |
| 118 | + stepTwoAggregator = { mean(skipNA) }, |
| 119 | + ) |
119 | 120 | }
|
120 | 121 |
|
| 122 | + // T: Comparable<T>? -> T |
121 | 123 | val percentile by withOneOption { percentile: Double ->
|
122 |
| - flatteningChangingTypes<Comparable<Any?>, Comparable<Any?>>(preserveReturnTypeNullIfEmpty) { type -> |
| 124 | + flatteningPreservingTypes<Comparable<Any?>> { type -> |
123 | 125 | percentile(percentile, type)
|
124 | 126 | }
|
125 | 127 | }
|
126 | 128 |
|
127 |
| - val median by flatteningPreservingTypes<Comparable<Any?>> { |
128 |
| - median(it) |
| 129 | + // T: Comparable<T>? -> T |
| 130 | + val median by flatteningPreservingTypes<Comparable<Any?>> { type -> |
| 131 | + median(type) |
129 | 132 | }
|
130 | 133 |
|
| 134 | + // T: Number -> T |
131 | 135 | val sum by twoStepForNumbers(
|
132 | 136 | getReturnTypeOrNull = { type, _ -> type.withNullability(false) },
|
133 |
| - ) { sum(it) } |
| 137 | + ) { type -> |
| 138 | + sum(type) |
| 139 | + } |
134 | 140 | }
|
0 commit comments