class VectorL extends VectoL
The VectorL class stores and operates on Numeric Vectors of base type Long.
It follows the framework of gen.VectorN [T] and is provided for performance.
- Alphabetic
- By Inheritance
- VectorL
- VectoL
- Serializable
- Error
- Vec
- PartiallyOrdered
- Iterable
- IterableFactoryDefaults
- IterableOps
- IterableOnceOps
- IterableOnce
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new VectorL(iv: (Int, Long), 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 VectorL(u: VectoL)
Construct a vector and assign values from vector 'u'.
Construct a vector and assign values from vector 'u'.
- u
the other vector
- new VectorL(dim: Int, v: Array[Long] = 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, Long)): VectorL
Multiply 'this' vector by scalar 's._2' only at position 's._1', e.g., 'x * (3, 5.5)'.
- def *(s: Long): VectorL
Multiply 'this' vector by scalar 's'.
- def *(b: VectorL): VectorL
Multiply 'this' vector by vector 'b'.
Multiply 'this' vector by vector 'b'.
- b
the vector to multiply by (same kind, more efficient)
- def *(b: VectoL): VectorL
Multiply 'this' vector by vector 'b'.
- def *=(s: Long): VectorL
Multiply in-place 'this' vector and scalar 's'.
- def *=(b: VectorL): VectorL
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: VectoL): VectorL
Multiply in-place 'this' vector and vector 'b'.
- def +(s: (Int, Long)): VectorL
Add 'this' vector and scalar 's._2' only at position 's._1', e.g., 'x + (3, 5.5)'.
- def +(s: Long): VectorL
Add 'this' vector and scalar 's'.
- def +(b: VectorL): VectorL
Add 'this' vector and vector 'b'.
Add 'this' vector and vector 'b'.
- b
the vector to add (same kind, more efficient)
- def +(b: VectoL): VectorL
Add 'this' vector and vector 'b'.
- def ++(s: Long): VectorL
Concatenate 'this' vector and scalar 's'.
- def ++(b: VectorL): VectorL
Concatenate 'this' vector and vector' b'.
Concatenate 'this' vector and vector' b'.
- b
the vector to be concatenated (same kind, more efficient)
- def ++(b: VectoL): VectorL
Concatenate 'this' vector and vector' b'.
- final def ++[B >: Long](suffix: IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps
- Annotations
- @inline()
- def +=(s: Long): VectorL
Add in-place 'this' vector and scalar 's'.
- def +=(b: VectorL): VectorL
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: VectoL): VectorL
Add in-place 'this' vector and vector 'b'.
- def -(s: (Int, Long)): VectorL
From 'this' vector subtract scalar 's._2' only at position 's._1', e.g., 'x - (3, 5.5)'.
- def -(s: Long): VectorL
From 'this' vector subtract scalar 's'.
- def -(b: VectorL): VectorL
From 'this' vector subtract vector 'b'.
From 'this' vector subtract vector 'b'.
- b
the vector to subtract (same kind, more efficient)
- def -(b: VectoL): VectorL
From 'this' vector subtract vector 'b'.
- def -=(s: Long): VectorL
From 'this' vector subtract in-place scalar 's'.
- def -=(b: VectorL): VectorL
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: VectoL): VectorL
From 'this' vector subtract in-place vector 'b'.
- def /(s: (Int, Long)): VectorL
Divide 'this' vector by scalar 's._2' only at position 's._1', e.g., 'x / (3, 5.5)'.
- def /(s: Long): VectorL
Divide 'this' vector by scalar 's'.
- def /(b: VectorL): VectorL
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: VectoL): VectorL
Divide 'this' vector by vector 'b' (element-by-element).
- def /=(s: Long): VectorL
Divide in-place 'this' vector and scalar 's'.
- def /=(b: VectorL): VectorL
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: VectoL): VectorL
Divide in-place 'this' vector and vector 'b'.
- def <[B >: VectoL](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- def <=[B >: VectoL](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def >[B >: VectoL](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- def >=[B >: VectoL](that: B)(implicit arg0: AsPartiallyOrdered[B]): Boolean
- Definition Classes
- PartiallyOrdered
- def _oneAt(j: Int, size: Int = dim): VectorL
Create a vector of the form (0, ...
- def abs: VectorL
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): VectorL
Get 'this' vector's elements that are given in the index vector.
- def apply(): ArraySeq[Long]
Get 'this' vector's entire array.
- def apply(r: Range): VectorL
Get 'this' vector's elements within the given range (vector slicing).
- def apply(i: Int): Long
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): VectorL
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: VectorL.this.type
- Attributes
- protected
- Definition Classes
- Iterable → IterableOps
- def collect[B](pf: PartialFunction[Long, B]): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def collectFirst[B](pf: PartialFunction[Long, B]): Option[B]
- Definition Classes
- IterableOnceOps
- def concat[B >: Long](suffix: IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps
- def contains(x: Long): Boolean
Determine whether 'x' is contained in 'this' vector.
- def containsAny(x: VectorL): 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: VectorL
Create an exact copy of 'this' vector.
- def copyToArray[B >: Long](xs: Array[B], start: Int, len: Int): Int
- Definition Classes
- IterableOnceOps
- def copyToArray[B >: Long](xs: Array[B], start: Int): Int
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def copyToArray[B >: Long](xs: Array[B]): Int
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def corresponds[B](that: IterableOnce[B])(p: (Long, B) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def count(p: (Long) => 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: VectorL
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: VectorL
Return a new vector consisting of the distinct elements from 'this' vector.
- def dot(b: VectorL): Long
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: VectoL): Long
Compute the dot product (or inner product) of 'this' vector with vector 'b'.
- def drop(n: Int): Iterable[Long]
- Definition Classes
- IterableOps → IterableOnceOps
- def dropRight(n: Int): Iterable[Long]
- Definition Classes
- IterableOps
- def dropWhile(p: (Long) => Boolean): Iterable[Long]
- Definition Classes
- IterableOps → IterableOnceOps
- def empty: Iterable[Long]
- 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: (Long) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def expand(more: Int = dim): VectorL
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
- VectoL
- def filter(p: (Long) => Boolean): VectorL
Filter the elements of 'this' vector based on the predicate 'p', returning a new vector.
- def filterMissing: VectorL
Filter out the missing elements of 'this' vector based on the predicate that 'e != noLong'.
- def filterNot(pred: (Long) => Boolean): Iterable[Long]
- Definition Classes
- IterableOps → IterableOnceOps
- def filterPos(p: (Long) => Boolean): IndexedSeq[Int]
Filter the elements of 'this' vector based on the predicate 'p', returning the index positions.
- def filterPos2(v2: VectoL, p: (Long, Long) => Boolean): IndexedSeq[(Int, Int)]
Filter the elements of 'this' vector based on the binary predicate 'p', returning the index positions.
- def find(p: (Long) => Boolean): Option[Long]
- 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: (Long) => IterableOnce[B]): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def flatten[B](implicit asIterable: (Long) => 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 >: Long](z: A1)(op: (A1, A1) => A1): A1
- Definition Classes
- IterableOnceOps
- def foldLeft[B](z: B)(op: (B, Long) => B): B
- Definition Classes
- IterableOnceOps
- def foldRight[B](z: B)(op: (Long, B) => B): B
- Definition Classes
- IterableOnceOps
- def forall(p: (Long) => Boolean): Boolean
- Definition Classes
- IterableOnceOps
- def foreach[U](f: (Long) => U): Unit
Iterate over 'this' vector element by element.
- def fromSpecific(coll: IterableOnce[Long]): Iterable[Long]
- Attributes
- protected
- Definition Classes
- IterableFactoryDefaults → IterableOps
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def groupBy[K](f: (Long) => K): Map[K, Iterable[Long]]
- Definition Classes
- IterableOps
- def groupMap[K, B](key: (Long) => K)(f: (Long) => B): Map[K, Iterable[B]]
- Definition Classes
- IterableOps
- def groupMapReduce[K, B](key: (Long) => K)(f: (Long) => B)(reduce: (B, B) => B): Map[K, B]
- Definition Classes
- IterableOps
- def grouped(size: Int): Iterator[Iterable[Long]]
- Definition Classes
- IterableOps
- def hashCode(): Int
Must also override hashCode for 'this' vector to be compatible with equals.
- def head: Long
- Definition Classes
- IterableOps
- def headOption: Option[Long]
- Definition Classes
- IterableOps
- def indexOf(x: Long, 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: (Long) => 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[Long]
- Definition Classes
- IterableOps
- def inits: Iterator[Iterable[Long]]
- Definition Classes
- IterableOps
- def intersect(x: VectorL): VectorL
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[Long]
Return an iterator which yields all the elements.
Return an iterator which yields all the elements.
- Definition Classes
- VectorL → IterableOnce
- def knownSize: Int
- Definition Classes
- IterableOnce
- def last: Long
- Definition Classes
- IterableOps
- def lastOption: Option[Long]
- Definition Classes
- IterableOps
- def lazyZip[B](that: Iterable[B]): LazyZip2[Long, B, VectorL.this.type]
- Definition Classes
- Iterable
- def mag: Long
Find the element with the greatest magnitude in 'this' vector.
Find the element with the greatest magnitude in 'this' vector.
- Definition Classes
- VectoL
- def map(f: (Long) => Long): VectorL
Map the elements of 'this' vector by applying the mapping function 'f'.
- def map[B](f: (Long) => B): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def max(b: VectorL): VectorL
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: VectoL): VectorL
Take the maximum of 'this' vector with vector 'b' (element-by element).
- def max(e: Int = dim): Long
Find the maximum element in 'this' vector.
- def max[B >: Long](implicit ord: Ordering[B]): Long
- Definition Classes
- IterableOnceOps
- def maxBy[B](f: (Long) => B)(implicit cmp: Ordering[B]): Long
- Definition Classes
- IterableOnceOps
- def maxByOption[B](f: (Long) => B)(implicit cmp: Ordering[B]): Option[Long]
- Definition Classes
- IterableOnceOps
- def maxOption[B >: Long](implicit ord: Ordering[B]): Option[Long]
- Definition Classes
- IterableOnceOps
- def mean: Double
Compute the mean of the elements of 'this' vector.
Compute the mean of the elements of 'this' vector.
- Definition Classes
- VectoL
- def min(b: VectorL): VectorL
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: VectoL): VectorL
Take the minimum of 'this' vector with vector 'b' (element-by element).
- def min(e: Int = dim): Long
Find the minimum element in 'this' vector.
- def min[B >: Long](implicit ord: Ordering[B]): Long
- Definition Classes
- IterableOnceOps
- def minBy[B](f: (Long) => B)(implicit cmp: Ordering[B]): Long
- Definition Classes
- IterableOnceOps
- def minByOption[B](f: (Long) => B)(implicit cmp: Ordering[B]): Option[Long]
- Definition Classes
- IterableOnceOps
- def minOption[B >: Long](implicit ord: Ordering[B]): Option[Long]
- 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 Long
Number of elements in the vector as a Long
- Definition Classes
- VectoL
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newSpecificBuilder: Builder[Long, Iterable[Long]]
- Attributes
- protected
- Definition Classes
- IterableFactoryDefaults → IterableOps
- def nonEmpty: Boolean
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecatedOverriding()
- def norm: Long
Compute the Euclidean norm (2-norm) of 'this' vector.
Compute the Euclidean norm (2-norm) of 'this' vector.
- Definition Classes
- VectoL
- def norm1: Long
Compute the Manhattan norm (1-norm) of 'this' vector, i.e., the sum of the absolute values of the elements.
- def normSq: Long
Compute the Euclidean norm (2-norm) squared of 'this' vector.
Compute the Euclidean norm (2-norm) squared of 'this' vector.
- Definition Classes
- VectoL
- def normalize: VectorL
Normalize 'this' vector so that it sums to one (like a probability vector).
- def normalize1: VectorL
Normalize 'this' vector to have a maximum of one.
- def normalizeU: VectorL
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): VectorL
Create a one vector (all elements are one) of length 'size'.
- def oneAt(j: Int, size: Int = dim): VectorL
Create a vector of the form (0, ...
- def partition(p: (Long) => Boolean): (Iterable[Long], Iterable[Long])
- Definition Classes
- IterableOps
- def partitionMap[A1, A2](f: (Long) => Either[A1, A2]): (Iterable[A1], Iterable[A2])
- Definition Classes
- IterableOps
- def pot(b: VectoL): Long
Compute the dot product (or inner product) of 'this' vector with vector 'b' zero-padded.
- def product[B >: Long](implicit num: Numeric[B]): B
- Definition Classes
- IterableOnceOps
- 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
- VectoL
- val range: Range
Range for the storage array
Range for the storage array
- Definition Classes
- VectoL
- 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: VectorL
Return the vector containing the reciprocal of each element of 'this' vector.
- def reduce[B >: Long](op: (B, B) => B): B
- Definition Classes
- IterableOnceOps
- def reduceLeft[B >: Long](op: (B, Long) => B): B
- Definition Classes
- IterableOnceOps
- def reduceLeftOption[B >: Long](op: (B, Long) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reduceOption[B >: Long](op: (B, B) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reduceRight[B >: Long](op: (Long, B) => B): B
- Definition Classes
- IterableOnceOps
- def reduceRightOption[B >: Long](op: (Long, B) => B): Option[B]
- Definition Classes
- IterableOnceOps
- def reorder(rnk: VectoI): VectoL
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
- VectoL
- def reverse(): VectorL
Reverse the order of the elements in 'this' vector.
- def reversed: Iterable[Long]
- Attributes
- protected
- Definition Classes
- IterableOnceOps
- def rot(b: VectoL)(from: Int = b.dim - 1): Long
Compute the dot product (or inner product) of 'this' vector with vector 'b' zero-padded and reversed.
- def sameDimensions(b: VectoL): 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
- VectoL
- def scan[B >: Long](z: B)(op: (B, B) => B): Iterable[B]
- Definition Classes
- IterableOps
- def scanLeft[B](z: B)(op: (B, Long) => B): Iterable[B]
- Definition Classes
- IterableOps → IterableOnceOps
- def scanRight[B](z: B)(op: (Long, B) => B): Iterable[B]
- Definition Classes
- IterableOps
- def select(basis: VectoI): VectorL
Select a subset of elements of 'this' vector corresponding to a 'basis'.
- def select(basis: Array[Int]): VectorL
Select a subset of elements of 'this' vector corresponding to a 'basis'.
- def selectEx(basis: VectoI): VectoL
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
- VectoL
- def selectEx(basis: Array[Int]): VectoL
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
- VectoL
- def set(u: Seq[Long]): Unit
Set the values in 'this' vector to the values in sequence/array 'u'.
- def set(x: Long): 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
- VectoL
- 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): VectorL
Slice 'this' vector 'from' to 'end'.
- def slice(rg: Range): VectoL
Slice 'this' vector over the given range 'rg'.
Slice 'this' vector over the given range 'rg'.
- rg
the range specifying the slice
- Definition Classes
- VectoL
- def sliceEx(rg: Range): VectoL
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
- VectoL
- def sliding(size: Int, step: Int): Iterator[Iterable[Long]]
- Definition Classes
- IterableOps
- def sliding(size: Int): Iterator[Iterable[Long]]
- 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: (Long) => Boolean): (Iterable[Long], Iterable[Long])
- Definition Classes
- IterableOps → IterableOnceOps
- def split(k: Int): Array[VectoL]
Split 'this' vector into 'k' arrays of equal sizes (perhaps except for the last one).
- def split(basis: VectoI): (VectoL, VectoL)
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
- VectoL
- def split(basis: Array[Int]): (VectoL, VectoL)
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
- VectoL
- def splitAt(n: Int): (Iterable[Long], Iterable[Long])
- Definition Classes
- IterableOps → IterableOnceOps
- def sq: VectoL
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
- VectoL
- def stepper[S <: Stepper[_]](implicit shape: StepperShape[Long, S]): S
- Definition Classes
- IterableOnce
- def stringPrefix: String
- Attributes
- protected[this]
- Definition Classes
- Iterable
- Annotations
- @deprecatedOverriding()
- def sum: Long
Sum the elements of 'this' vector.
- def sum[B >: Long](implicit num: Numeric[B]): B
- Definition Classes
- IterableOnceOps
- def sumNE(i: Int): Long
Sum the elements of 'this' vector skipping the 'i'-th element (Not Equal 'i').
- def sumPos: Long
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[Long]
- Definition Classes
- IterableOps
- def tails: Iterator[Iterable[Long]]
- Definition Classes
- IterableOps
- def take(n: Int): Iterable[Long]
- Definition Classes
- IterableOps → IterableOnceOps
- def takeRight(n: Int): Iterable[Long]
- Definition Classes
- IterableOps
- def takeWhile(p: (Long) => Boolean): Iterable[Long]
- Definition Classes
- IterableOps → IterableOnceOps
- def tapEach[U](f: (Long) => U): Iterable[Long]
- Definition Classes
- IterableOps → IterableOnceOps
- def to[C1](factory: Factory[Long, C1]): C1
- Definition Classes
- IterableOnceOps
- def toArray[B >: Long](implicit arg0: ClassTag[B]): Array[B]
- Definition Classes
- IterableOnceOps
- final def toBuffer[B >: Long]: Buffer[B]
- Definition Classes
- IterableOnceOps
- Annotations
- @inline()
- def toDense: VectorL
Convert 'this'
VectorLinto a denseVectorL. - def toDouble: VectorD
Convert 'this'
VectorLinto aVectorD. - def toIndexedSeq: IndexedSeq[Long]
- Definition Classes
- IterableOnceOps
- def toInt: VectorI
Convert 'this'
VectorLinto aVectorI. - final def toIterable: VectorL.this.type
- Definition Classes
- Iterable → IterableOps
- def toList: List[Long]
- Definition Classes
- IterableOnceOps
- def toLong: VectorL
Convert 'this'
VectorLinto aVectorL. - def toMap[K, V](implicit ev: <:<[Long, (K, V)]): Map[K, V]
- Definition Classes
- IterableOnceOps
- def toSeq: Seq[Long]
- Definition Classes
- IterableOnceOps
- def toSet[B >: Long]: Set[B]
- Definition Classes
- IterableOnceOps
- def toString: String
Convert 'this' vector to a String.
- def toVector: Vector[Long]
- Definition Classes
- IterableOnceOps
- def transpose[B](implicit asIterable: (Long) => Iterable[B]): Iterable[Iterable[B]]
- Definition Classes
- IterableOps
- def tryCompareTo[B >: VectorL](b: B)(implicit view_1: (B) => PartiallyOrdered[B]): Option[Int]
Compare 'this' vector with vector 'b'.
- def unary_-: VectorL
Return the negative of 'this' vector (unary minus).
- def unzip[A1, A2](implicit asPair: (Long) => (A1, A2)): (Iterable[A1], Iterable[A2])
- Definition Classes
- IterableOps
- def unzip3[A1, A2, A3](implicit asTriple: (Long) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
- Definition Classes
- IterableOps
- def update(r: Range, u: VectoL): Unit
Set 'this' vector's elements over the given range (vector slicing).
- def update(r: Range, x: Long): Unit
Set 'this' vector's elements over the given range (vector slicing).
- def update(i: Int, x: Long): Unit
Set 'this' vector's element at the 'i'-th index position.
- var v: Array[Long]
- Attributes
- protected
- def variance: Double
Compute the (unbiased) sample variance of the elements of 'this' vector.
Compute the (unbiased) sample variance of the elements of 'this' vector.
- Definition Classes
- VectoL
- def view: View[Long]
- 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: (Long) => Boolean): WithFilter[Long, Iterable]
- Definition Classes
- IterableOps
- def zero(size: Int = dim): VectorL
Create a zero vector (all elements are zero) of length 'size'.
- def zip[B](that: IterableOnce[B]): Iterable[(Long, B)]
- Definition Classes
- IterableOps
- def zipAll[A1 >: Long, B](that: Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]
- Definition Classes
- IterableOps
- def zipWithIndex: Iterable[(Long, Int)]
- Definition Classes
- IterableOps → IterableOnceOps
- def ~^(s: Long): VectorL
Return the vector containing each element of 'this' vector raised to the s-th power.
- def ~^=(s: Long): VectorL
Raise in-place each element of 'this' vector to the 's'-th power.
- def ∙(b: VectoL): Long
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
- VectoL
- def ≠(b: VectoL): Boolean
Compare 'this' vector with that vector 'b' for inequality.
- def ≤(b: VectoL): 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
- VectoL
- def ≥(b: VectoL): 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
- VectoL
Deprecated Value Members
- def ++:[B >: Long](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, Long) => B): B
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use foldLeft instead of /:
- final def :\[B](z: B)(op: (Long, 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, Long) => 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 >: Long](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[Long]
- 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: VectorL.this.type
- Definition Classes
- Iterable
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Iterable.seq always returns the iterable itself
- final def toIterator: Iterator[Long]
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use .iterator instead of .toIterator
- final def toStream: Stream[Long]
- Definition Classes
- IterableOnceOps
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.13.0) Use .to(LazyList) instead of .toStream
- final def toTraversable: Traversable[Long]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use toIterable instead
- def view(from: Int, until: Int): View[Long]
- Definition Classes
- IterableOps
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use .view.slice(from, until) instead of .view(from, until)