SortArray
A module for Array sort relevant utiliites
strictlySortedLengthU
let strictlySortedLengthU: (array<'a>, ('a, 'a) => bool) => int
strictlySortedLength
let strictlySortedLength: (array<'a>, ('a, 'a) => bool) => int
strictlySortedLenght(xs, cmp);
return +n
means increasing order -n
means negative order
Examples
RESCRIPTBelt.SortArray.strictlySortedLength([1, 2, 3, 4, 3], (x, y) => x < y) == 4
Belt.SortArray.strictlySortedLength([], (x, y) => x < y) == 0
Belt.SortArray.strictlySortedLength([1], (x, y) => x < y) == 1
Belt.SortArray.strictlySortedLength([4, 3, 2, 1], (x, y) => x < y) == -4
isSortedU
let isSortedU: (array<'a>, ('a, 'a) => int) => bool
isSorted
let isSorted: (array<'a>, ('a, 'a) => int) => bool
isSorted(arr, cmp)
: Returns true if array is increasingly sorted (equal is okay)
stableSortInPlaceByU
let stableSortInPlaceByU: (array<'a>, ('a, 'a) => int) => unit
stableSortInPlaceBy
let stableSortInPlaceBy: (array<'a>, ('a, 'a) => int) => unit
stableSortByU
let stableSortByU: (array<'a>, ('a, 'a) => int) => array<'a>
stableSortBy
let stableSortBy: (array<'a>, ('a, 'a) => int) => array<'a>
stableSortBy(xs, cmp)
: Returns a fresh array Sort xs
in place using
comparator cmp
, the stable means if the elements are equal, their order will
be preserved
binarySearchByU
let binarySearchByU: (array<'a>, 'a, ('a, 'a) => int) => int
binarySearchBy
let binarySearchBy: (array<'a>, 'a, ('a, 'a) => int) => int
If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
If value is not found and value is greater
than all elements in array, the negative number returned is the bitwise
complement of (the index of the last element plus 1)for example, if key
is
smaller than all elements return -1
since lnot(-1) == 0
if key
is larger
than all elements return lnot(-1) == 0
since lnot(- (len + 1)) == len
Examples
RESCRIPTBelt.SortArray.binarySearchBy([1, 2, 3, 4, 33, 35, 36], 33, Pervasives.compare) == 4
lnot(Belt.SortArray.binarySearchBy([1, 3, 5, 7], 4, Pervasives.compare)) == 2
unionU
let unionU: (
array<'a>,
int,
int,
array<'a>,
int,
int,
array<'a>,
int,
('a, 'a) => int,
) => int
union
let union: (
array<'a>,
int,
int,
array<'a>,
int,
int,
array<'a>,
int,
('a, 'a) => int,
) => int
union src src1ofs src1len src2 src2ofs src2len dst dstofs cmp
assume src
and
src2
is strictly sorted. for equivalent elements, it is picked from src
also assume that dst
is large enough to store all elements
intersectU
let intersectU: (
array<'a>,
int,
int,
array<'a>,
int,
int,
array<'a>,
int,
('a, 'a) => int,
) => int
intersect
let intersect: (
array<'a>,
int,
int,
array<'a>,
int,
int,
array<'a>,
int,
('a, 'a) => int,
) => int
union src src1ofs src1len src2 src2ofs src2len dst dstofs cmp
return the offset
in the output array
diffU
let diffU: (
array<'a>,
int,
int,
array<'a>,
int,
int,
array<'a>,
int,
('a, 'a) => int,
) => int
diff
let diff: (
array<'a>,
int,
int,
array<'a>,
int,
int,
array<'a>,
int,
('a, 'a) => int,
) => int