Deedle


Frame

Namespace: Deedle

The Frame module provides an F#-friendly API for working with data frames. The module follows the usual desing for collection-processing in F#, so the functions work well with the pipelining operator (|>). For example, given a frame with two columns representing prices, we can use Frame.diff and numerical operators to calculate daily returns like this:

1: 
2: 
3: 
4: 
let df = frame [ "MSFT" => prices1; "AAPL" => prices2 ]
let past = df |> Frame.diff 1
let rets = past / df * 100.0
rets |> Stats.mean

Note that the Stats.mean operation is overloaded and works both on series (returning a number) and on frames (returning a series).

The functions in this module are designed to be used from F#. For a C#-friendly API, see the FrameExtensions type. For working with individual series, see the Series module. The functions in the Frame module are grouped in a number of categories and documented below.

val df : float

Full name: docs.df
val past : float

Full name: docs.past
val rets : float

Full name: docs.rets

Table of contents

Accessing frame data and lookup 

Functions in this category provide access to the values in the fame. You can also add and remove columns from a frame (which both return a new value).

  • addCol, replaceCol and dropCol can be used to create a new data frame with a new column, by replacing an existing column with a new one, or by dropping an existing column

  • cols and rows return the columns or rows of a frame as a series containing objects; getCols and getRows return a generic series and cast the values to the type inferred from the context (columns or rows of incompatible types are skipped); getNumericCols returns columns of a type convertible to float for convenience.

  • You can get a specific row or column using get[Col|Row] or lookup[Col|Row] functions. The lookup variant lets you specify lookup behavior for key matching (e.g. find the nearest smaller key than the specified value). There are also [try]get and [try]Lookup functions that return optional values and functions returning entire observations (key together with the series).

  • sliceCols and sliceRows return a sub-frame containing only the specified columns or rows. Finally, toArray2D returns the frame data as a 2D array.

Functions and values

Function or valueDescription
addCol column series frame
Signature: column:'C -> series:Series<'R,'V> -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R, 'V

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)
cols frame
Signature: frame:Frame<'R,'C> -> ColumnSeries<'R,'C>
Type parameters: 'R, 'C

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.

countCols frame
Signature: frame:Frame<'R,'C> -> int
Type parameters: 'R, 'C

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.

countRows frame
Signature: frame:Frame<'R,'C> -> int
Type parameters: 'R, 'C

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.

countValues frame
Signature: frame:Frame<'R,'C> -> Series<'C,int>
Type parameters: 'R, 'C

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

dropCol column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R

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)
getCol column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Series<'R,'V>
Type parameters: 'C, 'R, 'V

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)

getCols frame
Signature: frame:Frame<'R,'C> -> Series<'C,Series<'R,'T>>
Type parameters: 'R, 'C, 'T

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:

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

val res : obj

Full name: docs.res
Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string
getNumericCols frame
Signature: frame:Frame<'R,'C> -> Series<'C,Series<'R,float>>
Type parameters: 'R, 'C

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.

getRow row frame
Signature: row:'R -> frame:Frame<'R,'C> -> Series<'C,'?555587>
Type parameters: 'R, 'C, '?555587

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)

getRows frame
Signature: frame:Frame<'R,'C> -> Series<'R,Series<'C,'T>>
Type parameters: 'R, 'C, 'T

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.

lookupCol column lookup frame
Signature: column:'C -> lookup:Lookup -> frame:Frame<'R,'C> -> Series<'R,'V>
Type parameters: 'C, 'R, 'V

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.

lookupRow row lookup frame
Signature: row:'R -> lookup:Lookup -> frame:Frame<'R,'C> -> Series<'C,'?555607>
Type parameters: 'R, 'C, '?555607

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.

replaceCol column series frame
Signature: column:'C -> series:ISeries<'R> -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R

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)
rows frame
Signature: frame:Frame<'R,'C> -> RowSeries<'R,'C>
Type parameters: 'R, 'C

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.

sliceCols columns frame
Signature: columns:seq<'C> -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R

Returns a frame consisting of the specified columns from the original data frame. The function uses exact key matching semantics.

sliceRows rows frame
Signature: rows:seq<'R> -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

Returns a frame consisting of the specified rows from the original data frame. The function uses exact key matching semantics.

toArray2D frame
Signature: frame:Frame<'R,'C> -> float [,]
Type parameters: 'R, 'C

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.

tryLookupCol column lookup frame
Signature: column:'C -> lookup:Lookup -> frame:Frame<'R,'C> -> Series<'R,'V> option
Type parameters: 'C, 'R, 'V

Returns a specified series (column) from a data frame, or missing value if column doesn't exist.

tryLookupColObservation (...)
Signature: column:'C -> lookup:Lookup -> frame:Frame<'R,'C> -> ('C * Series<'R,'?555603>) option
Type parameters: 'C, 'R, '?555603

Returns a specified key and series (column) from a data frame, or missing value if doesn't exist.

tryLookupRow row lookup frame
Signature: row:'R -> lookup:Lookup -> frame:Frame<'R,'C> -> Series<'C,'?555611> option
Type parameters: 'R, 'C, '?555611

Returns a specified series (row) from a data frame, or missing value if row doesn't exit.

tryLookupRowObservation row lookup frame
Signature: row:'R -> lookup:Lookup -> frame:Frame<'R,'C> -> ('R * Series<'C,'?555615>) option
Type parameters: 'R, 'C, '?555615

Returns a specified series (row) and key from a data frame, or missing value if row doesn't exit.

Frame transformations 

Functions in this category perform standard transformations on data frames including projections, filtering, taking some sub-frame of the frame, aggregating values using scanning and so on.

Projection and filtering functions such as [map|filter][Cols|Rows] call the specified function with the column or row key and an ObjectSeries<'K> representing the column or row. You can use functions ending with Values (such as mapRowValues) when you do not require the row key, but only the row series; mapRowKeys and mapColKeys can be used to transform the keys.

You can use reduceValues to apply a custom reduction to values of columns. Other aggregations are available in the Stats module. You can also get a row with the greaterst or smallest value of a given column using [min|max]RowBy.

The functions take[Last] and skip[Last] can be used to take a sub-frame of the original source frame by skipping a specified number of rows. Note that this does not require an ordered frame and it ignores the index - for index-based lookup use slicing, such as df.Rows.[lo .. hi], instead.

Finally the shift function can be used to obtain a frame with values shifted by the specified offset. This can be used e.g. to get previous value for each key using Frame.shift 1 df. The diff function calculates difference from previous value using df - (Frame.shift offs df).

Functions and values

Function or valueDescription
diff offset frame
Signature: offset:int -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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:

1: 
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.
filterCols f frame
Signature: f:('C -> ObjectSeries<'R> -> bool) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R

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
filterColValues f frame
Signature: f:(ObjectSeries<'R> -> bool) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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
filterRows f frame
Signature: f:('R -> ObjectSeries<'C> -> bool) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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
filterRowsBy column value frame
Signature: column:'C -> value:'V -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'V, 'R

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.
filterRowValues f frame
Signature: f:(ObjectSeries<'C> -> bool) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R

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
map f frame
Signature: f:('R -> 'C -> '?555811 -> '?555812) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C, '?555811, '?555812

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
mapColKeys f frame
Signature: f:('C -> '?555801) -> frame:Frame<'R,'C> -> Frame<'R,'?555801>
Type parameters: 'C, '?555801, 'R

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
mapCols f frame
Signature: f:('C -> ObjectSeries<'R> -> '?555792) -> frame:Frame<'R,'C> -> Frame<'?555793,'C>
Type parameters: 'C, 'R, '?555792, '?555793

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
mapColValues f frame
Signature: f:(ObjectSeries<'R> -> '?555796) -> frame:Frame<'R,'C> -> Frame<'?555797,'C>
Type parameters: 'R, '?555796, '?555797, 'C

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
mapRowKeys f frame
Signature: f:('R1 -> 'R2) -> frame:Frame<'R1,'C> -> Frame<'R2,'C>
Type parameters: 'R1, 'R2, 'C

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
mapRows f frame
Signature: f:('R -> ObjectSeries<'C> -> 'V) -> frame:Frame<'R,'C> -> Series<'R,'V>
Type parameters: 'R, 'C, 'V

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
mapRowValues f frame
Signature: f:(ObjectSeries<'C> -> 'V) -> frame:Frame<'R,'C> -> Series<'R,'V>
Type parameters: 'C, 'V, 'R

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
mapValues f frame
Signature: f:('?555804 -> '?555805) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: '?555804, '?555805, 'R, 'C

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
maxRowBy column frame
Signature: column:'C -> frame:Frame<'R,'C> -> ('R * ObjectSeries<'C>) option
Type parameters: 'C, 'R

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.

minRowBy column frame
Signature: column:'C -> frame:Frame<'R,'C> -> ('R * ObjectSeries<'C>) option
Type parameters: 'C, 'R

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.

reduceValues op frame
Signature: op:('T -> 'T -> 'T) -> frame:Frame<'R,'C> -> Series<'C,'T>
Type parameters: 'T, 'R, 'C

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:

1: 
df |> Frame.reduceValues (fun (a:float) b -> a + b)
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
shift offset frame
Signature: offset:int -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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:

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

skip count frame
Signature: count:int -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

skipLast count frame
Signature: count:int -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

take count frame
Signature: count:int -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

takeLast count frame
Signature: count:int -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

Grouping, windowing and chunking 

The basic grouping functions in this category can be used to group the rows of a data frame by a specified projection or column to create a frame with hierarchical index such as Frame<'K1 * 'K2, 'C>. The functions always aggregate rows, so if you want to group columns, you need to use Frame.transpose first.

The function groupRowsBy groups rows by the value of a specified column. Use groupRowsBy[Int|Float|String...] if you want to specify the type of the column in an easier way than using type inference; groupRowsUsing groups rows using the specified projection function and groupRowsByIndex projects the grouping key just from the row index.

More advanced functions include: aggregateRowsBy which groups the rows by a specified sequence of columns and aggregates each group into a single value; pivotTable implements the pivoting operation as documented in the tutorials.

The stack and unstack functions turn the data frame into a single data frame containing columns Row, Column and Value containing the data of the original frame; unstack can be used to turn this representation back into an original frame.

A simple windowing functions that are exposed for an entire frame operations are window and windowInto. For more complex windowing operations, you currently have to use mapRows or mapCols and apply windowing on individual series.

Functions and values

Function or valueDescription
aggregateRowsBy (...)
Signature: groupBy:seq<'C> -> aggBy:seq<'C> -> aggFunc:(Series<'R,'V1> -> 'V2) -> frame:Frame<'R,'C> -> Frame<int,'C>
Type parameters: 'C, 'R, 'V1, 'V2

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
groupRowsBy column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Frame<('K * 'R),'C>
Type parameters: 'C, 'R, 'K

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.

groupRowsByBool column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Frame<(bool * 'R),'C>
Type parameters: 'C, 'R

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.

groupRowsByIndex keySelector frame
Signature: keySelector:('R -> 'K) -> frame:Frame<'R,'C> -> Frame<('K * 'R),'C>
Type parameters: 'R, 'K, 'C

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.

groupRowsByInt column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Frame<(int * 'R),'C>
Type parameters: 'C, 'R

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.

groupRowsByObj column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Frame<(obj * 'R),'C>
Type parameters: 'C, 'R

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.

groupRowsByString column frame
Signature: column:'C -> frame:Frame<'R,'C> -> Frame<(string * 'R),'C>
Type parameters: 'C, 'R

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.

groupRowsUsing selector frame
Signature: selector:('R -> ObjectSeries<'C> -> 'K) -> frame:Frame<'R,'C> -> Frame<('K * 'R),'C>
Type parameters: 'R, 'C, 'K

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.

pivotTable rowGrp colGrp op frame
Signature: rowGrp:('R -> ObjectSeries<'C> -> 'RNew) -> colGrp:('R -> ObjectSeries<'C> -> 'CNew) -> op:(Frame<'R,'C> -> 'T) -> frame:Frame<'R,'C> -> Frame<'RNew,'CNew>
Type parameters: 'R, 'C, 'RNew, 'CNew, 'T

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
stack frame
Signature: frame:Frame<'R,'C> -> Frame<int,string>
Type parameters: 'R, 'C

Returns a data frame with three columns named Row, Column and Value that contains the data of the original data frame in individual rows.

unstack frame
Signature: frame:Frame<'O,string> -> Frame<'R,'C>
Type parameters: 'O, 'R, 'C

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.

window size frame
Signature: size:int -> frame:Frame<'R,'C> -> Series<'R,Frame<'R,'C>>
Type parameters: 'R, 'C

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.
windowInto size f frame
Signature: size:int -> f:(Frame<'R,'C> -> 'c) -> frame:Frame<'R,'C> -> Series<'R,'c>
Type parameters: 'R, 'C, 'c

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.

Hierarchical index operations 

A data frame has a hierarchical row index if the row index is formed by a tuple, such as Frame<'R1 * 'R2, 'C>. Frames of this kind are returned, for example, by the grouping functions such as Frame.groupRowsBy. The functions in this category provide ways for working with data frames that have hierarchical row keys.

The functions applyLevel and reduceLevel can be used to reduce values according to one of the levels. The applyLevel function takes a reduction of type Series<'K, 'T> -> 'T while reduceLevel reduces individual values using a function of type 'T -> 'T -> 'T.

The functions nest and unnest can be used to convert between frames with hierarchical indices (Frame<'K1 * 'K2, 'C>) and series of frames that represent individual groups (Series<'K1, Frame<'K2, 'C>>). The nestBy function can be used to perform group by operation and return the result as a series of frems.

Functions and values

Function or valueDescription
applyLevel levelSel op frame
Signature: levelSel:('R -> 'K) -> op:(Series<'R,'T> -> 'T) -> frame:Frame<'R,'C> -> Frame<'K,'C>
Type parameters: 'R, 'K, 'T, 'C

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:

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

val fst : tuple:('T1 * 'T2) -> 'T1

Full name: Microsoft.FSharp.Core.Operators.fst
nest frame
Signature: frame:Frame<('R1 * 'R2),'C> -> Series<'R1,Frame<'R2,'C>>
Type parameters: 'R1, 'R2, 'C

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

nestBy keySelector frame
Signature: keySelector:('K2 -> 'K1) -> frame:Frame<'K2,'C> -> Series<'K1,Frame<'K2,'C>>
Type parameters: 'K2, 'K1, 'C

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

reduceLevel levelSel op frame
Signature: levelSel:('R -> 'K) -> op:('T -> 'T -> 'T) -> frame:Frame<'R,'C> -> Frame<'K,'C>
Type parameters: 'R, 'K, 'T, 'C

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:

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

val fst : tuple:('T1 * 'T2) -> 'T1

Full name: Microsoft.FSharp.Core.Operators.fst
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
unnest series
Signature: series:Series<'R1,Frame<'R2,'C>> -> Frame<('R1 * 'R2),'C>
Type parameters: 'R1, 'R2, 'C

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.

Joining, merging and zipping 

The simplest way to join two frames is to use the join operation which can be used to perform left, right, outer or inner join of two frames. When the row keys of the frames do not match exactly, you can use joinAlign which takes an additional parameter that specifies how to find matching key in left/right join (e.g. by taking the nearest smaller available key).

Frames that do not contian overlapping values can be combined using merge (when combining just two frames) or using mergeAll (for larger number of frames). Tha latter is optimized to work well for a large number of data frames.

Finally, frames with overlapping values can be combined using zip. It takes a function that is used to combine the overlapping values. A zipAlign function provides a variant with more flexible row key matching (as in joinAlign)

Functions and values

Function or valueDescription
join kind frame1 frame2
Signature: kind:JoinKind -> frame1:Frame<'R,'C> -> frame2:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.
joinAlign kind lookup frame1 frame2
Signature: kind:JoinKind -> lookup:Lookup -> frame1:Frame<'R,'C> -> frame2:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.
merge frame1 frame2
Signature: frame1:Frame<'R,'C> -> frame2:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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
mergeAll frames
Signature: frames:seq<Frame<'R,'C>> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

zip op frame1 frame2
Signature: op:('V1 -> 'V2 -> 'V) -> frame1:Frame<'R,'C> -> frame2:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'V1, 'V2, 'V, 'R, 'C

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.
zipAlign (...)
Signature: columnKind:JoinKind -> rowKind:JoinKind -> lookup:Lookup -> op:('V1 -> 'V2 -> 'V) -> frame1:Frame<'R,'C> -> frame2:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'V1, 'V2, 'V, 'R, 'C

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.

Missing values 

This group of functions provides a way of working with missing values in a data frame. The category provides the following functions that can be used to fill missing values:

  • fillMissingWith fills missing values with a specified constant
  • fillMissingUsing calls a specified function for every missing value
  • fillMissing and variants propagates values from previous/later keys

We use the terms sparse and dense to denote series that contain some missing values or do not contain any missing values, respectively. The functions denseCols and denseRows return a series that contains only dense columns or rows and all sparse rows or columns are replaced with a missing value. The dropSparseCols and dropSparseRows functions drop these missing values and return a frame with no missing values.

Functions and values

Function or valueDescription
denseCols frame
Signature: frame:Frame<'R,'C> -> ColumnSeries<'R,'C>
Type parameters: 'R, 'C

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.

denseRows frame
Signature: frame:Frame<'R,'C> -> RowSeries<'R,'C>
Type parameters: 'R, 'C

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.

dropSparseCols frame
Signature: frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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

dropSparseRows frame
Signature: frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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

fillMissing direction frame
Signature: direction:Direction -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.
fillMissingUsing f frame
Signature: f:(Series<'R,'T> -> 'R -> 'T) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'T, 'C

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.
fillMissingWith value frame
Signature: value:'T -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'T, 'R, 'C

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

Processing frames with exceptions 

The functions in this group can be used to write computations over frames that may fail. They use the type tryval<'T> which is defined as a discriminated union:

1: 
2: 
3: 
type tryval<'T> = 
  | Success of 'T
  | Error of exn

Using tryval<'T> as a value in a data frame is not generally recommended, because the type of values cannot be tracked in the type. For this reason, it is better to use tryval<'T> with individual series. However, tryValues and fillErrorsWith functions can be used to get values, or fill failed values inside an entire data frame.

The tryMapRows function is more useful. It can be used to write a transformation that applies a computation (which may fail) to each row of a data frame. The resulting series is of type Series<'R, tryval<'T>> and can be processed using the Series module functions.

type tryval<'T> =
  | Success of 'T
  | Error of exn

Full name: docs.tryval<_>
union case tryval.Success: 'T -> tryval<'T>
union case tryval.Error: exn -> tryval<'T>
type exn = System.Exception

Full name: Microsoft.FSharp.Core.exn

Functions and values

Function or valueDescription
fillErrorsWith value frame
Signature: value:'T -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'T, 'R, 'C

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.

tryMapRows f frame
Signature: f:('R -> ObjectSeries<'C> -> 'V) -> frame:Frame<'R,'C> -> Series<'R,'V tryval>
Type parameters: 'R, 'C, 'V

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.

tryValues frame
Signature: frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

Sorting and index manipulation 

A frame is indexed by row keys and column keys. Both of these indices can be sorted (by the keys). A frame that is sorted allows a number of additional operations (such as lookup using the Lookp.ExactOrSmaller lookup behavior). The functions in this category provide ways for manipulating the indices. It is expected that most operations are done on rows and so more functions are available in a row-wise way. A frame can alwyas be transposed using Frame.transpose.

Index operations

The existing row/column keys can be replaced by a sequence of new keys using the indexColsWith and indexRowsWith functions. Row keys can also be replaced by ordinal numbers using indexRowsOrdinally.

The function indexRows uses the specified column of the original frame as the index. It removes the column from the resulting frame (to avoid this, use overloaded IndexRows method). This function infers the type of row keys from the context, so it is usually more convenient to use indexRows[Date|String|Int|...] functions. Finally, if you want to calculate the index value based on multiple columns of the row, you can use indexRowsUsing.

Sorting frame rows

Frame rows can be sorted according to the value of a specified column using the sortRows function; sortRowsBy takes a projection function which lets you transform the value of a column (e.g. to project a part of the value).

The functions sortRowsByKey and sortColsByKey sort the rows or columns using the default ordering on the key values. The result is a frame with ordered index.

Expanding columns

When the frame contains a series with complex .NET objects such as F# records or C# classes, it can be useful to "expand" the column. This operation looks at the type of the objects, gets all properties of the objects (recursively) and generates multiple series representing the properties as columns.

The function expandCols expands the specified columns while expandAllCols applies the expansion to all columns of the data frame.

Functions and values

Function or valueDescription
expandAllCols nesting frame
Signature: nesting:int -> frame:Frame<'R,string> -> Frame<'R,string>
Type parameters: 'R

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
expandCols names frame
Signature: names:seq<string> -> frame:Frame<'R,string> -> Frame<'R,string>
Type parameters: 'R

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:

1: 
2: 
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
val df : obj

Full name: docs.df
indexColsWith keys frame
Signature: keys:seq<'C2> -> frame:Frame<'R,'C1> -> Frame<'R,'C2>
Type parameters: 'C2, 'R, 'C1

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.
indexRows column frame
Signature: column:'C -> frame:Frame<'R1,'C> -> Frame<'R2,'C>
Type parameters: 'C, 'R1, 'R2

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.
indexRowsDate column frame
Signature: column:'C -> frame:Frame<'R1,'C> -> Frame<DateTime,'C>
Type parameters: 'C, 'R1

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.
indexRowsDateOffs column frame
Signature: column:'C -> frame:Frame<'R1,'C> -> Frame<DateTimeOffset,'C>
Type parameters: 'C, 'R1

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.
indexRowsInt column frame
Signature: column:'C -> frame:Frame<'R1,'C> -> Frame<int,'C>
Type parameters: 'C, 'R1

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.
indexRowsObj column frame
Signature: column:'C -> frame:Frame<'R1,'C> -> Frame<obj,'C>
Type parameters: 'C, 'R1

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.
indexRowsOrdinally frame
Signature: frame:Frame<'TRowKey,'TColumnKey> -> Frame<int,'TColumnKey>
Type parameters: 'TRowKey, 'TColumnKey

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.

indexRowsString column frame
Signature: column:'C -> frame:Frame<'R1,'C> -> Frame<string,'C>
Type parameters: 'C, 'R1

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.
indexRowsUsing f frame
Signature: f:(ObjectSeries<'C> -> 'R2) -> frame:Frame<'R1,'C> -> Frame<'R2,'C>
Type parameters: 'C, 'R2, 'R1

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
indexRowsWith keys frame
Signature: keys:seq<'R2> -> frame:Frame<'R1,'C> -> Frame<'R2,'C>
Type parameters: 'R2, 'R1, 'C

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.
realignRows keys frame
Signature: keys:seq<'R> -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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).
sortColsByKey frame
Signature: frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

sortRows colKey frame
Signature: colKey:'C -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'R

Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame.

sortRowsBy colKey f frame
Signature: colKey:'C -> f:('T -> 'V) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'T, 'V, 'R

Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame.

sortRowsByKey frame
Signature: frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'R, 'C

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.

sortRowsWith colKey compareFunc frame
Signature: colKey:'C -> compareFunc:('a -> 'a -> int) -> frame:Frame<'R,'C> -> Frame<'R,'C>
Type parameters: 'C, 'a, 'R

Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame.

transpose frame
Signature: frame:Frame<'R,'TColumnKey> -> Frame<'TColumnKey,'R>
Type parameters: 'R, 'TColumnKey

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

Fork me on GitHub