saddle-core
API
Generated with
saddle-core/org.saddle.vec/VecDefault

VecDefault

org.saddle.vec.VecDefault
class VecDefault[T](values: Array[T], val scalarTag: ScalarTag[T]) extends NumericOps[Vec[T]] with Vec[T]

Attributes

Graph
Supertypes
trait Vec[T]
trait NumericOps[Vec[T]]
class Object
trait Matchable
class Any
Self type

Members list

Concise view

Value members

Concrete methods

def apply(loc: Int): T

Same as raw

Same as raw

Attributes

def argmax(implicit na: Numeric[T], st: ScalarTag[T], ord: Order[T]): Int

Integer offset of the minimum element of the Vec, if one exists, or else -1

Integer offset of the minimum element of the Vec, if one exists, or else -1

Attributes

def argmin(implicit na: Numeric[T], st: ScalarTag[T], ord: Order[T]): Int

Integer offset of the minimum element of the Vec, if one exists, or else -1

Integer offset of the minimum element of the Vec, if one exists, or else -1

Attributes

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

Attributes

loc

offset into Vec

def concat(v: Vec[T]): Vec[T]

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]

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]

Attributes

B

type of other Vec elements

C

type of resulting Vec elements

mc

Implicit evidence of ST[C]

v

Vec[B] to concat

wd

Implicit evidence of Promoter[A, B, C]

def contents: Array[T]

Return copy of backing array

Return copy of backing array

Attributes

def copy: Vec[T]

Returns a Vec whose backing array has been copied

Returns a Vec whose backing array has been copied

Attributes

def count: Int

Counts the number of non-NA elements

Counts the number of non-NA elements

Attributes

def countif(test: T => Boolean): Int

Counts the number of non-NA elements satisfying the predicate

Counts the number of non-NA elements satisfying the predicate

Attributes

def countif(a: T): Int

Counts the number of elements which equal a

Counts the number of elements which equal a

Attributes

def dropLeft(i: Int): Vec[T]

Returns a Vec with the first i elements removed

Returns a Vec with the first i elements removed

Attributes

def dropNA: Vec[T]

Drop the elements of the Vec which are NA

Drop the elements of the Vec which are NA

Attributes

def dropRight(i: Int): Vec[T]

Returns a Vec with the last i elements removed

Returns a Vec with the last i elements removed

Attributes

override def equals(o: Any): Boolean

Default equality does an iterative, element-wise equality check of all values.

Default equality does an iterative, element-wise equality check of all values.

Attributes

Definition Classes
Any
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

Attributes

pred

Predicate function from A => Boolean

def fillBackward(limit: Int): Vec[T]

Fill NA values by propagating defined values backward.

Fill NA values by propagating defined values backward.

Attributes

limit

If > 0, propagate over a maximum of limit consecutive NA values

def fillForward(limit: Int): Vec[T]

Fill NA values by propagating defined values forward.

Fill NA values by propagating defined values forward.

Attributes

limit

If > 0, propagate over a maximum of limit consecutive NA values

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

Attributes

f

A function from Int => A; yields value for NA value at ith position

def fillNA(method: FillMethod, limit: Int): Vec[T]

Fill NAs by propagating existent values.

Fill NAs by propagating existent values.

Attributes

fm

Filling method, forward or backward

limit

If > 0, fill a maximum of limit consecutive NA values

def filter(pred: T => Boolean): Vec[T]

Return Vec whose elements satisfy a predicate function

Return Vec whose elements satisfy a predicate function

Attributes

pred

Predicate function from A => Boolean

def filterAt(pred: Int => Boolean): Vec[T]

Return vec whose offets satisfy a predicate function

Return vec whose offets satisfy a predicate function

Attributes

pred

Predicate function from Int => Boolean

def filterFoldLeft[B : ScalarTag](pred: T => Boolean)(init: B)(f: (B, T) => B): B

Filtered left fold over the elements of the Vec, as in scala collections library

Filtered left fold over the elements of the Vec, as in scala collections library

Attributes

def filterScanLeft[B : ScalarTag](pred: T => Boolean)(init: B)(f: (B, T) => B): Vec[B]

Filtered left scan over elements of the Vec, as in scala collections library

Filtered left scan over elements of the Vec, as in scala collections library

Attributes

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

Attributes

pred

Predicate function from A => Boolean

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

Attributes

pred

Predicate function from A => Boolean

def first: Scalar[T]

Access the first element of a Vec[A], or NA if length is zero

Access the first element of a Vec[A], or NA if length is zero

Attributes

def flatMap[B : ScalarTag](f: T => Vec[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.

Attributes

def foldLeft[B : ScalarTag](init: B)(f: (B, T) => B): B

Left fold over the elements of the Vec, as in scala collections library

Left fold over the elements of the Vec, as in scala collections library

Attributes

def foldLeftWhile[B : ScalarTag](init: B)(f: (B, T) => B)(cond: (B, T) => Boolean): B

Left fold that folds only while the test condition holds true. As soon as the condition function yields false, the fold returns.

Left fold that folds only while the test condition holds true. As soon as the condition function yields false, the fold returns.

Attributes

cond

Function whose signature is the same as the fold function, except that it evaluates to Boolean

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.

Attributes

op

Side-effecting function

pred

Function A => Boolean

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

Attributes

op

operation to execute

def hasNA: Boolean

Return true if there is an NA value in the Vec

Return true if there is an NA value in the Vec

Attributes

override def hashCode(): Int

Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.

Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.

Attributes

Definition Classes
Any
def head(n: Int): Vec[T]

Return first n elements

Return first n elements

Attributes

n

Number of elements to access

def isEmpty: Boolean

True if and only if number of elements is zero

True if and only if number of elements is zero

Attributes

def last: Scalar[T]

Access the last element of a Vec[A], or NA if length is zero

Access the last element of a Vec[A], or NA if length is zero

Attributes

def length: Int

The number of elements in the container F

The number of elements in the container F

Attributes

def map[B : ScalarTag](f: T => B): Vec[B]

Map a function over the elements of the Vec, as in scala collections library

Map a function over the elements of the Vec, as in scala collections library

Attributes

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

Attributes

m

Mask vector of Vec[Boolean]

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

Attributes

f

A function taking an element and returning a Boolean

def max(implicit na: Numeric[T], st: ScalarTag[T]): Scalar[T]
def mean(implicit n: Numeric[T]): Double

Return the mean of the values in the Vec, ignoring NA

Return the mean of the values in the Vec, ignoring NA

Attributes

def median(implicit n: Numeric[T]): Double

Return the median of the values in the Vec, ignoring NA

Return the median of the values in the Vec, ignoring NA

Attributes

def min(implicit na: Numeric[T], st: ScalarTag[T]): Scalar[T]
override 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 toArray structurally equals the backing array

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 toArray structurally equals the backing array

Attributes

Definition Classes
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)

Attributes

pred

Predicate vector: Vec[Boolean]

def percentile(tile: Double, method: PctMethod)(implicit na: Numeric[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

Attributes

method

The percentile method; one of org.saddle.PctMethod percentile function: see: http://en.wikipedia.org/wiki/Percentile

tile

The percentile in [0, 100] at which to compute the threshold

def prod(implicit na: Numeric[T], st: ScalarTag[T]): T

Product of all the values in the Vec, ignoring NA values

Product of all the values in the Vec, ignoring NA values

Attributes

def rank(tie: RankTie, ascending: Boolean)(implicit na: Numeric[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.

Attributes

ascending

Boolean, default true, whether to give lower values larger rank

tie

Method with which to break ties; a org.saddle.RankTie

def raw(loc: Int): T

Access an unboxed element of a Vec[A] at a single location

Access an unboxed element of a Vec[A] at a single location

Attributes

loc

offset into Vec

def reshape(rows: Int, columns: 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.

Attributes

def reversed: Vec[T]

Yield a Vec whose elements have been reversed from their original order

Yield a Vec whose elements have been reversed from their original order

Attributes

def rolling[B : ScalarTag](winSz: Int, f: Vec[T] => 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.

Attributes

B

Result type of function

f

Function Vec[A] => B to operate on sliding window

winSz

Window size

def roundTo(sig: Int)(implicit ev: Numeric[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

Attributes

sig

Significance level to round to (e.g., 2 decimal places)

def scanLeft[B : ScalarTag](init: B)(f: (B, T) => B): Vec[B]

Left scan over the elements of the Vec, as in scala collections library

Left scan over the elements of the Vec, as in scala collections library

Attributes

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. Data is not copied. ex. shift(1) : [1 2 3 4] => [NA 1 2 3] shift(-1) : [1 2 3 4] => [2 3 4 NA]

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. ex. shift(1) : [1 2 3 4] => [NA 1 2 3] shift(-1) : [1 2 3 4] => [2 3 4 NA]

Attributes

n

Number of offsets to shift

def slice(from: Int, until: Int, stride: Int): Vec[T]

Creates a view into original vector from an offset up to, but excluding, another offset. Data is not copied.

Creates a view into original vector from an offset up to, but excluding, another offset. Data is not copied.

Attributes

from

Beginning offset

stride

Increment within slice

until

One past ending offset

def sliceBy(from: Int, to: Int, stride: Int): Vec[T]

Creates a view into original vector from an offset up to, and including, another offset. Data is not copied.

Creates a view into original vector from an offset up to, and including, another offset. Data is not copied.

Attributes

from

Beginning offset

stride

Increment within slice

to

Ending offset

def sorted(implicit ev: Order[T], st: ScalarTag[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)

Attributes

ev

evidence of Ordering[A]

def splitAt(i: Int): (Vec[T], Vec[T])

Split Vec into two Vecs at position i

Split Vec into two Vecs at position i

Attributes

i

Position at which to split Vec

def stringify(len: Int): String

Creates a string representation of Vec

Creates a string representation of Vec

Attributes

len

Max number of elements to include

def sum(implicit na: Numeric[T], st: ScalarTag[T]): T

Sums up the elements of a numeric Vec

Sums up the elements of a numeric Vec

NOTE: scalac only specialized correctly if using the method in VecImpl referring to this.filterFoldLeft boxes

Attributes

def tail(n: Int): Vec[T]

Return last n elements

Return last n elements

Attributes

n

Number of elements to access

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)

Attributes

locs

Location of elements to take

def take(locs: Int*): Vec[T]
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)

Attributes

rng

evaluates to IRange

def takeLeft(i: Int): Vec[T]

Returns a Vec with the first i elements

Returns a Vec with the first i elements

Attributes

def takeRight(i: Int): Vec[T]

Returns a Vec with the last i elements

Returns a Vec with the last i elements

Attributes

def toArray: Array[T]

Returns an array containing the elements of this Vec in contiguous order

Returns an array containing the elements of this Vec in contiguous order

May or may not return the backing array, therefore mutations to the returned array may or may not are visible to this Vec

If needsCopy is false then it returns the backing array If needsCopy is true then the backing array is not contiguous

Attributes

def toSeq: IndexedSeq[T]

Converts Vec to an indexed sequence (default implementation is immutable.Vector)

Converts Vec to an indexed sequence (default implementation is immutable.Vector)

Attributes

override def toString: String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns:

a string representation of the object.

Definition Classes
Any
def unary_-(implicit num: Numeric[T]): Vec[T]

Additive inverse of Vec with numeric elements

Additive inverse of Vec with numeric elements

Attributes

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

Attributes

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

Attributes

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

Attributes

def updated(offset: Int, value: T): Vec[T]

Returns a new Vec with the value at offset set to `value

Returns a new Vec with the value at offset set to `value

Copies before mutating.

Attributes

def updated(offset: Array[Int], value: T): Vec[T]

Returns a new Vec with the value at offset set to `value

Returns a new Vec with the value at offset set to `value

Copies before mutating. Ignores invalid offsets in the array

Attributes

def view(offsets: Array[Int]): Vec[T]

Creates a view into original vector at arbitrary indexes. Data is not copied.

Creates a view into original vector at arbitrary indexes. Data is not copied.

Attributes

offsets1

indexes into the original array

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)

Attributes

pred

Predicate vector: Vec[Boolean]

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)

Attributes

pred

Predicate vector: Vec[Boolean]

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.

Attributes

locs

Location of elements not to take

def zipMap[B : ScalarTag, C : ScalarTag](other: Vec[B])(f: (T, B) => C): Vec[C]

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.

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.

Attributes

B

Parameter of other Vec

C

Result of function

f

Function (A, B) => C

other

Vec[B]

def zipMapIdx[C : ScalarTag](f: (T, Int) => C): Vec[C]

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.

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.

Attributes

B

Parameter of other Vec

C

Result of function

f

Function (A, B) => C

other

Vec[B]

Inherited methods

def %[B, That](other: B)(implicit op: BinOp[Mod, Vec[T], B, That]): That

Integer modulus of division

Integer modulus of division

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance (divisor)

Inherited from:
NumericOps
def %=[B](other: B)(implicit op: BinOpInPlace[Mod, Vec[T], B]): Unit

Attributes

Inherited from:
NumericOps
def &[B, That](other: B)(implicit op: BinOp[BitAnd, Vec[T], B, That]): That

Bit-wise AND

Bit-wise AND

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def &&[B, That](other: B)(implicit op: BinOp[AndOp, Vec[T], B, That]): That

Logical AND

Logical AND

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def *[B, That](other: B)(implicit op: BinOp[Multiply, Vec[T], B, That]): That

Multiplication

Multiplication

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def **[B, That](other: B)(implicit op: BinOp[Power, Vec[T], B, That]): That

Exponentiation

Exponentiation

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance (exponent)

Inherited from:
NumericOps
def **=[B](other: B)(implicit op: BinOpInPlace[Power, Vec[T], B]): Unit

Attributes

Inherited from:
NumericOps
def *=[B](other: B)(implicit op: BinOpInPlace[Multiply, Vec[T], B]): Unit

Attributes

Inherited from:
NumericOps
def +[B, That](other: B)(implicit op: BinOp[Add, Vec[T], B, That]): That

Addition

Addition

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def +=[B](other: B)(implicit op: BinOpInPlace[Add, Vec[T], B]): Unit

Attributes

Inherited from:
NumericOps
def -[B, That](other: B)(implicit op: BinOp[Subtract, Vec[T], B, That]): That

Subtraction

Subtraction

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def -=[B](other: B)(implicit op: BinOpInPlace[Subtract, Vec[T], B]): Unit

Attributes

Inherited from:
NumericOps
def /[B, That](other: B)(implicit op: BinOp[Divide, Vec[T], B, That]): That

Division

Division

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance (divisor)

Inherited from:
NumericOps
def /=[B](other: B)(implicit op: BinOpInPlace[Divide, Vec[T], B]): Unit

Attributes

Inherited from:
NumericOps
def <[B, That](other: B)(implicit op: BinOp[LtOp, Vec[T], B, That]): That

Less-than comparison operator

Less-than comparison operator

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def <<[B, That](other: B)(implicit op: BinOp[BitShl, Vec[T], B, That]): That

Bit-shift left

Bit-shift left

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
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

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def <>[B, That](other: B)(implicit op: BinOp[NeqOp, Vec[T], B, That]): That

Element-wise inequality operator

Element-wise inequality operator

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def =?[B, That](other: B)(implicit op: BinOp[EqOp, Vec[T], B, That]): That

Element-wise equality operator

Element-wise equality operator

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def >[B, That](other: B)(implicit op: BinOp[GtOp, Vec[T], B, That]): That

Greater-than comparison operator

Greater-than comparison operator

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
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

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def >>[B, That](other: B)(implicit op: BinOp[BitShr, Vec[T], B, That]): That

Bit-shift right (arithmetic)

Bit-shift right (arithmetic)

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def >>>[B, That](other: B)(implicit op: BinOp[BitUShr, Vec[T], B, That]): That

Bit-shift right (logical)

Bit-shift right (logical)

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def ^[B, That](other: B)(implicit op: BinOp[BitXor, Vec[T], B, That]): That

Bit-wise EXCLUSIVE OR

Bit-wise EXCLUSIVE OR

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def dot[B, That](other: B)(implicit op: BinOp[InnerProd, Vec[T], B, That]): That

Dot (inner) product

Dot (inner) product

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def outer[B, That](other: B)(implicit op: BinOp[OuterProd, Vec[T], B, That]): That

Outer product

Outer product

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def xor[B, That](other: B)(implicit op: BinOp[XorOp, Vec[T], B, That]): That

Logical EXCLUSIVE OR

Logical EXCLUSIVE OR

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def |[B, That](other: B)(implicit op: BinOp[BitOr, Vec[T], B, That]): That

Bit-wise OR

Bit-wise OR

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps
def ||[B, That](other: B)(implicit op: BinOp[OrOp, Vec[T], B, That]): That

Logical OR

Logical OR

Attributes

B

type of the other operand

That

result type of operation

op

implicit evidence for operation between this and other

other

other operand instance

Inherited from:
NumericOps

Concrete fields

val scalarTag: ScalarTag[T]

A ScalarTag in the type of the elements of the Vec

A ScalarTag in the type of the elements of the Vec

Attributes

Generated with