Package-level declarations

Types

Link copied to clipboard
interface AddDataRow<out T> : DataRow<T>

Receiver that is used by the AddExpression (for instance in the add and update operations) to access new (added or updated) column value in preceding row.

Link copied to clipboard

Receiver that is used by the add and mapToFrame for adding new columns and column groups based on DataFrame columns and row values.

Link copied to clipboard

AddExpression is used to express or select any instance of R using the given instance of AddDataRow<T> as this and it.

Link copied to clipboard
class AddGroup<T>(val body: AddDsl<T>.() -> Unit)
Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
interface CellAttributes

This represents a collection of CSS cell attributes that can be applied to a cell in an HTML-rendered dataframe.

Link copied to clipboard
typealias CellFormatter<C> = FormattingDsl.(cell: C) -> CellAttributes?

A lambda function expecting a CellAttributes or null given an instance of a cell: C of the dataframe.

Link copied to clipboard
value class CodeString(val value: String)

A value class wrapper for String, containing generated Kotlin code of data schema declarations (markers) and optionally extension properties.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
class ColumnDelegate<T>(parent: ColumnReference<DataRow<*>>? = null)
Link copied to clipboard
Link copied to clipboard
interface ColumnMatch<C> : ColumnSet<C>

A special ColumnSet that specifies a column match for the join operation.

Link copied to clipboard
internal class ColumnMatchImpl<C>(val left: ColumnReference<C>, val right: ColumnReference<C>) : ColumnMatch<C>
Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
typealias ColumnNamesGenerator<C> = ColumnWithPath<C>.(extraColumnIndex: Int) -> String
Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
class Convert<T, out C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)

An intermediate class used in the convert operation.

Link copied to clipboard
internal interface ConvertDocs

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.

Link copied to clipboard
class ConverterScope(val fromType: KType, val toSchema: ColumnSchema)

Provides access to fromType and toSchema in the flexible ConvertSchemaDsl.convertIf method.

Link copied to clipboard
interface ConvertSchemaDsl<in T>

Dsl to customize column conversion

Link copied to clipboard
data class ConvertToFill<T, C>(val dsl: ConvertSchemaDsl<T>, val columns: ColumnsSelector<T, C>)

Holds data context for fill operation

Link copied to clipboard
class ConvertType<T>(val dsl: ConvertSchemaDsl<*>, val from: KType, val property: KProperty<T>? = null)
Link copied to clipboard
class Corr<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)

An intermediate class used in the corr operation.

Link copied to clipboard
internal interface CorrDocs

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

Link copied to clipboard
internal typealias CorrWithDocs = Nothing

Calculates the correlation of specified otherColumns with values in the columns previously selected with corr.

Link copied to clipboard
abstract class CreateDataFrameDsl<T>
Link copied to clipboard

DslMarker to prevent functions from CreateDataFrameDsl being used inside TraversePropertiesDsl. This prevents notations like:

Link copied to clipboard
class DataFrameBuilder(header: List<String>)
Link copied to clipboard

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

Link copied to clipboard
interface DataRowSchema

Marker interface added as a supertype to classes annotated with DataSchema by the Kotlin DataFrame compiler plugin.

Link copied to clipboard
interface DataSchemaEnum

Make your enum class inherit DataSchemaEnum to make String -> Enum and Enum -> String conversions work using value instead of the enum name. (Fallback to enum name if the value cannot be found is implemented)

Link copied to clipboard

When using DataFrame.convert or DataColumn.convertTo to convert from String to a kotlinx-datetime type, like LocalDate, fails to parse, the DateTimeComponents fallback-mechanism kicks in.

Link copied to clipboard
sealed class DateTimeParserOptions<T>(val dateTimeFormats: Set<Pair<KType?, T>>?)

By default, DataFrame tries parsing date-time strings using custom formats and patterns defined in the global parser options and using default ISO formats. This is done for both Kotlin- and Java date-time types in order.

Link copied to clipboard
internal typealias DiffDocs = Nothing

Calculates the difference between the results of a row expression computed on the current and previous DataRow.

Link copied to clipboard
internal typealias DiffOrNullDocs = Nothing

Calculates the difference between the results of a row expression computed on the current and previous DataRow.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

The InsertException thrown when trying to insert a column with a path that already exists in the DataFrame.

Link copied to clipboard
class DynamicDataFrameBuilder(checkDuplicateValues: Boolean = true)

A builder class for dynamically constructing a DataFrame with provided columns. Allows adding columns manually while automatically handling duplicate column names by assigning unique names.

Link copied to clipboard

Specifies how to handle columns in the original dataframe that were not matched to any column in the destination dataframe schema.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
internal interface FillNA

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

Link copied to clipboard
internal interface FillNaNs

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

Link copied to clipboard
internal interface FillNulls

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

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
class FormatClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C> = { all().cast() }, val oldFormatter: RowColFormatter<T, C>? = null, val filter: RowValueFilter<T, C> = { true }, val oldHeaderFormatter: HeaderColFormatter<*>? = null)

An intermediate class used in the format operation.

Link copied to clipboard
internal interface FormatDocs

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.

Link copied to clipboard
class FormattedFrame<T>(val df: DataFrame<T>, val formatter: RowColFormatter<T, *>? = null, val headerFormatter: HeaderColFormatter<*>? = null)

A wrapper around a DataFrame with CSS attributes that can be converted to a formatted HTML table in the form of DataFrameHtmlData.

Link copied to clipboard
Link copied to clipboard

The formatting DSL allows you to create and combine CellAttributes to apply to one or multiple cells of a dataframe such that they have specific CSS attributes applied to them when rendered to HTML.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
class Gather<T, C, K, R>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>, val filter: RowValueFilter<T, C>? = null, val keyType: KType? = null, val keyTransform: (String) -> K, val valueTransform: (C) -> R? = null, val explode: Boolean = false)

An intermediate class used in the gather operation.

Link copied to clipboard
internal interface GatherDocs

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

Link copied to clipboard

Global counterpart of ParserOptions.

Link copied to clipboard
interface GroupBy<out T, out G> : Grouped<G>

A dataframe-like structure that contains all unique combinations of key-values along with the corresponding groups of rows (each represented as a DataFrame).

Link copied to clipboard
internal interface GroupByDocs

Groups the rows of this DataFrame based on the values in one or more specified cols. 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.

Link copied to clipboard

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

Link copied to clipboard

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

Link copied to clipboard
class GroupClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)

An intermediate class used in the group operation.

Link copied to clipboard
internal interface GroupDocs

Groups the specified columns within the DataFrame into column group.

Link copied to clipboard
interface Grouped<out T> : Aggregatable<T>

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

Link copied to clipboard
interface GroupedDataRow<out T, out G> : DataRow<T>

A specialized form of DataRow representing a single row of a GroupBy. Each instance contains the key values and a reference to the corresponding group.

Link copied to clipboard

A specialized lambda that provides a GroupedDataRow both as the receiver and as the argument (this and it) and returns a Boolean value used for filtering.

Link copied to clipboard

A specialized lambda that provides a GroupedDataRow both as the receiver and as the argument (this and it) and produces a result of type R.

Link copied to clipboard
data class GroupWithKey<T, G>(val key: DataRow<T>, val group: DataFrame<G>)

An alternative representation of a GroupBy.Entry, holding a key–group pair.

Link copied to clipboard

A lambda used to format a column header (its displayed name) when rendering a dataframe to HTML.

Link copied to clipboard
class HeaderFormatClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C> = { all().cast() }, val oldHeaderFormatter: HeaderColFormatter<C>? = null, val oldCellFormatter: RowColFormatter<T, *>? = null)

An intermediate class used in the header-format operation formatHeader.

Link copied to clipboard
enum class Infer : Enum<Infer>

Indicates how DataColumn.type should be calculated.

Link copied to clipboard
class InsertClause<T>(val df: DataFrame<T>, val column: DataColumn<*>)

An intermediate class used in the insert operation.

Link copied to clipboard
internal interface InsertDocs

This function does not immediately insert the new column but instead specifies a column to insert and returns an InsertClause, which serves as an intermediate step. The InsertClause object provides methods to insert a new column using:

Link copied to clipboard

The insert operation can throw two types of InsertException:

Link copied to clipboard

A specialized ColumnsSelector used for matching columns in a join operation.

Link copied to clipboard
interface JoinDsl<out A, out B> : ColumnsSelectionDsl<A>

A specialized ColumnsSelectionDsl that allows specifying join matching columns with different names in left and right DataFrames.

Link copied to clipboard
interface JoinedDataRow<out A, out B> : DataRow<A>

A specialized DataRow used in a JoinExpression.

Link copied to clipboard

A special row expression used to define the row-matching condition in a joinWith operation.

Link copied to clipboard
enum class JoinType : Enum<JoinType>

Represents the type of join operation.

Link copied to clipboard
value class JsonPath(val path: String = "$") : Serializable

Simplistic JSON path implementation. Supports just keys (in bracket notation), double quotes, arrays, and wildcards.

Link copied to clipboard
interface KeyValueProperty<T>

A DataSchema interface / class can implement this if it represents a map-like data schema (so key: value).

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
internal interface MapDocs

Computes a new value for every value, row, or key–group pair of the receiver, and collects the results.

Link copied to clipboard
internal interface MaxDocs : CommonMinMaxDocs

Computes the maximum of values.

Link copied to clipboard
internal interface MeanDocs : CommonStatisticsDocs

Computes the mean (average) of values — the sum divided by the number of values.

Link copied to clipboard

Computes the median of values: the value in the "middle" of the sorted values. This is also called the 50th percentile, or the 2-quantile.

Link copied to clipboard
data class Merge<T, C, R>(val df: DataFrame<T>, val selector: ColumnsSelector<T, C>, val notNull: Boolean, val transform: DataRow<T>.(List<C>) -> R, val resultType: KType, val infer: Infer)
Link copied to clipboard
class MergeWithTransform<T, C, R>(val df: DataFrame<T>, val selector: ColumnsSelector<T, C>, val notNull: Boolean, val transform: DataRow<T>.(List<C>) -> R, val resultType: KType, val infer: Infer)
Link copied to clipboard
internal interface MinDocs : CommonMinMaxDocs

Computes the minimum of values.

Link copied to clipboard
internal interface Move

Moves the specified columns within the DataFrame.

Link copied to clipboard
class MoveClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)

An intermediate class used in the move operation.

Link copied to clipboard
internal interface MoveTo

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

Link copied to clipboard
internal interface MoveToEnd

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

Link copied to clipboard
internal interface MoveToStart

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

Link copied to clipboard
data class NameValuePair<V>(val name: String, val value: V) : NameValueProperty<V>
Link copied to clipboard
interface NameValueProperty<T>

A DataSchema interface / class can implement this if it represents a map-like data schema (so name: value).

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

The InsertException thrown when trying to insert a column group into a non-column group.

Link copied to clipboard
Link copied to clipboard

Indicates how DataColumn.hasNulls (or, more accurately, DataColumn.type.isMarkedNullable) should be initialized from expected schema and actual data when reading schema-defined data formats.

Link copied to clipboard

DataFrame supports parsing to either kotlinx-datetime or java.time types.

Link copied to clipboard
class ParserOptions(val locale: Locale? = null, val dateTime: DateTimeParserOptions<*>? = null, val nullStrings: Set<String>? = null, val skipTypes: Set<KType>? = null, val useFastDoubleParser: Boolean? = null, val parseExperimentalUuid: Boolean? = null, val parseExperimentalInstant: Boolean? = null)

These options are used to configure how DataColumns of type String or String? should be parsed. They can be passed to tryParse and parse functions.

Link copied to clipboard

Computes the given percentile of values: the value below which the given percentage of the sorted values falls. This is also called the "centile", or the 100-quantile.

Link copied to clipboard
interface Pivot<T> : Aggregatable<T>

A dataframe-like structure that contains all unique combinations of key values as columns (or column groups for multiple keys) with a single row with the corresponding groups for each key combination (each represented as a DataFrame).

Link copied to clipboard

A specialized ColumnsSelector used for selecting columns in a pivot operation.

Link copied to clipboard
internal interface PivotDocs

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.

Link copied to clipboard
interface PivotDsl<out T> : ColumnsSelectionDsl<T>

A specialized ColumnsSelectionDsl that allows specifying pivot key ordering using the then function.

Link copied to clipboard
interface PivotGroupBy<out T> : Aggregatable<T>

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

Link copied to clipboard
internal interface PivotGroupByDocs

TODO (#1536)

Link copied to clipboard
class ReducedGroupBy<T, G>(val groupBy: GroupBy<T, G>, val reducer: Selector<DataFrame<G>, DataRow<G>?>)

An intermediate class used in GroupBy reducing operations.

Link copied to clipboard
class ReducedPivot<T>(val pivot: Pivot<T>, val reducer: Selector<DataFrame<T>, DataRow<T>?>)

An intermediate class used in Pivot reducing operations.

Link copied to clipboard
class ReducedPivotGroupBy<T>(val pivot: PivotGroupBy<T>, val reducer: Selector<DataFrame<T>, DataRow<T>?>)
Link copied to clipboard
internal typealias Remove = Nothing

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

Link copied to clipboard
class RenameClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)

An intermediate class used in the rename operation.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
internal interface RenameDocs

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

Link copied to clipboard
data class Reorder<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>, val inFrameColumns: Boolean)

An intermediate step of the reorder operation.

Link copied to clipboard
internal interface ReorderDocs

Reorders the selected columns of the DataFrame.

Link copied to clipboard
class ReplaceClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)
Link copied to clipboard
typealias RGBColor = RgbColor
Link copied to clipboard
data class RgbColor(val r: Short, val g: Short, val b: Short)

Represents a color in the RGB color space. To be used in the DataFrame.format; FormattingDsl.

Link copied to clipboard

A lambda function expecting a CellAttributes or null given an instance of DataRow<T> and ColumnWithPath<C>.

Link copied to clipboard
internal typealias SeeAlsoParse = Nothing

See also parse — a specialized form of the convert operation that parses String columns into other types without requiring explicit type specification.

Link copied to clipboard
internal interface Select

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

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

A specialized ColumnsSelector used for selecting columns for sorting.

Link copied to clipboard
interface SortDsl<out T> : ColumnsSelectionDsl<T>

A specialized Columns Selection DSL for selecting columns to sort rows by and specifying how each column should be sorted.

Link copied to clipboard
class Split<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C?>)
Link copied to clipboard
class SplitWithTransform<T, C, R>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C?>, val inward: Boolean, val tartypeOf: KType, val default: R? = null, val transform: DataRow<T>.(C) -> Iterable<R>)
Link copied to clipboard
internal interface StdDocs : CommonStatisticsDocs

Computes the standard deviation of values — a measure of how spread out the values are around their mean.

Link copied to clipboard
internal interface SumDocs : CommonStatisticsDocs

Computes the sum of values.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
Link copied to clipboard
internal interface UnfoldDocs
Link copied to clipboard
internal interface UngroupDocs

Ungroups the specified columns within the DataFrame, i.e., replaces each ColumnGroup with its nested columns.

Link copied to clipboard
class Update<T, C>(val df: DataFrame<T>, val filter: RowValueFilter<T, C>?, val columns: ColumnsSelector<T, C>)

Returns the DataFrame with changed values in some cells (column types cannot be changed).

Link copied to clipboard
typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
interface ValueCount

A DataSchema of the valueCounts result. It declares the count column with the number of occurrences of each counted value.

Link copied to clipboard
interface ValueProperty<T>
Link copied to clipboard

See Grammar for all functions in this interface.

Link copied to clipboard
internal interface XsDocs

Returns a cross-section: keeps only the rows in which the key columns hold the given key values, and removes the key columns from the result.

Properties

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
internal val AnyCol.canHaveNA: Boolean

Is true when this column can have NA values.

Link copied to clipboard
internal val AnyCol.canHaveNaN: Boolean
Link copied to clipboard
@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>
@get:JvmName(name = "NullableColumnDescription_count")
val DataRow<ColumnDescription?>.count: Int?
@get:JvmName(name = "ColumnDescription_count")
val DataRow<ColumnDescription>.count: Int
@get:JvmName(name = "NullableValueCount_count")
val DataRow<ValueCount?>.count: Int?
@get:JvmName(name = "ValueCount_count")
val DataRow<ValueCount>.count: Int
Link copied to clipboard
internal val ddofDefault: Int = 1

Default delta degrees of freedom for the standard deviation (std).

Link copied to clipboard

Performs no name normalization.

Link copied to clipboard
Link copied to clipboard

whether to skip nulls and NaNs in the cumSum operation.

Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_freq")
val ColumnsScope<ColumnDescription?>.freq: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_freq")
val ColumnsScope<ColumnDescription>.freq: DataColumn<Int>
@get:JvmName(name = "NullableColumnDescription_freq")
val DataRow<ColumnDescription?>.freq: Int?
@get:JvmName(name = "ColumnDescription_freq")
val DataRow<ColumnDescription>.freq: Int
Link copied to clipboard

The DataFrame representing the group corresponding to the current key values.

Link copied to clipboard
Link copied to clipboard
internal val Any?.isNA: Boolean

Is true if this is considered NA. "NA", in DataFrame, roughly means null or NaN.

internal val Double?.isNA: Boolean

Is true when this is null or Double.NaN.

internal val Float?.isNA: Boolean

Is true when this is null or Float.NaN.

Link copied to clipboard
internal val Any?.isNaN: Boolean

Is only true if this is Double.NaN or Float.NaN.

Link copied to clipboard
@get:JvmName(name = "NullableKeyValueProperty_key")
val ColumnsScope<KeyValueProperty<*>?>.key: DataColumn<String?>
@get:JvmName(name = "KeyValueProperty_key")
val ColumnsScope<KeyValueProperty<*>>.key: DataColumn<String>
@get:JvmName(name = "NullableKeyValueProperty_key")
val DataRow<KeyValueProperty<*>?>.key: String?
@get:JvmName(name = "KeyValueProperty_key")
val DataRow<KeyValueProperty<*>>.key: String
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_max")
val ColumnsScope<ColumnDescription?>.max: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_max")
val ColumnsScope<ColumnDescription>.max: DataColumn<Any>
@get:JvmName(name = "NullableColumnDescription_max")
val DataRow<ColumnDescription?>.max: Any?
@get:JvmName(name = "ColumnDescription_max")
val DataRow<ColumnDescription>.max: Any
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_mean")
val ColumnsScope<ColumnDescription?>.mean: DataColumn<Double?>
@get:JvmName(name = "ColumnDescription_mean")
val ColumnsScope<ColumnDescription>.mean: DataColumn<Double>
@get:JvmName(name = "NullableColumnDescription_mean")
val DataRow<ColumnDescription?>.mean: Double?
@get:JvmName(name = "ColumnDescription_mean")
val DataRow<ColumnDescription>.mean: Double
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_median")
val ColumnsScope<ColumnDescription?>.median: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_median")
val ColumnsScope<ColumnDescription>.median: DataColumn<Any>
@get:JvmName(name = "NullableColumnDescription_median")
val DataRow<ColumnDescription?>.median: Any?
@get:JvmName(name = "ColumnDescription_median")
val DataRow<ColumnDescription>.median: Any
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_min")
val ColumnsScope<ColumnDescription?>.min: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_min")
val ColumnsScope<ColumnDescription>.min: DataColumn<Any>
@get:JvmName(name = "NullableColumnDescription_min")
val DataRow<ColumnDescription?>.min: Any?
@get:JvmName(name = "ColumnDescription_min")
val DataRow<ColumnDescription>.min: Any
Link copied to clipboard
@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 = "NullableColumnDescription_name")
val DataRow<ColumnDescription?>.name: String?
@get:JvmName(name = "ColumnDescription_name")
val DataRow<ColumnDescription>.name: String
@get:JvmName(name = "NameValuePairAny_name")
val DataRow<NameValuePair<*>>.name: String
@get:JvmName(name = "NullableNameValuePair_name")
val <V> DataRow<NameValuePair<V>?>.name: String?
@get:JvmName(name = "NameValuePair_name")
val <V> DataRow<NameValuePair<V>>.name: String
@get:JvmName(name = "NullableNameValueProperty_name")
val <T> DataRow<NameValueProperty<T>?>.name: String?
@get:JvmName(name = "NameValueProperty_name")
val <T> DataRow<NameValueProperty<T>>.name: String
internal val ColumnReference<*>.name: 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.

@get:JvmName(name = "NullableKeyValueProperty_name")
val DataRow<KeyValueProperty<*>?>.name: String?
@get:JvmName(name = "KeyValueProperty_name")
val DataRow<KeyValueProperty<*>>.name: String

Accesses the 'key' value of this KeyValueProperty DataRow.

Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_nulls")
val ColumnsScope<ColumnDescription?>.nulls: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_nulls")
val ColumnsScope<ColumnDescription>.nulls: DataColumn<Int>
@get:JvmName(name = "NullableColumnDescription_nulls")
val DataRow<ColumnDescription?>.nulls: Int?
@get:JvmName(name = "ColumnDescription_nulls")
val DataRow<ColumnDescription>.nulls: Int
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_p25")
val ColumnsScope<ColumnDescription?>.p25: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_p25")
val ColumnsScope<ColumnDescription>.p25: DataColumn<Any>
@get:JvmName(name = "NullableColumnDescription_p25")
val DataRow<ColumnDescription?>.p25: Any?
@get:JvmName(name = "ColumnDescription_p25")
val DataRow<ColumnDescription>.p25: Any
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_p75")
val ColumnsScope<ColumnDescription?>.p75: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_p75")
val ColumnsScope<ColumnDescription>.p75: DataColumn<Any>
@get:JvmName(name = "NullableColumnDescription_p75")
val DataRow<ColumnDescription?>.p75: Any?
@get:JvmName(name = "ColumnDescription_p75")
val DataRow<ColumnDescription>.p75: Any
Link copied to clipboard
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_path")
val ColumnsScope<ColumnDescription?>.path: DataColumn<ColumnPath?>
@get:JvmName(name = "ColumnDescription_path")
val ColumnsScope<ColumnDescription>.path: DataColumn<ColumnPath>
@get:JvmName(name = "NullableColumnDescription_path")
val DataRow<ColumnDescription?>.path: ColumnPath?
@get:JvmName(name = "ColumnDescription_path")
val DataRow<ColumnDescription>.path: ColumnPath
Link copied to clipboard
internal val skipNaNDefault: Boolean = false
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_std")
val ColumnsScope<ColumnDescription?>.std: DataColumn<Double?>
@get:JvmName(name = "ColumnDescription_std")
val ColumnsScope<ColumnDescription>.std: DataColumn<Double>
@get:JvmName(name = "NullableColumnDescription_std")
val DataRow<ColumnDescription?>.std: Double?
@get:JvmName(name = "ColumnDescription_std")
val DataRow<ColumnDescription>.std: Double
Link copied to clipboard

Converts delimited 'my_name', 'my name', etc., String to camelCase 'myName'

Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_top")
val ColumnsScope<ColumnDescription?>.top: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_top")
val ColumnsScope<ColumnDescription>.top: DataColumn<Any>
@get:JvmName(name = "NullableColumnDescription_top")
val DataRow<ColumnDescription?>.top: Any?
@get:JvmName(name = "ColumnDescription_top")
val DataRow<ColumnDescription>.top: Any
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_type")
val ColumnsScope<ColumnDescription?>.type: DataColumn<String?>
@get:JvmName(name = "ColumnDescription_type")
val ColumnsScope<ColumnDescription>.type: DataColumn<String>
@get:JvmName(name = "NullableColumnDescription_type")
val DataRow<ColumnDescription?>.type: String?
@get:JvmName(name = "ColumnDescription_type")
val DataRow<ColumnDescription>.type: String
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_unique")
val ColumnsScope<ColumnDescription?>.unique: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_unique")
val ColumnsScope<ColumnDescription>.unique: DataColumn<Int>
@get:JvmName(name = "NullableColumnDescription_unique")
val DataRow<ColumnDescription?>.unique: Int?
@get:JvmName(name = "ColumnDescription_unique")
val DataRow<ColumnDescription>.unique: Int
Link copied to clipboard
@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>
@get:JvmName(name = "NullableKeyValueProperty_value")
val <T> DataRow<KeyValueProperty<T>?>.value: T?
@get:JvmName(name = "KeyValueProperty_value")
val <T> DataRow<KeyValueProperty<T>>.value: T
@get:JvmName(name = "NameValuePairAny_value")
val DataRow<NameValuePair<*>>.value: Any?
@get:JvmName(name = "NullableNameValuePair_value")
val <V> DataRow<NameValuePair<V>?>.value: V?
@get:JvmName(name = "NameValuePair_value")
val <V> DataRow<NameValuePair<V>>.value: V
@get:JvmName(name = "NullableNameValueProperty_value")
val <T> DataRow<NameValueProperty<T>?>.value: T?
@get:JvmName(name = "NameValueProperty_value")
val <T> DataRow<NameValueProperty<T>>.value: T
@get:JvmName(name = "NullableValueProperty_value")
val <T> DataRow<ValueProperty<T>?>.value: T?
@get:JvmName(name = "ValueProperty_value")
val <T> DataRow<ValueProperty<T>>.value: T

Functions

Link copied to clipboard
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, G> GroupBy<T, G>.add(column: ColumnAccessor<G>, infer: Infer = Infer.Nulls, noinline expression: AddExpression<G, R>): GroupBy<T, G>

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.

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

Creates a new column using AddExpression and adds a new column to the end of each group (i.e., DataFrames) of this GroupBy (at the top level).

Link copied to clipboard
@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).

Link copied to clipboard
inline fun <reified T : Any> GlobalParserOptions.addDateTimeFormat(format: DateTimeFormat<out T>)

Adds format to the global parser options of DataFrame.

Link copied to clipboard
@FormatStringsInDatetimeFormats
inline fun <reified T : Any> GlobalParserOptions.addDateTimeUnicodePattern(pattern: String)

Adds a Unicode date-time pattern to the global parser options of DataFrame.

Link copied to clipboard
fun DataColumn<*>.addId(columnName: String = "id"): DataFrame<*>
fun <T> DataFrame<T>.addId(columnName: String = "id"): DataFrame<T>
Link copied to clipboard

Adds a Java-based date-time formatter to the global parser options of DataFrame.

Link copied to clipboard

Adds a Java-based date-time pattern to the global parser options of DataFrame.

Link copied to clipboard

Inserts the new column previously specified with insert at the position immediately after the selected column (on the same level).

fun <T> InsertClause<T>.after(column: String): DataFrame<T>

Inserts the new column previously specified with insert at the position immediately after the column with the given name.

fun <T> InsertClause<T>.after(column: KProperty<*>): DataFrame<T>
fun <T> InsertClause<T>.after(columnPath: ColumnPath): DataFrame<T>
fun <T, C> MoveClause<T, C>.after(column: KProperty<*>): DataFrame<T>
fun <T, C> MoveClause<T, C>.after(column: ColumnReference<*>): DataFrame<T>

fun <T, C> MoveClause<T, C>.after(column: ColumnSelector<T, *>): DataFrame<T>
fun <T, C> MoveClause<T, C>.after(column: String): DataFrame<T>

Moves columns, previously selected with move to the position after the specified column within the DataFrame.

Link copied to clipboard

Aggregates this GroupBy using the provided statistics inside the AggregateGroupedDsl.

fun <T, R> Pivot<T>.aggregate(separate: Boolean = false, body: Selector<AggregateDsl<T>, R>): DataRow<T>

Aggregates this Pivot using the provided statistics inside the AggregateDsl.

Link copied to clipboard
fun <T> DataColumn<T>.all(predicate: Predicate<T>): Boolean

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

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

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

Link copied to clipboard
internal inline fun ColumnsResolver<*>.allAfterInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a new ColumnSet containing all columns after the first column that matches the given predicate.

Link copied to clipboard
internal inline fun ColumnsResolver<*>.allBeforeInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a new ColumnSet containing all columns before the first column that satisfies the given predicate.

Link copied to clipboard

Returns a new ColumnSet that contains all columns from inside the receiver column group except those specified in the "other" ColumnsResolver.

Link copied to clipboard

If this is a SingleColumn containing a single ColumnGroup (like SingleColumn<AnyRow> or ColumnsSelectionDsl), it returns a (transformable) ColumnSet containing the children of this ColumnGroup, else it simply returns a (transformable) ColumnSet from this (like when this is a ColumnSet).

Link copied to clipboard
internal inline fun ColumnsResolver<*>.allFromInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a column set containing all columns from the internal column set that satisfy the given predicate.

Link copied to clipboard
Link copied to clipboard

Returns true if all values are null or values is empty.

Link copied to clipboard
internal inline fun ColumnsResolver<*>.allUpToInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a ColumnSet containing all columns up to (and including) the first column that satisfies the given predicate.

Link copied to clipboard
internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C>

Chains up two row value filters together.

Combines two CellAttributes instances into a new one that combines their attributes.

Link copied to clipboard
fun <T> DataColumn<T>.any(predicate: Predicate<T>): Boolean

Returns true if at least one element in this DataColumn satisfies the given predicate.

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

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

Link copied to clipboard
fun <T> DataFrame<T>.append(vararg values: Any?): DataFrame<T>
inline fun <reified T : DataRowSchema> DataFrame<T>.append(vararg rows: T): DataFrame<T>
Link copied to clipboard
fun <T> DataFrame<T>.appendNulls(numberOfRows: Int = 1): DataFrame<T>
Link copied to clipboard
Link copied to clipboard
inline fun <T, C, R> Convert<T, C>.asColumn(crossinline columnConverter: DataFrame<T>.(DataColumn<C>) -> BaseColumn<R>): DataFrame<T>

Converts values in the columns previously selected with convert using columnConverter expression within the DataFrame.

Link copied to clipboard
@JvmName(name = "asColumnGroupUntyped")
fun DataColumn<*>.asColumnGroup(): ColumnGroup<*>
@JvmName(name = "asGroupedT")
fun <T> DataColumn<DataRow<T>>.asColumnGroup(): ColumnGroup<T>

@JvmName(name = "asColumnGroupDataRow")
fun <C> SingleColumn<DataRow<C>>.asColumnGroup(): SingleColumn<DataRow<C>>

Creates a ColumnAccessor<DataRow<C>> from this. This is especially useful when you want to use ColumnGroup functions in the ColumnsSelectionDsl but your column type is not recognized as a ColumnGroup. If you're not sure whether a column is recognized as ColumnGroup or not, you can always call asColumnGroup and it will return the same type if it is already a ColumnGroup.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard

Converts column groups previously selected with convert as a DataFrame using a dataframe expression.

Updates selected column group as a DataFrame with the given expression.

Link copied to clipboard
@JvmName(name = "asFrameColumnUntyped")
fun DataColumn<*>.asFrameColumn(): FrameColumn<*>
Link copied to clipboard
fun <T> DataFrame<T>.asGroupBy(groupedColumnName: String): GroupBy<T, T>
fun <T, G> DataFrame<T>.asGroupBy(groupedColumn: ColumnReference<DataFrame<G>>): GroupBy<T, G>
Link copied to clipboard

Returns an Iterable over the values of this DataColumn.

Link copied to clipboard
@JvmName(name = "asNumberAnyNullable")
fun DataColumn<Any?>.asNumbers(): ValueColumn<Number?>
@JvmName(name = "asNumberAny")
fun DataColumn<Any>.asNumbers(): ValueColumn<Number>
@JvmName(name = "asNumbersAnyNullable")
fun ColumnSet<Any?>.asNumbers(): ColumnSet<Number?>
@JvmName(name = "asNumbersAny")
fun ColumnSet<Any>.asNumbers(): ColumnSet<Number>
@JvmName(name = "asNumbersAnyNullable")
fun SingleColumn<Any?>.asNumbers(): SingleColumn<Number?>
@JvmName(name = "asNumbersAny")
fun SingleColumn<Any>.asNumbers(): SingleColumn<Number>
Link copied to clipboard

Returns a Sequence over the values of this DataColumn.

Returns a Sequence of DataRow over this DataFrame.

Link copied to clipboard
Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T, C> FormatClause<T, C>.at(rowIndices: Collection<Int>): FormatClause<T, C>
fun <T, C> FormatClause<T, C>.at(rowRange: IntRange): FormatClause<T, C>
fun <T, C> FormatClause<T, C>.at(vararg rowIndices: Int): FormatClause<T, C>

Only format the selected columns at given row indices.

fun <T> InsertClause<T>.at(position: Int): DataFrame<T>

Inserts the new column previously specified with insert at the given position in the DataFrame.

fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C>
fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C>
fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C>

Only update the columns at certain given org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam:

Link copied to clipboard

Inserts the new column previously specified with insert at the position immediately before the selected column (on the same level).

fun <T> InsertClause<T>.before(column: String): DataFrame<T>

Inserts the new column previously specified with insert at the position immediately before the column with the given name.

fun <T, C> MoveClause<T, C>.before(column: ColumnSelector<T, *>): DataFrame<T>
fun <T, C> MoveClause<T, C>.before(column: String): DataFrame<T>

Moves columns, previously selected with move to the position before the specified column within the DataFrame.

Link copied to clipboard
fun <T : Comparable<T>> DataColumn<T>.between(left: T, right: T, includeBoundaries: Boolean = true): DataColumn<Boolean>

Returns a DataColumn of Boolean values indicating whether each element in this column lies between left and right.

Link copied to clipboard
fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T>

Puts the columns selected by reorder in ascending order of the value of the expression and returns a new DataFrame.

inline fun <T, C, reified R> Split<T, C>.by(noinline splitter: DataRow<T>.(C) -> Iterable<R>): SplitWithTransform<T, C, R>
inline fun <T, C, R, reified V> Merge<T, C, R>.by(infer: Infer = Infer.Nulls, crossinline transform: DataRow<T>.(R) -> V): MergeWithTransform<T, C, V>
internal inline fun <T, C, R> Split<T, C>.by(type: KType, crossinline splitter: DataRow<T>.(C) -> Iterable<R>): SplitWithTransform<T, C, R>
fun <T, C> Split<T, C>.by(vararg delimiters: Char, trim: Boolean = true, ignoreCase: Boolean = false, limit: Int = 0): SplitWithTransform<T, C, String>
fun <T, C> Split<T, C>.by(vararg delimiters: String, trim: Boolean = true, ignoreCase: Boolean = false, limit: Int = 0): SplitWithTransform<T, C, String>
fun <T, C, R> Merge<T, C, R>.by(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "..."): MergeWithTransform<T, C, String>

fun <T, C> Split<T, C>.by(regex: Regex, trim: Boolean = true, limit: Int = 0): SplitWithTransform<T, C, String>

Example:

Link copied to clipboard
fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T>

Puts the columns selected by reorder in descending order of the value of the expression and returns a new DataFrame.

Link copied to clipboard
fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T>

Puts the columns selected by reorder in lexicographic order of their names and returns a new DataFrame.

Link copied to clipboard
fun <T> DataFrame<*>.cast(): DataFrame<T>
fun <T> DataRow<*>.cast(): DataRow<T>
fun <T, G> GroupBy<*, *>.cast(): GroupBy<T, G>
fun <C> ColumnSet<*>.cast(): ColumnSet<C>
inline fun <reified T> DataFrame<*>.cast(verify: Boolean = true): DataFrame<T>
inline fun <reified T> DataRow<*>.cast(verify: Boolean = true): DataRow<T>
Link copied to clipboard
Link copied to clipboard
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>
Link copied to clipboard

Groups consecutive values of this DataColumn into lists of at most size elements.

Splits a DataColumn of DataRow into a FrameColumn of sub-dataframes with up to size rows in each chunk.

Splits this ColumnGroup into a FrameColumn of sub-dataframes with up to size rows in each chunk.

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.

Link copied to clipboard

Returns all columns inside this ColumnsResolver at any depth if they satisfy the given predicate.

Link copied to clipboard
internal inline fun ColumnsResolver<*>.colsInternal(crossinline predicate: ColumnFilter<*>): TransformableColumnSet<*>

If this ColumnsResolver is a SingleColumn, it returns a new ColumnSet containing the columns inside of this SingleColumn that match the given predicate.

Link copied to clipboard
inline fun <reified C> ColumnsSelectionDsl<*>.colsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>
fun <C> ColumnsSelectionDsl<*>.colsOf(type: KType, filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

Returns a ColumnSet of columns from this that are a subtype of the given type C, optionally filtered by filter.

inline fun <reified C> ColumnSet<*>.colsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>
fun <C> ColumnSet<*>.colsOf(type: KType, filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

Returns a ColumnSet of columns from this that are a subtype of the given type C, optionally filtered by filter.

inline fun <reified C> SingleColumn<DataRow<*>>.colsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>
fun <C> SingleColumn<DataRow<*>>.colsOf(type: KType, filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

Returns a ColumnSet of columns from this that are a subtype of the given type C, optionally filtered by filter.

Link copied to clipboard
internal inline fun <C> ColumnsResolver<*>.colsOfInternal(type: KType, crossinline filter: ColumnFilter<C>): TransformableColumnSet<C>

If this ColumnsResolver is a SingleColumn, it returns a new ColumnSet containing the columns inside of this SingleColumn that match the given filter and are the given type.

Link copied to clipboard
fun <T> column(name: String): ColumnAccessor<T>
inline fun <reified T> column(values: Iterable<T>): DataColumn<T>
fun <T> column(property: KProperty<T>): ColumnAccessor<T>
inline fun <reified T> column(name: String = "", infer: Infer = Infer.Nulls, noinline expression: RowExpression<Any?, T>): ColumnReference<T>
inline fun <T, reified C> column(df: DataFrame<T>, name: String = "", infer: Infer = Infer.Nulls, noinline expression: RowExpression<T, C>): ColumnReference<C>
Link copied to clipboard
@JvmName(name = "columnGroupTyped")
fun <T> columnGroup(): ColumnDelegate<DataRow<T>>
@JvmName(name = "columnGroupTyped")
fun <T> columnGroup(name: String): ColumnAccessor<DataRow<T>>
@JvmName(name = "columnGroupDataRowKProperty")
fun <T> columnGroup(property: KProperty<DataRow<T>>): ColumnAccessor<DataRow<T>>
@JvmName(name = "columnGroupTyped")
fun <T> columnGroup(path: ColumnPath): ColumnAccessor<DataRow<T>>
Link copied to clipboard
Link copied to clipboard
internal inline fun ColumnsResolver<*>.columnGroupsInternal(crossinline filter: (ColumnGroup<*>) -> Boolean): ColumnSet<DataRow<*>>

Returns a ColumnSet containing the column groups that satisfy the given filter.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <reified T> columnOf(vararg values: T): DataColumn<T>
fun <T> columnOf(vararg frames: DataFrame<T>): FrameColumn<T>
fun columnOf(vararg values: BaseColumn<*>): DataColumn<DataRow<*>>

fun columnOf(vararg columns: Pair<String, BaseColumn<*>>): ColumnGroup<*>
Link copied to clipboard
Link copied to clipboard
internal inline fun ColumnsResolver<*>.columnsOfKindInternal(kinds: Set<ColumnKind>, crossinline filter: ColumnFilter<*>): TransformableColumnSet<*>

Returns a TransformableColumnSet containing the columns of given kind(s) that satisfy the given filter.

Link copied to clipboard
Link copied to clipboard
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.

Link copied to clipboard

Returns a DataColumn containing all values from the columns in this iterable.

Returns a DataFrame containing all rows from the DataFrames in this iterable.

@JvmName(name = "concatRows")
fun <T> Iterable<DataRow<T>?>.concat(): DataFrame<T>

Returns a DataFrame containing the rows in this iterable in iteration order.

Returns a List containing the elements of every Collection stored in this column.

Returns a DataFrame containing the rows from every DataFrame stored in this column.

fun <T, G> GroupBy<T, G>.concat(): DataFrame<G>

Returns a DataFrame containing all groups in this GroupBy.

Applies the stored reducer to every group and returns a DataFrame containing one resulting row per group, in the order in which the groups appear in the underlying GroupBy.

fun <T> DataColumn<T>.concat(vararg other: DataColumn<T>): DataColumn<T>

Returns a DataColumn containing the values of this column followed by the values of other.

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.

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

Returns a DataFrame containing this DataRow followed by rows.

Link copied to clipboard

Returns a DataFrame containing all groups in this GroupBy and every grouping key column that is missing from those groups.

Link copied to clipboard
operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean
operator fun ColumnsContainer<*>.contains(column: ColumnReference<*>): Boolean
operator fun DataRow<*>.contains(column: KProperty<*>): Boolean
operator fun DataRow<*>.contains(column: ColumnReference<*>): Boolean
Link copied to clipboard
Link copied to clipboard
fun DataRow<*>.containsKey(columnName: String): Boolean
fun DataRow<*>.containsKey(column: KProperty<*>): Boolean
Link copied to clipboard
inline fun <reified C> ConvertSchemaDsl<*>.convert(): ConvertType<C>

Defines how to convert values of the given type C.

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.

Link copied to clipboard
inline fun <reified C> DataColumn<*>.convertTo(): DataColumn<C>

Converts values in this column to the specified type C.

fun DataColumn<*>.convertTo(newType: KType): DataColumn<*>

Converts values in this column to the specified type.

inline fun <reified C> DataColumn<String?>.convertTo(parserOptions: ParserOptions? = null): DataColumn<C>

Converts values in this String column to the specified type C.

fun DataColumn<String?>.convertTo(newType: KType, parserOptions: ParserOptions? = null): DataColumn<*>

Converts values in this String column to the specified type.

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.

Link copied to clipboard

Converts values in this column to BigDecimal. Preserves null values.

@JvmName(name = "convertToBigDecimalFromT")
fun <T : Any> DataColumn<T>.convertToBigDecimal(): DataColumn<BigDecimal>

Converts values in this column to BigDecimal.

Link copied to clipboard

Converts values in this column to BigInteger. Preserves null values.

@JvmName(name = "convertToBigIntegerFromT")
fun <T : Any> DataColumn<T>.convertToBigInteger(): DataColumn<BigInteger>

Converts values in this column to BigInteger.

Link copied to clipboard

Converts values in this column to Boolean. Preserves null values.

@JvmName(name = "convertToBooleanFromT")
fun <T : Any> DataColumn<T>.convertToBoolean(): DataColumn<Boolean>

Converts values in this column to Boolean.

Link copied to clipboard

Converts values in this column to Byte. Preserves null values.

@JvmName(name = "convertToByteFromT")
fun <T : Any> DataColumn<T>.convertToByte(): DataColumn<Byte>

Converts values in this column to Byte.

Link copied to clipboard
@JvmName(name = "convertToDateTimeComponentsFromStringNullablePattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String?>.convertToDateTimeComponents(pattern: String): DataColumn<DateTimeComponents?>
@JvmName(name = "convertToDateTimeComponentsFromStringNullable")
fun DataColumn<String?>.convertToDateTimeComponents(format: DateTimeFormat<DateTimeComponents>? = null): DataColumn<DateTimeComponents?>

Converts values in this String column to DateTimeComponents. Preserves null values.

@JvmName(name = "convertToDateTimeComponentsFromStringPattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String>.convertToDateTimeComponents(pattern: String): DataColumn<DateTimeComponents>
@JvmName(name = "convertToDateTimeComponentsFromString")
fun DataColumn<String>.convertToDateTimeComponents(format: DateTimeFormat<DateTimeComponents>? = null): DataColumn<DateTimeComponents>

Converts values in this String column to DateTimeComponents.

Link copied to clipboard
@JvmName(name = "convertToDeprecatedInstantFromStringNullable")
fun DataColumn<String?>.convertToDeprecatedInstant(): DataColumn<Instant?>

Converts values in this String column to the deprecated kotlinx.datetime.Instant. Preserves null values.

Converts values in this String column to the deprecated kotlinx.datetime.Instant.

Link copied to clipboard

Converts values in this column to Double. Preserves null values.

@JvmName(name = "convertToDoubleFromT")
fun <T : Any> DataColumn<T>.convertToDouble(): DataColumn<Double>

Converts values in this column to Double.

@JvmName(name = "convertToDoubleFromStringNullable")
fun DataColumn<String?>.convertToDouble(locale: Locale? = null): DataColumn<Double?>
@JvmName(name = "convertToDoubleFromString")
fun DataColumn<String>.convertToDouble(locale: Locale? = null): DataColumn<Double>
@JvmName(name = "convertToDoubleFromStringNullable")
fun DataColumn<String?>.convertToDouble(locale: Locale? = null, nullStrings: Set<String>?, useFastDoubleParser: Boolean?): DataColumn<Double?>
@JvmName(name = "convertToDoubleFromString")
fun DataColumn<String>.convertToDouble(locale: Locale? = null, nullStrings: Set<String>?, useFastDoubleParser: Boolean?): DataColumn<Double>

Converts values in this String column to Double considering locale (number format).

Link copied to clipboard

Converts values in this column to Duration. Preserves null values.

@JvmName(name = "convertToDurationFromT")
fun <T : Any> DataColumn<T>.convertToDuration(): DataColumn<Duration>

Converts values in this column to Duration.

Link copied to clipboard

Converts values in this column to Float. Preserves null values.

@JvmName(name = "convertToFloatFromT")
fun <T : Any> DataColumn<T>.convertToFloat(): DataColumn<Float>

Converts values in this column to Float.

Link copied to clipboard
@JvmName(name = "convertToInstantFromStringNullable")
fun DataColumn<String?>.convertToInstant(): DataColumn<Instant?>

Deprecated:

Link copied to clipboard

Converts values in this column to Int. Preserves null values.

@JvmName(name = "convertToIntFromT")
fun <T : Any> DataColumn<T>.convertToInt(): DataColumn<Int>

Converts values in this column to Int.

Link copied to clipboard

Converts values in this column to JavaDuration. Preserves null values.

@JvmName(name = "convertToJavaDurationFromT")
fun <T : Any> DataColumn<T>.convertToJavaDuration(): DataColumn<Duration>

Converts values in this column to JavaDuration.

Link copied to clipboard

Converts values in this column to JavaInstant. Preserves null values.

@JvmName(name = "convertToJavaInstantFromT")
fun <T : Any> DataColumn<T>.convertToJavaInstant(): DataColumn<Instant>

Converts values in this column to JavaInstant.

Link copied to clipboard

Converts values in this column to JavaLocalDate. Preserves null values.

@JvmName(name = "convertToJavaLocalDateFromT")
fun <T : Any> DataColumn<T>.convertToJavaLocalDate(): DataColumn<LocalDate>

Converts values in this column to JavaLocalDate.

@JvmName(name = "convertToJavaLocalDateFromStringNullable")
fun DataColumn<String?>.convertToJavaLocalDate(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataColumn<LocalDate?>
@JvmName(name = "convertToJavaLocalDateFromStringNullablePattern")
fun DataColumn<String?>.convertToJavaLocalDate(pattern: String, locale: Locale? = null): DataColumn<LocalDate?>

Converts values in this nullable String column to JavaLocalDate. Preserves null values.

@JvmName(name = "convertToJavaLocalDateFromString")
fun DataColumn<String>.convertToJavaLocalDate(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataColumn<LocalDate>
@JvmName(name = "convertToJavaLocalDateFromStringPattern")
fun DataColumn<String>.convertToJavaLocalDate(pattern: String, locale: Locale? = null): DataColumn<LocalDate>

Converts values in this String column to JavaLocalDate.

Link copied to clipboard

Converts values in this column to JavaLocalDateTime. Preserves null values.

@JvmName(name = "convertToJavaLocalDateTimeFromT")
fun <T : Any> DataColumn<T>.convertToJavaLocalDateTime(): DataColumn<LocalDateTime>

Converts values in this column to JavaLocalDateTime.

@JvmName(name = "convertToJavaLocalDateTimeFromStringNullable")
fun DataColumn<String?>.convertToJavaLocalDateTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataColumn<LocalDateTime?>
@JvmName(name = "convertToJavaLocalDateTimeFromStringNullablePattern")
fun DataColumn<String?>.convertToJavaLocalDateTime(pattern: String, locale: Locale? = null): DataColumn<LocalDateTime?>

Converts values in this nullable String column to JavaLocalDateTime. Preserves null values.

@JvmName(name = "convertToJavaLocalDateTimeFromString")
fun DataColumn<String>.convertToJavaLocalDateTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataColumn<LocalDateTime>
@JvmName(name = "convertToJavaLocalDateTimeFromStringPattern")
fun DataColumn<String>.convertToJavaLocalDateTime(pattern: String, locale: Locale? = null): DataColumn<LocalDateTime>

Converts values in this String column to JavaLocalDateTime.

Link copied to clipboard

Converts values in this column to JavaLocalTime. Preserves null values.

@JvmName(name = "convertToJavaLocalTimeFromT")
fun <T : Any> DataColumn<T>.convertToJavaLocalTime(): DataColumn<LocalTime>

Converts values in this column to JavaLocalTime.

@JvmName(name = "convertToJavaLocalTimeFromStringNullable")
fun DataColumn<String?>.convertToJavaLocalTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataColumn<LocalTime?>
@JvmName(name = "convertToJavaLocalTimeFromStringNullablePattern")
fun DataColumn<String?>.convertToJavaLocalTime(pattern: String, locale: Locale? = null): DataColumn<LocalTime?>

Converts values in this nullable String column to JavaLocalTime. Preserves null values.

@JvmName(name = "convertToJavaLocalTimeFromString")
fun DataColumn<String>.convertToJavaLocalTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataColumn<LocalTime>
@JvmName(name = "convertToJavaLocalTimeFromStringPattern")
fun DataColumn<String>.convertToJavaLocalTime(pattern: String, locale: Locale? = null): DataColumn<LocalTime>

Converts values in this String column to JavaLocalTime.

Link copied to clipboard
fun <T : Any> DataColumn<T?>.convertToLocalDate(): DataColumn<LocalDate?>

Converts values in this column to LocalDate. Preserves null values.

@JvmName(name = "convertToLocalDateFromT")
fun <T : Any> DataColumn<T>.convertToLocalDate(): DataColumn<LocalDate>

Converts values in this column to LocalDate.

@JvmName(name = "convertToLocalDateFromDateTimeComponentsNullable")
fun DataColumn<DateTimeComponents?>.convertToLocalDate(): DataColumn<LocalDate?>

Converts values in this DateTimeComponents column to LocalDate. Preserves null values.

@JvmName(name = "convertToLocalDateFromDateTimeComponents")
fun DataColumn<DateTimeComponents>.convertToLocalDate(): DataColumn<LocalDate>

Converts values in this DateTimeComponents column to LocalDate.

@JvmName(name = "convertToLocalDateFromIntNullable")
fun DataColumn<Int?>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate?>

Converts values in this Int column to LocalDate. Preserves null values.

@JvmName(name = "convertToLocalDateFromInt")
fun DataColumn<Int>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate>

Converts values in this Int column to LocalDate.

fun DataColumn<Long?>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate?>

Converts values in this Long column to LocalDate. Preserves null values.

@JvmName(name = "convertToLocalDateFromLong")
fun DataColumn<Long>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate>

Converts values in this Long column to LocalDate.

@JvmName(name = "convertToLocalDateFromStringNullablePattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String?>.convertToLocalDate(pattern: String): DataColumn<LocalDate?>
@JvmName(name = "convertToLocalDateFromStringNullable")
fun DataColumn<String?>.convertToLocalDate(format: DateTimeFormat<LocalDate>? = null): DataColumn<LocalDate?>

Converts values in this String column to LocalDate. Preserves null values.

@JvmName(name = "convertToLocalDateFromStringPattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String>.convertToLocalDate(pattern: String): DataColumn<LocalDate>
@JvmName(name = "convertToLocalDateFromString")
fun DataColumn<String>.convertToLocalDate(format: DateTimeFormat<LocalDate>? = null): DataColumn<LocalDate>

Converts values in this String column to LocalDate.

@JvmName(name = "convertToLocalDateFromStringNullable")
fun DataColumn<String?>.convertToLocalDate(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDate?>
@JvmName(name = "convertToLocalDateFromString")
fun DataColumn<String>.convertToLocalDate(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDate>
Link copied to clipboard
fun <T : Any> DataColumn<T?>.convertToLocalDateTime(): DataColumn<LocalDateTime?>

Converts values in this column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromT")
fun <T : Any> DataColumn<T>.convertToLocalDateTime(): DataColumn<LocalDateTime>

Converts values in this column to LocalDateTime.

@JvmName(name = "convertToLocalDateTimeFromDateTimeComponentsNullable")
fun DataColumn<DateTimeComponents?>.convertToLocalDateTime(): DataColumn<LocalDateTime?>

Converts values in this DateTimeComponents column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromDateTimeComponents")
fun DataColumn<DateTimeComponents>.convertToLocalDateTime(): DataColumn<LocalDateTime>

Converts values in this DateTimeComponents column to LocalDateTime.

@JvmName(name = "convertToLocalDateTimeFromIntNullable")
fun DataColumn<Int?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?>

Converts values in this Int column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromInt")
fun DataColumn<Int>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime>

Converts values in this Int column to LocalDateTime.

fun DataColumn<Long?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?>

Converts values in this Long column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromLong")
fun DataColumn<Long>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime>

Converts values in this Long column to LocalDateTime.

@JvmName(name = "convertToLocalDateTimeFromStringNullablePattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String?>.convertToLocalDateTime(pattern: String): DataColumn<LocalDateTime?>
@JvmName(name = "convertToLocalDateTimeFromStringNullable")
fun DataColumn<String?>.convertToLocalDateTime(format: DateTimeFormat<LocalDateTime>? = null): DataColumn<LocalDateTime?>

Converts values in this String column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromStringPattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String>.convertToLocalDateTime(pattern: String): DataColumn<LocalDateTime>
@JvmName(name = "convertToLocalDateTimeFromString")
fun DataColumn<String>.convertToLocalDateTime(format: DateTimeFormat<LocalDateTime>? = null): DataColumn<LocalDateTime>

Converts values in this String column to LocalDateTime.

@JvmName(name = "convertToLocalDateTimeFromStdlibInstantNullable")
fun DataColumn<Instant?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?>

Converts values in this kotlin.time.Instant column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromStdlibInstant")
fun DataColumn<Instant>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime>

Converts values in this kotlin.time.Instant column to LocalDateTime.

@JvmName(name = "convertToLocalDateTimeFromDeprecatedInstantNullable")
fun DataColumn<Instant?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?>

Converts values in this kotlinx.datetime.Instant column to LocalDateTime. Preserves null values.

@JvmName(name = "convertToLocalDateTimeFromDeprecatedInstant")
fun DataColumn<Instant>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime>

Converts values in this kotlinx.datetime.Instant column to LocalDateTime.

@JvmName(name = "convertToLocalDateTimeFromStringNullable")
fun DataColumn<String?>.convertToLocalDateTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDateTime?>
@JvmName(name = "convertToLocalDateTimeFromString")
fun DataColumn<String>.convertToLocalDateTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDateTime>
Link copied to clipboard
fun <T : Any> DataColumn<T?>.convertToLocalTime(): DataColumn<LocalTime?>

Converts values in this column to LocalTime. Preserves null values.

@JvmName(name = "convertToLocalTimeFromT")
fun <T : Any> DataColumn<T>.convertToLocalTime(): DataColumn<LocalTime>

Converts values in this column to LocalTime.

@JvmName(name = "convertToLocalTimeFromDateTimeComponentsNullable")
fun DataColumn<DateTimeComponents?>.convertToLocalTime(): DataColumn<LocalTime?>

Converts values in this DateTimeComponents column to LocalTime. Preserves null values.

@JvmName(name = "convertToLocalTimeFromDateTimeComponents")
fun DataColumn<DateTimeComponents>.convertToLocalTime(): DataColumn<LocalTime>

Converts values in this DateTimeComponents column to LocalTime.

@JvmName(name = "convertToLocalTimeIntNullable")
fun DataColumn<Int?>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime?>

Converts values in this Int column to LocalTime. Preserves null values.

@JvmName(name = "convertToLocalTimeFromInt")
fun DataColumn<Int>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime>

Converts values in this Int column to LocalTime.

fun DataColumn<Long?>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime?>

Converts values in this Long column to LocalTime. Preserves null values.

@JvmName(name = "convertToLocalTimeFromLong")
fun DataColumn<Long>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime>

Converts values in this Long column to LocalTime.

@JvmName(name = "convertToLocalTimeFromStringNullablePattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String?>.convertToLocalTime(pattern: String): DataColumn<LocalTime?>
@JvmName(name = "convertToLocalTimeFromStringNullable")
fun DataColumn<String?>.convertToLocalTime(format: DateTimeFormat<LocalTime>? = null): DataColumn<LocalTime?>

Converts values in this String column to LocalTime. Preserves null values.

@JvmName(name = "convertToLocalTimeFromStringPattern")
@FormatStringsInDatetimeFormats
fun DataColumn<String>.convertToLocalTime(pattern: String): DataColumn<LocalTime>
@JvmName(name = "convertToLocalTimeFromString")
fun DataColumn<String>.convertToLocalTime(format: DateTimeFormat<LocalTime>? = null): DataColumn<LocalTime>

Converts values in this String column to LocalTime.

@JvmName(name = "convertToLocalTimeFromStringNullable")
fun DataColumn<String?>.convertToLocalTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalTime?>
@JvmName(name = "convertToLocalTimeFromString")
fun DataColumn<String>.convertToLocalTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalTime>
Link copied to clipboard

Converts values in this column to Long. Preserves null values.

@JvmName(name = "convertToLongFromT")
fun <T : Any> DataColumn<T>.convertToLong(): DataColumn<Long>

Converts values in this column to Long.

Link copied to clipboard

Converts values in this column to Short. Preserves null values.

@JvmName(name = "convertToShortFromT")
fun <T : Any> DataColumn<T>.convertToShort(): DataColumn<Short>

Converts values in this column to Short.

Link copied to clipboard
@JvmName(name = "convertToStdlibInstantFromStringNullable")
fun DataColumn<String?>.convertToStdlibInstant(): DataColumn<Instant?>

Converts values in this String column to kotlin.time.Instant. Preserves null values.

Converts values in this String column to kotlin.time.Instant.

@JvmName(name = "convertToStdlibInstantFromDeprecatedInstantNullable")
fun DataColumn<Instant?>.convertToStdlibInstant(): DataColumn<Instant?>

Converts values in this kotlinx.datetime.Instant column to kotlin.time.Instant. Preserves null values.

@JvmName(name = "convertToStdlibInstantFromDeprecatedInstant")
fun DataColumn<Instant>.convertToStdlibInstant(): DataColumn<Instant>

Converts values in this kotlinx.datetime.Instant column to kotlin.time.Instant.

@JvmName(name = "convertToStdlibInstantFromDateTimeComponentsNullable")
fun DataColumn<DateTimeComponents?>.convertToStdlibInstant(): DataColumn<Instant?>

Converts values in this DateTimeComponents column to kotlin.time.Instant. Preserves null values.

@JvmName(name = "convertToStdlibInstantFromDateTimeComponents")
fun DataColumn<DateTimeComponents>.convertToStdlibInstant(): DataColumn<Instant>

Converts values in this DateTimeComponents column to kotlin.time.Instant.

Link copied to clipboard

Converts values in this column to String. Preserves null values.

@JvmName(name = "convertToStringFromT")
fun <T : Any> DataColumn<T>.convertToString(): DataColumn<String>

Converts values in this column to String.

Link copied to clipboard
@JvmName(name = "convertToURLFromStringNullable")
fun DataColumn<String?>.convertToURL(): DataColumn<URL?>
Link copied to clipboard
@JvmName(name = "convertToUrlFromStringNullable")
fun DataColumn<String?>.convertToUrl(): DataColumn<URL?>

Converts values in this String column to an URL. Preserves null values.

Converts values in this String column to an URL.

Link copied to clipboard
@JvmName(name = "convertToUtcOffsetNullable")
fun DataColumn<DateTimeComponents?>.convertToUtcOffset(): DataColumn<UtcOffset?>

Converts values in this DateTimeComponents column to UtcOffset. Preserves null values.

fun DataColumn<DateTimeComponents>.convertToUtcOffset(): DataColumn<UtcOffset>

Converts values in this DateTimeComponents column to UtcOffset.

Link copied to clipboard
@JvmName(name = "convertToYearMonthNullable")
fun DataColumn<DateTimeComponents?>.convertToYearMonth(): DataColumn<YearMonth?>

Converts values in this DateTimeComponents column to YearMonth. Preserves null values.

fun DataColumn<DateTimeComponents>.convertToYearMonth(): DataColumn<YearMonth>

Converts values in this DateTimeComponents column to YearMonth.

Link copied to clipboard
Link copied to clipboard

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>
Link copied to clipboard
fun <T> DataFrame<T>.count(): Int

Returns the total number of rows of this DataFrame.

fun DataRow<*>.count(): Int

Returns the number of columns in this DataRow.

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

fun <T> Pivot<T>.count(): DataRow<T>

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

fun <T> DataColumn<T>.count(predicate: Predicate<T>? = null): Int

Counts the elements in this DataColumn that satisfy a given predicate or returns the total count if no predicate is provided.

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

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

inline fun DataRow<*>.count(predicate: Predicate<Any?>): Int

Counts the number of elements in the current row that satisfy the given predicate.

fun <T> Grouped<T>.count(resultName: String = "count"): DataFrame<T>

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

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

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

inline fun <T> Pivot<T>.count(crossinline predicate: RowFilter<T>): DataRow<T>

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

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

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

Link copied to clipboard

Returns the number of distinct rows in this DataFrame.

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

fun <T> Grouped<T>.countDistinct(resultName: String = "countDistinct"): DataFrame<T>

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

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

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

Link copied to clipboard
fun <T : Number?> DataColumn<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<T>
@JvmName(name = "cumSumNullableByte")
fun DataColumn<Byte?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Int?>
@JvmName(name = "cumSumByte")
fun DataColumn<Byte>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Int>
@JvmName(name = "cumSumDouble")
fun DataColumn<Double?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Double>
@JvmName(name = "cumSumFloat")
fun DataColumn<Float?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Float>
@JvmName(name = "cumSumNullableShort")
fun DataColumn<Short?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Int?>
@JvmName(name = "cumSumShort")
fun DataColumn<Short>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Int>

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

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.

fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G>
fun <T, G, C : Number?> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<G, C>): GroupBy<T, G>
fun <T, G> GroupBy<T, G>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G>
fun <T, G> GroupBy<T, G>.cumSum(vararg columns: KProperty<Number?>, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G>
fun <T, G> GroupBy<T, G>.cumSum(vararg columns: ColumnReference<Number?>, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G>

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

Link copied to clipboard
fun dataFrameOf(vararg columns: Pair<String, List<Any?>>): DataFrame<*>
fun dataFrameOf(vararg header: String): DataFrameBuilder
fun dataFrameOf(vararg columns: BaseColumn<*>): DataFrame<*>
inline fun <T, reified C> dataFrameOf(header: Iterable<T>, fill: (T) -> Iterable<C>): DataFrame<*>
fun dataFrameOf(header: Iterable<String>, values: Iterable<Any?>): DataFrame<*>
inline fun <reified C> dataFrameOf(vararg header: String, crossinline fill: (String) -> Iterable<C>): DataFrame<*>

Creates new DataFrame with given columns.

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

Example:

@JvmName(name = "dataFrameOfColumns")
fun dataFrameOf(vararg columns: Pair<String, BaseColumn<*>>): DataFrame<*>
Link copied to clipboard
fun <T, C, R> SplitWithTransform<T, C, R>.default(value: R?): SplitWithTransform<T, C, R>
inline fun <T, C : Iterable<R>, reified R> Split<T, C>.default(value: R?): SplitWithTransform<T, C, R>
Link copied to clipboard
internal inline fun <T> Pivot<T>.delegate(crossinline body: PivotGroupBy<T>.() -> DataFrame<T>): DataRow<T>
Link copied to clipboard

Computes descriptive statistics for a given DataColumn, returning a DataFrame with key summary metrics.

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

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

Link copied to clipboard
inline fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression<T, Double>): Double
inline fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<T, Float>): Float
inline fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T, Int>): Int
inline fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T, Long>): Long

Calculates the difference between the results of a row expression computed on the current and previous DataRow.

Link copied to clipboard
inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Double>): Double?
inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Float>): Float?
inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Int>): Int?
inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Long>): Long?

Calculates the difference between the results of a row expression computed on the current and previous DataRow.

Link copied to clipboard

Removes duplicated rows based on all columns.

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>
Link copied to clipboard
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>
Link copied to clipboard

Returns a DataColumn containing the results of dividing this BigDecimal by each element of column.

Returns a DataColumn containing the results of dividing this BigInteger by each element of column.

operator fun Double.div(column: DataColumn<Double>): DataColumn<Double>
@JvmName(name = "doubleDiv")
operator fun Double.div(column: DataColumn<Int>): DataColumn<Double>

Returns a DataColumn containing the results of dividing this Double by each element of column.

@JvmName(name = "intDiv")
operator fun Int.div(column: DataColumn<Double>): DataColumn<Double>
@JvmName(name = "divNullable")
operator fun Int.div(column: DataColumn<Int?>): DataColumn<Int?>
operator fun Int.div(column: DataColumn<Int>): DataColumn<Int>

Returns a DataColumn containing the results of dividing this Int by each element of column.

operator fun Int.div(column: ColumnReference<Int>): ColumnReference<Int>

Returns a ColumnReference containing the results of dividing this Int by each element of column.

operator fun Long.div(column: DataColumn<Long>): DataColumn<Long>

Returns a DataColumn containing the results of dividing this Long by each element of column.

operator fun DataColumn<Double>.div(value: Double): DataColumn<Double>
@JvmName(name = "divDouble")
operator fun DataColumn<Double>.div(value: Int): DataColumn<Double>
@JvmName(name = "divIntNullable")
operator fun DataColumn<Int?>.div(value: Int): DataColumn<Int?>
@JvmName(name = "divInt")
operator fun DataColumn<Int>.div(value: Double): DataColumn<Double>
operator fun DataColumn<Int>.div(value: Int): DataColumn<Int>
operator fun DataColumn<Long>.div(value: Long): DataColumn<Long>

Returns a DataColumn containing the results of dividing each element of this DataColumn by value.

operator fun ColumnReference<Int>.div(value: Int): ColumnReference<Int>

Returns a ColumnReference containing the results of dividing each element of this ColumnReference by value.

Link copied to clipboard
inline fun <T> DataColumn<T>.drop(predicate: Predicate<T>): DataColumn<T>

Returns a DataColumn containing only the values that do not match the given predicate.

Returns a DataColumn containing all values of this DataColumn except the first n values.

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.

Link copied to clipboard
fun <T> DataColumn<T>.dropLast(n: Int = 1): DataColumn<T>

Returns a DataColumn containing all values of this DataColumn except the last n values.

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

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

Link copied to clipboard

Removes NA values from this DataColumn, adjusting the type accordingly.

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.

Link copied to clipboard

Removes NaN values from this DataColumn, adjusting the type accordingly.

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.

Link copied to clipboard

Removes null values from this DataColumn, adjusting the type accordingly.

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.

Link copied to clipboard
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.

Link copied to clipboard

Returns a FrameColumn that holds this DataFrame n times.

Returns a DataFrame with n rows, each of them a copy of this DataRow.

Link copied to clipboard

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.

Link copied to clipboard
inline fun <reified T> emptyDataFrame(): DataFrame<T>

Returns DataFrame with empty columns according to schema T.

Link copied to clipboard

Checks the validity of this SingleColumn, by adding a check to see it's a ColumnGroup (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

Link copied to clipboard

Checks the validity of this SingleColumn, by adding a check to see it's a FrameColumn (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

Link copied to clipboard

Checks the validity of this SingleColumn, by adding a check to see it's a ValueColumn (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

Link copied to clipboard
infix fun <T> DataColumn<T>.eq(value: T): DataColumn<Boolean>

Returns a DataColumn containing the results of comparing each element of this DataColumn with value for equality using the == operator.

infix fun <C> ColumnReference<C>.eq(value: C): ColumnReference<Boolean>
Link copied to clipboard
internal fun <C> ColumnSet<C>.exceptInternal(other: ColumnsResolver<*>): ColumnSet<C>

Removes the columns in the "other" ColumnsResolver from the current ColumnSet while keeping the structure intact. Returns a new ColumnSet with the remaining columns.

@JvmName(name = "exceptInternalSingleColumn")
internal fun <C> SingleColumn<DataRow<C>>.exceptInternal(other: ColumnsResolver<*>): SingleColumn<DataRow<C>>

Returns a new SingleColumn> that has the same structure as the receiver, but excludes columns specified in the "other" ColumnsResolver.

Link copied to clipboard
fun <A, B> DataFrame<A>.excludeJoin(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.excludeJoin(other: DataFrame<B>, 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.

Link copied to clipboard
fun <A, B> DataFrame<A>.excludeJoinWith(right: DataFrame<B>, 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.

Link copied to clipboard
@JvmName(name = "explodeList")
fun <T> DataColumn<Collection<T>>.explode(): DataColumn<T>

Splits list-like values in this DataColumn and spreads them vertically — that is, it adds a separate row for each element (one value per row).

@JvmName(name = "explodeFrames")
fun <T> DataColumn<DataFrame<T>>.explode(): ColumnGroup<T>

Explodes a DataColumn of DataFrame values into a single ColumnGroup.

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>

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, 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>
fun <T, C> DataRow<T>.explode(vararg columns: KProperty<C>, dropEmpty: Boolean = true): DataFrame<T>
fun <T, C> DataRow<T>.explode(vararg columns: ColumnReference<C>, dropEmpty: Boolean = true): DataFrame<T>

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

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

Link copied to clipboard
fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R>

Explodes List values — i.e., splits each list into individual elements, creating a separate row for each element, and duplicating all other columns — in the columns previously selected by gather.

@JvmName(name = "explodeListsTyped")
fun <T, C, K, R> Gather<T, List<C>, K, R>.explodeLists(): Gather<T, C, K, R>

Explodes List values in the columns previously selected by gather.

Link copied to clipboard
inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(name: String = "", infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): DataColumn<R>

Creates a temporary new column by defining an expression to fill up each row.

Link copied to clipboard
inline fun <T, reified C> ConvertSchemaDsl<T>.fill(noinline columns: ColumnsSelector<T, C>): ConvertToFill<T, C>

Defines how to fill all specified columns in the destination schema that were not found in the original dataframe. All fill operations for missing columns are executed after successful conversion of matched columns, so converted values of matched columns can be safely used in with expression.

Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard
internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C>

inline fun <T> DataColumn<T>.filter(predicate: Predicate<T>): DataColumn<T>

Returns a new DataColumn containing only the elements that match the given predicate.

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.

Link copied to clipboard
Link copied to clipboard
fun <A, B> DataFrame<A>.filterJoin(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.filterJoin(other: DataFrame<B>, 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.

Link copied to clipboard
fun <A, B> DataFrame<A>.filterJoinWith(right: DataFrame<B>, 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.

Link copied to clipboard
Link copied to clipboard
fun <T> DataColumn<T>.first(): T

Returns the first value in this DataColumn.

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

Returns the first row in this DataFrame.

fun <T, G> GroupBy<T, G>.first(): ReducedGroupBy<T, G>

Reduces the groups of this GroupBy by taking the first row from each group, and returns a ReducedGroupBy containing these rows (one row per group, each row is the first row in its group).

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

Reduces this Pivot by taking the first row from each group, and returns a ReducedPivot that contains the first row from the corresponding group in each column.

fun <T> DataColumn<T>.first(predicate: (T) -> Boolean): T

Returns the first value in this DataColumn that matches the given predicate.

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

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

fun <T, G> GroupBy<T, G>.first(predicate: RowFilter<G>): ReducedGroupBy<T, G>

Reduces the groups of this GroupBy by taking from each group the first row satisfying the given predicate, and returns a ReducedGroupBy containing these rows (one row per group, each row is the first row in its group that satisfies the predicate).

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

fun <T> Pivot<T>.first(predicate: RowFilter<T>): ReducedPivot<T>

Reduces this Pivot by taking from each group the first row satisfying the given predicate, and returns a ReducedPivot that contains the first row, matching the predicate, from the corresponding group in each column.

Link copied to clipboard

Returns the first value in this DataColumn. If the DataColumn is empty, returns null.

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

fun <T> DataColumn<T>.firstOrNull(predicate: (T) -> Boolean): T?

Returns the first value in this DataColumn that matches the given predicate. Returns null if the DataColumn contains no elements matching the predicate (including the case when the DataColumn is empty).

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

Link copied to clipboard
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.

Link copied to clipboard
inline fun <T> DataColumn<T>.forEach(action: (T) -> Unit)

Calls action for every value of this DataColumn, from the first one to the last one.

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.

inline fun <T, G> GroupBy<T, G>.forEach(body: (GroupBy.Entry<T, G>) -> Unit)

Calls body for every key–group pair of this GroupBy, in the order in which the pairs appear in it.

Link copied to clipboard
inline fun <T> DataColumn<T>.forEachIndexed(action: (Int, T) -> Unit)

Calls action for every value of this DataColumn and its position, from the first value to the last one.

Link copied to clipboard

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.

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?>
fun <T> FormattedFrame<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>
Link copied to clipboard
fun <T> DataFrame<T>.formatHeader(vararg columns: String): HeaderFormatClause<T, Any?>

Experimental API. It may be changed in the future.

Link copied to clipboard
@JvmName(name = "frameColumnTyped")
fun <T> frameColumn(): ColumnDelegate<DataFrame<T>>
@JvmName(name = "frameColumnTyped")
fun <T> frameColumn(name: String): ColumnAccessor<DataFrame<T>>
@JvmName(name = "frameColumnDataFrameKProperty")
fun <T> frameColumn(property: KProperty<DataFrame<T>>): ColumnAccessor<DataFrame<T>>
@JvmName(name = "frameColumnTyped")
fun <T> frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<T>>
Link copied to clipboard
internal inline fun ColumnsResolver<*>.frameColumnsInternal(crossinline filter: (FrameColumn<*>) -> Boolean): TransformableColumnSet<AnyFrame>

Returns a TransformableColumnSet containing the frame columns that satisfy the given filter.

Link copied to clipboard
Link copied to clipboard
fun <A, B> DataFrame<A>.fullJoin(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.fullJoin(other: DataFrame<B>, 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.

Link copied to clipboard
fun <A, B> DataFrame<A>.fullJoinWith(right: DataFrame<B>, 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.

Link copied to clipboard
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>
Link copied to clipboard
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
Link copied to clipboard
internal fun DataFrameSchema.generateCodeImpl(markerName: String, extensionProperties: Boolean, visibility: MarkerVisibility, useFqNames: Boolean, nameNormalizer: NameNormalizer, asDataClass: Boolean, knownMarkers: Iterable<Marker> = emptyList(), nestedMarkerNameProvider: MarkerNameProvider = MarkerNameProvider.fromColumnName): CodeString

Generates a CodeString containing generated @DataSchema declarations (markers).

Link copied to clipboard
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).

@JvmName(name = "generateDataClassesForSchema")
fun DataFrameSchema.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 DataFrameSchema (including all nested frame columns and column groups).

Link copied to clipboard
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).

@JvmName(name = "generateInterfacesForSchema")
fun DataFrameSchema.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 DataFrameSchema (including all nested frame columns and column groups).

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T> DataFrame<T>.getColumns(vararg columns: String): List<DataColumn<*>>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T> DataFrame<T>.getOrNull(index: Int): DataRow<T>?
Link copied to clipboard
fun <T> DataRow<T>.getRow(index: Int): DataRow<T>
Link copied to clipboard
fun <T> DataRow<T>.getRowOrNull(index: Int): DataRow<T>?
Link copied to clipboard
fun <T> DataFrame<T>.getRows(indices: Iterable<Int>): DataFrame<T>
fun <T> DataRow<T>.getRows(indices: Iterable<Int>): DataFrame<T>
fun <T> DataRow<T>.getRows(indices: IntRange): DataFrame<T>
Link copied to clipboard
fun <T> DataRow<*>.getValue(columnName: String): T
fun <T> DataRow<*>.getValue(column: KProperty<T>): T
fun <T> DataRow<*>.getValue(column: ColumnReference<T>): T
Link copied to clipboard
fun <T> DataRow<*>.getValueOrNull(columnName: String): T?
fun <T> DataRow<*>.getValueOrNull(column: KProperty<T>): T?
Link copied to clipboard
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?>
Link copied to clipboard
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> Pivot<T>.groupBy(vararg columns: KProperty<*>): PivotGroupBy<T>
fun <T> Pivot<T>.groupBy(vararg columns: ColumnReference<*>): PivotGroupBy<T>
fun <T> DataFrame<T>.groupBy(vararg cols: ColumnReference<*>, moveToTop: Boolean = true): GroupBy<T, T>

fun <T> Pivot<T>.groupBy(vararg columns: String): PivotGroupBy<T>
fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T>

Groups the rows of this Pivot groups based on the values in one or more specified key columns. Returns a PivotGroupBy.

Link copied to clipboard

Groups the rows of this Pivot into a PivotGroupBy based on the values of all columns except the pivot key columns. For example, if a DataFrame has columns "a", "b", "c", "d" and is pivoted by "a" and "c", then this Pivot will be grouped by the remaining columns "b" and "d".

Link copied to clipboard
infix fun <T : Comparable<T>> DataColumn<T>.gt(value: T): DataColumn<Boolean>

Returns a DataColumn containing the results of comparing each element of this DataColumn with value using the > operator.

Link copied to clipboard
fun <T> DataFrame<T>.head(numRows: Int = 5): DataFrame<T>
Link copied to clipboard
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>
Link copied to clipboard

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.

Link copied to clipboard
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>
Link copied to clipboard
fun <A, B> DataFrame<A>.innerJoin(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.innerJoin(other: DataFrame<B>, 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.

Link copied to clipboard
fun <A, B> DataFrame<A>.innerJoinWith(right: DataFrame<B>, 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.

Link copied to clipboard
@JvmName(name = "inplaceTC")
inline fun <T, C : Iterable<R>, reified R> Split<T, C>.inplace(): DataFrame<T>
Link copied to clipboard
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>
Link copied to clipboard
fun <T> GroupBy<T, *>.into(column: KProperty<DataFrame<*>>): DataFrame<T>
fun <T> GroupBy<T, *>.into(column: ColumnAccessor<DataFrame<*>>): DataFrame<T>
fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T>
fun <T, C, R> MergeWithTransform<T, C, R>.into(columnName: String): DataFrame<T>
inline fun <T, C, reified R> MergeWithTransform<T, C, R>.into(column: ColumnAccessor<*>): DataFrame<T>
fun <T, C, R> Merge<T, C, R>.into(columnName: String): DataFrame<T>
inline fun <T, C, reified R> Merge<T, C, R>.into(column: ColumnAccessor<*>): DataFrame<T>
fun <T, C, R> Merge<T, C, R>.into(path: ColumnPath): DataFrame<T>
fun <T, G> ReducedGroupBy<T, G>.into(columnName: String): DataFrame<G>
fun <T, G> ReducedGroupBy<T, G>.into(column: KProperty<DataRow<*>>): DataFrame<G>
fun <T, C> RenameClause<T, C>.into(vararg newNames: KProperty<*>): DataFrame<T>
fun <T, C> RenameClause<T, C>.into(vararg newColumns: ColumnReference<*>): DataFrame<T>
fun <T, C, K, R> Gather<T, C, K, R>.into(keyColumn: KProperty<K>, valueColumn: KProperty<R>): DataFrame<T>
fun <T, C, K, R> Gather<T, C, K, R>.into(keyColumn: ColumnAccessor<K>, valueColumn: ColumnAccessor<R>): DataFrame<T>
inline fun <T, G, reified V> GroupBy<T, G>.into(column: KProperty<V>, noinline expression: RowExpression<G, V>): DataFrame<G>
inline fun <T, G, reified V> GroupBy<T, G>.into(column: ColumnAccessor<V>, noinline expression: RowExpression<G, V>): DataFrame<G>
inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(columnName: String? = null, noinline expression: RowExpression<G, V>): DataFrame<G>
inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(column: KProperty<V>, noinline expression: RowExpression<G, V>): DataFrame<G>
inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(column: ColumnAccessor<V>, noinline expression: RowExpression<G, V>): DataFrame<G>
fun <T, C, R> SplitWithTransform<T, C, R>.into(names: List<String>, extraNamesGenerator: ColumnWithPath<C>.(extraColumnIndex: Int) -> String? = null): DataFrame<T>
fun <T, C, R> SplitWithTransform<T, C, R>.into(firstName: KProperty<*>, vararg otherNames: KProperty<*>): DataFrame<T>
fun <T, C, R> SplitWithTransform<T, C, R>.into(firstName: ColumnAccessor<*>, vararg otherNames: ColumnAccessor<*>): DataFrame<T>
fun <T, C, R> SplitWithTransform<T, C, R>.into(vararg names: String, extraNamesGenerator: ColumnWithPath<C>.(extraColumnIndex: Int) -> String? = null): DataFrame<T>
fun <T, C : Iterable<*>> Split<T, C>.into(vararg names: String, extraNamesGenerator: ColumnNamesGenerator<C>? = null): DataFrame<T>
fun <T, A, B> Split<T, Pair<A, B>>.into(firstCol: String, secondCol: String): DataFrame<T>
inline fun <T, reified A, reified B> Split<T, Pair<A, B>>.into(firstCol: ColumnAccessor<A>, secondCol: ColumnAccessor<B>): DataFrame<T>
@JvmName(name = "intoTC")
fun <T> Split<T, String>.into(vararg names: String, extraNamesGenerator: ColumnWithPath<String>.(extraColumnIndex: Int) -> String? = null): DataFrame<T>
@JvmName(name = "splitDataFrameInto")
fun <T, C> Split<T, DataFrame<C>>.into(vararg names: String, extraNamesGenerator: ColumnNamesGenerator<DataFrame<C>>? = null): DataFrame<T>
internal fun <T, G, V> GroupBy<T, G>.into(path: ColumnPath, expression: RowExpression<G, V>, type: KType): DataFrame<G>

fun <T, G> GroupBy<T, G>.into(column: String): DataFrame<T>

Converts this GroupBy into a DataFrame.

@JvmName(name = "intoString")
fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T>

Groups columns, previously selected with group, into new or existing column groups within the DataFrame, using a ColumnsSelectionDsl expression to specify the target group name for each column. The expression is applied to each selected column and determines the name of the column group it will be placed into.

@JvmName(name = "intoColumn")
fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> ColumnReference<*>): DataFrame<T>

Groups columns, previously selected with group, into a new or existing column group within the DataFrame by specifying its path via ColumnsSelectionDsl expression.

fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T>

Groups columns, previously selected with group, into a new or existing column group within the DataFrame, by specifying its name.

Moves columns, previously selected with move into a new position specified by a given column path within the DataFrame.

fun <T, C> MoveClause<T, C>.into(column: String): DataFrame<T>

Moves the selected column, previously specified with move, to the top level of the DataFrame and assigns it a new name.

fun <T, C> RenameClause<T, C>.into(transform: (ColumnWithPath<C>) -> String): DataFrame<T>
fun <T, C> RenameClause<T, C>.into(vararg newNames: String): DataFrame<T>

NOTE: While you can keep using 'into', we recommend using to for better readability and more natural English.

fun <T, C, K, R> Gather<T, C, K, R>.into(keyColumn: String, valueColumn: String): DataFrame<T>

Reshapes the columns previously selected by gather into two new columns: keyColumn, containing the original column names, and valueColumn, containing the corresponding cell values.

inline fun <T, G, reified V> GroupBy<T, G>.into(columnName: String? = null, noinline expression: RowExpression<G, V>): DataFrame<G>

Aggregates this GroupBy into a DataFrame by computing the values of expression on all rows for each group.

Link copied to clipboard
fun <T, C : DataFrame<*>> Split<T, C>.intoColumns(): DataFrame<T>
Link copied to clipboard

Moves columns, previously selected with move into a new position specified by a given column path within the DataFrame. Provides selected column indices.

Link copied to clipboard
fun <T, C, R> Merge<T, C, R>.intoList(): List<R>
Link copied to clipboard
fun <T, C, R> SplitWithTransform<T, C, R>.intoRows(dropEmpty: Boolean = true): DataFrame<T>
@JvmName(name = "intoRowsTC")
inline fun <T, C : Iterable<R>, reified R> Split<T, C>.intoRows(dropEmpty: Boolean = true): DataFrame<T>
@JvmName(name = "intoRowsFrame")
fun <T, C : DataFrame<*>> Split<T, C>.intoRows(dropEmpty: Boolean = true): DataFrame<T>
Link copied to clipboard
fun <T, C, R> SplitWithTransform<T, C, R>.inward(names: Iterable<String>, extraNamesGenerator: ColumnNamesGenerator<C>? = null): DataFrame<T>
fun <T, C, R> SplitWithTransform<T, C, R>.inward(firstName: KProperty<*>, vararg otherNames: KProperty<*>): DataFrame<T>
fun <T, C, R> SplitWithTransform<T, C, R>.inward(firstName: ColumnAccessor<*>, vararg otherNames: ColumnAccessor<*>): DataFrame<T>
fun <T, C, R> SplitWithTransform<T, C, R>.inward(vararg names: String, extraNamesGenerator: ColumnNamesGenerator<C>? = null): DataFrame<T>
inline fun <T, C : Iterable<R>, reified R> Split<T, C>.inward(vararg names: String, noinline extraNamesGenerator: ColumnNamesGenerator<C>? = null): DataFrame<T>
@JvmName(name = "splitDataFrameInward")
fun <T, C : DataFrame<R>, R> Split<T, C>.inward(vararg names: String, extraNamesGenerator: ColumnNamesGenerator<C>? = null): DataFrame<T>
fun <T, A, B> Split<T, Pair<A, B>>.inward(firstCol: String, secondCol: String): DataFrame<T>
inline fun <T, reified A, reified B> Split<T, Pair<A, B>>.inward(firstCol: ColumnAccessor<A>, secondCol: ColumnAccessor<B>): DataFrame<T>
@JvmName(name = "inwardTC")
fun <T> Split<T, String>.inward(vararg names: String, extraNamesGenerator: ColumnWithPath<String>.(extraColumnIndex: Int) -> String? = null): DataFrame<T>
Link copied to clipboard

Returns true if this column is a ColumnGroup, i.e., its kind is ColumnKind.Group.

Link copied to clipboard

Returns true if this column is intra-comparable (mutually comparable), i.e., its values can be compared with each other and thus ordered.

Link copied to clipboard

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

Link copied to clipboard

Returns true if this column is a FrameColumn, i.e., its kind is ColumnKind.Frame.

Link copied to clipboard

Returns true when the class of this column's type is List, i.e., the column holds List<*> (or List<*>?) values.

Link copied to clipboard

Returns true only when this column's type is exactly Number or Number?.

Link copied to clipboard
@JvmName(name = "isNaWithContract")
internal inline fun <T> T.isNA(): Boolean

Returns true if this is considered NA. "NA", in DataFrame, roughly means null or NaN.

Link copied to clipboard

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

Link copied to clipboard

Returns true when this column's type is a subtype of Number?

Link copied to clipboard

Returns true when this column has the (nullable) type of either: Byte, Short, Int, Long, Float, or Double.

Link copied to clipboard

Returns true when this column has the (nullable) type of either: Byte, Short, Int, Long, Float, Double, or Number.

Link copied to clipboard
inline fun <reified T> DataColumn<*>.isSubtypeOf(): Boolean

Returns true if the type of this column is a subtype of T.

Returns true if the type of this column is a subtype of the given type.

Link copied to clipboard
Link copied to clipboard
inline fun <reified T> DataColumn<*>.isType(): Boolean

Returns true only if the type of this column is exactly T.

Link copied to clipboard

Returns true if this column is a ValueColumn, i.e., its kind is ColumnKind.Value.

Link copied to clipboard
fun <A, B> DataFrame<A>.join(other: DataFrame<B>, type: JoinType = JoinType.Inner, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.join(other: DataFrame<B>, vararg columns: String, type: JoinType = JoinType.Inner): DataFrame<A>

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

Link copied to clipboard
fun <T> Iterable<DataFrame<T>>.joinOrNull(joinType: JoinType = JoinType.Inner, selector: JoinColumnsSelector<T, T>? = null): DataFrame<T>?

Joins all DataFrames in this iterable into a single DataFrame.

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

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

Link copied to clipboard
fun <T, C, K, R> Gather<T, C, K, R>.keysInto(keyColumn: String): DataFrame<T>

Reshapes the columns previously selected by gather into a new keyColumn, containing the original column names. The value column is omitted.

fun <T, C, K, R> Gather<T, C, K, R>.keysInto(keyColumn: KProperty<K>): DataFrame<T>
fun <T, C, K, R> Gather<T, C, K, R>.keysInto(keyColumn: ColumnAccessor<K>): DataFrame<T>
Link copied to clipboard
fun <T> DataColumn<T>.last(): T

Returns the last value in this DataColumn.

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

Returns the last row in this DataFrame.

fun <T, G> GroupBy<T, G>.last(): ReducedGroupBy<T, G>

Reduces the groups of this GroupBy by taking the last row from each group, and returns a ReducedGroupBy containing these rows (one row per group, each row is the last row in its group).

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

fun <T> Pivot<T>.last(): ReducedPivot<T>

Reduces this Pivot by taking the last row from each group, and returns a ReducedPivot that contains the last row from the corresponding group in each column.

inline fun <T> DataColumn<T>.last(predicate: (T) -> Boolean): T

Returns the last value in this DataColumn that matches the given predicate.

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

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

fun <T, G> GroupBy<T, G>.last(predicate: RowFilter<G>): ReducedGroupBy<T, G>

Reduces the groups of this GroupBy by taking from each group the last row satisfying the given predicate, and returns a ReducedGroupBy containing these rows (one row per group, each row is the last row in its group that satisfies the predicate).

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

fun <T> Pivot<T>.last(predicate: RowFilter<T>): ReducedPivot<T>

Reduces this Pivot by taking from each group the last row satisfying the given predicate, and returns a ReducedPivot that contains the last row, matching the predicate, from the corresponding group in each column.

Link copied to clipboard

Returns the last value in this DataColumn. If the DataColumn is empty, returns null.

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

inline fun <T> DataColumn<T>.lastOrNull(predicate: (T) -> Boolean): T?

Returns the last value in this DataColumn that matches the given predicate. Returns null if the DataColumn contains no elements matching the predicate (including the case when the DataColumn is empty).

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

Link copied to clipboard
fun <A, B> DataFrame<A>.leftJoin(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.leftJoin(other: DataFrame<B>, 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.

Link copied to clipboard
fun <A, B> DataFrame<A>.leftJoinWith(right: DataFrame<B>, 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.

Link copied to clipboard

Creates a new FormattedFrame by just changing the background colors of the selected cells.

Link copied to clipboard
infix fun <T : Comparable<T>> DataColumn<T>.lt(value: T): DataColumn<Boolean>

Returns a DataColumn containing the results of comparing each element of this DataColumn with value using the < operator.

Link copied to clipboard
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.

inline fun <T, G, R> GroupBy<T, G>.map(body: Selector<GroupWithKey<T, G>, R>): List<R>

Returns a List with the values that body computes from the key–group pairs of this GroupBy.

inline fun <T, reified R> DataColumn<T>.map(infer: Infer = Infer.Nulls, transform: (T) -> R): DataColumn<R>

Returns a new DataColumn with the values that transform computes from the values of this column.

internal inline fun <C, reified R> ColumnReference<C>.map(infer: Infer = Infer.Nulls, noinline transform: (C) -> R): ColumnReference<R>

inline fun <T, R> DataColumn<T>.map(type: KType, infer: Infer = Infer.Nulls, transform: (T) -> R): DataColumn<R>

Returns a new DataColumn of the given type with the values that transform computes from the values of this column.

Link copied to clipboard
inline fun <T, reified R> DataColumn<T>.mapIndexed(infer: Infer = Infer.Nulls, transform: (Int, T) -> R): DataColumn<R>

Returns a new DataColumn with the values that transform computes from the values of this column and their positions.

inline fun <T, R> DataColumn<T>.mapIndexed(type: KType, infer: Infer = Infer.Nulls, transform: (Int, T) -> R): DataColumn<R>

Returns a new DataColumn of the given type with the values that transform computes from the values of this column and their positions.

Link copied to clipboard
inline fun <T, C, reified K, R> Gather<T, C, *, R>.mapKeys(noinline transform: (String) -> K): Gather<T, C, K, R>

Applies transform to the gathering keys — that is, the names of the columns previously selected by gather.

Link copied to clipboard
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>
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.

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

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

Link copied to clipboard

Returns a FrameColumn with the dataframes that body computes from the key–group pairs of this GroupBy.

Link copied to clipboard

Returns a DataFrame with the rows that body computes from the key–group pairs of this GroupBy.

Link copied to clipboard
fun <T, C, K, R> Gather<T, C, K, *>.mapValues(transform: (C) -> R): Gather<T, C, K, R>

Applies transform to the values from the columns previously selected by gather.

Link copied to clipboard
internal inline fun <reified T> markerName(): String
Link copied to clipboard
fun <T, C : String?> Split<T, C>.match(regex: String): SplitWithTransform<T, C, String?>
fun <T, C : String?> Split<T, C>.match(regex: Regex): SplitWithTransform<T, C, String?>

Creates new String columns according to MatchResult capturing groups, excluding the first group which is the entire matched String. Example:

Link copied to clipboard
fun <T, R> PivotGroupBy<T>.matches(yes: R, no: R): DataFrame<T>
Link copied to clipboard
fun <T : Comparable<T>> DataColumn<T?>.max(skipNaN: Boolean = skipNaNDefault): T

Returns the maximum of the values in this DataColumn.

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> Grouped<T>.max(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<C & Any>?> 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
fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.max(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.max(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

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

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

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

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

fun <T, R : Comparable<R & Any>?> Pivot<T>.max(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, R>): DataRow<T>
fun <T> Pivot<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

Returns the first element of this DataColumn for which the given selector returns the maximum value.

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>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>

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

Reduces each group of this GroupBy to the first row for which the given rowExpression returns the maximum value.

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

Reduces each group of this GroupBy to the first row that has the largest value in the column with the given name.

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

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

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

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

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

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

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

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

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

Returns the first element of this DataColumn for which the given selector returns the maximum value, or null if there is nothing to compare.

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>?
Link copied to clipboard
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>
fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(vararg columns: KProperty<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(vararg columns: ColumnReference<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<*>?> Pivot<T>.maxFor(vararg columns: KProperty<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, R : Comparable<*>?> Pivot<T>.maxFor(vararg columns: ColumnReference<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

fun <T, R : Comparable<*>?> Pivot<T>.maxFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, R>): DataRow<T>
fun <T> Pivot<T>.maxFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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.

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

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

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

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

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

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

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

Returns the maximum of the values that the given selector returns for each element of this DataColumn, or null if there is nothing to compare.

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.

Link copied to clipboard
fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(skipNaN: Boolean = skipNaNDefault): T?

Returns the maximum of the values in this DataColumn, or null if there is nothing to compare.

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?
Link copied to clipboard
fun DataColumn<Number?>.mean(skipNaN: Boolean = skipNaNDefault): Double

Returns the mean of the values in this DataColumn, as a Double.

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> Grouped<T>.mean(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Number?> 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
fun <T, R : Number?> PivotGroupBy<T>.mean(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Number?> PivotGroupBy<T>.mean(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.mean(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.mean(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

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

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

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

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

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

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

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

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

Link copied to clipboard
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>
fun <T, C : Number?> Grouped<T>.meanFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.meanFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.meanFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.meanFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Pivot<T>.meanFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault, separate: Boolean = false): DataRow<T>
fun <T, C : Number?> Pivot<T>.meanFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault, separate: Boolean = false): DataRow<T>

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

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

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

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

fun <T, C : Number?> Pivot<T>.meanFor(skipNaN: Boolean = skipNaNDefault, separate: Boolean = false, columns: ColumnsForAggregateSelector<T, C>): DataRow<T>
fun <T> Pivot<T>.meanFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault, separate: Boolean = false): DataRow<T>

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

Link copied to clipboard
inline fun <T, reified R : Number?> DataColumn<T>.meanOf(skipNaN: Boolean = skipNaNDefault, crossinline expression: (T) -> R): Double

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

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.

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

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

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

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

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

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

Link copied to clipboard
fun <T : Comparable<T & Any>?> DataColumn<T>.median(): T & Any

Returns the median of the comparable values in this DataColumn.

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

Returns the median of the numbers in this DataColumn, as a Double.

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 : Comparable<C & Any>?> PivotGroupBy<T>.median(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Pivot<T>.median(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<C & Any>?> Pivot<T>.median(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.median(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.median(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

fun <T, C : 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.

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

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

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

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

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

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

fun <T, C : Comparable<C & Any>?> Pivot<T>.median(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataRow<T>
fun <T> Pivot<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

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

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>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

Returns the element of this DataColumn at the median of the values that the given selector returns for each element, or null if there is nothing to compute the median of.

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>?
Link copied to clipboard
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>
fun <T, C : Comparable<*>?> Grouped<T>.medianFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.medianFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Pivot<T>.medianFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<*>?> Pivot<T>.medianFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

fun <T, C : Comparable<*>?> Pivot<T>.medianFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataRow<T>
fun <T> Pivot<T>.medianFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOf(crossinline expression: (T) -> R): R & Any

Returns the median of the comparable values that the given expression returns for each element of this DataColumn.

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?> DataColumn<T>.medianOf(skipNaN: Boolean = skipNaNDefault, crossinline expression: (T) -> R): Double

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

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.

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

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

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

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

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

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

Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOfOrNull(crossinline expression: (T) -> R): R?

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

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?> DataColumn<T>.medianOfOrNull(skipNaN: Boolean = skipNaNDefault, crossinline expression: (T) -> R): Double?

Returns the median of the numbers that the given expression returns for each element of this DataColumn, as a Double, 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.

Link copied to clipboard

Returns the median of the comparable values in this DataColumn, or null if there is nothing to compute the median of.

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

Returns the median of the numbers in this DataColumn, as a Double, or null if there is nothing to compute the median of.

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.

Link copied to clipboard
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>>
Link copied to clipboard
fun <T : Comparable<T>> DataColumn<T?>.min(skipNaN: Boolean = skipNaNDefault): T

Returns the minimum of the values in this DataColumn.

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> Grouped<T>.min(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

fun <T, C : Comparable<C & Any>?> 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
fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: KProperty<R>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: ColumnReference<R>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.min(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.min(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

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

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

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

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

fun <T, R : Comparable<R & Any>?> Pivot<T>.min(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, R>): DataRow<T>
fun <T> Pivot<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

Returns the first element of this DataColumn for which the given selector returns the minimum value.

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>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>

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

Reduces each group of this GroupBy to the first row for which the given rowExpression returns the minimum value.

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

Reduces each group of this GroupBy to the first row that has the smallest value in the column with the given name.

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

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

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

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

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

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

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

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

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

Returns the first element of this DataColumn for which the given selector returns the minimum value, or null if there is nothing to compare.

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>?
Link copied to clipboard
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>
fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(vararg columns: KProperty<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(vararg columns: ColumnReference<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, R : Comparable<*>?> Pivot<T>.minFor(vararg columns: KProperty<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, R : Comparable<*>?> Pivot<T>.minFor(vararg columns: ColumnReference<R>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

fun <T, R : Comparable<*>?> Pivot<T>.minFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, R>): DataRow<T>
fun <T> Pivot<T>.minFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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.

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

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

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

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

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

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

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

Returns the minimum of the values that the given selector returns for each element of this DataColumn, or null if there is nothing to compare.

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.

Link copied to clipboard
fun <T : Comparable<T>> DataColumn<T?>.minOrNull(skipNaN: Boolean = skipNaNDefault): T?

Returns the minimum of the values in this DataColumn, or null if there is nothing to compare.

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?
Link copied to clipboard

Returns a DataColumn where each element is the result of subtracting the corresponding element of column from this BigDecimal.

Returns a DataColumn where each element is the result of subtracting the corresponding element of column from this BigInteger.

operator fun Double.minus(column: DataColumn<Double>): DataColumn<Double>
@JvmName(name = "doubleMinus")
operator fun Double.minus(column: DataColumn<Int>): DataColumn<Double>

Returns a DataColumn where each element is the result of subtracting the corresponding element of column from this Double.

@JvmName(name = "intMinus")
operator fun Int.minus(column: DataColumn<Double>): DataColumn<Double>
@JvmName(name = "minusNullable")
operator fun Int.minus(column: DataColumn<Int?>): DataColumn<Int?>
operator fun Int.minus(column: DataColumn<Int>): DataColumn<Int>

Returns a DataColumn where each element is the result of subtracting the corresponding element of column from this Int.

operator fun Int.minus(column: ColumnReference<Int>): ColumnReference<Int>

Returns a ColumnReference where each element is the result of subtracting the corresponding element of column from this Int.

operator fun Long.minus(column: DataColumn<Long>): DataColumn<Long>

Returns a DataColumn where each element is the result of subtracting the corresponding element of column from this Long.

operator fun DataColumn<Double>.minus(value: Double): DataColumn<Double>
@JvmName(name = "minusDouble")
operator fun DataColumn<Double>.minus(value: Int): DataColumn<Double>
@JvmName(name = "minusIntNullable")
operator fun DataColumn<Int?>.minus(value: Int): DataColumn<Int?>
@JvmName(name = "minusInt")
operator fun DataColumn<Int>.minus(value: Double): DataColumn<Double>
operator fun DataColumn<Int>.minus(value: Int): DataColumn<Int>
operator fun DataColumn<Long>.minus(value: Long): DataColumn<Long>

Returns a DataColumn where each element is the result of subtracting value from the corresponding element of this DataColumn.

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>

Returns a ColumnReference where each element is the result of subtracting value from the corresponding element of this ColumnReference.

Link copied to clipboard
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>
Link copied to clipboard
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.

Link copied to clipboard
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>
Link copied to clipboard
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>
Link copied to clipboard
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>
Link copied to clipboard
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>
Link copied to clipboard
inline fun <T> DataRow<T>.movingAverage(k: Int, expression: RowExpression<T, Number>): Double
Link copied to clipboard
infix fun <T, C : ColumnReference<T>> C.named(name: String): C

Returns a new column reference with the original column values but a new name.

infix fun <T, C : ColumnReference<T>> C.named(name: KProperty<*>): C
infix fun <T, C : ColumnReference<T>> C.named(name: ColumnAccessor<*>): C
Link copied to clipboard
Link copied to clipboard
inline fun <reified R> DataRow<*>.namedValuesOf(): List<NameValuePair<R>>
Link copied to clipboard
infix fun <T> DataColumn<T>.neq(value: T): DataColumn<Boolean>

Returns a DataColumn containing the results of comparing each element of this DataColumn with value for inequality using the != operator.

infix fun <C> ColumnReference<C>.neq(value: C): ColumnReference<Boolean>
Link copied to clipboard
fun <T> DataRow<T>.next(): DataRow<T>?

Returns the next row in the DataFrame relative to the current row. If the current row is the last row in the DataFrame, it returns null.

Link copied to clipboard
fun <T> DataColumn<T>.none(predicate: Predicate<T>): Boolean

Returns true if none of the values match the given predicate.

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

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

Link copied to clipboard
@JvmName(name = "notBooleanNullable")
operator fun DataColumn<Boolean?>.not(): DataColumn<Boolean?>

Returns a DataColumn containing the inverse Boolean values of this DataColumn. Each null value in the original DataColumn is preserved.

Returns a DataColumn containing the inverse Boolean values of this DataColumn.

@JvmName(name = "notBooleanNullable")
operator fun ColumnReference<Boolean?>.not(): ColumnReference<Boolean?>

Returns a ColumnReference containing the inverse Boolean values of this ColumnReference. Each null value in the original ColumnReference is preserved.

Returns a ColumnReference containing the inverse Boolean values of this ColumnReference.

Link copied to clipboard

Filters the format-selection to only include cells where the value is not null.

fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R>

Filters out null values from the columns previously selected by gather, keeping only non-null entries.

fun <T, C, R> Merge<T, C, R>.notNull(): Merge<T, C & Any, R>
@JvmName(name = "notNullList")
fun <T, C, R> Merge<T, C, List<R>>.notNull(): Merge<T, C & Any, List<R & Any>>
inline fun <T, C, reified R> Convert<T, C?>.notNull(crossinline expression: RowValueExpression<T, C, R>): DataFrame<T>

fun <T, C> Update<T, C?>.notNull(): Update<T, C>

Filters the update-selection to only include cells where the value is not null.

Creates a new FormattedFrame that uses the specified CellFormatter to format selected non-null cells of the dataframe.

fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T>

Selects only the rows where the values in the selected columns are not null.

Link copied to clipboard
inline fun <reified T> ColumnAccessor<T>.nullable(): ColumnAccessor<T?>
Link copied to clipboard
@JvmName(name = "parseChar")
fun DataColumn<Char?>.parse(options: ParserOptions? = null): DataColumn<*>

Tries to parse a column of chars as strings into a column of a different type. Each parser in Parsers is run in order until a valid parser is found, a.k.a. that parser was able to parse all values in the column successfully. If a parser fails to parse any value, the next parser is tried.

fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn<*>

Tries to parse a column of strings into a column of a different type. Each parser in Parsers is run in order until a valid parser is found, a.k.a. that parser was able to parse all values in the column successfully. If a parser fails to parse any value, the next parser is tried.

@JvmName(name = "parseAnyFrameNullable")
fun DataColumn<DataFrame<*>?>.parse(options: ParserOptions? = null): DataColumn<DataFrame<*>?>
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>
Link copied to clipboard
inline fun <reified C> ConvertSchemaDsl<*>.parser(noinline parser: (String) -> C)

Defines how to convert String values into the given type C.

Link copied to clipboard
fun pathOf(vararg columnNames: String): ColumnPath
Link copied to clipboard
fun <T : Comparable<T & Any>?> DataColumn<T>.percentile(percentile: Double): T & Any

Returns the given percentile of the comparable values in this DataColumn.

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

Returns the given percentile of the numbers in this DataColumn, as a Double.

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 : Comparable<C & Any>?> PivotGroupBy<T>.percentile(percentile: Double, vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(percentile: Double, vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(percentile: Double, vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

fun <T, C : 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.

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

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

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

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

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

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

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

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

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

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

Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileBy(percentile: Double, skipNaN: Boolean = skipNaNDefault, crossinline selector: (T) -> R): T

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

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>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(percentile: Double, column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(percentile: Double, column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedGroupBy<T, G>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(percentile: Double, column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(percentile: Double, column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(percentile: Double, column: KProperty<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>
inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(percentile: Double, column: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): ReducedPivot<T>

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

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

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

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

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

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

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

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

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

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

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

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

Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileByOrNull(percentile: Double, skipNaN: Boolean = skipNaNDefault, crossinline selector: (T) -> R): T?

Returns the element of this DataColumn at the given percentile of the values that the given selector returns for each element, or null if there is nothing to compute the percentile of.

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>?
Link copied to clipboard
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>
fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(percentile: Double, vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(percentile: Double, vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(percentile: Double, vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(percentile: Double, vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(percentile: Double, vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(percentile: Double, vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

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

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

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

Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOf(percentile: Double, crossinline expression: (T) -> R): R & Any

Returns the given percentile of the comparable values that the given expression returns for each element of this DataColumn.

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?> DataColumn<T>.percentileOf(percentile: Double, skipNaN: Boolean = skipNaNDefault, crossinline expression: (T) -> R): Double

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

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.

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

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

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

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

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

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

Link copied to clipboard
inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOfOrNull(percentile: Double, crossinline expression: (T) -> R): R?

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

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?> DataColumn<T>.percentileOfOrNull(percentile: Double, skipNaN: Boolean = skipNaNDefault, crossinline expression: (T) -> R): Double?

Returns the given percentile of the numbers that the given expression returns for each element of this DataColumn, as a Double, 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.

Link copied to clipboard
fun <T : Comparable<T & Any>?> DataColumn<T>.percentileOrNull(percentile: Double): T?

Returns the given percentile of the comparable values in this DataColumn, or null if there is nothing to compute the percentile of.

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

Returns the given percentile of the numbers in this DataColumn, as a Double, or null if there is nothing to compute the percentile of.

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.

Link copied to clipboard
fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T>
fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T>
fun <T, C> Update<T, C>.perCol(values: DataRow<*>): DataFrame<T>

Per Col can be used for two different types of operations:

Link copied to clipboard

Creates a new FormattedFrame that uses the specified RowColFormatter to format the selected cells of the dataframe.

inline fun <T, C> Update<T, C>.perRowCol(crossinline expression: RowColumnExpression<T, C, C>): DataFrame<T>

Provide a new value for every selected cell given both its row and column using a row-column expression.

inline fun <T, C, reified R> Convert<T, C>.perRowCol(infer: Infer = Infer.Nulls, noinline expression: RowColumnExpression<T, C, R>): DataFrame<T>

Converts values in the columns previously selected with convert using row column expression within the DataFrame.

Link copied to clipboard
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 <G> GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<G>
fun <G> GroupBy<*, G>.pivot(vararg columns: ColumnReference<*>, inward: Boolean = true): PivotGroupBy<G>

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.

fun <G> GroupBy<*, G>.pivot(inward: Boolean = true, columns: PivotColumnsSelector<G, *>): PivotGroupBy<G>
fun <G> GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<G>

Pivots the selected columns of this GroupBy groups. Returns a PivotGroupBy.

Link copied to clipboard
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 <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G>
fun <G> GroupBy<*, G>.pivotCounts(vararg columns: ColumnReference<*>, inward: Boolean = true): DataFrame<G>

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.

fun <G> GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: PivotColumnsSelector<G, *>): DataFrame<G>
fun <G> GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<G>

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

Link copied to clipboard
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 <G> GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G>
fun <G> GroupBy<*, G>.pivotMatches(vararg columns: ColumnReference<*>, inward: Boolean = true): DataFrame<G>

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.

fun <G> GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: PivotColumnsSelector<G, *>): DataFrame<G>
fun <G> GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<G>

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

Link copied to clipboard

Returns a DataColumn where each element is the result of adding the corresponding element of column to this BigDecimal.

Returns a DataColumn where each element is the result of adding the corresponding element of column to this BigInteger.

operator fun Double.plus(column: DataColumn<Double>): DataColumn<Double>
@JvmName(name = "doublePlus")
operator fun Double.plus(column: DataColumn<Int>): DataColumn<Double>

Returns a DataColumn where each element is the result of adding the corresponding element of column to this Double.

@JvmName(name = "intPlus")
operator fun Int.plus(column: DataColumn<Double>): DataColumn<Double>
@JvmName(name = "plusNullable")
operator fun Int.plus(column: DataColumn<Int?>): DataColumn<Int?>
operator fun Int.plus(column: DataColumn<Int>): DataColumn<Int>

Returns a DataColumn where each element is the result of adding the corresponding element of column to this Int.

operator fun Int.plus(column: ColumnReference<Int>): ColumnReference<Int>

Returns a ColumnReference where each element is the result of adding the corresponding element of column to this Int.

operator fun Long.plus(column: DataColumn<Long>): DataColumn<Long>

Returns a DataColumn where each element is the result of adding the corresponding element of column to this Long.

operator fun DataColumn<*>.plus(str: String): DataColumn<String>

Returns a DataColumn of String values obtained by converting each element of this AnyCol to a String and concatenating it with str.

operator fun DataColumn<Double>.plus(value: Double): DataColumn<Double>
@JvmName(name = "plusDouble")
operator fun DataColumn<Double>.plus(value: Int): DataColumn<Double>
@JvmName(name = "plusIntNullable")
operator fun DataColumn<Int?>.plus(value: Int): DataColumn<Int?>
@JvmName(name = "plusInt")
operator fun DataColumn<Int>.plus(value: Double): DataColumn<Double>
operator fun DataColumn<Int>.plus(value: Int): DataColumn<Int>
operator fun DataColumn<Long>.plus(value: Long): DataColumn<Long>

Returns a DataColumn where each element is the result of adding value to the corresponding element of this DataColumn.

Returns a ColumnReference of String values obtained by converting each element of this ColumnReference to a String and concatenating it with str.

operator fun ColumnReference<Int>.plus(value: Int): ColumnReference<Int>

Returns a ColumnReference where each element is the result of adding value to the corresponding element of this ColumnReference.

Link copied to clipboard
inline fun <reified T> CreateDataFrameDsl<*>.preserve()

inline fun <reified T> TraversePropertiesDsl.preserve()

Store values of the given type T in ValueColumns without transformation into ColumnGroups or FrameColumns.

Link copied to clipboard
fun <T> DataRow<T>.prev(): DataRow<T>?

Returns the previous row in the DataFrame relative to the current row. If the current row is the first row in the DataFrame, it returns null.

Link copied to clipboard
fun <T> DataColumn<T>.print()
fun <T> DataRow<T>.print()
fun <T, G> GroupBy<T, G>.print()
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)
Link copied to clipboard

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

Link copied to clipboard
Link copied to clipboard
fun <T> DataRow<T>.relative(relativeIndices: Iterable<Int>): DataFrame<T>
fun <T> DataRow<T>.relative(relativeIndices: IntRange): DataFrame<T>
Link copied to clipboard
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.

Link copied to clipboard
fun <T, C : ColumnReference<T>> C.rename(column: KProperty<T>): C
fun <T, C : ColumnReference<T>> C.rename(column: ColumnAccessor<T>): C
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>

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.

Link copied to clipboard

Renames this column to "camelCase" format. All delimiters between words are removed, words are capitalized except for the first one. Places underscore between numbers. If the string does not contain any letters or numbers, it remains unchanged.

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

Link copied to clipboard
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>
Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard
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>
Link copied to clipboard
fun <T> DataFrame<T>.replaceAll(vararg valuePairs: Pair<Any?, Any?>, columns: ColumnsSelector<T, *> = { colsAtAnyDepth().filter { !it.isColumnGroup() } }): DataFrame<T>
Link copied to clipboard
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.

Link copied to clipboard

Returns a new DataColumn with the same values in reversed order, so the last value becomes the first one.

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

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

Returns a new FrameColumn with the same dataframes in reversed order, so the last dataframe becomes the first one.

Returns a new ValueColumn with the same values in reversed order, so the last value becomes the first one.

Link copied to clipboard
fun <A, B> DataFrame<A>.rightJoin(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>? = null): DataFrame<A>
fun <A, B> DataFrame<A>.rightJoin(other: DataFrame<B>, 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.

Link copied to clipboard
fun <A, B> DataFrame<A>.rightJoinWith(right: DataFrame<B>, 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.

Link copied to clipboard
Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowMaxOf(skipNaN: Boolean = skipNaNDefault): T

Returns the maximum of the values of type T in this DataRow.

Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowMaxOfOrNull(skipNaN: Boolean = skipNaNDefault): T?

Returns the maximum of the values of type T in this DataRow, or null if there is nothing to compare.

Link copied to clipboard
Link copied to clipboard
fun DataRow<*>.rowMean(skipNaN: Boolean = skipNaNDefault): Double

Returns the mean of all the numbers in this DataRow, as a Double.

Link copied to clipboard
inline fun <reified T : Number> DataRow<*>.rowMeanOf(skipNaN: Boolean = skipNaNDefault): Double

Returns the mean of the values of type T in this DataRow, as a Double.

Link copied to clipboard
Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowMedianOf(): T

Returns the median of the comparable values of type T in this DataRow.

inline fun <reified T : Comparable<T>, Number> DataRow<*>.rowMedianOf(skipNaN: Boolean = skipNaNDefault): Double

Returns the median of the numbers of type T in this DataRow, as a Double.

Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowMedianOfOrNull(): T?

Returns the median of the comparable values of type T in this DataRow, or null if there is nothing to compute the median of.

inline fun <reified T : Comparable<T>, Number> DataRow<*>.rowMedianOfOrNull(skipNaN: Boolean = skipNaNDefault): Double?

Returns the median of the numbers of type T in this DataRow, as a Double, or null if there is nothing to compute the median of.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowMinOf(skipNaN: Boolean = skipNaNDefault): T

Returns the minimum of the values of type T in this DataRow.

Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowMinOfOrNull(skipNaN: Boolean = skipNaNDefault): T?

Returns the minimum of the values of type T in this DataRow, or null if there is nothing to compare.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowPercentileOf(percentile: Double): T

Returns the given percentile of the comparable values of type T in this DataRow.

inline fun <reified T : Comparable<T>, Number> DataRow<*>.rowPercentileOf(percentile: Double, skipNaN: Boolean = skipNaNDefault): Double

Returns the given percentile of the numbers of type T in this DataRow, as a Double.

Link copied to clipboard
inline fun <reified T : Comparable<T>> DataRow<*>.rowPercentileOfOrNull(percentile: Double): T?

Returns the given percentile of the comparable values of type T in this DataRow, or null if there is nothing to compute the percentile of.

inline fun <reified T : Comparable<T>, Number> DataRow<*>.rowPercentileOfOrNull(percentile: Double, skipNaN: Boolean = skipNaNDefault): Double?

Returns the given percentile of the numbers of type T in this DataRow, as a Double, or null if there is nothing to compute the percentile of.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun DataRow<*>.rowStd(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): Double

Returns the standard deviation of all the numbers in this DataRow, as a Double.

Link copied to clipboard
inline fun <reified T : Number?> DataRow<*>.rowStdOf(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): Double

Returns the standard deviation of the values of type T in this DataRow, as a Double.

Link copied to clipboard
fun DataRow<*>.rowSum(skipNaN: Boolean = skipNaNDefault): Number

Returns the sum of all the numbers in this DataRow.

Link copied to clipboard
@JvmName(name = "rowSumOfByte")
inline fun <reified T : Byte> DataRow<*>.rowSumOf(_kClass: KClass<Byte> = Byte::class): Int

Returns the sum of the Byte values in this DataRow, as an Int.

@JvmName(name = "rowSumOfInt")
inline fun <reified T : Int> DataRow<*>.rowSumOf(_kClass: KClass<Int> = Int::class): Int

Returns the sum of the Int values in this DataRow.

@JvmName(name = "rowSumOfLong")
inline fun <reified T : Long> DataRow<*>.rowSumOf(_kClass: KClass<Long> = Long::class): Long

Returns the sum of the Long values in this DataRow.

@JvmName(name = "rowSumOfShort")
inline fun <reified T : Short> DataRow<*>.rowSumOf(_kClass: KClass<Short> = Short::class): Int

Returns the sum of the Short values in this DataRow, as an Int.

@JvmName(name = "rowSumOfDouble")
inline fun <reified T : Double> DataRow<*>.rowSumOf(skipNaN: Boolean = skipNaNDefault, _kClass: KClass<Double> = Double::class): Double

Returns the sum of the Double values in this DataRow.

@JvmName(name = "rowSumOfFloat")
inline fun <reified T : Float> DataRow<*>.rowSumOf(skipNaN: Boolean = skipNaNDefault, _kClass: KClass<Float> = Float::class): Float

Returns the sum of the Float values in this DataRow.

fun DataRow<*>.rowSumOf(type: KType, skipNaN: Boolean = skipNaNDefault): Number

Returns the sum of the values of the given type in this DataRow.

Link copied to clipboard

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

Returns the runtime DataFrameSchema of the DataFrame this row is part of.

Returns the runtime DataFrameSchema of this GroupBy seen as a DataFrame: the key columns, followed by a frame column holding the groups.

Link copied to clipboard
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.

Link copied to clipboard
internal fun <C, R> SingleColumn<DataRow<C>>.selectInternal(selector: ColumnsSelector<C, R>): ColumnSet<R>
Link copied to clipboard
Link copied to clipboard

Returns a new DataColumn with values in random order using the default randomness.

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

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

Returns a new DataColumn with the same values in random order using the provided random source.

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

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

Link copied to clipboard

Simplifies structure by removing columns that are already present in column groups in this.

Link copied to clipboard
fun <C> DataColumn<C>.single(): C

Returns the single value in this DataColumn.

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.

Link copied to clipboard
internal fun <C> ColumnsResolver<C>.singleInternal(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C>
Link copied to clipboard

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.

Link copied to clipboard

Sorts the values in this column in ascending order.

Link copied to clipboard

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>
fun <T, G> GroupBy<T, G>.sortBy(vararg cols: KProperty<Comparable<*>?>): GroupBy<T, G>
fun <T, G> GroupBy<T, G>.sortBy(vararg cols: ColumnReference<*>): GroupBy<T, G>

fun <T, G, C> GroupBy<T, G>.sortBy(selector: SortColumnsSelector<G, C>): GroupBy<T, G>

Sorts rows within each group of this GroupBy by the specified columns in ascending (default) or descending order.

fun <T, G> GroupBy<T, G>.sortBy(vararg cols: String): GroupBy<T, G>

Sorts rows within each group of this GroupBy by the specified columns in ascending order.

Link copied to clipboard
fun <T, G> GroupBy<T, G>.sortByCount(): GroupBy<T, G>

Sorts the key-group pairs of this GroupBy by the number of rows in groups descending.

Link copied to clipboard

Sorts the key-group pairs of this GroupBy by the number of rows in groups ascending.

Link copied to clipboard

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>
fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: KProperty<Comparable<*>?>): GroupBy<T, G>
fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: ColumnReference<*>): GroupBy<T, G>

fun <T, G, C> GroupBy<T, G>.sortByDesc(selector: SortColumnsSelector<G, C>): GroupBy<T, G>

Sorts rows within each group of this GroupBy by the specified columns in ascending or descending (default) order.

fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: String): GroupBy<T, G>

Sorts rows within each group of this GroupBy by the specified columns in descending order.

Link copied to clipboard
fun <T, G, C> GroupBy<T, G>.sortByGroup(nullsLast: Boolean = false, expression: DataFrameExpression<G, C>): GroupBy<T, G>

Sorts the key-group pairs of this GroupBy by a value computed for each group using the specified expression ascending.

Link copied to clipboard
fun <T, G, C> GroupBy<T, G>.sortByGroupDesc(nullsLast: Boolean = false, expression: DataFrameExpression<G, C>): GroupBy<T, G>

Sorts the key-group pairs of this GroupBy by a value computed for each group using the specified expression descending.

Link copied to clipboard
fun <T, G> GroupBy<T, G>.sortByKey(nullsLast: Boolean = false): GroupBy<T, G>

Sorts the key-group pairs of this GroupBy by the keys ascending.

Link copied to clipboard
fun <T, G> GroupBy<T, G>.sortByKeyDesc(nullsLast: Boolean = false): GroupBy<T, G>

Sorts the key-group pairs of this GroupBy by the keys descending.

Link copied to clipboard

Sorts the values in this column in descending order.

Link copied to clipboard
fun <T, C : DataColumn<T>> C.sortWith(comparator: Comparator<T>): C
fun <T, C : DataColumn<T>> C.sortWith(comparator: (T, T) -> Int): C

Returns the sorted version of the current ValueColumn, FrameColumn, or ColumnGroup based on the given Comparator. The comparator can either be given as an instance of Comparator, or directly as a lambda.

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.

Link copied to clipboard
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>
Link copied to clipboard
internal inline fun <T, C, R> Convert<T, C?>.splitInplace(type: KType, crossinline transform: DataRow<T>.(C) -> Iterable<R>): DataFrame<T>
Link copied to clipboard
fun DataColumn<Iterable<*>>.splitInto(vararg names: String): DataFrame<*>
Link copied to clipboard
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, C : Number?> PivotGroupBy<T>.std(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.std(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> Pivot<T>.std(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataRow<T>
fun <T, C : Number?> Pivot<T>.std(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataRow<T>
fun <T, C : Number?> Grouped<T>.std(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.std(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

fun DataColumn<Number?>.std(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): Double

Returns the standard deviation of the values in this DataColumn, as a 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> Grouped<T>.std(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>

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

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

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

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

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

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

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

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

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

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

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

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

Link copied to clipboard
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>
fun <T, C : Number?> Grouped<T>.stdFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.stdFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.stdFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.stdFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataFrame<T>
fun <T, C : Number?> Pivot<T>.stdFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataRow<T>
fun <T, C : Number?> Pivot<T>.stdFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault): DataRow<T>

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

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

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

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

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

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

Link copied to clipboard
inline fun <T, reified R : Number?> DataColumn<T>.stdOf(skipNaN: Boolean = skipNaNDefault, ddof: Int = ddofDefault, noinline expression: (T) -> R): Double

Returns the standard deviation of the values that the given expression returns for each element of this DataColumn, as a Double.

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.

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

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

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

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

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

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

Link copied to clipboard
@JvmName(name = "sumByte")
fun DataColumn<Byte?>.sum(): Int

Returns the sum of the Byte values in this DataColumn, as an Int.

@JvmName(name = "sumShort")
fun DataColumn<Short?>.sum(): Int

Returns the sum of the Short values in this DataColumn, as an Int.

@JvmName(name = "sumNumber")
fun <T : Number?> DataColumn<T>.sum(skipNaN: Boolean = skipNaNDefault): T & Any

Returns the sum of the values in this DataColumn.

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
fun <T, C : Number?> PivotGroupBy<T>.sum(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.sum(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Pivot<T>.sum(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Number?> Pivot<T>.sum(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Number?> Grouped<T>.sum(vararg columns: KProperty<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.sum(vararg columns: ColumnReference<C>, name: String? = null, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

fun <T> Grouped<T>.sum(skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

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

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

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

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

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

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

fun <T, C : Number?> Pivot<T>.sum(skipNaN: Boolean = skipNaNDefault, columns: ColumnsSelector<T, C>): DataRow<T>
fun <T> Pivot<T>.sum(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

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

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

Link copied to clipboard
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>
fun <T, C : Number?> Grouped<T>.sumFor(vararg columns: KProperty<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Grouped<T>.sumFor(vararg columns: ColumnReference<C>, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.sumFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> PivotGroupBy<T>.sumFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T>
fun <T, C : Number?> Pivot<T>.sumFor(vararg columns: KProperty<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>
fun <T, C : Number?> Pivot<T>.sumFor(vararg columns: ColumnReference<C>, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

fun <T, C : Number?> Grouped<T>.sumFor(skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, C>): DataFrame<T>
fun <T> Grouped<T>.sumFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T>

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

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

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

fun <T, R : Number?> Pivot<T>.sumFor(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault, columns: ColumnsForAggregateSelector<T, R>): DataRow<T>
fun <T> Pivot<T>.sumFor(vararg columns: String, separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T>

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

Link copied to clipboard
@JvmName(name = "sumOfByte")
inline fun <C, reified V : Byte?> DataColumn<C>.sumOf(crossinline expression: (C) -> V): Int

Returns the sum of the Byte values that the given expression returns for each element of this DataColumn, as an Int.

@JvmName(name = "sumOfShort")
inline fun <C, reified V : Short?> DataColumn<C>.sumOf(crossinline expression: (C) -> V): Int

Returns the sum of the Short values that the given expression returns for each element of this DataColumn, as an Int.

@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 <C, reified V : Number?> DataColumn<C>.sumOf(skipNaN: Boolean = skipNaNDefault, crossinline expression: (C) -> V): V & Any

Returns the sum of the values that the given expression returns for each element of this DataColumn.

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

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

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

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

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

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

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

Link copied to clipboard
fun <T> DataFrame<T>.tail(numRows: Int = 5): DataFrame<T>

Returns a DataFrame containing the last numRows rows.

Link copied to clipboard

Returns a DataColumn containing the first n values of this DataColumn.

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

Returns a DataFrame containing the first n rows.

Link copied to clipboard
fun <T> DataColumn<T>.takeLast(n: Int = 1): DataColumn<T>

Returns a DataColumn containing the last n values of this DataColumn.

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

Returns a DataFrame containing the last n rows.

Link copied to clipboard
inline fun <T> DataFrame<T>.takeWhile(predicate: RowFilter<T>): DataFrame<T>

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

Link copied to clipboard
operator fun DataColumn<Double>.times(value: Double): DataColumn<Double>
@JvmName(name = "timesDouble")
operator fun DataColumn<Double>.times(value: Int): DataColumn<Double>
@JvmName(name = "timesIntNullable")
operator fun DataColumn<Int?>.times(value: Int): DataColumn<Int?>
@JvmName(name = "timesInt")
operator fun DataColumn<Int>.times(value: Double): DataColumn<Double>
operator fun DataColumn<Int>.times(value: Int): DataColumn<Int>
operator fun DataColumn<Long>.times(value: Long): DataColumn<Long>

Returns a DataColumn containing the results of multiplying each element of this DataColumn by value.

Returns a ColumnReference containing the results of multiplying each element of this ColumnReference by value.

Link copied to clipboard
fun <T, C> Convert<T, C>.to(columnConverter: DataFrame<T>.(DataColumn<C>) -> BaseColumn<*>): DataFrame<T>

fun <T, C> MoveClause<T, C>.to(columnIndex: Int): DataFrame<T>

Moves columns, previously selected with move to a new position specified by columnIndex within the DataFrame.

fun <T, C> RenameClause<T, C>.to(transform: (ColumnWithPath<C>) -> String): DataFrame<T>

Renames the columns selected with rename by applying the transform expression to each of them. This expression receives the column together with its full path (as ColumnWithPath) and must return the new name for that column. The operation preserves the original columns’ values and their positions within the DataFrame.

fun <T, C> RenameClause<T, C>.to(vararg newNames: String): DataFrame<T>

Renames the columns selected with rename to the specified newNames, preserving their values and positions within the DataFrame.

fun <T> Convert<T, *>.to(type: KType, parserOptions: ParserOptions? = null): DataFrame<T>

Converts the values in the columns previously selected with convert to the specified type, preserving their original names and positions within the DataFrame.

fun <T, C> MoveClause<T, C>.to(columnIndex: Int, insideGroup: Boolean): DataFrame<T>

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

Link copied to clipboard

Converts values in the columns previously selected with convert to BigDecimal, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the columns previously selected with convert to BigInteger, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the columns previously selected with convert to Boolean, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
Link copied to clipboard

Renames the columns, previously selected with rename to "camelCase" format.

Link copied to clipboard
Link copied to clipboard
inline fun <reified T> Iterable<T>.toColumn(property: KProperty<T>): DataColumn<T>
inline fun <reified T> Iterable<T>.toColumn(ref: ColumnReference<T>): DataColumn<T>
inline fun <reified T> Iterable<T>.toColumn(name: String = "", infer: Infer = Infer.Nulls): DataColumn<T>
Link copied to clipboard
Link copied to clipboard
inline fun <reified T> Iterable<*>.toColumnOf(name: String = ""): DataColumn<T>
Link copied to clipboard
inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T>
@JvmName(name = "toDataFrameMapStringAnyNullable")
fun Iterable<Map<String, Any?>>.toDataFrame(): DataFrame<*>
@JvmName(name = "toDataFrameT")
fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T>
@JvmName(name = "toDataFrameAnyColumn")
fun Iterable<BaseColumn<*>>.toDataFrame(): DataFrame<*>
@JvmName(name = "toDataFrameColumnPathAnyNullable")
fun Map<ColumnPath, Iterable<Any?>>.toDataFrame(): DataFrame<*>
internal fun <T, C> Split<T, C>.toDataFrame(): DataFrame<T>
inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T>
inline fun <reified T> Iterable<T>.toDataFrame(columnName: String): DataFrame<*>
inline fun <reified T> Iterable<T>.toDataFrame(vararg props: KProperty<*>, maxDepth: Int = 0): DataFrame<T>

fun <T> List<List<T>>.toDataFrame(header: List<String>?, containsColumns: Boolean = false): DataFrame<*>

Converts a list of lists into a DataFrame.

Link copied to clipboard
@JvmName(name = "toDataFrameColumnPathAnyNullable")
fun Iterable<Pair<ColumnPath, Iterable<Any?>>>.toDataFrameFromPairs(): DataFrame<*>
@JvmName(name = "toDataFramePairColumnPathAnyCol")
fun <T> Iterable<Pair<ColumnPath, BaseColumn<*>>>.toDataFrameFromPairs(): DataFrame<T>
Link copied to clipboard
fun <T> DataColumn<List<List<T>>>.toDataFrames(containsColumns: Boolean = false): DataColumn<DataFrame<*>>

Converts a list of lists values in this DataColumn to DataFrame.

fun <T, C> Convert<T, List<List<C>>>.toDataFrames(containsColumns: Boolean = false): DataFrame<T>

Converts a list of lists values in the columns previously selected with convert to DataFrame, preserving their original names and positions within the DataFrame.

Link copied to clipboard
Link copied to clipboard

Converts values in the columns previously selected with convert to DateTimeComponents, preserving their original names and positions within the DataFrame.

@FormatStringsInDatetimeFormats
fun <T> Convert<T, String?>.toDateTimeComponents(pattern: String): DataFrame<T>
fun <T> Convert<T, String?>.toDateTimeComponents(format: DateTimeFormat<DateTimeComponents>? = null): DataFrame<T>

Converts values in the String columns previously selected with convert to DateTimeComponents, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the String columns previously selected with convert to kotlinx.datetime.Instant, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the columns previously selected with convert to Double, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
Link copied to clipboard

Converts values in the columns previously selected with convert to Duration, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
fun <T, C> MoveClause<T, C>.toEnd(): DataFrame<T>

Moves columns, previously selected with move to the DataFrame end.

fun <T, C> MoveClause<T, C>.toEnd(insideGroup: Boolean): DataFrame<T>

If insideGroup is true, moves columns previously selected with move to the end of their ColumnGroup. Else, selected columns will be moved to the end of their DataFrame (to the top-level).

Link copied to clipboard

Converts values in the columns previously selected with convert to Float, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T> Convert<T, URL?>.toIFrame(border: Boolean = false, width: Int? = null, height: Int? = null): DataFrame<T>

Converts values in the URL columns previously selected with convert to IFRAME, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
fun <T> Convert<T, URL?>.toImg(width: Int? = null, height: Int? = null): DataFrame<T>

Converts values in the URL columns previously selected with convert to IMG, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Deprecated:

Link copied to clipboard
fun <T> Convert<T, Any?>.toInt(): DataFrame<T>

Converts values in the columns previously selected with convert to Int, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
Link copied to clipboard

Converts values in the columns previously selected with convert to JavaDuration, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the columns previously selected with convert to JavaInstant, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the columns previously selected with convert to JavaLocalDate, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toJavaLocalDateFromStringNullable")
fun <T> Convert<T, String?>.toJavaLocalDate(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataFrame<T>
@JvmName(name = "toJavaLocalDateFromStringNullablePattern")
fun <T> Convert<T, String?>.toJavaLocalDate(pattern: String, locale: Locale? = null): DataFrame<T>

Converts values in the nullable String columns previously selected with convert to JavaLocalDate, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toJavaLocalDateFromString")
fun <T> Convert<T, String>.toJavaLocalDate(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataFrame<T>
@JvmName(name = "toJavaLocalDateFromStringPattern")
fun <T> Convert<T, String>.toJavaLocalDate(pattern: String, locale: Locale? = null): DataFrame<T>

Converts values in the String columns previously selected with convert to JavaLocalDate, preserving their original names and positions within the DataFrame.

Link copied to clipboard

Converts values in the columns previously selected with convert to JavaLocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

fun <T> Convert<T, String?>.toJavaLocalDateTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataFrame<T>
fun <T> Convert<T, String?>.toJavaLocalDateTime(pattern: String, locale: Locale? = null): DataFrame<T>

Converts values in the nullable String columns previously selected with convert to JavaLocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts values in the columns previously selected with convert to JavaLocalTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toJavaLocalTimeFromStringNullable")
fun <T> Convert<T, String?>.toJavaLocalTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataFrame<T>
@JvmName(name = "toJavaLocalTimeFromStringNullablePattern")
fun <T> Convert<T, String?>.toJavaLocalTime(pattern: String, locale: Locale? = null): DataFrame<T>

Converts values in the nullable String columns previously selected with convert to JavaLocalTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toJavaLocalTimeFromString")
fun <T> Convert<T, String>.toJavaLocalTime(formatter: DateTimeFormatter? = null, locale: Locale? = null): DataFrame<T>
@JvmName(name = "toJavaLocalTimeFromStringPattern")
fun <T> Convert<T, String>.toJavaLocalTime(pattern: String, locale: Locale? = null): DataFrame<T>

Converts values in the String columns previously selected with convert to JavaLocalTime, preserving their original names and positions within the DataFrame.

Link copied to clipboard
fun <T, C> MoveClause<T, C>.toLeft(): DataFrame<T>
Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard

Converts values in the columns previously selected with convert to LocalDate, preserving their original names and positions within the DataFrame.

@JvmName(name = "toLocalDateFromDateTimeComponents")
fun <T> Convert<T, DateTimeComponents?>.toLocalDate(): DataFrame<T>

Converts values in the DateTimeComponents columns previously selected with convert to LocalDate, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalDateFromTInt")
fun <T> Convert<T, Int?>.toLocalDate(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the Int columns previously selected with convert to LocalDate, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalDateFromTLong")
fun <T> Convert<T, Long?>.toLocalDate(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the Long columns previously selected with convert to LocalDate, preserving their original names and positions within the DataFrame. Preserves null values.

@FormatStringsInDatetimeFormats
fun <T> Convert<T, String?>.toLocalDate(pattern: String): DataFrame<T>
fun <T> Convert<T, String?>.toLocalDate(format: DateTimeFormat<LocalDate>? = null): DataFrame<T>

Converts values in the String columns previously selected with convert to LocalDate, preserving their original names and positions within the DataFrame. Preserves null values.

fun <T> Convert<T, String?>.toLocalDate(pattern: String? = null, locale: Locale?): DataFrame<T>
Link copied to clipboard

Converts values in the columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame.

@JvmName(name = "toLocalDateTimeFromDateTimeComponents")
fun <T> Convert<T, DateTimeComponents?>.toLocalDateTime(): DataFrame<T>

Converts values in the DateTimeComponents columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalDateTimeFromTInt")
fun <T> Convert<T, Int?>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the Int columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalDateTimeFromTLong")
fun <T> Convert<T, Long?>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the Long columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

@FormatStringsInDatetimeFormats
fun <T> Convert<T, String?>.toLocalDateTime(pattern: String): DataFrame<T>
fun <T> Convert<T, String?>.toLocalDateTime(format: DateTimeFormat<LocalDateTime>? = null): DataFrame<T>

Converts values in the String columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalDateTimeFromTStdlibInstant")
fun <T> Convert<T, Instant?>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the kotlin.time.Instant columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalDateTimeFromTDeprecatedInstant")
fun <T> Convert<T, Instant?>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the kotlinx.datetime.Instant columns previously selected with convert to LocalDateTime, preserving their original names and positions within the DataFrame. Preserves null values.

fun <T> Convert<T, String?>.toLocalDateTime(pattern: String? = null, locale: Locale?): DataFrame<T>
Link copied to clipboard

Converts values in the columns previously selected with convert to LocalTime, preserving their original names and positions within the DataFrame.

@JvmName(name = "toLocalTimeFromDateTimeComponents")
fun <T> Convert<T, DateTimeComponents?>.toLocalTime(): DataFrame<T>

Converts values in the DateTimeComponents columns previously selected with convert to LocalTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalTimeFromTInt")
fun <T> Convert<T, Int?>.toLocalTime(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the Int columns previously selected with convert to LocalTime, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toLocalTimeFromTLong")
fun <T> Convert<T, Long?>.toLocalTime(zone: TimeZone = defaultTimeZone): DataFrame<T>

Converts values in the Long columns previously selected with convert to LocalTime, preserving their original names and positions within the DataFrame. Preserves null values.

@FormatStringsInDatetimeFormats
fun <T> Convert<T, String?>.toLocalTime(pattern: String): DataFrame<T>
fun <T> Convert<T, String?>.toLocalTime(format: DateTimeFormat<LocalTime>? = null): DataFrame<T>

Converts values in the String columns previously selected with convert to LocalTime, preserving their original names and positions within the DataFrame. Preserves null values.

fun <T> Convert<T, String?>.toLocalTime(pattern: String? = null, locale: Locale?): DataFrame<T>
Link copied to clipboard
fun <T> Convert<T, Any?>.toLong(): DataFrame<T>

Converts values in the columns previously selected with convert to Long, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
Link copied to clipboard
fun DataRow<*>.toMap(): Map<String, Any?>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
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.

Link copied to clipboard
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.

Link copied to clipboard
Link copied to clipboard

Moves columns, previously selected with move to the DataFrame start (on top-level).

fun <T, C> MoveClause<T, C>.toStart(insideGroup: Boolean): DataFrame<T>

If insideGroup is true, moves columns previously selected with move to the start of their ColumnGroup. Else, selected columns will be moved to the start of their DataFrame (to the top-level).

Link copied to clipboard
@JvmName(name = "toStdlibInstantFromString")
fun <T> Convert<T, String?>.toStdlibInstant(): DataFrame<T>

Converts values in the String columns previously selected with convert to kotlin.time.Instant, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toStdlibInstantFromDeprecatedInstant")
fun <T> Convert<T, Instant?>.toStdlibInstant(): DataFrame<T>

Converts values in the kotlinx.datetime.Instant columns previously selected with convert to kotlin.time.Instant, preserving their original names and positions within the DataFrame. Preserves null values.

@JvmName(name = "toStdlibInstantFromDateTimeComponents")
fun <T> Convert<T, DateTimeComponents?>.toStdlibInstant(): DataFrame<T>

Converts values in the DateTimeComponents columns previously selected with convert to kotlin.time.Instant, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
fun <T> Convert<T, Any?>.toStr(): DataFrame<T>

Converts values in the columns previously selected with convert to String, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
fun <T, C> MoveClause<T, C>.toTop(newColumnName: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String = { it.name() }): DataFrame<T>

Moves columns, previously selected with move to the top-level within the DataFrame. Moved columns name can be specified via special ColumnSelectionDsl.

Link copied to clipboard
inline fun <reified T> DataColumn<T>.toTypedArray(): Array<T>
Link copied to clipboard

Converts values in the String columns previously selected with convert to an URL, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
fun <T> Convert<T, DateTimeComponents?>.toUtcOffset(): DataFrame<T>

Converts values in the DateTimeComponents columns previously selected with convert to UtcOffset, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard
inline fun <reified T> Array<T>.toValueColumn(name: String): ValueColumn<T>
inline fun <reified T> Iterable<T>.toValueColumn(name: String = ""): ValueColumn<T>
inline fun <reified T> Iterable<T>.toValueColumn(column: KProperty<T>): ValueColumn<T>
inline fun <reified T> Iterable<T>.toValueColumn(column: ColumnAccessor<T>): ValueColumn<T>
Link copied to clipboard
fun <T> Convert<T, DateTimeComponents?>.toYearMonth(): DataFrame<T>

Converts values in the DateTimeComponents columns previously selected with convert to YearMonth, preserving their original names and positions within the DataFrame. Preserves null values.

Link copied to clipboard

Converts this DataRow into a DataFrame with one row per column of the original row.

Link copied to clipboard
inline fun <reified T> DataRow<*>.transposeTo(): DataFrame<NameValuePair<T>>

Converts this DataRow into a DataFrame with one row per column of the original row.

Implementation of the public transposeTo that takes the target type explicitly instead of as a reified type parameter.

Link copied to clipboard
@JvmName(name = "tryParseChar")
fun DataColumn<Char?>.tryParse(options: ParserOptions? = null): DataColumn<*>

Tries to parse a column of chars into a column of a different type. Each parser in Parsers is run in order until a valid parser is found, a.k.a. that parser was able to parse all values in the column successfully. If a parser fails to parse any value, the next parser is tried. If all the others fail, the final parser returns strings.

fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataColumn<*>

Tries to parse a column of strings into a column of a different type. Each parser in Parsers is run in order until a valid parser is found, a.k.a. that parser was able to parse all values in the column successfully. If a parser fails to parse any value, the next parser is tried. If all the others fail, the final parser simply returns the original string, leaving the column unchanged.

Link copied to clipboard
@JvmName(name = "unaryMinusBigDecimal")
operator fun DataColumn<BigDecimal>.unaryMinus(): DataColumn<BigDecimal>
@JvmName(name = "unaryMinusBigInteger")
operator fun DataColumn<BigInteger>.unaryMinus(): DataColumn<BigInteger>
@JvmName(name = "unaryMinusDouble")
operator fun DataColumn<Double>.unaryMinus(): DataColumn<Double>
@JvmName(name = "unaryMinusIntNullable")
operator fun DataColumn<Int?>.unaryMinus(): DataColumn<Int?>
@JvmName(name = "unaryMinusLong")
operator fun DataColumn<Long>.unaryMinus(): DataColumn<Long>

Returns a DataColumn containing negatives of the corresponding elements of this DataColumn.

Returns a ColumnReference containing negatives of the corresponding elements of this ColumnReference.

Link copied to clipboard

Inserts the new column previously specified with insert under the selected column group.

fun <T> InsertClause<T>.under(column: String): DataFrame<T>

Inserts the new column previously specified with insert under the given column group by its name.

fun <T> InsertClause<T>.under(column: KProperty<*>): DataFrame<T>

fun <T> InsertClause<T>.under(columnPath: ColumnPath): DataFrame<T>

DEPRECATED:

Moves columns, previously selected with move under a new or an existing column group specified by a column path within the DataFrame.

fun <T, C> MoveClause<T, C>.under(column: String): DataFrame<T>

Moves columns, previously selected with move under a new or an existing column group within the DataFrame. If the column group doesn't exist, it will be created.

Link copied to clipboard
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>

inline fun <reified T> DataColumn<T>.unfold(vararg roots: KCallable<*>, maxDepth: Int = 0): DataColumn<*>

Returns a ColumnGroup made from the objects of this column, with a column for every public property of these objects, or this column itself when it cannot be unfolded.

Link copied to clipboard
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>
Link copied to clipboard
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).

Link copied to clipboard
@JvmName(name = "valueColumnTyped")
fun <T> valueColumn(): ColumnDelegate<T>
@JvmName(name = "valueColumnTyped")
fun <T> valueColumn(name: String): ColumnAccessor<T>
fun <T> valueColumn(property: KProperty<T>): ColumnAccessor<T>
@JvmName(name = "valueColumnTyped")
fun <T> valueColumn(path: ColumnPath): ColumnAccessor<T>
Link copied to clipboard
internal inline fun ColumnsResolver<*>.valueColumnsInternal(crossinline filter: (ValueColumn<*>) -> Boolean): TransformableColumnSet<*>

Returns a TransformableColumnSet containing the value columns that satisfy the given filter.

Link copied to clipboard
fun <T> DataColumn<T>.valueCounts(sort: Boolean = true, ascending: Boolean = false, dropNA: Boolean = true, resultColumn: String = defaultCountColumnName): DataFrame<ValueCount>

Returns a DataFrame containing counts of unique values in this DataColumn.

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>
Link copied to clipboard
fun <T> DataFrame<T>.values(byRows: Boolean = false): Sequence<Any?>
fun <T, G> ReducedGroupBy<T, G>.values(vararg columns: String): DataFrame<G>
fun <T, G> ReducedGroupBy<T, G>.values(vararg columns: KProperty<*>): DataFrame<G>
fun <T, G> ReducedGroupBy<T, G>.values(vararg columns: ColumnReference<*>): DataFrame<G>
fun <T> ReducedPivotGroupBy<T>.values(separate: Boolean = false): DataFrame<T>
fun <T> ReducedPivot<T>.values(separate: Boolean = false): DataRow<T>
fun <T, C> DataFrame<T>.values(byRow: Boolean = false, columns: ColumnsSelector<T, C>): Sequence<C>
fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T>
fun <T> ReducedPivotGroupBy<T>.values(separate: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataFrame<T>
fun <T> ReducedPivotGroupBy<T>.values(vararg columns: String, separate: Boolean = false): DataFrame<T>
fun <T> ReducedPivotGroupBy<T>.values(vararg columns: KProperty<*>, separate: Boolean = false): DataFrame<T>
fun <T> ReducedPivotGroupBy<T>.values(vararg columns: ColumnReference<*>, separate: Boolean = false): DataFrame<T>
fun <T> ReducedPivot<T>.values(separate: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataRow<T>
fun <T> ReducedPivot<T>.values(vararg columns: String, separate: Boolean = false): DataRow<T>
fun <T> ReducedPivot<T>.values(vararg columns: KProperty<*>, separate: Boolean = false): DataRow<T>
fun <T> ReducedPivot<T>.values(vararg columns: ColumnReference<*>, separate: Boolean = false): DataRow<T>
fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataFrame<T>
fun <T> Grouped<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T>
fun <T> Grouped<T>.values(vararg columns: ColumnReference<*>, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T>
fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>
fun <T> Pivot<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataRow<T>
fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataFrame<T>
fun <T> PivotGroupBy<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>
fun <T> PivotGroupBy<T>.values(vararg columns: KProperty<*>, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>
fun <T> PivotGroupBy<T>.values(vararg columns: ColumnReference<*>, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T>
fun <T> Pivot<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false, columns: ColumnsForAggregateSelector<T, *>): DataRow<T>
fun <T> Pivot<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataRow<T>
fun <T> Pivot<T>.values(vararg columns: KProperty<*>, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataRow<T>
fun <T> Pivot<T>.values(vararg columns: ColumnReference<*>, dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataRow<T>
Link copied to clipboard

Returns true if this column is intra-comparable (mutually comparable), i.e., its values can be compared with each other and thus ordered.

Link copied to clipboard
fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(valueColumn: String): DataFrame<T>

Reshapes the columns previously selected by gather into a new valueColumn, containing the original column values. The key column is omitted.

fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(valueColumn: KProperty<K>): DataFrame<T>
fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(valueColumn: ColumnAccessor<K>): DataFrame<T>
Link copied to clipboard
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>
Link copied to clipboard
inline fun <reified R> DataRow<*>.valuesOf(): List<R>
Link copied to clipboard
fun <T, C> FormatClause<T, C>.where(filter: RowValueFilter<T, C>): FormatClause<T, C>

Filters the rows to format using a RowValueFilter.

fun <T, C, K, R> Gather<T, C, K, R>.where(filter: RowValueFilter<T, C>): Gather<T, C, K, R>

Filter values in columns previously selected by gather using a filter.

fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C>

Filter or find rows to operate on after selecting columns using a row value filter.

Link copied to clipboard
fun <T, C> ConvertToFill<T, C>.with(expr: RowExpression<T, C>)
fun <T, C, R> Corr<T, C>.with(vararg otherColumns: KProperty<R>): DataFrame<T>
fun <T, C, R> Corr<T, C>.with(vararg otherColumns: ColumnReference<R>): DataFrame<T>
fun <T, C> ReplaceClause<T, C>.with(newColumns: List<DataColumn<*>>): DataFrame<T>
fun <T, C> ReplaceClause<T, C>.with(vararg columns: DataColumn<*>): DataFrame<T>

inline fun <C, reified R> ConvertType<C>.with(noinline converter: (C) -> R)

Defines how to convert values of type C into type R

fun <T, C, R> Corr<T, C>.with(otherColumns: ColumnsSelector<T, R>): DataFrame<T>
fun <T, C> Corr<T, C>.with(vararg otherColumns: String): DataFrame<T>

Calculates the correlation of specified columns with values in the columns previously selected with corr.

fun <T, C> FormatClause<T, C>.with(formatter: CellFormatter<C>): FormattedFrame<T>

Creates a new FormattedFrame that uses the specified CellFormatter to format the selected cells of the dataframe.

Experimental API. It may be changed in the future.

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

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

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

Aggregates this Pivot by evaluating the given row expression on every row of each pivot group.

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

Aggregates this ReducedPivotGroupBy by evaluating the given row expression on the single row selected by the reducer in each group defined by the grouping and pivot keys.

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

Aggregates this ReducedPivot by evaluating the given row expression on the single row selected by the reducer in each pivot group.

For an alternative supported in the compiler plugin use Convert.asColumn

inline fun <T, C, R : C?> Update<T, C>.with(crossinline expression: UpdateExpression<T, C, R>): DataFrame<T>

Provide a new value for every selected cell given its row and its previous value using a row value expression.

inline fun <T, C, reified R> Convert<T, C>.with(infer: Infer = Infer.Nulls, noinline rowConverter: RowValueExpression<T, C, R>): DataFrame<T>

Converts values in columns previously selected by convert using the specified rowConverter, a row value expression applied to each row in the DataFrame.

Link copied to clipboard
fun <T, C> Corr<T, C>.withItself(): DataFrame<T>

Calculates Pearson pairwise correlations between the columns previously selected with corr.

Link copied to clipboard
fun <T, C> Update<T, C>.withNull(): DataFrame<T>

Specific version of with that simply sets the value of each selected row to null.

Link copied to clipboard
inline fun <reified T> ColumnReference<T>.withValues(values: Iterable<T>): ValueColumn<T>
inline fun <reified T> ColumnReference<T>.withValues(vararg values: T): ValueColumn<T>
Link copied to clipboard
fun <T, C> Update<T, C>.withZero(): DataFrame<T>

Specific version of with that simply sets the value of each selected row to 0.

Link copied to clipboard
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, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G>

Returns a cross-section of this GroupBy: only the key–group pairs 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.

fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G>

Returns a cross-section of this GroupBy: only the key–group pairs in which the key columns hold the given keyValues, without those key columns.