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