fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-23 03:31:44 +00:00
Code Issues Projects Releases Wiki Activity

Implement <TypedArray>#sort and improve default comparator (#208)

Browse Source
This commit is contained in:
Max Graey
2018-08-04 16:30:03 +03:00
committed by Daniel Wirtz
parent 7965776133
commit 947cee08c7
15 changed files with 9782 additions and 1643 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
std/assembly/internal/array.ts
View File

@ -1,75 +1,120 @@
import { loadUnsafe, storeUnsafe } from "./arraybuffer";
import { Array } from "../array";
import {
loadUnsafeWithOffset,
storeUnsafeWithOffset
} from "./arraybuffer";
import {
compareUnsafe,
} from "./string";
/** Obtains the default comparator for the specified type. */
@inline
export function defaultComparator<T>(): (a: T, b: T) => i32 {
return function compare(a: T, b: T): i32 {
return (<i32>(a > b) - <i32>(a < b));
};
if (isInteger<T>()) {
if (isSigned<T>() && sizeof<T>() <= 4) {
return (a: T, b: T): i32 => (<i32>(a - b));
} else {
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
}
} else if (isFloat<T>()) {
if (sizeof<T>() == 4) {
return (a: T, b: T): i32 => {
var ia = reinterpret<i32>(a);
var ib = reinterpret<i32>(b);
ia ^= (ia >> 31) >>> 1;
ib ^= (ib >> 31) >>> 1;
return <i32>(ia > ib) - <i32>(ia < ib);
};
} else {
return (a: T, b: T): i32 => {
var ia = reinterpret<i64>(a);
var ib = reinterpret<i64>(b);
ia ^= (ia >> 63) >>> 1;
ib ^= (ib >> 63) >>> 1;
return <i32>(ia > ib) - <i32>(ia < ib);
};
}
} else if (isString<T>()) {
return (a: T, b: T): i32 => {
var sa = <string>a, sb = <string>b;
return compareUnsafe(sa, 0, sb, 0, min(sa.length, sb.length));
};
} else {
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
}
}
export function insertionSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
var buffer = arr.buffer_;
for (let i: i32 = 0, length: i32 = arr.length; i < length; i++) {
let a = loadUnsafe<T,T>(buffer, i); // a = arr[i]
/** Sorts an Array with the 'Insertion Sort' algorithm. */
export function insertionSort<T>(
buffer: ArrayBuffer,
byteOffset: i32,
length: i32,
comparator: (a: T, b: T) => i32
): void {
for (let i = 0; i < length; i++) {
let a = loadUnsafeWithOffset<T,T>(buffer, i, byteOffset); // a = arr[i]
let j = i - 1;
while (j >= 0) {
let b = loadUnsafe<T,T>(buffer, j); // b = arr[j]
let b = loadUnsafeWithOffset<T,T>(buffer, j, byteOffset); // b = arr[j]
if (comparator(a, b) < 0) {
storeUnsafe<T,T>(buffer, j-- + 1, b); // arr[j + 1] = b
storeUnsafeWithOffset<T,T>(buffer, j-- + 1, b, byteOffset); // arr[j + 1] = b
} else break;
}
storeUnsafe<T,T>(buffer, j + 1, a); // arr[j + 1] = a
storeUnsafeWithOffset<T,T>(buffer, j + 1, a, byteOffset); // arr[j + 1] = a
}
return arr;
}
export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
export function weakHeapSort<T>(
buffer: ArrayBuffer,
byteOffset: i32,
length: i32,
comparator: (a: T, b: T) => i32
): void {
const shift32 = alignof<u32>();
var length = arr.length;
var bitsetSize = (length + 31) >> 5 << shift32;
var bitset = memory.allocate(bitsetSize); // indexed in 32-bit chunks below
memory.fill(bitset, 0, bitsetSize);
// see: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.1863&rep=rep1&type=pdf
var buffer = arr.buffer_;
for (let i = length - 1; i > 0; i--) {
let j = i;
while ((j & 1) == (load<u32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
let p = j >> 1;
let a = loadUnsafe<T,T>(buffer, p); // a = arr[p]
let b = loadUnsafe<T,T>(buffer, i); // b = arr[i]
let a = loadUnsafeWithOffset<T,T>(buffer, p, byteOffset); // a = arr[p]
let b = loadUnsafeWithOffset<T,T>(buffer, i, byteOffset); // b = arr[i]
if (comparator(a, b) < 0) {
store<u32>(
bitset + (i >> 5 << shift32),
load<u32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
);
storeUnsafe<T,T>(buffer, i, a); // arr[i] = a
storeUnsafe<T,T>(buffer, p, b); // arr[p] = b
storeUnsafeWithOffset<T,T>(buffer, i, a, byteOffset); // arr[i] = a
storeUnsafeWithOffset<T,T>(buffer, p, b, byteOffset); // arr[p] = b
}
}
for (let i = length - 1; i >= 2; i--) {
let a = loadUnsafe<T,T>(buffer, 0); // a = arr[0]
storeUnsafe<T,T>(buffer, 0, loadUnsafe<T,T>(buffer, i)); // arr[0] = arr[i]
storeUnsafe<T,T>(buffer, i, a); // arr[i] = a
let a = loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset);
storeUnsafeWithOffset<T,T>(buffer, 0, loadUnsafeWithOffset<T,T>(buffer, i, byteOffset), byteOffset);
storeUnsafeWithOffset<T,T>(buffer, i, a, byteOffset);
let x = 1, y: i32;
while ((y = (x << 1) + ((load<u32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
while (x > 0) {
a = loadUnsafe<T,T>(buffer, 0); // a = arr[0]
let b = loadUnsafe<T,T>(buffer, x); // b = arr[x]
a = loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset); // a = arr[0]
let b = loadUnsafeWithOffset<T,T>(buffer, x, byteOffset); // b = arr[x]
if (comparator(a, b) < 0) {
store<u32>(
bitset + (x >> 5 << shift32),
load<u32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
);
storeUnsafe<T,T>(buffer, x, a); // arr[x] = a
storeUnsafe<T,T>(buffer, 0, b); // arr[0] = b
storeUnsafeWithOffset<T,T>(buffer, x, a, byteOffset); // arr[x] = a
storeUnsafeWithOffset<T,T>(buffer, 0, b, byteOffset); // arr[0] = b
}
x >>= 1;
}
@ -77,8 +122,7 @@ export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32):
memory.free(bitset);
var t = loadUnsafe<T,T>(buffer, 1); // t = arr[1]
storeUnsafe<T,T>(buffer, 1, loadUnsafe<T,T>(buffer, 0)); // arr[1] = arr[0]
storeUnsafe<T,T>(buffer, 0, t); // arr[0] = t
return arr;
var t = loadUnsafeWithOffset<T,T>(buffer, 1, byteOffset); // t = arr[1]
storeUnsafeWithOffset<T,T>(buffer, 1, loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset), byteOffset);
storeUnsafeWithOffset<T,T>(buffer, 0, t, byteOffset); // arr[0] = t
}

35
std/assembly/internal/typedarray.ts
View File

@ -6,6 +6,12 @@ import {
storeUnsafeWithOffset
} from "./arraybuffer";
import {
insertionSort,
weakHeapSort,
defaultComparator
} from "./array";
/** Typed array base class. Not a global object. */
export abstract class TypedArray<T,V> {
@ -70,4 +76,33 @@ export abstract class TypedArray<T,V> {
store<i32>(slice, end << alignof<T>(), offsetof<this>("byteLength"));
return changetype<this>(slice);
}
sort(comparator: (a: T, b: T) => i32 = defaultComparator<T>()): this {
var byteOffset = this.byteOffset;
var length = this.length;
if (length <= 1) return this;
var buffer = this.buffer;
if (length == 2) {
let a = loadUnsafeWithOffset<T,T>(buffer, 1, byteOffset);
let b = loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset);
if (comparator(a, b) < 0) {
storeUnsafeWithOffset<T,T>(buffer, 1, b, byteOffset);
storeUnsafeWithOffset<T,T>(buffer, 0, a, byteOffset);
}
return this;
}
if (isReference<T>()) {
// TODO replace this to faster stable sort (TimSort) when it implemented
insertionSort<T>(buffer, byteOffset, length, comparator);
return this;
} else {
if (length < 256) {
insertionSort<T>(buffer, byteOffset, length, comparator);
} else {
weakHeapSort<T>(buffer, byteOffset, length, comparator);
}
return this;
}
}
}