core/org.jetbrains.kotlinx.dataframe.api/Grouped

Grouped

interface Grouped<out T> : Aggregatable<T>

Represents a dataframe-like structure with grouped values, offering aggregation capabilities.

For more information: See groupBy on the documentation website.

Inheritors

Functions

Link copied to clipboard
fun <T, R> Grouped<T>.aggregate(body: AggregateGroupedBody<T, R>): DataFrame<T>

Aggregates this GroupBy using the provided statistics inside the AggregateGroupedDsl.

Link copied to clipboard
internal fun <T, C, R> Grouped<T>.aggregateAll(aggregator: Aggregator<C & Any, R>, columns: ColumnsSelector<T, C>, name: String?): DataFrame<T>
Link copied to clipboard
Link copied to clipboard
@PublishedApi
internal inline fun <T, reified C, reified R> Grouped<T>.aggregateOf(resultName: String?, crossinline expression: RowExpression<T, C>, aggregator: Aggregator<C & Any, R>): DataFrame<T>
Link copied to clipboard
@PublishedApi
internal fun <T, R> Grouped<T>.aggregateValue(resultName: String, body: AggregateBody<T, R>): DataFrame<T>
Link copied to clipboard
fun <T> Grouped<T>.count(resultName: String = "count"): DataFrame<T>

Aggregates this GroupBy by counting the number of rows in each group.

inline fun <T> Grouped<T>.count(resultName: String = "count", crossinline predicate: RowFilter<T>): DataFrame<T>

Aggregates this GroupBy by counting the number of rows in each group that satisfy the given predicate.

Link copied to clipboard
fun <T> Grouped<T>.countDistinct(resultName: String = "countDistinct"): DataFrame<T>

Aggregates this GroupBy by counting the number of distinct rows in each group.

fun <T, C> Grouped<T>.countDistinct(resultName: String = "countDistinct", columns: ColumnsSelector<T, C>): DataFrame<T>

Aggregates this GroupBy by counting the number of distinct combinations of values in the selected columns in each group.

Link copied to clipboard
Link copied to clipboard
internal fun <T> Aggregatable<T>.intraComparableColumns(): ColumnsSelector<T, Comparable<Any>?>

Emulates selecting all columns whose values are mutually comparable to each other. These are columns of type R where R : Comparable<R>.

Link copied to clipboard
fun <T> Grouped<T>.max(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the maximum of the values of each suitable column separately, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.max(name: String? = null, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C?>): DataFrame<T>
fun <T> Grouped<T>.max(vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing a single maximum of all the values in the selected columns, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.max(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.max(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Comparable<*>?> Grouped<T>.maxFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.maxFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the maximum of the values of each selected column separately, per group.

fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(name: String? = null, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, C>): DataFrame<T>

Aggregates this GroupBy by computing the maximum of the values that the given expression returns for each row of a group.

Link copied to clipboard
fun <T> Grouped<T>.mean(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the mean of the values of each suitable column separately, per group.

fun <T, C : Number?> Grouped<T>.mean(name: String? = null, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.mean(vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing a single mean of means of the selected columns, per group.

fun <T, C : Number?> Grouped<T>.mean(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.mean(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Number?> Grouped<T>.meanFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.meanFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the mean of the values of each selected column separately, per group.

fun <T, C : Number?> Grouped<T>.meanFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.meanFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified R : Number?> Grouped<T>.meanOf(name: String? = null, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this GroupBy by computing the mean of the values that the given expression returns for each row of a group.

Link copied to clipboard
fun <T> Grouped<T>.median(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the median of the values of each suitable column separately, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.median(name: String? = null, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.median(vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing a single median of all the values in the selected columns, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.median(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.median(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Comparable<*>?> Grouped<T>.medianFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.medianFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the median of the values of each selected column separately, per group.

fun <T, C : Comparable<*>?> Grouped<T>.medianFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.medianFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.medianOf(name: String? = null, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this GroupBy by computing the median of the values that the given expression returns for each row of a group.

Link copied to clipboard
fun <T> Grouped<T>.min(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the minimum of the values of each suitable column separately, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.min(name: String? = null, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C?>): DataFrame<T>
fun <T> Grouped<T>.min(vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing a single minimum of all the values in the selected columns, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.min(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.min(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Comparable<*>?> Grouped<T>.minFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.minFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the minimum of the values of each selected column separately, per group.

fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(name: String? = null, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, C>): DataFrame<T>

Aggregates this GroupBy by computing the minimum of the values that the given expression returns for each row of a group.

Link copied to clipboard
Link copied to clipboard
fun <T> Grouped<T>.percentile(percentile: Double, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the given percentile of the values of each suitable column separately, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(percentile: Double, name: String? = null, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.percentile(percentile: Double, vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing a single percentile of all the values in the selected columns, per group.

fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(percentile: Double, vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(percentile: Double, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.percentileFor(percentile: Double, vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the given percentile of the values of each selected column separately, per group.

fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(percentile: Double, vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(percentile: Double, vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.percentileOf(percentile: Double, name: String? = null, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this GroupBy by computing the given percentile of the values that the given expression returns for each row of a group.

Link copied to clipboard
Link copied to clipboard
internal inline fun <T> Aggregatable<T>.remainingColumns(crossinline predicate: (AnyCol) -> Boolean): ColumnsSelector<T, Any?>
Link copied to clipboard
Link copied to clipboard
fun <T> Grouped<T>.std(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

Aggregates this GroupBy by computing the standard deviation of the values of each suitable column separately, per group.

fun <T, C : Number?> Grouped<T>.std(name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, columns: ColumnsSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.std(vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

Aggregates this GroupBy by computing a single standard deviation of all the values in the selected columns, per group.

fun <T, C : Number?> Grouped<T>.std(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.std(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Number?> Grouped<T>.stdFor(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.stdFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

Aggregates this GroupBy by computing the standard deviation of the values of each selected column separately, per group.

fun <T, C : Number?> Grouped<T>.stdFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.stdFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified R : Number?> Grouped<T>.stdOf(name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this GroupBy by computing the standard deviation of the values that the given expression returns for each row of a group.

Link copied to clipboard
fun <T> Grouped<T>.sum(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the sum of the values of each suitable column separately, per group.

fun <T, C : Number?> Grouped<T>.sum(name: String? = null, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.sum(vararg columns: String, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing a single sum of all the values in the selected columns, per group.

fun <T, C : Number?> Grouped<T>.sum(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.sum(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
fun <T, C : Number?> Grouped<T>.sumFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.sumFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

Aggregates this GroupBy by computing the sum of the values of each selected column separately, per group.

fun <T, C : Number?> Grouped<T>.sumFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.sumFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
Link copied to clipboard
inline fun <T, reified R : Number?> Grouped<T>.sumOf(resultName: String? = null, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this GroupBy by computing the sum of the values that the given expression returns for each row of a group.

Link copied to clipboard
fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T>
fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataFrame<T>
fun <T> Grouped<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T>
fun <T> Grouped<T>.values(vararg columns: ColumnReference<*>, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T>
Generated by Dokka
© 2021–2026 JetBrains s.r.o. and contributors. Licensed under Apache 2.0. | Documentation | GitHub | Slack Community | X | YouTube