VectorD

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(m: Matrix): VectorD

Multiply this 'row' vector by matrix m.

def *(s: Double): VectorD

Multiply this vector by scalar s.

def *(b: VectorD): VectorD

Multiply this vector by vector b.

def *=(s: Double): VectorD

Multiply in-place this vector and scalar s.

def *=(b: VectorD): VectorD

Multiply in-place this vector and vector b.

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

Add this vector and scalar s.

def +(s: Double): VectorD

Add this vector and scalar s.

def +(b: VectorD): VectorD

Add this vector and vector b.

def ++(b: Double): VectorD

Concatenate this vector and scalar b.

def ++(b: VectorD): VectorD

Concatenate this vector and vector b.

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

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

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

def +=(s: Double): VectorD

Add in-place this vector and scalar s.

def +=(b: VectorD): VectorD

Add in-place this vector and vector b.

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

From this vector subtract scalar s.

def -(s: Double): VectorD

From this vector subtract scalar s.

def -(b: VectorD): VectorD

From this vector subtract vector b.

def -=(s: Double): VectorD

From this vector subtract in-place scalar s.

def -=(b: VectorD): VectorD

From this vector subtract in-place vector b.

def /(s: Double): VectorD

Divide this vector by scalar s.

def /(b: VectorD): VectorD

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

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

def /=(s: Double): VectorD

Divide in-place this vector and scalar s.

def /=(b: VectorD): VectorD

Divide in-place this vector and vector b.

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

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

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

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

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

Create a vector of the form (0, .

def abs: VectorD

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

def addString(b: StringBuilder): StringBuilder

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

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

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

def apply(): Array[Double]

Get this vector's entire array.

def apply(r: Range): VectorD

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

def apply(i: Int): Double

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

def argmax(e: Int = dim): Int

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

def argmaxPos(e: Int = dim): Int

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

def argmin(e: Int = dim): Int

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

def argminNeg(e: Int = dim): Int

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

def companion: GenericCompanion[Traversable]

def contains(x: Double): Boolean

Determine whether x is contained in this vector.

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

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

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

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

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

def countNeg: Int

Count the number of strictly negative entries in this vector.

def countPos: Int

Count the number of strictly positive entries in this vector.

def cumulate: VectorD

Cumulate the values of this vector from left to right (e.

val dim: Int

the dimension/size of the vector

def dot(b: VectorD): Double

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(b: Any): Boolean

Override equals to determine whether vector this equals vector b.

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

def expand(more: Int = dim): VectorD

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

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

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

def finalize(): Unit

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

def firstNeg(e: Int = dim): Int

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

def firstPos(e: Int = dim): Int

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

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

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

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

Show the flaw by printing the error message.

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

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

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

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

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

Iterate over the vector element by element.

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

final def getClass(): Class[_]

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

def hasDefiniteSize: Boolean

def hashCode(): Int

Must also override hashCode to be be compatible with equals.

def head: Double

def headOption: Option[Double]

def indices: Range

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

def init: Traversable[Double]

def inits: Iterator[Traversable[Double]]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isNonnegative: Boolean

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

final def isTraversableAgain: Boolean

def last: Double

def lastOption: Option[Double]

def mag: Double

Find the element with the greatest magnitude in this vector.

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

def max(b: VectorD): VectorD

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

def max(e: Int = dim): Double

Find the maximum element in this vector.

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

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

def min(b: VectorD): VectorD

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

def min(e: Int = dim): Double

Find the minimum element in this vector.

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

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

def mkString: String

def mkString(sep: String): String

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

final def ne(arg0: AnyRef): Boolean

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

def nonEmpty: Boolean

def norm: Double

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

def norm1: Double

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

def normSq: Double

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

def normalize: VectorD

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

def normalize1: VectorD

Normalize this vector to have a maximum of one.

def normalizeU: VectorD

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

final def notify(): Unit

final def notifyAll(): Unit

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

Create a vector of the form (0, .

def par: ParIterable[Double]

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

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

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

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

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

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

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

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

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

def repr: Traversable[Double]

def reversed: List[Double]

def sameDimensions(b: VectorD): Boolean

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

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

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

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

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

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

def seq: Traversable[Double]

def set(x: Double): Unit

Set each value in this vector to x.

def setAll(u: Array[Double]): Unit

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

def setFormat(newFormat: String): Unit

Set the format to the newFormat (e.

def size: Int

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

Slice this vector from to end.

def sort(): Unit

Sort this vector in-place in non-decreasing order.

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

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

def sq: VectorD

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

def stringPrefix: String

def sum: Double

Sum the elements of this vector.

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

def sum_ne(i: Int): Double

Sum the elements of this vector skipping the i-th element.

def sum_pos: Double

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

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

def tail: Traversable[Double]

def tails: Iterator[Traversable[Double]]

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

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

def thisCollection: Traversable[Double]

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

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

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

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

def toIndexedSeq: IndexedSeq[Double]

def toIterable: Iterable[Double]

def toIterator: Iterator[Double]

def toList: List[Double]

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

def toSeq: Seq[Double]

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

def toStream: Stream[Double]

def toString(): String

Convert this vector to a String.

def toTraversable: Traversable[Double]

def toVector: Vector[Double]

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

def tryCompareTo[B >: VectorD](b: B)(implicit arg0: (B) ⇒ PartiallyOrdered[B]): Option[Int]

Compare this vector with vector b.

def unary_-(): VectorD

Return the negative of this vector (unary minus).

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

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

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

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

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

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

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

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

var v: Array[Double]

the 1D array used to store vector elements

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def ~^(s: Double): VectorD

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

def ~^=(s: Double): Unit

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

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