DoubleSeq

abstract def =+(a: Array[Double], offset: Int, f: Double): Unit

Increment given array (starting at offset index) with contents of this DoubleSeq, multiplied by factor f.

abstract def apply(i: Int): Double

abstract def contains(d: Double): Boolean

abstract def containsNaN: Boolean

abstract def foreachActiveElement(f: (Int, Double) ⇒ Unit): Unit

abstract def indexOf(d: Double): Int

abstract def infinityNorm: Double

abstract def length: Int

abstract def max: Double

abstract def maxIndex: Int

abstract def maxIndex2: (Int, Int)

abstract def min: Double

abstract def oneNorm: Double

abstract def sampleIndex(normalizer: Double)(implicit r: Random): Int

abstract def sum: Double

abstract def toArray: Array[Double]

Return the values as an Array[Double].

abstract def twoNormSquared: Double

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def =+(a: Array[Double], f: Double): Unit

final def =+(a: Array[Double], offset: Int): Unit

final def =+(a: Array[Double]): Unit

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

Append a string representation of this DoubleSeq to the StringBuilder.

def asArray: Array[Double]

Return the values as an Array[Double].

final def asInstanceOf[T0]: T0

def asSeq: Seq[Double]

With uncopied contents

def clone(): AnyRef

def different(t: DoubleSeq, threshold: Double): Boolean

def entropy: Double

Assumes that the values are already normalized to sum to 1.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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

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

def forallElements(f: (Int, Double) ⇒ Boolean): Boolean

def foreach(f: (Double) ⇒ Unit): Unit

def foreachElement(f: (Int, Double) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def jsDivergence(p: DoubleSeq): Double

Assumes that the values are already normalized to sum to 1.

def klDivergence(p: DoubleSeq): Double

Assumes that the values in both DoubleSeq are already normalized to sum to 1.

def l2Similarity(t: DoubleSeq): Double

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

def mkString: String

def mkString(sep: String): String

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def sampleIndex(implicit r: Random): Int

Careful, for many subclasses this is inefficient because it calls the method "sum" to get the normalizer.

final def size: Int

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

def toSeq: Seq[Double]

With copied contents

def toString(): String

def top(n: Int): TopN[String]

Return records for the n elements with the largest values.

final def twoNorm: Double

final def wait(): Unit

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

final def wait(arg0: Long): Unit