VectorR

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(m: Matrir): VectorR

Multiply this 'row' vector by matrix m.

def *(s: Double): VectorR

Multiply this vector by scalar s.

def *(s: Rational): VectorR

Multiply this vector by scalar s.

def *(b: VectorR): VectorR

Multiply this vector by vector b.

def *=(s: Double): VectorR

Multiply in-place this vector and scalar s.

def *=(s: Rational): VectorR

Multiply in-place this vector and scalar s.

def *=(b: VectorR): VectorR

Multiply in-place this vector and vector b.

def +(s: (Rational, Int)): VectorR

Add this vector and scalar s.

def +(s: Double): VectorR

Add this vector and scalar s.

def +(s: Rational): VectorR

Add this vector and scalar s.

def +(b: VectorR): VectorR

Add this vector and vector b.

def ++(b: Double): VectorR

Concatenate this vector and scalar b.

def ++(b: Rational): VectorR

Concatenate this vector and scalar b.

def ++(b: VectorR): VectorR

Concatenate this vector and vector b.

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

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

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

def +=(s: Double): VectorR

Add in-place this vector and scalar s.

def +=(s: Rational): VectorR

Add in-place this vector and scalar s.

def +=(b: VectorR): VectorR

Add in-place this vector and vector b.

def -(s: (Rational, Int)): VectorR

From this vector subtract scalar s.

def -(s: Double): VectorR

From this vector subtract scalar s.

def -(s: Rational): VectorR

From this vector subtract scalar s.

def -(b: VectorR): VectorR

From this vector subtract vector b.

def -=(s: Double): VectorR

From this vector subtract in-place scalar s.

def -=(s: Rational): VectorR

From this vector subtract in-place scalar s.

def -=(b: VectorR): VectorR

From this vector subtract in-place vector b.

def /(s: Double): VectorR

Divide this vector by scalar s.

def /(s: Rational): VectorR

Divide this vector by scalar s.

def /(b: VectorR): VectorR

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

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

def /=(s: Double): VectorR

Divide in-place this vector and scalar s.

def /=(s: Rational): VectorR

Divide in-place this vector and scalar s.

def /=(b: VectorR): VectorR

Divide in-place this vector and vector b.

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

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

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

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

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

Create a vector of the form (0, .

def abs: VectorR

Return the vector is absolute values.

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, Rational) ⇒ B, combop: (B, B) ⇒ B): B

def apply(): Array[Rational]

Get this vector's entire array.

def apply(r: Range): VectorR

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

def apply(i: Int): Rational

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[Rational, B])(implicit bf: CanBuildFrom[Traversable[Rational], B, That]): That

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

def companion: GenericCompanion[Traversable]

def contains(x: Rational): Boolean

Determine whether x is contained in this vector.

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

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

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

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

def count(p: (Rational) ⇒ 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: VectorR

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

val dim: Int

the dimension/size of the vector

def dot(b: VectorR): Rational

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(b: Any): Boolean

Override equals to determine whether vector this equals vector b.

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

def expand(more: Int = dim): VectorR

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

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

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

def finalize(): Unit

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

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: (Rational) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Rational], B, That]): That

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

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

Show the flaw by printing the error message.

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

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

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

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

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

Iterate over the vector element by element.

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

final def getClass(): Class[_]

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

def hasDefiniteSize: Boolean

def hashCode(): Int

Must also override hashCode to be be compatible with equals.

def head: Rational

def headOption: Option[Rational]

def init: Traversable[Rational]

def inits: Iterator[Traversable[Rational]]

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: Rational

def lastOption: Option[Rational]

def mag: Rational

Find the element with the greatest magnitude in this vector.

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

def max(b: VectorR): VectorR

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

def max(e: Int = dim): Rational

Find the maximum element in this vector.

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

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

def min(b: VectorR): VectorR

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

def min(e: Int = dim): Rational

Find the minimum element in this vector.

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

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

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[Rational, Traversable[Rational]]

def nonEmpty: Boolean

def norm: Rational

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

def norm1: Rational

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

def normSq: Rational

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

def normalize: VectorR

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

def normalize1: VectorR

Normalize this vector to have a maximum of one.

def normalizeU: VectorR

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): VectorR

Create a vector of the form (0, .

def par: ParIterable[Rational]

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

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

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

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

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

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

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

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

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

def repr: Traversable[Rational]

def reversed: List[Rational]

def sameDimensions(b: VectorR): Boolean

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

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

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

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

def select(index: Array[Int]): VectorR

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

def seq: Traversable[Rational]

def set(x: Rational): Unit

Set each value in this vector to x.

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

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

def size: Int

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

Slice this vector from to end.

def sort(): Unit

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

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

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

def sq: VectorR

Square each element of this vector.

def stringPrefix: String

def sum: Rational

Sum the elements of this vector.

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

def sum_ne(i: Int): Rational

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

def sum_pos: Rational

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

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

def tail: Traversable[Rational]

def tails: Iterator[Traversable[Rational]]

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

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

def thisCollection: Traversable[Rational]

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

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

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

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

def toIndexedSeq: IndexedSeq[Rational]

def toIterable: Iterable[Rational]

def toIterator: Iterator[Rational]

def toList: List[Rational]

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

def toSeq: Seq[Rational]

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

def toStream: Stream[Rational]

def toString(): String

Convert this rational vector to a String.

def toTraversable: Traversable[Rational]

def toVector: Vector[Rational]

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

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

Compare this vector with vector b.

def unary_-(): VectorR

Return the negative of this vector (unary minus).

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

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

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

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

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

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

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

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

var v: Array[Rational]

the 1D array used to store vector elements

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def ~^(s: Rational): VectorR

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

def ~^(s: Long): VectorR

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

def ~^=(s: Rational): Unit

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

def ~^=(s: Long): Unit

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

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