IIndex<'K>

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 member	Description
`x.AddressAt(arg1)` Signature: int64 -> Address Modifiers: abstract	Return an address that represents the specified offset
`x.AddressingScheme` 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). CompiledName: `get_AddressingScheme`
`x.AddressOperations` 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. CompiledName: `get_AddressOperations`
`x.Builder` 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) CompiledName: `get_Builder`
`x.Comparer` Signature: Comparer<'K> Modifiers: abstract	Returns a comparer associated with the values used by the current index. CompiledName: `get_Comparer`
`x.IsEmpty` 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. CompiledName: `get_IsEmpty`
`x.IsOrdered` Signature: bool Modifiers: abstract	Returns `true` if the index is ordered and `false` otherwise CompiledName: `get_IsOrdered`
`x.KeyAt(arg1)` Signature: Address -> 'K Modifiers: abstract	Performs reverse lookup - and returns key for a specified address
`x.KeyCount` Signature: int64 Modifiers: abstract	Returns the number of keys in the index CompiledName: `get_KeyCount`
`x.KeyRange` Signature: 'K * 'K Modifiers: abstract	Returns the minimal and maximal key associated with the index. (the operation may fail for unordered indices) CompiledName: `get_KeyRange`
`x.Keys` Signature: ReadOnlyCollection<'K> Modifiers: abstract	Returns a (fully evaluated) collection with all keys in the index CompiledName: `get_Keys`
`x.KeySequence` Signature: seq<'K> Modifiers: abstract	Returns a lazy sequence that iterates over all keys in the index CompiledName: `get_KeySequence`
`x.Locate(key)` Signature: key:'K -> Address Modifiers: abstract
`x.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)
`x.Mappings` Signature: seq<KeyValuePair<'K,Address>> Modifiers: abstract	Returns all key-address mappings in the index CompiledName: `get_Mappings`