VecDefault

Same as raw

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

Access a boxed element of a Vec[A] at a single location

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]

Return copy of backing array

Returns a Vec whose backing array has been copied

Counts the number of non-NA elements

Counts the number of non-NA elements satisfying the predicate

Counts the number of elements which equal a

Returns a Vec with the first i elements removed

Drop the elements of the Vec which are NA

Returns a Vec with the last i elements removed

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

Return true if there exists some element of the Vec which satisfies the predicate function

Fills NA values in vector with result of a function which acts on the index of the particular NA value found

Return Vec whose elements satisfy a predicate function

Return vec whose offets satisfy a predicate function

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

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

Return Vec of integer locations (offsets) which satisfy some predicate

Return first integer location which satisfies some predicate, or -1 if there is none

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

Maps a function over elements of the Vec and flattens the result.

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

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

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 the vec

Return true if there is an NA value in the Vec

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

Return first n elements

True if and only if number of elements is zero

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

The number of elements in the container F

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

Returns Vec whose locations corresponding to true entries in the boolean input mask vector are set to NA

Returns Vec whose locations are NA where the result of the provided function evaluates to true

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

Return the percentile of the values at a particular threshold, ignoring NA

Pretty-printer for Vec, which simply outputs the result of stringify.

Return a Vec of ranks corresponding to a Vec of numeric values.

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

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

Produce a Vec whose entries are the result of executing a function on a sliding window of the data.

Rounds elements in the vec (which must be numeric) to a significance level

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

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 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, and including, another offset. Data is not copied.

Yield a Vec whose elements have been sorted (in ascending order)

Split Vec into two Vecs at position i

Creates a string representation of 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

Return last n elements

Equivalent to slicing operation; e.g.

 val v = Vec(1,2,3)
 v.take(0,1) == v(0,1)

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)

Returns a Vec with the first i elements

Returns a Vec with the last i elements

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

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

Additive inverse of Vec with numeric elements

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

Copies before mutating.

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

Copies before mutating. Ignores invalid offsets in the array

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

Return Vec whose elements are selected via a Vec of booleans (where that Vec holds the value true)

The complement of the take operation; slice out elements NOT specified in list.

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.

Integer modulus of division

Bit-wise AND

Logical AND

Multiplication

Exponentiation

Addition

Subtraction

Division

Less-than comparison operator

Bit-shift left

Less-than-or-equal-to comparison operator

Element-wise inequality operator

Element-wise equality operator

Greater-than comparison operator

Greater-than-or-equal-to comparison operator

Bit-shift right (arithmetic)

Bit-shift right (logical)

Bit-wise EXCLUSIVE OR

Dot (inner) product

Outer product

Logical EXCLUSIVE OR

Bit-wise OR

Logical OR