core/org.jetbrains.kotlinx.dataframe.aggregation/AggregateGroupedDsl

AggregateGroupedDsl

abstract class AggregateGroupedDsl<out T> : AggregateDsl<T>

A specialized AggregateDsl used in GroupBy.aggregate method; allows pivoting inside its body.

AggregateGroupedDsl allows you to compute statistics on the columns within groups in GroupBy and store the results as a new column using into. The given aggregating expression is applied to each group independently.

The resulting DataFrame has the same structure as the original GroupBy; instead of the groups, there are new columns of aggregated values created with into.

You can use any of DataFrame Aggregation Statistics or any custom aggregation function.

Aggregated values can be either simple values, data rows or even data frames. Including them in the result using into will lead to creating a value column, a column group, or a frame column respectively in the resulting DataFrame while preserving the original structure at higher levels.

It allows pivoting inside aggregate via corresponding methods:

Pivoting inside aggregate is useful for counting cross-group matrix-like statistics.

Inheritors

GroupByReceiverImpl

Constructors

AggregateGroupedDsl

constructor()

Properties

count

@get:JvmName(name = "NullableColumnDescription_count")

val ColumnsScope<ColumnDescription?>.count: DataColumn<Int?>

@get:JvmName(name = "ColumnDescription_count")

val ColumnsScope<ColumnDescription>.count: DataColumn<Int>

@get:JvmName(name = "NullableValueCount_count")

val ColumnsScope<ValueCount?>.count: DataColumn<Int?>

@get:JvmName(name = "ValueCount_count")

val ColumnsScope<ValueCount>.count: DataColumn<Int>

freq

@get:JvmName(name = "NullableColumnDescription_freq")

val ColumnsScope<ColumnDescription?>.freq: DataColumn<Int?>

@get:JvmName(name = "ColumnDescription_freq")

val ColumnsScope<ColumnDescription>.freq: DataColumn<Int>

indices

internal val AnyFrame.indices: IntRange

key

@get:JvmName(name = "NullableKeyValueProperty_key")

val ColumnsScope<KeyValueProperty<*>?>.~~key~~: DataColumn<String?>

@get:JvmName(name = "KeyValueProperty_key")

val ColumnsScope<KeyValueProperty<*>>.~~key~~: DataColumn<String>

max

@get:JvmName(name = "NullableColumnDescription_max")

val ColumnsScope<ColumnDescription?>.max: DataColumn<Any?>

@get:JvmName(name = "ColumnDescription_max")

val ColumnsScope<ColumnDescription>.max: DataColumn<Any>

mean

@get:JvmName(name = "NullableColumnDescription_mean")

val ColumnsScope<ColumnDescription?>.mean: DataColumn<Double?>

@get:JvmName(name = "ColumnDescription_mean")

val ColumnsScope<ColumnDescription>.mean: DataColumn<Double>

median

@get:JvmName(name = "NullableColumnDescription_median")

val ColumnsScope<ColumnDescription?>.median: DataColumn<Any?>

@get:JvmName(name = "ColumnDescription_median")

val ColumnsScope<ColumnDescription>.median: DataColumn<Any>

min

@get:JvmName(name = "NullableColumnDescription_min")

val ColumnsScope<ColumnDescription?>.min: DataColumn<Any?>

@get:JvmName(name = "ColumnDescription_min")

val ColumnsScope<ColumnDescription>.min: DataColumn<Any>

name

@get:JvmName(name = "NameValuePairAny_name")

val ColumnsContainer<NameValuePair<*>>.name: DataColumn<String>

@get:JvmName(name = "NullableColumnDescription_name")

val ColumnsScope<ColumnDescription?>.name: DataColumn<String?>

@get:JvmName(name = "ColumnDescription_name")

val ColumnsScope<ColumnDescription>.name: DataColumn<String>

@get:JvmName(name = "NullableNameValuePair_name")

val <V> ColumnsScope<NameValuePair<V>?>.name: DataColumn<String?>

@get:JvmName(name = "NameValuePair_name")

val <V> ColumnsScope<NameValuePair<V>>.name: DataColumn<String>

@get:JvmName(name = "NullableNameValueProperty_name")

val <T> ColumnsScope<NameValueProperty<T>?>.name: DataColumn<String?>

@get:JvmName(name = "NameValueProperty_name")

val <T> ColumnsScope<NameValueProperty<T>>.name: DataColumn<String>

@get:JvmName(name = "NullableKeyValueProperty_name")

val ColumnsScope<KeyValueProperty<*>?>.name: DataColumn<String?>

@get:JvmName(name = "KeyValueProperty_name")

val ColumnsScope<KeyValueProperty<*>>.name: DataColumn<String>

Accesses the 'key' column of this KeyValueProperty ColumnsContainer.

ncol

internal val ColumnsContainer<*>.ncol: Int

nrow

internal val AnyFrame.nrow: Int

nulls

@get:JvmName(name = "NullableColumnDescription_nulls")

val ColumnsScope<ColumnDescription?>.nulls: DataColumn<Int?>

@get:JvmName(name = "ColumnDescription_nulls")

val ColumnsScope<ColumnDescription>.nulls: DataColumn<Int>

p25

@get:JvmName(name = "NullableColumnDescription_p25")

val ColumnsScope<ColumnDescription?>.p25: DataColumn<Any?>

@get:JvmName(name = "ColumnDescription_p25")

val ColumnsScope<ColumnDescription>.p25: DataColumn<Any>

p75

@get:JvmName(name = "NullableColumnDescription_p75")

val ColumnsScope<ColumnDescription?>.p75: DataColumn<Any?>

@get:JvmName(name = "ColumnDescription_p75")

val ColumnsScope<ColumnDescription>.p75: DataColumn<Any>

path

@get:JvmName(name = "NullableColumnDescription_path")

val ColumnsScope<ColumnDescription?>.path: DataColumn<ColumnPath?>

@get:JvmName(name = "ColumnDescription_path")

val ColumnsScope<ColumnDescription>.path: DataColumn<ColumnPath>

size

internal val AnyFrame.size: DataFrameSize

std

@get:JvmName(name = "NullableColumnDescription_std")

val ColumnsScope<ColumnDescription?>.std: DataColumn<Double?>

@get:JvmName(name = "ColumnDescription_std")

val ColumnsScope<ColumnDescription>.std: DataColumn<Double>

top

@get:JvmName(name = "NullableColumnDescription_top")

val ColumnsScope<ColumnDescription?>.top: DataColumn<Any?>

@get:JvmName(name = "ColumnDescription_top")

val ColumnsScope<ColumnDescription>.top: DataColumn<Any>

type

@get:JvmName(name = "NullableColumnDescription_type")

val ColumnsScope<ColumnDescription?>.type: DataColumn<String?>

@get:JvmName(name = "ColumnDescription_type")

val ColumnsScope<ColumnDescription>.type: DataColumn<String>

unique

@get:JvmName(name = "NullableColumnDescription_unique")

val ColumnsScope<ColumnDescription?>.unique: DataColumn<Int?>

@get:JvmName(name = "ColumnDescription_unique")

val ColumnsScope<ColumnDescription>.unique: DataColumn<Int>

value

@get:JvmName(name = "NameValuePairAny_value")

val ColumnsContainer<NameValuePair<*>>.value: DataColumn<*>

@get:JvmName(name = "NullableKeyValueProperty_value")

val <T> ColumnsScope<KeyValueProperty<T>?>.value: DataColumn<T?>

@get:JvmName(name = "KeyValueProperty_value")

val <T> ColumnsScope<KeyValueProperty<T>>.value: DataColumn<T>

@get:JvmName(name = "NullableNameValuePair_value")

val <V> ColumnsScope<NameValuePair<V>?>.value: DataColumn<V?>

@get:JvmName(name = "NameValuePair_value")

val <V> ColumnsScope<NameValuePair<V>>.value: DataColumn<V>

@get:JvmName(name = "NullableNameValueProperty_value")

val <T> ColumnsScope<NameValueProperty<T>?>.value: DataColumn<T?>

@get:JvmName(name = "NameValueProperty_value")

val <T> ColumnsScope<NameValueProperty<T>>.value: DataColumn<T>

@get:JvmName(name = "NullableValueProperty_value")

val <T> ColumnsScope<ValueProperty<T>?>.value: DataColumn<T?>

@get:JvmName(name = "ValueProperty_value")

val <T> ColumnsScope<ValueProperty<T>>.value: DataColumn<T>

Functions

add

fun <T> DataFrame<T>.add(body: AddDsl<T>.() -> Unit): DataFrame<T>

Creates new columns using the AddDsl builder.

fun <T> DataFrame<T>.~~add~~(vararg dataFrames: DataFrame<*>): DataFrame<T>

Adds all columns from the given dataFrames to the end of this DataFrame (at the top level).

fun <T> DataFrame<T>.~~add~~(vararg columns: BaseColumn<*>): DataFrame<T>

Adds new columns to the end of this DataFrame (at the top level).

inline fun <reified R, T> DataFrame<T>.add(name: String, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): DataFrame<T>

Creates a new column using an AddExpression and adds a new column to the end of this DataFrame (at the top level).

inline fun <reified R, T> DataFrame<T>.~~add~~(property: KProperty<R>, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): DataFrame<T>

inline fun <reified R, T> DataFrame<T>.~~add~~(column: ColumnAccessor<R>, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): DataFrame<T>

inline fun <reified R, T> DataFrame<T>.add(path: ColumnPath, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): DataFrame<T>

Creates a new column using AddExpression and inserts it at the specified ColumnPath.

addAll

@JvmName(name = "addAllFrames")

fun <T> DataFrame<T>.addAll(dataFrames: Iterable<DataFrame<*>>): DataFrame<T>

fun <T> DataFrame<T>.addAll(vararg dataFrames: DataFrame<*>): DataFrame<T>

Adds all columns from the given dataFrames to the end of this DataFrame (at the top level).

fun <T> DataFrame<T>.addAll(columns: Iterable<BaseColumn<*>>): DataFrame<T>

fun <T> DataFrame<T>.addAll(vararg columns: BaseColumn<*>): DataFrame<T>

Adds new columns to the end of this DataFrame (at the top level).

addId

fun <T> DataFrame<T>.addId(columnName: String = "id"): DataFrame<T>

fun <T> DataFrame<T>.~~addId~~(column: ColumnAccessor<Int>): DataFrame<T>

aggregate

abstract fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataRow<T>

Aggregates this DataFrame using the provided statistics inside the AggregateDsl.

aggregateAll

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

all

inline fun <T> DataFrame<T>.all(predicate: RowFilter<T>): Boolean

Returns true if all rows match the given predicate or rows is empty.

any

inline fun <T> DataFrame<T>.any(predicate: RowFilter<T>): Boolean

Returns true if at least one row in this DataFrame satisfies the given predicate.

append

fun <T> DataFrame<T>.append(vararg values: Any?): DataFrame<T>

inline fun <reified T : DataRowSchema> DataFrame<T>.append(vararg rows: T): DataFrame<T>

appendNulls

fun <T> DataFrame<T>.appendNulls(numberOfRows: Int = 1): DataFrame<T>

asColumnGroup

fun <T> DataFrame<T>.asColumnGroup(name: String = ""): ColumnGroup<T>

fun <T> DataFrame<T>.asColumnGroup(column: ColumnGroupAccessor<T>): ColumnGroup<T>

asGroupBy

fun <T> DataFrame<T>.asGroupBy(): GroupBy<T, T>

fun <T, G> DataFrame<T>.asGroupBy(selector: ColumnSelector<T, DataFrame<G>>): GroupBy<T, G>

fun <T> DataFrame<T>.asGroupBy(groupedColumnName: String): GroupBy<T, T>

fun <T, G> DataFrame<T>.~~asGroupBy~~(groupedColumn: ColumnReference<DataFrame<G>>): GroupBy<T, G>

asSequence

fun <T> DataFrame<T>.asSequence(): Sequence<DataRow<T>>

Returns a Sequence of DataRow over this DataFrame.

associate

inline fun <T, K, V> DataFrame<T>.associate(transform: RowExpression<T, Pair<K, V>>): Map<K, V>

Builds a Map from key-value Pairs produced by applying transform to each row.

associateBy

inline fun <T, V> DataFrame<T>.associateBy(transform: RowExpression<T, V>): Map<V, DataRow<T>>

Builds a Map where each key is produced by applying transform to a row, and the value is the corresponding DataRow.

cast

fun <T> DataFrame<*>.cast(): DataFrame<T>

inline fun <reified T> DataFrame<*>.cast(verify: Boolean = true): DataFrame<T>

castTo

inline fun <reified T> DataFrame<*>.castTo(schemaFrom: Function<DataFrame<T>>, verify: Boolean = true): DataFrame<T>

With the compiler plugin, schema marker T of DataFrame can be a local type. You cannot refer to it directly from your code, like a type argument for cast. The example below shows a situation where you'd need to cast DataFrame<*> to DataFrame. This function helps by inferring type from schemaFrom

inline fun <reified T> DataFrame<*>.castTo(schemaFrom: DataFrame<T>, verify: Boolean = true): DataFrame<T>

chunked

fun <T> DataFrame<T>.chunked(size: Int, name: String = "groups"): FrameColumn<T>

Splits this DataFrame into consecutive chunks of up to size rows and returns them as a FrameColumn.

fun <T> DataFrame<T>.chunked(startIndices: Iterable<Int>, name: String = "groups"): FrameColumn<T>

Splits this DataFrame into chunks starting at the given startIndices.

chunkedImpl

internal fun <T> DataFrame<T>.chunkedImpl(startIndices: Iterable<Int>, name: String = "groups"): FrameColumn<T>

Creates a FrameColumn from this by splitting the dataframe into smaller ones, based on the given startIndices.

columnNames

abstract fun columnNames(): List<String>

columns

abstract fun columns(): List<DataColumn<*>>

columnsCount

abstract fun columnsCount(): Int

columnTypes

abstract fun columnTypes(): List<KType>

compileTimeSchema

inline fun <reified T> DataFrame<T>.compileTimeSchema(ordered: Boolean = true): DataFrameSchema

Returns the compile-time DataFrameSchema of this DataFrame: the schema that follows from its type argument T, not from the columns it holds.

concat

fun <T> DataFrame<T>.concat(frames: Iterable<DataFrame<T>>): DataFrame<T>

Returns a DataFrame containing the rows of this DataFrame followed by the rows from frames.

@JvmName(name = "concatT")

fun <T> DataFrame<T>.concat(rows: Iterable<DataRow<T>>): DataFrame<T>

Returns a DataFrame containing the rows of this DataFrame followed by rows.

infix fun <T, T1> DataFrame<T>.concat(frame: DataFrame<T1>): DataFrame<Any>

Returns a DataFrame containing the rows of this DataFrame followed by the rows of frame.

fun <T> DataFrame<T>.concat(vararg frames: DataFrame<T>): DataFrame<T>

Returns a DataFrame containing the rows of this DataFrame followed by the rows of frames.

contains

operator fun ColumnsContainer<*>.~~contains~~(column: KProperty<*>): Boolean

operator fun ColumnsContainer<*>.~~contains~~(column: ColumnReference<*>): Boolean

containsColumn

abstract fun containsColumn(name: String): Boolean

abstract fun containsColumn(path: ColumnPath): Boolean

containsColumn

fun ColumnsContainer<*>.~~containsColumn~~(column: KProperty<*>): Boolean

fun <C> ColumnsContainer<*>.~~containsColumn~~(column: ColumnReference<C>): Boolean

convert

fun <T, C> DataFrame<T>.convert(columns: ColumnsSelector<T, C>): Convert<T, C>

fun <T> DataFrame<T>.convert(vararg columns: String): Convert<T, Any?>

Converts the values in the specified columns either to a supported target type or using a custom converter, keeping their original names and positions within the DataFrame.

fun <T, C> DataFrame<T>.~~convert~~(vararg columns: KProperty<C>): Convert<T, C>

fun <T, C> DataFrame<T>.~~convert~~(vararg columns: ColumnReference<C>): Convert<T, C>

inline fun <T, C, reified R> DataFrame<T>.~~convert~~(firstCol: KProperty<C>, vararg cols: KProperty<C>, infer: Infer = Infer.Nulls, noinline expression: RowValueExpression<T, C, R>): DataFrame<T>

inline fun <T, C, reified R> DataFrame<T>.~~convert~~(firstCol: ColumnReference<C>, vararg cols: ColumnReference<C>, infer: Infer = Infer.Nulls, noinline expression: RowValueExpression<T, C, R>): DataFrame<T>

inline fun <T, reified R> DataFrame<T>.convert(firstCol: String, vararg cols: String, infer: Infer = Infer.Nulls, noinline expression: RowValueExpression<T, Any?, R>): DataFrame<T>

Converts specified columns using row converter expression within the DataFrame. Provide a new value for every selected cell given its row and its previous value using a row value expression.

convertTo

inline fun <reified T : Any> DataFrame<*>.convertTo(excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep, noinline body: ConvertSchemaDsl<T>.() -> Unit = {}): DataFrame<T>

inline fun <reified T : Any> DataFrame<*>.convertTo(schemaFrom: DataFrame<T>, excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep, noinline body: ConvertSchemaDsl<T>.() -> Unit = {}): DataFrame<T>

Converts values in DataFrame to match given column schema T.

fun DataFrame<*>.convertTo(schemaType: KType, excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep, body: ConvertSchemaDsl<Any>.() -> Unit = {}): DataFrame<*>

Converts values in DataFrame to match given column schema schemaType.

convertToImpl

@PublishedApi

internal fun AnyFrame.convertToImpl(type: KType, allowConversion: Boolean, excessiveColumns: ExcessiveColumns, body: ConvertSchemaDsl<Any>.() -> Unit = {}): AnyFrame

copy

fun <T> DataFrame<T>.~~copy~~(): DataFrame<T>

corr

fun <T> DataFrame<T>.corr(): DataFrame<T>

Computes the pearson correlation between all suitable columns in this DataFrame, including nested columns at any depth.

fun <T, C> DataFrame<T>.corr(columns: ColumnsSelector<T, C>): Corr<T, C>

fun <T> DataFrame<T>.corr(vararg columns: String): Corr<T, Any?>

Calculates the Pearson pairwise correlation between values in the specified columns.

fun <T, C> DataFrame<T>.~~corr~~(vararg columns: KProperty<C>): Corr<T, C>

fun <T, C> DataFrame<T>.~~corr~~(vararg columns: ColumnReference<C>): Corr<T, C>

count

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

Returns the total number of rows of this DataFrame.

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

Counts the number of rows in this DataFrame that satisfy the given predicate.

countDistinct

fun DataFrame<*>.countDistinct(): Int

Returns the number of distinct rows in this DataFrame.

fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): Int

fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int

Returns the number of distinct combinations of values in selected columns in this DataFrame.

fun <T, C> DataFrame<T>.~~countDistinct~~(vararg columns: KProperty<C>): Int

fun <T> DataFrame<T>.~~countDistinct~~(vararg columns: ColumnReference<*>): Int

cumSum

fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T>

fun <T, C : Number?> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> DataFrame<T>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T>

fun <T> DataFrame<T>.~~cumSum~~(vararg columns: KProperty<Number?>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T>

fun <T> DataFrame<T>.~~cumSum~~(vararg columns: ColumnReference<Number?>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T>

Computes the cumulative sums of the values in each column from the DataFrame from the first cell to the last cell.

default

infix fun <R> R.default(defaultValue: R): Any

Sets the default value for the aggregation operation. All null values will be replaced with this value.

describe

fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription>

Computes descriptive statistics for all columns in a given DataFrame, including nested columns, returning a DataFrame with key summary metrics for each column (with a ColumnDescription data schema).

fun <T> DataFrame<T>.describe(columns: ColumnsSelector<T, *>): DataFrame<ColumnDescription>

fun <T> DataFrame<T>.describe(vararg columns: String): DataFrame<ColumnDescription>

fun <T, C : Number?> DataFrame<T>.~~describe~~(vararg columns: KProperty<C>): DataFrame<ColumnDescription>

fun <T, C : Number?> DataFrame<T>.~~describe~~(vararg columns: ColumnReference<C>): DataFrame<ColumnDescription>

Computes descriptive statistics for the selected columns in a given DataFrame, including nested columns, returning a DataFrame with key summary metrics for each column (with a ColumnDescription data schema).

distinct

fun <T> DataFrame<T>.distinct(): DataFrame<T>

Removes duplicated rows based on all columns.

fun <T, C> DataFrame<T>.distinct(columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> DataFrame<T>.distinct(vararg columns: String): DataFrame<T>

Selects the specified columns and keeps only distinct rows based on these selected columns.

fun <T> DataFrame<T>.~~distinct~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~distinct~~(vararg columns: ColumnReference<*>): DataFrame<T>

distinctBy

fun <T, C> DataFrame<T>.distinctBy(columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> DataFrame<T>.distinctBy(vararg columns: String): DataFrame<T>

Removes duplicated rows based on the specified columns.

fun <T> DataFrame<T>.~~distinctBy~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~distinctBy~~(vararg columns: ColumnReference<*>): DataFrame<T>

drop

inline fun <T> DataFrame<T>.drop(predicate: RowFilter<T>): DataFrame<T>

Returns a DataFrame containing all rows except the rows that satisfy the given predicate.

fun <T> DataFrame<T>.drop(n: Int): DataFrame<T>

Returns a DataFrame containing all rows except the first n rows.

dropLast

fun <T> DataFrame<T>.dropLast(n: Int = 1): DataFrame<T>

Returns a DataFrame containing all rows except the last n rows.

dropNA

fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.~~dropNA~~(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.~~dropNA~~(vararg columns: ColumnReference<*>, whereAllNA: Boolean = false): DataFrame<T>

Removes rows with NA values. Specific case of drop.

dropNaNs

fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.dropNaNs(vararg columns: String, whereAllNaN: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.~~dropNaNs~~(vararg columns: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.~~dropNaNs~~(vararg columns: ColumnReference<*>, whereAllNaN: Boolean = false): DataFrame<T>

Removes rows with NaN values. Specific case of drop.

dropNulls

fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.~~dropNulls~~(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.~~dropNulls~~(vararg columns: ColumnReference<*>, whereAllNull: Boolean = false): DataFrame<T>

Removes rows with null values. Specific case of drop.

dropWhile

inline fun <T> DataFrame<T>.dropWhile(predicate: RowFilter<T>): DataFrame<T>

Returns a DataFrame containing all rows except the first rows that satisfy the given predicate.

duplicate

fun <T> DataFrame<T>.duplicate(n: Int): FrameColumn<T>

Returns a FrameColumn that holds this DataFrame n times.

duplicateImpl

internal fun <T> DataFrame<T>.duplicateImpl(n: Int): FrameColumn<T>

duplicateRows

fun <T> DataFrame<T>.duplicateRows(n: Int): DataFrame<T>

Returns a DataFrame where every row is repeated n times.

inline fun <T> DataFrame<T>.duplicateRows(n: Int, filter: RowFilter<T>): DataFrame<T>

Returns a DataFrame where each row that matches the filter is repeated n times.

duplicateRowsImpl

internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int): DataFrame<T>

@PublishedApi

internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int, indicesSorted: Iterable<Int>): DataFrame<T>

excludeJoin

fun <A, B> DataFrame<A>.excludeJoin(other: DataFrame, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.excludeJoin(other: DataFrame, vararg columns: String): DataFrame<A>

Performs an exclude join of this DataFrame with the other DataFrame using the selected key columns. Includes only rows from the left DataFrame that do not have a match in the right one; right-side columns are not merged.

excludeJoinWith

fun <A, B> DataFrame<A>.excludeJoinWith(right: DataFrame, joinExpression: JoinExpression<A, B>): DataFrame<A>

Performs an exclude join of this DataFrame with the right DataFrame using the provided joinExpression. Includes only rows from the left DataFrame that do not have a match in the right one; right-side columns are not merged.

explode

fun <T> DataFrame<T>.explode(dropEmpty: Boolean = true, selector: ColumnsSelector<T, *> = defaultExplodeColumns): DataFrame<T>

Splits list-like values in the specified columns and spreads them vertically — that is, it adds a separate row for each element (one value per row). Values in all other columns are duplicated to preserve row context.

fun <T> DataFrame<T>.explode(vararg columns: String, dropEmpty: Boolean = true): DataFrame<T>

fun <T, C> DataFrame<T>.~~explode~~(vararg columns: KProperty<C>, dropEmpty: Boolean = true): DataFrame<T>

fun <T, C> DataFrame<T>.~~explode~~(vararg columns: ColumnReference<C>, dropEmpty: Boolean = true): DataFrame<T>

explodeImpl

internal fun <T> DataFrame<T>.explodeImpl(dropEmpty: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T>

extractSchema

internal fun AnyFrame.extractSchema(): DataFrameSchema

fillNA

fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T, C?>

fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?>

fun <T, C> DataFrame<T>.~~fillNA~~(vararg columns: KProperty<C>): Update<T, C?>

fun <T, C> DataFrame<T>.~~fillNA~~(vararg columns: ColumnReference<C>): Update<T, C?>

Replaces NA values with the given value or expression. Specific case of update.

fillNaNs

fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C>

fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?>

fun <T, C> DataFrame<T>.~~fillNaNs~~(vararg columns: KProperty<C>): Update<T, C>

fun <T, C> DataFrame<T>.~~fillNaNs~~(vararg columns: ColumnReference<C>): Update<T, C>

Replaces NaN values with the given value or expression. Specific case of update.

fillNulls

fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?>

fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?>

fun <T, C> DataFrame<T>.~~fillNulls~~(vararg columns: KProperty<C>): Update<T, C?>

fun <T, C> DataFrame<T>.~~fillNulls~~(vararg columns: ColumnReference<C>): Update<T, C?>

Replaces null values with the given value or expression. Specific case of update.

filter

inline fun <T> DataFrame<T>.filter(predicate: RowFilter<T>): DataFrame<T>

Filters the rows of this DataFrame based on the provided RowFilter. Returns a new DataFrame containing only the rows that satisfy the given predicate.

filterBy

fun <T> DataFrame<T>.~~filterBy~~(column: ColumnSelector<T, Boolean>): DataFrame<T>

fun <T> DataFrame<T>.~~filterBy~~(column: String): DataFrame<T>

fun <T> DataFrame<T>.~~filterBy~~(column: KProperty<Boolean>): DataFrame<T>

fun <T> DataFrame<T>.~~filterBy~~(column: ColumnReference<Boolean>): DataFrame<T>

filterJoin

fun <A, B> DataFrame<A>.filterJoin(other: DataFrame, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.filterJoin(other: DataFrame, vararg columns: String): DataFrame<A>

Performs a filter join of this DataFrame with the other DataFrame using the selected key columns. Includes only rows from the left DataFrame that have a match in the right one; right-side columns are not merged.

filterJoinWith

fun <A, B> DataFrame<A>.filterJoinWith(right: DataFrame, joinExpression: JoinExpression<A, B>): DataFrame<A>

Performs a filter join of this DataFrame with the right DataFrame using the provided joinExpression. Includes only rows from the left DataFrame that have a match in the right one; right-side columns are not merged.

filterNotNull

fun <T> DataFrame<T>.~~filterNotNull~~(columns: ColumnsSelector<T, *>): DataFrame<T>

first

fun <T> DataFrame<T>.first(): DataRow<T>

Returns the first row in this DataFrame.

inline fun <T> DataFrame<T>.first(predicate: RowFilter<T>): DataRow<T>

Returns the first row in this DataFrame that satisfies the given predicate.

firstOrNull

fun <T> DataFrame<T>.firstOrNull(): DataRow<T>?

Returns the first row in this DataFrame. If the DataFrame does not contain any rows, returns null.

inline fun <T> DataFrame<T>.firstOrNull(predicate: RowFilter<T>): DataRow<T>?

Returns the first row in this DataFrame that satisfies the given predicate. Returns null if the DataFrame contains no rows matching the predicate (including the case when the DataFrame is empty).

flatten

fun <T> DataFrame<T>.flatten(keepParentNameForColumns: Boolean = false, separator: String = "_"): DataFrame<T>

Removes all column groups in the DataFrame, replacing them with their leaf columns.

fun <T, C> DataFrame<T>.flatten(keepParentNameForColumns: Boolean = false, separator: String = "_", columns: ColumnsSelector<T, C>): DataFrame<T>

Removes specified column groups in the DataFrame, replacing them with their leaf columns.

fun <T> DataFrame<T>.flatten(vararg columns: String, keepParentNameForColumns: Boolean = false, separator: String = "_"): DataFrame<T>

fun <T, C> DataFrame<T>.~~flatten~~(vararg columns: KProperty<C>, keepParentNameForColumns: Boolean = false, separator: String = "_"): DataFrame<T>

fun <T, C> DataFrame<T>.~~flatten~~(vararg columns: ColumnReference<C>, keepParentNameForColumns: Boolean = false, separator: String = "_"): DataFrame<T>

Removes selected column groups in the DataFrame, replacing them with their leaf columns.

flattenImpl

internal fun <T, C> DataFrame<T>.flattenImpl(columns: ColumnsSelector<T, C>, keepParentNameForColumns: Boolean = false, separator: String = "_"): DataFrame<T>

forEach

inline fun <T> DataFrame<T>.forEach(action: RowExpression<T, Unit>)

Calls action for every row of this DataFrame, from the first one to the last one.

format

fun <T> DataFrame<T>.format(): FormatClause<T, Any?>

Formats the specified columns or cells within this dataframe such that they have specific CSS attributes applied to them when rendering the dataframe to HTML.

fun <T, C> DataFrame<T>.format(columns: ColumnsSelector<T, C>): FormatClause<T, C>

fun <T> DataFrame<T>.format(vararg columns: String): FormatClause<T, Any?>

Formats the specified columns or cells within this dataframe such that they have specific CSS attributes applied to them when rendering the dataframe to HTML.

fun <T, C> DataFrame<T>.~~format~~(vararg columns: KProperty<C>): FormatClause<T, C>

fun <T, C> DataFrame<T>.~~format~~(vararg columns: ColumnReference<C>): FormatClause<T, C>

formatHeader

fun <T> DataFrame<T>.formatHeader(): HeaderFormatClause<T, Any?>

fun <T, C> DataFrame<T>.formatHeader(columns: ColumnsSelector<T, C>): HeaderFormatClause<T, C>

fun <T> DataFrame<T>.formatHeader(vararg columns: String): HeaderFormatClause<T, Any?>

Experimental API. It may be changed in the future.

fullJoin

fun <A, B> DataFrame<A>.fullJoin(other: DataFrame, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.fullJoin(other: DataFrame, vararg columns: String): DataFrame<A>

Performs a full join of this DataFrame with the other DataFrame using the selected key columns. Includes all rows from both DataFrames; matching rows are merged, all mismatches are filled with null.

fullJoinWith

fun <A, B> DataFrame<A>.fullJoinWith(right: DataFrame, joinExpression: JoinExpression<A, B>): DataFrame<A>

Performs a full join of this DataFrame with the right DataFrame using the provided joinExpression. Includes all rows from both DataFrames; matching rows are merged, all mismatches are filled with null.

gather

fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C>

Reshapes the DataFrame by gathering specified columns into two columns: keys and values (or into just one of them).

fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?>

Reshapes the DataFrame by gathering specified columns into two columns: keys and values (or into just one of them).

fun <T, C> DataFrame<T>.~~gather~~(vararg columns: KProperty<C>): Gather<T, C, String, C>

fun <T, C> DataFrame<T>.~~gather~~(vararg columns: ColumnReference<C>): Gather<T, C, String, C>

generateCode

inline fun <reified T> DataFrame<T>.~~generateCode~~(fields: Boolean = true, extensionProperties: Boolean = true): CodeString

fun <T> DataFrame<T>.~~generateCode~~(markerName: String, fields: Boolean = true, extensionProperties: Boolean = true, visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC): CodeString

generateDataClasses

inline fun <reified T> DataFrame<T>.generateDataClasses(extensionProperties: Boolean = false, visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC, useFqNames: Boolean = false, nameNormalizer: NameNormalizer = NameNormalizer.default, nestedMarkerNameProvider: MarkerNameProvider = MarkerNameProvider.fromColumnName): CodeString

fun <T> DataFrame<T>.generateDataClasses(markerName: String, extensionProperties: Boolean = false, visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC, useFqNames: Boolean = false, nameNormalizer: NameNormalizer = NameNormalizer.default, nestedMarkerNameProvider: MarkerNameProvider = MarkerNameProvider.fromColumnName): CodeString

Generates a CodeString containing generated @DataSchema data classes for the given DataFrame's schema (including all nested frame columns and column groups).

generateInterfaces

inline fun <reified T> DataFrame<T>.generateInterfaces(extensionProperties: Boolean = false, visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC, useFqNames: Boolean = false, nameNormalizer: NameNormalizer = NameNormalizer.default, nestedMarkerNameProvider: MarkerNameProvider = MarkerNameProvider.fromColumnName): CodeString

fun <T> DataFrame<T>.generateInterfaces(markerName: String, extensionProperties: Boolean = false, visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC, useFqNames: Boolean = false, nameNormalizer: NameNormalizer = NameNormalizer.default, nestedMarkerNameProvider: MarkerNameProvider = MarkerNameProvider.fromColumnName): CodeString

Generates a CodeString containing generated @DataSchema interfaces for the given DataFrame's schema (including all nested frame columns and column groups).

get

open fun <C> get(column: ColumnSelector<T, C>): DataColumn<C>

open operator override fun get(columnName: String): DataColumn<*>

open operator fun <R> ~~get~~(column: KProperty<R>): DataColumn<R>

open operator fun <R> ~~get~~(column: KProperty<DataFrame<R>>): FrameColumn<R>

open operator fun <R> ~~get~~(column: KProperty<DataRow<R>>): ColumnGroup<R>

open operator fun <R> ~~get~~(column: DataColumn<R>): DataColumn<R>

open operator fun <R> ~~get~~(column: DataColumn<DataFrame<R>>): FrameColumn<R>

open operator fun <R> ~~get~~(column: DataColumn<DataRow<R>>): ColumnGroup<R>

open operator fun get(columnPath: ColumnPath): DataColumn<*>

open operator fun <R> ~~get~~(column: ColumnReference<R>): DataColumn<R>

open operator fun <R> ~~get~~(column: ColumnReference<DataFrame<R>>): FrameColumn<R>

open operator fun <R> ~~get~~(column: ColumnReference<DataRow<R>>): ColumnGroup<R>

abstract operator fun get(index: Int): DataRow<T>

open operator fun get(indices: Iterable<Int>): DataFrame<T>

open operator fun get(range: IntRange): DataFrame<T>

open operator fun get(firstIndex: Int, vararg otherIndices: Int): DataFrame<T>

open operator fun get(first: IntRange, vararg ranges: IntRange): DataFrame<T>

open override fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>>

Returns a list of columns selected by columns, a ColumnsSelectionDsl.

open operator fun String.get(column: String): ColumnPath

Creates a ColumnPath from the receiver and the given column name column. This is a shorthand for pathOf("myColumnName", "myNestedColumnName") and is often used in combination with ColumnPath.invoke to retrieve the value of a nested column. For instance:

open operator fun <T, R> KProperty<T>.~~get~~(column: KProperty<R>): DataColumn<R>

open operator fun <T, R> KProperty<T>.~~get~~(column: KProperty<DataFrame<R>>): FrameColumn<R>

open operator fun <T, R> KProperty<T>.~~get~~(column: KProperty<DataRow<R>>): ColumnGroup<R>

@JvmName(name = "KPropertyDataRowGet")

open operator fun <T, R> KProperty<DataRow<T>>.~~get~~(column: KProperty<R>): DataColumn<R>

@JvmName(name = "KPropertyDataRowGet")

open operator fun <T, R> KProperty<DataRow<T>>.~~get~~(column: KProperty<DataFrame<R>>): FrameColumn<R>

@JvmName(name = "KPropertyDataRowGet")

open operator fun <T, R> KProperty<DataRow<T>>.~~get~~(column: KProperty<DataRow<R>>): ColumnGroup<R>

Retrieves the value of this KProperty Accessor from the DataFrame.

open operator fun ColumnPath.get(column: String): ColumnPath

As extension to "myColumn"["myNestedColumn"], this function enables "myColumn"["myNestedColumn"]["myDoublyNestedColumn"] as alternative to pathOf("myColumn", "myNestedColumn", "myDoublyNestedColumn")

get

operator fun <T, C> DataFrame<T>.get(columns: ColumnsSelector<T, C>): List<DataColumn<C>>

Returns a list of columns selected by columns, a ColumnsSelectionDsl.

operator fun <T> DataFrame<T>.get(columnRange: ClosedRange<String>): DataFrame<T>

operator fun <T> DataFrame<T>.get(first: String, vararg other: String): DataFrame<T>

operator fun <T> DataFrame<T>.~~get~~(first: ColumnReference<*>, vararg other: ColumnReference<*>): DataFrame<T>

getAggregateColumn

internal fun <T, C> DataFrame<T>.getAggregateColumn(selector: ColumnsForAggregateSelector<T, C>): AggregateColumnDescriptor<C>

getAggregateColumns

internal fun <T, C> DataFrame<T>.getAggregateColumns(selector: ColumnsForAggregateSelector<T, C>): List<AggregateColumnDescriptor<C>>

getColumn

fun <T, C> ColumnsContainer<T>.getColumn(selector: ColumnSelector<T, C>): DataColumn<C>

fun <T> ColumnsContainer<T>.getColumn(index: Int): DataColumn<*>

fun <T> ColumnsContainer<T>.getColumn(name: String): DataColumn<*>

fun <T> ColumnsContainer<T>.getColumn(path: ColumnPath): DataColumn<*>

fun <T, R> ColumnsContainer<T>.~~getColumn~~(column: ColumnReference<R>): DataColumn<R>

fun <T, R> ColumnsContainer<T>.~~getColumn~~(column: ColumnReference<DataFrame<R>>): FrameColumn<R>

fun <T, R> ColumnsContainer<T>.~~getColumn~~(column: ColumnReference<DataRow<R>>): ColumnGroup<R>

internal fun <C> ColumnsContainer<*>.getColumn(name: String, policy: UnresolvedColumnsPolicy): DataColumn<C>?

internal fun <C> ColumnsContainer<*>.getColumn(path: ColumnPath, policy: UnresolvedColumnsPolicy): DataColumn<C>?

getColumnGroup

fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnSelector<T, DataRow<C>>): ColumnGroup<C>

fun <T> ColumnsContainer<T>.getColumnGroup(index: Int): ColumnGroup<*>

fun <T> ColumnsContainer<T>.getColumnGroup(name: String): ColumnGroup<*>

fun <T> ColumnsContainer<T>.~~getColumnGroup~~(column: KProperty<*>): ColumnGroup<*>

fun <T> ColumnsContainer<T>.getColumnGroup(columnPath: ColumnPath): ColumnGroup<*>

fun <T, C> ColumnsContainer<T>.~~getColumnGroup~~(column: ColumnReference<DataRow<C>>): ColumnGroup<C>

getColumnGroupOrNull

fun <T> ColumnsContainer<T>.getColumnGroupOrNull(name: String): ColumnGroup<*>?

fun <T> ColumnsContainer<T>.~~getColumnGroupOrNull~~(column: KProperty<*>): ColumnGroup<*>?

getColumnIndex

abstract fun getColumnIndex(name: String): Int

getColumnIndex

fun <T> DataFrame<T>.getColumnIndex(col: DataColumn<*>): Int

getColumnOrNull

abstract fun <R> getColumnOrNull(column: ColumnSelector<T, R>): DataColumn<R>?

abstract fun getColumnOrNull(index: Int): DataColumn<*>?

abstract fun getColumnOrNull(name: String): DataColumn<*>?

abstract fun <R> ~~getColumnOrNull~~(column: KProperty<R>): DataColumn<R>?

abstract fun getColumnOrNull(path: ColumnPath): DataColumn<*>?

abstract fun <R> ~~getColumnOrNull~~(column: ColumnReference<R>): DataColumn<R>?

getColumnPath

fun <T, C> DataFrame<T>.getColumnPath(selector: ColumnSelector<T, C>): ColumnPath

getColumnPaths

fun <T, C> DataFrame<T>.getColumnPaths(selector: ColumnsSelector<T, C>): List<ColumnPath>

internal fun <T, C> DataFrame<T>.getColumnPaths(unresolvedColumnsPolicy: UnresolvedColumnsPolicy, selector: ColumnsSelector<T, C>): List<ColumnPath>

getColumns

fun <T, C> DataFrame<T>.getColumns(selector: ColumnsSelector<T, C>): List<DataColumn<C>>

fun <T> DataFrame<T>.getColumns(vararg columns: String): List<DataColumn<*>>

getColumnsImpl

internal fun <T, C> DataFrame<T>.getColumnsImpl(unresolvedColumnsPolicy: UnresolvedColumnsPolicy, selector: ColumnsSelector<T, C>): List<DataColumn<C>>

getColumnsWithPaths

fun <T, C> DataFrame<T>.getColumnsWithPaths(selector: ColumnsSelector<T, C>): List<ColumnWithPath<C>>

internal fun <T, C> DataFrame<T>.getColumnsWithPaths(unresolvedColumnsPolicy: UnresolvedColumnsPolicy, selector: ColumnsSelector<T, C>): List<ColumnWithPath<C>>

getColumnWithPath

fun <T, C> DataFrame<T>.getColumnWithPath(selector: ColumnSelector<T, C>): ColumnWithPath<C>

getFrameColumn

fun <T> ColumnsContainer<T>.getFrameColumn(columnName: String): FrameColumn<*>

fun <T> ColumnsContainer<T>.getFrameColumn(columnPath: ColumnPath): FrameColumn<*>

getOrNull

fun <T> DataFrame<T>.getOrNull(index: Int): DataRow<T>?

getPivotColumnPaths

internal fun <T> DataFrame<T>.getPivotColumnPaths(columns: PivotColumnsSelector<T, *>): List<ColumnPath>

getPivotSequences

internal fun <T, C> DataFrame<T>.getPivotSequences(columns: PivotColumnsSelector<T, C>): List<List<PivotChainElement>>

getRows

fun <T> DataFrame<T>.getRows(indices: Iterable<Int>): DataFrame<T>

fun <T> DataFrame<T>.getRows(range: IntRange): DataFrame<T>

getSortColumns

internal fun <T, C> DataFrame<T>.getSortColumns(columns: SortColumnsSelector<T, C>, unresolvedColumnsPolicy: UnresolvedColumnsPolicy): List<SortColumnDescriptor<*>>

group

fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C>

fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?>

Groups the specified columns within the DataFrame into column group.

fun <T> DataFrame<T>.~~group~~(vararg columns: KProperty<*>): GroupClause<T, Any?>

fun <T> DataFrame<T>.~~group~~(vararg columns: ColumnReference<*>): GroupClause<T, Any?>

groupBy

fun <T> DataFrame<T>.groupBy(vararg cols: String): GroupBy<T, T>

fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T>

Groups the rows of this DataFrame based on the values in one or more specified key columns. Each unique value in a key column — or a unique tuple of values for multiple columns — defines the group consisting of all rows where the column(s) contain that value combination.

fun <T> DataFrame<T>.~~groupBy~~(vararg cols: KProperty<*>): GroupBy<T, T>

fun <T> DataFrame<T>.~~groupBy~~(vararg cols: ColumnReference<*>, moveToTop: Boolean = true): GroupBy<T, T>

groupByImpl

@PublishedApi

internal fun <T> DataFrame<T>.groupByImpl(moveToTop: Boolean, columns: ColumnsSelector<T, *>): GroupBy<T, T>

head

fun <T> DataFrame<T>.head(numRows: Int = 5): DataFrame<T>

implode

fun <T> DataFrame<T>.implode(dropNA: Boolean = false): DataRow<T>

fun <T, C> DataFrame<T>.implode(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> DataFrame<T>.implode(vararg columns: String, dropNA: Boolean = false): DataFrame<T>

fun <T, C> DataFrame<T>.~~implode~~(vararg columns: KProperty<C>, dropNA: Boolean = false): DataFrame<T>

fun <T, C> DataFrame<T>.~~implode~~(vararg columns: ColumnReference<C>, dropNA: Boolean = false): DataFrame<T>

implodeImpl

internal fun <T, C> DataFrame<T>.implodeImpl(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T>

indices

fun DataFrame<*>.indices(): IntRange

Returns the indices of all rows in this DataFrame, from 0 to the number of rows minus one, or an empty range if this DataFrame has no rows.

inline fun <T> DataFrame<T>.indices(filter: RowFilter<T>): List<Int>

Returns the indices of the rows in this DataFrame that satisfy the given filter.

inferType

fun <T> DataFrame<T>.inferType(): DataFrame<T>

fun <T> DataFrame<T>.inferType(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.inferType(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.~~inferType~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~inferType~~(vararg columns: ColumnReference<*>): DataFrame<T>

innerJoin

fun <A, B> DataFrame<A>.innerJoin(other: DataFrame, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.innerJoin(other: DataFrame, vararg columns: String): DataFrame<A>

Performs an inner join of this DataFrame with the other DataFrame using the selected key columns. Includes only matching rows from both DataFrames; rows are merged.

innerJoinWith

fun <A, B> DataFrame<A>.innerJoinWith(right: DataFrame, joinExpression: JoinExpression<A, B>): DataFrame<A>

Performs an inner join of this DataFrame with the right DataFrame using the provided joinExpression. Includes only matching rows from both DataFrames; rows are merged.

insert

fun <T, C> DataFrame<T>.insert(column: DataColumn<C>): InsertClause<T>

Inserts the given column into this DataFrame.

inline fun <T, reified R> DataFrame<T>.insert(name: String, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): InsertClause<T>

Creates a new column using the provided expression and inserts it into this DataFrame.

inline fun <T, reified R> DataFrame<T>.~~insert~~(column: KProperty<R>, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): InsertClause<T>

inline fun <T, reified R> DataFrame<T>.~~insert~~(column: ColumnAccessor<R>, infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): InsertClause<T>

insertImpl

@JvmName(name = "insertImplT")

internal fun <T> DataFrame<T>.insertImpl(columns: List<ColumnToInsert>): DataFrame<T>

@PublishedApi

internal fun <T> DataFrame<T>.insertImpl(path: ColumnPath, column: AnyCol): DataFrame<T>

internal

@PublishedApi

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

@PublishedApi

internal fun <T> AggregateDsl<T>.internal(): AggregateInternalDsl<T>

@PublishedApi

internal fun <T> AggregateDsl<T>.internal(): AggregateInternalDsl<T>

into

infix inline fun <reified R> R.into(name: String): NamedValue

Adds the result of the aggregation operation to the resulting DataFrame or DataRow as a new column.

infix inline fun <reified R> R.~~into~~(column: KProperty<R>): NamedValue

infix inline fun <reified R> R.~~into~~(column: ColumnAccessor<R>): NamedValue

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

invoke

@JvmName(name = "stringInvokeTyped")

open operator fun <C> String.invoke(): DataColumn<C>

Retrieves the value of the column with this name from the DataFrame. This can be both typed and untyped. This is a shorthand for get("myColumnName") and can be written as "myColumnName"<MyColumnType>() instead.

@JvmName(name = "stringInvokeUntyped")

open operator fun String.invoke(): DataColumn<*>

open operator fun <T> KProperty<T>.~~invoke~~(): DataColumn<T>

open operator fun <T> KProperty<DataFrame<T>>.~~invoke~~(): FrameColumn<T>

open operator fun <T> KProperty<DataRow<T>>.~~invoke~~(): ColumnGroup<T>

Retrieves the value of this KProperty Accessor from the DataFrame.

open operator fun <C> ColumnPath.invoke(): DataColumn<C>

Retrieves the value of this ColumnPath from the DataFrame. This is a shorthand for getColumn(myColumnPath) and is most often used in combination with operator fun String.get(column: String), for instance:

open operator fun <C> ColumnReference<C>.invoke(): DataColumn<C>

open operator fun <T> ColumnReference<DataFrame<T>>.invoke(): FrameColumn<T>

open operator fun <T> ColumnReference<DataRow<T>>.invoke(): ColumnGroup<T>

Retrieves the value of this ColumnReference or -Accessor from the DataFrame.

isEmpty

fun DataFrame<*>.isEmpty(): Boolean

Returns true if this DataFrame has no rows or no columns.

isNotEmpty

fun DataFrame<*>.isNotEmpty(): Boolean

Returns true if this DataFrame has at least one row and at least one column, that is, if it is not empty.

iterator

open operator fun iterator(): Iterator<DataRow<T>>

join

fun <A, B> DataFrame<A>.join(other: DataFrame, type: JoinType = JoinType.Inner, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.join(other: DataFrame, vararg columns: String, type: JoinType = JoinType.Inner): DataFrame<A>

Joins this DataFrame with the other DataFrame using the selected key columns.

joinImpl

internal fun <A, B> DataFrame<A>.joinImpl(other: DataFrame, joinType: JoinType = JoinType.Inner, addNewColumns: Boolean = true, selector: JoinColumnsSelector<A, B>?): DataFrame<A>

joinWith

fun <A, B> DataFrame<A>.joinWith(right: DataFrame, type: JoinType = JoinType.Inner, joinExpression: JoinExpression<A, B>): DataFrame<A>

Joins this DataFrame with the right DataFrame using the provided joinExpression.

joinWithImpl

internal fun <A, B> DataFrame<A>.joinWithImpl(right: DataFrame, type: JoinType = JoinType.Inner, addNewColumns: Boolean, joinExpression: JoinExpression<A, B>): DataFrame<A>

last

fun <T> DataFrame<T>.last(): DataRow<T>

Returns the last row in this DataFrame.

inline fun <T> DataFrame<T>.last(predicate: RowFilter<T>): DataRow<T>

Returns the last row in this DataFrame that satisfies the given predicate.

lastOrNull

fun <T> DataFrame<T>.lastOrNull(): DataRow<T>?

Returns the last row in this DataFrame. If the DataFrame does not contain any rows, returns null.

inline fun <T> DataFrame<T>.lastOrNull(predicate: RowFilter<T>): DataRow<T>?

Returns the last row in this DataFrame that satisfies the given predicate. Returns null if the DataFrame contains no rows matching the predicate (including the case when the DataFrame is empty).

leftJoin

fun <A, B> DataFrame<A>.leftJoin(other: DataFrame, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.leftJoin(other: DataFrame, vararg columns: String): DataFrame<A>

Performs a left join of this DataFrame with the other DataFrame using the selected key columns. Includes all rows from the left DataFrame; matching rows are merged, unmatched right-side values are filled with null.

leftJoinWith

fun <A, B> DataFrame<A>.leftJoinWith(right: DataFrame, joinExpression: JoinExpression<A, B>): DataFrame<A>

Performs a left join of this DataFrame with the right DataFrame using the provided joinExpression. Includes all rows from the left DataFrame; matching rows are merged, unmatched right-side values are filled with null.

map

inline fun <T, R> DataFrame<T>.map(transform: RowExpression<T, R>): List<R>

Returns a List with the values that transform computes from the rows of this DataFrame.

mapToColumn

inline fun <T, reified R> ColumnsContainer<T>.~~mapToColumn~~(name: String, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>

Returns a new DataColumn with the given name and the values that body computes from the rows of this ColumnsContainer.

inline fun <T, reified R> ColumnsContainer<T>.~~mapToColumn~~(column: KProperty<R>, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>

inline fun <T, reified R> ColumnsContainer<T>.~~mapToColumn~~(column: ColumnReference<R>, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>

@PublishedApi

internal fun <T, R> ColumnsContainer<T>.mapToColumn(name: String, type: KType, infer: Infer = Infer.Nulls, body: AddExpression<T, R>): DataColumn<R>

fun <T, R> ColumnsContainer<T>.~~mapToColumn~~(column: KProperty<R>, type: KType, infer: Infer = Infer.Nulls, body: AddExpression<T, R>): DataColumn<R>

fun <T, R> ColumnsContainer<T>.~~mapToColumn~~(column: ColumnReference<R>, type: KType, infer: Infer = Infer.Nulls, body: AddExpression<T, R>): DataColumn<R>

inline fun <T, reified R> DataFrame<T>.mapToColumn(name: String, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>

Returns a new DataColumn with the given name and the values that body computes from the rows of this DataFrame.

mapToFrame

inline fun <T> DataFrame<T>.mapToFrame(body: AddDsl<T>.() -> Unit): DataFrame<*>

Returns a new DataFrame made of the columns described in body.

max

fun <T> DataFrame<T>.max(skipNaN: Boolean = skipNaNDefault): DataRow<T>

Returns the maximum of the values of each suitable column of this DataFrame separately.

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

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

Returns a single maximum of all the values in the selected columns of this DataFrame.

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

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

maxBy

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

Returns the first row of this DataFrame for which the given expression returns the maximum value.

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

Returns the first row of this DataFrame that has the largest value in the column with the given name.

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

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

maxByOrNull

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

Returns the first row of this DataFrame for which the given expression returns the maximum value, or null if there is nothing to compare.

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

Returns the first row of this DataFrame that has the largest value in the column with the given name, or null if there is nothing to compare.

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.~~maxByOrNull~~(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.~~maxByOrNull~~(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

maxDepth

internal fun AnyFrame.maxDepth(startingAt: Int = 0): Int

Returns the depth of the most-nested column in this df/group, starting at 0

maxFor

fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataRow<T>

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

Returns the maximum of the values of each selected column of this DataFrame separately.

fun <T, C : Comparable<*>?> DataFrame<T>.~~maxFor~~(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>

fun <T, C : Comparable<*>?> DataFrame<T>.~~maxFor~~(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>

maxOf

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

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

maxOfOrNull

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

Returns the maximum of the values that the given expression returns for each row of this DataFrame, or null if there is nothing to compare.

maxOrNull

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

fun <T> DataFrame<T>.maxOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>?

Returns a single maximum of all the values in the selected columns of this DataFrame, or null if there is nothing to compare.

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

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

mean

fun <T> DataFrame<T>.mean(skipNaN: Boolean = skipNaNDefault): DataRow<T>

Returns the mean of the values of each suitable column of this DataFrame separately.

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

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

Returns a single mean of means of the selected columns of this DataFrame, as a Double.

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

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

meanFor

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

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

Returns the mean of the values of each selected column of this DataFrame separately.

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

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

meanOf

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

Returns the mean of the values that the given expression returns for each row of this DataFrame, as a Double.

median

fun <T> DataFrame<T>.median(skipNaN: Boolean = skipNaNDefault): DataRow<T>

Returns the median of the values of each suitable column of this DataFrame separately.

fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C & Any

Returns a single median of all the comparable values in the selected columns of this DataFrame.

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

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

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

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

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

Returns a single median of all the numbers in the selected columns of this DataFrame, as a Double.

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

Returns a single median of all the values in the columns of this DataFrame with the given names.

medianBy

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.

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.

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

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

medianByOrNull

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(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, or null if there is nothing to compute the median of.

fun <T> DataFrame<T>.medianByOrNull(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, or null if there is nothing to compute the median of.

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.~~medianByOrNull~~(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.~~medianByOrNull~~(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

medianFor

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

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

Returns the median of the values of each selected column of this DataFrame separately.

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

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

medianOf

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

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

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

Returns the median of the numbers that the given expression returns for each row of this DataFrame, as a Double.

medianOfOrNull

inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOfOrNull(crossinline expression: RowExpression<T, R>): R?

Returns the median of the comparable values that the given expression returns for each row of this DataFrame, or null if there is nothing to compute the median of.

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

Returns the median of the numbers that the given expression returns for each row of this DataFrame, as a Double, or null if there is nothing to compute the median of.

medianOrNull

fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C?

Returns a single median of all the comparable values in the selected columns of this DataFrame, or null if there is nothing to compute the median of.

fun <T, C : Comparable<C & Any>?> DataFrame<T>.~~medianOrNull~~(vararg columns: KProperty<C>): C?

fun <T, C : Comparable<C & Any>?> DataFrame<T>.~~medianOrNull~~(vararg columns: ColumnReference<C>): C?

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

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

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

Returns a single median of all the numbers in the selected columns of this DataFrame, as a Double, or null if there is nothing to compute the median of.

fun <T> DataFrame<T>.medianOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Any?

Returns a single median of all the values in the columns of this DataFrame with the given names, or null if there is nothing to compute the median of.

merge

fun <T, C> DataFrame<T>.merge(selector: ColumnsSelector<T, C>): Merge<T, C, List<C>>

fun <T> DataFrame<T>.merge(vararg columns: String): Merge<T, Any?, List<Any?>>

inline fun <T, reified C> DataFrame<T>.~~merge~~(vararg columns: KProperty<C>): Merge<T, C, List<C>>

inline fun <T, reified C> DataFrame<T>.~~merge~~(vararg columns: ColumnReference<C>): Merge<T, C, List<C>>

min

fun <T> DataFrame<T>.min(skipNaN: Boolean = skipNaNDefault): DataRow<T>

Returns the minimum of the values of each suitable column of this DataFrame separately.

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

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

Returns a single minimum of all the values in the selected columns of this DataFrame.

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

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

minBy

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

Returns the first row of this DataFrame for which the given expression returns the minimum value.

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

Returns the first row of this DataFrame that has the smallest value in the column with the given name.

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

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

minByOrNull

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

Returns the first row of this DataFrame for which the given expression returns the minimum value, or null if there is nothing to compare.

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

Returns the first row of this DataFrame that has the smallest value in the column with the given name, or null if there is nothing to compare.

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.~~minByOrNull~~(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.~~minByOrNull~~(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

minFor

fun <T, C : Comparable<*>?> DataFrame<T>.minFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataRow<T>

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

Returns the minimum of the values of each selected column of this DataFrame separately.

fun <T, C : Comparable<*>?> DataFrame<T>.~~minFor~~(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>

fun <T, C : Comparable<*>?> DataFrame<T>.~~minFor~~(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>

minOf

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

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

minOfOrNull

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

Returns the minimum of the values that the given expression returns for each row of this DataFrame, or null if there is nothing to compare.

minOrNull

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

fun <T> DataFrame<T>.minOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>?

Returns a single minimum of all the values in the selected columns of this DataFrame, or null if there is nothing to compare.

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

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

minus

infix operator fun <T> DataFrame<T>.~~minus~~(columns: ColumnsSelector<T, *>): DataFrame<T>

infix operator fun <T> DataFrame<T>.~~minus~~(column: String): DataFrame<T>

infix operator fun <T> DataFrame<T>.~~minus~~(columns: KProperty<*>): DataFrame<T>

infix operator fun <T> DataFrame<T>.~~minus~~(column: ColumnReference<*>): DataFrame<T>

move

fun <T, C> DataFrame<T>.move(columns: ColumnsSelector<T, C>): MoveClause<T, C>

fun <T> DataFrame<T>.move(vararg columns: String): MoveClause<T, Any?>

Moves the specified columns within the DataFrame.

fun <T, C> DataFrame<T>.~~move~~(vararg columns: KProperty<C>): MoveClause<T, C>

fun <T, C> DataFrame<T>.~~move~~(vararg columns: ColumnReference<C>): MoveClause<T, C>

moveTo

fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: String): DataFrame<T>

Moves the specified columns to a new position specified by newColumnIndex within the DataFrame.

fun <T> DataFrame<T>.~~moveTo~~(newColumnIndex: Int, vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~moveTo~~(newColumnIndex: Int, vararg columns: ColumnReference<*>): DataFrame<T>

fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, insideGroup: Boolean, columns: ColumnsSelector<T, *>): DataFrame<T>

Moves the specified columns to a new position specified by newColumnIndex. If insideGroup is true selected columns will be moved remaining within their ColumnGroup, else they will be moved to the top level.

moveToEnd

fun <T> DataFrame<T>.moveToEnd(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.moveToEnd(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.moveToEnd(insideGroup: Boolean, columns: ColumnsSelector<T, *>): DataFrame<T>

Moves the specified columns to the DataFrame end. Returns a new DataFrame with an updated column structure.

fun <T> DataFrame<T>.~~moveToEnd~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~moveToEnd~~(vararg columns: ColumnReference<*>): DataFrame<T>

moveToLeft

fun <T> DataFrame<T>.~~moveToLeft~~(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.~~moveToLeft~~(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.~~moveToLeft~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~moveToLeft~~(vararg columns: ColumnReference<*>): DataFrame<T>

moveToRight

fun <T> DataFrame<T>.~~moveToRight~~(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.~~moveToRight~~(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.~~moveToRight~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~moveToRight~~(vararg columns: ColumnReference<*>): DataFrame<T>

moveToStart

fun <T> DataFrame<T>.moveToStart(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.moveToStart(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.moveToStart(insideGroup: Boolean, columns: ColumnsSelector<T, *>): DataFrame<T>

Moves the specified columns to the DataFrame start (on top-level). Returns a new DataFrame with an updated column structure.

fun <T> DataFrame<T>.~~moveToStart~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~moveToStart~~(vararg columns: ColumnReference<*>): DataFrame<T>

nameGenerator

internal fun AnyFrame.nameGenerator(): ColumnNameGenerator

newColumn

@PublishedApi

internal fun <T, R> ColumnsContainer<T>.newColumn(type: KType, name: String = "", infer: Infer = Infer.Nulls, expression: AddExpression<T, R>): DataColumn<R>

newColumnWithActualType

@PublishedApi

internal fun <T, R> ColumnsContainer<T>.newColumnWithActualType(name: String, expression: AddExpression<T, R>): DataColumn<R>

none

inline fun <T> DataFrame<T>.none(predicate: RowFilter<T>): Boolean

Returns true if none of the rows in this DataFrame satisfies the given predicate.

numberColumns

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

parse

fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T>

fun <T> DataFrame<T>.parse(options: ParserOptions? = null, columns: ColumnsSelector<T, Any?>): DataFrame<T>

fun <T> DataFrame<T>.parse(vararg columns: String, options: ParserOptions? = null): DataFrame<T>

fun <T, C> DataFrame<T>.~~parse~~(vararg columns: KProperty<C>, options: ParserOptions? = null): DataFrame<T>

fun <T, C> DataFrame<T>.~~parse~~(vararg columns: ColumnReference<C>, options: ParserOptions? = null): DataFrame<T>

parseImpl

internal fun <T> DataFrame<T>.parseImpl(options: ParserOptions?, columns: ColumnsSelector<T, Any?>): DataFrame<T>

percentile

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

Returns the given percentile of the values of each suitable column of this DataFrame separately.

fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(percentile: Double, columns: ColumnsSelector<T, C>): C & Any

Returns a single percentile of all the comparable values in the selected columns of this DataFrame.

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

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

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

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

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

Returns a single percentile of all the numbers in the selected columns of this DataFrame, as a Double.

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

Returns a single percentile of all the values in the columns of this DataFrame with the given names.

percentileBy

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

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

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

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

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

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

percentileByOrNull

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

Returns the row of this DataFrame at the given percentile of the values that the given expression returns for each row, or null if there is nothing to compute the percentile of.

fun <T> DataFrame<T>.percentileByOrNull(percentile: Double, column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>?

Returns the row of this DataFrame at the given percentile of the values in the column with the given name, or null if there is nothing to compute the percentile of.

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

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

percentileFor

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

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

Returns the given percentile of the values of each selected column of this DataFrame separately.

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

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

percentileOf

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

Returns the given percentile of the comparable values that the given expression returns for each row of this DataFrame.

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

Returns the given percentile of the numbers that the given expression returns for each row of this DataFrame, as a Double.

percentileOfOrNull

inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOfOrNull(percentile: Double, crossinline expression: RowExpression<T, R>): R?

Returns the given percentile of the comparable values that the given expression returns for each row of this DataFrame, or null if there is nothing to compute the percentile of.

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

Returns the given percentile of the numbers that the given expression returns for each row of this DataFrame, as a Double, or null if there is nothing to compute the percentile of.

percentileOrNull

fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(percentile: Double, columns: ColumnsSelector<T, C>): C?

Returns a single percentile of all the comparable values in the selected columns of this DataFrame, or null if there is nothing to compute the percentile of.

fun <T, C : Comparable<C & Any>?> DataFrame<T>.~~percentileOrNull~~(percentile: Double, vararg columns: KProperty<C>): C?

fun <T, C : Comparable<C & Any>?> DataFrame<T>.~~percentileOrNull~~(percentile: Double, vararg columns: ColumnReference<C>): C?

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

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

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

Returns a single percentile of all the numbers in the selected columns of this DataFrame, as a Double, or null if there is nothing to compute the percentile of.

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

Returns a single percentile of all the values in the columns of this DataFrame with the given names, or null if there is nothing to compute the percentile of.

pivot

fun <T> DataFrame<T>.pivot(inward: Boolean? = null, columns: PivotColumnsSelector<T, *>): Pivot<T>

fun <T> DataFrame<T>.pivot(vararg columns: String, inward: Boolean? = null): Pivot<T>

Splits the rows of this DataFrame and groups them horizontally into new columns based on values from one or several provided columns of the original DataFrame.

fun <T> DataFrame<T>.~~pivot~~(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot<T>

fun <T> DataFrame<T>.~~pivot~~(vararg columns: ColumnReference<*>, inward: Boolean? = null): Pivot<T>

fun <T> AggregateGroupedDsl<T>.~~pivot~~(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<T>

fun <T> AggregateGroupedDsl<T>.~~pivot~~(vararg columns: ColumnReference<*>, inward: Boolean = true): PivotGroupBy<T>

fun <T> AggregateGroupedDsl<T>.pivot(inward: Boolean = true, columns: PivotColumnsSelector<T, *>): PivotGroupBy<T>

fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<T>

Pivots the selected columns within each group for further pivot aggregations.

pivotCounts

fun <T> DataFrame<T>.pivotCounts(inward: Boolean = true, columns: PivotColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T>

Computes a count matrix (similar to frequency encoding) for the values in the specified columns of this DataFrame, returning a new DataFrame where:

fun <T> DataFrame<T>.~~pivotCounts~~(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T>

fun <T> DataFrame<T>.~~pivotCounts~~(vararg columns: ColumnReference<*>, inward: Boolean = true): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.~~pivotCounts~~(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.~~pivotCounts~~(vararg columns: ColumnReference<*>, inward: Boolean = true): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.pivotCounts(inward: Boolean = true, columns: PivotColumnsSelector<T, *>): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T>

Computes the pivotCounts statistic for the selected columns within each group and adds it to the aggregate result.

pivotMatches

fun <T> DataFrame<T>.pivotMatches(inward: Boolean = true, columns: PivotColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T>

Computes a presence matrix (similar to one-hot encoding) for the values in the specified columns of this DataFrame, returning a new DataFrame where:

fun <T> DataFrame<T>.~~pivotMatches~~(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T>

fun <T> DataFrame<T>.~~pivotMatches~~(vararg columns: ColumnReference<*>, inward: Boolean = true): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.~~pivotMatches~~(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.~~pivotMatches~~(vararg columns: ColumnReference<*>, inward: Boolean = true): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.pivotMatches(inward: Boolean = true, columns: PivotColumnsSelector<T, *>): DataFrame<T>

fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T>

Computes the pivotMatches statistic for the selected columns within each group and adds it to the aggregate result.

plus

open operator fun plus(cols: Iterable<AnyBaseCol>): DataFrame<T>

open operator fun plus(col: AnyBaseCol): DataFrame<T>

prepareTable

internal fun AnyFrame.prepareTable(rowsLimit: Int?, valueLimit: Int?, columnTypes: Boolean, rowIndex: Boolean, escapeValue: (String) -> String = { it }): PreparedTable

primitiveOrMixedNumberColumns

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

fun <T> DataFrame<T>.print(rowsLimit: Int? = 20, valueLimit: Int? = 40, borders: Boolean = false, alignLeft: Boolean = false, columnTypes: Boolean = true, title: Boolean = false, rowIndex: Boolean = true, borderStyle: StringBorderStyle = StringBorderStyle.DottedLineWithRounderCorners)

properties

fun <T> DataFrame<T>.properties(): ColumnsScope<T>

Utility property to access scope with only dataframe column properties for code completion, filtering out DataFrame API.

remainingColumns

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

remainingColumnsSelector

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

remove

fun <T> DataFrame<T>.remove(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.remove(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.~~remove~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~remove~~(vararg columns: ColumnReference<*>): DataFrame<T>

Removes the specified columns from the original DataFrame and returns a new DataFrame without them.

removeImpl

internal fun <T> DataFrame<T>.removeImpl(allowMissingColumns: Boolean = false, columns: ColumnsSelector<T, *>): RemoveResult<T>

rename

fun <T, C> DataFrame<T>.rename(columns: ColumnsSelector<T, C>): RenameClause<T, C>

Renames the specified columns keeping their original values and location within the DataFrame.

fun <T> DataFrame<T>.rename(vararg mappings: Pair<String, String>): DataFrame<T>

Renames columns in the DataFrame.

fun <T> DataFrame<T>.rename(vararg cols: String): RenameClause<T, Any?>

Renames the specified columns keeping their original values and location within the DataFrame.

fun <T, C> DataFrame<T>.~~rename~~(vararg cols: KProperty<C>): RenameClause<T, C>

fun <T, C> DataFrame<T>.~~rename~~(vararg cols: ColumnReference<C>): RenameClause<T, C>

renameToCamelCase

fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T>

Renames all columns in this DataFrame to the "camelCase" format.

render

internal fun DataFrame<ValueCount>.render(): List<Counts>

renderToMarkdown

fun AnyFrame.renderToMarkdown(rowsLimit: Int? = 20, valueLimit: Int? = 40, alignment: MarkdownAlignment = MarkdownAlignment.UNSPECIFIED, columnTypes: Boolean = false, title: Boolean = false, rowIndex: Boolean = true): String

renderToString

fun AnyFrame.renderToString(rowsLimit: Int? = 20, valueLimit: Int? = 40, borders: Boolean = false, alignLeft: Boolean = false, columnTypes: Boolean = true, title: Boolean = false, rowIndex: Boolean = true, borderStyle: StringBorderStyle = StringBorderStyle.DottedLineWithRounderCorners): String

reorder

fun <T, C> DataFrame<T>.reorder(selector: ColumnsSelector<T, C>): Reorder<T, C>

fun <T> DataFrame<T>.reorder(vararg columns: String): Reorder<T, *>

Reorders the selected columns of the DataFrame.

fun <T, C> DataFrame<T>.~~reorder~~(vararg columns: KProperty<C>): Reorder<T, C>

fun <T, C> DataFrame<T>.~~reorder~~(vararg columns: ColumnReference<C>): Reorder<T, C>

reorderColumnsBy

fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(atAnyDepth: Boolean = true, desc: Boolean = false, expression: Selector<DataColumn<*>, V>): DataFrame<T>

fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(atAnyDepth: Boolean = true, desc: Boolean = false, inFrameColumns: Boolean, expression: Selector<DataColumn<*>, V>): DataFrame<T>

Puts all columns of the DataFrame in order of the value of the expression and returns a new DataFrame.

reorderColumnsByName

fun <T> DataFrame<T>.reorderColumnsByName(atAnyDepth: Boolean = true, desc: Boolean = false): DataFrame<T>

fun <T> DataFrame<T>.reorderColumnsByName(atAnyDepth: Boolean = true, desc: Boolean = false, inFrameColumns: Boolean): DataFrame<T>

Puts all columns of the DataFrame in lexicographic order of their names and returns a new DataFrame.

replace

fun <T, C> DataFrame<T>.replace(columns: ColumnsSelector<T, C>): ReplaceClause<T, C>

fun <T> DataFrame<T>.replace(vararg columns: String): ReplaceClause<T, Any?>

fun <T, C> DataFrame<T>.~~replace~~(vararg columns: KProperty<C>): ReplaceClause<T, C>

fun <T, C> DataFrame<T>.~~replace~~(vararg columns: ColumnReference<C>): ReplaceClause<T, C>

replaceAll

fun <T> DataFrame<T>.replaceAll(vararg valuePairs: Pair<Any?, Any?>, columns: ColumnsSelector<T, *> = { colsAtAnyDepth().filter { !it.isColumnGroup() } }): DataFrame<T>

requireColumn

inline fun <T, reified C> DataFrame<T>.requireColumn(noinline column: ColumnSelector<T, C>): DataFrame<T>

Resolves column in this DataFrame and checks that its runtime type is a subtype of C. Throws if the column can't be resolved or if its type doesn't match.

requireImpl

@PublishedApi

internal fun <T, C> DataFrame<T>.requireImpl(column: ColumnSelector<T, C>, type: KType): DataFrame<T>

reverse

fun <T> DataFrame<T>.reverse(): DataFrame<T>

Returns a new DataFrame with the same rows in reversed order, so the last row becomes the first one.

rightJoin

fun <A, B> DataFrame<A>.rightJoin(other: DataFrame, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>

fun <A, B> DataFrame<A>.rightJoin(other: DataFrame, vararg columns: String): DataFrame<A>

Performs a right join of this DataFrame with the other DataFrame using the selected key columns. Includes all rows from the right DataFrame; matching rows are merged, unmatched left-side values are filled with null.

rightJoinWith

fun <A, B> DataFrame<A>.rightJoinWith(right: DataFrame, joinExpression: JoinExpression<A, B>): DataFrame<A>

Performs a right join of this DataFrame with the right DataFrame using the provided joinExpression. Includes all rows from the right DataFrame; matching rows are merged, unmatched left-side values are filled with null.

rows

fun <T> DataFrame<T>.rows(): Iterable<DataRow<T>>

rowsCount

abstract fun rowsCount(): Int

Returns the total number of rows of this DataFrame.

rowsReversed

fun <T> DataFrame<T>.rowsReversed(): Iterable<DataRow<T>>

schema

fun DataFrame<*>.schema(): DataFrameSchema

Returns the runtime DataFrameSchema of this DataFrame, read from the columns it holds.

select

fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T>

fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.~~select~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~select~~(vararg columns: ColumnReference<*>): DataFrame<T>

Returns a new DataFrame with only the columns selected by columns.

shuffle

fun <T> DataFrame<T>.shuffle(): DataFrame<T>

Returns a new DataFrame with rows in random order using the default randomness.

fun <T> DataFrame<T>.shuffle(random: Random): DataFrame<T>

Returns a new DataFrame with rows reordered randomly using the provided random source.

single

fun <T> DataFrame<T>.single(): DataRow<T>

Returns the single row in this DataFrame.

inline fun <T> DataFrame<T>.single(predicate: RowFilter<T>): DataRow<T>

Returns the single row in this DataFrame that satisfies the given predicate.

singleOrNull

fun <T> DataFrame<T>.singleOrNull(): DataRow<T>?

Returns the single row in this DataFrame. Returns null if the DataFrame contains no rows or contains more than one row.

inline fun <T> DataFrame<T>.singleOrNull(predicate: RowFilter<T>): DataRow<T>?

Returns the single row in this DataFrame that satisfies the given predicate. Returns null if the DataFrame contains no rows matching the predicate (including the case when the DataFrame is empty) or contains more than one row matching the predicate.

size

fun AnyFrame.size(): DataFrameSize

sortBy

fun <T, C> DataFrame<T>.sortBy(columns: SortColumnsSelector<T, C>): DataFrame<T>

Sorts this DataFrame rows by the specified columns in ascending (default) or descending order.

fun <T> DataFrame<T>.sortBy(vararg cols: String): DataFrame<T>

Sorts this DataFrame rows by the specified columns in ascending order.

fun <T> DataFrame<T>.~~sortBy~~(vararg cols: KProperty<Comparable<*>?>): DataFrame<T>

fun <T> DataFrame<T>.~~sortBy~~(vararg cols: ColumnReference<*>): DataFrame<T>

sortByDesc

fun <T, C> DataFrame<T>.sortByDesc(columns: SortColumnsSelector<T, C>): DataFrame<T>

Sorts this DataFrame rows by the specified columns in ascending or descending (default) order.

fun <T> DataFrame<T>.sortByDesc(vararg columns: String): DataFrame<T>

Sorts this DataFrame rows by the specified columns in descending order.

fun <T, C> DataFrame<T>.~~sortByDesc~~(vararg columns: KProperty<Comparable<C>?>): DataFrame<T>

fun <T> DataFrame<T>.~~sortByDesc~~(vararg columns: ColumnReference<*>): DataFrame<T>

sortByImpl

internal fun <T, C> DataFrame<T>.sortByImpl(unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail, columns: SortColumnsSelector<T, C>): DataFrame<T>

sortWith

fun <T> DataFrame<T>.sortWith(comparator: Comparator<DataRow<T>>): DataFrame<T>

fun <T> DataFrame<T>.sortWith(comparator: (DataRow<T>, DataRow<T>) -> Int): DataFrame<T>

Sorts the rows of this DataFrame using the specified row comparator.

split

fun <T, C> DataFrame<T>.split(columns: ColumnsSelector<T, C?>): Split<T, C>

fun <T> DataFrame<T>.split(vararg columns: String): Split<T, Any>

fun <T, C> DataFrame<T>.~~split~~(vararg columns: KProperty<C?>): Split<T, C>

fun <T, C> DataFrame<T>.~~split~~(vararg columns: ColumnReference<C?>): Split<T, C>

splitByIndices

internal fun <T> DataFrame<T>.splitByIndices(startIndices: Sequence<Int>): Sequence<DataFrame<T>>

std

fun <T, C : Number?> DataFrame<T>.~~std~~(vararg columns: KProperty<C>): Double

fun <T, C : Number?> DataFrame<T>.~~std~~(vararg columns: ColumnReference<C>): Double

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

Returns the standard deviation of the values of each suitable column of this DataFrame separately.

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

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

Returns a single standard deviation of all the values in the selected columns of this DataFrame, as a Double.

stdFor

fun <T, C : Number?> DataFrame<T>.stdFor(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, columns: ColumnsForAggregateSelector<T, C>): DataRow<T>

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

Returns the standard deviation of the values of each selected column of this DataFrame separately.

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

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

stdOf

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

Returns the standard deviation of the values that the given expression returns for each row of this DataFrame, as a Double.

sum

fun <T> DataFrame<T>.sum(skipNaN: Boolean = skipNaNDefault): DataRow<T>

Returns the sum of the values of each suitable column of this DataFrame separately.

@JvmName(name = "sumByte")

fun <T, C : Byte?> DataFrame<T>.sum(columns: ColumnsSelector<T, C>): Int

Returns a single sum of all the Byte values in the selected columns of this DataFrame, as an Int.

@JvmName(name = "sumShort")

fun <T, C : Short?> DataFrame<T>.sum(columns: ColumnsSelector<T, C>): Int

Returns a single sum of all the Short values in the selected columns of this DataFrame, as an Int.

@JvmName(name = "sumByte")

fun <T> DataFrame<T>.~~sum~~(vararg columns: KProperty<Byte?>): Int

@JvmName(name = "sumShort")

fun <T> DataFrame<T>.~~sum~~(vararg columns: KProperty<Short?>): Int

@JvmName(name = "sumByte")

fun <T, C : Byte?> DataFrame<T>.~~sum~~(vararg columns: ColumnReference<C>): Int

@JvmName(name = "sumShort")

fun <T, C : Short?> DataFrame<T>.~~sum~~(vararg columns: ColumnReference<C>): Int

@JvmName(name = "sumNumber")

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

@JvmName(name = "sumNumber")

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

@JvmName(name = "sumNumber")

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

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

Returns a single sum of all the values in the selected columns of this DataFrame.

sumFor

fun <T, C : Number?> DataFrame<T>.sumFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataRow<T>

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

Returns the sum of the values of each selected column of this DataFrame separately.

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

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

sumOf

@JvmName(name = "sumOfByte")

inline fun <T, reified C : Byte?> DataFrame<T>.sumOf(crossinline expression: RowExpression<T, C>): Int

Returns the sum of the Byte values that the given expression returns for each row of this DataFrame, as an Int.

@JvmName(name = "sumOfShort")

inline fun <T, reified C : Short?> DataFrame<T>.sumOf(crossinline expression: RowExpression<T, C>): Int

Returns the sum of the Short values that the given expression returns for each row of this DataFrame, as an Int.

@JvmName(name = "sumOfNumber")

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

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

tail

fun <T> DataFrame<T>.tail(numRows: Int = 5): DataFrame<T>

Returns a DataFrame containing the last numRows rows.

take

fun <T> DataFrame<T>.take(n: Int): DataFrame<T>

Returns a DataFrame containing the first n rows.

takeLast

fun <T> DataFrame<T>.takeLast(n: Int = 1): DataFrame<T>

Returns a DataFrame containing the last n rows.

takeWhile

inline fun <T> DataFrame<T>.takeWhile(predicate: RowFilter<T>): DataFrame<T>

Returns a DataFrame containing the first rows that satisfy the given predicate.

toCsv

fun AnyFrame.~~toCsv~~(format: CSVFormat = CSVFormat.DEFAULT): String

toHTML

fun <T> DataFrame<T>.~~toHTML~~(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT, cellRenderer: CellRenderer = DefaultCellRenderer, getFooter: (DataFrame<T>) -> String? = { "DataFrame [${it.size}]" }): DataFrameHtmlData

toHtml

fun <T> DataFrame<T>.toHtml(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT, cellRenderer: CellRenderer = DefaultCellRenderer, getFooter: (DataFrame<T>) -> String? = { "DataFrame [${it.size}]" }): DataFrameHtmlData

Returns a DataFrameHtmlData without additional definitions. Can be rendered in Jupyter kernel (Kotlin Notebook) environments or other environments that already have CSS- and script definitions for DataFrame.

toHtmlData

internal fun AnyFrame.toHtmlData(defaultConfiguration: DisplayConfiguration = DisplayConfiguration.DEFAULT, cellRenderer: CellRenderer): DataFrameHtmlData

toList

inline fun <reified T> DataFrame<T>.toList(): List<T>

Converts this DataFrame into a List of T instances, where T is the type argument of this DataFrame.

toListOf

inline fun <reified T> DataFrame<*>.toListOf(): List<T>

Converts this DataFrame into a List of T instances, where T is given explicitly as the type argument of this call.

toMap

fun DataFrame<*>.toMap(): Map<String, List<Any?>>

toSequence

inline fun <reified T> DataFrame<T>.toSequence(): Sequence<T>

Converts this DataFrame into a Sequence of T instances, where T is the type argument of this DataFrame.

toSequenceImpl

@PublishedApi

internal fun AnyFrame.toSequenceImpl(type: KType): Sequence<Any>

toSequenceOf

inline fun <reified T> DataFrame<*>.toSequenceOf(): Sequence<T>

Converts this DataFrame into a Sequence of T instances, where T is given explicitly as the type argument of this call.

toStandaloneHTML

fun <T> DataFrame<T>.~~toStandaloneHTML~~(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT, cellRenderer: CellRenderer = DefaultCellRenderer, getFooter: (DataFrame<T>) -> String? = { "DataFrame [${it.size}]" }): DataFrameHtmlData

toStandaloneHtml

fun <T> DataFrame<T>.toStandaloneHtml(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT, cellRenderer: CellRenderer = DefaultCellRenderer, getFooter: (DataFrame<T>) -> String? = { "DataFrame [${it.size}]" }): DataFrameHtmlData

Returns a DataFrameHtmlData with CSS- and script definitions for DataFrame.

toStaticHtml

fun AnyFrame.toStaticHtml(configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT, cellRenderer: CellRenderer = DefaultCellRenderer, includeCss: Boolean = true, openNestedDfs: Boolean = false): DataFrameHtmlData

Renders this DataFrame as static HTML (meaning no JS is used). CSS rendering is enabled by default but can be turned off using includeCss

unfold

fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T>

fun <T> DataFrame<T>.unfold(vararg roots: KCallable<*>, maxDepth: Int = 0, columns: ColumnsSelector<T, *>): DataFrame<T>

Returns a new DataFrame in which the selected columns of objects are turned into ColumnGroups, with a column for every public property of these objects. The other columns and the order of the columns stay the same.

fun <T> DataFrame<T>.~~unfold~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~unfold~~(vararg columns: ColumnReference<*>): DataFrame<T>

ungroup

fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFrame<T>

fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T>

Ungroups the specified column groups within the DataFrame, i.e., replaces each ColumnGroup with its nested columns.

fun <T> DataFrame<T>.~~ungroup~~(vararg columns: KProperty<*>): DataFrame<T>

fun <T> DataFrame<T>.~~ungroup~~(vararg columns: ColumnReference<*>): DataFrame<T>

update

fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C>

fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?>

fun <T, C> DataFrame<T>.~~update~~(vararg columns: KProperty<C>): Update<T, C>

fun <T, C> DataFrame<T>.~~update~~(vararg columns: ColumnReference<C>): Update<T, C>

fun <T> DataFrame<T>.update(firstCol: String, vararg cols: String, expression: UpdateExpression<T, Any?, Any?>): DataFrame<T>

fun <T, C> DataFrame<T>.~~update~~(firstCol: KProperty<C>, vararg cols: KProperty<C>, expression: UpdateExpression<T, C, C>): DataFrame<T>

fun <T, C> DataFrame<T>.~~update~~(firstCol: ColumnReference<C>, vararg cols: ColumnReference<C>, expression: UpdateExpression<T, C, C>): DataFrame<T>

Returns the DataFrame with changed values in some cells (column types cannot be changed).

valueCounts

fun <T> DataFrame<T>.valueCounts(sort: Boolean = true, ascending: Boolean = false, dropNA: Boolean = true, resultColumn: String = defaultCountColumnName, columns: ColumnsSelector<T, *>? = null): DataFrame<T>

fun <T> DataFrame<T>.valueCounts(vararg columns: String, sort: Boolean = true, ascending: Boolean = false, dropNA: Boolean = true, resultColumn: String = defaultCountColumnName): DataFrame<T>

Returns a DataFrame containing the counts of unique rows (or combinations of selected values) in this DataFrame.

fun <T> DataFrame<T>.~~valueCounts~~(vararg columns: KProperty<*>, sort: Boolean = true, ascending: Boolean = false, dropNA: Boolean = true, resultColumn: String = defaultCountColumnName): DataFrame<T>

fun <T> DataFrame<T>.~~valueCounts~~(vararg columns: ColumnReference<*>, sort: Boolean = true, ascending: Boolean = false, dropNA: Boolean = true, resultColumn: String = defaultCountColumnName): DataFrame<T>

values

fun <T> DataFrame<T>.values(byRows: Boolean = false): Sequence<Any?>

fun <T, C> DataFrame<T>.values(byRow: Boolean = false, columns: ColumnsSelector<T, C>): Sequence<C>

valuesImpl

internal fun <T, C> DataFrame<T>.valuesImpl(byRow: Boolean, columns: ColumnsSelector<T, C>): Sequence<C>

valuesNotNull

fun <T> DataFrame<T>.valuesNotNull(byRow: Boolean = false): Sequence<Any>

fun <T, C> DataFrame<T>.valuesNotNull(byRow: Boolean = false, columns: ColumnsSelector<T, C?>): Sequence<C>

writeCSV

fun AnyFrame.~~writeCSV~~(file: File, format: CSVFormat = CSVFormat.DEFAULT)

fun AnyFrame.~~writeCSV~~(writer: Appendable, format: CSVFormat = CSVFormat.DEFAULT)

fun AnyFrame.~~writeCSV~~(path: String, format: CSVFormat = CSVFormat.DEFAULT)

fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T>

Returns a cross-section of this DataFrame: only the rows in which the key columns hold the given keyValues, without those key columns.

fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T>

Returns a cross-section of this DataFrame: only the rows in which the key columns hold the given keyValues, without those key columns.

xsImpl

internal fun <T, C> DataFrame<T>.xsImpl(keyColumns: ColumnsSelector<T, C>, allowMissingColumns: Boolean, vararg keyValues: C): DataFrame<T>