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

PivotGroupBy

interface PivotGroupBy<out T> : Aggregatable<T>

PivotGroupBy is a dataframe-like structure that combines Pivot and GroupBy, representing a matrix table with vertical Pivot groups (as columns) and horizontal GroupBy groups (as rows), where each cell represents a group corresponding to both the GroupBy and Pivot key.

Reversed order of pivot and groupBy (i.e., DataFrame.pivot + Pivot.groupBy or DataFrame.groupBy + GroupBy.pivot) will produce the same result.

PivotGroupBy can be reduced or aggregated into a DataFrame.

Check out PivotGroupBy Grammar.

For more information: See "pivot + groupBy" on the documentation website.

Inheritors

PivotGroupByImpl

PivotInAggregateImpl

Functions

aggregate

abstract fun <R> aggregate(separate: Boolean = false, body: AggregateBody<T, R>): DataFrame<T>

Aggregates this PivotGroupBy using the provided statistics inside the AggregateDsl.

aggregateAll

internal fun <T, C, R> PivotGroupBy<T>.aggregateAll(aggregator: Aggregator<C & Any, R>, columns: ColumnsSelector<T, C>): DataFrame<T>

aggregateOf

@PublishedApi

internal inline fun <T, reified C, R> PivotGroupBy<T>.aggregateOf(crossinline expression: RowExpression<T, C>, aggregator: Aggregator<C & Any, R>): DataFrame<T>

count

fun <T> PivotGroupBy<T>.count(): DataFrame<T>

Aggregates this PivotGroupBy by counting the number of rows in each combined pivot + groupBy group.

inline fun <T> PivotGroupBy<T>.count(crossinline predicate: RowFilter<T>): DataFrame<T>

Aggregates this PivotGroupBy by counting the number of rows in each combined pivot + groupBy group, that satisfy the given predicate.

default

abstract fun default(value: Any?): PivotGroupBy<T>

first

fun <T> PivotGroupBy<T>.first(): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking the first row from each combined pivot + groupBy group, and returns a ReducedPivotGroupBy that contains the first row from each corresponding group. If any combined pivot + groupBy group in PivotGroupBy is empty, in the resulting ReducedPivotGroupBy it will be represented by a row with null values (except the grouping key).

fun <T> PivotGroupBy<T>.first(predicate: RowFilter<T>): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each combined pivot + groupBy group the first row satisfying the given predicate. Returns a ReducedPivotGroupBy that contains the first row, matching the predicate, from each corresponding group. If any combined pivot + groupBy group in PivotGroupBy does not contain any rows matching the predicate, in the resulting ReducedPivotGroupBy it will be represented by a row with null values (except the grouping key).

frames

fun <T> PivotGroupBy<T>.frames(): DataFrame<T>

internal

@PublishedApi

internal fun <T> Aggregatable<T>.internal(): AggregatableInternal<T>

intraComparableColumns

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>.

last

fun <T> PivotGroupBy<T>.last(): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking the last row from each combined pivot + groupBy group, and returns a ReducedPivotGroupBy that contains the last row from each corresponding group. If any combined pivot + groupBy group in PivotGroupBy is empty, in the resulting ReducedPivotGroupBy it will be represented by a row with null values (except the grouping key).

fun <T> PivotGroupBy<T>.last(predicate: RowFilter<T>): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each combined pivot + groupBy group the last row satisfying the given predicate. Returns a ReducedPivotGroupBy that contains the last row, matching the predicate, from each corresponding group. If any combined pivot + groupBy group in PivotGroupBy does not contain any rows matching the predicate, in the resulting ReducedPivotGroupBy it will be represented by a row with null values (except the grouping key).

matches

fun <T> PivotGroupBy<T>.matches(): DataFrame<T>

fun <T, R> PivotGroupBy<T>.matches(yes: R, no: R): DataFrame<T>

max

fun <T> PivotGroupBy<T>.max(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.~~max~~(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.~~max~~(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

maxBy

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(skipNaN: Boolean = skipNaNDefault, crossinline rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the first row for which the given rowExpression returns the maximum value.

fun <T> PivotGroupBy<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the first row that has the largest value in the given column.

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~maxBy~~(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~maxBy~~(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

maxFor

fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.maxFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Comparable<*>?> PivotGroupBy<T>.~~maxFor~~(vararg columns: KProperty<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, R : Comparable<*>?> PivotGroupBy<T>.~~maxFor~~(vararg columns: ColumnReference<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

maxOf

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(skipNaN: Boolean = skipNaNDefault, crossinline rowExpression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the maximum of the values that the given rowExpression returns for each row, per group.

mean

fun <T> PivotGroupBy<T>.mean(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Number?> PivotGroupBy<T>.mean(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.mean(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Number?> PivotGroupBy<T>.~~mean~~(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, R : Number?> PivotGroupBy<T>.~~mean~~(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

meanFor

fun <T, C : Number?> PivotGroupBy<T>.meanFor(skipNaN: Boolean = skipNaNDefault, separate: Boolean = false, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.meanFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.~~meanFor~~(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Number?> PivotGroupBy<T>.~~meanFor~~(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

meanOf

inline fun <T, reified R : Number?> PivotGroupBy<T>.meanOf(skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the mean of the values that the given expression returns for each row, per group.

median

fun <T> PivotGroupBy<T>.median(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.~~median~~(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.~~median~~(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

medianBy

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianBy(skipNaN: Boolean = skipNaNDefault, crossinline rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the row at the median of the values that the given rowExpression returns for each row of that group.

fun <T> PivotGroupBy<T>.medianBy(column: String, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the row at the median of the values in the given column.

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~medianBy~~(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~medianBy~~(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

medianFor

fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.medianFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<*>?> PivotGroupBy<T>.~~medianFor~~(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Comparable<*>?> PivotGroupBy<T>.~~medianFor~~(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

medianOf

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianOf(skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the median of the values that the given expression returns for each row, per group.

min

fun <T> PivotGroupBy<T>.min(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.~~min~~(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.~~min~~(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

minBy

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(skipNaN: Boolean = skipNaNDefault, crossinline rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the first row for which the given rowExpression returns the minimum value.

fun <T> PivotGroupBy<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the first row that has the smallest value in the given column.

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~minBy~~(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~minBy~~(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

minFor

fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.minFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, R : Comparable<*>?> PivotGroupBy<T>.~~minFor~~(vararg columns: KProperty<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, R : Comparable<*>?> PivotGroupBy<T>.~~minFor~~(vararg columns: ColumnReference<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

minOf

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(skipNaN: Boolean = skipNaNDefault, crossinline rowExpression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the minimum of the values that the given rowExpression returns for each row, per group.

numberColumns

internal fun <T> Aggregatable<T>.numberColumns(): ColumnsSelector<T, Number?>

percentile

fun <T> PivotGroupBy<T>.percentile(percentile: Double, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(percentile: Double, skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.percentile(percentile: Double, vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.~~percentile~~(percentile: Double, vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.~~percentile~~(percentile: Double, vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

percentileBy

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileBy(percentile: Double, skipNaN: Boolean = skipNaNDefault, crossinline rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the row at the given percentile of the values that the given rowExpression returns for each row of that group.

fun <T> PivotGroupBy<T>.percentileBy(percentile: Double, column: String, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

Reduces this PivotGroupBy by taking from each group the row at the given percentile of the values in the given column.

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~percentileBy~~(percentile: Double, column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.~~percentileBy~~(percentile: Double, column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

percentileFor

fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(percentile: Double, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.percentileFor(percentile: Double, vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<*>?> PivotGroupBy<T>.~~percentileFor~~(percentile: Double, vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Comparable<*>?> PivotGroupBy<T>.~~percentileFor~~(percentile: Double, vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

percentileOf

inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileOf(percentile: Double, skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the given percentile of the values that the given expression returns for each row, per group.

primitiveOrMixedNumberColumns

internal fun <T> Aggregatable<T>.primitiveOrMixedNumberColumns(): ColumnsSelector<T, Number?>

reduce

@PublishedApi

internal fun <T> PivotGroupBy<T>.reduce(reducer: Selector<DataFrame<T>, DataRow<T>?>): ReducedPivotGroupBy<T>

remainingColumns

internal inline fun <T> Aggregatable<T>.remainingColumns(crossinline predicate: (AnyCol) -> Boolean): ColumnsSelector<T, Any?>

remainingColumnsSelector

internal fun <T> Aggregatable<T>.remainingColumnsSelector(): ColumnsSelector<*, *>

std

fun <T> PivotGroupBy<T>.std(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.std(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.std(vararg columns: String, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.~~std~~(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

fun <T, C : Number?> PivotGroupBy<T>.~~std~~(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

stdFor

fun <T, R : Number?> PivotGroupBy<T>.stdFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, columns: ColumnsForAggregateSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.stdFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.~~stdFor~~(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

fun <T, C : Number?> PivotGroupBy<T>.~~stdFor~~(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

stdOf

inline fun <T, reified R : Number?> PivotGroupBy<T>.stdOf(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the standard deviation of the values that the given expression returns for each row, per group.

sum

fun <T> PivotGroupBy<T>.sum(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.sum(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> PivotGroupBy<T>.sum(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.~~sum~~(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Number?> PivotGroupBy<T>.~~sum~~(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

sumFor

fun <T, R : Number?> PivotGroupBy<T>.sumFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, R>): DataFrame<T>

fun <T> PivotGroupBy<T>.sumFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Number?> PivotGroupBy<T>.~~sumFor~~(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T, C : Number?> PivotGroupBy<T>.~~sumFor~~(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

sumOf

inline fun <T, reified R : Number?> PivotGroupBy<T>.sumOf(skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, R>): DataFrame<T>

Aggregates this PivotGroupBy by computing the sum of the values that the given expression returns for each row, per group.

values

fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>

fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataFrame<T>

fun <T> PivotGroupBy<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>

fun <T> PivotGroupBy<T>.~~values~~(vararg columns: KProperty<*>, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>

fun <T> PivotGroupBy<T>.~~values~~(vararg columns: ColumnReference<*>, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>

with

inline fun <T, reified V> PivotGroupBy<T>.with(noinline expression: RowExpression<T, V>): DataFrame<T>

Aggregates this PivotGroupBy by evaluating the given row expression on every row in each group defined by the grouping and pivot keys.