Deedle
Deedle Namespace
- Core frame and series types
- Frame and series operations
- Parameters and results of various operations
- Primitive types and values
- Specialized frame and series types
- Vectors and indices
- Other namespace members
Core frame and series types
Type | Description |
Frame<'TRowKey, 'TColumnKey> | 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 |
FrameData | Represents the underlying (raw) data of the frame in a format that can be used for exporting data frame to other formats etc. (DataTable, CSV, Excel) |
ISeries<'K> | Represents an untyped series with keys of type |
Series<'K, 'V> | The type |
Module | Description |
F# Series extensions | Contains extensions for creating values of type |
Frame and series operations
Type | Description |
EnumerableExtensions | Contains C#-friendly extension methods for various instances of |
Frame | Provides static methods for creating frames, reading frame data from CSV files and database (via IDataReader). The type also provides global configuration for reflection-based expansion. |
FrameExtensions | Contains C# and F# extension methods for the |
SeriesExtensions | The type implements C# and F# extension methods for the |
SeriesStatsExtensions | The type implements C# and F# extension methods that add numerical operations
to Deedle series. With a few exceptions, the methods are only available for
series containing floating-point values, that is |
Stats | The The resulting series has the same keys as the input series. When there are no values, or missing values, different functions behave in different ways. Statistics (e.g. mean) return missing value when any value is missing, while min/max functions return the minimal/maximal element (skipping over missing values). |
Module | Description | ||||
F# Frame extensions | This module contains F# functions and extensions for working with frames. This
includes operations for creating frames such as the |
||||
Frame | The
Note that the The functions in this module are designed to be used from F#. For a C#-friendly
API, see the val df : float
Full name: docs.df val past : float
Full name: docs.past val rets : float
Full name: docs.rets |
||||
FrameBuilder | Type that can be used for creating frames using the C# collection initializer syntax.
You can use |
||||
Series | The
The module provides comprehensive set of functions for working with series. The same API is also exposed using C#-friendly extension methods. In C#, the above snippet could be written as:
For more information about similar frame-manipulation functions, see the |
Parameters and results of various operations
Type | Description |
Aggregation<'K> | Represents a strategy for aggregating data in an ordered series into data segments.
To create a value of this type from C#, use the non-generic |
Aggregation | A non-generic type that simplifies the construction of |
Boundary | Represents boundary behaviour for operations such as floating window. The type
specifies whether incomplete windows (of smaller than required length) should be
produced at the beginning ( |
ConversionKind | Represents different kinds of type conversions that can be used by Deedle internally.
This is used, for example, when converting |
DataSegment<'T> | Represents a segment of a series or sequence. The value is returned from
various functions that aggregate data into chunks or floating windows. The
|
DataSegmentKind | Represents a kind of |
Direction | Specifies in which direction should we look when performing operations such as
|
ICustomLookup<'K> | Represents a special lookup. This can be used to support hierarchical or duplicate keys
in an index. A key type |
JoinKind | This enumeration specifies joining behavior for |
Lookup | Represents different behaviors of key lookup in series. For unordered series,
the only available option is |
UnionBehavior | This enumeration specifies the behavior of |
Module | Description |
DataSegment | Provides helper functions and active patterns for working with |
MultiKeyExtensions | F#-friendly functions for creating multi-level keys and lookups |
Primitive types and values
Type | Description |
KeyValue | A type with extension method for |
MissingValueException | Thrown when a value at the specified index does not exist in the data frame or series.
This exception is thrown only when the key is defined, but the value is not available,
in other situations |
OptionalValue<'T> | Value type that represents a potentially missing value. This is similar to
The type is only used in C#-friendly API. F# operations generally use expose
standard F# |
OptionalValue | Non-generic type that makes it easier to create |
OptionalValueExtensions | Extension methods for working with optional values from C#. These make
it easier to provide default values and convert optional values to
|
TryValue<'T> | Represents a value or an exception. This type is used by functions such as
|
opt<'T> | A type alias for the |
tryval<'T> | A type alias for the |
Module | Description |
OptionalValue | Provides various helper functions for using the |
Pair | Module with helper functions for extracting values from hierarchical tuples |
Specialized frame and series types
Type | Description |
ColumnSeries<'TRowKey, 'TColumnKey> | Represents a series of columns from a frame. The type inherits from a series of
series representing individual columns ( |
DelayedSeries | This type exposes a single static method |
IFrame | An empty interface that is implemented by |
IFrameOperation<'V> | Represents an operation that can be invoked on |
ObjectSeries<'K> | Represents a series containing boxed values. This type is inherited from |
RowSeries<'TRowKey, 'TColumnKey> | Represents a series of rows from a frame. The type inherits from a series of
series representing individual rows ( |
SeriesBuilder<'K, 'V> | The type can be used for creating series using mutation. You can add
items using |
SeriesBuilder<'K> | A simple class that inherits from |
Vectors and indices
Type | Description |
IVector<'T> | A generic, typed vector. Represents mapping from addresses to values of type |
IVector | Represents an (untyped) vector that stores some values and provides access
to the values via a generic address. This type should be only used directly when
extending the DataFrame library and adding a new way of storing or loading data.
To allow invocation via Reflection, the vector exposes type of elements as |
IVectorLocation | Represents a location in a vector. In general, we always know the address, but
sometimes (BigDeedle) it is hard to get the offset (requires some data lookups),
so we use this interface to delay the calculation of the Offset (which is mainly
needed in one of the |
Index | Type that provides access to creating indices (represented as |
VectorCallSite<'R> | Represents a generic function |
Module | Description |
Addressing | An Here is a brief summary of what we assume (and don't assume) about addresses:
|
F# Index extensions | Defines non-generic |
F# IndexBuilder implementation | Set concrete IIndexBuilder implementation |
F# Vector extensions | Defines non-generic |
F# Vector extensions (core) | Module with extensions for generic vector type. Given |
F# VectorBuilder implementation | Set concrete IVectorBuilder implementation |
Other namespace members
Type | Description |
IRangeRestriction<'TAddress> | A sequence of indicies together with the total number. Use For example, if your source has an optimised way for getting every 10th address, you
can create your own |
RangeRestriction<'TAddress> | Specifies a sub-range within index that can be accessed via slicing
(see the |
Module | Description |
RangeRestriction | Provides additional operations for working with the |
Deedle.Indices Namespace
Type | Description |
AsyncSeriesConstruction<'K> | Asynchronous version of |
BoundaryBehavior | Specifies the boundary behavior for the |
IIndex<'K> | An interface that represents index mapping keys of some generic type |
IIndexBuilder | A builder represents various ways of constructing index, either from keys or from
other indices. The operations that build a new index from an existing index also
build |
SeriesConstruction<'K> | Represents a pair of index and vector construction (many of the index operations take/return an index together with a construction command that builds a vector matching with the index, so this type alias makes this more obvious) |
Deedle.Indices.Linear Namespace
Type | Description |
LinearAddressOperations | Implements address operations for linear addressing |
LinearIndex<'K> | An index that maps keys |
LinearIndexBuilder | Index builder object that is associated with |
LinearRangeIndex<'K> | A virtual index that represents a subrange of a specified index. This is useful for windowing operations where we do not want to allocate a new index for each window. This index can be cheaply constructed and it implements many of the standard functions without actually allocating the index (e.g. KeyCount, KeyAt, IsEmpty). For more complex index manipulations (including lookup), an actual index is constructed lazily. |
Deedle.Indices.Virtual Namespace
Type | Description |
VirtualIndexBuilder | Implements |
VirtualOrderedIndex<'K> | Represents an ordered index based on data provided by a virtual source. The index can be used by BigDeedle virtual frames and series, without accessing all data from the data source. The index only evaluates the full key collection when needed. Most of the actual
work is delegated to the |
VirtualOrdinalIndex | Represents an ordinal index based on addressing provided by a virtual source. The index can be used by BigDeedle virtual frames and series, without accessing all data from the data source. |
Deedle.Internal Namespace
Module | Description |
Array | This module contains additional functions for working with arrays.
|
List | This module contains additional functions for working with lists. |
MissingValues | Utility functions for identifying missing values. The The functions in this module are not intended to be called directly. |
ReadOnlyCollection | Provides helper functions for working with |
Seq | This module contains additional functions for working with sequences.
|
Deedle.Keys Namespace
Type | Description |
CustomKey | Helper type that can be used to get |
ICustomKey | Represents a special hierarchical key. This is mainly used in pretty printing (where we want to
get parts of the keys based on levels. |
SimpleLookup<'T> | Implements a simple lookup that matches any multi-level key against a specified array of optional objects (that represent missing/set parts of a key) |
Deedle.Ranges Namespace
Type | Description |
IRangeKeyOperations<'TKey> | A set of operations on keys that you need to implement in order to use the
The operations need to implement the right thing based on the logic of the
keys. So for example if you have one data point every hour, |
Ranges<'T> | Represents a sub-range of an ordinal index. The range can consist of multiple blocks, i.e. [ 0..9; 20..29 ]. The pairs represent indices of first and last element (inclusively) and we also keep size so that we do not have to recalculate it. For more information, see also the documentation for the |
Module | Description |
Ranges | Provides F# functions for working with the
Say, you have daily range |
Deedle.Vectors Namespace
Type | Description |
IBinaryTransform | Represent a transformation that is applied when combining two vectors (because
we are combining untyped |
INaryTransform | Represent a tranformation that is applied when combining N vectors
(This follows exactly the same pattern as |
IRowReaderTransform | When an |
IVectorBuilder | Represents an object that can construct vector values by processing
the "mini-DSL" representation |
KnownLocation | An |
Vector | Type that provides access to creating vectors (represented as arrays) |
VectorConstruction | A "mini-DSL" that describes construction of a vector. Vector can be constructed from various range operations (relocate, drop, slicing, appending), by combination of two vectors or by taking a vector from a list of variables. Notably, vectors can only be constructed from other vectors of the same type
(the Logically, when we apply some index operation, we should get back a polymorphic vector
construction ( |
VectorData<'T> | Provides a way to get the data of an arbitrary vector. This is a concrete type used
by functions that operate on vectors (like |
VectorFillMissing | Specifies how to fill missing values in a vector (when using the
|
VectorHole | Representes a "variable" in the mini-DSL below |
VectorListTransform | A transformation on vector(s) can specified as binary or as N-ary. A binary transformation
can be applied to N elements using |
Deedle.Vectors.ArrayVector Namespace
Type | Description |
ArrayVector<'T> | Vector that stores data in an array. The data is stored using the
|
ArrayVectorBuilder | Implements a builder object ( |
Deedle.Vectors.Virtual Namespace
Type | Description |
DelayedLocation | Represents a vector location that calculates the offset using address operations as needed (typically, we want to avoid this because it might be slow) |
IVirtualVectorSource | Non-generic part of the |
IVirtualVectorSource<'V> | Represents a data source for Big Deedle. The interface is used both as a representation
of data source for |
IVirtualVectorSourceOperation<'R> | A helper type used by non-generic |
RangesAddressOperations<'TKey> | In BigDeedle, we often use |
VirtualAddressingScheme | Represents an addressing scheme associated to virtual vectors. The addresses may be partitioned differently (for different data sources), so this carries an "id" of the data source (to make sure we don't try to mix mismatching data sources) |
VirtualVector<'V> | Creates an |
VirtualVectorBuilder | Implements a builder object ( |
Module | Description |
VirtualVectorSource | Module that implements various helper operations over |
Deedle.Virtual Namespace
Type | Description |
IndexUtils | Helpers that can be used when implementing Lookup |
Virtual | Provides static methods for creating virtual series and virtual frames.
Those provide necessary wrapping around |
Module | Description |
IndexUtilsModule |