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

Improve inlining where locals can be aliased; Add a crude mechanism for explicit unchecked array accesses

Browse Source 
The `unchecked` builtin should be handled with ultimate care and it would be a lot better if there'd be a mechanism doing this automatically.
This commit is contained in:
dcodeIO
2018-04-25 05:04:35 +02:00
parent 391db28fe2
commit 6d6d1dddcf
47 changed files with 5374 additions and 15672 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
std/assembly.d.ts vendored
View File

@ -231,6 +231,8 @@ declare function alignof<T>(): usize;
declare function offsetof<T>(fieldName?: string): usize;
/** Changes the type of any value of `usize` kind to another one of `usize` kind. Useful for casting class instances to their pointer values and vice-versa. Beware that this is unsafe.*/
declare function changetype<T>(value: any): T;
/** Explicitly requests no bounds checks on the provided expression. */
declare function unchecked<T>(value: T): T;
/** Tests if a 32-bit or 64-bit float is `NaN`. */
declare function isNaN<T = f32 | f64>(value: T): bool;
/** Tests if a 32-bit or 64-bit float is finite, that is not `NaN` or +/-`Infinity`. */

84
std/assembly/array.ts
View File

@ -21,8 +21,15 @@ export class Array<T> {
constructor(length: i32 = 0) {
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
this.buffer_ = allocUnsafe(length << alignof<T>());
var byteLength = length << alignof<T>();
var buffer = allocUnsafe(byteLength);
this.buffer_ = buffer;
this.length_ = length;
set_memory(
changetype<usize>(buffer) + HEADER_SIZE_AB,
0,
<usize>byteLength
);
}
get length(): i32 {
@ -44,7 +51,7 @@ export class Array<T> {
every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
if (!callbackfn(loadUnsafe<T>(buffer, index), index, this)) return false;
if (!callbackfn(loadUnsafe<T,T>(buffer, index), index, this)) return false;
}
return true;
}
@ -52,7 +59,7 @@ export class Array<T> {
findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
if (predicate(loadUnsafe<T>(buffer, index), index, this)) return index;
if (predicate(loadUnsafe<T,T>(buffer, index), index, this)) return index;
}
return -1;
}
@ -61,15 +68,13 @@ export class Array<T> {
private __get(index: i32): T {
var buffer = this.buffer_;
return <u32>index < <u32>(buffer.byteLength >>> alignof<T>())
? load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE_AB)
// ^= loadUnsafe<T>(buffer, index)
? loadUnsafe<T,T>(buffer, index)
: <T>unreachable();
// FIXME: using a plain if-else here (as below) results in n-body being about 25% slower?
// if (<u32>index < <u32>(buffer.byteLength >>> alignof<T>())) {
// return load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE_AB);
// } else {
// throw new Error("Index out of bounds");
// }
}
@operator("{}")
private __unchecked_get(index: i32): T {
return loadUnsafe<T,T>(this.buffer_, index);
}
@operator("[]=")
@ -83,8 +88,12 @@ export class Array<T> {
this.buffer_ = buffer;
this.length_ = index + 1;
}
store<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), value, HEADER_SIZE_AB);
// ^= storeUnsafe<T>(buffer, index, value)
storeUnsafe<T,T>(buffer, index, value);
}
@operator("{}=")
private __unchecked_set(index: i32, value: T): void {
storeUnsafe<T,T>(this.buffer_, index, value);
}
includes(searchElement: T, fromIndex: i32 = 0): bool {
@ -93,7 +102,7 @@ export class Array<T> {
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
var buffer = this.buffer_;
while (fromIndex < length) {
if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return true;
if (loadUnsafe<T,T>(buffer, fromIndex) == searchElement) return true;
++fromIndex;
}
return false;
@ -105,7 +114,7 @@ export class Array<T> {
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
var buffer = this.buffer_;
while (fromIndex < length) {
if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return fromIndex;
if (loadUnsafe<T,T>(buffer, fromIndex) == searchElement) return fromIndex;
++fromIndex;
}
return -1;
@ -118,7 +127,7 @@ export class Array<T> {
else if (fromIndex >= length) fromIndex = length - 1;
var buffer = this.buffer_;
while (fromIndex >= 0) { // ^
if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return fromIndex;
if (loadUnsafe<T,T>(buffer, fromIndex) == searchElement) return fromIndex;
--fromIndex;
}
return -1;
@ -136,14 +145,14 @@ export class Array<T> {
this.buffer_ = buffer;
}
this.length_ = newLength;
storeUnsafe<T>(buffer, length, element);
storeUnsafe<T,T>(buffer, length, element);
return newLength;
}
pop(): T {
var length = this.length_;
if (length < 1) throw new RangeError("Array is empty");
var element = loadUnsafe<T>(this.buffer_, --length);
var element = loadUnsafe<T,T>(this.buffer_, --length);
this.length_ = length;
return element;
}
@ -151,7 +160,7 @@ export class Array<T> {
forEach(callbackfn: (value: T, index: i32, array: Array<T>) => void): void {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
callbackfn(loadUnsafe<T>(buffer, index), index, this);
callbackfn(loadUnsafe<T,T>(buffer, index), index, this);
}
}
@ -161,7 +170,7 @@ export class Array<T> {
var result = new Array<U>(length);
var resultBuffer = result.buffer_;
for (let index = 0; index < length && index < this.length_; ++index) {
storeUnsafe<U>(resultBuffer, index, callbackfn(loadUnsafe<T>(buffer, index), index, this));
storeUnsafe<U,U>(resultBuffer, index, callbackfn(loadUnsafe<T,T>(buffer, index), index, this));
}
return result;
}
@ -171,7 +180,7 @@ export class Array<T> {
var length = this.length_;
var result = new Array<T>();
for (let index = 0; index < length && index < this.length_; ++index) {
let value = loadUnsafe<T>(buffer, index);
let value = loadUnsafe<T,T>(buffer, index);
if (callbackfn(value, index, this)) result.push(value);
}
return result;
@ -184,7 +193,7 @@ export class Array<T> {
var accum = initialValue;
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
accum = callbackfn(accum, loadUnsafe<T>(buffer, index), index, this);
accum = callbackfn(accum, loadUnsafe<T,T>(buffer, index), index, this);
}
return accum;
}
@ -196,7 +205,7 @@ export class Array<T> {
var accum = initialValue;
var buffer = this.buffer_;
for (let index: i32 = this.length_ - 1; index >= 0; --index) {
accum = callbackfn(accum, loadUnsafe<T>(buffer, index), index, this);
accum = callbackfn(accum, loadUnsafe<T,T>(buffer, index), index, this);
}
return accum;
}
@ -205,14 +214,14 @@ export class Array<T> {
var length = this.length_;
if (length < 1) throw new RangeError("Array is empty");
var buffer = this.buffer_;
var element = loadUnsafe<T>(buffer, 0);
var element = loadUnsafe<T,T>(buffer, 0);
var lastIndex = length - 1;
move_memory(
changetype<usize>(buffer) + HEADER_SIZE_AB,
changetype<usize>(buffer) + HEADER_SIZE_AB + sizeof<T>(),
<usize>lastIndex << alignof<T>()
);
storeUnsafe<T>(buffer, lastIndex, isReference<T>() ? null : <T>0);
storeUnsafe<T,T>(buffer, lastIndex, <T>null);
this.length_ = lastIndex;
return element;
}
@ -220,7 +229,7 @@ export class Array<T> {
some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
if (callbackfn(loadUnsafe<T>(buffer, index), index, this)) return true;
if (callbackfn(loadUnsafe<T,T>(buffer, index), index, this)) return true;
}
return false;
}
@ -242,7 +251,7 @@ export class Array<T> {
changetype<usize>(buffer) + HEADER_SIZE_AB,
<usize>(capacity - 1) << alignof<T>()
);
storeUnsafe<T>(buffer, 0, element);
storeUnsafe<T,T>(buffer, 0, element);
this.length_ = newLength;
return newLength;
}
@ -285,9 +294,9 @@ export class Array<T> {
reverse(): Array<T> {
var buffer = this.buffer_;
for (let front = 0, back = this.length_ - 1; front < back; ++front, --back) {
let temp = loadUnsafe<T>(buffer, front);
storeUnsafe<T>(buffer, front, loadUnsafe<T>(buffer, back));
storeUnsafe<T>(buffer, back, temp);
let temp = loadUnsafe<T,T>(buffer, front);
storeUnsafe<T,T>(buffer, front, loadUnsafe<T,T>(buffer, back));
storeUnsafe<T,T>(buffer, back, temp);
}
return this;
}
@ -297,16 +306,17 @@ export class Array<T> {
if (length <= 1) return this;
var buffer = this.buffer_;
if (length == 2) {
let a = loadUnsafe<T>(buffer, 1); // a = arr[1]
let b = loadUnsafe<T>(buffer, 0); // b = arr[0]
let a = loadUnsafe<T,T>(buffer, 1); // a = arr[1]
let b = loadUnsafe<T,T>(buffer, 0); // b = arr[0]
if (comparator(a, b) < 0) {
storeUnsafe<T>(buffer, 1, b); // arr[1] = b;
storeUnsafe<T>(buffer, 0, a); // arr[0] = a;
storeUnsafe<T,T>(buffer, 1, b); // arr[1] = b;
storeUnsafe<T,T>(buffer, 0, a); // arr[0] = a;
}
return this;
}
return length < 256
? insertionSort<T>(this, comparator)
: weakHeapSort<T>(this, comparator);
return changetype<this>(length < 256
? insertionSort<T,T>(this, comparator)
: weakHeapSort<T,T>(this, comparator)
);
}
}

9
std/assembly/arraybuffer.ts
View File

@ -28,12 +28,3 @@ export class ArrayBuffer {
return buffer;
}
}
export declare interface FastArray<T> {}
export declare interface ArrayBufferView<T> {
readonly buffer: ArrayBuffer;
readonly byteOffset: i32;
readonly byteLength: i32;
readonly length: i32;
}

2
std/assembly/builtins.ts
View File

@ -83,6 +83,8 @@ export declare function abort(
columnNumber?: u32
): void;
export declare function unchecked<T>(expr: T): T;
export declare function i8(value: void): i8;
export namespace i8 {
export const MIN_VALUE: i8 = -128;

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

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

12
std/assembly/internal/arraybuffer.ts
View File

@ -60,21 +60,21 @@ export function reallocUnsafe(buffer: ArrayBuffer, newByteLength: i32): ArrayBuf
}
@inline
export function loadUnsafe<T>(buffer: ArrayBuffer, index: i32): T {
return load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE);
export function loadUnsafe<T,V>(buffer: ArrayBuffer, index: i32): V {
return <V>load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE);
}
@inline
export function storeUnsafe<T>(buffer: ArrayBuffer, index: i32, value: T): void {
export function storeUnsafe<T,V>(buffer: ArrayBuffer, index: i32, value: V): void {
store<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), value, HEADER_SIZE);
}
@inline
export function loadUnsafeWithOffset<T>(buffer: ArrayBuffer, index: i32, byteOffset: i32): T {
return load<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), HEADER_SIZE);
export function loadUnsafeWithOffset<T,V>(buffer: ArrayBuffer, index: i32, byteOffset: i32): V {
return <V>load<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), HEADER_SIZE);
}
@inline
export function storeUnsafeWithOffset<T>(buffer: ArrayBuffer, index: i32, value: T, byteOffset: i32): void {
export function storeUnsafeWithOffset<T,V>(buffer: ArrayBuffer, index: i32, value: V, byteOffset: i32): void {
store<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), value, HEADER_SIZE);
}

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

@ -6,12 +6,8 @@ import {
storeUnsafeWithOffset
} from "./arraybuffer";
import {
ArrayBufferView
} from "../arraybuffer";
/** Typed array base class. Not a global object. */
export abstract class TypedArray<T> implements ArrayBufferView<T> {
export abstract class TypedArray<T,V> {
readonly buffer: ArrayBuffer;
readonly byteOffset: i32;
@ -37,21 +33,31 @@ export abstract class TypedArray<T> implements ArrayBufferView<T> {
var byteOffset = this.byteOffset;
var elementLength = (this.byteLength - byteOffset) >>> alignof<T>();
if (<u32>index >= <u32>elementLength) throw new Error("Index out of bounds");
return loadUnsafeWithOffset<T>(this.buffer, index, byteOffset);
return loadUnsafeWithOffset<T,T>(this.buffer, index, byteOffset);
}
@operator("{}")
protected __unchecked_get(index: i32): T {
return loadUnsafeWithOffset<T,T>(this.buffer, index, this.byteOffset);
}
@operator("[]=")
protected __set(index: i32, value: T): void {
protected __set(index: i32, value: V): void {
var byteOffset = this.byteOffset;
var elementLength = (this.byteLength - byteOffset) >>> alignof<T>();
if (<u32>index >= <u32>elementLength) throw new Error("Index out of bounds");
storeUnsafeWithOffset<T>(this.buffer, index, value, byteOffset);
storeUnsafeWithOffset<T,V>(this.buffer, index, value, byteOffset);
}
@operator("{}=")
protected __unchecked_set(index: i32, value: V): void {
storeUnsafeWithOffset<T,V>(this.buffer, index, value, this.byteOffset);
}
// copyWithin(target: i32, start: i32, end: i32 = this.length): this
@inline
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T> {
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T,V> {
var length = this.length;
if (begin < 0) begin = max(length + begin, 0);
else begin = min(begin, length);

29
std/assembly/typedarray.ts
View File

@ -2,7 +2,7 @@ import {
TypedArray
} from "./internal/typedarray";
export class Int8Array extends TypedArray<i8> {
export class Int8Array extends TypedArray<i8,i32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<i8>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Int8Array {
@ -10,7 +10,7 @@ export class Int8Array extends TypedArray<i8> {
}
}
export class Uint8Array extends TypedArray<u8> {
export class Uint8Array extends TypedArray<u8,u32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Uint8Array {
@ -18,12 +18,17 @@ export class Uint8Array extends TypedArray<u8> {
}
}
export class Uint8ClampedArray extends TypedArray<u8> {
export class Uint8ClampedArray extends TypedArray<u8,u32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
@operator("[]=")
protected __set(index: i32, value: i32): void {
super.__set(index, <u8>max(0, min(0xFF, value)));
super.__set(index, max(min(value, 255), 0));
}
@operator("{}=")
protected __unchecked_set(index: i32, value: i32): void {
super.__unchecked_set(index, max(min(value, 255), 0));
}
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Uint8ClampedArray {
@ -31,7 +36,7 @@ export class Uint8ClampedArray extends TypedArray<u8> {
}
}
export class Int16Array extends TypedArray<i16> {
export class Int16Array extends TypedArray<i16,i32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<i16>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Int16Array {
@ -39,7 +44,7 @@ export class Int16Array extends TypedArray<i16> {
}
}
export class Uint16Array extends TypedArray<u16> {
export class Uint16Array extends TypedArray<u16,u32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<u16>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Uint16Array {
@ -47,7 +52,7 @@ export class Uint16Array extends TypedArray<u16> {
}
}
export class Int32Array extends TypedArray<i32> {
export class Int32Array extends TypedArray<i32,i32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<i32>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Int32Array {
@ -55,7 +60,7 @@ export class Int32Array extends TypedArray<i32> {
}
}
export class Uint32Array extends TypedArray<u32> {
export class Uint32Array extends TypedArray<u32,u32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<u32>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Uint32Array {
@ -63,7 +68,7 @@ export class Uint32Array extends TypedArray<u32> {
}
}
export class Int64Array extends TypedArray<i64> {
export class Int64Array extends TypedArray<i64,i64> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<i64>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Int64Array {
@ -71,7 +76,7 @@ export class Int64Array extends TypedArray<i64> {
}
}
export class Uint64Array extends TypedArray<u64> {
export class Uint64Array extends TypedArray<u64,u64> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<u64>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Uint64Array {
@ -79,7 +84,7 @@ export class Uint64Array extends TypedArray<u64> {
}
}
export class Float32Array extends TypedArray<f32> {
export class Float32Array extends TypedArray<f32,f32> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<f32>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Float32Array {
@ -87,7 +92,7 @@ export class Float32Array extends TypedArray<f32> {
}
}
export class Float64Array extends TypedArray<f64> {
export class Float64Array extends TypedArray<f64,f64> {
static readonly BYTES_PER_ELEMENT: usize = sizeof<f64>();
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Float64Array {