fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-12 22:41:27 +00:00
Code Issues Projects Releases Wiki Activity

Use insertion sort for references in Array#sort (#90)

Browse Source 
This fixes that Weak Heap Sort isn't stable and thus might swap equal values, which sometimes results in not deep equal arrays of strings, for example. Insertion sort is stable, so it is used for references instead.
This commit is contained in:
Max Graey
2018-05-02 20:33:17 +03:00
committed by Daniel Wirtz
parent 8b5d1d7f74
commit 99bde3a5fa
5 changed files with 240 additions and 1901 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
std/assembly/array.ts
View File

@ -314,9 +314,15 @@ export class Array<T> {
}
return this;
}
return changetype<this>(length < 256
? insertionSort<T,T>(this, comparator)
: weakHeapSort<T,T>(this, comparator)
);
if (isReference<T>()) {
// TODO replace this to stable sort when it implemented
return changetype<this>(insertionSort<T>(this, comparator));
} else {
return changetype<this>(length < 256
? insertionSort<T>(this, comparator)
: weakHeapSort<T>(this, comparator)
);
}
}
}

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

@ -14,25 +14,25 @@ export function defaultComparator<T>(): (a: T, b: T) => i32 {
}
/** Sorts an Array with the 'Insertion Sort' algorithm. */
export function insertionSort<T,V>(arr: Array<T>, comparator: (a: V, b: V) => i32): Array<T> {
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,V>(buffer, i); // a = arr[i]
let a = loadUnsafe<T,T>(buffer, i); // a = arr[i]
let j = i - 1;
while (j >= 0) {
let b = loadUnsafe<T,V>(buffer, j); // b = arr[j]
let b = loadUnsafe<T,T>(buffer, j); // b = arr[j]
if (comparator(a, b) < 0) {
storeUnsafe<T,V>(buffer, j-- + 1, b); // arr[j + 1] = b
storeUnsafe<T,T>(buffer, j-- + 1, b); // arr[j + 1] = b
} else break;
}
storeUnsafe<T,V>(buffer, j + 1, a); // arr[j + 1] = a
storeUnsafe<T,T>(buffer, j + 1, a); // arr[j + 1] = a
}
return arr;
}
/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
export function weakHeapSort<T,V>(arr: Array<T>, comparator: (a: V, b: V) => i32): Array<T> {
const shift32 = alignof<i32>();
export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
const shift32 = alignof<u32>();
var length = arr.length;
var bitsetSize = (length + 31) >> 5 << shift32;
@ -44,40 +44,40 @@ export function weakHeapSort<T,V>(arr: Array<T>, comparator: (a: V, b: V) => i32
var buffer = arr.buffer_;
for (let i = length - 1; i > 0; i--) {
let j = i;
while ((j & 1) == (load<i32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
while ((j & 1) == (load<u32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
let p = j >> 1;
let a = loadUnsafe<T,V>(buffer, p); // a = arr[p]
let b = loadUnsafe<T,V>(buffer, i); // b = arr[i]
let a = loadUnsafe<T,T>(buffer, p); // a = arr[p]
let b = loadUnsafe<T,T>(buffer, i); // b = arr[i]
if (comparator(a, b) < 0) {
store<i32>(
store<u32>(
bitset + (i >> 5 << shift32),
load<i32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
load<u32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
);
storeUnsafe<T,V>(buffer, i, a); // arr[i] = a
storeUnsafe<T,V>(buffer, p, b); // arr[p] = b
storeUnsafe<T,T>(buffer, i, a); // arr[i] = a
storeUnsafe<T,T>(buffer, p, b); // arr[p] = b
}
}
for (let i = length - 1; i >= 2; i--) {
let a = loadUnsafe<T,V>(buffer, 0); // a = arr[0]
storeUnsafe<T,V>(buffer, 0, loadUnsafe<T,V>(buffer, i)); // arr[0] = arr[i]
storeUnsafe<T,V>(buffer, i, a); // arr[i] = a
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 x = 1, y: i32;
while ((y = (x << 1) + ((load<i32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
while ((y = (x << 1) + ((load<u32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
while (x > 0) {
a = loadUnsafe<T,V>(buffer, 0); // a = arr[0]
let b = loadUnsafe<T,V>(buffer, x); // b = arr[x]
a = loadUnsafe<T,T>(buffer, 0); // a = arr[0]
let b = loadUnsafe<T,T>(buffer, x); // b = arr[x]
if (comparator(a, b) < 0) {
store<i32>(
store<u32>(
bitset + (x >> 5 << shift32),
load<i32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
load<u32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
);
storeUnsafe<T,V>(buffer, x, a); // arr[x] = a
storeUnsafe<T,V>(buffer, 0, b); // arr[0] = b
storeUnsafe<T,T>(buffer, x, a); // arr[x] = a
storeUnsafe<T,T>(buffer, 0, b); // arr[0] = b
}
x >>= 1;
}
@ -85,8 +85,8 @@ export function weakHeapSort<T,V>(arr: Array<T>, comparator: (a: V, b: V) => i32
free_memory(bitset);
var t = loadUnsafe<T,V>(buffer, 1); // t = arr[1]
storeUnsafe<T,V>(buffer, 1, loadUnsafe<T,V>(buffer, 0)); // arr[1] = arr[0]
storeUnsafe<T,V>(buffer, 0, t); // arr[0] = t
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;
}