SortArray

A module for Array sort relevant utiliites

binarySearchBy

RESCRIPT

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

RESCRIPT
Belt.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

binarySearchByU

Deprecated

Use binarySearchBy instead

RESCRIPT

let binarySearchByU: (array<'a>, 'a, ('a, 'a) => int) => int

diff

RESCRIPT

let diff: (
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  ('a, 'a) => int,
) => int

diffU

Deprecated

Use diff instead

RESCRIPT

let diffU: (
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  ('a, 'a) => int,
) => int

intersect

RESCRIPT

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

intersectU

Deprecated

Use intersect instead

RESCRIPT

let intersectU: (
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  ('a, 'a) => int,
) => int

isSorted

RESCRIPT

let isSorted: (array<'a>, ('a, 'a) => int) => bool

isSorted(arr, cmp): Returns true if array is increasingly sorted (equal is okay)

isSortedU

Deprecated

Use isSorted instead

RESCRIPT

let isSortedU: (array<'a>, ('a, 'a) => int) => bool

stableSortBy

RESCRIPT

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

stableSortByU

Deprecated

Use stableSortBy instead

RESCRIPT

let stableSortByU: (array<'a>, ('a, 'a) => int) => array<'a>

stableSortInPlaceBy

RESCRIPT

let stableSortInPlaceBy: (array<'a>, ('a, 'a) => int) => unit

stableSortInPlaceByU

Deprecated

Use stableSortInPlaceBy instead

RESCRIPT

let stableSortInPlaceByU: (array<'a>, ('a, 'a) => int) => unit

strictlySortedLength

RESCRIPT

let strictlySortedLength: (array<'a>, ('a, 'a) => bool) => int

strictlySortedLenght(xs, cmp); return +n means increasing order -n means negative order

Examples

RESCRIPT
Belt.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

strictlySortedLengthU

Deprecated

Use strictlySortedLength instead

RESCRIPT

let strictlySortedLengthU: (array<'a>, ('a, 'a) => bool) => int

union

RESCRIPT

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

unionU

Deprecated

Use union instead

RESCRIPT

let unionU: (
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  int,
  array<'a>,
  int,
  ('a, 'a) => int,
) => int