UnivariateTimeSeries

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[Double], maxLag: Int): ARModel

7. final def asInstanceOf[T0]: T0

   Definition Classes

   Any

8. def autocorr(ts: Vector[Double], numLags: Int): Vector[Double]

   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[Double], lag: Int): Vector[Double]

    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[Double], destTs: Vector[Double], lag: Int, startIndex: Int): Vector[Double]

    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[Double], d: Int): Vector[Double]

    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[Double], n: Int, phase: Int = 0): DenseVector[Double]

    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[Double]): DenseVector[Double]

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

19. def fillNearest(values: Vector[Double]): DenseVector[Double]

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

21. def fillNext(values: Vector[Double]): DenseVector[Double]

    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[Double]): DenseVector[Double]

    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[Double]): DenseVector[Double]

    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 fillWithDefault(values: Vector[Double], filler: Double): DenseVector[Double]

    fills in NaN with a default value

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

29. def fillts(ts: Vector[Double], fillMethod: String): Vector[Double]

30. def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

31. def firstNotNaN(ts: Vector[Double]): Int

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

    Definition Classes

    AnyRef → Any

33. def hashCode(): Int

    Definition Classes

    AnyRef → Any

34. def inverseDifferencesAtLag(diffedTs: Vector[Double], lag: Int): Vector[Double]

    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

35. def inverseDifferencesAtLag(diffedTs: Vector[Double], destTs: Vector[Double], lag: Int, startIndex: Int): Vector[Double]

    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

36. def inverseDifferencesOfOrderD(diffedTs: Vector[Double], d: Int): Vector[Double]

    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, whcih when differenced to order ts, yields the original vector provided

37. final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

38. def lag(ts: Vector[Double], maxLag: Int, includeOriginal: Boolean): Matrix[Double]

    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 2 1 4 3 2 5 4 3

39. def lastNotNaN(ts: Vector[Double]): Int

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

    Definition Classes

    AnyRef

41. final def notify(): Unit

    Definition Classes

    AnyRef

42. final def notifyAll(): Unit

    Definition Classes

    AnyRef

43. def price2ret(ts: Vector[Double], lag: Int): Vector[Double]

44. def quotients(ts: Vector[Double], lag: Int): Vector[Double]

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

    Definition Classes

    AnyRef

46. def toString(): String

    Definition Classes

    AnyRef → Any

47. def trimLeading(ts: Vector[Double]): Vector[Double]

    Trim leading NaNs from a series.

48. def trimTrailing(ts: Vector[Double]): Vector[Double]

    Trim trailing NaNs from a series.

49. def upsample(values: Vector[Double], n: Int, phase: Int = 0, useZero: Boolean = false): DenseVector[Double]

    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

50. final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

51. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

52. final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )