final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

def *(s: (Int, Double)): VectoD

Multiply 'this' vector by scalar 's._2' only at position 's._1' and return the uncompressed vector

s: the (scalar, position) to multiply by

Definition Classes: RleVectorD → VectoD

def *(s: Double): RleVectorD

Multiply 'this' vector by scalar 's'.

s: the scalar to multiply by

Definition Classes: RleVectorD → VectoD

def *(x: RleVectorD): VectoD

Multiply 'this' vector by vector 'x'.

x: the vector to multiply by (same kind, more efficient)

def *(b: VectoD): VectoD

Multiply 'this' vector by vector 'b'.

b: the vector to multiply by (any kind)

Definition Classes: RleVectorD → VectoD

def *=(s: Double): RleVectorD

Multiply in-place 'this' vector and scalar 's'.

s: the scalar to multiply by

Definition Classes: RleVectorD → VectoD

def *=(b: VectoD): RleVectorD

Multiply in-place 'this' vector and vector 'b'.

b: the vector to multiply by

Definition Classes: RleVectorD → VectoD

def +(s: (Int, Double)): VectoD

From 'this' vector add scalar 's._2' only at position 's._1' and return the uncompressed vector

s: the (scalar, position) to add

Definition Classes: RleVectorD → VectoD

def +(s: Double): RleVectorD

Add 'this' vector and scalar 's' and return the compressed vector

s: the scalar to add

Definition Classes: RleVectorD → VectoD

def +(x: RleVectorD): VectoD

Add 'this' vector and vector 'b'.

def +(b: VectoD): VectoD

Add 'this' vector and vector 'b'.

b: the vector to add (any kind)

Definition Classes: RleVectorD → VectoD

def ++(s: Double): RleVectorD

Concatenate 'this' vector and scalar 's' and return the compressed vector

s: the scalar to be concatenated

Definition Classes: RleVectorD → VectoD

def ++(b: VectoD): VectoD

Concatenate 'this' vector and vector' b' and return the uncompressed vector

b: the vector to be concatenated

Definition Classes: RleVectorD → VectoD

def ++[B >: Double, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike

def ++:[B >: Double, That](that: Traversable[B])(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike

def ++:[B >: Double, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike

def +=(s: Double): RleVectorD

Add in-place 'this' vector and scalar 's' and return the compressed vector

s: the scalar to add

Definition Classes: RleVectorD → VectoD

def +=(x: RleVectorD): RleVectorD

Add in-place 'this' vector and vector 'b' and return the compressed vector.

x: the vector to add

def +=(b: VectoD): VectoD

Add in-place 'this' vector and vector 'b' and return the compressed vector.

b: the vector to add

Definition Classes: RleVectorD → VectoD

def -(s: (Int, Double)): VectoD

From 'this' vector subtract scalar 's._2' only at position 's._1' and return the uncompressed vector

s: the (scalar, position) to subtract

Definition Classes: RleVectorD → VectoD

def -(s: Double): RleVectorD

From 'this' vector subtract scalar 's'.

s: the scalar to subtract

Definition Classes: RleVectorD → VectoD

def -(x: RleVectorD): VectoD

From 'this' vector subtract vector 'b'.

def -(b: VectoD): VectoD

From 'this' vector subtract vector 'b'.

b: the vector to subtract (any kind)

Definition Classes: RleVectorD → VectoD

def -=(s: Double): RleVectorD

Subtract in-place 'this' vector and scalar 's' and return the compressed vector

s: the scalar to subtract

Definition Classes: RleVectorD → VectoD

def -=(b: VectoD): RleVectorD

Subtract in-place 'this' vector and vector 'b' and return the compressed vector.

b: the vector to subtract

Definition Classes: RleVectorD → VectoD

def /(s: (Int, Double)): VectoD

Divide 'this' vector by scalar 's._2' only at position 's._1' and return the uncompressed vector

s: the (scalar, position) to divide by

Definition Classes: RleVectorD → VectoD

def /(s: Double): RleVectorD

Divide 'this' vector by scalar 's'.

s: the scalar to divide by

Definition Classes: RleVectorD → VectoD

def /(x: RleVectorD): VectoD

Divide 'this' vector by vector 'x' (element-by-element).

x: the vector to divide by (same kind, more efficient)

def /(b: VectoD): VectoD

Divide 'this' vector by vector 'b' (element-by-element).

b: the vector to divide by (any kind)

Definition Classes: RleVectorD → VectoD

def /=(s: Double): RleVectorD

Divide in-place 'this' vector and scalar 's'.

s: the scalar to divide by

Definition Classes: RleVectorD → VectoD

def /=(b: VectoD): RleVectorD

Divide in-place 'this' vector and vector 'b'.

b: the vector to divide by

Definition Classes: RleVectorD → VectoD

def <[B >: VectoD](that: B)(implicit arg0: (B) ⇒ PartiallyOrdered[B]): Boolean

Definition Classes: PartiallyOrdered

def <=[B >: VectoD](that: B)(implicit arg0: (B) ⇒ PartiallyOrdered[B]): Boolean

Definition Classes: PartiallyOrdered

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def >[B >: VectoD](that: B)(implicit arg0: (B) ⇒ PartiallyOrdered[B]): Boolean

Definition Classes: PartiallyOrdered

def >=[B >: VectoD](that: B)(implicit arg0: (B) ⇒ PartiallyOrdered[B]): Boolean

Definition Classes: PartiallyOrdered

def _oneAt(j: Int, size: Int = dim): RleVectorD

Create an compressed vector of the form (0, ...

Create an compressed vector of the form (0, ... -1.0, ... 0) where the -1.0 is at position j.

j: the position to place the -1.0
size: the size of the vector (upper bound = size - 1)

Definition Classes: RleVectorD → VectoD

def abs: RleVectorD

Return the vector that is the element-wise absolute value of 'this' vector.

Definition Classes: RleVectorD → VectoD

def addString(b: StringBuilder): StringBuilder

Definition Classes: TraversableOnce

def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes: TraversableOnce

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes: TraversableOnce

def aggregate[B](z: ⇒ B)(seqop: (B, Double) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes: TraversableOnce → GenTraversableOnce

def apply(): IndexedSeq[Double]

Get 'this' vector's entire data as an array.

Definition Classes: RleVectorD → VectoD

def apply(r: Range): VectorD

Get 'this' vector's elements within the given range (vector slicing).

r: the given range

Definition Classes: RleVectorD → VectoD

def apply(i: Int): Double

Get the uncompressed vector's element at the 'i'-th index position.

i: the given index

Definition Classes: RleVectorD → VectoD

def apply(iv: VectoI): VectoD

Get 'this' vector's elements that are given in the index vector.

iv: the index vector

Definition Classes: VectoD

def argmax(s: Int, e: Int): Int

Find the argument maximum of 'this' vector (index of maximum element).

s: the starting index (inclusive) for the search
e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def argmax(e: Int = dim): Int

Find the argument maximum of 'this' vector (index of maximum element).

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def argmaxPos(e: Int = dim): Int

Return the argument maximum of 'this' vector (-1 if its not positive).

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def argmin(s: Int, e: Int): Int

Find the argument minimum of 'this' vector (index of minimum element).

s: the starting index (inclusive) for the search
e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def argmin(e: Int = dim): Int

Find the argument minimum of 'this' vector (index of minimum element).

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def argminNeg(e: Int = dim): Int

Return the argument minimum of 'this' vector (-1 if its not negative).

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

final def asInstanceOf[T0]: T0

Definition Classes: Any

def clone(): AnyRef

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( ... ) @native() @HotSpotIntrinsicCandidate()

def cnd: Double

Number of elements in the compressed vector RleVectorD as a double.

def collect[B, That](pf: PartialFunction[Double, B])(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike

def collectFirst[B](pf: PartialFunction[Double, B]): Option[B]

Definition Classes: TraversableOnce

def companion: GenericCompanion[Traversable]

Definition Classes: Traversable → GenTraversable → GenericTraversableTemplate

def contains(x: Double): Boolean

Determine whether 'x' is contained in 'this' vector.

x: the element to be checked

Definition Classes: RleVectorD → VectoD

def copy: RleVectorD

Clone (make a copy) a vector from this vector.

Definition Classes: RleVectorD → VectoD

def copyToArray[B >: Double](xs: Array[B], start: Int, len: Int): Unit

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def copyToArray[B >: Double](xs: Array[B]): Unit

Definition Classes: TraversableOnce → GenTraversableOnce

def copyToArray[B >: Double](xs: Array[B], start: Int): Unit

Definition Classes: TraversableOnce → GenTraversableOnce

def copyToBuffer[B >: Double](dest: Buffer[B]): Unit

Definition Classes: TraversableOnce

def count(p: (Double) ⇒ Boolean): Int

Definition Classes: TraversableOnce → GenTraversableOnce

def countNeg: Int

Count the number of strictly negative elements in 'this' vector.

Definition Classes: RleVectorD → VectoD

def countPos: Int

Count the number of strictly positive elements in 'this' vector.

Definition Classes: RleVectorD → VectoD

def countZero: Int

Count the number of zero elements in the 'this' vector.

Definition Classes: RleVectorD → VectoD

def countinct: Int

Count the number of distinct elements in 'this' vector.

Definition Classes: RleVectorD → VectoD

def crange: Range

Range for the compressed storage array.

def csize: Int

Return the size (number of elements) of compressed vector RleVectorD.

def cumulate: VectoD

Cumulate the values of 'this' vector from left to right (e.g., create a CDF from a pmf).

Cumulate the values of 'this' vector from left to right (e.g., create a CDF from a pmf). Example: (4, 2, 3, 1) --> (4, 6, 9, 10)

Definition Classes: RleVectorD → VectoD

val dim: Int

Vector dimension

Definition Classes: RleVectorD → VectoD

def distinct: RleVectorD

Count the number of distinct elements in 'this' vector.

Definition Classes: RleVectorD → VectoD

def dot(x: RleVectorD): Double

Compute the dot product (or inner product) of 'this' compressed vector with compressed vector 'b'.

def dot(b: VectoD): Double

Compute the dot product (or inner product) of 'this' vector with vector 'b'.

b: the other vector

Definition Classes: RleVectorD → VectoD

def drop(n: Int): Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def dropWhile(p: (Double) ⇒ Boolean): Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(b: Any): Boolean

Override equals to determine whether 'this' vector equals vector 'b.

b: the vector to compare with this

Definition Classes: RleVectorD → VectoD → AnyRef → Any

def exists(p: (Double) ⇒ Boolean): Boolean

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def expand(more: Int = dim): VectoD

Expand the size 'dim' of 'this' vector by 'more' elements.

more: the number of new elements to add

Definition Classes: RleVectorD → VectoD

val fString: String

Format String used for printing vector values (change using 'setFormat') Ex: "%d,\t", "%.6g,\t" or "%12.6g,\t"

Attributes: protected
Definition Classes: VectoD

def filter(p: (Double) ⇒ Boolean): RleVectorD

Filter the elements of 'this' vector based on the predicate 'p', returning a new vector.

p: the predicate (Boolean function) to apply

Definition Classes: RleVectorD → VectoD → TraversableLike → GenTraversableLike

def filterMissing: RleVectorD

Filter out the missing elements of 'this' vector based on the predicate that 'e != noDouble'.

Definition Classes: RleVectorD → VectoD

def filterNot(p: (Double) ⇒ Boolean): Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def filterPos(p: (Double) ⇒ Boolean): IndexedSeq[Int]

Filter the elements of 'this' vector based on the predicate 'p', returning the index positions.

p: the predicate (Boolean function) to apply

Definition Classes: RleVectorD → VectoD

def filterPos2(v2: VectoD, p: (Double, Double) ⇒ Boolean): IndexedSeq[(Int, Int)]

Filter the elements of 'this' vector based on the predicate 'p', returning the index positions.

Filter the elements of 'this' vector based on the predicate 'p', returning the index positions. (for thetajoin, return first vector index combine second vector index)

v2: the vector to compare with
p: the predicate (Boolean function, between two elements) to apply

Definition Classes: RleVectorD → VectoD

def find(p: (Double) ⇒ Boolean): Option[Double]

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def firstNeg(e: Int = dim): Int

Return the index of the first negative element in 'this' vector (-1 otherwise).

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def firstPos(e: Int = dim): Int

Return the index of the first positive element in 'this' vector (-1 otherwise).

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def flatMap[B, That](f: (Double) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def flatten[B](implicit asTraversable: (Double) ⇒ GenTraversableOnce[B]): Traversable[B]

Definition Classes: GenericTraversableTemplate

final def flaw(method: String, message: String): Unit

Show the flaw by printing the error message.

method: the method where the error occurred
message: the error message

Definition Classes: Error

def fold[A1 >: Double](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes: TraversableOnce → GenTraversableOnce

def foldLeft[B](z: B)(op: (B, Double) ⇒ B): B

Definition Classes: TraversableOnce → GenTraversableOnce

def foldRight[B](z: B)(op: (Double, B) ⇒ B): B

Definition Classes: TraversableOnce → GenTraversableOnce

def forall(p: (Double) ⇒ Boolean): Boolean

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def foreach[U](f: (Double) ⇒ U): Unit

Iterate over 'this' vector element by element.

f: the function to apply

Definition Classes: RleVectorD → VectoD → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def genericBuilder[B]: Builder[B, Traversable[B]]

Definition Classes: GenericTraversableTemplate

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native() @HotSpotIntrinsicCandidate()

def getTriplet(i: Int): Int

Get the triplet corresponding to the element at the 'i'-th index position.

i: the given index

def groupBy[K](f: (Double) ⇒ K): Map[K, Traversable[Double]]

Definition Classes: TraversableLike → GenTraversableLike

def hasDefiniteSize: Boolean

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

Must also override hashCode for 'this' vector to be compatible with equals.

Definition Classes: RleVectorD → VectoD → AnyRef → Any

def head: Double

Definition Classes: TraversableLike → GenTraversableLike

def headOption: Option[Double]

Definition Classes: TraversableLike → GenTraversableLike

def indexOf(x: Double, e: Int = dim): Int

Return the index of the first occurrence of element 'x' in 'this' vector, or -1 if not found.

x: the given element
e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def indexWhere(p: (Double) ⇒ Boolean): Int

Find and return index of first element satisfying predicate 'p', or -1 if not found.

p: the predicate to check

Definition Classes: RleVectorD → VectoD

def indices: Range

Produce the range of all indices (0 to one less than dim).

Definition Classes: VectoD → Vec

def init: Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def inits: Iterator[Traversable[Double]]

Definition Classes: TraversableLike

def isEmpty: Boolean

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def isNonnegative: Boolean

Check whether 'this' vector is nonnegative (has no negative elements).

Definition Classes: RleVectorD → VectoD

def isSorted: Boolean

Determine whether 'this' vector is in sorted (ascending) order.

Definition Classes: RleVectorD → VectoD

final def isTraversableAgain: Boolean

Definition Classes: TraversableLike → GenTraversableLike → GenTraversableOnce

def last: Double

Definition Classes: TraversableLike → GenTraversableLike

def lastOption: Option[Double]

Definition Classes: TraversableLike → GenTraversableLike

def mag: Double

Find the element with the greatest magnitude in 'this' vector.

Definition Classes: VectoD

def map(f: (Double) ⇒ Double): RleVectorD

Map the elements of 'this' vector by applying the mapping function 'f'.

f: the function to apply

Definition Classes: RleVectorD → VectoD

def map[B, That](f: (Double) ⇒ B)(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max(b: VectoD): VectoD

Take the maximum of 'this' vector with vector 'b' (element-by element).

Take the maximum of 'this' vector with vector 'b' (element-by element). I.e., the 'dim' of this Vector and 'b' should be same.

b: the other vector

Definition Classes: RleVectorD → VectoD

def max(e: Int = dim): Double

Find the maximum element in 'this' compressed vector.

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def max[B >: Double](implicit cmp: Ordering[B]): Double

Definition Classes: TraversableOnce → GenTraversableOnce

def maxBy[B](f: (Double) ⇒ B)(implicit cmp: Ordering[B]): Double

Definition Classes: TraversableOnce → GenTraversableOnce

def mean: Double

Compute the mean of the elements of 'this' vector.

Definition Classes: VectoD

def min(b: VectoD): VectoD

Take the minimum of 'this' vector with vector 'b' (element-by element).

b: the other vector

Definition Classes: RleVectorD → VectoD

def min(e: Int = dim): Double

Find the minimum element in 'this' vector.

e: the ending index (exclusive) for the search

Definition Classes: RleVectorD → VectoD

def min[B >: Double](implicit cmp: Ordering[B]): Double

Definition Classes: TraversableOnce → GenTraversableOnce

def minBy[B](f: (Double) ⇒ B)(implicit cmp: Ordering[B]): Double

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString: String

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(start: String, sep: String, end: String): String

Definition Classes: TraversableOnce → GenTraversableOnce

val nd: Double

Number of elements in the vector as a Double

Definition Classes: VectoD

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def newBuilder: Builder[Double, Traversable[Double]]

Attributes: protected[this]
Definition Classes: GenericTraversableTemplate → HasNewBuilder

def nonEmpty: Boolean

Definition Classes: TraversableOnce → GenTraversableOnce

def norm: Double

Compute the Euclidean norm (2-norm) of 'this' vector.

Definition Classes: VectoD

def norm1: Double

Compute the Manhattan norm (1-norm) of 'this' vector.

Definition Classes: RleVectorD → VectoD

def normSq: Double

Compute the Euclidean norm (2-norm) squared of 'this' vector.

Definition Classes: RleVectorD → VectoD

def normalize: RleVectorD

Normalize 'this' vector so that it sums to one (like a probability vector).

Definition Classes: RleVectorD → VectoD

def normalize1: RleVectorD

Normalize 'this' vector to have a maximum of one.

Definition Classes: RleVectorD → VectoD

def normalizeU: RleVectorD

Normalize 'this' vector so its length is one (unit vector).

Definition Classes: RleVectorD → VectoD

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native() @HotSpotIntrinsicCandidate()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native() @HotSpotIntrinsicCandidate()

def one(size: Int): RleVectorD

Create a one vector (all elements are one) of length 'size'.

size: the size of the new vector

Definition Classes: RleVectorD → VectoD

def oneAt(j: Int, size: Int = dim): RleVectorD

Create an compressed vector of the form (0, ...

Create an compressed vector of the form (0, ... 1.0, ... 0) where the 1.0 is at position j.

j: the position to place the 1.0
size: the size of the vector (upper bound = size - 1)

Definition Classes: RleVectorD → VectoD

def par: ParIterable[Double]

Definition Classes: Parallelizable

def parCombiner: Combiner[Double, ParIterable[Double]]

Attributes: protected[this]
Definition Classes: TraversableLike → Parallelizable

def partition(p: (Double) ⇒ Boolean): (Traversable[Double], Traversable[Double])

Definition Classes: TraversableLike → GenTraversableLike

def pot(b: VectoD): Double

Compute the dot product (or inner product) of 'this' vector with vector 'b' zero-padded.

b: the other vector

Definition Classes: VectoD

def product[B >: Double](implicit num: Numeric[B]): B

Definition Classes: TraversableOnce → GenTraversableOnce

def pvariance: Double

Compute the population variance of the elements of 'this' vector.

Compute the population variance of the elements of 'this' vector. This is also the (biased) MLE estimator for sample variance.

Definition Classes: VectoD

def qspartition(l: Int, h: Int, asc: Boolean = true): Int

Partition function of quicksort.

l: the low index
h: the high index
asc: whether to sort in ascending order

val range: Range

Range for the storage array

Definition Classes: VectoD

def rank: VectorI

Establish the rank order of the elements in 'self' vector, e.g., (8.0, 2.0, 4.0, 6.0) is (3, 0, 1, 2).

Definition Classes: RleVectorD → VectoD

def recip: RleVectorD

Return the vector containing the reciprocal of each element of 'this' vector.

Definition Classes: RleVectorD → VectoD

def reduce[A1 >: Double](op: (A1, A1) ⇒ A1): A1

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceLeft[B >: Double](op: (B, Double) ⇒ B): B

Definition Classes: TraversableOnce

def reduceLeftOption[B >: Double](op: (B, Double) ⇒ B): Option[B]

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceOption[A1 >: Double](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceRight[B >: Double](op: (Double, B) ⇒ B): B

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceRightOption[B >: Double](op: (Double, B) ⇒ B): Option[B]

Definition Classes: TraversableOnce → GenTraversableOnce

def reorder(rnk: VectoI): VectoD

Return the elements in 'this' vector in the given rank order 'rnk'.

rnk: the given rank order

Definition Classes: VectoD

def repr: Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def reverse(): RleVectorD

Reverse the order of the elements in 'this' vector.

Definition Classes: RleVectorD → VectoD

def reversed: List[Double]

Attributes: protected[this]
Definition Classes: TraversableOnce

def rle_quicksort(l: Int, h: Int, asc: Boolean = true): Unit

Quicksort implementation for rle vectors.

l: the low index
h: the high index
asc: whether to sort in ascending order

def rot(b: VectoD)(from: Int = b.dim - 1): Double

Compute the dot product (or inner product) of 'this' vector with vector 'b' reversed.

Compute the dot product (or inner product) of 'this' vector with vector 'b' reversed. zero-padded and reversed.

b: the other vector

Definition Classes: VectoD

def sameDimensions(b: VectoD): Boolean

Check whether the other vector 'b' is at least as long as 'this' vector.

b: the other vector

Definition Classes: VectoD

def scan[B >: Double, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike

def scanLeft[B, That](z: B)(op: (B, Double) ⇒ B)(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (Double, B) ⇒ B)(implicit bf: CanBuildFrom[Traversable[Double], B, That]): That

Definition Classes: TraversableLike → GenTraversableLike
Annotations: @migration
Migration: (Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.

def select(basis: Array[Int]): VectoD

Select a subset of elements of 'this' vector corresponding to a 'basis'.

basis: the set of index positions (e.g., 0, 2, 5)

Definition Classes: RleVectorD → VectoD

def select(basis: VectoI): VectoD

Select a subset of elements of 'this' vector corresponding to a 'basis'.

basis: the set of index positions (e.g., 0, 2, 5)

Definition Classes: VectoD

def selectEx(basis: VectoI): VectoD

Select all elements of 'this' vector excluding ones in the 'basis'.

basis: the index positions to be excluded

Definition Classes: VectoD

def selectEx(basis: Array[Int]): VectoD

Select all elements of 'this' vector excluding ones in the 'basis'.

basis: the index positions to be excluded

Definition Classes: VectoD

def seq: Traversable[Double]

Definition Classes: Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce

def set(u: Seq[Double]): Unit

Set the values in 'this' vector to the values in array 'u'.

u: the array of values to be assigned

Definition Classes: RleVectorD → VectoD

def set(x: Double): Unit

Set each value in 'this' vector to 'x'.

x: the value to be assigned

Definition Classes: RleVectorD → VectoD

def setFormat(newFormat: String): Unit

Set the format to the 'newFormat' (e.g., "%.6g,\t" or "%12.6g,\t").

newFormat: the new format String

Definition Classes: VectoD

def size: Int

Return the size (number of elements) of 'this' vector.

Definition Classes: VectoD → Vec → GenTraversableLike → TraversableOnce → GenTraversableOnce

def sizeHintIfCheap: Int

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(from: Int, till: Int): VectorD

Slice 'this' vector 'from' to 'end'.

from: the start of the slice (included)
till: the end of the slice (excluded)

Definition Classes: RleVectorD → VectoD → TraversableLike → GenTraversableLike

def slice(rg: Range): VectoD

Slice 'this' vector over the given range 'rg'.

rg: the range specifying the slice

Definition Classes: VectoD

def sliceEx(rg: Range): VectoD

Slice 'this' vector excluding the given range 'rg'.

rg: the excluded range of the slice

Definition Classes: VectoD

def sort(): Unit

Sort 'this' vector in-place in ascending (non-decreasing) order.

Definition Classes: RleVectorD → VectoD

def sort2(): Unit

Sort 'this' vector in-place in descending (non-increasing) order.

Definition Classes: RleVectorD → VectoD

def span(p: (Double) ⇒ Boolean): (Traversable[Double], Traversable[Double])

Definition Classes: TraversableLike → GenTraversableLike

def split(basis: VectoI): (VectoD, VectoD)

Split the elements of 'this' vector into two vectors, one including the 'basis' and the other excluding the 'basis'.

basis: the index positions to be included/excluded

Definition Classes: VectoD

def split(basis: Array[Int]): (VectoD, VectoD)

Split the elements of 'this' vector into two vectors, one including the 'basis' and the other excluding the 'basis'.

basis: the index positions to be included/excluded

Definition Classes: VectoD

def split(k: Int): Array[VectoD]

Split 'this' vector into 'k' arrays of equal sizes (perhaps except for the last one).

k: the number of pieces the vector is to be split into

Definition Classes: VectoD

def splitAt(n: Int): (Traversable[Double], Traversable[Double])

Definition Classes: TraversableLike → GenTraversableLike

def sq: VectoD

Return the vector containing the square of each element of 'this' vector.

Definition Classes: VectoD

def stringPrefix: String

Definition Classes: TraversableLike → GenTraversableLike

def sum: Double

Get the sum of the elements of 'this' vector.

Definition Classes: RleVectorD → VectoD

def sum[B >: Double](implicit num: Numeric[B]): B

Definition Classes: TraversableOnce → GenTraversableOnce

def sumNE(i: Int): Double

Sum the elements of 'this' vector skipping the 'i'-th element (Not Equal 'i').

i: the index of the element to skip

Definition Classes: RleVectorD → VectoD

def sumPos: Double

Sum the positive (> 0) elements of 'this' vector.

Definition Classes: RleVectorD → VectoD

def swap(i: Int, j: Int): Unit

Swap elements 'i' and 'j' in 'this' vector.

i: the first element in the swap
j: the second element in the swap

Definition Classes: RleVectorD → VectoD

def swap2(i: Int, j: Int): Unit

Swap elements 'i' and 'j' in 'this' vector.

Swap elements 'i' and 'j' in 'this' vector. (2nd implementation)

i: the first element in the swap
j: the second element in the swap

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

Definition Classes: AnyRef

def tail: Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def tails: Iterator[Traversable[Double]]

Definition Classes: TraversableLike

def take(n: Int): Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def takeWhile(p: (Double) ⇒ Boolean): Traversable[Double]

Definition Classes: TraversableLike → GenTraversableLike

def thisCollection: Traversable[Double]

Attributes: protected[this]
Definition Classes: TraversableLike

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Double, Col[Double]]): Col[Double]

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray[B >: Double](implicit arg0: ClassTag[B]): Array[B]

Definition Classes: TraversableOnce → GenTraversableOnce

def toBuffer[B >: Double]: Buffer[B]

Definition Classes: TraversableOnce → GenTraversableOnce

def toCollection(repr: Traversable[Double]): Traversable[Double]

Attributes: protected[this]
Definition Classes: TraversableLike

def toDense: VectorD

Converts the compressed vector to a dense vector.

returns: Vector of base type Double containing uncompressed data

Definition Classes: RleVectorD → VectoD

def toDouble: VectorD

Convert 'this' RleVectorD into a VectorD.

Definition Classes: RleVectorD → VectoD

def toIndexedSeq: IndexedSeq[Double]

Definition Classes: TraversableOnce → GenTraversableOnce

def toInt: VectorI

Convert 'this' RleVectorD into a VectorI.

Definition Classes: RleVectorD → VectoD

def toIterable: Iterable[Double]

Definition Classes: TraversableOnce → GenTraversableOnce

def toIterator: Iterator[Double]

Definition Classes: TraversableLike → GenTraversableOnce

def toList: List[Double]

Definition Classes: TraversableOnce → GenTraversableOnce

def toLong: VectorL

Convert 'this' RleVectorD into a VectorL.

Definition Classes: RleVectorD → VectoD

def toMap[T, U](implicit ev: <:<[Double, (T, U)]): Map[T, U]

Definition Classes: TraversableOnce → GenTraversableOnce

def toSeq: Seq[Double]

Definition Classes: TraversableOnce → GenTraversableOnce

def toSet[B >: Double]: Set[B]

Definition Classes: TraversableOnce → GenTraversableOnce

def toStream: Stream[Double]

Definition Classes: TraversableLike → GenTraversableOnce

def toString: String

Convert 'this' vector to a string.

Definition Classes: RleVectorD → VectoD → TraversableLike → AnyRef → Any

def toTraversable: Traversable[Double]

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce
Annotations: @deprecatedOverriding( ... , "2.11.0" )

def toVector: Vector[Double]

Definition Classes: TraversableOnce → GenTraversableOnce

def transpose[B](implicit asTraversable: (Double) ⇒ GenTraversableOnce[B]): Traversable[Traversable[B]]

Definition Classes: GenericTraversableTemplate
Annotations: @migration
Migration: (Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.

def tryCompareTo[B >: RleVectorD](b: B)(implicit view_1: (B) ⇒ PartiallyOrdered[B]): Option[Int]

Compare 'this' vector with vector 'b'.

b: the other vector

Definition Classes: RleVectorD → PartiallyOrdered

def unary_-(): RleVectorD

Return the negative of 'this' vector (unary minus).

Definition Classes: RleVectorD → VectoD

def unzip[A1, A2](implicit asPair: (Double) ⇒ (A1, A2)): (Traversable[A1], Traversable[A2])

Definition Classes: GenericTraversableTemplate

def unzip3[A1, A2, A3](implicit asTriple: (Double) ⇒ (A1, A2, A3)): (Traversable[A1], Traversable[A2], Traversable[A3])

Definition Classes: GenericTraversableTemplate

def update(r: Range, u: VectoD): Unit

Set 'this' vector's elements over the given range (vector slicing).

r: the given range
u: the vector to assign

Definition Classes: RleVectorD → VectoD

def update(r: Range, x: Double): Unit

Set 'this' vector's elements over the given range (vector slicing).

r: the given range
x: the value to assign

Definition Classes: RleVectorD → VectoD

def update(i: Int, x: Double): Unit

Set 'this' vector's element at the 'i'-th index position.

i: the given index
x: the value to assign

Definition Classes: RleVectorD → VectoD

var v: ReArray[TripletD]

Attributes: protected

def variance: Double

Compute the (unbiased) sample variance of the elements of 'this' vector.

Definition Classes: VectoD

def view(from: Int, until: Int): TraversableView[Double, Traversable[Double]]

Definition Classes: TraversableLike

def view: TraversableView[Double, Traversable[Double]]

Definition Classes: TraversableLike

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

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

def withFilter(p: (Double) ⇒ Boolean): FilterMonadic[Double, Traversable[Double]]

Definition Classes: TraversableLike → FilterMonadic

def zero(size: Int): RleVectorD

Create a zero vector (all elements are zero) of length 'size'.

size: the size of the new vector

Definition Classes: RleVectorD → VectoD

def ~^(s: Double): RleVectorD

Return the vector containing each element of 'this' vector raised to the s-th power.

s: the scalar exponent

Definition Classes: RleVectorD → VectoD

def ~^=(s: Double): RleVectorD

Raise each element of 'this' vector to the 's'-th power.

s: the scalar exponent

Definition Classes: RleVectorD → VectoD

def ∙(b: VectoD): Double

Compute the dot product (or inner product) of 'this' vector with vector 'b'.

Compute the dot product (or inner product) of 'this' vector with vector 'b'. When b.dim > dim, the remaining elements in b are skipped. When b.dim < dim, an index out of bound exception is thrown.

b: the other vector

Definition Classes: VectoD

def ≠(b: VectoD): Boolean

Compare 'this' vector with that vector 'b' for inequality.

b: that vector

Definition Classes: VectoD

def ≤(b: VectoD): Boolean

Compare 'this' vector with that vector 'b' for less than or equal to.

b: that vector

Definition Classes: VectoD

def ≥(b: VectoD): Boolean

Compare 'this' vector with that vector 'b' for greater than or equal to.

b: that vector

Definition Classes: VectoD

Packages

RleVectorD

Companion object RleVectorD

class RleVectorD extends VectoD

Instance Constructors

Type Members

Value Members

Deprecated Value Members

Inherited from VectoD

Inherited from Serializable

Inherited from Serializable

Inherited from Error

Inherited from Vec

Inherited from PartiallyOrdered[VectoD]

Inherited from Traversable[Double]

Inherited from GenTraversable[Double]

Inherited from GenericTraversableTemplate[Double, Traversable]

Inherited from TraversableLike[Double, Traversable[Double]]

Inherited from GenTraversableLike[Double, Traversable[Double]]

Inherited from Parallelizable[Double, ParIterable[Double]]

Inherited from TraversableOnce[Double]

Inherited from GenTraversableOnce[Double]

Inherited from FilterMonadic[Double, Traversable[Double]]

Inherited from HasNewBuilder[Double, Traversable[Double]]

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

RleVectorD 

Companion object RleVectorD

class RleVectorD extends VectoD

Instance Constructors

Type Members

Value Members

Deprecated Value Members

Inherited from VectoD

Inherited from Serializable

Inherited from Serializable

Inherited from Error

Inherited from Vec

Inherited from PartiallyOrdered[VectoD]

Inherited from Traversable[Double]

Inherited from GenTraversable[Double]

Inherited from GenericTraversableTemplate[Double, Traversable]

Inherited from TraversableLike[Double, Traversable[Double]]

Inherited from GenTraversableLike[Double, Traversable[Double]]

Inherited from Parallelizable[Double, ParIterable[Double]]

Inherited from TraversableOnce[Double]

Inherited from GenTraversableOnce[Double]

Inherited from FilterMonadic[Double, Traversable[Double]]

Inherited from HasNewBuilder[Double, Traversable[Double]]

Inherited from AnyRef

Inherited from Any

Ungrouped

RleVectorD