 | SeriesK, V Class |
The type `Series<K, V>` represents a data series consisting of values `V` indexed by
keys `K`. The keys of a series may or may not be ordered
[category:Core frame and series types]
Inheritance HierarchySystemObject
DeedleSeriesK, V
DeedleColumnSeriesTRowKey, TColumnKey
DeedleObjectSeriesK
DeedleRowSeriesTRowKey, TColumnKey
DeedleSeriesK, V
DeedleColumnSeriesTRowKey, TColumnKey
DeedleObjectSeriesK
DeedleRowSeriesTRowKey, TColumnKey
Namespace: Deedle
Assembly: Deedle (in Deedle.dll) Version: 1.2
SyntaxThe SeriesK, V type exposes the following members.
Constructors| Name | Description | |
|---|---|---|
 | SeriesK, V(IEnumerableKeyValuePairK, V) | Initializes a new instance of the SeriesK, V class |
| SeriesK, V(IEnumerableK, IEnumerableV) | Initializes a new instance of the SeriesK, V class |
| SeriesK, V(K, V) | Initializes a new instance of the SeriesK, V class |
| SeriesK, V(IIndexK, IVectorV, IVectorBuilder, IIndexBuilder) | Initializes a new instance of the SeriesK, V class |
Properties| Name | Description | |
|---|---|---|
 | Index |
Returns the index associated with this series. This member should not generally
be accessed directly, because all functionality is exposed through series operations.
[category:Series data]
|
| IsEmpty |
[category:Series data]
|
| IsOrdered |
[category:Series data]
|
| ItemIEnumerableK |
[category:Accessors and slicing]
|
| ItemK |
[category:Accessors and slicing]
|
| ItemICustomLookupK |
[category:Accessors and slicing]
|
| KeyCount |
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.
[category:Series data]
|
| KeyRange |
[category:Series data]
|
| Keys |
Returns a collection of keys that are defined by the index of this series.
Note that the length of this sequence does not match the `Values` sequence
if there are missing values. To get matching sequence, use the `Observations`
property or `Series.observation`.
[category:Series data]
|
| Observations |
Returns a collection of observations that form this series. Note that this property
skips over all missing (or NaN) values. Observations are returned as `KeyValuePair<K, V>`
objects. For an F# alternative that uses tuples, see `Series.observations`.
[category:Series data]
|
| ObservationsAll |
Returns a collection of observations that form this series. Note that this property
includes all missing (or NaN) values. Observations are returned as
`KeyValuePair<K, OptionalValue<V>>` objects. For an F# alternative that uses tuples,
see `Series.observationsAll`.
[category:Series data]
|
| Reversed |
[category:Projection and filtering]
|
| ValueCount |
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.).
[category:Series data]
|
| Values |
Returns a collection of values that are available in the series data.
Note that the length of this sequence does not match the `Keys` sequence
if there are missing values. To get matching sequence, use the `Observations`
property or `Series.observation`.
[category:Series data]
|
| ValuesAll |
Returns a collection of values, including possibly missing values. Note that
the length of this sequence matches the `Keys` sequence.
[category:Series data]
|
| Vector |
Returns the vector associated with this series. This member should not generally
be accessed directly, because all functionality is exposed through series operations.
[category:Series data]
|
Methods| Name | Description | |
|---|---|---|
 | Abs(SeriesK, Double) |
[category:Operators]
|
| Abs(SeriesK, Int32) |
[category:Operators]
|
| Acos |
[category:Operators]
|
| After | |
| AggregateTNewKey, R(AggregationK, FuncDataSegmentSeriesK, V, KeyValuePairTNewKey, OptionalValueR) |
Aggregates an ordered series using the method specified by `Aggregation<K>` and then
applies the provided `observationSelector` on each window or chunk to produce the result
which is returned as a new series. The selector returns both the key and the value.
## Parameters
- `aggregation` - Specifies the aggregation method using `Aggregation<K>`. This is
a discriminated union listing various chunking and windowing conditions.
- `observationSelector` - A function that is called on each chunk to obtain a key and a value.
[category:Windowing, chunking and grouping]
|
| AggregateTNewKey, R(AggregationK, FuncDataSegmentSeriesK, V, TNewKey, FuncDataSegmentSeriesK, V, OptionalValueR) |
Aggregates an ordered series using the method specified by `Aggregation<K>` and then
applies the provided `valueSelector` 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.
- `valueSelector` - A value selector function that is called to aggregate each chunk or window.
[category:Windowing, chunking and grouping]
|
| Asin |
[category:Operators]
|
| AsyncMaterialize | |
| Atan |
[category:Operators]
|
| Before | |
| Between | |
| Ceiling |
[category:Operators]
|
| ConvertR |
[category:Projection and filtering]
|
| Cos |
[category:Operators]
|
| Cosh |
[category:Operators]
|
| EndAt | |
| Equals | (Overrides ObjectEquals(Object).) |
| Exp |
[category:Operators]
|
 | Finalize | Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.) |
| Floor |
[category:Operators]
|
| Format |
Shows the series content in a human-readable format. The resulting string
shows a limited number of values from the series.
|
| Format(Int32) |
Shows the series content in a human-readable format. The resulting string
shows a limited number of values from the series.
## Parameters
- `itemCount` - The total number of items to show. The result will show
at most `itemCount/2` items at the beginning and ending of the series.
|
| Format(Int32, Int32) |
Shows the series content in a human-readable format. The resulting string
shows a limited number of values from the series.
## Parameters
- `startCount` - The number of elements to show at the beginning of the series
- `endCount` - The number of elements to show at the end of the series
|
| Get(K) |
[category:Accessors and slicing]
|
| Get(K, Lookup) |
[category:Accessors and slicing]
|
| GetAddressRange |
Internal helper used by `skip`, `take`, etc.
|
| GetAt |
[category:Accessors and slicing]
|
| GetByLevel |
[category:Accessors and slicing]
|
| GetHashCode | (Overrides ObjectGetHashCode.) |
| GetItems(IEnumerableK) |
Returns a new series with an index containing the specified keys.
When the key is not found in the current series, the newly returned
series will contain a missing value. When the second parameter is not
specified, the keys have to exactly match the keys in the current series
(`Lookup.Exact`).
## Parameters
* `keys` - A collection of keys in the current series.
[category:Accessors and slicing]
|
| GetItems(IEnumerableK, Lookup) |
Returns a new series with an index containing the specified keys.
When the key is not found in the current series, the newly returned
series will contain a missing value. When the second parameter is not
specified, the keys have to exactly match the keys in the current series
(`Lookup.Exact`).
## Parameters
* `keys` - A collection of keys in the current series.
* `lookup` - Specifies the lookup behavior when searching for keys in
the current series. `Lookup.NearestGreater` and `Lookup.NearestSmaller`
can be used when the current series is ordered.
[category:Accessors and slicing]
|
| GetKeyAt |
[category:Accessors and slicing]
|
| GetObservation(K) |
[category:Accessors and slicing]
|
| GetObservation(K, Lookup) |
[category:Accessors and slicing]
|
| GetSlice |
[category:Accessors and slicing]
|
| GetSubrange |
[category:Accessors and slicing]
|
| GetType | Gets the Type of the current instance. (Inherited from Object.) |
| GroupByTNewKey |
Groups a series (ordered or unordered) using the specified key selector (`keySelector`)
## 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.
[category:Windowing, chunking and grouping]
|
| IndexOrdinally |
Replace the index of the series with ordinally generated integers starting from zero.
The elements of the series are assigned index according to the current order, or in a
non-deterministic way, if the current index is not ordered.
[category:Indexing]
|
| IndexWithTNewKey |
[category:Indexing]
|
| Interpolate |
Interpolates an ordered series given a new sequence of keys. The function iterates through
each new key, and invokes a function on the current key, the nearest smaller and larger valid
observations from the series argument. The function must return a new valid float.
## Parameters
- `keys` - Sequence of new keys that forms the index of interpolated results
- `f` - Function to do the interpolating
[category:Windowing, chunking and grouping]
|
| Log |
[category:Operators]
|
| Log10 |
[category:Operators]
|
| Materialize | |
| MaterializeAsync | |
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.) |
| Merge(SeriesK, V) |
[category:Merging, joining and zipping]
|
| Merge(SeriesK, V) |
[category:Merging, joining and zipping]
|
| Merge(IEnumerableSeriesK, V) |
[category:Merging, joining and zipping]
|
| Merge(SeriesK, V, UnionBehavior) |
[category:Merging, joining and zipping]
|
| Pairwise |
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
let input = series [ 1 => 'a'; 2 => 'b'; 3 => 'c']
let res = input.Pairwise()
res = series [2 => ('a', 'b'); 3 => ('b', 'c') ]
[category:Windowing, chunking and grouping]
|
| Pairwise(Boundary) |
Returns a series containing an element and its neighbor for each input.
The returned series is one key shorter (it does not contain a
value for the first or last key depending on `boundary`). If `boundary` is
other than `Boundary.Skip`, then the key is included in the returned series,
but its value is missing.
## Parameters
- `series` - The input series to be aggregated.
- `boundary` - Specifies the direction in which the series is aggregated and
how the corner case is handled. If the value is `Boundary.AtEnding`, then the
function returns value and its successor, otherwise it returns value and its
predecessor.
## Example
let input = series [ 1 => 'a'; 2 => 'b'; 3 => 'c']
let res = input.Pairwise()
res = series [2 => ('a', 'b'); 3 => ('b', 'c') ]
[category:Windowing, chunking and grouping]
|
| Pow(Double, SeriesK, Double) |
[category:Operators]
|
| Pow(SeriesK, Double, SeriesK, Double) |
[category:Operators]
|
| Pow(SeriesK, Double, Double) |
[category:Operators]
|
| Realign |
[category:Indexing]
|
| Resample(IEnumerableK, Direction) |
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). The chunks
are then returned as a nested series.
## Parameters
- `keys` - A collection of keys to be used for resampling of the series
- `direction` - 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.
[category:Resampling]
|
| Resamplea(IEnumerableK, Direction, FuncK, SeriesK, V, a) |
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 `valueSelector` and `keySelector`
(an overload that does not take `keySelector` just selects the explicitly provided key).
## Parameters
- `keys` - A collection of keys to be used for resampling of the series
- `direction` - 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.
- `valueSelector` - 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.
[category:Resampling]
|
| ResampleTNewKey, R(IEnumerableK, Direction, FuncTNewKey, SeriesK, V, R, FuncK, SeriesK, V, TNewKey) |
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 `valueSelector` and `keySelector`
(an overload that does not take `keySelector` just selects the explicitly provided key).
## Parameters
- `keys` - A collection of keys to be used for resampling of the series
- `direction` - 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.
- `valueSelector` - A function that is used to collapse a generated chunk into a
single value. Note that this function may be called with empty series.
- `keySelector` - A function that is used to generate a new key for each chunk.
## Remarks
This operation is only supported on ordered series. The method throws
`InvalidOperationException` when the series is not ordered.
[category:Resampling]
|
| Round |
[category:Operators]
|
| ScanAllValuesS |
[category:Projection and filtering]
|
| ScanValuesS |
[category:Projection and filtering]
|
| SelectR(FuncKeyValuePairK, V, R) |
[category:Projection and filtering]
|
| SelectR(FuncKeyValuePairK, V, Int32, R) |
[category:Projection and filtering]
|
| SelectKeysR |
[category:Projection and filtering]
|
| SelectOptionalR |
[category:Projection and filtering]
|
| SelectValuesT |
[category:Projection and filtering]
|
| Sign |
[category:Operators]
|
| Sin |
[category:Operators]
|
| Sinh |
[category:Operators]
|
| Sqrt |
[category:Operators]
|
| StartAt | |
| Tan |
[category:Operators]
|
| Tanh |
[category:Operators]
|
| ToString | (Overrides ObjectToString.) |
| Truncate |
[category:Operators]
|
| TryGet(K) |
[category:Accessors and slicing]
|
| TryGet(K, Lookup) |
[category:Accessors and slicing]
|
| TryGetAt |
[category:Accessors and slicing]
|
| TryGetObservation(K) |
Attempts to get a value at the specified 'key'
[category:Accessors and slicing]
|
| TryGetObservation(K, Lookup) |
[category:Accessors and slicing]
|
| Where(FuncKeyValuePairK, V, Boolean) |
[category:Projection and filtering]
|
| Where(FuncKeyValuePairK, V, Int32, Boolean) |
[category:Projection and filtering]
|
| WhereOptional |
[category:Projection and filtering]
|
| WithMissingFroma |
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.
[category:Projection and filtering]
|
| ZipV2(SeriesK, V2) |
[category:Merging, joining and zipping]
|
| ZipV2(SeriesK, V2, JoinKind) |
[category:Merging, joining and zipping]
|
| ZipV2(SeriesK, V2, JoinKind, Lookup) |
[category:Merging, joining and zipping]
|
| ZipInnerV2 |
[category:Merging, joining and zipping]
|
Operators| Name | Description | |
|---|---|---|
 | Addition(Double, SeriesK, Double) |
[category:Operators]
|
| Addition(Int32, SeriesK, Int32) |
[category:Operators]
|
| Addition(SeriesK, Double, SeriesK, Double) |
[category:Operators]
|
| Addition(SeriesK, Double, Double) |
[category:Operators]
|
| Addition(SeriesK, Int32, SeriesK, Int32) |
[category:Operators]
|
| Addition(SeriesK, Int32, Int32) |
[category:Operators]
|
| Division(Double, SeriesK, Double) |
[category:Operators]
|
| Division(Int32, SeriesK, Int32) |
[category:Operators]
|
| Division(SeriesK, Double, SeriesK, Double) |
[category:Operators]
|
| Division(SeriesK, Double, Double) |
[category:Operators]
|
| Division(SeriesK, Int32, SeriesK, Int32) |
[category:Operators]
|
| Division(SeriesK, Int32, Int32) |
[category:Operators]
|
| Dollara |
Custom operator that can be used for applying a function to all elements of
a series. This provides a nicer syntactic sugar for the `Series.mapValues`
function. For example:
// Given a float series and a function on floats
let s1 = Series.ofValues [ 1.0 .. 10.0 ]
let adjust v = max 10.0 v
// Apply "adjust (v + v)" to all elements
adjust $ (s1 + s1)
|
| Dynamica |
[category:Accessors and slicing]
|
| Multiply(Double, SeriesK, Double) |
[category:Operators]
|
| Multiply(Int32, SeriesK, Int32) |
[category:Operators]
|
| Multiply(SeriesK, Double, SeriesK, Double) |
[category:Operators]
|
| Multiply(SeriesK, Double, Double) |
[category:Operators]
|
| Multiply(SeriesK, Int32, SeriesK, Int32) |
[category:Operators]
|
| Multiply(SeriesK, Int32, Int32) |
[category:Operators]
|
| Subtraction(Double, SeriesK, Double) |
[category:Operators]
|
| Subtraction(Int32, SeriesK, Int32) |
[category:Operators]
|
| Subtraction(SeriesK, Double, SeriesK, Double) |
[category:Operators]
|
| Subtraction(SeriesK, Double, Double) |
[category:Operators]
|
| Subtraction(SeriesK, Int32, SeriesK, Int32) |
[category:Operators]
|
| Subtraction(SeriesK, Int32, Int32) |
[category:Operators]
|
| UnaryNegation(SeriesK, Double) |
[category:Operators]
|
| UnaryNegation(SeriesK, Int32) |
[category:Operators]
|
See Also