Skip to content

Commit 947cee0

Browse files
MaxGraeydcodeIO
MaxGraey
authored and
dcodeIO
committed
Implement <TypedArray>#sort and improve default comparator (#208)
1 parent 7965776 commit 947cee0

15 files changed

+10147
-2008
lines changed

‎std/assembly/array.ts

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@ export class Array<T> {
3232
);
3333
}
3434

35+
@inline
3536
get length(): i32 {
3637
return this.length_;
3738
}
@@ -324,12 +325,15 @@ export class Array<T> {
324325

325326
if (isReference<T>()) {
326327
// TODO replace this to faster stable sort (TimSort) when it implemented
327-
return changetype<this>(insertionSort<T>(this, comparator));
328+
insertionSort<T>(buffer, 0, length, comparator);
329+
return this;
328330
} else {
329-
return changetype<this>(length < 256
330-
? insertionSort<T>(this, comparator)
331-
: weakHeapSort<T>(this, comparator)
332-
);
331+
if (length < 256) {
332+
insertionSort<T>(buffer, 0, length, comparator);
333+
} else {
334+
weakHeapSort<T>(buffer, 0, length, comparator);
335+
}
336+
return this;
333337
}
334338
}
335339

‎std/assembly/internal/array.ts

Lines changed: 75 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1,84 +1,128 @@
1-
import { loadUnsafe, storeUnsafe } from "./arraybuffer";
2-
import { Array } from "../array";
1+
import {
2+
loadUnsafeWithOffset,
3+
storeUnsafeWithOffset
4+
} from "./arraybuffer";
35

6+
import {
7+
compareUnsafe,
8+
} from "./string";
9+
10+
/** Obtains the default comparator for the specified type. */
11+
@inline
412
export function defaultComparator<T>(): (a: T, b: T) => i32 {
5-
return function compare(a: T, b: T): i32 {
6-
return (<i32>(a > b) - <i32>(a < b));
7-
};
13+
if (isInteger<T>()) {
14+
if (isSigned<T>() && sizeof<T>() <= 4) {
15+
return (a: T, b: T): i32 => (<i32>(a - b));
16+
} else {
17+
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
18+
}
19+
} else if (isFloat<T>()) {
20+
if (sizeof<T>() == 4) {
21+
return (a: T, b: T): i32 => {
22+
var ia = reinterpret<i32>(a);
23+
var ib = reinterpret<i32>(b);
24+
ia ^= (ia >> 31) >>> 1;
25+
ib ^= (ib >> 31) >>> 1;
26+
return <i32>(ia > ib) - <i32>(ia < ib);
27+
};
28+
} else {
29+
return (a: T, b: T): i32 => {
30+
var ia = reinterpret<i64>(a);
31+
var ib = reinterpret<i64>(b);
32+
ia ^= (ia >> 63) >>> 1;
33+
ib ^= (ib >> 63) >>> 1;
34+
return <i32>(ia > ib) - <i32>(ia < ib);
35+
};
36+
}
37+
} else if (isString<T>()) {
38+
return (a: T, b: T): i32 => {
39+
var sa = <string>a, sb = <string>b;
40+
return compareUnsafe(sa, 0, sb, 0, min(sa.length, sb.length));
41+
};
42+
} else {
43+
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
44+
}
845
}
946

10-
export function insertionSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
11-
var buffer = arr.buffer_;
12-
for (let i: i32 = 0, length: i32 = arr.length; i < length; i++) {
13-
let a = loadUnsafe<T,T>(buffer, i); // a = arr[i]
47+
/** Sorts an Array with the 'Insertion Sort' algorithm. */
48+
export function insertionSort<T>(
49+
buffer: ArrayBuffer,
50+
byteOffset: i32,
51+
length: i32,
52+
comparator: (a: T, b: T) => i32
53+
): void {
54+
for (let i = 0; i < length; i++) {
55+
let a = loadUnsafeWithOffset<T,T>(buffer, i, byteOffset); // a = arr[i]
1456
let j = i - 1;
1557
while (j >= 0) {
16-
let b = loadUnsafe<T,T>(buffer, j); // b = arr[j]
58+
let b = loadUnsafeWithOffset<T,T>(buffer, j, byteOffset); // b = arr[j]
1759
if (comparator(a, b) < 0) {
18-
storeUnsafe<T,T>(buffer, j-- + 1, b); // arr[j + 1] = b
60+
storeUnsafeWithOffset<T,T>(buffer, j-- + 1, b, byteOffset); // arr[j + 1] = b
1961
} else break;
2062
}
21-
storeUnsafe<T,T>(buffer, j + 1, a); // arr[j + 1] = a
63+
storeUnsafeWithOffset<T,T>(buffer, j + 1, a, byteOffset); // arr[j + 1] = a
2264
}
23-
return arr;
2465
}
2566

26-
export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
67+
/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
68+
export function weakHeapSort<T>(
69+
buffer: ArrayBuffer,
70+
byteOffset: i32,
71+
length: i32,
72+
comparator: (a: T, b: T) => i32
73+
): void {
2774
const shift32 = alignof<u32>();
2875

29-
var length = arr.length;
3076
var bitsetSize = (length + 31) >> 5 << shift32;
3177
var bitset = memory.allocate(bitsetSize); // indexed in 32-bit chunks below
3278
memory.fill(bitset, 0, bitsetSize);
3379

3480
// see: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.1863&rep=rep1&type=pdf
3581

36-
var buffer = arr.buffer_;
3782
for (let i = length - 1; i > 0; i--) {
3883
let j = i;
3984
while ((j & 1) == (load<u32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
4085

4186
let p = j >> 1;
42-
let a = loadUnsafe<T,T>(buffer, p); // a = arr[p]
43-
let b = loadUnsafe<T,T>(buffer, i); // b = arr[i]
87+
let a = loadUnsafeWithOffset<T,T>(buffer, p, byteOffset); // a = arr[p]
88+
let b = loadUnsafeWithOffset<T,T>(buffer, i, byteOffset); // b = arr[i]
4489
if (comparator(a, b) < 0) {
4590
store<u32>(
4691
bitset + (i >> 5 << shift32),
4792
load<u32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
4893
);
49-
storeUnsafe<T,T>(buffer, i, a); // arr[i] = a
50-
storeUnsafe<T,T>(buffer, p, b); // arr[p] = b
94+
storeUnsafeWithOffset<T,T>(buffer, i, a, byteOffset); // arr[i] = a
95+
storeUnsafeWithOffset<T,T>(buffer, p, b, byteOffset); // arr[p] = b
5196
}
5297
}
5398

5499
for (let i = length - 1; i >= 2; i--) {
55-
let a = loadUnsafe<T,T>(buffer, 0); // a = arr[0]
56-
storeUnsafe<T,T>(buffer, 0, loadUnsafe<T,T>(buffer, i)); // arr[0] = arr[i]
57-
storeUnsafe<T,T>(buffer, i, a); // arr[i] = a
100+
let a = loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset);
101+
storeUnsafeWithOffset<T,T>(buffer, 0, loadUnsafeWithOffset<T,T>(buffer, i, byteOffset), byteOffset);
102+
storeUnsafeWithOffset<T,T>(buffer, i, a, byteOffset);
58103

59104
let x = 1, y: i32;
60105
while ((y = (x << 1) + ((load<u32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
61106

62107
while (x > 0) {
63-
a = loadUnsafe<T,T>(buffer, 0); // a = arr[0]
64-
let b = loadUnsafe<T,T>(buffer, x); // b = arr[x]
108+
a = loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset); // a = arr[0]
109+
let b = loadUnsafeWithOffset<T,T>(buffer, x, byteOffset); // b = arr[x]
65110

66111
if (comparator(a, b) < 0) {
67112
store<u32>(
68113
bitset + (x >> 5 << shift32),
69114
load<u32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
70115
);
71-
storeUnsafe<T,T>(buffer, x, a); // arr[x] = a
72-
storeUnsafe<T,T>(buffer, 0, b); // arr[0] = b
116+
storeUnsafeWithOffset<T,T>(buffer, x, a, byteOffset); // arr[x] = a
117+
storeUnsafeWithOffset<T,T>(buffer, 0, b, byteOffset); // arr[0] = b
73118
}
74119
x >>= 1;
75120
}
76121
}
77122

78123
memory.free(bitset);
79124

80-
var t = loadUnsafe<T,T>(buffer, 1); // t = arr[1]
81-
storeUnsafe<T,T>(buffer, 1, loadUnsafe<T,T>(buffer, 0)); // arr[1] = arr[0]
82-
storeUnsafe<T,T>(buffer, 0, t); // arr[0] = t
83-
return arr;
125+
var t = loadUnsafeWithOffset<T,T>(buffer, 1, byteOffset); // t = arr[1]
126+
storeUnsafeWithOffset<T,T>(buffer, 1, loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset), byteOffset);
127+
storeUnsafeWithOffset<T,T>(buffer, 0, t, byteOffset); // arr[0] = t
84128
}

‎std/assembly/internal/typedarray.ts

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,12 @@ import {
66
storeUnsafeWithOffset
77
} from "./arraybuffer";
88

9+
import {
10+
insertionSort,
11+
weakHeapSort,
12+
defaultComparator
13+
} from "./array";
14+
915
/** Typed array base class. Not a global object. */
1016
export abstract class TypedArray<T,V> {
1117

@@ -70,4 +76,33 @@ export abstract class TypedArray<T,V> {
7076
store<i32>(slice, end << alignof<T>(), offsetof<this>("byteLength"));
7177
return changetype<this>(slice);
7278
}
79+
80+
sort(comparator: (a: T, b: T) => i32 = defaultComparator<T>()): this {
81+
var byteOffset = this.byteOffset;
82+
var length = this.length;
83+
if (length <= 1) return this;
84+
var buffer = this.buffer;
85+
if (length == 2) {
86+
let a = loadUnsafeWithOffset<T,T>(buffer, 1, byteOffset);
87+
let b = loadUnsafeWithOffset<T,T>(buffer, 0, byteOffset);
88+
if (comparator(a, b) < 0) {
89+
storeUnsafeWithOffset<T,T>(buffer, 1, b, byteOffset);
90+
storeUnsafeWithOffset<T,T>(buffer, 0, a, byteOffset);
91+
}
92+
return this;
93+
}
94+
95+
if (isReference<T>()) {
96+
// TODO replace this to faster stable sort (TimSort) when it implemented
97+
insertionSort<T>(buffer, byteOffset, length, comparator);
98+
return this;
99+
} else {
100+
if (length < 256) {
101+
insertionSort<T>(buffer, byteOffset, length, comparator);
102+
} else {
103+
weakHeapSort<T>(buffer, byteOffset, length, comparator);
104+
}
105+
return this;
106+
}
107+
}
73108
}

0 commit comments

Comments
 (0)