carldata/timeseries

Time Series library for Scala

timeseries's Issues

Check index based on timestamp instead of LocalDateTime

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

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

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.

Add mapValues

Update TimeConverter

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

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)

Implement I(d) from ARIMA

Differentiate d times

Generator for repeated series

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

Check if series is stationary

Add TimeConverter

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

mkConvert(c: CronLike): LocalDateTime => LocalDateTime

Generator for random noise series

Add removeOutliers function.

diffOverflow return TS with wrong indexes

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

Add groupBy

Group data by time range

Add trimOutliers function

Provide min and max value as a parameters

repeat

Repeat series for given period

Add join for 2 series

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

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

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

Current implementation is not effective

Add resampling

Resample based on index

Add rolling window operation

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

Generator for constant TS

Move outliers functions to separate module

New module name: Outliers..
Functions to move:

• removeOutliers
• trimOutliers
• interpolateOutliers

inner join for multiple series

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

Create inner join within all series in the sequence.

Periodic constant

Create time series for a given time range with constant value

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]

Implement toCSV function

Allow compilation to scala.js

This will at least require changes to:

• index data type
• some functions which operates on index

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

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.

Remove "forward" param from shiftTime function

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

Add interpolate and find_missing functions

-> refactor resample

Add covariance between 2 series

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.

Generator for random walk series

Add step function

Create diffOverflow function without overflowValue

Create function to compare two timeseries

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

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 last

Add a function which give a last element of TimeSeries.

Add shift function.

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

New repeat function

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

Add function interpolateOutliers

Add prediction engine

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

TimeConverter: converter return wrong time with seconds and ms

Implement group by hour

Add function addMissing

this function adds missing points without resampling index