Deedle


Series

Namespace: Deedle

The Series module provides an F#-friendly API for working with data and time series. The API follows the usual design for collection-processing in F#, so the functions work well with the pipelining (|>) operator. For example, given a series with ages, we can use Series.filterValues to filter outliers and then Stats.mean to calculate the mean:

1: 
2: 
3: 
ages
|> Series.filterValues (fun v -> v > 0.0 && v < 120.0)
|> Stats.mean

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:

1: 
2: 
3: 
ages
  .Where(kvp => kvp.Value > 0.0 && kvp.Value < 120.0)
  .Mean()

For more information about similar frame-manipulation functions, see the Frame module. For more information about C#-friendly extensions, see SeriesExtensions. The functions in the Series module are grouped in a number of categories and documented below.

Table of contents

Accessing series data and lookup 

Functions in this category provide access to the values in the series.

  • The term observation is used for a key value pair in the series.
  • When working with a sorted series, it is possible to perform lookup using keys that are not present in the series - you can specify to search for the previous or next available value using lookup behavior.
  • Functions such as get and getAll have their counterparts lookup and lookupAll that let you specify lookup behavior.
  • For most of the functions that may fail, there is a try[Foo] variant that returns None instead of failing.
  • Functions with a name ending with At perform lookup based on the absolute integer offset (and ignore the keys of the series)

Functions and values

Function or valueDescription
countKeys series
Signature: series:Series<'K,'T> -> int
Type parameters: 'K, 'T

Returns the total number of keys in the specified series. This returns the total length of the series, including keys for which there is no value available.

countValues series
Signature: series:Series<'K,'T> -> int
Type parameters: 'K, 'T

Returns the total number of values in the specified series. This excludes missing values or not available values (such as values created from null, Double.NaN, or those that are missing due to outer join etc.).

firstKey series
Signature: series:Series<'K,'V> -> 'K
Type parameters: 'K, 'V

Returns the first key of the series, or throws exception if one doesn't exist

firstValue series
Signature: series:Series<'K,'V> -> 'V
Type parameters: 'K, 'V

Returns the first value of the series. This fails if the first value is missing.

get key series
Signature: key:'K -> series:Series<'K,'T> -> 'T
Type parameters: 'K, 'T

Get the value for the specified key. Uses exact lookup semantics for key lookup - use lookup for more options

getAll keys series
Signature: keys:seq<'K> -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Create a new series that contains values for all provided keys. Uses exact lookup semantics for key lookup - use lookupAll for more options

Parameters

  • keys - A sequence of keys that will form the keys of the retunred sequence
getAt index series
Signature: index:int -> series:Series<'K,'T> -> 'T
Type parameters: 'K, 'T

Returns the value at the specified (integer) offset.

has key series
Signature: key:'K -> series:Series<'K,'T> -> bool
Type parameters: 'K, 'T

Returns true when the series contains value for the specified key (This is useful for checking prior to performing a computation)

hasAll keys series
Signature: keys:seq<'K> -> series:Series<'K,'T> -> bool
Type parameters: 'K, 'T

Returns true when the series contains value for all of the specified keys (This is useful for checking prior to performing a computation)

hasNone keys series
Signature: keys:seq<'K> -> series:Series<'K,'T> -> bool
Type parameters: 'K, 'T

Returns true when the series does not contains value for any of the specified keys (This is useful for checking prior to performing a computation)

hasNot key series
Signature: key:'K -> series:Series<'K,'T> -> bool
Type parameters: 'K, 'T

Returns true when the series does not contains value for the specified key (This is useful for checking prior to performing a computation)

hasSome keys series
Signature: keys:seq<'K> -> series:Series<'K,'T> -> bool
Type parameters: 'K, 'T

Returns true when the series contains value for some of the specified keys (This is useful for checking prior to performing a computation)

keys series
Signature: series:Series<'K,'T> -> seq<'K>
Type parameters: 'K, 'T

Returns the keys of the series as a sequence

lastKey series
Signature: series:Series<'K,'V> -> 'K
Type parameters: 'K, 'V

Returns the last key of the series, or throws exception if one doesn't exist

lastValue series
Signature: series:Series<'K,'V> -> 'V
Type parameters: 'K, 'V

Returns the last value of the series. This fails if the last value is missing.

lookup key lookup series
Signature: key:'K -> lookup:Lookup -> series:Series<'K,'T> -> 'T
Type parameters: 'K, 'T

Get the value for the specified key. Use the specified lookup semantics - for exact matching, use get

lookupAll keys lookup series
Signature: keys:seq<'K> -> lookup:Lookup -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Create a new series that contains values for all provided keys. Use the specified lookup semantics - for exact matching, use getAll

Parameters

  • keys - A sequence of keys that will form the keys of the retunred sequence
  • lookup - Lookup behavior to use when the value at the specified key does not exist
observations series
Signature: series:Series<'K,'T> -> seq<'K * 'T>
Type parameters: 'K, 'T

Return observations with available values. The operation skips over all keys with missing values (such as values created from null, Double.NaN, or those that are missing due to outer join etc.).

observationsAll series
Signature: series:Series<'K,'T> -> seq<'K * 'T option>
Type parameters: 'K, 'T

Returns all keys from the sequence, together with the associated (optional) values.

sample keys series
Signature: keys:seq<'K> -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Sample an (ordered) series by finding the value at the exact or closest prior key for some new sequence of keys.

Parameters

  • keys - A sequence of keys that will form the keys of the retunred sequence
tryFirstValue series
Signature: series:Series<'K,'V> -> 'V option
Type parameters: 'K, 'V

Returns the last value of the series if one exists.

tryGet key series
Signature: key:'K -> series:Series<'K,'T> -> 'T option
Type parameters: 'K, 'T

Get the value for the specified key. Returns None when the key does not exist or the value is missing. Uses exact lookup semantics for key lookup - use tryLookup for more options

tryGetAt index series
Signature: index:int -> series:Series<'K,'T> -> 'T option
Type parameters: 'K, 'T

Returns the value at the specified (integer) offset, or None if the value is missing.

tryLastValue series
Signature: series:Series<'K,'V> -> 'V option
Type parameters: 'K, 'V

Returns the last value of the series if one exists.

tryLookup key lookup series
Signature: key:'K -> lookup:Lookup -> series:Series<'K,'T> -> 'T option
Type parameters: 'K, 'T

Attempts to get the value for the specified key. If the value is not available, None is returned. Use the specified lookup semantics - for exact matching, use tryGet.

tryLookupObservation key lookup series
Signature: key:'K -> lookup:Lookup -> series:Series<'K,'T> -> ('K * 'T) option
Type parameters: 'K, 'T

Attempts to get an observation (key value pair) based on the specified key. The search uses the specified lookup semantics and so the returned key may differ from the key searched for. If the value is not available, None is returned.

values series
Signature: series:Series<'K,'T> -> seq<'T>
Type parameters: 'K, 'T

Returns the (non-missing) values of the series as a sequence

valuesAll series
Signature: series:Series<'K,'T> -> seq<'T option>
Type parameters: 'K, 'T

Returns the series values (both missing and present) as a sequence

Grouping, windowing and chunking 

This category includes functions that group data from a series in some way. Two key concepts here are window and chunk. Window refers to (overlapping) sliding windows over the input series while chunk refers to non-overlapping blocks of the series.

The boundary behavior can be specified using the Boundary flags. The value Skip means that boundaries (incomplete windows or chunks) should be skipped. The value AtBeginning and AtEnding can be used to define at which side should the boundary be returned (or skipped). For chunking, AtBeginning ||| Skip makes sense and it means that the incomplete chunk at the beginning should be skipped (aligning the last chunk with the end).

The behavior may be specified in a number of ways (which is reflected in the name): - dist - using an absolute distance between the keys - while - using a condition on the first and last key - size - by specifying the absolute size of the window/chunk

The functions ending with Into take a function to be applied to the window/chunk. The functions window, windowInto and chunk, chunkInto are simplified versions that take a size. There is also pairwise function for sliding window of size two.

Functions and values

Function or valueDescription
aggregate aggregation keySelector series
Signature: aggregation:Aggregation<'K> -> keySelector:(DataSegment<Series<'K,'T>> -> 'TNewKey) -> series:Series<'K,'T> -> Series<'TNewKey,DataSegment<Series<'K,'T>>>
Type parameters: 'K, 'T, 'TNewKey

Aggregates an ordered series using the method specified by Aggregation<K> and returns the windows or chunks as nested series. A key for each window or chunk is selected using the specified keySelector.

Parameters

  • aggregation - Specifies the aggregation method using Aggregation<K>. This is a discriminated union listing various chunking and windowing conditions.
  • keySelector - A function that is called on each chunk to obtain a key.
  • series - The input series to be aggregated.
aggregateInto (...)
Signature: aggregation:Aggregation<'K> -> keySelector:(DataSegment<Series<'K,'T>> -> 'TNewKey) -> f:(DataSegment<Series<'K,'T>> -> OptionalValue<'R>) -> series:Series<'K,'T> -> Series<'TNewKey,'R>
Type parameters: 'K, 'T, 'TNewKey, 'R

Aggregates an ordered series using the method specified by Aggregation<K> and then applies the provided value selector f on each window or chunk to produce the result which is returned as a new series. A key for each window or chunk is selected using the specified keySelector.

Parameters

  • aggregation - Specifies the aggregation method using Aggregation<K>. This is a discriminated union listing various chunking and windowing conditions.
  • keySelector - A function that is called on each chunk to obtain a key.
  • f - A value selector function that is called to aggregate each chunk or window.
  • series - The input series to be aggregated.
chunk size series
Signature: size:int -> series:Series<'K,'T> -> Series<'K,Series<'K,'T>>
Type parameters: 'K, 'T

Aggregates the input into a series of adacent chunks and returns the produced chunks as a nested series. The key in the new series is the last key of the chunk. This function skips incomplete chunks - you can use Series.chunkSize for more options.

Parameters

  • size - The size of the chunk.
  • series - The input series to be aggregated.
chunkDist distance series
Signature: distance:^D -> series:Series<^K,'T> -> Series<^K,Series<^K,'T>>
Type parameters: ^D, ^K, 'T

Aggregates the input into a series of adacent chunks. A chunk is started once the distance between the first and the last key of a previous chunk is greater than the specified distance. The chunks are then returned as a nested series. The key of each chunk is the key of the first element in the chunk.

Parameters

  • distance - The maximal allowed distance between keys of a chunk. Note that this is an inline function - there must be - operator defined between distance and the keys of the series.
  • series - The input series to be aggregated.
chunkDistInto distance f series
Signature: distance:^D -> f:(Series<^K,'T> -> 'R) -> series:Series<^K,'T> -> Series<^K,'R>
Type parameters: ^D, ^K, 'T, 'R

Aggregates the input into a series of adacent chunks. A chunk is started once the distance between the first and the last key of a previous chunk is greater than the specified distance. Each chunk is then aggregated into a value using the specified function f. The key of each chunk is the key of the first element in the chunk.

Parameters

  • distance - The maximal allowed distance between keys of a chunk. Note that this is an inline function - there must be - operator defined between distance and the keys of the series.
  • f - A value selector that is called to aggregate each chunk.
  • series - The input series to be aggregated.
chunkInto size f series
Signature: size:int -> f:(Series<'K,'T> -> 'R) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'K, 'T, 'R

Aggregates the input into a series of adacent chunks and then applies the provided value selector f on each chunk to produce the result which is returned as a new series. The key in the new series is the last key of the chunk. This function skips incomplete chunks - you can use Series.chunkSizeInto for more options.

Parameters

  • size - The size of the chunk.
  • series - The input series to be aggregated.
chunkSize (arg1, arg2) series
Signature: (int * Boundary) -> series:Series<'K,'T> -> Series<'K,Series<'K,'T>>
Type parameters: 'K, 'T

Aggregates the input into a series of adacent chunks using the specified size and boundary behavior and returns the produced chunks as a nested series. The key is the first key of the chunk, unless boundary behavior has Boundary.AtBeginning flag (in which case it is the last key).

Parameters

  • bounds - Specifies the chunk size and bounary behavior. The boundary behavior can be Boundary.Skip (meaning that no incomplete chunks are produced), Boundary.AtBeginning (meaning that incomplete chunks are produced at the beginning) or Boundary.AtEnding (to produce incomplete chunks at the end of series)
  • series - The input series to be aggregated.
chunkSizeInto (arg1, arg2) f series
Signature: (int * Boundary) -> f:(DataSegment<Series<'K,'T>> -> 'R) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'K, 'T, 'R

Aggregates the input into a series of adacent chunks using the specified size and boundary behavior and then applies the provided value selector f on each chunk to produce the result which is returned as a new series. The key is the first key of the chunk, unless boundary behavior has Boundary.AtBeginning flag (in which case it is the last key).

Parameters

  • bounds - Specifies the chunk size and bounary behavior. The boundary behavior can be Boundary.Skip (meaning that no incomplete chunks are produced), Boundary.AtBeginning (meaning that incomplete chunks are produced at the beginning) or Boundary.AtEnding (to produce incomplete chunks at the end of series)
  • f - A value selector that is called to aggregate each chunk.
  • series - The input series to be aggregated.
chunkWhile cond series
Signature: cond:('K -> 'K -> bool) -> series:Series<'K,'T> -> Series<'K,Series<'K,'T>>
Type parameters: 'K, 'T

Aggregates the input into a series of adacent chunks based on a condition on keys. A chunk is started once the specified cond function returns false when called on the first and the last key of the previous chunk. The chunks are then returned as a nested series. The key of each chunk is the key of the first element in the chunk.

Parameters

  • cond - A function that is called on the first and the last key of a chunk to determine when a window should end.
  • series - The input series to be aggregated.
chunkWhileInto cond f series
Signature: cond:('K -> 'K -> bool) -> f:(Series<'K,'T> -> '?553499) -> series:Series<'K,'T> -> Series<'K,'?553499>
Type parameters: 'K, 'T, '?553499

Aggregates the input into a series of adacent chunks based on a condition on keys. A chunk is started once the specified cond function returns false when called on the first and the last key of the previous chunk. Each chunk is then aggregated into a value using the specified function f. The key of each chunk is the key of the first element in the chunk.

Parameters

  • cond - A function that is called on the first and the last key of a chunk to determine when a window should end.
  • f - A value selector that is called to aggregate each chunk.
  • series - The input series to be aggregated.
groupBy keySelector series
Signature: keySelector:('K -> 'T -> 'TNewKey) -> series:Series<'K,'T> -> Series<'TNewKey,Series<'K,'T>>
Type parameters: 'K, 'T, 'TNewKey

Groups a series (ordered or unordered) using the specified key selector (keySelector) and then returns a series of (nested) series as the result. The outer series is indexed by the newly produced keys, the nested series are indexed with the original keys.

Parameters

  • keySelector - Generates a new key that is used for aggregation, based on the original key and value. The new key must support equality testing.
  • series - An input series to be grouped.
groupInto keySelector f series
Signature: keySelector:('K -> 'T -> 'TNewKey) -> f:('TNewKey -> Series<'K,'T> -> 'TNewValue) -> series:Series<'K,'T> -> Series<'TNewKey,'TNewValue>
Type parameters: 'K, 'T, 'TNewKey, 'TNewValue

Groups a series (ordered or unordered) using the specified key selector (keySelector) and then aggregates each group into a single value, returned in the resulting series, using the provided f function.

Parameters

  • keySelector - Generates a new key that is used for aggregation, based on the original key and value. The new key must support equality testing.
  • f - A function to aggregate each group of collected elements.
  • series - An input series to be grouped.
pairwise series
Signature: series:Series<'K,'T> -> Series<'K,('T * 'T)>
Type parameters: 'K, 'T

Returns a series containing the predecessor and an element for each input, except for the first one. The returned series is one key shorter (it does not contain a value for the first key).

Parameters

  • series - The input series to be aggregated.

Example

1: 
2: 
3: 
let input = series [ 1 => 'a'; 2 => 'b'; 3 => 'c']
let res = input |> Series.pairwise
res = series [2 => ('a', 'b'); 3 => ('b', 'c') ]
val input : obj

Full name: docs.input
val res : obj

Full name: docs.res
pairwiseWith f series
Signature: f:('K -> 'T * 'T -> '?553523) -> series:Series<'K,'T> -> Series<'K,'?553523>
Type parameters: 'K, 'T, '?553523

Aggregates the input into pairs containing the predecessor and an element for each input, except for the first one. Then calls the specified aggregation function f with a tuple and a key. The returned series is one key shorter (it does not contain a value for the first key).

Parameters

  • f - A function that is called for each pair to produce result in the final series.
  • series - The input series to be aggregated.
window size series
Signature: size:int -> series:Series<'K,'T> -> Series<'K,Series<'K,'T>>
Type parameters: 'K, 'T

Creates a sliding window using the specified size and returns the produced windows as a nested series. The key in the new series is the last key of the window. This function skips incomplete chunks - you can use Series.windowSize for more options.

Parameters

  • size - The size of the sliding window.
  • series - The input series to be aggregated.
windowDist distance series
Signature: distance:^D -> series:Series<^K,'T> -> Series<^K,Series<^K,'T>>
Type parameters: ^D, ^K, 'T

Creates a sliding window based on distance between keys. A window is started at each input element and ends once the distance between the first and the last key is greater than the specified distance. The windows are then returned as a nested series. The key of each window is the key of the first element in the window.

Parameters

  • distance - The maximal allowed distance between keys of a window. Note that this is an inline function - there must be - operator defined between distance and the keys of the series.
  • series - The input series to be aggregated.
windowDistInto distance f series
Signature: distance:^?553465 -> f:(Series<^K,'T> -> '?553468) -> series:Series<^K,'T> -> Series<^K,'?553468>
Type parameters: ^?553465, ^K, 'T, '?553468

Creates a sliding window based on distance between keys. A window is started at each input element and ends once the distance between the first and the last key is greater than the specified distance. Each window is then aggregated into a value using the specified function f. The key of each window is the key of the first element in the window.

Parameters

  • distance - The maximal allowed distance between keys of a window. Note that this is an inline function - there must be - operator defined between distance and the keys of the series.
  • f - A function that is used to aggregate each window into a single value.
  • series - The input series to be aggregated.
windowInto size f series
Signature: size:int -> f:(Series<'K,'T> -> 'R) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'K, 'T, 'R

Creates a sliding window using the specified size and then applies the provided value selector f on each window to produce the result which is returned as a new series. This function skips incomplete chunks - you can use Series.windowSizeInto for more options.

Parameters

  • size - The size of the sliding window.
  • series - The input series to be aggregated.
  • f - A function that is called on each created window.
windowSize (arg1, arg2) series
Signature: (int * Boundary) -> series:Series<'K,'T> -> Series<'K,Series<'K,'T>>
Type parameters: 'K, 'T

Creates a sliding window using the specified size and boundary behavior and returns the produced windows as a nested series. The key is the last key of the window, unless boundary behavior is Boundary.AtEnding (in which case it is the first key).

Parameters

  • bounds - Specifies the window size and bounary behavior. The boundary behavior can be Boundary.Skip (meaning that no incomplete windows are produced), Boundary.AtBeginning (meaning that incomplete windows are produced at the beginning) or Boundary.AtEnding (to produce incomplete windows at the end of series)
  • series - The input series to be aggregated.
windowSizeInto (arg1, arg2) f series
Signature: (int * Boundary) -> f:(DataSegment<Series<'K,'T>> -> 'R) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'K, 'T, 'R

Creates a sliding window using the specified size and boundary behavior and then applies the provided value selector f on each window to produce the result which is returned as a new series. The key is the last key of the window, unless boundary behavior is Boundary.AtEnding (in which case it is the first key).

Parameters

  • bounds - Specifies the window size and bounary behavior. The boundary behavior can be Boundary.Skip (meaning that no incomplete windows are produced), Boundary.AtBeginning (meaning that incomplete windows are produced at the beginning) or Boundary.AtEnding (to produce incomplete windows at the end of series)
  • f - A value selector that is called to aggregate each window.
  • series - The input series to be aggregated.
windowWhile cond series
Signature: cond:('K -> 'K -> bool) -> series:Series<'K,'T> -> Series<'K,Series<'K,'T>>
Type parameters: 'K, 'T

Creates a sliding window based on a condition on keys. A window is started at each input element and ends once the specified cond function returns false when called on the first and the last key of the window. The windows are then returned as a nested series. The key of each window is the key of the first element in the window.

Parameters

  • cond - A function that is called on the first and the last key of a window to determine when a window should end.
  • series - The input series to be aggregated.
windowWhileInto cond f series
Signature: cond:('K -> 'K -> bool) -> f:(Series<'K,'T> -> '?553476) -> series:Series<'K,'T> -> Series<'K,'?553476>
Type parameters: 'K, 'T, '?553476

Creates a sliding window based on a condition on keys. A window is started at each input element and ends once the specified cond function returns false when called on the first and the last key of the window. Each window is then aggregated into a value using the specified function f. The key of each window is the key of the first element in the window.

Parameters

  • cond - A function that is called on the first and the last key of a window to determine when a window should end.
  • f - A function that is used to aggregate each window into a single value.
  • series - The input series to be aggregated.

Hierarchical index operations 

When the key of a series is tuple, the elements of the tuple can be treated as multiple levels of a index. For example Series<'K1 * 'K2, 'V> has two levels with keys of types 'K1 and 'K2 respectively.

The functions in this cateogry provide a way for aggregating values in the series at one of the levels. For example, given a series input indexed by two-element tuple, you can calculate mean for different first-level values as follows:

1: 
input |> applyLevel fst Stats.mean

Note that the Stats module provides helpers for typical statistical operations, so the above could be written just as input |> Stats.levelMean fst.

val fst : tuple:('T1 * 'T2) -> 'T1

Full name: Microsoft.FSharp.Core.Operators.fst

Functions and values

Function or valueDescription
applyLevel level op series
Signature: level:('K1 -> 'K2) -> op:(Series<'K1,'V> -> 'R) -> series:Series<'K1,'V> -> Series<'K2,'R>
Type parameters: 'K1, 'K2, 'V, 'R

Groups the elements of the input series in groups based on the keys produced by level and then aggregates series representing each group using the specified function op. The result is a new series containing the aggregates of each group.

This operation is designed to be used with hierarchical indexing.

Parameters

  • series - An input series to be aggregated
  • op - A function that takes a series and produces an aggregated result
  • level - A delegate that returns a new group key, based on the key in the input series
applyLevelOptional level op series
Signature: level:('K1 -> 'K2) -> op:(Series<'K1,'V> -> 'R option) -> series:Series<'K1,'V> -> Series<'K2,'R>
Type parameters: 'K1, 'K2, 'V, 'R

Groups the elements of the input series in groups based on the keys produced by level and then aggregates series representing each group using the specified function op. The result is a new series containing the aggregates of each group. The result of a group may be None, in which case the group will have no representation in the resulting series.

This operation is designed to be used with hierarchical indexing.

Parameters

  • series - An input series to be aggregated
  • op - A function that takes a series and produces an optional aggregated result
  • level - A delegate that returns a new group key, based on the key in the input series
reduceLevel level op series
Signature: level:('K1 -> 'K2) -> op:('T -> 'T -> 'T) -> series:Series<'K1,'T> -> Series<'K2,'T>
Type parameters: 'K1, 'K2, 'T

Groups the elements of the input series in groups based on the keys produced by level and then aggregates elements in each group using the specified function op. The result is a new series containing the aggregates of each group.

This operation is designed to be used with hierarchical indexing.

Parameters

  • series - An input series to be aggregated
  • op - A function that is used to aggregate elements of each group
  • level - A delegate that returns a new group key, based on the key in the input series

Joining, merging and zipping 

Given two series, there are two ways to combine the values. If the keys in the series are not overlapping (or you want to throw away values from one or the other series), then you can use merge or mergeUsing. To merge more than 2 series efficiently, use the mergeAll function, which has been optimized for large number of series.

If you want to align two series, you can use the zipping operation. This aligns two series based on their keys and gives you tuples of values. The default behavior (zip) uses outer join and exact matching. For ordered series, you can specify other forms of key lookups (e.g. find the greatest smaller key) using zipAlign. functions ending with Into are generally easier to use as they call a specified function to turn the tuple (of possibly missing values) into a new value.

For more complicated behaviors, it is often convenient to use joins on frames instead of working with series. Create two frames with single columns and then use the join operation. The result will be a frame with two columns (which is easier to use than series of tuples).

Functions and values

Function or valueDescription
merge series1 series2
Signature: series1:Series<'K,'V> -> series2:Series<'K,'V> -> Series<'K,'V>
Type parameters: 'K, 'V

Merge two series with distinct keys. When the same key with a value occurs in both series, an exception is thrown. In that case, you can use mergeUsing, which allows specifying merging behavior.

mergeAll series
Signature: series:seq<Series<'K,'V>> -> Series<'K,'V>
Type parameters: 'K, 'V

Merge multiple series with distinct keys. When the same key with a value occurs in two of the series, an exception is thrown. This function is efficient even when the number of series to be merged is large.

mergeUsing behavior series1 series2
Signature: behavior:UnionBehavior -> series1:Series<'K,'V> -> series2:Series<'K,'V> -> Series<'K,'V>
Type parameters: 'K, 'V

Merge two series with possibly overlapping keys. The behavior parameter specifies how to handle situation when a value is definedin both series.

Parameters

  • behavior specifies how to handle values available in both series. You can use UnionBehavior.Exclusive to throw an exception, or UnionBehavior.PreferLeft and UnionBehavior.PreferRight to prefer values from the first or the second series, respectively.
  • series1 - the first (left) series to be merged
  • series2 - the second (right) series to be merged
zip series1 series2
Signature: series1:Series<'K,'V1> -> series2:Series<'K,'V2> -> Series<'K,('V1 opt * 'V2 opt)>
Type parameters: 'K, 'V1, 'V2

Align and zip two series using outer join and exact key matching. The function returns a series of tuples where both elements may be missing. As a result, it is often easier to use join on frames instead.

zipAlign kind lookup series1 series2
Signature: kind:JoinKind -> lookup:Lookup -> series1:Series<'K,'V1> -> series2:Series<'K,'V2> -> Series<'K,('V1 opt * 'V2 opt)>
Type parameters: 'K, 'V1, 'V2

Align and zip two series using the specified joining mechanism and key matching. The function returns a series of tuples where both elements may be missing. As a result, it is often easier to use join on frames instead.

Parameters

  • kind specifies the kind of join you want to use (left, right, inner or outer). For inner join, it is better to use zipInner instead.
  • lookup specifies how matching keys are found when left or right join is used on a sorted series. Use this to find the nearest smaller or nearest greater key in the other series. Supported values are Lookup.Exact, Lookup.ExactOrSmaller and Lookup.ExactOrGreater.
  • series1 - The first (left) series to be aligned
  • series2 - The second (right) series to be aligned
zipAlignInto (...)
Signature: kind:JoinKind -> lookup:Lookup -> op:('V1 option -> 'V2 option -> 'R option) -> series1:Series<'K,'V1> -> series2:Series<'K,'V2> -> Series<'K,'R>
Type parameters: 'V1, 'V2, 'R, 'K

Align and zip two series using the specified joining mechanism and key matching. The function calls the specified function op to combine values from the two series

Parameters

  • kind specifies the kind of join you want to use (left, right, inner or outer). For inner join, it is better to use zipInner instead.
  • lookup specifies how matching keys are found when left or right join is used on a sorted series. Use this to find the nearest smaller or nearest greater key in the other series. Supported values are Lookup.Exact, Lookup.ExactOrSmaller and Lookup.ExactOrGreater.
  • op - A function that combines values from the two series. In case of left, right or outer join, some of the values may be missing. The function can also return None to indicate a missing result.
  • series1 - The first (left) series to be aligned
  • series2 - The second (right) series to be aligned
zipInner series1 series2
Signature: series1:Series<'K,'V1> -> series2:Series<'K,'V2> -> Series<'K,('V1 * 'V2)>
Type parameters: 'K, 'V1, 'V2

Align and zip two series using inner join and exact key matching. The function returns a series of tuples with values from the two series.

zipInto op series1 series2
Signature: op:('V1 -> 'V2 -> 'R) -> series1:Series<'K,'V1> -> series2:Series<'K,'V2> -> Series<'K,'R>
Type parameters: 'V1, 'V2, 'R, 'K

Align and zip two series using inner join and exact key matching (use zipAlignInto for more options). The function calls the specified function op to combine values from the two series

Parameters

  • op - A function that combines values from the two series.
  • series1 - The first (left) series to be aligned
  • series2 - The second (right) series to be aligned

Missing values 

This group of functions provides a way of working with missing values in a series. The dropMissing function drops all keys for which there are no values in the series. The withMissingFrom function lets you copy missing values from another series. The remaining functions provide different mechanism for filling the missing values.

  • fillMissingWith fills missing values with a specified constant
  • fillMissingUsing calls a specified function for every missing value
  • fillMissing and variants propagates values from previous/later keys

Functions and values

Function or valueDescription
dropMissing series
Signature: series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Drop missing values from the specified series. The returned series contains only those keys for which there is a value available in the original one.

Parameters

  • series - An input series to be filtered

Example

1: 
2: 
3: 
let s = series [ 1 => 1.0; 2 => Double.NaN ]
s |> Series.dropMissing 
[fsi:val it : Series<int,float> = series [ 1 => 1]
val s : obj

Full name: docs.s
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
fillMissing direction series
Signature: direction:Direction -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Fill missing values in the series with the nearest available value (using the specified direction). Note that the series may still contain missing values after call to this function. This operation can only be used on ordered series.

Parameters

  • series - An input series that is to be filled
  • direction - Specifies the direction used when searching for the nearest available value. Backward means that we want to look for the first value with a smaller key while Forward searches for the nearest greater key.

Example

1: 
2: 
3: 
4: 
5: 
6: 
7: 
let sample = Series.ofValues [ Double.NaN; 1.0; Double.NaN; 3.0 ]

// Returns a series consisting of [1; 1; 3; 3]
sample |> Series.fillMissing Direction.Backward

// Returns a series consisting of [<missing>; 1; 1; 3]
sample |> Series.fillMissing Direction.Forward 
val sample : obj

Full name: docs.sample
fillMissingBetween (...)
Signature: (startKey:'K * endKey:'K) -> direction:Direction -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Fill missing values only between startKey and endKey, inclusive.

Parameters

  • series - An input series that is to be filled
  • direction - Specifies the direction used when searching for the nearest available value. Backward means that we want to look for the first value with a smaller key while Forward searches for the nearest greater key.
  • startKey - the lower bound at which values should be filled
  • endKey - the upper bound at which values should be filled
fillMissingInside direction series
Signature: direction:Direction -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Fill missing values only between the first and last non-missing values.

fillMissingUsing f series
Signature: f:('K -> 'T) -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Fill missing values in the series using the specified function. The specified function is called with all keys for which the series does not contain value and the result of the call is used in place of the missing value.

Parameters

  • series - An input series that is to be filled
  • f - A function that takes key K and generates a value to be used in a place where the original series contains a missing value.

Remarks

This function can be used to implement more complex interpolation. For example see handling missing values in the tutorial

fillMissingWith value series
Signature: value:'a -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'a, 'K, 'T

Fill missing values in the series with a constant value.

Parameters

  • series - An input series that is to be filled
  • value - A constant value that is used to fill all missing values
withMissingFrom other series
Signature: other:Series<'K,'S> -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'S, 'T

Returns the current series with the same index but with values missing wherever the corresponding key exists in the other series index with an associated missing value.

Processing series with exceptions 

The functions in this group can be used to write computations over series that may fail. They use the type tryval<'T> which is defined as a discriminated union:

1: 
2: 
3: 
type tryval<'T> = 
  | Success of 'T
  | Error of exn

The function tryMap lets you create Series<'K, tryval<'T>> by mapping over values of an original series. You can then extract values using tryValues, which throws AggregateException if there were any errors. Functions tryErrors and trySuccesses give series containing only errors and successes. You can fill failed values with a constant using fillErrorsWith.

type tryval<'T> =
  | Success of 'T
  | Error of exn

Full name: docs.tryval<_>
union case tryval.Success: 'T -> tryval<'T>
union case tryval.Error: exn -> tryval<'T>
type exn = System.Exception

Full name: Microsoft.FSharp.Core.exn

Functions and values

Function or valueDescription
fillErrorsWith value series
Signature: value:'T -> series:Series<'K,'T tryval> -> Series<'K,'T>
Type parameters: 'T, 'K

Givnen a series of tryval<'V> values, returns a new series where all Error values are filled with the specified constant value.

tryErrors series
Signature: series:Series<'K,'V tryval> -> Series<'K,exn>
Type parameters: 'K, 'V

Given a series of tryval<'V> values, returns a series that contains all exceptions contained in the source series. The exceptions are returned as a series.

tryMap f series
Signature: f:('K -> 'T -> 'R) -> series:Series<'K,'T> -> Series<'K,'R tryval>
Type parameters: 'K, 'T, 'R

Returns a new series by applying the specified transformation to all values of the input series. The result contains Error(e) when the projection fails with an exception e or Success(v) containing a value v otherwise.

trySuccesses series
Signature: series:Series<'K,'V tryval> -> Series<'K,'V>
Type parameters: 'K, 'V

Given a series of tryval<'V> values, returns a series that contains all values contained in the source series. The input elements containing exceptions are ignored.

tryValues series
Signature: series:Series<'K,'T tryval> -> Series<'K,'T>
Type parameters: 'K, 'T

Obtains values from a series of tryval<'T> values. When the series contains one or more failures, the operation throws AggregateException. Otherwise, it returns a series containing values.

Sampling, resampling and advanced lookup 

Given a (typically) time series sampling or resampling makes it possible to get time series with representative values at lower or uniform frequency. We use the following terminology:

  • lookup and sample functions find values at specified key; if a key is not available, they can look for value associated with the nearest smaller or the nearest greater key.

  • resample function aggregate values values into chunks based on a specified collection of keys (e.g. explicitly provided times), or based on some relation between keys (e.g. date times having the same date).

  • resampleUniform is similar to resampling, but we specify keys by providing functions that generate a uniform sequence of keys (e.g. days), the operation also fills value for days that have no corresponding observations in the input sequence.

Functions and values

Function or valueDescription
lookupTime interval dir lookup series
Signature: interval:TimeSpan -> dir:Direction -> lookup:Lookup -> series:Series<^K,^V> -> Series<^K,^V>
Type parameters: ^K, ^V

Finds values at, or near, the specified times in a given series. The operation generates keys starting from the smallest key of the original series, using the specified interval and then finds values close to such keys using the specified lookup and dir.

Parameters

  • series - An input series to be resampled
  • interval - The interval between the individual samples
  • dir - Specifies how the keys should be generated. Direction.Forward means that the key is the smallest value of each chunk (and so first key of the series is returned and the last is not, unless it matches exactly start + k*interval); Direction.Backward means that the first key is skipped and sample is generated at, or just before the end of interval and at the end of the series.
  • lookup - Specifies how the lookup based on keys is performed. Exact means that the values at exact keys will be returned; NearestGreater returns the nearest greater key value (starting at the first key) and NearestSmaller returns the nearest smaller key value (starting at most interval after the end of the series)

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

lookupTimeAt (...)
Signature: start:^K -> interval:TimeSpan -> dir:Direction -> lookup:Lookup -> series:Series<^K,^V> -> Series<^K,^V>
Type parameters: ^K, ^V

Finds values at, or near, the specified times in a given series. The operation generates keys starting at the specified start time, using the specified interval and then finds values close to such keys using the specified lookup and dir.

Parameters

  • series - An input series to be resampled
  • start - The initial time to be used for sampling
  • interval - The interval between the individual samples
  • dir - Specifies how the keys should be generated. Direction.Forward means that the key is the smallest value of each chunk (and so first key of the series is returned and the last is not, unless it matches exactly start + k*interval); Direction.Backward means that the first key is skipped and sample is generated at, or just before the end of interval and at the end of the series.
  • lookup - Specifies how the lookup based on keys is performed. Exact means that the values at exact keys will be returned; NearestGreater returns the nearest greater key value (starting at the first key) and NearestSmaller returns the nearest smaller key value (starting at most interval after the end of the series)

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

resample keys dir series
Signature: keys:seq<'K> -> dir:Direction -> series:Series<'K,'V> -> Series<'K,Series<'K,'V>>
Type parameters: 'K, 'V

Resample the series based on a provided collection of keys. The values of the series are aggregated into chunks based on the specified keys. Depending on direction, the specified key is either used as the smallest or as the greatest key of the chunk (with the exception of boundaries that are added to the first/last chunk). Such chunks are then returned as nested series.

Parameters

  • series - An input series to be resampled
  • keys - A collection of keys to be used for resampling of the series
  • dir - If this parameter is Direction.Forward, then each key is used as the smallest key in a chunk; for Direction.Backward, the keys are used as the greatest keys in a chunk.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

resampleEquiv keyProj series
Signature: keyProj:('K1 -> 'K2) -> series:Series<'K1,'V1> -> Series<'K2,Series<'K1,'V1>>
Type parameters: 'K1, 'K2, 'V1

Resample the series based on equivalence class on the keys. A specified function keyProj is used to project keys to another space and the observations for which the projected keys are equivalent are grouped into chunks. The chunks are then returned as nested series.

Parameters

  • series - An input series to be resampled
  • keyProj - A function that transforms keys from original space to a new space (which is then used for grouping based on equivalence)

Remarks

This function is similar to Series.chunkBy, with the exception that it transforms keys to a new space.

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered. For unordered series, similar functionality can be implemented using Series.groupBy.

resampleEquivInto keyProj f series
Signature: keyProj:('K1 -> 'K2) -> f:(Series<'K1,'V1> -> 'V2) -> series:Series<'K1,'V1> -> Series<'K2,'V2>
Type parameters: 'K1, 'K2, 'V1, 'V2

Resample the series based on equivalence class on the keys. A specified function keyProj is used to project keys to another space and the observations for which the projected keys are equivalent are grouped into chunks. The chunks are then transformed to values using the provided function f.

Parameters

  • series - An input series to be resampled
  • keyProj - A function that transforms keys from original space to a new space (which is then used for grouping based on equivalence)
  • f - A function that is used to collapse a generated chunk into a single value.

Remarks

This function is similar to Series.chunkBy, with the exception that it transforms keys to a new space.

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered. For unordered series, similar functionality can be implemented using Series.groupBy.

resampleInto keys dir f series
Signature: keys:seq<'K> -> dir:Direction -> f:('K -> Series<'K,'V> -> '?553592) -> series:Series<'K,'V> -> Series<'K,'?553592>
Type parameters: 'K, 'V, '?553592

Resample the series based on a provided collection of keys. The values of the series are aggregated into chunks based on the specified keys. Depending on direction, the specified key is either used as the smallest or as the greatest key of the chunk (with the exception of boundaries that are added to the first/last chunk). Such chunks are then aggregated using the provided function f.

Parameters

  • series - An input series to be resampled
  • keys - A collection of keys to be used for resampling of the series
  • dir - If this parameter is Direction.Forward, then each key is used as the smallest key in a chunk; for Direction.Backward, the keys are used as the greatest keys in a chunk.
  • f - A function that is used to collapse a generated chunk into a single value. Note that this function may be called with empty series.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

resampleUniform (...)
Signature: fillMode:Lookup -> keyProj:('K1 -> 'K2) -> nextKey:('K2 -> 'K2) -> series:Series<'K1,'V> -> Series<'K2,Series<'K1,'V>>
Type parameters: 'K1, 'K2, 'V

Resample the series based on equivalence class on the keys and also generate values for all keys of the target space that are between the minimal and maximal key of the specified series (e.g. generate value for all days in the range covered by the series). A specified function keyProj is used to project keys to another space and nextKey is used to generate all keys in the range. Then return the chunks as nested series.

When there are no values for a (generated) key, then the function behaves according to fillMode. It can look at the greatest value of previous chunk or smallest value of the next chunk, or it produces an empty series.

Parameters

  • series - An input series to be resampled
  • fillMode - When set to Lookup.NearestSmaller or Lookup.NearestGreater, the function searches for a nearest available observation in an neighboring chunk. Otherwise, the function f is called with an empty series as an argument.
  • keyProj - A function that transforms keys from original space to a new space (which is then used for grouping based on equivalence)
  • nextKey - A function that gets the next key in the transformed space

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

resampleUniformInto (...)
Signature: fillMode:Lookup -> keyProj:('K1 -> 'K2) -> nextKey:('K2 -> 'K2) -> f:(Series<'K1,'V> -> 'b) -> series:Series<'K1,'V> -> Series<'K2,'b>
Type parameters: 'K1, 'K2, 'V, 'b

Resample the series based on equivalence class on the keys and also generate values for all keys of the target space that are between the minimal and maximal key of the specified series (e.g. generate value for all days in the range covered by the series). A specified function keyProj is used to project keys to another space and nextKey is used to generate all keys in the range. The chunk is then aggregated using f.

When there are no values for a (generated) key, then the function behaves according to fillMode. It can look at the greatest value of previous chunk or smallest value of the next chunk, or it produces an empty series.

Parameters

  • series - An input series to be resampled
  • fillMode - When set to Lookup.ExactOrSmaller or Lookup.ExactOrGreater, the function searches for a nearest available observation in an neighboring chunk. Otherwise, the function f is called with an empty series as an argument. Values Lookup.Smaller and Lookup.Greater are not supported.
  • keyProj - A function that transforms keys from original space to a new space (which is then used for grouping based on equivalence)
  • nextKey - A function that gets the next key in the transformed space
  • f - A function that is used to collapse a generated chunk into a single value. The function may be called on empty series when fillMode is Lookup.Exact.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

sampleTime interval dir series
Signature: interval:TimeSpan -> dir:Direction -> series:Series<^?553623,^?553624> -> Series<^?553623,Series<^?553623,^?553624>>
Type parameters: ^?553623, ^?553624

Performs sampling by time and returns chunks obtained by time-sampling as a nested
series. The operation generates keys starting at the first key in the source series, using the specified interval and then obtains chunks based on these keys in a fashion similar to the Series.resample function.

Parameters

  • series - An input series to be resampled
  • interval - The interval between the individual samples
  • dir - If this parameter is Direction.Forward, then each key is used as the smallest key in a chunk; for Direction.Backward, the keys are used as the greatest keys in a chunk.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

sampleTimeAt start interval dir series
Signature: start:^?553626 -> interval:TimeSpan -> dir:Direction -> series:Series<^?553626,^?553627> -> Series<^?553626,Series<^?553626,^?553627>>
Type parameters: ^?553626, ^?553627

Performs sampling by time and returns chunks obtained by time-sampling as a nested
series. The operation generates keys starting at the given start time, using the specified interval and then obtains chunks based on these keys in a fashion similar to the Series.resample function.

Parameters

  • series - An input series to be resampled
  • start - The initial time to be used for sampling
  • interval - The interval between the individual samples
  • dir - If this parameter is Direction.Forward, then each key is used as the smallest key in a chunk; for Direction.Backward, the keys are used as the greatest keys in a chunk.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

sampleTimeAtInto (...)
Signature: start:^K -> interval:TimeSpan -> dir:Direction -> f:(Series<^K,^V> -> '?553621) -> series:Series<^K,^V> -> Series<^K,'?553621>
Type parameters: ^K, ^V, '?553621

Performs sampling by time and aggregates chunks obtained by time-sampling into a single value using a specified function. The operation generates keys starting at the given start time, using the specified interval and then obtains chunks based on these keys in a fashion similar to the Series.resample function.

Parameters

  • series - An input series to be resampled
  • start - The initial time to be used for sampling
  • interval - The interval between the individual samples
  • dir - If this parameter is Direction.Forward, then each key is used as the smallest key in a chunk; for Direction.Backward, the keys are used as the greatest keys in a chunk.
  • f - A function that is called to aggregate each chunk into a single value.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

sampleTimeInto interval dir f series
Signature: interval:TimeSpan -> dir:Direction -> f:(Series<^K,^V> -> '?553617) -> series:Series<^K,^V> -> Series<^K,'?553617>
Type parameters: ^K, ^V, '?553617

Performs sampling by time and aggregates chunks obtained by time-sampling into a single value using a specified function. The operation generates keys starting at the first key in the source series, using the specified interval and then obtains chunks based on these keys in a fashion similar to the Series.resample function.

Parameters

  • series - An input series to be resampled
  • interval - The interval between the individual samples
  • dir - If this parameter is Direction.Forward, then each key is used as the smallest key in a chunk; for Direction.Backward, the keys are used as the greatest keys in a chunk.
  • f - A function that is called to aggregate each chunk into a single value.

Remarks

This operation is only supported on ordered series. The method throws InvalidOperationException when the series is not ordered.

Series transformations 

Functions in this category perform standard transformations on series including projections, filtering, taking some sub-series of the series, aggregating values using scanning and so on.

Projection and filtering functions generally skip over missing values, but there are variants filterAll and mapAll that let you handle missing values explicitly. Keys can be transformed using mapKeys. When you do not need to consider the keys, and only care about values, use filterValues and mapValues (which is also aliased as the $ operator).

Series supports standard set of folding functions including reduce and fold (to reduce series values into a single value) as well as the scan[All] function, which can be used to fold values of a series into a series of intermeidate folding results.

The functions take[Last] and skip[Last] can be used to take a sub-series of the original source series by skipping a specified number of elements. Note that this does not require an ordered series and it ignores the index - for index-based lookup use slicing, such as series.[lo .. hi], instead.

Finally the shift function can be used to obtain a series with values shifted by the specified offset. This can be used e.g. to get previous value for each key using Series.shift 1 ts. The diff function calculates difference from previous value using ts - (Series.shift offs ts).

Functions and values

Function or valueDescription
diff offset series
Signature: offset:int -> series:Series<'K,^T> -> Series<'K,^T>
Type parameters: 'K, ^T

Returns a series containing difference between a value in the original series and a value at the specified offset. For example, calling Series.diff 1 s returns a series where previous value is subtracted from the current one. In pseudo-code, the function behaves as follows:

1: 
result[k] = series[k] - series[k - offset]

Parameters

  • offset - When positive, subtracts the past values from the current values; when negative, subtracts the future values from the current values.
  • series - The input series, containing values that support the - operator.
filter f series
Signature: f:('K -> 'T -> bool) -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a new series containing only the elements for which the specified predicate returns true. The function skips over missing values. If you want to handle missing values, use filterAll instead.

filterAll f series
Signature: f:('K -> 'T option -> bool) -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a new series containing only the elements for which the specified predicate returns true. The predicate is called for missing values as well.

filterValues f series
Signature: f:('T -> bool) -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'T, 'K

Returns a new series containing only the elements for which the specified predicate returns true. The function skips over missing values and calls the predicate with just the value. See also filterAll and filter for more options.

flatten series
Signature: series:Series<'K,'T option> -> Series<'K,'T>
Type parameters: 'K, 'T

Given a series containing optional values, flatten the option values. That is, None values become missing values of the series and Some values become ordinary values in the resulting series.

foldValues op init series
Signature: op:('?553409 -> 'T -> '?553409) -> init:'?553409 -> series:Series<'K,'T> -> '?553409
Type parameters: '?553409, 'T, 'K

Aggregates the values of the specified series using a function that can combine individual values. The folding starts with the specified initial value.

Parameters

  • series - An input series to be aggregated
  • init - An initial value for the aggregation
  • op - A function that is used to aggregate elements of the series with the current state
force series
Signature: series:Series<'K,'V> -> Series<'K,'V>
Type parameters: 'K, 'V

Returns a new fully evaluated series. If the source series contains a lazy index or lazy vectors, these are forced to evaluate and the resulting series is fully loaded in memory.

map f series
Signature: f:('K -> 'T -> 'R) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'K, 'T, 'R

Returns a new series whose values are the results of applying the given function to values of the original series. This function skips over missing values and call the function with both keys and values.

mapAll f series
Signature: f:('K -> 'T option -> 'R option) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'K, 'T, 'R

Returns a new series whose values are the results of applying the given function to values of the original series. This specified function is called even when the value is missing. It returns option<'T> so that it can create/eliminate missing values in the result.

mapKeys f series
Signature: f:('K -> 'R) -> series:Series<'K,'T> -> Series<'R,'T>
Type parameters: 'K, 'R, 'T

Returns a new series whose keys are the results of applying the given function to keys of the original series.

mapValues f series
Signature: f:('T -> 'R) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'T, 'R, 'K

Returns a new series whose values are the results of applying the given function to values of the original series. This function skips over missing values and call the function with just values. It is also aliased using the $ operator so you can write series $ func for series |> Series.mapValues func.

reduceValues op series
Signature: op:('T -> 'T -> 'T) -> series:Series<'K,'T> -> 'T
Type parameters: 'T, 'K

Aggregates the values of the specified series using a function that can combine individual values. Fails if the series contains no values.

Parameters

  • series - An input series to be aggregated
  • op - A function that is used to aggregate elements of the series
scanAllValues foldFunc init series
Signature: foldFunc:('R option -> 'T option -> 'R option) -> init:'R option -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'R, 'T, 'K

Applies a folding function starting with some initial optional value and the first optional value of the series, and continues to "scan" along the series, saving all values produced from the first function application, and yielding a new series having the original index and newly produced values.

Parameters

  • foldFunc - A folding function
  • init - An initial value
  • series - The series over whose values to scan
scanValues foldFunc init series
Signature: foldFunc:('R -> 'T -> 'R) -> init:'R -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'R, 'T, 'K

Applies a folding function starting with some initial value and the first value of the series, and continues to "scan" along the series, saving all values produced from the first function application, and yielding a new series having the original index and newly produced values. Any application involving a missing value yields a missing value.

Parameters

  • foldFunc - A folding function
  • init - An initial value
  • series - The series over whose values to scan
shift offset series
Signature: offset:int -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a series with values shifted by the specified offset. When the offset is positive, the values are shifted forward and first offset keys are dropped. When the offset is negative, the values are shifted backwards and the last offset keys are dropped. Expressed in pseudo-code:

1: 
result[k] = series[k - offset]

Parameters

  • offset - Can be both positive and negative number.
  • series - The input series to be shifted.

Remarks

If you want to calculate the difference, e.g. s - (Series.shift 1 s), you can use Series.diff which will be a little bit faster.

skip count series
Signature: count:int -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a series that contains the data from the original series, except for the first count keys.

Parameters

  • count - Number of keys to skip; must be smaller or equal to the original number of keys
  • series - Input series from which the keys are taken
skipLast count series
Signature: count:int -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a series that contains the data from the original series, except for the last count keys.

Parameters

  • count - Number of keys to skip; must be smaller or equal to the original number of keys
  • series - Input series from which the keys are taken
take count series
Signature: count:int -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a series that contains the specified number of keys from the original series.

Parameters

  • count - Number of keys to take; must be smaller or equal to the original number of keys
  • series - Input series from which the keys are taken
takeLast count series
Signature: count:int -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a series that contains the specified number of keys from the original series. The keys are taken from the end of the series.

Parameters

  • count - Number of keys to take; must be smaller or equal to the original number of keys
  • series - Input series from which the keys are taken

Sorting and index manipulation 

A series that is sorted by keys allows a number of additional operations (such as lookup using the Lookp.ExactOrSmaller lookup behavior). However, it is also possible to sort series based on the values - although the functions for manipulation with series do not guarantee that the order will be preserved.

To sort series by keys, use sortByKey. Other sorting functions let you sort the series using a specified comparer function (sortWith), using a projection function (sortBy) and using the default comparison (sort).

In addition, you can also replace the keys of a series with other keys using indexWith or with integers using indexOrdinally. To pick and reorder series values using to match a list of keys use realign.

Functions and values

Function or valueDescription
indexOrdinally series
Signature: series:Series<'K,'T> -> Series<int,'T>
Type parameters: 'K, 'T

Return a new series containing the same values as the original series, but with ordinal index formed by int values starting from 0.

indexWith keys series
Signature: keys:seq<'K2> -> series:Series<'K1,'T> -> Series<'K2,'T>
Type parameters: 'K2, 'K1, 'T

Returns a new series containing the specified keys mapped to the original values of the series. When the sequence contains fewer keys, the values from the series are dropped. When it contains more keys, the values for additional keys are missing.

realign keys series
Signature: keys:seq<'K> -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Given an original series and a sequence of keys, returns a new series that contains the matching value for each of the specified keys. The KeyCount of the returned sequence is the length of keys. If there is no value for the specified keys in the input sequence, the returned series will contain a missing value.

rev series
Signature: series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a new series, containing the observations of the original series in a reverse order.

sort series
Signature: series:Series<'K,'V> -> Series<'K,'V>
Type parameters: 'K, 'V

Returns a new series, containing the observations of the original series sorted based on the default ordering defined on the values of the series.

sortBy proj series
Signature: proj:('T -> 'V) -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'T, 'V, 'K

Returns a new series, containing the observations of the original series sorted by values returned by the specified projection function.

Parameters

  • series - An input series whose values are sorter
  • proj - A projection function that returns a value to be compared for each value contained in the original input series.
sortByKey series
Signature: series:Series<'K,'T> -> Series<'K,'T>
Type parameters: 'K, 'T

Returns a new series whose observations are sorted according to keys of the index.

Parameters

  • series - An input series to be sorted
sortWith comparer series
Signature: comparer:('V -> 'V -> int) -> series:Series<'K,'V> -> Series<'K,'V>
Type parameters: 'V, 'K

Returns a new series, containing the observations of the original series sorted using the specified comparison function.

Parameters

  • series - An input series whose values are sorter
  • comparer - A comparer function on the series values. The function should return negative integer when the first value is smaller, positive when it is greater and 0 when the values are equal.

Other module members 

Functions and values

Function or valueDescription
convert forward backward series
Signature: forward:('T -> 'R) -> backward:('R -> 'T) -> series:Series<'K,'T> -> Series<'K,'R>
Type parameters: 'T, 'R, 'K

Retruns a new series whose values are converted using the specified conversion function. This operation is like mapValues, but it requires a pair of function that converts the values in both ways.

Parameters

  • forward - Function that converts original values to the new
  • backward - Function that converts new values back to the original

Remarks

This operation is only interesting when working with virtualized data sources. Using the convert function makes it possible to perfom additional operations on the resulting series - for example lookup - by converting the new value back and using the lookup of the underlying virtualized source.

Fork me on GitHub