medianBy

inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianBy(skipNaN: Boolean = skipNaNDefault, crossinline selector: (T) -> R): T

Returns the element of this DataColumn at the median of the values that the given selector returns for each element.

The result of the expression is considered the 'input' of this operation.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Throws a NoSuchElementException when there is nothing to compute the median of, for instance, when the input is empty or contains only null values.

Don't confuse medianBy with medianOf, which returns the median selector value itself instead of the element it belongs to.

See also:

  • medianByOrNull — returns null instead of throwing for a column with nothing to compute the median of.

  • percentileBy — the element at any other percentile of the values a selector returns.

  • The Median Operation — an overview of all median modes.

For more information: See median on the documentation website.

Example

// The first name of median length in the "name"/"firstName" column
df.name.firstName.medianBy { it.length }

Return

The element at the median of the values selector returns.

Parameters

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.

selector

A function that returns the value to compare for each element of this column.

Throws

if there are no values to compute the median of.


inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(skipNaN: Boolean = skipNaNDefault, crossinline expression: RowExpression<T, C>): DataRow<T>

Returns the row of this DataFrame at the median of the values that the given expression returns for each row.

The given RowExpression is evaluated for each row of the dataframe. The row is both the receiver and the argument (it) of the expression, so the values in it can be accessed directly.

For more information: See RowExpression on the documentation website.

The result of the expression is considered the 'input' of this operation.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Throws a NoSuchElementException when there is nothing to compute the median of, for instance, when the input is empty or contains only null values.

Don't confuse medianBy with medianOf, which returns the median expression value itself instead of the row it belongs to.

See also:

  • medianByOrNull — returns null instead of throwing when there's nothing to compute the median of.

  • percentileBy — the row at any other percentile of the values a row expression returns.

  • sortBy — orders all rows instead of taking just the middle one.

  • The Median Operation — an overview of all median modes.

For more information: See median on the documentation website.

Example

// The row with the median "age"
df.medianBy { age }
// The row with the median weight-to-age ratio
df.medianBy { (weight ?: 0) / age }

Return

The DataRow at the median of the values expression returns.

Parameters

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.

expression

The RowExpression to compute the value to compare the rows by.

Throws

if there are no values to compute the median of.


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

Returns the row of this DataFrame at the median of the values in the column with the given name.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Throws a NoSuchElementException when there is nothing to compute the median of, for instance, when the input is empty or contains only null values.

Don't confuse medianBy with median, which returns the median value itself instead of the row it belongs to.

See also:

  • medianByOrNull — returns null instead of throwing when there's nothing to compute the median of.

  • percentileBy — the row at any other percentile of the values in a column.

  • sortBy — orders all rows instead of taking just the middle one.

  • The Median Operation — an overview of all median modes.

For more information: See median on the documentation website.

Example

// The row with the median "age"
df.medianBy("age")

Return

The DataRow at the median of the values in the given column.

Parameters

column

The name of the column of this DataFrame to compare the rows by.

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.

Throws

if there are no values to compute the median of.


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

Reduces each group of this GroupBy to the row at the median of the values that the given rowExpression returns for each row of that group.

This operation does not produce a result right away. Instead, it returns a ReducedGroupBy — an intermediate step which can be finished with concat (to get a DataFrame with the selected rows), values, or into.

See GroupBy reducing for more details.

The given RowExpression is evaluated for each row of the dataframe. The row is both the receiver and the argument (it) of the expression, so the values in it can be accessed directly.

For more information: See RowExpression on the documentation website.

The result of the expression is considered the 'input' of this operation.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Groups that have no values to compute the median of cannot select a row, and produce null values instead.

Don't confuse medianBy with medianOf, which returns the median value itself instead of the row it belongs to.

See also:

For more information: See median on the documentation website.

Example

// For each city, the full row of the person with the median "age"
df.groupBy { city }.medianBy { age }.concat()

Return

A ReducedGroupBy with, for each group, the row at the median of the values rowExpression returns.

Parameters

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.

rowExpression

The RowExpression to compute the value to compare the rows by.


fun <T, G> GroupBy<T, G>.medianBy(column: String, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>

Reduces each group of this GroupBy to the row at the median of the values in the column with the given name.

This operation does not produce a result right away. Instead, it returns a ReducedGroupBy — an intermediate step which can be finished with concat (to get a DataFrame with the selected rows), values, or into.

See GroupBy reducing for more details.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Groups that have no values to compute the median of cannot select a row, and produce null values instead.

Don't confuse medianBy with median, which returns the median value itself instead of the row it belongs to.

See also:

For more information: See median on the documentation website.

Example

// For each city, the full row of the person with the median "age"
df.groupBy { city }.medianBy("age").concat()

Return

A ReducedGroupBy with, for each group, the row at the median of the values in the given column.

Parameters

column

The name of the column to compare the rows by.

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.


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

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

The given RowExpression is evaluated for each row of the dataframe. The row is both the receiver and the argument (it) of the expression, so the values in it can be accessed directly.

For more information: See RowExpression on the documentation website.

The result of the expression is considered the 'input' of this operation.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Groups that have no values to compute the median of cannot select a row, and produce null values instead.

This operation does not produce a result right away. Instead, it returns a ReducedPivot — an intermediate step which can be finished with values or with.

Don't confuse medianBy with medianOf, which returns the median value the expression returns itself, instead of the row.

Check out the Pivot Grammar.

See also:

For more information: See median on the documentation website.

Example

// For each city, the "name" of the person with the median weight-to-age ratio
df.pivot { city }.medianBy { (weight ?: 0) / age }.with { name }

Return

A ReducedPivot holding, per group, the row at the median of the values rowExpression returns.

Parameters

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.

rowExpression

The RowExpression to compute the value to compare the rows by.


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

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

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Groups that have no values to compute the median of cannot select a row, and produce null values instead.

This operation does not produce a result right away. Instead, it returns a ReducedPivot — an intermediate step which can be finished with values or with.

Don't confuse medianBy with median, which returns the median value itself, instead of the row.

Check out the Pivot Grammar.

See also:

For more information: See median on the documentation website.

Example

// For each city, the "name" of the person with the median "age"
df.pivot { city }.medianBy("age").with { name }

Return

A ReducedPivot holding, per group, the row at the median of the values in the given column.

Parameters

column

The name of the column to compare the rows by.

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.


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.

The given RowExpression is evaluated for each row of the dataframe. The row is both the receiver and the argument (it) of the expression, so the values in it can be accessed directly.

For more information: See RowExpression on the documentation website.

The result of the expression is considered the 'input' of this operation.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Groups that have no values to compute the median of cannot select a row, and produce null values instead.

This operation does not produce a result right away. Instead, it returns a ReducedPivotGroupBy — an intermediate step which can be finished with values or with.

Don't confuse medianBy with medianOf, which returns the median value the expression returns itself, instead of the row.

Check out the PivotGroupBy Grammar.

See also:

For more information: See median on the documentation website.

Example

// Per city and last name, the "firstName" of the person with the median weight-to-age ratio
df.pivot { city }.groupBy { name.lastName }.medianBy { (weight ?: 0) / age }.with { name.firstName }

Return

A ReducedPivotGroupBy holding, per group, the row at the median of the values rowExpression returns.

Parameters

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.

rowExpression

The RowExpression to compute the value to compare the rows by.


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.

Only self-comparable values are supported: values of a type T : Comparable<T> that are mutually comparable (like strings, primitive numbers, or dates). This includes all primitive number types, but no mix of different number types, which would result in a ClassCastException.

null values in the input are always ignored.

Which value lies at the median is determined using quantile estimation method R3, so no interpolation takes place, not even for numbers. If skipNaN is false and NaN values are encountered, the first one with a NaN value is selected.

Currently, only the default quantile estimation methods can be used. In the future, it might become possible to choose a different one, see #1121.

Groups that have no values to compute the median of cannot select a row, and produce null values instead.

This operation does not produce a result right away. Instead, it returns a ReducedPivotGroupBy — an intermediate step which can be finished with values or with.

Don't confuse medianBy with median, which returns the median value itself, instead of the row.

Check out the PivotGroupBy Grammar.

See also:

For more information: See median on the documentation website.

Example

// Per city and last name, the "firstName" of the person with the median "age"
df.pivot { city }.groupBy { name.lastName }.medianBy("age").with { name.firstName }

Return

A ReducedPivotGroupBy holding, per group, the row at the median of the values in the given column.

Parameters

column

The name of the column to compare the rows by.

skipNaN

If true, NaN values are ignored, just like null values. If false (the default), a NaN in the input is propagated to the result. This only has an effect on Double and Float values.


inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html