com.cloudera.sparkts

UnivariateTimeSeries

object UnivariateTimeSeries

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. UnivariateTimeSeries
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. def ar(values: Vector, maxLag: Int): ARModel

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  8. def autocorr(ts: Vector, numLags: Int): Vector

    Computes the sample autocorrelation of the given series.

  9. def autocorr(ts: Array[Double], numLags: Int): Array[Double]

  10. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  11. def differencesAtLag(ts: Vector, lag: Int): Vector

    Convenience wrapper around differencesAtLag[Vector[Double], Vector[Double], Int, Int]

    Convenience wrapper around differencesAtLag[Vector[Double], Vector[Double], Int, Int]

    ts

    vector to difference

    lag

    the difference lag (e.g. x means destTs(i) = ts(i) - ts(i - x), etc)

    returns

    the differenced vector, for convenience

  12. def differencesAtLag(ts: Vector, destTs: Vector, lag: Int, startIndex: Int): Vector

    Difference a vector with respect to the m-th prior element.

    Difference a vector with respect to the m-th prior element. Size-preserving by leaving first m elements intact. This is the inverse of the inverseDifferences function.

    ts

    Series to difference

    destTs

    Series to store the differenced values (and return for convenience)

    lag

    The difference lag (e.g. x means destTs(i) = ts(i) - ts(i - x), etc)

    startIndex

    the starting index for the differencing. Must be at least equal to lag

    returns

    the differenced vector, for convenience

  13. def differencesOfOrderD(ts: Vector, d: Int): Vector

    Performs differencing of order d.

    Performs differencing of order d. This means we recursively difference a vector a total of d-times. So that d = 2 is a vector of the differences of differences. Note that for each difference level, d_i, the element at ts(d_i - 1) corresponds to the value in the prior iteration.

    ts

    time series to difference

    d

    order of differencing

    returns

    a vector of the same length differenced to order d

  14. def downsample(values: Vector, n: Int, phase: Int = 0): DenseVector

    Down sample by taking every nth element starting from offset phase

    Down sample by taking every nth element starting from offset phase

    values

    Vector to down sample

    n

    take every nth element

    phase

    offset from starting index

    returns

    downsampled vector with appropriate length

  15. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  16. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  17. def fillLinear(values: Vector): DenseVector

  18. def fillLinear(values: Array[Double]): Array[Double]

  19. def fillNearest(values: Vector): DenseVector

  20. def fillNearest(values: Array[Double]): Array[Double]

  21. def fillNext(values: Vector): DenseVector

    fills in NaN with the next available not NaN, scanning from right to left.

    fills in NaN with the next available not NaN, scanning from right to left. 1 NaN NaN 2 Nan -> 1 2 2 2 NaN

  22. def fillNext(values: Array[Double]): Array[Double]

  23. def fillPrevious(values: Vector): DenseVector

    fills in NaN with the previously available not NaN, scanning from left to right.

    fills in NaN with the previously available not NaN, scanning from left to right. 1 NaN NaN 2 Nan -> 1 1 1 2 2

  24. def fillPrevious(values: Array[Double]): Array[Double]

  25. def fillSpline(values: Vector): DenseVector

    Fill in NaN values using a natural cubic spline.

    Fill in NaN values using a natural cubic spline.

    values

    Vector to interpolate

    returns

    Interpolated vector

  26. def fillSpline(values: Array[Double]): Array[Double]

  27. def fillValue(values: Vector, filler: Double): DenseVector

    Replace all NaNs with a specific value

  28. def fillValue(values: Array[Double], filler: Double): Array[Double]

    Replace all NaNs with a specific value

  29. def fillWithDefault(values: Vector, filler: Double): DenseVector

    fills in NaN with a default value

  30. def fillWithDefault(values: Array[Double], filler: Double): Array[Double]

  31. def fillts(ts: Vector, fillMethod: String): Vector

  32. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  33. def firstNotNaN(ts: Vector): Int

  34. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  35. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  36. def inverseDifferencesAtLag(diffedTs: Vector, lag: Int): Vector

    Convenience wrapper around inverseDifferencesAtLag[Vector[Double], Vector[Double], Int, Int]

    Convenience wrapper around inverseDifferencesAtLag[Vector[Double], Vector[Double], Int, Int]

    diffedTs

    differenced vector that we want to inverse

    lag

    the difference lag (e.g. x means destTs(i) = ts(i) - ts(i - x), etc)

    returns

    the inverse differenced vector, for convenience

  37. def inverseDifferencesAtLag(diffedTs: Vector, destTs: Vector, lag: Int, startIndex: Int): Vector

    Calculate an "inverse-differenced" vector of a given lag.

    Calculate an "inverse-differenced" vector of a given lag. Size-preserving by leaving first startIndex elements intact. This is the inverse of the differences function.

    diffedTs

    differenced vector that we want to inverse

    destTs

    Series to store the added up values (and return for convenience)

    lag

    The difference lag (e.g. x means destTs(i) = diffedTs(i) + destTs(i - x), etc)

    startIndex

    the starting index for the differencing. Must be at least equal to lag

    returns

    the inverse differenced vector, for convenience

  38. def inverseDifferencesOfOrderD(diffedTs: Vector, d: Int): Vector

    Inverses differencing of order d.

    Inverses differencing of order d.

    diffedTs

    time series to reverse differencing process

    d

    order of differencing

    returns

    a vector of the same length, which when differenced to order ts, yields the original vector provided

  39. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  40. def lag(ts: Vector, maxLag: Int, includeOriginal: Boolean): Matrix

    Lags the univariate time series

    Lags the univariate time series

    Example input vector: (1.0, 2.0, 3.0, 4.0, 5.0)

    With lag 2 and includeOriginal = true should give output matrix:

    3.0 2.0 1.0 4.0 3.0 2.0 5.0 4.0 3.0

  41. def lastNotNaN(ts: Vector): Int

  42. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  43. final def notify(): Unit

    Definition Classes
    AnyRef
  44. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  45. def price2ret(ts: Vector, lag: Int): Vector

  46. def quotients(ts: Vector, lag: Int): Vector

  47. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  48. def toString(): String

    Definition Classes
    AnyRef → Any
  49. def trimLeading(ts: Vector): Vector

    Trim leading NaNs from a series.

  50. def trimTrailing(ts: Vector): Vector

    Trim trailing NaNs from a series.

  51. def upsample(values: Vector, n: Int, phase: Int = 0, useZero: Boolean = false): DenseVector

    Up sample by inserting n - 1 elements into the original values vector, starting at index phase

    Up sample by inserting n - 1 elements into the original values vector, starting at index phase

    values

    the original data vector

    n

    the number of insertions between elements

    phase

    the offset to begin

    useZero

    fill with zeros rather than NaN

    returns

    upsampled vector filled with zeros or NaN, as specified by user

  52. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  53. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  54. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped