class VectorR extends VectoR
The VectorR class stores and operates on Numeric Vectors of base type Real.
It follows the framework of gen.VectorN [T] and is provided for performance.
- Alphabetic
- By Inheritance
- VectorR
- VectoR
- Serializable
- Error
- Vec
- PartiallyOrdered
- Iterable
- IterableFactoryDefaults
- IterableOps
- IterableOnceOps
- IterableOnce
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new VectorR(iv: (Int, Real), dm: Int)
Construct a vector and assign 'value' at 'index' position.
Construct a vector and assign 'value' at 'index' position.
- iv
the tuple containing (index, value)
- dm
the dimension for the new vector
- new VectorR(u: VectoR)
Construct a vector and assign values from vector 'u'.
Construct a vector and assign values from vector 'u'.
- u
the other vector
- new VectorR(dim: Int, v: Array[Real] = null)
- dim
the dimension/size of the vector
- v
the 1D array used to store vector elements
Type Members
- type AsPartiallyOrdered[B] = (B) => PartiallyOrdered[B]
- Definition Classes
- PartiallyOrdered
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def *(s: (Int, Real)): VectorR
Multiply 'this' vector by scalar 's._2' only at position 's._1', e.g., 'x * (3, 5.5)'.
- def *(s: Real): VectorR
Multiply 'this' vector by scalar 's'.
- def *(b: VectorR): VectorR
Multiply 'this' vector by vector 'b'.
Multiply 'this' vector by vector 'b'.
- b
the vector to multiply by (same kind, more efficient)
- def *(b: VectoR): VectorR
Multiply 'this' vector by vector 'b'.
- def *=(s: Real): VectorR
Multiply in-place 'this' vector and scalar 's'.
- def *=(b: VectorR): VectorR
Multiply in-place 'this' vector and vector 'b'.
Multiply in-place 'this' vector and vector 'b'.
- b
the vector to multiply by (same kind, more efficient)
- def *=(b: VectoR): VectorR
Multiply in-place 'this' vector and vector 'b'.
- def +(s: (Int, Real)): VectorR
Add 'this' vector and scalar 's._2' only at position 's._1', e.g., 'x + (3, 5.5)'.
- def +(s: Real): VectorR
Add 'this' vector and scalar 's'.
- def +(b: VectorR): VectorR
Add 'this' vector and vector 'b'.
Add 'this' vector and vector 'b'.
- b
the vector to add (same kind, more efficient)
- def +(b: VectoR): VectorR
Add 'this' vector and vector 'b'.
- def ++(s: Real): VectorR
Concatenate 'this' vector and scalar 's'.
- def ++(b: VectorR): VectorR
Concatenate 'this' vector and vector' b'.
Concatenate 'this' vector and vector' b'.
- b
the vector to be concatenated (same kind, more efficient)
- def ++(b: VectoR): VectorR
Concatenate 'this' vector and vector' b'.
- final def ++[B >: Real](suffix: IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps
- Annotations
- @inline()
- def +=(s: Real): VectorR
Add in-place 'this' vector and scalar 's'.
- def +=(b: VectorR): VectorR
Add in-place 'this' vector and vector 'b'.
Add in-place 'this' vector and vector 'b'.
- b
the vector to add (same kind, more efficient)
- def +=(b: VectoR): VectorR
Add in-place 'this' vector and vector 'b'.
- def -(s: (Int, Real)): VectorR
From 'this' vector subtract scalar 's._2' only at position 's._1', e.g., 'x - (3, 5.5)'.
- def -(s: Real): VectorR
From 'this' vector subtract scalar 's'.
- def -(b: VectorR): VectorR
From 'this' vector subtract vector 'b'.
From 'this' vector subtract vector 'b'.
- b
the vector to subtract (same kind, more efficient)
- def -(b: VectoR): VectorR
From 'this' vector subtract vector 'b'.
- def -=(s: Real): VectorR
From 'this' vector subtract in-place scalar 's'.
- def -=(b: VectorR): VectorR
From 'this' vector subtract in-place vector 'b'.
From 'this' vector subtract in-place vector 'b'.
- b
the vector to subtract (same kind, more efficient)
- def -=(b: VectoR): VectorR
From 'this' vector subtract in-place vector 'b'.
- def /(s: (Int, Real)): VectorR
Divide 'this' vector by scalar 's._2' only at position 's._1', e.g., 'x / (3, 5.5)'.
- def /(s: Real): VectorR
Divide 'this' vector by scalar 's'.
- def /(b: VectorR): VectorR
Divide 'this' vector by vector 'b' (element-by-element).
Divide 'this' vector by vector 'b' (element-by-element).
- b
the vector to divide by (same kind, more efficient)
- def /(b: VectoR): VectorR
Divide 'this' vector by vector 'b' (element-by-element).
- def /=(s: Real): VectorR
Divide in-place 'this' vector and scalar 's'.
- def /=(b: VectorR): VectorR
Divide in-place 'this' vector and vector 'b'.
Divide in-place 'this' vector and vector 'b'.
- b
the vector to divide by (same kind, more efficient)
- def /=(b: VectoR): VectorR
Divide in-place 'this' vector and vector 'b'.
- def <[B >: VectoR](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- def <=[B >: VectoR](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def >[B >: VectoR](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- def >=[B >: VectoR](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- def _oneAt(j: Int, size: Int = dim): VectorR
Create a vector of the form (0, ...
- def abs: VectorR
Return the vector that is the element-wise absolute value of 'this' vector.
- final def addString(b: StringBuilder): StringBuilder
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- final def addString(b: StringBuilder, sep: String): StringBuilder
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
- Definition Classes
- IterableOnceOps
- def apply(iv: VectoI): VectorR
Get 'this' vector's elements that are given in the index vector.
- def apply(): ArraySeq[Real]
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): Real
Get 'this' vector's element at the 'i'-th index position.
- def argmax(s: Int, e: Int): Int
Find the argument maximum of 'this' vector (index of maximum element).
- 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 it's not positive).
- def argmin(s: Int, e: Int): Int
Find the argument minimum of 'this' vector (index of minimum element).
- 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 it's not negative).
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def className: String
- Attributes
- protected[this]
- Definition Classes
- Iterable
- def clean(thres: Double = TOL, relative: Boolean = true): VectorR
Clean values in 'this' vector at or below the threshold 'thres' by setting them to zero.
Clean values in 'this' vector at or below the threshold 'thres' by setting them to zero. Iterative algorithms give approximate values and if very close to zero, may throw off other calculations, e.g., in computing eigenvectors.
- thres
the cutoff threshold (a small value)
- relative
whether to use relative or absolute cutoff
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- final def coll: VectorR.this.type
- Attributes
- protected
- Definition Classes
- Iterable → IterableOps
- def collect[B](pf: PartialFunction[Real, B]): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def collectFirst[B](pf: PartialFunction[Real, B]): Option[B]
- Definition Classes
- IterableOnceOps
- def concat[B >: Real](suffix: IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps
- def contains(x: Real): Boolean
Determine whether 'x' is contained in 'this' vector.
- def containsAny(x: VectorR): Boolean
Determine whether any of the elements in 'x' are contained in 'this' vector.
Determine whether any of the elements in 'x' are contained in 'this' vector.
- x
the vector of elements to be checked
- def copy: VectorR
Create an exact copy of 'this' vector.
- def copyToArray[B >: Real](xs: Array[B], start: Int, len: Int): Int
- Definition Classes
- IterableOnceOps
- def copyToArray[B >: Real](xs: Array[B], start: Int): Int
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def copyToArray[B >: Real](xs: Array[B]): Int
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def corresponds[B](that: IterableOnce[B])(p: (Real, B) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def count(p: (Real) => Boolean): Int
- Definition Classes
- IterableOnceOps
- def countNeg: Int
Count the number of strictly negative elements in 'this' vector.
- def countPos: Int
Count the number of strictly positive elements in 'this' vector.
- def countZero: Int
Count the number of zero elements in the 'this' vector.
- def countinct: Int
Count the number of distinct elements in 'this' vector.
- def cumulate: VectorR
Cumulate the values of 'this' vector from left to right (e.g., create a CDF from a pmf).
- val dim: Int
Vector dimension
- def distinct: VectorR
Return a new vector consisting of the distinct elements from 'this' vector.
- def dot(b: VectorR): Real
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 (same kind, more efficient)
- def dot(b: VectoR): Real
Compute the dot product (or inner product) of 'this' vector with vector 'b'.
- def drop(n: Int): Iterable[Real]
- Definition Classes
- IterableOps → IterableOnceOps
- def dropRight(n: Int): Iterable[Real]
- Definition Classes
- IterableOps
- def dropWhile(p: (Real) => Boolean): Iterable[Real]
- Definition Classes
- IterableOps → IterableOnceOps
- def empty: Iterable[Real]
- Definition Classes
- IterableFactoryDefaults → IterableOps
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(b: Any): Boolean
Override equals to determine whether 'this' vector equals vector 'b'.
- def exists(p: (Real) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def expand(more: Int = dim): VectorR
Expand the size (dim) of 'this' vector by 'more' elements.
- val fString: String
Format String used for printing vector values (change using 'setFormat') Ex: "%d,\t", "%.6g,\t" or "%12.6g,\t"
Format String used for printing vector values (change using 'setFormat') Ex: "%d,\t", "%.6g,\t" or "%12.6g,\t"
- Attributes
- protected
- Definition Classes
- VectoR
- def filter(p: (Real) => Boolean): VectorR
Filter the elements of 'this' vector based on the predicate 'p', returning a new vector.
- def filterMissing: VectorR
Filter out the missing elements of 'this' vector based on the predicate that 'e != noReal'.
- def filterNot(pred: (Real) => Boolean): Iterable[Real]
- Definition Classes
- IterableOps → IterableOnceOps
- def filterPos(p: (Real) => Boolean): IndexedSeq[Int]
Filter the elements of 'this' vector based on the predicate 'p', returning the index positions.
- def filterPos2(v2: VectoR, p: (Real, Real) => Boolean): IndexedSeq[(Int, Int)]
Filter the elements of 'this' vector based on the binary predicate 'p', returning the index positions.
- def find(p: (Real) => Boolean): Option[Real]
- Definition Classes
- IterableOnceOps
- 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](f: (Real) => IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def flatten[B](implicit asIterable: (Real) => IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- final def flaw(method: String, message: String): Unit
Show the flaw by printing the error message.
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 >: Real](z: A1)(op: (A1, A1) => A1): A1
- Definition Classes
- IterableOnceOps
- def foldLeft[B](z: B)(op: (B, Real) => B): B
- Definition Classes
- IterableOnceOps
- def foldRight[B](z: B)(op: (Real, B) => B): B
- Definition Classes
- IterableOnceOps
- def forall(p: (Real) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def foreach[U](f: (Real) => U): Unit
Iterate over 'this' vector element by element.
- def fromSpecific(coll: IterableOnce[Real]): Iterable[Real]
- Attributes
- protected
- Definition Classes
- IterableFactoryDefaults → IterableOps
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def groupBy[K](f: (Real) => K): Map[K, Iterable[Real]]
- Definition Classes
- IterableOps
- def groupMap[K, B](key: (Real) => K)(f: (Real) => B): Map[K, Iterable[B]]
- Definition Classes
- IterableOps
- def groupMapReduce[K, B](key: (Real) => K)(f: (Real) => B)(reduce: (B, B) => B): Map[K, B]
- Definition Classes
- IterableOps
- def grouped(size: Int): Iterator[Iterable[Real]]
- Definition Classes
- IterableOps
- def hashCode(): Int
Must also override hashCode for 'this' vector to be compatible with equals.
- def head: Real
- Definition Classes
- IterableOps
- def headOption: Option[Real]
- Definition Classes
- IterableOps
- def indexOf(x: Real, e: Int = dim): Int
Return the index of the first occurrence of element 'x' in 'this' vector, or -1 if not found.
- def indexWhere(p: (Real) => Boolean): Int
Find and return index of first element satisfying predicate 'p', or -1 if not found.
- def indices: Range
Produce the range of all indices (0 to one less than dim).
- def init: Iterable[Real]
- Definition Classes
- IterableOps
- def inits: Iterator[Iterable[Real]]
- Definition Classes
- IterableOps
- def intersect(x: VectorR): VectorR
Return the intersection of vectors 'this' and 'x'.
Return the intersection of vectors 'this' and 'x'.
- x
the other vector
- def isEmpty: Boolean
- Definition Classes
- IterableOnceOps
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isNonnegative: Boolean
Check whether 'this' vector is nonnegative (has no negative elements).
- def isSorted: Boolean
Determine whether 'this' vector is in sorted (ascending) order.
- def isTraversableAgain: Boolean
- Definition Classes
- IterableOps → IterableOnceOps
- def iterableFactory: IterableFactory[Iterable]
- Definition Classes
- Iterable → IterableOps
- def iterator: Iterator[Real]
Return an iterator which yields all the elements.
Return an iterator which yields all the elements.
- Definition Classes
- VectorR → IterableOnce
- def knownSize: Int
- Definition Classes
- IterableOnce
- def last: Real
- Definition Classes
- IterableOps
- def lastOption: Option[Real]
- Definition Classes
- IterableOps
- def lazyZip[B](that: Iterable[B]): LazyZip2[Real, B, VectorR.this.type]
- Definition Classes
- Iterable
- def mag: Real
Find the element with the greatest magnitude in 'this' vector.
Find the element with the greatest magnitude in 'this' vector.
- Definition Classes
- VectoR
- def map(f: (Real) => Real): VectorR
Map the elements of 'this' vector by applying the mapping function 'f'.
- def map[B](f: (Real) => B): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def max(b: VectorR): VectorR
Take the maximum of 'this' vector with vector 'b' (element-by element).
Take the maximum of 'this' vector with vector 'b' (element-by element).
- b
the other vector (same kind, more efficient)
- def max(b: VectoR): VectorR
Take the maximum of 'this' vector with vector 'b' (element-by element).
- def max(e: Int = dim): Real
Find the maximum element in 'this' vector.
- def max[B >: Real](implicit ord: Ordering[B]): Real
- Definition Classes
- IterableOnceOps
- def maxBy[B](f: (Real) => B)(implicit cmp: Ordering[B]): Real
- Definition Classes
- IterableOnceOps
- def maxByOption[B](f: (Real) => B)(implicit cmp: Ordering[B]): Option[Real]
- Definition Classes
- IterableOnceOps
- def maxOption[B >: Real](implicit ord: Ordering[B]): Option[Real]
- Definition Classes
- IterableOnceOps
- def mean: Real
Compute the mean of the elements of 'this' vector.
Compute the mean of the elements of 'this' vector.
- Definition Classes
- VectoR
- def min(b: VectorR): VectorR
Take the minimum of 'this' vector with vector 'b' (element-by element).
Take the minimum of 'this' vector with vector 'b' (element-by element).
- b
the other vector (same kind, more efficient)
- def min(b: VectoR): VectorR
Take the minimum of 'this' vector with vector 'b' (element-by element).
- def min(e: Int = dim): Real
Find the minimum element in 'this' vector.
- def min[B >: Real](implicit ord: Ordering[B]): Real
- Definition Classes
- IterableOnceOps
- def minBy[B](f: (Real) => B)(implicit cmp: Ordering[B]): Real
- Definition Classes
- IterableOnceOps
- def minByOption[B](f: (Real) => B)(implicit cmp: Ordering[B]): Option[Real]
- Definition Classes
- IterableOnceOps
- def minOption[B >: Real](implicit ord: Ordering[B]): Option[Real]
- Definition Classes
- IterableOnceOps
- final def mkString: String
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- final def mkString(sep: String): String
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- final def mkString(start: String, sep: String, end: String): String
- Definition Classes
- IterableOnceOps
- val nd: Double
Number of elements in the vector as a Real
Number of elements in the vector as a Real
- Definition Classes
- VectoR
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newSpecificBuilder: Builder[Real, Iterable[Real]]
- Attributes
- protected
- Definition Classes
- IterableFactoryDefaults → IterableOps
- def nonEmpty: Boolean
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def norm: Real
Compute the Euclidean norm (2-norm) of 'this' vector.
Compute the Euclidean norm (2-norm) of 'this' vector.
- Definition Classes
- VectoR
- def norm1: Real
Compute the Manhattan norm (1-norm) of 'this' vector, i.e., the sum of the absolute values of the elements.
- def normSq: Real
Compute the Euclidean norm (2-norm) squared of 'this' vector.
Compute the Euclidean norm (2-norm) squared of 'this' vector.
- Definition Classes
- 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
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def one(size: Int = dim): VectorR
Create a one vector (all elements are one) of length 'size'.
- def oneAt(j: Int, size: Int = dim): VectorR
Create a vector of the form (0, ...
- def partition(p: (Real) => Boolean): (Iterable[Real], Iterable[Real])
- Definition Classes
- IterableOps
- def partitionMap[A1, A2](f: (Real) => Either[A1, A2]): (Iterable[A1], Iterable[A2])
- Definition Classes
- IterableOps
- def pot(b: VectoR): Real
Compute the dot product (or inner product) of 'this' vector with vector 'b' zero-padded.
- def product[B >: Real](implicit num: Numeric[B]): B
- Definition Classes
- IterableOnceOps
- def pvariance: Real
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
- VectoR
- val range: Range
Range for the storage array
Range for the storage array
- Definition Classes
- VectoR
- 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).
- def recip: VectorR
Return the vector containing the reciprocal of each element of 'this' vector.
- def reduce[B >: Real](op: (B, B) => B): B
- Definition Classes
- IterableOnceOps
- def reduceLeft[B >: Real](op: (B, Real) => B): B
- Definition Classes
- IterableOnceOps
- def reduceLeftOption[B >: Real](op: (B, Real) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reduceOption[B >: Real](op: (B, B) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reduceRight[B >: Real](op: (Real, B) => B): B
- Definition Classes
- IterableOnceOps
- def reduceRightOption[B >: Real](op: (Real, B) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reorder(rnk: VectoI): VectoR
Return the elements in 'this' vector in the given rank order 'rnk'.
Return the elements in 'this' vector in the given rank order 'rnk'.
- rnk
the given rank order
- Definition Classes
- VectoR
- def reverse(): VectorR
Reverse the order of the elements in 'this' vector.
- def reversed: Iterable[Real]
- Attributes
- protected
- Definition Classes
- IterableOnceOps
- def rot(b: VectoR)(from: Int = b.dim - 1): Real
Compute the dot product (or inner product) of 'this' vector with vector 'b' zero-padded and reversed.
- def sameDimensions(b: VectoR): Boolean
Check whether the other vector 'b' is at least as long as 'this' vector.
Check whether the other vector 'b' is at least as long as 'this' vector.
- b
the other vector
- Definition Classes
- VectoR
- def scan[B >: Real](z: B)(op: (B, B) => B): Iterable[B]
- Definition Classes
- IterableOps
- def scanLeft[B](z: B)(op: (B, Real) => B): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def scanRight[B](z: B)(op: (Real, B) => B): Iterable[B]
- Definition Classes
- IterableOps
- def select(basis: VectoI): VectorR
Select a subset of elements of 'this' vector corresponding to a 'basis'.
- def select(basis: Array[Int]): VectorR
Select a subset of elements of 'this' vector corresponding to a 'basis'.
- def selectEx(basis: VectoI): VectoR
Select all elements of 'this' vector excluding ones in the 'basis'.
Select all elements of 'this' vector excluding ones in the 'basis'.
- basis
the index positions to be excluded
- Definition Classes
- VectoR
- def selectEx(basis: Array[Int]): VectoR
Select all elements of 'this' vector excluding ones in the 'basis'.
Select all elements of 'this' vector excluding ones in the 'basis'.
- basis
the index positions to be excluded
- Definition Classes
- VectoR
- def set(u: Seq[Real]): Unit
Set the values in 'this' vector to the values in sequence/array 'u'.
- def set(x: Real): Unit
Set each value in 'this' vector to 'x'.
- def setFormat(newFormat: String): Unit
Set the format to the 'newFormat' (e.g., "%.6g,\t" or "%12.6g,\t").
Set the format to the 'newFormat' (e.g., "%.6g,\t" or "%12.6g,\t").
- newFormat
the new format String
- Definition Classes
- VectoR
- def size: Int
Return the size (number of elements) of 'this' vector.
- def sizeCompare(that: Iterable[_]): Int
- Definition Classes
- IterableOps
- def sizeCompare(otherSize: Int): Int
- Definition Classes
- IterableOps
- final def sizeIs: SizeCompareOps
- Definition Classes
- IterableOps
- Annotations
- @inline()
- def slice(from: Int, till: Int = dim): VectorR
Slice 'this' vector 'from' to 'end'.
- def slice(rg: Range): VectoR
Slice 'this' vector over the given range 'rg'.
Slice 'this' vector over the given range 'rg'.
- rg
the range specifying the slice
- Definition Classes
- VectoR
- def sliceEx(rg: Range): VectoR
Slice 'this' vector excluding the given range 'rg'.
Slice 'this' vector excluding the given range 'rg'.
- rg
the excluded range of the slice
- Definition Classes
- VectoR
- def sliding(size: Int, step: Int): Iterator[Iterable[Real]]
- Definition Classes
- IterableOps
- def sliding(size: Int): Iterator[Iterable[Real]]
- Definition Classes
- IterableOps
- def sort(): Unit
Sort 'this' vector in-place in ascending (non-decreasing) order.
- def sort2(): Unit
Sort 'this' vector in-place in descending (non-increasing) order.
- def span(p: (Real) => Boolean): (Iterable[Real], Iterable[Real])
- Definition Classes
- IterableOps → IterableOnceOps
- def split(k: Int): Array[VectoR]
Split 'this' vector into 'k' arrays of equal sizes (perhaps except for the last one).
- def split(basis: VectoI): (VectoR, VectoR)
Split the elements of 'this' vector into two vectors, one including the 'basis' and the other excluding the 'basis'.
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
- VectoR
- def split(basis: Array[Int]): (VectoR, VectoR)
Split the elements of 'this' vector into two vectors, one including the 'basis' and the other excluding the 'basis'.
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
- VectoR
- def splitAt(n: Int): (Iterable[Real], Iterable[Real])
- Definition Classes
- IterableOps → IterableOnceOps
- def sq: VectoR
Return the vector containing the square of each element of 'this' vector.
Return the vector containing the square of each element of 'this' vector.
- Definition Classes
- VectoR
- def stepper[S <: Stepper[_]](implicit shape: StepperShape[Real, S]): S
- Definition Classes
- IterableOnce
- def stringPrefix: String
- Attributes
- protected[this]
- Definition Classes
- Iterable
- Annotations
- @deprecatedOverriding()
- def sum: Real
Sum the elements of 'this' vector.
- def sum[B >: Real](implicit num: Numeric[B]): B
- Definition Classes
- IterableOnceOps
- def sumNE(i: Int): Real
Sum the elements of 'this' vector skipping the 'i'-th element (Not Equal 'i').
- def sumPos: Real
Sum the positive (> 0) elements of 'this' vector.
- def swap(i: Int, j: Int): Unit
Swap elements 'i' and 'j' in 'this' vector.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tail: Iterable[Real]
- Definition Classes
- IterableOps
- def tails: Iterator[Iterable[Real]]
- Definition Classes
- IterableOps
- def take(n: Int): Iterable[Real]
- Definition Classes
- IterableOps → IterableOnceOps
- def takeRight(n: Int): Iterable[Real]
- Definition Classes
- IterableOps
- def takeWhile(p: (Real) => Boolean): Iterable[Real]
- Definition Classes
- IterableOps → IterableOnceOps
- def tapEach[U](f: (Real) => U): Iterable[Real]
- Definition Classes
- IterableOps → IterableOnceOps
- def to[C1](factory: Factory[Real, C1]): C1
- Definition Classes
- IterableOnceOps
- def toArray[B >: Real](implicit arg0: ClassTag[B]): Array[B]
- Definition Classes
- IterableOnceOps
- final def toBuffer[B >: Real]: Buffer[B]
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- def toDense: VectorR
Convert 'this'
VectorRinto a denseVectorR. - def toDouble: VectorD
Convert 'this'
VectorRinto aVectorD. - def toIndexedSeq: IndexedSeq[Real]
- Definition Classes
- IterableOnceOps
- def toInt: VectorI
Convert 'this'
VectorRinto aVectorI. - final def toIterable: VectorR.this.type
- Definition Classes
- Iterable → IterableOps
- def toList: List[Real]
- Definition Classes
- IterableOnceOps
- def toLong: VectorL
Convert 'this'
VectorRinto aVectorL. - def toMap[K, V](implicit ev: <:<[Real, (K, V)]): Map[K, V]
- Definition Classes
- IterableOnceOps
- def toSeq: Seq[Real]
- Definition Classes
- IterableOnceOps
- def toSet[B >: Real]: Set[B]
- Definition Classes
- IterableOnceOps
- def toString: String
Convert 'this' vector to a String.
- def toVector: Vector[Real]
- Definition Classes
- IterableOnceOps
- def transpose[B](implicit asIterable: (Real) => Iterable[B]): Iterable[Iterable[B]]
- Definition Classes
- IterableOps
- def tryCompareTo[B >: VectorR](b: B)(implicit view_1: (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: (Real) => (A1, A2)): (Iterable[A1], Iterable[A2])
- Definition Classes
- IterableOps
- def unzip3[A1, A2, A3](implicit asTriple: (Real) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
- Definition Classes
- IterableOps
- def update(r: Range, u: VectoR): Unit
Set 'this' vector's elements over the given range (vector slicing).
- def update(r: Range, x: Real): Unit
Set 'this' vector's elements over the given range (vector slicing).
- def update(i: Int, x: Real): Unit
Set 'this' vector's element at the 'i'-th index position.
- var v: Array[Real]
- Attributes
- protected
- def variance: Real
Compute the (unbiased) sample variance of the elements of 'this' vector.
Compute the (unbiased) sample variance of the elements of 'this' vector.
- Definition Classes
- VectoR
- def view: View[Real]
- Definition Classes
- IterableOps
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def withFilter(p: (Real) => Boolean): WithFilter[Real, Iterable]
- Definition Classes
- IterableOps
- def zero(size: Int = dim): VectorR
Create a zero vector (all elements are zero) of length 'size'.
- def zip[B](that: IterableOnce[B]): Iterable[(Real, B)]
- Definition Classes
- IterableOps
- def zipAll[A1 >: Real, B](that: Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]
- Definition Classes
- IterableOps
- def zipWithIndex: Iterable[(Real, Int)]
- Definition Classes
- IterableOps → IterableOnceOps
- def ~^(s: Double): VectorR
Return the vector containing each element of 'this' vector raised to the s-th power.
- def ~^=(s: Double): VectorR
Raise in-place each element of 'this' vector to the 's'-th power.
- def ∙(b: VectoR): Real
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
- VectoR
- def ≠(b: VectoR): Boolean
Compare 'this' vector with that vector 'b' for inequality.
- def ≤(b: VectoR): Boolean
Compare 'this' vector with that vector 'b' for less than or equal to.
Compare 'this' vector with that vector 'b' for less than or equal to.
- b
that vector
- Definition Classes
- VectoR
- def ≥(b: VectoR): Boolean
Compare 'this' vector with that vector 'b' for greater than or equal to.
Compare 'this' vector with that vector 'b' for greater than or equal to.
- b
that vector
- Definition Classes
- VectoR
Deprecated Value Members
- def ++:[B >: Real](that: IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use ++ instead of ++: for collections of type Iterable
- final def /:[B](z: B)(op: (B, Real) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use foldLeft instead of /:
- final def :\[B](z: B)(op: (Real, B) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use foldRight instead of :\
- def aggregate[B](z: => B)(seqop: (B, Real) => B, combop: (B, B) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0)
aggregateis not relevant for sequential collections. UsefoldLeft(z)(seqop)instead.
- def companion: IterableFactory[Iterable]
- Definition Classes
- IterableOps
- Annotations
- @deprecated @deprecatedOverriding() @inline()
- Deprecated
(Since version 2.13.0) Use iterableFactory instead
- final def copyToBuffer[B >: Real](dest: Buffer[B]): Unit
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use
dest ++= collinstead
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
- def hasDefiniteSize: Boolean
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Check .knownSize instead of .hasDefiniteSize for more actionable information (see scaladoc for details)
- final def repr: Iterable[Real]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use coll instead of repr in a collection implementation, use the collection value itself from the outside
- def seq: VectorR.this.type
- Definition Classes
- Iterable
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Iterable.seq always returns the iterable itself
- final def toIterator: Iterator[Real]
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use .iterator instead of .toIterator
- final def toStream: Stream[Real]
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use .to(LazyList) instead of .toStream
- final def toTraversable: Traversable[Real]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use toIterable instead
- def view(from: Int, until: Int): View[Real]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use .view.slice(from, until) instead of .view(from, until)