TimeSeriesRDD

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: RDD[(K, Vector)]): RDD[(K, Vector)]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def aggregate[U](zeroValue: U)(seqOp: (U, (K, Vector)) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

final def asInstanceOf[T0]: T0

def cache(): TimeSeriesRDD.this.type

def cartesian[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((K, Vector), U)]

def checkpoint(): Unit

def clearDependencies(): Unit

def clone(): AnyRef

def coalesce(numPartitions: Int, shuffle: Boolean)(implicit ord: Ordering[(K, Vector)]): RDD[(K, Vector)]

def collect[U](f: PartialFunction[(K, Vector), U])(implicit arg0: ClassTag[U]): RDD[U]

def collect(): Array[(K, Vector)]

def collectAsTimeSeries(): TimeSeries[K]

Collects the RDD as a local TimeSeries

def compute(split: Partition, context: TaskContext): Iterator[(K, Vector)]

def context: SparkContext

def count(): Long

def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble]

def countApproxDistinct(relativeSD: Double): Long

def countApproxDistinct(p: Int, sp: Int): Long

def countByValue()(implicit ord: Ordering[(K, Vector)]): Map[(K, Vector), Long]

def countByValueApprox(timeout: Long, confidence: Double)(implicit ord: Ordering[(K, Vector)]): PartialResult[Map[(K, Vector), BoundedDouble]]

final def dependencies: Seq[Dependency[_]]

def differences(n: Int): TimeSeriesRDD[K]

Returns a TimeSeriesRDD where each time series is differenced with the given order.

def distinct(): RDD[(K, Vector)]

def distinct(numPartitions: Int)(implicit ord: Ordering[(K, Vector)]): RDD[(K, Vector)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fill(method: String): TimeSeriesRDD[K]

Fills in missing data (NaNs) in each series according to a given imputation method.

def filter(f: ((K, Vector)) ⇒ Boolean): TimeSeriesRDD[K]

def filterEndingAfter(dt: ZonedDateTime): TimeSeriesRDD[K]

Keep only time series whose last observation is after or equal to the given end date.

def filterStartingBefore(dt: ZonedDateTime): TimeSeriesRDD[K]

Keep only time series whose first observation is before or equal to the given start date.

def finalize(): Unit

def findSeries(key: K): Vector

Finds a series in the TimeSeriesRDD with the given key.

def first(): (K, Vector)

def firstParent[U](implicit arg0: ClassTag[U]): RDD[U]

def flatMap[U](f: ((K, Vector)) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDD[U]

def fold(zeroValue: (K, Vector))(op: ((K, Vector), (K, Vector)) ⇒ (K, Vector)): (K, Vector)

def foreach(f: ((K, Vector)) ⇒ Unit): Unit

def foreachPartition(f: (Iterator[(K, Vector)]) ⇒ Unit): Unit

def getCheckpointFile: Option[String]

final def getClass(): Class[_]

def getDependencies: Seq[Dependency[_]]

def getPartitions: Array[Partition]

def getPreferredLocations(split: Partition): Seq[String]

def getStorageLevel: StorageLevel

def glom(): RDD[Array[(K, Vector)]]

def groupBy[K](f: ((K, Vector)) ⇒ K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K]): RDD[(K, Iterable[(K, Vector)])]

def groupBy[K](f: ((K, Vector)) ⇒ K, numPartitions: Int)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(K, Vector)])]

def groupBy[K](f: ((K, Vector)) ⇒ K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(K, Vector)])]

def hashCode(): Int

val id: Int

val index: DateTimeIndex

The DateTimeIndex shared by all the time series.

def intersection(other: RDD[(K, Vector)], numPartitions: Int): RDD[(K, Vector)]

def intersection(other: RDD[(K, Vector)], partitioner: Partitioner)(implicit ord: Ordering[(K, Vector)]): RDD[(K, Vector)]

def intersection(other: RDD[(K, Vector)]): RDD[(K, Vector)]

def isCheckpointed: Boolean

def isEmpty(): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

final def iterator(split: Partition, context: TaskContext): Iterator[(K, Vector)]

implicit val kClassTag: ClassTag[K]

def keyBy[K](f: ((K, Vector)) ⇒ K): RDD[(K, (K, Vector))]

lazy val keys: Array[K]

def lags[U](maxLag: Int, includeOriginals: Boolean, laggedKey: (K, Int) ⇒ U)(implicit arg0: ClassTag[U]): TimeSeriesRDD[U]

Lags each time series in the RDD

def log: Logger

def logDebug(msg: ⇒ String, throwable: Throwable): Unit

def logDebug(msg: ⇒ String): Unit

def logError(msg: ⇒ String, throwable: Throwable): Unit

def logError(msg: ⇒ String): Unit

def logInfo(msg: ⇒ String, throwable: Throwable): Unit

def logInfo(msg: ⇒ String): Unit

def logName: String

def logTrace(msg: ⇒ String, throwable: Throwable): Unit

def logTrace(msg: ⇒ String): Unit

def logWarning(msg: ⇒ String, throwable: Throwable): Unit

def logWarning(msg: ⇒ String): Unit

def map[U](f: ((K, Vector)) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

def mapPartitions[U](f: (Iterator[(K, Vector)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapPartitionsWithIndex[U](f: (Int, Iterator[(K, Vector)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapSeries[U](f: (Vector) ⇒ Vector, index: DateTimeIndex): TimeSeriesRDD[K]

Applies a transformation to each time series and returns a TimeSeriesRDD with the given index.

def mapSeries[U](f: (Vector) ⇒ Vector): TimeSeriesRDD[K]

Applies a transformation to each time series that preserves the time index of this TimeSeriesRDD.

def max()(implicit ord: Ordering[(K, Vector)]): (K, Vector)

def min()(implicit ord: Ordering[(K, Vector)]): (K, Vector)

var name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parent[U](j: Int)(implicit arg0: ClassTag[U]): RDD[U]

val partitioner: Option[Partitioner]

final def partitions: Array[Partition]

def persist(): TimeSeriesRDD.this.type

def persist(newLevel: StorageLevel): TimeSeriesRDD.this.type

def pipe(command: Seq[String], env: Map[String, String], printPipeContext: ((String) ⇒ Unit) ⇒ Unit, printRDDElement: ((K, Vector), (String) ⇒ Unit) ⇒ Unit, separateWorkingDir: Boolean): RDD[String]

def pipe(command: String, env: Map[String, String]): RDD[String]

def pipe(command: String): RDD[String]

final def preferredLocations(split: Partition): Seq[String]

def quotients(n: Int): TimeSeriesRDD[K]

Returns a TimeSeriesRDD where each time series is quotiented with the given order.

def randomSplit(weights: Array[Double], seed: Long): Array[RDD[(K, Vector)]]

def reduce(f: ((K, Vector), (K, Vector)) ⇒ (K, Vector)): (K, Vector)

def removeInstantsWithNaNs(): TimeSeriesRDD[K]

Return a TimeSeriesRDD with all instants removed that have a NaN in one of the series.

def repartition(numPartitions: Int)(implicit ord: Ordering[(K, Vector)]): RDD[(K, Vector)]

def returnRates(): TimeSeriesRDD[K]

Returns a return rate series for each time series.

def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDD[(K, Vector)]

def saveAsCsv(path: String): Unit

Writes out the contents of this TimeSeriesRDD to a set of CSV files in the given directory, with an accompanying file in the same directory including the time index.

def saveAsObjectFile(path: String): Unit

def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit

def saveAsTextFile(path: String): Unit

def seriesStats(): RDD[StatCounter]

Gets stats like min, max, mean, and standard deviation for each time series.

def setName(_name: String): TimeSeriesRDD.this.type

def slice(start: Long, end: Long): TimeSeriesRDD[K]

Returns a TimeSeriesRDD that's a sub-slice of the given series.

def slice(start: ZonedDateTime, end: ZonedDateTime): TimeSeriesRDD[K]

Returns a TimeSeriesRDD that's a sub-slice of the given series.

def sortBy[K](f: ((K, Vector)) ⇒ K, ascending: Boolean, numPartitions: Int)(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[(K, Vector)]

def sparkContext: SparkContext

def subtract(other: RDD[(K, Vector)], p: Partitioner)(implicit ord: Ordering[(K, Vector)]): RDD[(K, Vector)]

def subtract(other: RDD[(K, Vector)], numPartitions: Int): RDD[(K, Vector)]

def subtract(other: RDD[(K, Vector)]): RDD[(K, Vector)]

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

def take(num: Int): Array[(K, Vector)]

def takeOrdered(num: Int)(implicit ord: Ordering[(K, Vector)]): Array[(K, Vector)]

def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[(K, Vector)]

def toDebugString: String

def toIndexedRowMatrix(nPartitions: Int = 1): IndexedRowMatrix

Converts a TimeSeriesRDD into a distributed IndexedRowMatrix, useful to take advantage of Spark MLlib's statistic functions on matrices in a distributed fashion.

def toInstants(nPartitions: Int = 1): RDD[(ZonedDateTime, Vector)]

Essentially transposes the time series matrix to create an RDD where each record contains a single instant in time and all the values that correspond to it.

def toInstantsDataFrame(sqlContext: SQLContext, nPartitions: Int = 1): DataFrame

Performs the same operations as toInstants but returns a DataFrame instead.

def toJavaRDD(): JavaRDD[(K, Vector)]

def toLocalIterator: Iterator[(K, Vector)]

def toObservationsDataFrame(sqlContext: SQLContext, tsCol: String = "timestamp", keyCol: String = "key", valueCol: String = "value"): DataFrame

Returns a DataFrame where each row is an observation containing a timestamp, a key, and a value.

def toRowMatrix(nPartitions: Int = 1): RowMatrix

Converts a TimeSeriesRDD into a distributed RowMatrix, note that indices in a RowMatrix are not significant, and thus this is a valid operation regardless of the type of time index.

def toString(): String

def top(num: Int)(implicit ord: Ordering[(K, Vector)]): Array[(K, Vector)]

def treeAggregate[U](zeroValue: U)(seqOp: (U, (K, Vector)) ⇒ U, combOp: (U, U) ⇒ U, depth: Int)(implicit arg0: ClassTag[U]): U

def treeReduce(f: ((K, Vector), (K, Vector)) ⇒ (K, Vector), depth: Int): (K, Vector)

def union(other: RDD[(K, Vector)]): RDD[(K, Vector)]

def unpersist(blocking: Boolean): TimeSeriesRDD.this.type

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withIndex(newIndex: DateTimeIndex): TimeSeriesRDD[K]

Returns a TimeSeriesRDD rebased on top of a new index.

def zip[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((K, Vector), U)]

def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D])(f: (Iterator[(K, Vector)], Iterator[B], Iterator[C], Iterator[D]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[D], arg3: ClassTag[V]): RDD[V]

def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D], preservesPartitioning: Boolean)(f: (Iterator[(K, Vector)], Iterator[B], Iterator[C], Iterator[D]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[D], arg3: ClassTag[V]): RDD[V]

def zipPartitions[B, C, V](rdd2: RDD[B], rdd3: RDD[C])(f: (Iterator[(K, Vector)], Iterator[B], Iterator[C]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[V]): RDD[V]

def zipPartitions[B, C, V](rdd2: RDD[B], rdd3: RDD[C], preservesPartitioning: Boolean)(f: (Iterator[(K, Vector)], Iterator[B], Iterator[C]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[V]): RDD[V]

def zipPartitions[B, V](rdd2: RDD[B])(f: (Iterator[(K, Vector)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

def zipPartitions[B, V](rdd2: RDD[B], preservesPartitioning: Boolean)(f: (Iterator[(K, Vector)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

def zipWithIndex(): RDD[((K, Vector), Long)]

def zipWithUniqueId(): RDD[((K, Vector), Long)]

def filterWith[A](constructA: (Int) ⇒ A)(p: ((K, Vector), A) ⇒ Boolean): RDD[(K, Vector)]

def flatMapWith[A, U](constructA: (Int) ⇒ A, preservesPartitioning: Boolean)(f: ((K, Vector), A) ⇒ Seq[U])(implicit arg0: ClassTag[U]): RDD[U]

def foreachWith[A](constructA: (Int) ⇒ A)(f: ((K, Vector), A) ⇒ Unit): Unit

def mapPartitionsWithContext[U](f: (TaskContext, Iterator[(K, Vector)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapPartitionsWithSplit[U](f: (Int, Iterator[(K, Vector)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapWith[A, U](constructA: (Int) ⇒ A, preservesPartitioning: Boolean)(f: ((K, Vector), A) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

def toArray(): Array[(K, Vector)]