fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-26 13:11:52 +00:00
Code Issues Projects Releases Wiki Activity

it's all broken

Browse Source
This commit is contained in:
dcode
2019-03-11 23:34:20 +01:00
parent d9a5681489
commit 146dfdbb4a
8 changed files with 210 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
std/assembly/internal/sort.ts
View File

@ -1,12 +1,3 @@
import {
LOAD,
STORE
} from "./arraybuffer";
import {
compareUnsafe
} from "./string";
/** Obtains the default comparator for the specified value type. */
@inline
export function COMPARATOR<T>(): (a: T, b: T) => i32 {
@ -42,7 +33,7 @@ export function COMPARATOR<T>(): (a: T, b: T) => i32 {
if (!alen && !blen) return 0;
if (!alen) return -1;
if (!blen) return 1;
return compareUnsafe(<string>a, 0, <string>b, 0, <usize>min(alen, blen));
return String.cmp(<string>a, 0, <string>b, 0, <usize>min(alen, blen));
};
} else {
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
@ -51,47 +42,44 @@ export function COMPARATOR<T>(): (a: T, b: T) => i32 {
@inline
export function SORT<T>(
buffer: ArrayBuffer,
byteOffset: i32,
dataStart: usize,
length: i32,
comparator: (a: T, b: T) => i32
): void {
if (isReference<T>()) {
// TODO replace this to faster stable sort (TimSort) when it implemented
insertionSort<T>(buffer, byteOffset, length, comparator);
insertionSort<T>(dataStart, length, comparator);
} else {
if (length < 256) {
insertionSort<T>(buffer, byteOffset, length, comparator);
insertionSort<T>(dataStart, length, comparator);
} else {
weakHeapSort<T>(buffer, byteOffset, length, comparator);
weakHeapSort<T>(dataStart, length, comparator);
}
}
}
/** Sorts an Array with the 'Insertion Sort' algorithm. */
function insertionSort<T>(
buffer: ArrayBuffer,
byteOffset: i32,
dataStart: usize,
length: i32,
comparator: (a: T, b: T) => i32
): void {
for (let i = 0; i < length; i++) {
let a = LOAD<T>(buffer, i, byteOffset); // a = arr[i]
let a: T = load<T>(dataStart + (<usize>i << alignof<T>())); // a = arr[i]
let j = i - 1;
while (j >= 0) {
let b = LOAD<T>(buffer, j, byteOffset); // b = arr[j]
let b: T = load<T>(dataStart + (<usize>j << alignof<T>())); // b = arr[j]
if (comparator(a, b) < 0) {
STORE<T>(buffer, j-- + 1, b, byteOffset); // arr[j + 1] = b
store<T>(dataStart + (<usize>(j-- + 1) << alignof<T>()), b); // arr[j + 1] = b
} else break;
}
STORE<T>(buffer, j + 1, a, byteOffset); // arr[j + 1] = a
store<T>(dataStart + (<usize>(j + 1) << alignof<T>()), a); // arr[j + 1] = a
}
}
/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
function weakHeapSort<T>(
buffer: ArrayBuffer,
byteOffset: i32,
dataStart: usize,
length: i32,
comparator: (a: T, b: T) => i32
): void {
@ -108,37 +96,37 @@ function weakHeapSort<T>(
while ((j & 1) == (load<u32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
let p = j >> 1;
let a = LOAD<T>(buffer, p, byteOffset); // a = arr[p]
let b = LOAD<T>(buffer, i, byteOffset); // b = arr[i]
let a: T = load<T>(dataStart + (<usize>p << alignof<T>())); // a = arr[p]
let b: T = load<T>(dataStart + (<usize>i << alignof<T>())); // b = arr[i]
if (comparator(a, b) < 0) {
store<u32>(
bitset + (i >> 5 << shift32),
load<u32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
);
STORE<T>(buffer, i, a, byteOffset); // arr[i] = a
STORE<T>(buffer, p, b, byteOffset); // arr[p] = b
store<T>(dataStart + (<usize>i << alignof<T>()), a); // arr[i] = a
store<T>(dataStart + (<usize>p << alignof<T>()), b); // arr[p] = b
}
}
for (let i = length - 1; i >= 2; i--) {
let a = LOAD<T>(buffer, 0, byteOffset);
STORE<T>(buffer, 0, LOAD<T>(buffer, i, byteOffset), byteOffset);
STORE<T>(buffer, i, a, byteOffset);
let a: T = load<T>(dataStart); // a = arr[0]
store<T>(dataStart, load<T>(dataStart + (<usize>i << alignof<T>()))); // arr[0] = arr[i]
store<T>(dataStart + (<usize>i << alignof<T>()), a); // arr[i] = a
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 = LOAD<T>(buffer, 0, byteOffset); // a = arr[0]
let b = LOAD<T>(buffer, x, byteOffset); // b = arr[x]
a = load<T>(dataStart); // a = arr[0]
let b: T = load<T>(dataStart + (<usize>x << alignof<T>())); // b = arr[x]
if (comparator(a, b) < 0) {
store<u32>(
bitset + (x >> 5 << shift32),
load<u32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
);
STORE<T>(buffer, x, a, byteOffset); // arr[x] = a
STORE<T>(buffer, 0, b, byteOffset); // arr[0] = b
store<T>(dataStart + (<usize>x << alignof<T>()), a); // arr[x] = a
store<T>(dataStart, b); // arr[0] = b
}
x >>= 1;
}
@ -146,7 +134,7 @@ function weakHeapSort<T>(
memory.free(bitset);
var t = LOAD<T>(buffer, 1, byteOffset); // t = arr[1]
STORE<T>(buffer, 1, LOAD<T>(buffer, 0, byteOffset), byteOffset);
STORE<T>(buffer, 0, t, byteOffset); // arr[0] = t
var t: T = load<T>(dataStart, sizeof<T>()); // t = arr[1]
store<T>(dataStart, load<T>(dataStart), sizeof<T>()); // arr[1] = arr[0]
store<T>(dataStart, t); // arr[0] = t
}

20
std/assembly/internal/string.ts
View File

@ -1,3 +1,13 @@
export function compareImpl(str1: String, index1: usize, str2: String, index2: usize, len: usize): i32 {
var result: i32 = 0;
var ptr1 = changetype<usize>(str1) + (index1 << 1);
var ptr2 = changetype<usize>(str2) + (index2 << 1);
while (len && !(result = <i32>load<u16>(ptr1) - <i32>load<u16>(ptr2))) {
--len, ptr1 += 2, ptr2 += 2;
}
return result;
}
import { MAX_SIZE_32 } from "./allocator";
import { String } from "../string";
@ -38,16 +48,6 @@ export function copyUnsafe(dest: String, destOffset: usize, src: String, srcOffs
);
}
export function compareUnsafe(str1: String, offset1: usize, str2: String, offset2: usize, len: usize): i32 {
var cmp: i32 = 0;
var ptr1 = changetype<usize>(str1) + (offset1 << 1);
var ptr2 = changetype<usize>(str2) + (offset2 << 1);
while (len && !(cmp = <i32>load<u16>(ptr1, HEADER_SIZE) - <i32>load<u16>(ptr2, HEADER_SIZE))) {
--len, ptr1 += 2, ptr2 += 2;
}
return cmp;
}
export function repeatUnsafe(dest: String, destOffset: usize, src: String, count: i32): void {
var length = src.length;
if (ASC_SHRINK_LEVEL > 1) {