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 reflectionbased expansion. 
FrameExtensions 
Contains C# and F# extension methods for the 
FrameStatsExtensions 
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 floatingpoint values, that is 
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. 
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
val past : float
val rets : float


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 framemanipulation 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 nongeneric 
Aggregation 
A nongeneric 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 multilevel 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 
Nongeneric 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 
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 
IVector<'T> 
A generic, typed vector. Represents mapping from addresses to values of type 
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 nongeneric 
F# IndexBuilder implementation 
Set concrete IIndexBuilder implementation 
F# Vector extensions 
Defines nongeneric 
F# Vector extensions (core) 
Module with extensions for generic vector type. Given 
F# VectorBuilder implementation 
Set concrete IVectorBuilder implementation 
Other namespace members
Type  Description 
Diff<'T>  
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 subrange within index that can be accessed via slicing
(see the 
Module  Description 
RangeRestriction 
Provides additional operations for working with the 
StatsInternal 
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 multilevel key against a specified array of optional objects (that represent missing/set parts of a key) 
Deedle.Math Namespace
 Financial Analysis
 Linear Algebra
 Matrix conversions and operators
 Statistical Analysis
 Vector conversions and operators
 Other namespace members
Financial Analysis
Type  Description 
Finance 
Financial analysis 
Linear Algebra
Type  Description 
LinearAlgebra 
Linear algebra on frame using MathNet.Numerics library. 
Matrix conversions and operators
Type  Description 
Frame 
Frame to matrix conversion 
FrameExtensions 
Extension of Frame<'R, 'C> 
Matrix 
Matrix conversions and operators between Frame and Series 
MatrixExtensions 
Extension of Matrix 
SeriesExtensions 
Extension of Series<'C, float> 
Statistical Analysis
Type  Description 
CorrelationMethod 
Correlation method (Pearson or Spearman) 
Stats 
Statistical analysis using MathNet.Numerics 
Vector conversions and operators
Type  Description 
VectorExtensions 
Extension of Vector 
Other namespace members
Type  Description 
Series  
StatsInternal 
Module  Description 
LinearRegression  
PCA 
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 subrange 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 "miniDSL" representation 
KnownLocation 
An 
Vector 
Type that provides access to creating vectors (represented as arrays) 
VectorConstruction 
A "miniDSL" 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 miniDSL below 
VectorListTransform 
A transformation on vector(s) can specified as binary or as Nary. 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 
Nongeneric 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 nongeneric 
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 
FSharp.Data Namespace
Type  Description 
Http 
Utilities for working with network via HTTP. Includes methods for downloading resources with specified headers, query parameters and HTTP body 
HttpRequestBody 
The body to send in an HTTP request 
HttpResponse 
The response returned by an HTTP request 
HttpResponseBody 
The response body returned by an HTTP request 
HttpResponseWithStream 
The response returned by an HTTP request with direct access to the response stream 
MultipartItem 
Module  Description 
HttpContentTypes 
Constants for common HTTP content types 
HttpEncodings 
Constants for common HTTP encodings 
HttpMethod 
The method to use in an HTTP request 
HttpRequestHeaders 
Headers that can be sent in an HTTP request 
HttpResponseHeaders 
Headers that can be received in an HTTP response 
HttpStatusCodes 
Status codes that can be received in an HTTP response 
MimeTypes 