trait Vec[T] extends NumericOps[Vec[T]]
Vec
is an immutable container for 1D homogeneous data (a "vector"). It is
backed by an array and indexed from 0 to length - 1.
Several element access methods are provided.
The apply()
method returns a slice of the original vector:
val v = Vec(1,2,3,4) v(0) == Vec(1) v(1, 2) == Vec(2,3)
The at
method returns an instance of a org.saddle.scalar.Scalar, which
behaves much like an Option
in that it can be either an instance of
org.saddle.scalar.NA or a org.saddle.scalar.Value case class:
Vec[Int](1,2,3,na).at(0) == Scalar(1) Vec[Int](1,2,3,na).at(3) == NA
The method raw
accesses the underlying value directly.
Vec(1d,2,3).raw(0) == 1d
Vec
may be used in arithmetic expressions which operate on two Vec
s or
on a Vec
and a scalar value. A few examples:
Vec(1,2,3,4) + Vec(2,3,4,5) == Vec(3,5,7,9) Vec(1,2,3,4) * 2 == Vec(2,4,6,8)
Note, Vec is implicitly convertible to an array for convenience; this could be abused to mutate the contents of the Vec. Try to avoid this!
- T
Type of elements within the Vec
- Alphabetic
- By Inheritance
- Vec
- NumericOps
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def apply(loc: Int): T
Access an unboxed element of a Vec[A] at a single location Same as raw
Access an unboxed element of a Vec[A] at a single location Same as raw
- loc
offset into Vec
- abstract def argmax(implicit na: NUM[T], st: ST[T], ord: ORD[T]): Int
Integer offset of the minimum element of the Vec, if one exists, or else -1
- abstract def argmin(implicit na: NUM[T], st: ST[T], ord: ORD[T]): Int
Integer offset of the minimum element of the Vec, if one exists, or else -1
- abstract def at(loc: Int): Scalar[T]
Access a boxed element of a Vec[A] at a single location
Access a boxed element of a Vec[A] at a single location
- loc
offset into Vec
- abstract def concat(v: Vec[T]): Vec[T]
Concatenate two Vec instances together, where there exists some way to join the type of elements.
Concatenate two Vec instances together, where there exists some way to join the type of elements. For instance, Vec[Double] concat Vec[Int] will promote Int to Double as a result of the implicit existence of an instance of Promoter[Double, Int, Double]
- v
Vec[B] to concat
- abstract def contents: Array[T]
Return copy of backing array
- abstract def copy: Vec[T]
Returns a Vec whose backing array has been copied
- abstract def count: Int
- abstract def countif(test: (T) => Boolean): Int
- abstract def dropLeft(i: Int): Vec[T]
Returns a Vec with the first
i
elements removed - abstract def dropNA: Vec[T]
Drop the elements of the Vec which are NA
- abstract def dropRight(i: Int): Vec[T]
Returns a Vec with the last
i
elements removed - abstract def exists(pred: (T) => Boolean): Boolean
Return true if there exists some element of the Vec which satisfies the predicate function
Return true if there exists some element of the Vec which satisfies the predicate function
- pred
Predicate function from A => Boolean
- abstract def fillBackward(limit: Int = 0): Vec[T]
Fill NA values by propagating defined values backward.
Fill NA values by propagating defined values backward.
- limit
If > 0, propagate over a maximum of
limit
consecutive NA values
- abstract def fillForward(limit: Int = 0): Vec[T]
Fill NA values by propagating defined values forward.
Fill NA values by propagating defined values forward.
- limit
If > 0, propagate over a maximum of
limit
consecutive NA values
- abstract def fillNA(method: FillMethod, limit: Int = 0): Vec[T]
Fill NAs by propagating existent values.
Fill NAs by propagating existent values.
- limit
If > 0, fill a maximum of
limit
consecutive NA values
- abstract def fillNA(f: (Int) => T): Vec[T]
Fills NA values in vector with result of a function which acts on the index of the particular NA value found
Fills NA values in vector with result of a function which acts on the index of the particular NA value found
- f
A function from Int => A; yields value for NA value at ith position
- abstract def filter(pred: (T) => Boolean): Vec[T]
Return Vec whose elements satisfy a predicate function
Return Vec whose elements satisfy a predicate function
- pred
Predicate function from A => Boolean
- abstract def filterAt(pred: (Int) => Boolean): Vec[T]
Return vec whose offets satisfy a predicate function
Return vec whose offets satisfy a predicate function
- pred
Predicate function from Int => Boolean
- abstract def filterFoldLeft[B](pred: (T) => Boolean)(init: B)(f: (B, T) => B)(implicit arg0: ST[B]): B
Filtered left fold over the elements of the Vec, as in scala collections library
- abstract def filterScanLeft[B](pred: (T) => Boolean)(init: B)(f: (B, T) => B)(implicit arg0: ST[B]): Vec[B]
Filtered left scan over elements of the Vec, as in scala collections library
- abstract def find(pred: (T) => Boolean): Vec[Int]
Return Vec of integer locations (offsets) which satisfy some predicate
Return Vec of integer locations (offsets) which satisfy some predicate
- pred
Predicate function from A => Boolean
- abstract def findOne(pred: (T) => Boolean): Int
Return first integer location which satisfies some predicate, or -1 if there is none
Return first integer location which satisfies some predicate, or -1 if there is none
- pred
Predicate function from A => Boolean
- abstract def first: Scalar[T]
Access the first element of a Vec[A], or NA if length is zero
- abstract def flatMap[B](f: (T) => Vec[B])(implicit arg0: ST[B]): Vec[B]
Maps a function over elements of the Vec and flattens the result.
Maps a function over elements of the Vec and flattens the result.
NAs are ignored and
f
is never called on a NA - abstract def foldLeft[B](init: B)(f: (B, T) => B)(implicit arg0: ST[B]): B
Left fold over the elements of the Vec, as in scala collections library
- abstract def foldLeftWhile[B](init: B)(f: (B, T) => B)(cond: (B, T) => Boolean)(implicit arg0: ST[B]): B
Left fold that folds only while the test condition holds true.
Left fold that folds only while the test condition holds true. As soon as the condition function yields false, the fold returns.
- cond
Function whose signature is the same as the fold function, except that it evaluates to Boolean
- abstract def forall(pred: (T) => Boolean)(op: (T) => Unit): Unit
Execute a (side-effecting) operation on each (non-NA) element in vec which satisfies some predicate.
Execute a (side-effecting) operation on each (non-NA) element in vec which satisfies some predicate.
- pred
Function A => Boolean
- op
Side-effecting function
- abstract def foreach(op: (T) => Unit): Unit
Execute a (side-effecting) operation on each (non-NA) element in the vec
Execute a (side-effecting) operation on each (non-NA) element in the vec
- op
operation to execute
- abstract def hasNA: Boolean
Return true if there is an NA value in the Vec
- abstract def head(n: Int): Vec[T]
Return first n elements
Return first n elements
- n
Number of elements to access
- abstract def isEmpty: Boolean
True if and only if number of elements is zero
- abstract def last: Scalar[T]
Access the last element of a Vec[A], or NA if length is zero
- abstract def length: Int
The number of elements in the container F
- abstract def map[B](f: (T) => B)(implicit arg0: ST[B]): Vec[B]
Map a function over the elements of the Vec, as in scala collections library
- abstract def mask(f: (T) => Boolean): Vec[T]
Returns Vec whose locations are NA where the result of the provided function evaluates to true
Returns Vec whose locations are NA where the result of the provided function evaluates to true
- f
A function taking an element and returning a Boolean
- abstract def mask(m: Vec[Boolean]): Vec[T]
Returns Vec whose locations corresponding to true entries in the boolean input mask vector are set to NA
Returns Vec whose locations corresponding to true entries in the boolean input mask vector are set to NA
- m
Mask vector of Vec[Boolean]
- abstract def max(implicit na: NUM[T], st: ST[T]): Scalar[T]
- abstract def mean(implicit na: NUM[T]): Double
Return the mean of the values in the Vec, ignoring NA
- abstract def median(implicit na: NUM[T]): Double
Return the median of the values in the Vec, ignoring NA
- abstract def min(implicit na: NUM[T], st: ST[T]): Scalar[T]
- abstract def needsCopy: Boolean
Set to true when the vec is shifted over the backing array false iff the backing array is a contiguous sequence of the elements of this Vec false iff 0 until length map (raw) == the backing array
- abstract def partition(pred: Vec[Boolean]): (Vec[T], Vec[T])
Return Vec whose elements are selected via negating a Vec of booleans (where that Vec holds the value true)
Return Vec whose elements are selected via negating a Vec of booleans (where that Vec holds the value true)
- pred
Predicate vector: Vec[Boolean]
- abstract def percentile(tile: Double, method: PctMethod = PctMethod.NIST)(implicit na: NUM[T]): Double
Return the percentile of the values at a particular threshold, ignoring NA
Return the percentile of the values at a particular threshold, ignoring NA
- tile
The percentile in [0, 100] at which to compute the threshold
- method
The percentile method; one of org.saddle.PctMethod
- abstract def print(len: Int, stream: OutputStream): Unit
Pretty-printer for Vec, which simply outputs the result of stringify.
Pretty-printer for Vec, which simply outputs the result of stringify.
- len
Number of elements to display
- abstract def prod(implicit na: NUM[T], st: ST[T]): T
Product of all the values in the Vec, ignoring NA values
- abstract def rank(tie: RankTie = RankTie.Avg, ascending: Boolean = true)(implicit na: NUM[T]): Vec[Double]
Return a Vec of ranks corresponding to a Vec of numeric values.
Return a Vec of ranks corresponding to a Vec of numeric values.
- tie
Method with which to break ties; a org.saddle.RankTie
- ascending
Boolean, default true, whether to give lower values larger rank
- abstract def raw(loc: Int): T
Access an unboxed element of a Vec[A] at a single location Same as apply
Access an unboxed element of a Vec[A] at a single location Same as apply
- loc
offset into Vec
- abstract def reshape(rows: Int, cols: Int): Mat[T]
Reshapes the Vec into a Mat
Reshapes the Vec into a Mat
May not copy. The new Mat instance may share data with this Vec.
- abstract def reversed: Vec[T]
Yield a Vec whose elements have been reversed from their original order
- abstract def rolling[B](winSz: Int, f: (Vec[T]) => B)(implicit arg0: ST[B]): Vec[B]
Produce a Vec whose entries are the result of executing a function on a sliding window of the data.
Produce a Vec whose entries are the result of executing a function on a sliding window of the data.
- B
Result type of function
- winSz
Window size
- f
Function Vec[A] => B to operate on sliding window
- abstract def roundTo(sig: Int = 2)(implicit ev: NUM[T]): Vec[Double]
Rounds elements in the vec (which must be numeric) to a significance level
Rounds elements in the vec (which must be numeric) to a significance level
- sig
Significance level to round to (e.g., 2 decimal places)
- abstract def scalarTag: ScalarTag[T]
A ScalarTag in the type of the elements of the Vec
- abstract def scanLeft[B](init: B)(f: (B, T) => B)(implicit arg0: ST[B]): Vec[B]
Left scan over the elements of the Vec, as in scala collections library
- abstract def shift(n: Int): Vec[T]
Creates a view into original Vec, but shifted so that n values at the beginning or end of the Vec are NA's.
Creates a view into original Vec, but shifted so that n values at the beginning or end of the Vec are NA's. Data is not copied.
- n
Number of offsets to shift
- abstract def slice(from: Int, until: Int, stride: Int = 1): Vec[T]
Creates a view into original vector from an offset up to, but excluding, another offset.
Creates a view into original vector from an offset up to, but excluding, another offset. Data is not copied.
- from
Beginning offset
- until
One past ending offset
- stride
Increment within slice
- abstract def sliceBy(from: Int, to: Int, stride: Int = 1): Vec[T]
Creates a view into original vector from an offset up to, and including, another offset.
Creates a view into original vector from an offset up to, and including, another offset. Data is not copied.
- from
Beginning offset
- to
Ending offset
- stride
Increment within slice
- abstract def sorted(implicit ev: ORD[T], st: ST[T]): Vec[T]
Yield a Vec whose elements have been sorted (in ascending order)
Yield a Vec whose elements have been sorted (in ascending order)
- ev
evidence of Ordering[A]
- abstract def splitAt(i: Int): (Vec[T], Vec[T])
Split Vec into two Vecs at position i
Split Vec into two Vecs at position i
- i
Position at which to split Vec
- abstract def stringify(len: Int): String
Creates a string representation of Vec
Creates a string representation of Vec
- len
Max number of elements to include
- abstract def sum(implicit na: NUM[T], st: ST[T]): T
- abstract def tail(n: Int): Vec[T]
Return last n elements
Return last n elements
- n
Number of elements to access
- abstract def take(rng: Slice[Int]): Vec[T]
Slice a Vec at a bound of locations, e.g.
Slice a Vec at a bound of locations, e.g.
val v = Vec(1,2,3,4,5) v(1->3) == Vec(2,3,4)
- rng
evaluates to IRange
- abstract def take(locs: Int*): Vec[T]
- abstract def take(locs: Array[Int]): Vec[T]
Equivalent to slicing operation; e.g.
Equivalent to slicing operation; e.g.
val v = Vec(1,2,3) v.take(0,1) == v(0,1)
- locs
Location of elements to take
- abstract def takeLeft(i: Int): Vec[T]
Returns a Vec with the first
i
elements - abstract def takeRight(i: Int): Vec[T]
Returns a Vec with the last
i
elements - abstract def toArray: Array[T]
- abstract def toSeq: IndexedSeq[T]
Converts Vec to an indexed sequence (default implementation is immutable.Vector)
- abstract def unary_-(implicit num: NUM[T]): Vec[T]
Additive inverse of Vec with numeric elements
- abstract def update(slice: Slice[Int], value: Vec[T]): Unit
Updates (overwrites) a range in the Vec
Updates (overwrites) a range in the Vec
Mutates the underlying array
- abstract def update(slice: Slice[Int], value: T): Unit
Updates (overwrites) a range in the Vec
Updates (overwrites) a range in the Vec
Mutates the underlying array
- abstract def update(offset: Int, value: T): Unit
Updates (overwrites) a location in the Vec
Updates (overwrites) a location in the Vec
Mutates the underlying array
- abstract def updated(offsets: Array[Int], value: T): Vec[T]
Returns a new Vec with the values at
offset
set tovalue
Returns a new Vec with the values at
offset
set tovalue
Copies before mutating. Ignores invalid offsets in the array
- abstract def updated(offset: Int, value: T): Vec[T]
Returns a new Vec with the value at
offset
set tovalue
Returns a new Vec with the value at
offset
set tovalue
Copies before mutating.
- abstract def view(offsets1: Array[Int]): Vec[T]
Creates a view into original vector at arbitrary indexes.
Creates a view into original vector at arbitrary indexes. Data is not copied.
- offsets1
indexes into the original array
- abstract def where(pred: Vec[Boolean]): Vec[T]
Return Vec whose elements are selected via a Vec of booleans (where that Vec holds the value true)
Return Vec whose elements are selected via a Vec of booleans (where that Vec holds the value true)
- pred
Predicate vector: Vec[Boolean]
- abstract def whereNot(pred: Vec[Boolean]): Vec[T]
Return Vec whose elements are selected via negating a Vec of booleans (where that Vec holds the value true)
Return Vec whose elements are selected via negating a Vec of booleans (where that Vec holds the value true)
- pred
Predicate vector: Vec[Boolean]
- abstract def without(locs: Array[Int]): Vec[T]
The complement of the take operation; slice out elements NOT specified in list.
The complement of the take operation; slice out elements NOT specified in list.
- locs
Location of elements not to take
- abstract def zipMap[B, C](other: Vec[B])(f: (T, B) => C)(implicit arg0: ST[B], arg1: ST[C]): Vec[C]
Zips Vec with another Vec and applies a function to the paired elements.
Zips Vec with another Vec and applies a function to the paired elements. If either of the pair is NA, the result is forced to NA.
- B
Parameter of other Vec
- C
Result of function
- other
Vec[B]
- f
Function (A, B) => C
- abstract def zipMapIdx[C](f: (T, Int) => C)(implicit arg0: ST[C]): Vec[C]
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def %[B, That](other: B)(implicit op: BinOp[Mod, Vec[T], B, That]): That
Integer modulus of division
Integer modulus of division
- B
type of the other operand
- That
result type of operation
- other
other operand instance (divisor)
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def %=[B](other: B)(implicit op: BinOpInPlace[Mod, Vec[T], B]): Unit
- Definition Classes
- NumericOps
- def &[B, That](other: B)(implicit op: BinOp[BitAnd, Vec[T], B, That]): That
Bit-wise AND
Bit-wise AND
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def &&[B, That](other: B)(implicit op: BinOp[AndOp, Vec[T], B, That]): That
Logical AND
Logical AND
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def *[B, That](other: B)(implicit op: BinOp[Multiply, Vec[T], B, That]): That
Multiplication
Multiplication
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def **[B, That](other: B)(implicit op: BinOp[Power, Vec[T], B, That]): That
Exponentiation
Exponentiation
- B
type of the other operand
- That
result type of operation
- other
other operand instance (exponent)
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def **=[B](other: B)(implicit op: BinOpInPlace[Power, Vec[T], B]): Unit
- Definition Classes
- NumericOps
- def *=[B](other: B)(implicit op: BinOpInPlace[Multiply, Vec[T], B]): Unit
- Definition Classes
- NumericOps
- def +[B, That](other: B)(implicit op: BinOp[Add, Vec[T], B, That]): That
Addition
Addition
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def +=[B](other: B)(implicit op: BinOpInPlace[Add, Vec[T], B]): Unit
- Definition Classes
- NumericOps
- def -[B, That](other: B)(implicit op: BinOp[Subtract, Vec[T], B, That]): That
Subtraction
Subtraction
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def -=[B](other: B)(implicit op: BinOpInPlace[Subtract, Vec[T], B]): Unit
- Definition Classes
- NumericOps
- def /[B, That](other: B)(implicit op: BinOp[Divide, Vec[T], B, That]): That
Division
Division
- B
type of the other operand
- That
result type of operation
- other
other operand instance (divisor)
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def /=[B](other: B)(implicit op: BinOpInPlace[Divide, Vec[T], B]): Unit
- Definition Classes
- NumericOps
- def <[B, That](other: B)(implicit op: BinOp[LtOp, Vec[T], B, That]): That
Less-than comparison operator
Less-than comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def <<[B, That](other: B)(implicit op: BinOp[BitShl, Vec[T], B, That]): That
Bit-shift left
Bit-shift left
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def <=[B, That](other: B)(implicit op: BinOp[LteOp, Vec[T], B, That]): That
Less-than-or-equal-to comparison operator
Less-than-or-equal-to comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def <>[B, That](other: B)(implicit op: BinOp[NeqOp, Vec[T], B, That]): That
Element-wise inequality operator
Element-wise inequality operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def =?[B, That](other: B)(implicit op: BinOp[EqOp, Vec[T], B, That]): That
Element-wise equality operator
Element-wise equality operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def >[B, That](other: B)(implicit op: BinOp[GtOp, Vec[T], B, That]): That
Greater-than comparison operator
Greater-than comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def >=[B, That](other: B)(implicit op: BinOp[GteOp, Vec[T], B, That]): That
Greater-than-or-equal-to comparison operator
Greater-than-or-equal-to comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def >>[B, That](other: B)(implicit op: BinOp[BitShr, Vec[T], B, That]): That
Bit-shift right (arithmetic)
Bit-shift right (arithmetic)
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def >>>[B, That](other: B)(implicit op: BinOp[BitUShr, Vec[T], B, That]): That
Bit-shift right (logical)
Bit-shift right (logical)
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def ^[B, That](other: B)(implicit op: BinOp[BitXor, Vec[T], B, That]): That
Bit-wise EXCLUSIVE OR
Bit-wise EXCLUSIVE OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def dot[B, That](other: B)(implicit op: BinOp[InnerProd, Vec[T], B, That]): That
Dot (inner) product
Dot (inner) product
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def outer[B, That](other: B)(implicit op: BinOp[OuterProd, Vec[T], B, That]): That
Outer product
Outer product
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- 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()
- def xor[B, That](other: B)(implicit op: BinOp[XorOp, Vec[T], B, That]): That
Logical EXCLUSIVE OR
Logical EXCLUSIVE OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def |[B, That](other: B)(implicit op: BinOp[BitOr, Vec[T], B, That]): That
Bit-wise OR
Bit-wise OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def ||[B, That](other: B)(implicit op: BinOp[OrOp, Vec[T], B, That]): That
Logical OR
Logical OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps