carldata/timeseries

Time Series library for Scala

timeseries's Issues

Update TimeConverter

Support for:
-x * * * *
-* x * * *
,for after/equal.

Add join for 2 series

Join should work on index and the output value is tuple with values from first and second series

Add function interpolateOutliers

Generator for random walk series

Add rolling window operation

def rollingWindow(windowSize: Duration, stepSize: Duration, f: Seq[V] => V): TimeSeries[V]

TimeConverter should handle 0 0 */1 * *

It should be: “At 00:00 on every day-of-month.”
Currently TimeConverter set time for this cron to 23:00

Add prediction engine

• Implement as separate module.
• Allow to specify range for prediction
• Use different models.
• Add benchmarks

Allow TS to use any type as its value (not only numeric)

Allow compilation to scala.js

This will at least require changes to:

• index data type
• some functions which operates on index

Add groupBy

Group data by time range

repeat

Repeat series for given period

Implement group by hour

Generator for constant TS

Refactor integrateByTime function

Currently this function takes as a parameter Duration.
Instead it should take function LocalDateTime => LocalDateTime and reset to 0 when transformed DateTime has new value.
This transformation is used only to find switch point. The index will remain the same.

Implement toCSV function

Add interpolate and find_missing functions

-> refactor resample

Implemented overflow differentiate

This function is motivated by the following use case:

Older sensor equipment often used simple counters to record events. These counters would continue to some max value (i.e. 100) and then rollover to 0

diffOverflow return TS with wrong indexes

This function should return timeseries with length of indexes vector less than provided in arguments.

Create function to compare two timeseries

def almostEqual[V: Numeric](xs: TimeSeries[V], ys: TimeSeries[V], epsilon: Numeric[V]): Boolean

Add trimOutliers function

Provide min and max value as a parameters

Remove "forward" param from shiftTime function

Duration can be used with negative values for shifting backward in time

Check if series is stationary

New repeat function

def repeat(start: Instant, end: Instant, repetitionStart: Instant, repetitionEnd: Instant): TimeSeries[V] 

Try making findSessions(ts: TimeSeries[V], maxTolerance: Duration) faster

Current implementation is not effective

Add function addMissing

this function adds missing points without resampling index

Periodic constant

Create time series for a given time range with constant value

Add outer join

def joinOuter[U](ts: TimeSeries[U], defaultLeft: V, defaultRight: U): TimeSeries[(V, U)]

This join will work similar to SQL full outer join

Add step function

Ensure that index is monotonically increasing and the same size as values

Generator for random noise series

Move outliers functions to separate module

New module name: Outliers..
Functions to move:

• removeOutliers
• trimOutliers
• interpolateOutliers

Add shift function.

TimeConverter: converter return wrong time with seconds and ms

Add resampling

Resample based on index

inner join for multiple series

TimeSeries.join(series: Seq[TimeSeries]): TimeSeries

Create inner join within all series in the sequence.

integrateByTime

Integrate series for selected time ranges.
Example:
Lets say that we have series with data every 15 minutes.
(10:00, 1), (10:15, 2), (10:30, 3), (10:45, 4), (11:00, 5), (11:15, 6)
And we want to integrate it for every hour. So we expected the following series:
(10:00, 1), (10:15, 3), (10:30, 6), (10:45, 10), (11:00, 5), (11:15, 11)

The sum is reseted after every hour

Create diffOverflow function without overflowValue

Add TimeConverter

• mkCronLike function to parse cron
• mkConvert function which convert custom cron type, like:

mkConvert(c: CronLike): LocalDateTime => LocalDateTime

Update function parameter in groupByTime

Change

def groupByTime(g: LocalDateTime => LocalDateTime, f: Seq[V] => V): TimeSeries[V]

to
def groupByTime(g: LocalDateTime => LocalDateTime, f: Seq[(LocalDateTime, V)] => V): TimeSeries[V]

Add session finder with tolerance

Add a new (version of) findSessions function to Sessions object, with the following signature

def findSessions[V: Numeric](ts: TimeSeries[V], maxTolerance: Duration): Seq[Session]

where Duration is java.time.Duration, which works exactly as
def findSessions[V: Numeric](ts: TimeSeries[V]): Seq[Session]
with the additional tolerance of non-positive samples for at most maxDuration window.

Implement I(d) from ARIMA

Differentiate d times

Add covariance between 2 series

Add last

Add a function which give a last element of TimeSeries.

Add session finder

Add object Analysis with function:

def findSessions[V: Fractional](ts: TimeSeries[V]): Seq[Session]

Where session contains start and end date.
Session is defined as period where values are > 0.
For example in a given series values:
1, 3, 2, 0, 4,5
We have 2 sessions (0,3) and (4,6) (startIndex, endIndex)
End date is on the first sample where the value is == 0

Add mapValues

Improve functions efficiency

1. Measure: map
100000 points: 10.568595 ms.
500000 points: 55.22252 ms.
1000000 points: 45.036296 ms.

2. Measure: groupBy
100000 points: 339.662496 ms.
500000 points: 2098.315767 ms.
1000000 points: 5014.337623 ms.

3. Measure: rollingWindow
1000 points: 23.720139 ms.
5000 points: 597.484543 ms.
10000 points: 2347.1362 ms.

Generator for repeated series

Add the possiblity to merge 2 series

Series are merged on index.
This operation merges series A into B which means that, the output series will contain all values from B and all from A not presented in B (values from B overwrites values in A)

Add removeOutliers function.

Check index based on timestamp instead of LocalDateTime