object EmptyTimeSeries extends TimeSeries[Nothing] with Product with Serializable
A time series that is never defined.
- Alphabetic
- By Inheritance
- EmptyTimeSeries
- Serializable
- Product
- Equals
- TimeSeries
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- def *[U >: Nothing](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]
- Definition Classes
- TimeSeries
- def +[U >: Nothing](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]
- Definition Classes
- TimeSeries
- def -[U >: Nothing](other: TimeSeries[U])(implicit n: Numeric[U]): TimeSeries[U]
- Definition Classes
- TimeSeries
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def append[U >: Nothing](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.
- Definition Classes
- TimeSeries
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def at(t: Long): Option[Nothing]
The value valid at time 't' if there is one.
The value valid at time 't' if there is one.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def bucket(buckets: Stream[Long]): Stream[(Long, TimeSeries[Nothing])]
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).
- Definition Classes
- TimeSeries
- def clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- 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]
- Definition Classes
- TimeSeries
- def entries: Seq[TSEntry[Nothing]]
Return a Seq of the TSEntries representing this time series.
Return a Seq of the TSEntries representing this time series.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def entryAt(t: Long): Option[TSEntry[Nothing]]
The whole entry containing the value valid at time 't', if there is one
The whole entry containing the value valid at time 't', if there is one
- Definition Classes
- EmptyTimeSeries → TimeSeries
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def fallback[U >: Nothing](other: TimeSeries[U]): TimeSeries[U]
Fallback to
otherwhenthisis not definedFallback to
otherwhenthisis not defined- U
The new underlying parameter
- other
Another time series which should contain the value when
thisis not defined- returns
A time series which contains the values of
thisif defined, and ofotherotherwise
- Definition Classes
- TimeSeries
- def fill[U](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.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def filter(predicate: (TSEntry[Nothing]) => Boolean): TimeSeries[Nothing]
Return a time series that will only contain entries for which the passed predicate returned True.
Return a time series that will only contain entries for which the passed predicate returned True.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def filterValues(predicate: (Nothing) => Boolean): TimeSeries[Nothing]
Return a time series that will only contain entries containing values for which the passed predicate returned True.
Return a time series that will only contain entries containing values for which the passed predicate returned True.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def head: TSEntry[Nothing]
Return the first (chronological) entry in this time series.
Return the first (chronological) entry in this time series.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- Exceptions thrown
NoSuchElementExceptionif this time series is empty.
- def headOption: Option[TSEntry[Nothing]]
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.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def headValue: Nothing
Return the first (chronological) value in this time series.
Return the first (chronological) value in this time series.
- Definition Classes
- TimeSeries
- Exceptions thrown
NoSuchElementExceptionif this time series is empty.
- def headValueOption: Option[Nothing]
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.
- Definition Classes
- TimeSeries
- 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.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- 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.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def isEmpty: Boolean
Convenient and efficient method for
size == 0Convenient and efficient method for
size == 0- Definition Classes
- EmptyTimeSeries → TimeSeries
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def last: TSEntry[Nothing]
Return the last (chronological) entry in this time series.
Return the last (chronological) entry in this time series.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- Exceptions thrown
NoSuchElementExceptionif this time series is empty.
- def lastOption: Option[TSEntry[Nothing]]
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.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def lastValue: Nothing
Return the last (chronological) value in this time series.
Return the last (chronological) value in this time series.
- Definition Classes
- TimeSeries
- Exceptions thrown
NoSuchElementExceptionif this time series is empty.
- def lastValueOption: Option[Nothing]
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.
- Definition Classes
- TimeSeries
- 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
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def map[O](f: (Nothing) => 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
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def mapWithTime[O](f: (Long, Nothing) => 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.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def merge[O, R](op: (Option[Nothing], 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).
- Definition Classes
- TimeSeries
- def minus[U >: Nothing](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.
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.
- Definition Classes
- TimeSeries
- def multiply[U >: Nothing](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.
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.
- Definition Classes
- TimeSeries
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- 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
- Definition Classes
- TimeSeries
- def nonEmpty: Boolean
Convenient method for !isEmpty
Convenient method for !isEmpty
- Definition Classes
- TimeSeries
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def plus[U >: Nothing](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.
- Definition Classes
- TimeSeries
- def prepend[U >: Nothing](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.
- Definition Classes
- TimeSeries
- def productElementName(n: Int): String
- Definition Classes
- Product
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- def rollup[R](buckets: Stream[Long], aggregator: (TimeSeries[Nothing]) => 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.
- Definition Classes
- TimeSeries
- def sample(start: Long, sampleRate: Long, useClosestInWindow: Boolean, compress: Boolean = false): TimeSeries[Nothing]
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
- Definition Classes
- TimeSeries
- Note
In either case, this function does **not** perform any kind of aggregation or roll-up.
- def size: Int
The number of elements in this time series.
The number of elements in this time series.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def slice(from: Long, to: Long): TimeSeries[Nothing]
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.
- Definition Classes
- TimeSeries
- def sliceDiscrete(from: Long, to: Long, fromInclusive: Boolean = true, toInclusive: Boolean = true): TimeSeries[Nothing]
Extract a slice from this time series, while preventing entries on the slice boundaries from being split.
Extract a slice from this time series, while preventing entries on the slice boundaries from being split.
- Definition Classes
- TimeSeries
- def slidingIntegral[U >: Nothing](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
- Definition Classes
- TimeSeries
- def split(at: Long): (TimeSeries[Nothing], TimeSeries[Nothing])
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))
- Definition Classes
- TimeSeries
- def splitDiscrete(at: Long, splitAfterEntry: Boolean = true): (TimeSeries[Nothing], TimeSeries[Nothing])
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'
- Definition Classes
- TimeSeries
- def splitEntriesLongerThan(sampleLengthMs: Long): TimeSeries[Nothing]
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.
- returns
timeseries with entries guaranteed to be shorter than the given maximal length
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def stepIntegral[U >: Nothing](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.
- Definition Classes
- TimeSeries
- def strictMerge[O, R](op: (Nothing, 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
- Definition Classes
- TimeSeries
- def strictZip[O](other: TimeSeries[O]): TimeSeries[(Nothing, 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.
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.
- Definition Classes
- TimeSeries
- def supportRatio: Double
- returns
The probability that the time series is defined over its loose-domain
- Definition Classes
- EmptyTimeSeries → TimeSeries
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def trimLeft(at: Long): TimeSeries[Nothing]
Returns a time series that is never defined for t < at and unchanged for t >= at
Returns a time series that is never defined for t < at and unchanged for t >= at
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def trimLeftDiscrete(at: Long, includeEntry: Boolean): TimeSeries[Nothing]
Similar to trimLeft, but if
atlands within an existing entry, the returned time series' domain is either, depending on 'includeEntry':Similar to trimLeft, but if
atlands 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
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def trimRight(at: Long): TimeSeries[Nothing]
Returns a time series that is never defined for t >= at and unchanged for t < at
Returns a time series that is never defined for t >= at and unchanged for t < at
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def trimRightDiscrete(at: Long, includeEntry: Boolean): TimeSeries[Nothing]
Similar to trimRight, but if
atlands within an existing entry, the returned time series' domain is either, depending on 'includeEntry':Similar to trimRight, but if
atlands 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
- Definition Classes
- EmptyTimeSeries → TimeSeries
- def values: Seq[Nothing]
Return a Seq of the values contained by this series, in their chronological order.
Return a Seq of the values contained by this series, in their chronological order.
- Definition Classes
- EmptyTimeSeries → TimeSeries
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Deprecated Value Members
- def integrateBetween[U >: Nothing](from: Long, to: Long)(implicit n: Numeric[U]): U
- Definition Classes
- TimeSeries
- Annotations
- @deprecated
- Deprecated
This function does only sum values in a slice of the series. Use slice and stepIntegral or slidingIntegral.