warpo 3.2.0 → 3.2.1

package/assemblyscript/std/assembly/util/sort.ts

@@ -0,0 +1,282 @@
+import { compareImpl } from "./string";
+
+type Comparator<T> = (a: T, b: T) => i32;
+
+// @ts-ignore: decorator
+@lazy @inline const EMPTY = u32.MAX_VALUE;
+// @ts-ignore: decorator
+@inline const INSERTION_SORT_THRESHOLD = 48;
+// @ts-ignore: decorator
+@inline const MIN_RUN_LENGTH = 32;
+
+// @ts-ignore: decorator
+@inline
+function log2u(n: u32): u32 {
+  return 31 - clz(n);
+}
+
+// @ts-ignore: decorator
+@inline
+export function COMPARATOR<T>(): Comparator<T> {
+  if (isInteger<T>()) {
+    if (isSigned<T>() && sizeof<T>() <= 4) {
+      return (a, b) => i32(a) - i32(b);
+    } else {
+      return (a, b) => i32(a > b) - i32(a < b);
+    }
+  } else if (isFloat<T>()) {
+    if (sizeof<T>() == 4) {
+      return (a, b) => {
+        let ia = reinterpret<i32>(f32(a));
+        let ib = reinterpret<i32>(f32(b));
+        ia ^= (ia >> 31) >>> 1;
+        ib ^= (ib >> 31) >>> 1;
+        return i32(ia > ib) - i32(ia < ib);
+      };
+    } else {
+      return (a, b) => {
+        let ia = reinterpret<i64>(f64(a));
+        let ib = reinterpret<i64>(f64(b));
+        ia ^= (ia >> 63) >>> 1;
+        ib ^= (ib >> 63) >>> 1;
+        return i32(ia > ib) - i32(ia < ib);
+      };
+    }
+  } else if (isString<T>()) {
+    return (a, b) => {
+      if (changetype<usize>(a) == changetype<usize>(b) || changetype<usize>(a) == 0 || changetype<usize>(b) == 0)
+        return 0;
+      let aLen = changetype<string>(a).length;
+      let bLen = changetype<string>(b).length;
+      if (!(aLen | bLen)) return 0;
+      if (!aLen) return -1;
+      if (!bLen) return 1;
+      let res = compareImpl(changetype<string>(a), 0, changetype<string>(b), 0, <usize>min(aLen, bLen));
+      return res ? res : aLen - bLen;
+    };
+  } else {
+    return (a, b) => i32(a > b) - i32(a < b);
+  }
+}
+
+// Power Sort implementation (stable) from paper "Nearly-Optimal MergeSorts"
+// https://arxiv.org/pdf/1805.04154.pdf
+// This method usually outperform TimSort.
+// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt
+export function SORT<T>(ptr: usize, len: i32, comparator: Comparator<T>): void {
+  if (len <= INSERTION_SORT_THRESHOLD) {
+    if (len <= 1) return;
+    if (ASC_SHRINK_LEVEL < 1) {
+      switch (len) {
+        case 3: {
+          let a = load<T>(ptr, 0);
+          let b = load<T>(ptr, 1 << alignof<T>());
+          let c = comparator(a, b) > 0;
+          store<T>(ptr, select<T>(b, a, c), 0);
+          a = select<T>(a, b, c);
+          b = load<T>(ptr, 2 << alignof<T>());
+          c = comparator(a, b) > 0;
+          store<T>(ptr, select<T>(b, a, c), 1 << alignof<T>());
+          store<T>(ptr, select<T>(a, b, c), 2 << alignof<T>());
+        }
+        case 2: {
+          let a = load<T>(ptr, 0);
+          let b = load<T>(ptr, 1 << alignof<T>());
+          let c = comparator(a, b) > 0;
+          store<T>(ptr, select<T>(b, a, c), 0);
+          store<T>(ptr, select<T>(a, b, c), 1 << alignof<T>());
+          return;
+        }
+      }
+    }
+    insertionSort<T>(ptr, 0, len - 1, 0, comparator);
+    return;
+  }
+
+  let lgPlus2 = log2u(len) + 2;
+  let lgPlus2Size = lgPlus2 << alignof<u32>();
+  let leftRunStartBuf = __alloc(lgPlus2Size << 1);
+  let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;
+
+  for (let i: u32 = 0; i < lgPlus2; ++i) {
+    store<u32>(leftRunStartBuf + ((<usize>i) << alignof<u32>()), EMPTY);
+  }
+
+  let buffer = __alloc(len << alignof<T>());
+
+  let hi = len - 1;
+  let endA = extendRunRight<T>(ptr, 0, hi, comparator);
+  let lenA = endA + 1;
+
+  if (lenA < MIN_RUN_LENGTH) {
+    endA = min(hi, MIN_RUN_LENGTH - 1);
+    insertionSort<T>(ptr, 0, endA, lenA, comparator);
+  }
+
+  let top: u32 = 0,
+    startA = 0;
+  while (endA < hi) {
+    let startB = endA + 1;
+    let endB = extendRunRight<T>(ptr, startB, hi, comparator);
+    let lenB = endB - startB + 1;
+
+    if (lenB < MIN_RUN_LENGTH) {
+      endB = min(hi, startB + MIN_RUN_LENGTH - 1);
+      insertionSort<T>(ptr, startB, endB, lenB, comparator);
+    }
+
+    let k = nodePower(0, hi, startA, startB, endB);
+
+    for (let i = top; i > k; --i) {
+      let start = load<u32>(leftRunStartBuf + ((<usize>i) << alignof<u32>()));
+      if (start != EMPTY) {
+        mergeRuns<T>(
+          ptr,
+          start,
+          load<u32>(leftRunEndBuf + ((<usize>i) << alignof<u32>())) + 1,
+          endA,
+          buffer,
+          comparator
+        );
+        startA = start;
+        store<u32>(leftRunStartBuf + ((<usize>i) << alignof<u32>()), EMPTY);
+      }
+    }
+
+    store<u32>(leftRunStartBuf + ((<usize>k) << alignof<u32>()), startA);
+    store<u32>(leftRunEndBuf + ((<usize>k) << alignof<u32>()), endA);
+    startA = startB;
+    endA = endB;
+    top = k;
+  }
+
+  for (let i = top; i != 0; --i) {
+    let start = load<u32>(leftRunStartBuf + ((<usize>i) << alignof<u32>()));
+    if (start != EMPTY) {
+      mergeRuns<T>(ptr, start, load<u32>(leftRunEndBuf + ((<usize>i) << alignof<u32>())) + 1, hi, buffer, comparator);
+    }
+  }
+  // dealloc aux buffers
+  __free(buffer);
+  __free(leftRunStartBuf);
+}
+
+function insertionSort<T>(ptr: usize, left: i32, right: i32, presorted: i32, comparator: Comparator<T>): void {
+  if (ASC_SHRINK_LEVEL >= 1) {
+    // slightly improved original insertion sort
+    for (let i = left + presorted; i <= right; ++i) {
+      let j = i - 1;
+      let a = load<T>(ptr + ((<usize>i) << alignof<T>()));
+      while (j >= left) {
+        let b = load<T>(ptr + ((<usize>j) << alignof<T>()));
+        if (comparator(a, b) < 0) {
+          store<T>(ptr + ((<usize>j) << alignof<T>()), b, 1 << alignof<T>());
+          --j;
+        } else break;
+      }
+      store<T>(ptr + ((<usize>j) << alignof<T>()), a, 1 << alignof<T>());
+    }
+  } else {
+    // even-odd two-way insertion sort which allow increase minRunLen
+    let range = right - left + 1;
+    let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);
+    for (; i <= right; i += 2) {
+      let a = load<T>(ptr + ((<usize>i) << alignof<T>()), 0);
+      let b = load<T>(ptr + ((<usize>i) << alignof<T>()), 1 << alignof<T>());
+      let min = b,
+        max = a;
+      if (comparator(a, b) <= 0) {
+        ((min = a), (max = b));
+      }
+      let j = i - 1;
+      while (j >= left) {
+        a = load<T>(ptr + ((<usize>j) << alignof<T>()));
+        if (comparator(a, max) > 0) {
+          store<T>(ptr + ((<usize>j) << alignof<T>()), a, 2 << alignof<T>());
+          --j;
+        } else break;
+      }
+      store<T>(ptr + ((<usize>j) << alignof<T>()), max, 2 << alignof<T>());
+      while (j >= left) {
+        a = load<T>(ptr + ((<usize>j) << alignof<T>()));
+        if (comparator(a, min) > 0) {
+          store<T>(ptr + ((<usize>j) << alignof<T>()), a, 1 << alignof<T>());
+          --j;
+        } else break;
+      }
+      store<T>(ptr + ((<usize>j) << alignof<T>()), min, 1 << alignof<T>());
+    }
+  }
+}
+
+function nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {
+  let n: u64 = right - left + 1;
+  let s = startB - (left << 1);
+  let l = startA + s;
+  let r = endB + s + 1;
+  let a = ((<u64>l) << 30) / n;
+  let b = ((<u64>r) << 30) / n;
+  return clz(<u32>(a ^ b));
+}
+
+function extendRunRight<T>(ptr: usize, i: i32, right: i32, comparator: Comparator<T>): i32 {
+  if (i == right) return i;
+  let j = i;
+  if (comparator(load<T>(ptr + ((<usize>j) << alignof<T>())), load<T>(ptr + ((<usize>++j) << alignof<T>()))) > 0) {
+    while (
+      j < right &&
+      comparator(
+        load<T>(ptr + ((<usize>j) << alignof<T>()), 1 << alignof<T>()),
+        load<T>(ptr + ((<usize>j) << alignof<T>()))
+      ) >>> 31 // < 0
+    )
+      ++j;
+    // reverse
+    let k = j;
+    while (i < k) {
+      let tmp = load<T>(ptr + ((<usize>i) << alignof<T>()));
+      store<T>(ptr + ((<usize>i) << alignof<T>()), load<T>(ptr + ((<usize>k) << alignof<T>())));
+      ++i;
+      store<T>(ptr + ((<usize>k) << alignof<T>()), tmp);
+      --k;
+    }
+  } else {
+    while (
+      j < right &&
+      comparator(
+        load<T>(ptr + ((<usize>j) << alignof<T>()), 1 << alignof<T>()),
+        load<T>(ptr + ((<usize>j) << alignof<T>()))
+      ) >= 0
+    )
+      ++j;
+  }
+  return j;
+}
+
+// Merges arr[l..m - 1] and arr[m..r]
+function mergeRuns<T>(ptr: usize, l: i32, m: i32, r: i32, buffer: usize, comparator: Comparator<T>): void {
+  --m;
+  let i: i32,
+    j: i32,
+    t = r + m;
+  for (i = m + 1; i > l; --i) {
+    store<T>(buffer + ((<usize>(i - 1)) << alignof<T>()), load<T>(ptr + ((<usize>(i - 1)) << alignof<T>())));
+  }
+  for (j = m; j < r; ++j) {
+    store<T>(
+      buffer + ((<usize>(t - j)) << alignof<T>()),
+      load<T>(ptr + ((<usize>j) << alignof<T>()), 1 << alignof<T>())
+    );
+  }
+  for (let k = l; k <= r; ++k) {
+    let a = load<T>(buffer + ((<usize>j) << alignof<T>()));
+    let b = load<T>(buffer + ((<usize>i) << alignof<T>()));
+    if (comparator(a, b) < 0) {
+      store<T>(ptr + ((<usize>k) << alignof<T>()), a);
+      --j;
+    } else {
+      store<T>(ptr + ((<usize>k) << alignof<T>()), b);
+      ++i;
+    }
+  }
+}