package array
This package contains utilities for working with arrays that are specialized for numeric types.
- Alphabetic
- By Inheritance
- array
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- def argmax[T](arr: Array[T])(implicit arg0: ST[T], arg1: NUM[T]): Int
Return the integer offset of the maximum element, or -1 for an empty array
- def argmin[T](arr: Array[T])(implicit arg0: ST[T], arg1: NUM[T]): Int
Return the integer offset of the minimum element, or -1 for an empty array
- def argsort[T](vec: Vec[T])(implicit arg0: ST[T], arg1: ORD[T]): Array[Int]
- def argsort[T](arr: Array[T])(implicit arg0: ORD[T], st: ST[T]): Array[Int]
Stable indirect sort resulting in permutation of numbers [0, n), whose application on an array results in a sorted array.
Stable indirect sort resulting in permutation of numbers [0, n), whose application on an array results in a sorted array.
- arr
Array to sort
- def copySlice[T](from: Int, until: Int, source: Array[T])(implicit arg0: ST[T]): Array[T]
Copies a contiguous segment of the array into a new array.
Copies a contiguous segment of the array into a new array.
- from
start index, inclusive
- until
end index, exclusive
- source
source array to copy
- def empty[T](len: Int)(implicit arg0: ST[T]): Array[T]
Create a new initialized empty array
- def fill[T](arr: Array[T], v: T): Unit
Fill array with value
- def filter[T](f: (T) => Boolean)(arr: Array[T])(implicit arg0: ST[T]): Array[T]
Filter an array based on a predicate function, wherever that predicate is true
- def flatten[T](arrs: Seq[Array[T]])(implicit arg0: CLM[T]): Array[T]
Flatten a sequence of arrays into a single array
- def linspace(start: Double, stop: Double, num: Int = 50, endpoint: Boolean = true): Array[Double]
Derived from numpy 1.7
Derived from numpy 1.7
Return evenly spaced numbers over a specified interval.
Returns num evenly spaced samples, calculated over the interval [start, stop].
If start < stop, then the order of elements are decreasing.
The endpoint of the interval can optionally be excluded.
- def put[T](arr: Array[T], offsets: Array[Boolean], value: T): Array[T]
Put a value into array arr at particular offsets provided by a boolean array where its locations are true, so as to produce a new array.
- def put[T](arr: Array[T], offsets: Array[Int], value: T): Array[T]
Put a single value into array arr at particular offsets, so as to produce a new array.
- def putn[T](arr: Array[T], offsets: Array[Int], values: Array[T]): Array[T]
Put n values into array arr at particular offsets, where the values come from another array, so as to produce a new array.
- def randDouble(sz: Int, min: Double, until: Double): Array[Double]
Generate an array of random doubles on [min,until)
- def randDouble(sz: Int, min: Double, until: Double, rng: Generator): Array[Double]
Generate an array of random doubles on [min,until)
- def randDouble(sz: Int, n: Double): Array[Double]
Generate an array of random doubles on [0,n)
- def randDouble(sz: Int, n: Double, rng: Generator): Array[Double]
Generate an array of random doubles on [0,n)
- def randDouble(sz: Int): Array[Double]
Generate an array of random doubles on [0,1)
- def randDouble(sz: Int, rng: Generator): Array[Double]
Generate an array of random doubles on [0,1)
- def randDoublePos(sz: Int): Array[Double]
Generate an array of random positive doubles on (0, 1]
- def randDoublePos(sz: Int, rng: Generator): Array[Double]
Generate an array of random positive doubles on (0, 1]
- def randInt(sz: Int, from: Int, to: Int): Array[Int]
Generate an array of random integers in [from,to]
- def randInt(sz: Int, from: Int, to: Int, rng: Generator): Array[Int]
Generate an array of random integers in [from,to]
- def randInt(sz: Int): Array[Int]
Generate an array of random integers
- def randInt(sz: Int, rng: Generator): Array[Int]
Generate an array of random integers
- def randIntPos(sz: Int): Array[Int]
Generate an array of random positive integers
- def randIntPos(sz: Int, rng: Generator): Array[Int]
Generate an array of random positive integers
- def randLong(sz: Int, from: Long, to: Long): Array[Long]
Generate an array of a random long integers in [from,to]
- def randLong(sz: Int, from: Long, to: Long, rng: Generator): Array[Long]
Generate an array of a random long integers in [from,to]
- def randLong(sz: Int): Array[Long]
Generate an array of a random long integers
- def randLong(sz: Int, rng: Generator): Array[Long]
Generate an array of a random long integers
- def randLongPos(sz: Int): Array[Long]
Generate an array of random long positive integers
- def randLongPos(sz: Int, rng: Generator): Array[Long]
Generate an array of random long positive integers
- def randNormal(sz: Int): Array[Double]
Generate an array of random doubles which is normally distributed with a mean of zero and stdev of one.
- def randNormal(sz: Int, rng: Generator): Array[Double]
Generate an array of random doubles which is normally distributed with a mean of zero and stdev of one.
- def randNormal2(sz: Int, mu: Double, sigma: Double): Array[Double]
Generate an array of random doubles which is normally distributed with a mean of mu and stdev of sigma.
- def randNormal2(sz: Int, mu: Double, sigma: Double, rng: Generator): Array[Double]
Generate an array of random doubles which is normally distributed with a mean of mu and stdev of sigma.
- def range(from: Int, until: Int, step: Int = 1): Array[Int]
Create a new array consisting of a range of numbers from a lower bound up to, but not including, an upper bound, at a particular increment (default 1)
- def remove[T](arr: Array[T], locs: Array[Int])(implicit arg0: ST[T]): Array[T]
Remove values from array arr at particular offsets so as to produce a new array.
- def reverse[T](arr: Array[T])(implicit arg0: ST[T]): Array[T]
Reverse an array
- def send[T](arr: Array[T], offsets: Array[Int])(implicit arg0: ST[T]): Array[T]
Sends values from an array to particular offsets so as to produce a new array.
Sends values from an array to particular offsets so as to produce a new array. This does the inverse of 'take'; ie, each integer I at offset O in
offsets
works to "send" input[O] to output[I]. Eg, Array(2,0,1) permutes locations as follows:- 0 to 2
- 1 to 0
- 2 to 1
For example,
send(Array(5,6,7), Array(2,0,1)) == Array(6,7,5)
- def shuffle[T](arr: Array[T]): Array[T]
Return a uniform random permutation of the array
- def shuffle[T](arr: Array[T], rng: Generator): Array[T]
Return a uniform random permutation of the array
- def sort[T](arr: Array[T])(implicit arg0: ST[T], arg1: ORD[T]): Array[T]
Stable sort of array argument (not destructive), using radix sort implementation wherever possible.
Stable sort of array argument (not destructive), using radix sort implementation wherever possible.
- arr
Array to sort
- def sum[T](arr: Array[T], offsets: Array[Int], missing: => T)(implicit arg0: ST[T], arg1: NUM[T]): T
Compute the sum of the array at particular offets.
Compute the sum of the array at particular offets. If any of the offets is -1, the pass-by-name value 'missing' is used instead.
For example,
sum(Array(1,2,3,4), Array(0,2,), 0)
- def take[T](arr: Array[T], offsets: Vec[Int], missing: => T)(implicit arg0: ST[T]): Array[T]
Takes values from array arr at particular offsets so as to produce a new array.
Takes values from array arr at particular offsets so as to produce a new array. Offset -1 is mapped to by-name parameter
missing
.Note that each integer I at offset O in
offsets
works to "take" input[I] to output[O]. Eg, Array(2,0,1) permutes locations as follows:- 2 to 0
- 0 to 1
- 1 to 2
For example,
take(Array(5,6,7), Array(2,0,1), -1) == Array(7,5,6)
- def take[T](arr: Array[T], offsets: Array[Int], missing: => T)(implicit arg0: ST[T]): Array[T]
Takes values from array arr at particular offsets so as to produce a new array.
Takes values from array arr at particular offsets so as to produce a new array. Offset -1 is mapped to by-name parameter
missing
.Note that each integer I at offset O in
offsets
works to "take" input[I] to output[O]. Eg, Array(2,0,1) permutes locations as follows:- 2 to 0
- 0 to 1
- 1 to 2
For example,
take(Array(5,6,7), Array(2,0,1), -1) == Array(7,5,6)
- def tile[T](arr: Array[T], n: Int)(implicit arg0: ST[T]): Array[T]
Repeat elements of the array some number of times
- object InsertionSort
An implementation of insertion sort.
An implementation of insertion sort.
Works well for small arrays but due to quadratic complexity is not generally optimal.
- object MergeSort
In-place merge sort implementation.
In-place merge sort implementation. This sort is stable but does mutate the given array. It is an in-place sort but it does allocate a temporary array of the same size as the input. It uses InsertionSort for sorting very small arrays.
- object PermuteInsertionSort
An implementation of insertion sort.
An implementation of insertion sort.
Works well for small arrays but due to quadratic complexity is not generally optimal.
- object PermuteMergeSort
In-place merge sort implementation.
In-place merge sort implementation. This sort is stable but does mutate the given array. It is an in-place sort but it does allocate a temporary array of the same size as the input. It uses InsertionSort for sorting very small arrays.
- object Sorter