 | FrameTRowKey, TColumnKey Class |
A frame is the key Deedle data structure (together with series). It represents a
data table (think spreadsheet or CSV file) with multiple rows and columns. The frame
consists of row index, column index and data. The indices are used for efficient
lookup when accessing data by the row key `'TRowKey` or by the column key
`'TColumnKey`. Deedle frames are optimized for the scenario when all values in a given
column are of the same type (but types of different columns can differ).
## Joining, zipping and appending
More info
[category:Core frame and series types]
Inheritance HierarchyNamespace: Deedle
Assembly: Deedle (in Deedle.dll) Version: 1.2
SyntaxC#
[SerializableAttribute] public class Frame<TRowKey, TColumnKey> : IDynamicMetaObjectProvider, INotifyCollectionChanged, IFrame
Type Parameters
- TRowKey
- TColumnKey
The FrameTRowKey, TColumnKey type exposes the following members.
Constructors| Name | Description | |
|---|---|---|
 | FrameTRowKey, TColumnKey(IEnumerableTColumnKey, IEnumerableISeriesTRowKey) | Initializes a new instance of the FrameTRowKey, TColumnKey class |
| FrameTRowKey, TColumnKey(IIndexTRowKey, IIndexTColumnKey, IVectorIVector, IIndexBuilder, IVectorBuilder) | Initializes a new instance of the FrameTRowKey, TColumnKey class |
Properties| Name | Description | |
|---|---|---|
 | ColumnCount | |
| ColumnIndex | |
| ColumnKeys |
[category:Accessors and slicing]
|
| Columns |
[category:Accessors and slicing]
|
| ColumnsDense |
[category:Accessors and slicing]
|
| ColumnTypes |
[category:Accessors and slicing]
|
| IsEmpty |
[category:Accessors and slicing]
|
| ItemTColumnKey |
[category:Series operations]
|
| ItemTColumnKey, TRowKey |
[category:Accessors and slicing]
|
| RowCount | |
| RowIndex | |
| RowKeys |
[category:Accessors and slicing]
|
| Rows |
[category:Accessors and slicing]
|
| RowsDense |
[category:Accessors and slicing]
|
Methods| Name | Description | |
|---|---|---|
 | Abs |
[category:Operators]
|
| Acos |
[category:Operators]
|
| AddColumn(TColumnKey, ISeriesTRowKey) |
Mutates the data frame by adding an additional data series
as a new column with the specified column key. The operation
uses left join and aligns new series to the existing frame keys.
## Parameters
- `series` - A data series to be added (the row key type has to match)
- `column` - A key (or name) for the newly added column
[category:Series operations]
|
| AddColumnV(TColumnKey, IEnumerableV) |
Mutates the data frame by adding an additional data series
as a new column with the specified column key. The sequence is
aligned to the data frame based on ordering. If it is longer, it is
trimmed and if it is shorter, missing values will be added.
## Parameters
- `column` - A key (or name) for the newly added column
- `series` - A sequence of values to be added
[category:Series operations]
|
| AddColumnV(TColumnKey, ISeriesTRowKey, Lookup) |
Mutates the data frame by adding an additional data series
as a new column with the specified column key. The operation
uses left join and aligns new series to the existing frame keys.
A parameter `lookup` can be used to specify how to find a value in the
added series (if an exact key is not available). The `lookup` parameter
can only be used with ordered indices.
## Parameters
- `series` - A data series to be added (the row key type has to match)
- `column` - A key (or name) for the newly added column
- `lookup` - Specify how to find value in the added series (look for
nearest available value with the smaller/greater key).
[category:Series operations]
|
| AddColumnV(TColumnKey, IEnumerableV, Lookup) |
Mutates the data frame by adding an additional data series
as a new column with the specified column key. The sequence is
aligned to the data frame based on ordering. If it is longer, it is
trimmed and if it is shorter, missing values will be added.
A parameter `lookup` can be used to specify how to find a value in the
added series (if the sequence contains invalid values like `null` or `NaN`).
## Parameters
- `column` - A key (or name) for the newly added column
- `series` - A sequence of values to be added
- `lookup` - Specify how to find value in the added series (look for
nearest available value with the smaller/greater key).
[category:Series operations]
|
| AggregateRowsBya, b |
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:Windowing, chunking and grouping]
|
| Asin |
[category:Operators]
|
| Atan |
[category:Operators]
|
| Ceiling |
[category:Operators]
|
| Clone | |
| ColumnApplyT(FuncSeriesTRowKey, T, ISeriesTRowKey) |
[category:Projection and filtering]
|
| ColumnApplyT(Boolean, FuncSeriesTRowKey, T, ISeriesTRowKey) | Obsolete. |
| ColumnApplyT(ConversionKind, FuncSeriesTRowKey, T, ISeriesTRowKey) |
[category:Projection and filtering]
|
| Cos |
[category:Operators]
|
| Cosh |
[category:Operators]
|
| DropColumn |
Mutates the data frame by removing the specified series from the
frame columns. 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:Series operations]
|
| Equals | (Overrides ObjectEquals(Object).) |
| Exp |
[category:Operators]
|
 | Finalize | Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.) |
| Floor |
[category:Operators]
|
| Format |
Shows the data frame content in a human-readable format. The resulting string
shows all columns, but a limited number of rows.
[category:Formatting and raw data access]
|
| Format(Boolean) |
Shows the data frame content in a human-readable format. The resulting string
shows all columns, but a limited number of rows.
## Parameters
- `startCount` - The number of rows at the beginning to be printed
- `endCount` - The number of rows at the end of the frame to be printed
- `printTypes` - When true, the types of vectors storing column data are printed
[category:Formatting and raw data access]
|
| Format(Int32) |
Shows the data frame content in a human-readable format. The resulting string
shows all columns, but a limited number of rows.
## Parameters
- `count` - The maximal total number of rows to be printed
[category:Formatting and raw data access]
|
| Format(Int32, Int32) |
Shows the data frame content in a human-readable format. The resulting string
shows all columns, but a limited number of rows.
## Parameters
- `startCount` - The number of rows at the beginning to be printed
- `endCount` - The number of rows at the end of the frame to be printed
[category:Formatting and raw data access]
|
| Format(Int32, Int32, Boolean) |
Shows the data frame content in a human-readable format. The resulting string
shows all columns, but a limited number of rows.
## Parameters
- `startCount` - The number of rows at the beginning to be printed
- `endCount` - The number of rows at the end of the frame to be printed
- `printTypes` - When true, the types of vectors storing column data are printed
[category:Formatting and raw data access]
|
| GetAddressRange |
Internal helper used by `skip`, `take`, etc.
|
| GetAllColumnsR |
[category:Series operations]
|
| GetAllColumnsR(Boolean) | Obsolete. |
| GetAllColumnsR(ConversionKind) |
[category:Series operations]
|
| GetAllValuesR |
[category:Fancy accessors]
|
| GetAllValuesR(ConversionKind) |
[category:Fancy accessors]
|
| GetColumnR(TColumnKey) |
[category:Series operations]
|
| GetColumnR(TColumnKey, Lookup) |
[category:Series operations]
|
| GetColumnAtR |
[category:Series operations]
|
| GetColumnsR |
[category:Fancy accessors]
|
| GetFrameData |
[category:Formatting and raw data access]
|
| GetHashCode | (Overrides ObjectGetHashCode.) |
| GetRowT(TRowKey) |
Returns a row with the specieifed key. This method is generic and returns the result
as a series containing values of the specified type. To get heterogeneous series of
type `ObjectSeries<'TCol>`, use the `frame.Rows` property.
## Parameters
- `rowKey` - Specifies the key of the row to be returned
[category:Accessors and slicing]
|
| GetRowT(TRowKey, Lookup) |
Returns a row with the specieifed key. This method is generic and returns the result
as a series containing values of the specified type. To get heterogeneous series of
type `ObjectSeries<'TCol>`, use the `frame.Rows` property.
## Parameters
- `rowKey` - Specifies the key of the row to be returned
- `lookup` - Specifies how to find value in a frame with ordered rows when the key does
not exactly match (look for nearest available value with the smaller/greater key).
[category:Accessors and slicing]
|
| GetRowAtT |
Returns a row of the data frame that is located at the specified int offset.
This does not use the row key and directly accesses the frame data. This method
is generic and returns the result as a series containing values of the specified type.
To get heterogeneous series of type `ObjectSeries<'TCol>`, use the `frame.Rows` property.
If the index is invalid, `ArgumentOutOfRangeException` is thrown. You can get the
matching key at a specified index using `GetRowKeyAt`.
## Parameters
- `index` - Offset (integer) of the row to be returned
[category:Accessors and slicing]
|
| GetRowKeyAt |
Returns the row key that is located at the specified int offset.
If the index is invalid, `ArgumentOutOfRangeException` is thrown.
You can get the corresponding row using `GetRowAt`.
## Parameters
- `index` - Offset (integer) of the row key to be returned
[category:Accessors and slicing]
|
| GetRowsR |
[category:Fancy accessors]
|
| GetRowsAsTRow |
[category:Accessors and slicing]
|
| GetSubrange |
[category:Accessors and slicing]
|
| GetType | Gets the Type of the current instance. (Inherited from Object.) |
| GroupRowsByTGroup | |
| GroupRowsByIndexc | |
| GroupRowsUsingTGroup | |
| IndexRowsTNewRowIndex(TColumnKey) |
Returns a data frame whose rows are indexed based on the specified column of the original
data frame. The generic type parameter is (typically) needed to specify the type of the
values in the required index column.
The resulting frame will *not* contain the specified column. If you want to preserve the
column, use the overload that takes `keepColumn` parameter.
## Parameters
- `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:Indexing]
|
| IndexRowsTNewRowIndex(TColumnKey, Boolean) |
Returns a data frame whose rows are indexed based on the specified column of the original
data frame. The generic type parameter is (typically) needed to specify the type of the
values in the required index column.
## Parameters
- `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.
- `keepColumn` - Specifies whether the column used as an index should be kept in the frame.
[category:Indexing]
|
| Join(FrameTRowKey, TColumnKey) |
Performs outer join on two data frames. The columns of the joined frames must not
overlap and their rows are aligned. The unavailable values are marked as missing.
## Parameters
- `otherFrame` - Other frame (right) to be joined with the current instance (left)
[category:Joining, zipping and appending]
|
| Join(FrameTRowKey, TColumnKey, JoinKind) |
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 overload taking `lookup`.
## Parameters
- `otherFrame` - Other frame (right) to be joined with the current instance (left)
- `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, zipping and appending]
|
| Join(FrameTRowKey, TColumnKey, JoinKind, Lookup) |
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
- `otherFrame` - Other frame (right) to be joined with the current instance (left)
- `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.
Supported values are `Lookup.Exact`, `Lookup.ExactOrSmaller` and `Lookup.ExactOrGreater`.
[category:Joining, zipping and appending]
|
| JoinV(TColumnKey, SeriesTRowKey, V) |
Performs outer join on data frame and a series. The column key for the joined
series must not occur in the current data frame. The rows are automatically aligned
and unavailable values are marked as missing.
## Parameters
- `colKey` - Column key to be used for the joined series
- `series` - Series to be joined with the current data frame
[category:Joining, zipping and appending]
|
| JoinV(TColumnKey, SeriesTRowKey, V, JoinKind) |
Join data frame and a series. The column key for the joined series must not occur in the
current data frame. The rows are aligned and transformed according to the specified join kind.
## Parameters
- `colKey` - Column key to be used for the joined series
- `series` - Series to be joined with the current data frame
- `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, zipping and appending]
|
| JoinV(TColumnKey, SeriesTRowKey, V, JoinKind, Lookup) |
Join data frame and a series. The column key for the joined series must not occur in the
current data frame. The rows are aligned and transformed according to the specified join kind.
When the index of both objects 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
- `colKey` - Column key to be used for the joined series
- `series` - Series to be joined with the current data frame
- `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.
Supported values are `Lookup.Exact`, `Lookup.ExactOrSmaller` and `Lookup.ExactOrGreater`.
[category:Joining, zipping and appending]
|
| Log |
[category:Operators]
|
| Log10 |
[category:Operators]
|
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.) |
| Merge(FrameTRowKey, TColumnKey) |
Merge 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
- `otherFrame` - The other frame to be appended (combined) with the current instance
[category:Joining, zipping and appending]
|
| Merge(FrameTRowKey, TColumnKey) |
Merge multiple 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
- `otherFrames` - A collection containing other data frame to be appended
(combined) with the current instance
[category:Joining, zipping and appending]
|
| Merge(IEnumerableFrameTRowKey, TColumnKey) |
Merge multiple 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
- `otherFrames` - A collection containing other data frame to be appended
(combined) with the current instance
[category:Joining, zipping and appending]
|
| Pow(Double, FrameTRowKey, TColumnKey) |
[category:Operators]
|
| Pow(FrameTRowKey, TColumnKey, Double) |
[category:Operators]
|
| RenameColumn |
[category:Series operations]
|
| RenameColumns(IEnumerableTColumnKey) |
[category:Series operations]
|
| RenameColumns(FuncTColumnKey, TColumnKey) |
[category:Series operations]
|
| ReplaceColumn(TColumnKey, ISeriesTRowKey) |
Mutates the data frame by replacing the specified series 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)
[category:Series operations]
|
| ReplaceColumn(TColumnKey, ISeriesTRowKey, Lookup) |
Mutates the data frame by replacing the specified series with
a new series. (If the series does not exist, only the new series is added.)
When adding a series, the specified `lookup` parameter is used for matching
keys. The parameter can only be used for frame with ordered indices.
## 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)
- `lookup` - Specify how to find value in the added series (look for
nearest available value with the smaller/greater key).
[category:Series operations]
|
| ReplaceColumnV(TColumnKey, IEnumerableV) |
Mutates the data frame by replacing the specified series with
a new data sequence . (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 sequence of values to be added
[category:Series operations]
|
| ReplaceColumnV(TColumnKey, IEnumerableV, Lookup) |
Mutates the data frame by replacing the specified series with
a new data sequence. (If the series does not exist, only the new series is added.)
When adding a series, the specified `lookup` parameter is used for filling
missing values (e.g. `null` or `NaN`). The parameter can only be used for
frame with ordered indices.
## 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)
- `lookup` - Specify how to find value in the added series (look for
nearest available value with the smaller/greater key).
[category:Series operations]
|
| Round |
[category:Operators]
|
| SelectT1, T2 |
[category:Projection and filtering]
|
| SelectValuesT1, T2 |
[category:Projection and filtering]
|
| Sign |
[category:Operators]
|
| Sin |
[category:Operators]
|
| Sinh |
[category:Operators]
|
| Sqrt |
[category:Operators]
|
| Tan |
[category:Operators]
|
| Tanh |
[category:Operators]
|
| ToArray2DR |
Returns data of the data frame as a 2D array. The method attempts to convert
all values to the specified type 'R. If the specified type is 'float' or 'double'
then the method automatically uses NaN. For other values, the default value has to
be explicitly specified using another overload.
[category:Fancy accessors]
|
| ToArray2DR(R) |
Returns data of the data frame as a 2D array. The method attempts to convert
all values to the specified type 'R. When a value is missing, the specified
`defaultValue` is used.
## Parameters
- `defaultValue` - Default value used to fill all missing values
[category:Fancy accessors]
|
| ToString | Returns a string that represents the current object. (Inherited from Object.) |
| Truncate |
[category:Operators]
|
| TryGetColumnR |
[category:Series operations]
|
| TryGetColumnObservationR |
[category:Series operations]
|
| TryGetRowT(TRowKey) |
Returns a row with the specieifed key wrapped in `OptionalValue`. When the specified key
is not found, the result is `OptionalValue.Missing`. This method is generic and returns the result
as a series containing values of the specified type. To get heterogeneous series of
type `ObjectSeries<'TCol>`, use the `frame.Rows` property.
## Parameters
- `rowKey` - Specifies the key of the row to be returned
[category:Accessors and slicing]
|
| TryGetRowT(TRowKey, Lookup) |
Returns a row with the specieifed key wrapped in `OptionalValue`. When the specified key
is not found, the result is `OptionalValue.Missing`. This method is generic and returns the result
as a series containing values of the specified type. To get heterogeneous series of
type `ObjectSeries<'TCol>`, use the `frame.Rows` property.
## Parameters
- `rowKey` - Specifies the key of the row to be returned
- `lookup` - Specifies how to find value in a frame with ordered rows when the key does
not exactly match (look for nearest available value with the smaller/greater key).
[category:Accessors and slicing]
|
| TryGetRowObservationT |
Try to find a row with the specified row key, or using the specified `lookup` parameter,
and return the found row together with its actual key in case `lookup` was used. In case the
row is not found, `OptionalValue.Missing` is returned.
## Parameters
- `rowKey` - Specifies the key of the row to be returned
- `lookup` - Specifies how to find value in a frame with ordered rows when the key does
not exactly match (look for nearest available value with the smaller/greater key).
[category:Accessors and slicing]
|
| ZipV1, V2, V3(FrameTRowKey, TColumnKey, FuncV1, V2, V3) |
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
- `otherFrame` - Other frame to be aligned and zipped with the current instance
- `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, zipping and appending]
|
| ZipV1, V2, V3(FrameTRowKey, TColumnKey, JoinKind, JoinKind, Lookup, FuncV1, V2, V3) |
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
- `otherFrame` - Other frame to be aligned and zipped with the current 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)
Supported values are `Lookup.Exact`, `Lookup.ExactOrSmaller` and `Lookup.ExactOrGreater`.
- `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, zipping and appending]
|
OperatorsTop
See Also