Namespace: Deedle.Indices

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.

Instance members

Instance memberDescription
Signature: int64 -> Address
Modifiers: abstract

Return an address that represents the specified offset

Signature: IAddressingScheme
Modifiers: abstract

Returns the addressing scheme of the index. When creating a series or a frame this is compared for equality with the addressing scheme of the vector(s).

Signature: IAddressOperations
Modifiers: abstract

Returns the address operations associated with this index. The addresses of the index are not necesarilly continuous integers from 0. This provides some operations that can be used for implementing generic operations over any kind of indices.

Signature: IIndexBuilder
Modifiers: abstract

Returns an index builder that can be used for constructing new indices of the same kind as the current index (e.g. a lazy index returns a lazy index builder)

Signature: Comparer<'K>
Modifiers: abstract

Returns a comparer associated with the values used by the current index.

Signature: bool
Modifiers: abstract

Returns whether the specified index is empty. This is equivalent to testing if Keys are empty, but it does not have to evaluate delayed index.

Signature: bool
Modifiers: abstract

Returns true if the index is ordered and false otherwise

Signature: Address -> 'K
Modifiers: abstract

Performs reverse lookup - and returns key for a specified address

Signature: int64
Modifiers: abstract

Returns the number of keys in the index

Signature: 'K * 'K
Modifiers: abstract

Returns the minimal and maximal key associated with the index. (the operation may fail for unordered indices)

Signature: ReadOnlyCollection<'K>
Modifiers: abstract

Returns a (fully evaluated) collection with all keys in the index

Signature: seq<'K>
Modifiers: abstract

Returns a lazy sequence that iterates over all keys in the index

Signature: key:'K -> Address
Modifiers: abstract
Lookup(key, lookup, condition)
Signature: (key:'K * lookup:Lookup * condition:(Address -> bool)) -> OptionalValue<'K * Address>
Modifiers: abstract

Find the address associated with the specified key, or with the nearest key as specified by the lookup argument. The condition function is called when searching for keys to ask the caller whether the address should be returned (or whether to continue searching). This is used when searching for previous element in a series (where we need to check if a value at the address is available)

Signature: seq<KeyValuePair<'K,Address>>
Modifiers: abstract

Returns all key-address mappings in the index

Fork me on GitHub