Creates a new data frame that contains all data from the original data frame, together with an additional series. The operation uses left join and aligns new series to the existing frame keys. ## Parameters - `column` - A key (or name) for the newly added column - `series` - A data series to be added (the row key type has to match) - `frame` - Source data frame (which is not mutated by the operation) [category:Accessing frame data and lookup]

Returns a data frame whose rows are grouped by `groupBy` and whose columns specified in `aggBy` are aggregated according to `aggFunc`. ## Parameters - `groupBy` - sequence of columns to group by - `aggBy` - sequence of columns to apply aggFunc to - `aggFunc` - invoked in order to aggregate values [category:Grouping, windowing and chunking]

Apply a specified function to a group of values in each series according to the specified level of a hierarchical row key. For each group of rows as specified by `levelSel`, the function applies the specified function `op` to all columns. Columns that cannot be converted to a type required by `op` are skipped. ## Example To get the standard deviation of values in all numerical columns according to the first component of a two level row key `'K1 * 'K2`, you can use the following: df |> Frame.applyLevel fst Stats.stdDev ## Remarks This function reduces a series of values using a function `Series<'R, 'T> -> 'T`. If you want to reduce values using a simpler function `'T -> 'T -> 'T`, you can use `Frame.reduceLevel` instead. [category:Hierarchical index operations]

Returns the columns of the data frame as a series (indexed by the column keys of the source frame) containing untyped series representing individual columns of the frame. [category:Accessing frame data and lookup]

Returns the total number of column keys in the specified frame. This returns the total length of columns, including keys for which there is no data available. [category:Accessing frame data and lookup]

Returns the total number of row keys in the specified frame. This returns the total length of the row series, including keys for which there is no value available. [category:Accessing frame data and lookup]

Returns a series with the total number of values in each column. This counts the number of actual values, excluding the missing values or not available values (such as `nan`, `null`, etc.) [category:Accessing frame data and lookup]

Returns the columns of the data frame that do not have any missing values. The operation returns a series (indexed by the column keys of the source frame) containing _series_ representing individual columns of the frame. This is similar to `Columns`, but it skips columns that contain missing value in _any_ row. [category:Missing values]

Returns the rows of the data frame that do not have any missing values. The operation returns a series (indexed by the row keys of the source frame) containing _series_ representing individual row of the frame. This is similar to `Rows`, but it skips rows that contain missing value in _any_ column. [category:Missing values]

Returns a frame with columns containing difference between an original value and a value at the specified offset. For example, calling `Frame.diff 1 s` returns a frame where previous column values is subtracted from the current ones. In pseudo-code, the function behaves as follows: result[k] = series[k] - series[k - offset] Columns that cannot be converted to `float` are left without a change. ## Parameters - `offset` - When positive, subtracts the past values from the current values; when negative, subtracts the future values from the current values. - `frame` - The input frame containing at least some `float` columns. [category:Frame transformations]

Creates a new data frame that contains all data from the original data frame without the specified series (column). The operation throws if the column key is not found. ## Parameters - `column` - The key (or name) to be dropped from the frame - `frame` - Source data frame (which is not mutated by the operation) [category:Accessing frame data and lookup]

Creates a new data frame that contains only those columns of the original data frame that are _dense_, meaning that they have a value for each row. The resulting data frame has the same number of rows, but may have fewer columns (or no columns at all). [category:Missing values]

Creates a new data frame that contains only those rows of the original data frame that are _dense_, meaning that they have a value for each column. The resulting data frame has the same number of columns, but may have fewer rows (or no rows at all). [category:Missing values]

Creates a new data frame where all columns are expanded based on runtime structure of the objects they store. The expansion is performed recrusively to the specified depth. A column can be expanded if it is `Series<string, T>` or `IDictionary<K, V>` or if it is any .NET object with readable properties. ## Parameters - `nesting` - The nesting level for expansion. When set to 0, nothing is done. - `frame` - Input data frame whose columns will be expanded [category:Sorting and index manipulation]

Creates a new data frame where the specified columns are expanded based on runtime structure of the objects they store. A column can be expanded if it is `Series<string, T>` or `IDictionary<K, V>` or if it is any .NET object with readable properties. ## Example Given a data frame with a series that contains tuples, you can expand the tuple members and get a frame with columns `S.Item1` and `S.Item2`: let df = frame [ "S" => series [ 1 => (1, "One"); 2 => (2, "Two") ] ] df |> Frame.expandCols ["S"] ## Parameters - `names` - Names of columns in the original data frame to be expanded - `frame` - Input data frame whose columns will be expanded [category:Sorting and index manipulation]

Fills all error cases of a `tryval<'T>` value in a data frame with the specified `value`. The function takes all columns of type `tryval<'T>` and uses `Series.fillErrorsWith` to fill the error values with the specified default value. [category:Processing frames with exceptions]

Fill missing values in the data frame with the nearest available value (using the specified direction). Note that the frame may still contain missing values after call to this function (e.g. if the first value is not available and we attempt to fill series with previous values). This operation can only be used on ordered frames. ## Parameters - `frame` - An input data frame that is to be filled - `direction` - Specifies the direction used when searching for the nearest available value. `Backward` means that we want to look for the first value with a smaller key while `Forward` searches for the nearest greater key. [category:Missing values]

Fill missing values in the frame using the specified function. The specified function is called with all series and keys for which the frame does not contain value and the result of the call is used in place of the missing value. The operation is only applied to columns (series) that contain values of the same type as the return type of the provided filling function. The operation does not attempt to convert between numeric values (so a series containing `float` will not be converted to a series of `int`). ## Parameters - `frame` - An input data frame that is to be filled - `f` - A function that takes a series `Series<R, T>` together with a key `K` in the series and generates a value to be used in a place where the original series contains a missing value. [category:Missing values]

Fill missing values of a given type in the frame with a constant value. The operation is only applied to columns (series) that contain values of the same type as the provided filling value. The operation does not attempt to convert between numeric values (so a series containing `float` will not be converted to a series of `int`). ## Parameters - `frame` - An input data frame that is to be filled - `value` - A constant value that is used to fill all missing values [category:Missing values]

Returns a specified column from a data frame. This function uses exact matching semantics on the key. Use `lookupCol` if you want to use inexact matching (e.g. on dates) [category:Accessing frame data and lookup]

Returns a series of columns of the data frame indexed by the column keys, which contains those series whose values are convertible to `'T`, and with missing values where the conversion fails. If you want to get numeric columns, you can use a simpler `numericCols` function instead. Note that this function typically requires a type annotation. This can be specified in various ways, for example by annotating the result value: let (res:Series<_, Series<_, string>>) = frame |> getCols Here, the annotation on the values of the nested series specifies that we want to get columns containing `string` values. [category:Accessing frame data and lookup]

Returns a series of columns of the data frame indexed by the column keys, which contains those series whose values are convertible to float, and with missing values where the conversion fails. [category:Accessing frame data and lookup]

Returns a specified row from a data frame. This function uses exact matching semantics on the key. Use `lookupRow` if you want to use inexact matching (e.g. on dates) [category:Accessing frame data and lookup]

Returns a series of rows of the data frame indexed by the row keys, which contains those rows whose values are convertible to 'T, and with missing values where the conversion fails. [category:Accessing frame data and lookup]

Group rows of a data frame using the specified `column`. The type of the column is inferred from the usage of the resulting frame. The result is a frame with multi-level index, where the first level is formed by the newly created keys. Use `groupRowsBy[Int|String|...]` to explicitly specify the type of the column. [category:Grouping, windowing and chunking]

Groups the rows of a frame by a specified column in the same way as `groupRowsBy`. This function assumes that the values of the specified column are of type `bool`. [category:Grouping, windowing and chunking]

Group rows of a data frame using the specified `keySelector`. The selector is called with a key of each row and should return a new key. The result is a frame with multi-level index, here the first level is formed by the newly created keys. [category:Grouping, windowing and chunking]

Groups the rows of a frame by a specified column in the same way as `groupRowsBy`. This function assumes that the values of the specified column are of type `int`. [category:Grouping, windowing and chunking]

Groups the rows of a frame by a specified column in the same way as `groupRowsBy`. This function assumes that the values of the specified column are of type `obj`. [category:Grouping, windowing and chunking]

Groups the rows of a frame by a specified column in the same way as `groupRowsBy`. This function assumes that the values of the specified column are of type `string`. [category:Grouping, windowing and chunking]

Group rows of a data frame using the specified `selector`. The selector is called with a row key and object series representing the row and should return a new key. The result is a frame with multi-level index, where the first level is formed by the newly created keys. [category:Grouping, windowing and chunking]

Replace the column index of the frame with the provided sequence of column keys. The columns of the frame are assigned keys according to the provided order. The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose column index are to be replaced. - `keys` - A collection of new column keys. [category:Sorting and index manipulation]

Returns a data frame whose rows are indexed based on the specified column of the original data frame. The generic type parameter is specifies the type of the values in the required index column (and usually needs to be specified using a type annotation). The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose row index is to be replaced. - `column` - The name of a column in the original data frame that will be used for the new index. Note that the values in the column need to be unique. [category:Sorting and index manipulation]

Returns a data frame whose rows are indexed based on the specified column of the original data frame. This function casts (or converts) the column key to values of type `DateTime` (a generic variant that may require some type annotation is `Frame.indexRows`) The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose row index is to be replaced. - `column` - The name of a column in the original data frame that will be used for the new index. Note that the values in the column need to be unique. [category:Sorting and index manipulation]

Returns a data frame whose rows are indexed based on the specified column of the original data frame. This function casts (or converts) the column key to values of type `DateTimeOffset` (a generic variant that may require some type annotation is `Frame.indexRows`) The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose row index is to be replaced. - `column` - The name of a column in the original data frame that will be used for the new index. Note that the values in the column need to be unique. [category:Sorting and index manipulation]

Returns a data frame whose rows are indexed based on the specified column of the original data frame. This function casts (or converts) the column key to values of type `int` (a generic variant that may require some type annotation is `Frame.indexRows`) The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose row index is to be replaced. - `column` - The name of a column in the original data frame that will be used for the new index. Note that the values in the column need to be unique. [category:Sorting and index manipulation]

Returns a data frame whose rows are indexed based on the specified column of the original data frame. This function casts (or converts) the column key to values of type `obj` (a generic variant that may require some type annotation is `Frame.indexRows`) The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose row index is to be replaced. - `column` - The name of a column in the original data frame that will be used for the new index. Note that the values in the column need to be unique. [category:Sorting and index manipulation]

Returns a data frame whose rows are indexed based on the specified column of the original data frame. This function casts (or converts) the column key to values of type `string` (a generic variant that may require some type annotation is `Frame.indexRows`) The specified column is removed from the resulting frame. ## Parameters - `frame` - Source data frame whose row index is to be replaced. - `column` - The name of a column in the original data frame that will be used for the new index. Note that the values in the column need to be unique. [category:Sorting and index manipulation]

Replace the row index of the frame with ordinarilly generated integers starting from zero. The rows of the frame are assigned index according to the current order, or in a non-deterministic way, if the current row index is not ordered. [category:Sorting and index manipulation]

Replace the row index of the frame with a sequence of row keys generated using a function invoked on each row. ## Parameters - `frame` - Source data frame whose row index are to be replaced. - `f` - A function from row (as object series) to new row key value [category:Sorting and index manipulation]

Replace the row index of the frame with the provided sequence of row keys. The rows of the frame are assigned keys according to the provided order. ## Parameters - `frame` - Source data frame whose row index are to be replaced. - `keys` - A collection of new row keys. [category:Sorting and index manipulation]

Join two data frames. The columns of the joined frames must not overlap and their rows are aligned and transformed according to the specified join kind. For more alignment options on ordered frames, see `joinAlign`. ## Parameters - `frame1` - First data frame (left) to be used in the joining - `frame2` - Other frame (right) to be joined with `frame1` - `kind` - Specifies the joining behavior on row indices. Use `JoinKind.Outer` and `JoinKind.Inner` to get the union and intersection of the row keys, respectively. Use `JoinKind.Left` and `JoinKind.Right` to use the current key of the left/right data frame. [category:Joining, merging and zipping]

Join two data frames. The columns of the joined frames must not overlap and their rows are aligned and transformed according to the specified join kind. When the index of both frames is ordered, it is possible to specify `lookup` in order to align indices from other frame to the indices of the main frame (typically, to find the nearest key with available value for a key). ## Parameters - `frame1` - First data frame (left) to be used in the joining - `frame2` - Other frame (right) to be joined with `frame1` - `kind` - Specifies the joining behavior on row indices. Use `JoinKind.Outer` and `JoinKind.Inner` to get the union and intersection of the row keys, respectively. Use `JoinKind.Left` and `JoinKind.Right` to use the current key of the left/right data frame. - `lookup` - When `kind` is `Left` or `Right` and the two frames have ordered row index, this parameter can be used to specify how to find value for a key when there is no exactly matching key or when there are missing values. [category:Joining, merging and zipping]

Returns a specified series (column) from a data frame. If the data frame has ordered column index, the lookup semantics can be used to get series with nearest greater/smaller key. For exact semantics, you can use `getCol`. [category:Accessing frame data and lookup]

Returns a specified row from a data frame. If the data frame has ordered row index, the lookup semantics can be used to get row with nearest greater/smaller key. For exact semantics, you can use `getRow`. [category:Accessing frame data and lookup]

Builds a new data frame whose values are the results of applying the specified function on these values, but only for those columns which can be converted to the appropriate type for input to the mapping function. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function that defines the mapping [category:Frame transformations]

Builds a new data frame whose values are the results of applying the specified function on these values, but only for those columns which can be converted to the appropriate type for input to the mapping function (use `map` if you need ## Parameters - `frame` - Input data frame to be transformed - `f` - Function that defines the mapping [category:Frame transformations]

Returns a row of the data frame which has the greatest value of the specified `column`. The row is returned as an optional value (which is `None` for empty frame) and contains a key together with an object series representing the row. [category:Frame transformations]

Append two data frames with non-overlapping values. The operation takes the union of columns and rows of the source data frames and then unions the values. An exception is thrown when both data frames define value for a column/row location, but the operation succeeds if one frame has a missing value at the location. Note that the rows are *not* automatically reindexed to avoid overlaps. This means that when a frame has rows indexed with ordinal numbers, you may need to explicitly reindex the row keys before calling append. ## Parameters - `frame1` - First of the two frames to be merged (combined) - `frame2` - The other frame to be merged (combined) with the first instance [category:Joining, merging and zipping]

Append a sequence of data frames with non-overlapping values. The operation takes the union of columns and rows of the source data frames and then unions the values. An exception is thrown when both data frames define value for a column/row location, but the operation succeeds if one all frames but one has a missing value at the location. Note that the rows are *not* automatically reindexed to avoid overlaps. This means that when a frame has rows indexed with ordinal numbers, you may need to explicitly reindex the row keys before calling append. [category:Joining, merging and zipping]

Returns a row of the data frame which has the smallest value of the specified `column`. The row is returned as an optional value (which is `None` for empty frame) and contains a key together with an object series representing the row. [category:Frame transformations]

Given a frame with two-level row index, returns a series indexed by the first part of the key, containing frames representing individual groups. This function can be used if you want to perform a transformation individually on each group (e.g. using `Series.mapValues` after calling `Frame.nest`). [category:Hierarchical index operations]

Given a data frame, use the specified `keySelector` to generate a new, first-level of indices based on the current indices. Returns a series (indexed by the first-level) of frames (indexed by the second-level). [category:Hierarchical index operations]

Creates a new data frame resulting from a 'pivot' operation. Consider a denormalized data frame representing a table: column labels are field names & table values are observations of those fields. pivotTable buckets the rows along two axes, according to the results of the functions `rowGrp` and `colGrp`; and then computes a value for the frame of rows that land in each bucket. ## Parameters - `rowGrp` - A function from rowkey & row to group value for the resulting row index - `colGrp` - A function from rowkey & row to group value for the resulting col index - `op` - A function computing a value from the corresponding bucket frame [category:Grouping, windowing and chunking]

Align the existing data to a specified collection of row keys. Values in the data frame that do not match any new key are dropped, new keys (that were not in the original data frame) are assigned missing values. ## Parameters - `frame` - Source data frame that is to be realigned. - `keys` - A sequence of new row keys. The keys must have the same type as the original frame keys (because the rows are realigned). [category:Sorting and index manipulation]

Reduce the values in each series according to the specified level of a hierarchical row key. For each group of rows as specified by `levelSel`, the function reduces the values in each series using the preovided function `op` by applying `Series.reduceLevel`. Columns that cannot be converted to a type required by `op` are skipped. ## Example To sum the values in all numerical columns according to the first component of a two level row key `'K1 * 'K2`, you can use the following: df |> Frame.reduceLevel fst (fun (a:float) b -> a + b) ## Remarks This function reduces values using a function `'T -> 'T -> 'T`. If you want to process an entire group of values at once, you can use `applyLevel` instead. [category:Hierarchical index operations]

Returns a series that contains the results of aggregating each column to a single value. The function takes columns that can be converted to the type expected by the specified `op` function and reduces the values in each column using `Series.reduceValues`. ## Example The following sums the values in each column that can be converted to `float` and returns the result as a new series: df |> Frame.reduceValues (fun (a:float) b -> a + b) [category:Frame transformations]

Creates a new data frame where the specified column is replaced with a new series. (If the series does not exist, only the new series is added.) ## Parameters - `column` - A key (or name) for the column to be replaced or added - `series` - A data series to be used (the row key type has to match) - `frame` - Source data frame (which is not mutated by the operation) [category:Accessing frame data and lookup]

Returns the rows of the data frame as a series (indexed by the row keys of the source frame) containing untyped series representing individual row of the frame. [category:Accessing frame data and lookup]

Builds a new data frame whose column keys are the results of applying the specified function on the column keys of the original data frame. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of one argument that defines the column key mapping [category:Frame transformations]

Builds a new data frame whose columns are the results of applying the specified function on the columns of the input data frame. The function is called with the column key and object series that represents the column data. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of two arguments that defines the column mapping [category:Frame transformations]

Builds a new data frame whose columns are the results of applying the specified function on the columns of the input data frame. The function is called with an object series that represents the column data (use `mapCols` if you need to access the column key). ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of one argument that defines the column mapping [category:Frame transformations]

Builds a new data frame whose row keys are the results of applying the specified function on the row keys of the original data frame. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of one argument that defines the row key mapping [category:Frame transformations]

Builds a new data frame whose rows are the results of applying the specified function on the rows of the input data frame. The function is called with the row key and object series that represents the row data. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of two arguments that defines the row mapping [category:Frame transformations]

Builds a new data frame whose rows are the results of applying the specified function on the rows of the input data frame. The function is called with an object series that represents the row data (use `mapRows` if you need to access the row key). ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of one argument that defines the row mapping [category:Frame transformations]

Returns a frame with columns shifted by the specified offset. When the offset is positive, the values are shifted forward and first `offset` keys are dropped. When the offset is negative, the values are shifted backwards and the last `offset` keys are dropped. Expressed in pseudo-code: result[k] = series[k - offset] ## Parameters - `offset` - Can be both positive and negative number. - `frame` - The input frame whose columns are to be shifted. ## Remarks If you want to calculate the difference, e.g. `df - (Frame.shift 1 df)`, you can use `Frame.diff` which will be a little bit faster. [category:Frame transformations]

Returns a frame that contains the data from the original frame, except for the first `count` rows; `count` must be smaller or equal to the original number of rows. [category:Frame transformations]

Returns a frame that contains the data from the original frame, except for the last `count` rows; `count` must be smaller or equal to the original number of rows. [category:Frame transformations]

Returns a frame consisting of the specified columns from the original data frame. The function uses exact key matching semantics. [category:Accessing frame data and lookup]

Returns a frame consisting of the specified rows from the original data frame. The function uses exact key matching semantics. [category:Accessing frame data and lookup]

Returns a data frame that contains the same data as the input, but whose columns are an ordered series. This allows using operations that are only available on indexed series such as alignment and inexact lookup. [category:Sorting and index manipulation]

Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame. [category:Sorting and index manipulation]

Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame. [category:Sorting and index manipulation]

Returns a data frame that contains the same data as the input, but whose rows are an ordered series. This allows using operations that are only available on indexed series such as alignment and inexact lookup. [category:Sorting and index manipulation]

Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame. [category:Sorting and index manipulation]

Returns a data frame with three columns named `Row`, `Column` and `Value` that contains the data of the original data frame in individual rows. [category:Grouping, windowing and chunking]

Returns a frame that contains the specified `count` of rows from the original frame; `count` must be smaller or equal to the original number of rows. [category:Frame transformations]

Returns a frame that contains the specified `count` of rows from the original frame. The rows are taken from the end of the frame; `count` must be smaller or equal to the original number of rows. [category:Frame transformations]

Returns data of the data frame as a 2D array containing data as `float` values. Missing data are represented as `Double.NaN` in the returned array. [category:Accessing frame data and lookup]

Returns a transposed data frame. The rows of the original data frame are used as the columns of the new one (and vice versa). Use this operation if you have a data frame and you mostly need to access its rows as a series (because accessing columns as a series is more efficient). [category:Sorting and index manipulation]

Returns a specified key and series (column) from a data frame, or missing value if doesn't exist. [category:Accessing frame data and lookup]

Returns a specified series (column) from a data frame, or missing value if column doesn't exist. [category:Accessing frame data and lookup]

Returns a specified series (row) from a data frame, or missing value if row doesn't exit. [category:Accessing frame data and lookup]

Returns a specified series (row) and key from a data frame, or missing value if row doesn't exit. [category:Accessing frame data and lookup]

Returns a series, obtained by applying the specified projection function `f` to all rows of the input frame. The resulting series wraps the results in `tryval<'V>`. When the projection function fails, the exception is wrapped using the `Error` case. [category:Processing frames with exceptions]

Given a data frame containing columns of type `tryval<'T>`, returns a new data frame that contains the underlying values of type `'T`. When the frame contains one or more failures, the operation throws `AggregateException`. Otherwise, it returns a frame containing values. [category:Processing frames with exceptions]

Given a series of frames, returns a new data frame with two-level hierarchical row index, using the series keys as the first component. This function is the dual of `Frame.nest`. [category:Hierarchical index operations]

This function is the opposite of `stack`. It takes a data frame with three columns named `Row`, `Column` and `Value` and reconstructs a data frame by using `Row` and `Column` as row and column index keys, respectively. [category:Grouping, windowing and chunking]

Returns a new data frame containing only the columns of the input frame for which the specified predicate returns `true`. The predicate is called with the column key and object series that represents the column data. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of two arguments that defines the predicate [category:Frame transformations]

Returns a new data frame containing only the columns of the input frame for which the specified predicate returns `true`. The predicate is called with an object series that represents the column data (use `filterCols` if you need to access the column key). ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of one argument that defines the predicate [category:Frame transformations]

Returns a new data frame containing only the rows of the input frame for which the specified predicate returns `true`. The predicate is called with the row key and object series that represents the row data. ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of two arguments that defines the predicate [category:Frame transformations]

Returns a new data frame containing only the rows of the input frame for which the specified `column` has the specified `value`. The operation may be implemented via an index for virtualized Deedle frames. ## Parameters - `frame` - Input data frame to be transformed - `column` - The name of the column to be matched - `value` - Required value of the column. Note that the function is generic and no conversions are performed, so the value has to match including the actual type. [category:Frame transformations]

Returns a new data frame containing only the rows of the input frame for which the specified predicate returns `true`. The predicate is called with an object series that represents the row data (use `filterRows` if you need to access the row key). ## Parameters - `frame` - Input data frame to be transformed - `f` - Function of one argument that defines the predicate [category:Frame transformations]

Creates a sliding window using the specified size. The result is a series containing data frames that represent individual windows. This function skips incomplete chunks. ## Parameters - `size` - The size of the sliding window. - `frame` - The input frame to be aggregated. [category:Grouping, windowing and chunking]

Creates a sliding window using the specified size and then applies the provided value selector `f` on each window to produce the result which is returned as a new series. This function skips incomplete chunks. ## Parameters - `size` - The size of the sliding window. - `frame` - The input frame to be aggregated. - `f` - A function that is called on each created window. [category:Grouping, windowing and chunking]

Aligns two data frames using both column index and row index and apply the specified operation on values of a specified type that are available in both data frames. The parameters `columnKind`, and `rowKind` can be specified to determine how the alginment works (similarly to `Join`). Column keys are always matched using `Lookup.Exact`, but `lookup` determines lookup for rows. Once aligned, the call `df1.Zip<T>(df2, f)` applies the specifed function `f` on all `T` values that are available in corresponding locations in both frames. For values of other types, the value from `df1` is returned. ## Parameters - `frame1` - First frame to be aligned and zipped with the other instance - `frame2` - Other frame to be aligned and zipped with the first instance - `columnKind` - Specifies how to align columns (inner, outer, left or right join) - `rowKind` - Specifies how to align rows (inner, outer, left or right join) - `lookup` - Specifies how to find matching value for a row (when using left or right join on rows) - `op` - A function that is applied to aligned values. The `Zip` operation is generic in the type of this function and the type of function is used to determine which values in the frames are zipped and which are left unchanged. [category:Joining, merging and zipping]

Aligns two data frames using both column index and row index and apply the specified operation on values of a specified type that are available in both data frames. This overload uses `JoinKind.Outer` for both columns and rows. Once aligned, the call `df1.Zip<T>(df2, f)` applies the specifed function `f` on all `T` values that are available in corresponding locations in both frames. For values of other types, the value from `df1` is returned. ## Parameters - `frame1` - First frame to be aligned and zipped with the other instance - `frame2` - Other frame to be aligned and zipped with the first instance - `columnKind` - Specifies how to align columns (inner, outer, left or right join) - `rowKind` - Specifies how to align rows (inner, outer, left or right join) - `lookup` - Specifies how to find matching value for a row (when using left or right join on rows) - `op` - A function that is applied to aligned values. The `Zip` operation is generic in the type of this function and the type of function is used to determine which values in the frames are zipped and which are left unchanged. [category:Joining, merging and zipping]