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.

Accessing series data and lookup
Grouping, windowing and chunking
Hierarchical index operations
Joining, merging and zipping
Missing values
Processing series with exceptions
Sampling, resampling and advanced lookup
Series transformations
Sorting and index manipulation
Other module members

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 value	Description
`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 value Description


            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 last key of the chunk, unless boundary behavior is Boundary.AtEnding (in which case it is the first 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 last key of the chunk, unless boundary behavior is Boundary.AtEnding (in which case it is the first 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> -> '?494683) -> series:Series<'K,'T> -> Series<'K,'?494683>
Type parameters: 'K, 'T, '?494683

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 -> '?494707) -> series:Series<'K,'T> -> Series<'K,'?494707>
Type parameters: 'K, 'T, '?494707

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:^?494649 -> f:(Series<^K,'T> -> '?494652) -> series:Series<^K,'T> -> Series<^K,'?494652>
Type parameters: ^?494649, ^K, 'T, '?494652

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> -> '?494660) -> series:Series<'K,'T> -> Series<'K,'?494660>
Type parameters: 'K, 'T, '?494660

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 value	Description
`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 value	Description
`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 value Description


            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:'?494728 -> series:Series<'K,'T> -> Series<'K,'T>
Type parameters: '?494728, '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 value	Description
`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 value	Description
`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 + kinterval*); `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 + kinterval*); `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> -> '?494776) -> series:Series<'K,'V> -> Series<'K,'?494776> Type parameters: 'K, 'V, '?494776	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> -> '?494793) -> series:Series<'K1,'V> -> Series<'K2,'?494793> Type parameters: 'K1, 'K2, 'V, '?494793	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<^?494807,^?494808> -> Series<^?494807,Series<^?494807,^?494808>> Type parameters: ^?494807, ^?494808	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:^?494810 -> interval:TimeSpan -> dir:Direction -> series:Series<^?494810,^?494811> -> Series<^?494810,Series<^?494810,^?494811>> Type parameters: ^?494810, ^?494811	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> -> '?494805) -> series:Series<^K,^V> -> Series<^K,'?494805> Type parameters: ^K, ^V, '?494805	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> -> '?494801) -> series:Series<^K,^V> -> Series<^K,'?494801> Type parameters: ^K, ^V, '?494801	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 value Description


            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:('?494593 -> 'T -> '?494593) -> init:'?494593 -> series:Series<'K,'T> -> '?494593
Type parameters: '?494593, '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


            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 value	Description
`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 value Description

Function or value	Description
`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.


            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.

Deedle

Series

Table of contents

Accessing series data and lookup

Functions and values

Parameters

Parameters

Parameters

Grouping, windowing and chunking

Functions and values

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Example

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Hierarchical index operations

Functions and values

Parameters

Parameters

Parameters

Joining, merging and zipping

Functions and values

Parameters

Parameters

Parameters

Parameters

Missing values

Functions and values

Parameters

Example

Parameters

Example

Parameters

Parameters

Remarks

Parameters

Processing series with exceptions

Functions and values

Sampling, resampling and advanced lookup

Functions and values

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks

Parameters

Remarks