Deedle

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 type. Data can be aggregate using floating windows or chunks of a specified size or by specifying a condition on two keys (i.e. end a window/chunk when the condition no longer holds).

A non-generic type that simplifies the construction of Aggregation<K> values from C#. It provides methods for constructing different kinds of aggregation strategies for ordered series.

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 (AtBeginning) or at the end (AtEnding) or skipped (Skip). For chunking, combinations are allowed too - to skip incomplete chunk at the beginning, use Boundary.Skip ||| Boundary.AtBeginning.

Represents a segment of a series or sequence. The value is returned from various functions that aggregate data into chunks or floating windows. The Complete case represents complete segment (e.g. of the specified size) and Boundary represents segment at the boundary (e.g. smaller than the required size).

Represents a kind of DataSegment<T>. See that type for more information.

This type exposes a single static method DelayedSeries.Create that can be used for constructing data series (of type Series<K, V>) with lazily loaded data. You can use this functionality to create series that represents e.g. an entire price history in a database, but only loads data that are actually needed. For more information see the lazy data loading tutorial.

Example

Assuming we have a function generate lo hi that generates data in the specified DateTime range, we can create lazy series as follows:

let ls = DelayedSeries.Create(min, max, fun (lo, lob) (hi, hib) -> 
  async { 
    printfn "Query: %A - %A" (lo, lob) (hi, hib)
    return generate lo hi })

The arguments min and max specfify the complete range of the series. The function passed to Create is called with minimal and maximal required key (lo and hi) and with two values that specify boundary behaviour.

Specifies in which direction should we look when performing operations such as Series.Pairwise.

A frame contains one Index, with multiple Vecs (because this is dynamic, we need to store them as IVec)

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)

Some comment

Represents a special lookup. This can be used to support hierarchical or duplicate keys in an index. A key type K can come with associated ICustomLookup<K> to provide customized pattern matching (equality testing)

An empty interface that is implemented by Frame<'R, 'C>. The purpose of the interface is to allow writing code that works on arbitrary data frames, although you

Represents an untyped series with keys of type K and values of some unknown type (This type should not generally be used directly, but it can be used when you need to write code that works on a sequence of series of heterogeneous types).

A generic, typed vector. Represents mapping from addresses to values of type T. The vector provides a minimal interface that is required by series and can be implemented in a number of ways to provide vector backed by database or an alternative representation of data.

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 System.Type.

Type that provides access to creating indices (represented as LinearIndex values)

This enumeration specifies joining behavior for Join method provided by Series and Frame. Outer join unions the keys (and may introduce missing values), inner join takes the intersection of keys; left and right joins take the keys of the first or the second series/frame.

Represents different behaviors of key lookup in series. For unordered series, the only available option is Lookup.Exact which finds the exact key - methods fail or return missing value if the key is not available in the index. For ordered series Lookup.NearestGreater finds the first greater key (e.g. later date) with a value. Lookup.NearestSmaller searches for the first smaller key.

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 KeyNotFoundException is thrown

Value type that represents a potentially missing value. This is similar to System.Nullable<T>, but does not restrict the contained value to be a value type, so it can be used for storing values of any types. When obtained from DataFrame<R, C> or Series<K, T>, the Value will never be Double.NaN or null (but this is not, in general, checked when constructing the value).

The type is only used in C#-friendly API. F# operations generally use expose standard F# option<T> type instead. However, there the OptionalValue module contains helper functions for using this type from F# as well as Missing and Present active patterns.

Non-generic type that makes it easier to create OptionalValue<T> values from C# by benefiting the type inference for generic method invocations.

Extension methods for working with optional values from C#. These make it easier to provide default values and convert optional values to Nullable (when the contained value is value type)

The type Series<K, V> represents a data series consisting of values V indexed by keys K. The keys of a series may or may not be ordered

Represents a value or an exception. This type is used by functions such as Series.tryMap and Frame.tryMap to capture the result of a lambda function, which may be either a value or an exception. The type is a discriminated union, so it can be processed using F# pattern matching, or using Value, HasValue and Exception properties

This enumeration specifeis the behavior of Union operation on series when there are overlapping keys in two series that are being unioned. The options include prefering values from the left/right series or throwing an exception when both values are available.

A type alias for the OptionalValue<T> type. The type alias can be used to make F# type definitions that use optional values directly more succinct.

A type alias for the TryValue<T> type. The type alias can be used to make F# type declarations that explcitly handle exceptions more succinct.

Asynchronous version of SeriesConstruction<'K>. Returns a workflow that evaluates the index, together with a construction to apply (asynchronously) on vectors

Specifies the boundary behavior for the IIndexBuilder.GetRange operation (whether the boundary elements should be included or not)

An interface that represents index mapping keys of some generic type T to locations of address Address. The IIndex<K> contains minimal set of operations that have to be supported by an index. This type should be only used directly when extending the DataFrame library and adding a new way of storing or loading data. Values of this type are constructed using the associated IIndexBuilder type.

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 VectorConstruction which specifies how to transform vectors aligned with the previous index to match the new index. The methods generally take VectorConstruction as an input, apply necessary transformations to it and return a new VectorConstruction.

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)

An index that maps keys K to offsets Address. The keys cannot be duplicated. The construction checks if the keys are ordered (using the provided or the default comparer for K) and disallows certain operations on unordered indices.

Index builder object that is associated with LinearIndex<K> type. The builder provides operations for manipulating linear indices (and the associated vectors).

An internal exception that is used to handle the case when comparison fails (even though the type implements IComparable and everything...)

Helper type that can be used to get ICustomKey for any object (including objects that actually implement the interface and tuples)

Represents a special hierarchical key. This is mainly used in pretty printing (where we want to get parts of the keys based on levels. CustomKey.Get provides a way of getting ICustomKey.

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)

Represents an object that can construct vector values by processing the "mini-DSL" representation VectorConstruction.

Represent a transformation that is applied when combining two vectors (because we are combining untyped IVector values, the transformation is also untyped)

Type that provides access to creating vectors (represented as arrays)

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 Combine operation requires this - even though that one could be made more general). This is an intentional choice to make the representation simpler.

Logically, when we apply some index operation, we should get back a polymorphic vector construction (\forall T. VectorConstruction<T>) that can be applied to variuous different vector types. That would mean adding some more types, so we just model vector construction as an untyped operation and the typing is resquired by the Build method of the vector builder.

Provides a way to get the data of an arbitrary vector. This is a concrete type used by functions that operate on vectors (like Series.sum, etc.). The vector may choose to return the data as ReadOnlyCollection (with or without N/A values) which is more efficient to use or as a lazy sequence (slower, but more general).

Specifies how to fill missing values in a vector (when using the VectorConstruction.FillMissing command). This can only fill missing values using strategy that does not require access to index keys - either using constant or by propagating values.

Representes a "variable" in the mini-DSL below

Represents a range inside a vector

Vector that stores data in an array. The data is stored using the ArrayVectorData<'T> type (discriminated union)

Implements a builder object (IVectorBuilder) for creating vectors of type ArrayVector<'T>. This includes operations such as appending, relocating values, creating vectors from arrays etc. The vector builder automatically switches between the two possible representations of the vector - when a missing value is present, it uses ArrayVectorData.VectorOptional, otherwise it uses ArrayVectorData.VectorNonOptional.