A series is a labeled array of values of type a, indexed by keys of type k.

Like Data.Map and Data.HashMap, they support efficient:

• random access by key ( \(O(\log n)\) );
• slice by key ( \(O(\log n)\) ).

Like Data.Vector.Vector, they support efficient:

• random access by index ( \(O(1)\) );
• slice by index ( \(O(1)\) );
• numerical operations.

Create a Series with a single element.

\(O(n)\) Generate a Series by mapping every element of its index.

>>> fromIndex (const (0::Int)) $ Index.fromList ['a','b','c','d']
index | values
----- | ------
  'a' |      0
  'b' |      0
  'c' |      0
  'd' |      0

Construct a series from a list of key-value pairs. There is no condition on the order of pairs.

>>> let xs = fromList [('b', 0::Int), ('a', 5), ('d', 1) ]
>>> xs
index | values
----- | ------
  'a' |      5
  'b' |      0
  'd' |      1

If you need to handle duplicate keys, take a look at fromListDuplicates.

Construct a list from key-value pairs. The elements are in order sorted by key:

>>> let xs = Series.fromList [ ('b', 0::Int), ('a', 5), ('d', 1) ]
>>> xs
index | values
----- | ------
  'a' |      5
  'b' |      0
  'd' |      1
>>> toList xs
[('a',5),('b',0),('d',1)]

Construct a Series from a Vector of key-value pairs. There is no condition on the order of pairs. Duplicate keys are silently dropped. If you need to handle duplicate keys, see fromVectorDuplicates.

Note that due to differences in sorting, fromList and fromVector . fromList may not be equivalent if the input list contains duplicate keys.

Construct a Vector of key-value pairs. The elements are in order sorted by key.

Integer-like, non-negative number that specifies how many occurrences of a key is present in a Series.

The easiest way to convert from an Occurrence to another integer-like type is the fromIntegral function.

Construct a series from a list of key-value pairs. Contrary to fromList, values at duplicate keys are preserved. To keep each key unique, an Occurrence number counts up.

>>> let xs = fromListDuplicates [('b', 0::Int), ('a', 5), ('d', 1), ('d', -4), ('d', 7) ]
>>> xs
  index | values
  ----- | ------
('a',0) |      5
('b',0) |      0
('d',0) |      1
('d',1) |     -4
('d',2) |      7

Construct a series from a Vector of key-value pairs. Contrary to fromVector, values at duplicate keys are preserved. To keep each key unique, an Occurrence number counts up.

>>> import qualified Data.Vector as Vector
>>> let xs = fromVectorDuplicates $ Vector.fromList [('b', 0::Int), ('a', 5), ('d', 1), ('d', -4), ('d', 7) ]
>>> xs
  index | values
  ----- | ------
('a',0) |      5
('b',0) |      0
('d',0) |      1
('d',1) |     -4
('d',2) |      7

Construct a series from a strict Map.

Convert a series into a strict Map.

Construct a series from a lazy Map.

Convert a series into a lazy Map.

The IsSeries typeclass allow for ad-hoc definition of conversion functions, converting to / from Series.

\(O(n)\) Convert between two types of Series.

\(O(n)\) Map every element of a Series.

\(O(n)\) Map every element of a Series, possibly using the key as well.

\(O(n \log n)\). Map each key in the index to another value. Note that the resulting series may have less elements, because each key must be unique.

In case new keys are conflicting, the first element is kept.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> import qualified Data.List
>>> xs `mapIndex` (Data.List.take 1)
index | values
----- | ------
  "L" |      4
  "P" |      1

Map a function over all the elements of a Series and concatenate the result into a single Series.

\(O(\log n)\) take n xs returns at most n elements of the Series xs.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4), ("Vienna", 5)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
"Vienna" |      5
>>> take 2 xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2

\(O(n)\) Returns the longest prefix (possibly empty) of the input Series that satisfy a predicate.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4), ("Vienna", 5)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
"Vienna" |      5

\(O(\log n)\) drop n xs drops at most n elements from the Series xs.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4), ("Vienna", 5)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
"Vienna" |      5
>>> drop 2 xs
   index | values
   ----- | ------
 "Paris" |      1
"Vienna" |      5

\(O(n)\) Returns the complement of takeWhile.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4), ("Vienna", 5)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
"Vienna" |      5

Filter elements. Only elements for which the predicate is True are kept. Notice that the filtering is done on the values, not on the keys.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> filter (>2) xs
   index | values
   ----- | ------
"Lisbon" |      4

See also filterWithKey.

Filter elements, taking into account the corresponding key. Only elements for which the predicate is True are kept.

\(O(n)\) Apply the monadic action to every element of a series and its index, yielding a series of results.

\(O(n)\) Apply the monadic action to every element of a series and its index, discarding the results.

\(O(n)\) Apply the monadic action to all elements of the series and their associated keys, yielding a series of results.

\(O(n)\) Apply the monadic action to all elements of the series and their associated keys, discarding the results.

\(O(n)\) Traverse a Series with an Applicative action, taking into account both keys and values.

Apply a function elementwise to two series, matching elements based on their keys. For keys present only in the left or right series, the value Nothing is returned.

>>> let xs = Series.fromList [ ("alpha", 0::Int), ("beta", 1), ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11), ("delta", 13) ]
>>> zipWith (+) xs ys
  index |  values
  ----- |  ------
"alpha" | Just 10
 "beta" | Just 12
"delta" | Nothing
"gamma" | Nothing

To only combine elements where keys are in both series, see zipWithMatched.

Apply a function elementwise to two series, matching elements based on their keys. Keys present only in the left or right series are dropped.

>>> let xs = Series.fromList [ ("alpha", 0::Int), ("beta", 1), ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11), ("delta", 13) ]
>>> zipWithMatched (+) xs ys
  index | values
  ----- | ------
"alpha" |     10
 "beta" |     12

To combine elements where keys are in either series, see zipWith.

Apply a function elementwise to two series, matching elements based on their keys. Keys present only in the left or right series are dropped.

To combine elements where keys are in either series, see zipWith

Apply a function elementwise to three series, matching elements based on their keys. For keys present only in the left or right series, the value Nothing is returned.

>>> let xs = Series.fromList [ ("alpha", 0::Int),  ("beta", 1),   ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11),  ("delta", 13) ]
>>> let zs = Series.fromList [ ("alpha", 20::Int), ("delta", 13), ("epsilon", 6) ]
>>> zipWith3 (\x y z -> x + y + z) xs ys zs
    index |  values
    ----- |  ------
  "alpha" | Just 30
   "beta" | Nothing
  "delta" | Nothing
"epsilon" | Nothing
  "gamma" | Nothing

To only combine elements where keys are in all series, see zipWithMatched3

Apply a function elementwise to three series, matching elements based on their keys. Keys not present in all three series are dropped.

>>> let xs = Series.fromList [ ("alpha", 0::Int),  ("beta", 1),   ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11),  ("delta", 13) ]
>>> let zs = Series.fromList [ ("alpha", 20::Int), ("delta", 13), ("epsilon", 6) ]
>>> zipWithMatched3 (\x y z -> x + y + z) xs ys zs
  index | values
  ----- | ------
"alpha" |     30

Apply a function elementwise to three series, matching elements based on their keys. Keys present only in the left or right series are dropped.

To combine elements where keys are in any series, see zipWith3

A ZipStrategy is a function which is used to decide what to do when a key is missing from one of two Series being zipped together with zipWithStrategy.

If a ZipStrategy returns Nothing, the key is dropped. If a ZipStrategy returns Just v for key k, then the value v is inserted at key k.

For example, the most basic ZipStrategy is to skip over any key which is missing from the other series. Such a strategy can be written as skip key value = Nothing (see skipStrategy).

This ZipStrategy drops keys which are not present in both Series.

>>> let xs = Series.fromList [ ("alpha", 0::Int), ("beta", 1), ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11), ("delta", 13) ]
>>> zipWithStrategy (+) skipStrategy skipStrategy xs ys
  index | values
  ----- | ------
"alpha" |     10
 "beta" |     12

This ZipStrategy sets the value at keys which are not present in both Series to the some mapping from the value present in one of the series. See the example below.

>>> let xs = Series.fromList [ ("alpha", 0::Int), ("beta", 1), ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 5::Int), ("beta", 6), ("delta", 7) ]
>>> zipWithStrategy (+) (mapStrategy id) (mapStrategy (*10)) xs ys
  index | values
  ----- | ------
"alpha" |      5
 "beta" |      7
"delta" |     70
"gamma" |      2

This ZipStrategy sets a constant value at keys which are not present in both Series.

>>> let xs = Series.fromList [ ("alpha", 0::Int), ("beta", 1), ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11), ("delta", 13) ]
>>> zipWith (+) xs ys
  index |  values
  ----- |  ------
"alpha" | Just 10
 "beta" | Just 12
"delta" | Nothing
"gamma" | Nothing
>>> zipWithStrategy (+) (constStrategy (-100)) (constStrategy 200)  xs ys
  index | values
  ----- | ------
"alpha" |     10
 "beta" |     12
"delta" |    200
"gamma" |   -100

Zip two Series with a combining function, applying a ZipStrategy when one key is present in one of the Series but not both.

In the example below, we want to set the value to -100 (via constStrategy (-100)) for keys which are only present in the left Series, and drop keys (via skipStrategy) which are only present in the `right Series

>>> let xs = Series.fromList [ ("alpha", 0::Int), ("beta", 1), ("gamma", 2) ]
>>> let ys = Series.fromList [ ("alpha", 10::Int), ("beta", 11), ("delta", 13) ]
>>> zipWithStrategy (+) (constStrategy (-100)) skipStrategy  xs ys
  index | values
  ----- | ------
"alpha" |     10
 "beta" |     12
"gamma" |   -100

Note that if you want to drop keys missing in either Series, it is faster to use zipWithMatched f than using zipWithStrategy f skipStrategy skipStrategy.

Zip three Series with a combining function, applying a ZipStrategy when one key is present in one of the Series but not all of the others.

Note that if you want to drop keys missing in either Series, it is faster to use zipWithMatched3 f than using zipWithStrategy3 f skipStrategy skipStrategy skipStrategy.

Zip two Series with a combining function. The value for keys which are missing from either Series is replaced with the appropriate mempty value.

>>> import Data.Monoid ( Sum(..) )
>>> let xs = Series.fromList [ ("2023-01-01", Sum (1::Int)), ("2023-01-02", Sum 2) ]
>>> let ys = Series.fromList [ ("2023-01-01", Sum (5::Int)), ("2023-01-03", Sum 7) ]
>>> Series.zipWith (<>) xs ys
       index |                  values
       ----- |                  ------
"2023-01-01" | Just (Sum {getSum = 6})
"2023-01-02" |                 Nothing
"2023-01-03" |                 Nothing
>>> zipWithMonoid (<>) xs ys
       index |           values
       ----- |           ------
"2023-01-01" | Sum {getSum = 6}
"2023-01-02" | Sum {getSum = 2}
"2023-01-03" | Sum {getSum = 7}

Elementwise sum of two Series. Elements missing in one or the other Series is considered 0.

>>> let xs = Series.fromList [ ("2023-01-01", (1::Int)), ("2023-01-02", 2) ]
>>> let ys = Series.fromList [ ("2023-01-01", (5::Int)), ("2023-01-03", 7) ]
>>> xs `esum` ys
       index | values
       ----- | ------
"2023-01-01" |      6
"2023-01-02" |      2
"2023-01-03" |      7

Elementwise product of two Series. Elements missing in one or the other Series is considered 1.

>>> let xs = Series.fromList [ ("2023-01-01", (2::Int)), ("2023-01-02", 3) ]
>>> let ys = Series.fromList [ ("2023-01-01", (5::Int)), ("2023-01-03", 7) ]
>>> xs `eproduct` ys
       index | values
       ----- | ------
"2023-01-01" |     10
"2023-01-02" |      3
"2023-01-03" |      7

\(O(n)\) Unzip a Series of 2-tuples.

\(O(n)\) Unzip a Series of 3-tuples.

Require a series to have a specific Index. Contrary to select, all keys in the Index will be present in the resulting series.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> xs `require` Index.fromList ["Paris", "Lisbon", "Taipei"]
   index |  values
   ----- |  ------
"Lisbon" |  Just 4
 "Paris" |  Just 1
"Taipei" | Nothing

Drop elements which are not available (NA).

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> let ys = xs `require` Index.fromList ["Paris", "London", "Lisbon", "Toronto"]
>>> ys
    index |  values
    ----- |  ------
 "Lisbon" |  Just 4
 "London" |  Just 2
  "Paris" |  Just 1
"Toronto" | Nothing
>>> catMaybes ys
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1

\(O(n)\) Drop the index of a series by replacing it with an Int-based index. Values will be indexed from 0.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> dropIndex xs
index | values
----- | ------
    0 |      4
    1 |      2
    2 |      1

Select a subseries. There are a few ways to do this.

The first way to do this is to select a sub-series based on random keys. For example, selecting a subseries from an Index:

>>> let xs = Series.fromList [('a', 10::Int), ('b', 20), ('c', 30), ('d', 40)]
>>> xs `select` Index.fromList ['a', 'd']
index | values
----- | ------
  'a' |     10
  'd' |     40

The second way to select a sub-series is to select all keys in a range:

>>> xs `select` 'b' `to` 'c'
index | values
----- | ------
  'b' |     20
  'c' |     30

Note that with select, you'll always get a sub-series; if you ask for a key which is not in the series, it'll be ignored:

>>> xs `select` Index.fromList ['a', 'd', 'e']
index | values
----- | ------
  'a' |     10
  'd' |     40

See require if you want to ensure that all keys are present.

Select a sub-series from a series matching a condition.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> xs `selectWhere` (fmap (>1) xs)
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2

Datatype representing an inclusive range of keys, which can either be bounded or unbounded. The canonical ways to construct a Range are to use to, from, and upto:

>>> 'a' `to` 'z'
Range (from 'a' to 'z')
>>> from 'd'
Range (from 'd')
>>> upto 'q'
Range (up to 'q')

A Range can be used to efficiently select a sub-series with select.

Create a bounded Range which can be used for slicing. This function is expected to be used in conjunction with select.

For unbound ranges, see from and upto.

Create an unbounded Range which can be used for slicing. This function is expected to be used in conjunction with select.

For bound ranges, see to.

Create an unbounded Range which can be used for slicing. This function is expected to be used in conjunction with select.

For bound ranges, see to.

Class for datatypes which can be used to select sub-series using select.

There are two use-cases for select:

• Bulk random-access (selecting from an Index of keys);
• Bulk ordered access (selecting from a Range of keys).

See the documentation for select.

\(O(\log n)\). Extract a single value from a series, by key.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs `at` "Paris"
Just 1
>>> xs `at` "Sydney"
Nothing

\(O(1)\). Extract a single value from a series, by index.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> xs `iat` 0
Just 4
>>> xs `iat` 3
Nothing

Replace values in the right series from values in the left series at matching keys. Keys not in the right series are unaffected.

See (|->) and (<-|), which might be more readable.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> let ys = Series.singleton "Paris" (99::Int)
>>> ys `replace` xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |     99

Replace values in the right series from values in the left series at matching keys. Keys not in the right series are unaffected.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> let ys = Series.singleton "Paris" (99::Int)
>>> ys |-> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |     99

Replace values in the left series from values in the right series at matching keys. Keys not in the left series are unaffected.

>>> let xs = Series.fromList [("Paris", 1 :: Int), ("London", 2), ("Lisbon", 4)]
>>> xs
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |      1
>>> let ys = Series.singleton "Paris" (99::Int)
>>> xs <-| ys
   index | values
   ----- | ------
"Lisbon" |      4
"London" |      2
 "Paris" |     99

\(O(n)\) Replace all instances of Nothing with the last previous value which was not Nothing.

>>> let xs = Series.fromList (zip [0..] [Just 1, Just 2,Nothing, Just 3]) :: Series Int (Maybe Int)
>>> xs
index |  values
----- |  ------
    0 |  Just 1
    1 |  Just 2
    2 | Nothing
    3 |  Just 3
>>> forwardFill 0 xs
index | values
----- | ------
    0 |      1
    1 |      2
    2 |      2
    3 |      3

If the first entry of the series is missing, the first input to forwardFill will be used:

>>> let ys = Series.fromList (zip [0..] [Nothing, Just 2,Nothing, Just 3]) :: Series Int (Maybe Int)
>>> ys
index |  values
----- |  ------
    0 | Nothing
    1 |  Just 2
    2 | Nothing
    3 |  Just 3
>>> forwardFill 0 ys
index | values
----- | ------
    0 |      0
    1 |      2
    2 |      2
    3 |      3

Group values in a Series by some grouping function (k -> g). The provided grouping function is guaranteed to operate on a non-empty Series.

This function is expected to be used in conjunction with aggregateWith:

>>> import Data.Maybe ( fromMaybe )
>>> type Date = (Int, String)
>>> month :: (Date -> String) = snd
>>> :{
    let xs = Series.fromList [ ((2020, "January") :: Date,  0 :: Int)
                             , ((2021, "January"), -5)
                             , ((2020, "June")   , 20)
                             , ((2021, "June")   , 25) 
                             ]
     in xs `groupBy` month `aggregateWith` (fromMaybe 0 . minimum)
:}
    index | values
    ----- | ------
"January" |     -5
   "June" |     20

Representation of a Series being grouped.

Aggregate groups resulting from a call to groupBy:

>>> import Data.Maybe ( fromMaybe )
>>> type Date = (Int, String)
>>> month :: (Date -> String) = snd
>>> :{
    let xs = Series.fromList [ ((2020, "January") :: Date,  0 :: Int)
                             , ((2021, "January"), -5)
                             , ((2020, "June")   , 20)
                             , ((2021, "June")   , 25) 
                             ]
     in xs `groupBy` month `aggregateWith` (fromMaybe 0 . minimum)
:}
    index | values
    ----- | ------
"January" |     -5
   "June" |     20

If you want to aggregate groups using a binary function, see foldWith which may be much faster.

Aggregate each group in a Grouping using a binary function. While this is not as expressive as aggregateWith, users looking for maximum performance should use foldWith as much as possible.

General-purpose window aggregation.

>>> import qualified Data.Series as Series
>>> :{
    let (xs :: Series.Series Int Int) 
         = Series.fromList [ (1, 0)
                           , (2, 1)
                           , (3, 2)
                           , (4, 3)
                           , (5, 4)
                           , (6, 5)
                           ]
    in windowing (\k -> k `to` (k+2)) sum xs
:}
index | values
----- | ------
    1 |      3
    2 |      6
    3 |      9
    4 |     12
    5 |      9
    6 |      5

Expanding window aggregation.

>>> import qualified Data.Series as Series
>>> :{
    let (xs :: Series.Series Int Int) 
         = Series.fromList [ (1, 0)
                           , (2, 1)
                           , (3, 2)
                           , (4, 3)
                           , (5, 4)
                           , (6, 5)
                           ]
    in (xs `expanding` sum) :: Series.Series Int Int 
:}
index | values
----- | ------
    1 |      0
    2 |      1
    3 |      3
    4 |      6
    5 |     10
    6 |     15

\(O(n)\) Execute a Fold over a Series.

>>> let xs = Series.fromList (zip [0..] [1,2,3,4]) :: Series Int Double
>>> xs
index | values
----- | ------
    0 |    1.0
    1 |    2.0
    2 |    3.0
    3 |    4.0
>>> import Control.Foldl (variance)
>>> fold variance xs
1.25

See also foldM for monadic folds, and foldWithKey to take keys into account while folding.

\(O(n)\) Execute a monadic FoldM over a Series.

See also fold for pure folds, and foldMWithKey to take keys into account while folding.

\(O(n)\) Execute a Fold over a Series, taking keys into account.

\(O(n)\) Execute a monadic FoldM over a Series, where the FoldM takes keys into account.

\(O(n)\) Map each element and associated key of the structure to a monoid and combine the results.

Compute a numerically stable arithmetic mean of all elements

Compute a numerically stable (population) variance over all elements

Compute a numerically stable (population) standard deviation over all elements

\(O(1)\) Extract the length of a Series.

\(O(1)\) Test whether a Series is empty.

\(O(n)\) Check if all elements satisfy the predicate.

\(O(n)\) Check if any element satisfies the predicate.

\(O(n)\) Check if all elements are True.

\(O(n)\) Check if any element is True.

\(O(n)\) Compute the sum of the elements.

\(O(n)\) Compute the product of the elements.

\(O(n)\) Yield the maximum element of the series. In case of a tie, the first occurrence wins. If the Series is empty, Nothing is returned.

See also argmax.

\(O(n)\) maximumOn f xs teturns the maximum element of the series xs, as determined by the function f. In case of a tie, the first occurrence wins. If the Series is empty, Nothing is returned.

\(O(n)\) Yield the minimum element of the series. In case of a tie, the first occurrence wins. If the Series is empty, Nothing is returned.

See also argmin.

\(O(n)\) minimumOn f xs teturns the minimum element of the series xs, as determined by the function f. In case of a tie, the first occurrence wins. If the Series is empty, Nothing is returned.

\(O(n)\) Find the index of the minimum element in the input series. If the input series is empty, Nothing is returned.

The index of the first occurrence of the minimum element is returned. >>> :{ let (xs :: Series Int Int) = Series.fromList [ (1, 1) , (2, 1) , (3, 2) , (4, 0) , (5, 4) , (6, 5) ] in argmin xs :} Just 4

\(O(n)\) Find the index of the maximum element in the input series. If the input series is empty, Nothing is returned.

The index of the first occurrence of the maximum element is returned.

>>> :{
    let (xs :: Series Int Int) 
         = Series.fromList [ (1, 0)
                           , (2, 1)
                           , (3, 2)
                           , (4, 7)
                           , (5, 4)
                           , (6, 5)
                           ]
    in argmax xs 
:}
Just 4

\(O(n)\) Left-to-right postscan.

>>> let xs = Series.fromList (zip [0..] [1,2,3,4]) :: Series Int Int
>>> xs
index | values
----- | ------
    0 |      1
    1 |      2
    2 |      3
    3 |      4
>>> postscanl (+) 0 xs
index | values
----- | ------
    0 |      1
    1 |      3
    2 |      6
    3 |     10

\(O(n)\) Left-to-right prescan.

>>> let xs = Series.fromList (zip [0..] [1,2,3,4]) :: Series Int Int
>>> xs
index | values
----- | ------
    0 |      1
    1 |      2
    2 |      3
    3 |      4
>>> prescanl (+) 0 xs
index | values
----- | ------
    0 |      0
    1 |      1
    2 |      3
    3 |      6

Display a Series using default DisplayOptions.

>>> let xs = Series.fromList (zip [0..] [1,2,3,4,5,6,7]) :: Series Int Int
>>> putStrLn $ display xs
index | values
----- | ------
    0 |      1
    1 |      2
    2 |      3
  ... |    ...
    4 |      5
    5 |      6
    6 |      7

Display a Series using customizable DisplayOptions.

>>> let xs = Series.fromList (zip [0..] [1,2,3,4,5,6,7]) :: Series Int Int
>>> import Data.List (replicate)
>>> :{
    let opts = DisplayOptions { maximumNumberOfRows  = 4
                              , indexHeader = "keys"
                              , valuesHeader = "vals"
                              , keyDisplayFunction   = (\i -> replicate i 'x') `noLongerThan` 5
                              , valueDisplayFunction = (\i -> replicate i 'o') 
                              }
     in putStrLn $ displayWith opts xs
:}
  keys |    vals
 ----- |  ------
       |       o
     x |      oo
   ... |     ...
 xxxxx |  oooooo
xxx... | ooooooo

This function modifies existing functions to limit the width of its result.

>>> let limit7 = (show :: Int -> String) `noLongerThan` 7
>>> limit7 123456789
"123456..."

Options controlling how to display Series in the displayWith function. Default options are provided by defaultDisplayOptions.

To help with creating DisplayOptions, see noLongerThan.

Default Series display options.