Packages

trait TimeSeries[+T] extends AnyRef

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TimeSeries
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def at(t: Long): Option[T]

    The value valid at time 't' if there is one.

  2. abstract def entries: Seq[TSEntry[T]]

    Return a Seq of the TSEntries representing this time series.

  3. abstract def entryAt(t: Long): Option[TSEntry[T]]

    The whole entry containing the value valid at time 't', if there is one

  4. abstract def fill[U >: T](whenUndef: U): TimeSeries[U]

    Fill the wholes in the definition domain of this time series with the passed value.

    Fill the wholes in the definition domain of this time series with the passed value. The resulting time series will have a single continuous definition domain, provided the original time series was non-empty.

  5. abstract def filter(predicate: (TSEntry[T]) => Boolean): TimeSeries[T]

    Return a time series that will only contain entries for which the passed predicate returned True.

  6. abstract def filterValues(predicate: (T) => Boolean): TimeSeries[T]

    Return a time series that will only contain entries containing values for which the passed predicate returned True.

  7. abstract def head: TSEntry[T]

    Return the first (chronological) entry in this time series.

    Return the first (chronological) entry in this time series.

    Exceptions thrown

    NoSuchElementException if this time series is empty.

  8. abstract def headOption: Option[TSEntry[T]]

    Return a filled option containing the first (chronological) entry in this time series.

    Return a filled option containing the first (chronological) entry in this time series. None if this time series is empty.

  9. abstract def isCompressed: Boolean

    Returns true if it is guaranteed that this timeseries was compressed at construction.

    Returns true if it is guaranteed that this timeseries was compressed at construction. If this returns false it is not known whether the series has been compressed.

  10. abstract def isDomainContinuous: Boolean

    Returns true if it is guaranteed that this timeseries is defined for all t in its looseDomain.

    Returns true if it is guaranteed that this timeseries is defined for all t in its looseDomain. I. e. whether there are holes in its time domain or not. If this returns false it is not known whether the series has been compressed.

  11. abstract def isEmpty: Boolean

    Convenient and efficient method for size == 0

  12. abstract def last: TSEntry[T]

    Return the last (chronological) entry in this time series.

    Return the last (chronological) entry in this time series.

    Exceptions thrown

    NoSuchElementException if this time series is empty.

  13. abstract def lastOption: Option[TSEntry[T]]

    Return a filled option containing the last (chronological) entry in this time series.

    Return a filled option containing the last (chronological) entry in this time series. None if this time series is empty.

  14. abstract def looseDomain: TimeDomain

    Returns the bounds of the domain

    Returns the bounds of the domain

    If the time series does not contain any "hole" in its domain, then the loose domain is equal to its domain. Otherwise, the loose domain only contains the min/max bounds of the domain.

    Said otherwise, the time series is guaranteed to be undefined outside of the loose domain, and has at least a point where it is defined within the loose domain.

    returns

    The oldest and newest timestamps where the time series is defined, encapsulated in a LooseDomain

  15. abstract def map[O](f: (T) => O, compress: Boolean = true)(implicit arg0: scala.reflect.api.JavaUniverse.WeakTypeTag[O]): TimeSeries[O]

    Map the values within the time series.

    Map the values within the time series. the 'compress' parameters allows callers to control whether or not compression should occur. If set to false, timestamps and validities remain unchanged. Defaults to true

  16. abstract def mapWithTime[O](f: (Long, T) => O, compress: Boolean = true)(implicit arg0: scala.reflect.api.JavaUniverse.WeakTypeTag[O]): TimeSeries[O]

    Map the values within the time series.

    Map the values within the time series. Timestamps and validities of entries remain unchanged, but the time is made available for cases where the new value would depend on it.

  17. abstract def size: Int

    The number of elements in this time series.

  18. abstract def supportRatio: Double

    returns

    The probability that the time series is defined over its loose-domain

  19. abstract def trimLeft(at: Long): TimeSeries[T]

    Returns a time series that is never defined for t < at and unchanged for t >= at

  20. abstract def trimLeftDiscrete(at: Long, includeEntry: Boolean = true): TimeSeries[T]

    Similar to trimLeft, but if at lands within an existing entry, the returned time series' domain is either, depending on 'includeEntry':

    Similar to trimLeft, but if at lands within an existing entry, the returned time series' domain is either, depending on 'includeEntry':

    • extended to that entry's timestamp, which fully remains in the time series (the default)
    • trimmed further to the next entry's timestamp, fully removing the entry from the time series
  21. abstract def trimRight(at: Long): TimeSeries[T]

    Returns a time series that is never defined for t >= at and unchanged for t < at

  22. abstract def trimRightDiscrete(at: Long, includeEntry: Boolean = true): TimeSeries[T]

    Similar to trimRight, but if at lands within an existing entry, the returned time series' domain is either, depending on 'includeEntry':

    Similar to trimRight, but if at lands within an existing entry, the returned time series' domain is either, depending on 'includeEntry':

    • extended to that entry's end of validity, which fully remains in the time series (the default)
    • trimmed further to the previous entry's end of validity, fully removing the entry from the time series

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def *[U >: T](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]
  4. def +[U >: T](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]
  5. def -[U >: T](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def append[U >: T](other: TimeSeries[U], compress: Boolean = true): TimeSeries[U]

    Append the 'other' time series to this one at exactly the first of other's entries timestamp.

    Append the 'other' time series to this one at exactly the first of other's entries timestamp.

    if t_app = other.head.timestamp, this time series domain will be completely forgotten for all t > t_app, and replaced with whatever is in the domain of 'other'.

    This is equivalent to right-trimming this time series at other.head.timestamp and prepending it as-is to 'other'.

    If 'other' is empty, this time series is unchanged.

  8. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  9. def bucket(buckets: Stream[Long]): Stream[(Long, TimeSeries[T])]

    Buckets this TimeSeries into sub-time series that have a domain of definition that is at most that specified by the passed bucket boundaries.

    Buckets this TimeSeries into sub-time series that have a domain of definition that is at most that specified by the passed bucket boundaries.

    buckets

    a stream of times representing bucket boundaries. A stream of (a, b, c, ...) will generate buckets with domain (([a, b[), ([b, c[), ...) Note that it is wise to have 'buckets' start at a meaningfully close point in time relative to the time series first entry.

    returns

    a stream of (bucket-start, timeseries).

  10. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  11. def defined(t: Long): Boolean

    True if this time series is defined at 'at'.

    True if this time series is defined at 'at'. Ie, at('at') would return Some[T]

  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  14. def fallback[U >: T](other: TimeSeries[U]): TimeSeries[U]

    Fallback to other when this is not defined

    Fallback to other when this is not defined

    U

    The new underlying parameter

    other

    Another time series which should contain the value when this is not defined

    returns

    A time series which contains the values of this if defined, and of other otherwise

  15. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  16. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  18. def headValue: T

    Return the first (chronological) value in this time series.

    Return the first (chronological) value in this time series.

    Exceptions thrown

    NoSuchElementException if this time series is empty.

  19. def headValueOption: Option[T]

    Return a filled option containing the first (chronological) value in this time series.

    Return a filled option containing the first (chronological) value in this time series. None if this time series is empty.

  20. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  21. def lastValue: T

    Return the last (chronological) value in this time series.

    Return the last (chronological) value in this time series.

    Exceptions thrown

    NoSuchElementException if this time series is empty.

  22. def lastValueOption: Option[T]

    Return a filled option containing the last (chronological) value in this time series.

    Return a filled option containing the last (chronological) value in this time series. None if this time series is empty.

  23. def merge[O, R](op: (Option[T], Option[O]) => Option[R])(other: TimeSeries[O]): TimeSeries[R]

    Merge another time series to this one, using the provided operator to merge entries.

    Merge another time series to this one, using the provided operator to merge entries.

    The operator can define all four cases encountered during merging:

    • both entries defined
    • only one of the entries defined
    • no entry defined

    In any case, the returned time series will only be defined between the bounds defined by min(this.head.timestamp, other.head.timestamp) and max(this.last.definedUntil, other.last.definedUntil).

  24. def minus[U >: T](other: TimeSeries[U], leftHandDefault: Option[U] = None, rightHandDefault: Option[U] = None)(implicit n: Numeric[U]): TimeSeries[U]

    Subtract the entries within this and the provided time series such that this.at(x) - other.at(x) = returned.at(x) where x may take any value where both time series are defined.

  25. def multiply[U >: T](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]

    Multiply the entries within this and the provided time series such that this.at(x) * other.at(x) = returned.at(x) where x may take any value where both time series are defined.

  26. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  27. def newBuilder[U](compress: Boolean = true)(implicit tag: scala.reflect.api.JavaUniverse.WeakTypeTag[U]): TimeSeriesBuilder[U]

    returns

    a builder that constructs a new timeseries of this implementation

  28. def nonEmpty: Boolean

    Convenient method for !isEmpty

  29. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  30. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  31. def plus[U >: T](other: TimeSeries[U], strict: Boolean = true)(implicit n: Numeric[U]): TimeSeries[U]

    Sum the entries within this and the provided time series such that

    Sum the entries within this and the provided time series such that

    - If strict (default): this.at(x) + other.at(x) = returned.at(x) where x may take any value where both time series are defined. - If non strict : this.at(x) + other.at(x) = returned.at(x) where x may take any value where any time series is defined.

  32. def prepend[U >: T](other: TimeSeries[U], compress: Boolean = true): TimeSeries[U]

    Prepend the 'other' time series to this one at exactly the last of other's entries definedUntil().

    Prepend the 'other' time series to this one at exactly the last of other's entries definedUntil().

    if t_prep = other.last.definedUntil, this time series domain will be completely forgotten for all t <= t_prep, and replaced with whatever is in the domain of 'other'.

    This is equivalent to left-trimming this time series at other.last.definedUntil and appending it as-is with to 'other'.

    If 'other' is empty, this time series is unchanged.

  33. def rollup[R](buckets: Stream[Long], aggregator: (TimeSeries[T]) => R): TimeSeries[R]

    Given the passed bucket delimiters, apply 'aggregator' for each generated bucket.

    Given the passed bucket delimiters, apply 'aggregator' for each generated bucket.

    Note that the timestamps and validities of the entries present in the returned timeseries are ONLY driven by the boundaries generated by 'buckets': the first and last entry may well be defined outside of the domain of definition of this time series

    R

    the type returned by the aggregator

    buckets

    a stream generating the bucket boundaries for the rollup/aggregation

    aggregator

    a function that computes an aggregate over a time series

    returns

    a TimeSeries, the values of which are generated by the aggregator and the entries' domains are defined by the respective buckets.

  34. def sample(start: Long, sampleRate: Long, useClosestInWindow: Boolean, compress: Boolean = false): TimeSeries[T]

    Sample this TimeSeries at fixed time intervals of length sampleRate starting at the start timestamp.

    Sample this TimeSeries at fixed time intervals of length sampleRate starting at the start timestamp. By default, all resulting entries will have the duration of sampleRate. If equal contiguous entries are compressed (set the compress flag) all entries have a duration that is a multiple of sampleRate.

    In the strict mode (useClosestInWindow = false), the sampled values are exactly equal to the value of this TimeSeries at the sample points. In the useClosestInWindow mode, the sampling looks at the entries in the window of [samplePoint - sampleRate/2, samplePoint + sampleRate/2[. The value of the entry that starts the closest to the samplePoint among those starting in the window is taken.

    start

    timestamp of first sample point

    sampleRate

    interval between sample points

    useClosestInWindow

    enables non-strict look-around sampling

    compress

    specifies whether equal contiguous entries should be compressed

    returns

    the sampled time series

    Note

    In either case, this function does **not** perform any kind of aggregation or roll-up.

  35. def slice(from: Long, to: Long): TimeSeries[T]

    Extract a slice from this time series.

    Extract a slice from this time series.

    The returned slice will only be defined between the specified bounds such that:

    this.at(x) == returned.at(x) for all x in [from, to[.

    If x is outside of the bounds, returned.at(x) is None.

  36. def sliceDiscrete(from: Long, to: Long, fromInclusive: Boolean = true, toInclusive: Boolean = true): TimeSeries[T]

    Extract a slice from this time series, while preventing entries on the slice boundaries from being split.

  37. def slidingIntegral[U >: T](window: Long, sampleRate: Long, timeUnit: TimeUnit = TimeUnit.MILLISECONDS)(implicit n: Numeric[U]): TimeSeries[Double]

    Compute a new time series that will contain, for any query time t, the integral over the entries present in this time series that are defined for a time between t - window and t.

    Compute a new time series that will contain, for any query time t, the integral over the entries present in this time series that are defined for a time between t - window and t.

    Note: returns a step function, meaning that there is a slight level of imprecision depending on your resolution. The bigger the window is relative to the sampleRate, the smaller the imprecision becomes.

    window

    width of the window

    sampleRate

    frequency of resampling

    timeUnit

    time unit used for this entry. By default, milliseconds are assumed.

    returns

    a TimeSeries that for any queried time will return an approximate integral of this time series over the past window

  38. def split(at: Long): (TimeSeries[T], TimeSeries[T])

    Split this time series into two.

    Split this time series into two.

    Returns a tuple of two contiguous time series, such that the left time series is never defined for t >= 'at' and the right time series is never defined for t < 'at'.

    Default implementation simply returns (this.trimRight(at), this.trimLeft(at))

  39. def splitDiscrete(at: Long, splitAfterEntry: Boolean = true): (TimeSeries[T], TimeSeries[T])

    Split this time series into two.

    Split this time series into two.

    If 'at' is within the domain of a particular entry, the time series will be split either at the beginning or end of that entry, according to the passed 'splitAfterEntry'

  40. def splitEntriesLongerThan(entryMaxLength: Long): TimeSeries[T]

    Splits up all entries of this timeseries that are longer than the given maximal length.

    Splits up all entries of this timeseries that are longer than the given maximal length. This is slightly similar but not strictly equivalent to resampling a series: if you need some form of resampling, make sure this is what you need.

    entryMaxLength

    to use for splitting

    returns

    timeseries with entries guaranteed to be shorter than the given maximal length

  41. def stepIntegral[U >: T](stepLengthMs: Long, timeUnit: TimeUnit = TimeUnit.MILLISECONDS)(implicit n: Numeric[U]): TimeSeries[Double]

    Computes the integral of this time series.

    Computes the integral of this time series. This function returns a step function, so only represents an approximation. Use it if you need to compute multiple integrals of the same time series.

  42. def strictMerge[O, R](op: (T, O) => R)(other: TimeSeries[O]): TimeSeries[R]

    Merge another time series to this one, using the provided operator to merge entries.

    Merge another time series to this one, using the provided operator to merge entries. The resulting series has the value defined by the operator at all times where both input series are defined. At all other times (i.e. where only one or none of the input series is defined), the resulting series is not defined.

    op

    the operator for the merge

    other

    TimeSeries to merge

    returns

    the strictly merged TimeSeries

  43. def strictZip[O](other: TimeSeries[O]): TimeSeries[(T, O)]

    Zips this time series with another one, returning a time series of tuples containing the values from both this and the other time series across their common domain.

  44. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  45. def toString(): String
    Definition Classes
    AnyRef → Any
  46. def values: Seq[T]

    Return a Seq of the values contained by this series, in their chronological order.

  47. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  48. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  49. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Deprecated Value Members

  1. def integrateBetween[U >: T](from: Long, to: Long)(implicit n: Numeric[U]): U
    Annotations
    @deprecated
    Deprecated

    This function does only sum values in a slice of the series. Use slice and stepIntegral or slidingIntegral.

Inherited from AnyRef

Inherited from Any

Ungrouped