You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1243 lines
41 KiB
1243 lines
41 KiB
/*! @petamoriken/float16 v3.6.6 | MIT License - https://github.com/petamoriken/float16 */
|
|
|
|
const float16 = (function (exports) {
|
|
'use strict';
|
|
|
|
const THIS_IS_NOT_AN_OBJECT = "This is not an object";
|
|
const THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = "This is not a Float16Array object";
|
|
const THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY =
|
|
"This constructor is not a subclass of Float16Array";
|
|
const THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT =
|
|
"The constructor property value is not an object";
|
|
const SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT =
|
|
"Species constructor didn't return TypedArray object";
|
|
const DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH =
|
|
"Derived constructor created TypedArray object which was too small length";
|
|
const ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER =
|
|
"Attempting to access detached ArrayBuffer";
|
|
const CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT =
|
|
"Cannot convert undefined or null to object";
|
|
const CANNOT_MIX_BIGINT_AND_OTHER_TYPES =
|
|
"Cannot mix BigInt and other types, use explicit conversions";
|
|
const ITERATOR_PROPERTY_IS_NOT_CALLABLE = "@@iterator property is not callable";
|
|
const REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE =
|
|
"Reduce of empty array with no initial value";
|
|
const OFFSET_IS_OUT_OF_BOUNDS = "Offset is out of bounds";
|
|
|
|
function uncurryThis(target) {
|
|
return (thisArg, ...args) => {
|
|
return ReflectApply(target, thisArg, args);
|
|
};
|
|
}
|
|
function uncurryThisGetter(target, key) {
|
|
return uncurryThis(
|
|
ReflectGetOwnPropertyDescriptor(
|
|
target,
|
|
key
|
|
).get
|
|
);
|
|
}
|
|
const {
|
|
apply: ReflectApply,
|
|
construct: ReflectConstruct,
|
|
defineProperty: ReflectDefineProperty,
|
|
get: ReflectGet,
|
|
getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
|
|
getPrototypeOf: ReflectGetPrototypeOf,
|
|
has: ReflectHas,
|
|
ownKeys: ReflectOwnKeys,
|
|
set: ReflectSet,
|
|
setPrototypeOf: ReflectSetPrototypeOf,
|
|
} = Reflect;
|
|
const NativeProxy = Proxy;
|
|
const {
|
|
MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
|
|
isFinite: NumberIsFinite,
|
|
isNaN: NumberIsNaN,
|
|
} = Number;
|
|
const {
|
|
iterator: SymbolIterator,
|
|
species: SymbolSpecies,
|
|
toStringTag: SymbolToStringTag,
|
|
for: SymbolFor,
|
|
} = Symbol;
|
|
const NativeObject = Object;
|
|
const {
|
|
create: ObjectCreate,
|
|
defineProperty: ObjectDefineProperty,
|
|
freeze: ObjectFreeze,
|
|
is: ObjectIs,
|
|
} = NativeObject;
|
|
const ObjectPrototype = NativeObject.prototype;
|
|
const ObjectPrototype__lookupGetter__ = (ObjectPrototype).__lookupGetter__
|
|
? uncurryThis( (ObjectPrototype).__lookupGetter__)
|
|
: (object, key) => {
|
|
if (object == null) {
|
|
throw NativeTypeError(
|
|
CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT
|
|
);
|
|
}
|
|
let target = NativeObject(object);
|
|
do {
|
|
const descriptor = ReflectGetOwnPropertyDescriptor(target, key);
|
|
if (descriptor !== undefined) {
|
|
if (ObjectHasOwn(descriptor, "get")) {
|
|
return descriptor.get;
|
|
}
|
|
return;
|
|
}
|
|
} while ((target = ReflectGetPrototypeOf(target)) !== null);
|
|
};
|
|
const ObjectHasOwn = (NativeObject).hasOwn ||
|
|
uncurryThis(ObjectPrototype.hasOwnProperty);
|
|
const NativeArray = Array;
|
|
const ArrayIsArray = NativeArray.isArray;
|
|
const ArrayPrototype = NativeArray.prototype;
|
|
const ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);
|
|
const ArrayPrototypePush = uncurryThis(ArrayPrototype.push);
|
|
const ArrayPrototypeToLocaleString = uncurryThis(
|
|
ArrayPrototype.toLocaleString
|
|
);
|
|
const NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];
|
|
const ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);
|
|
const MathTrunc = Math.trunc;
|
|
const NativeArrayBuffer = ArrayBuffer;
|
|
const ArrayBufferIsView = NativeArrayBuffer.isView;
|
|
const ArrayBufferPrototype = NativeArrayBuffer.prototype;
|
|
const ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);
|
|
const ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, "byteLength");
|
|
const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : null;
|
|
const SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer
|
|
&& uncurryThisGetter(NativeSharedArrayBuffer.prototype, "byteLength");
|
|
const TypedArray = ReflectGetPrototypeOf(Uint8Array);
|
|
const TypedArrayFrom = TypedArray.from;
|
|
const TypedArrayPrototype = TypedArray.prototype;
|
|
const NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];
|
|
const TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);
|
|
const TypedArrayPrototypeValues = uncurryThis(
|
|
TypedArrayPrototype.values
|
|
);
|
|
const TypedArrayPrototypeEntries = uncurryThis(
|
|
TypedArrayPrototype.entries
|
|
);
|
|
const TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);
|
|
const TypedArrayPrototypeReverse = uncurryThis(
|
|
TypedArrayPrototype.reverse
|
|
);
|
|
const TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);
|
|
const TypedArrayPrototypeCopyWithin = uncurryThis(
|
|
TypedArrayPrototype.copyWithin
|
|
);
|
|
const TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);
|
|
const TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);
|
|
const TypedArrayPrototypeSubarray = uncurryThis(
|
|
TypedArrayPrototype.subarray
|
|
);
|
|
const TypedArrayPrototypeGetBuffer = uncurryThisGetter(
|
|
TypedArrayPrototype,
|
|
"buffer"
|
|
);
|
|
const TypedArrayPrototypeGetByteOffset = uncurryThisGetter(
|
|
TypedArrayPrototype,
|
|
"byteOffset"
|
|
);
|
|
const TypedArrayPrototypeGetLength = uncurryThisGetter(
|
|
TypedArrayPrototype,
|
|
"length"
|
|
);
|
|
const TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(
|
|
TypedArrayPrototype,
|
|
SymbolToStringTag
|
|
);
|
|
const NativeUint16Array = Uint16Array;
|
|
const Uint16ArrayFrom = (...args) => {
|
|
return ReflectApply(TypedArrayFrom, NativeUint16Array, args);
|
|
};
|
|
const NativeUint32Array = Uint32Array;
|
|
const NativeFloat32Array = Float32Array;
|
|
const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());
|
|
const ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);
|
|
const GeneratorPrototypeNext = uncurryThis((function* () {})().next);
|
|
const IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);
|
|
const DataViewPrototype = DataView.prototype;
|
|
const DataViewPrototypeGetUint16 = uncurryThis(
|
|
DataViewPrototype.getUint16
|
|
);
|
|
const DataViewPrototypeSetUint16 = uncurryThis(
|
|
DataViewPrototype.setUint16
|
|
);
|
|
const NativeTypeError = TypeError;
|
|
const NativeRangeError = RangeError;
|
|
const NativeWeakSet = WeakSet;
|
|
const WeakSetPrototype = NativeWeakSet.prototype;
|
|
const WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);
|
|
const WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);
|
|
const NativeWeakMap = WeakMap;
|
|
const WeakMapPrototype = NativeWeakMap.prototype;
|
|
const WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);
|
|
const WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);
|
|
const WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);
|
|
|
|
const arrayIterators = new NativeWeakMap();
|
|
const SafeIteratorPrototype = ObjectCreate(null, {
|
|
next: {
|
|
value: function next() {
|
|
const arrayIterator = WeakMapPrototypeGet(arrayIterators, this);
|
|
return ArrayIteratorPrototypeNext(arrayIterator);
|
|
},
|
|
},
|
|
[SymbolIterator]: {
|
|
value: function values() {
|
|
return this;
|
|
},
|
|
},
|
|
});
|
|
function safeIfNeeded(array) {
|
|
if (array[SymbolIterator] === NativeArrayPrototypeSymbolIterator) {
|
|
return array;
|
|
}
|
|
const safe = ObjectCreate(SafeIteratorPrototype);
|
|
WeakMapPrototypeSet(arrayIterators, safe, ArrayPrototypeSymbolIterator(array));
|
|
return safe;
|
|
}
|
|
const generators = new NativeWeakMap();
|
|
const DummyArrayIteratorPrototype = ObjectCreate(IteratorPrototype, {
|
|
next: {
|
|
value: function next() {
|
|
const generator = WeakMapPrototypeGet(generators, this);
|
|
return GeneratorPrototypeNext(generator);
|
|
},
|
|
writable: true,
|
|
configurable: true,
|
|
},
|
|
});
|
|
for (const key of ReflectOwnKeys(ArrayIteratorPrototype)) {
|
|
if (key === "next") {
|
|
continue;
|
|
}
|
|
ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key));
|
|
}
|
|
function wrap(generator) {
|
|
const dummy = ObjectCreate(DummyArrayIteratorPrototype);
|
|
WeakMapPrototypeSet(generators, dummy, generator);
|
|
return dummy;
|
|
}
|
|
|
|
function isObject(value) {
|
|
return (value !== null && typeof value === "object") ||
|
|
typeof value === "function";
|
|
}
|
|
function isObjectLike(value) {
|
|
return value !== null && typeof value === "object";
|
|
}
|
|
function isNativeTypedArray(value) {
|
|
return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined;
|
|
}
|
|
function isNativeBigIntTypedArray(value) {
|
|
const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value);
|
|
return typedArrayName === "BigInt64Array" ||
|
|
typedArrayName === "BigUint64Array";
|
|
}
|
|
function isArrayBuffer(value) {
|
|
try {
|
|
ArrayBufferPrototypeGetByteLength( (value));
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
function isSharedArrayBuffer(value) {
|
|
if (NativeSharedArrayBuffer === null) {
|
|
return false;
|
|
}
|
|
try {
|
|
SharedArrayBufferPrototypeGetByteLength( (value));
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
function isOrdinaryArray(value) {
|
|
if (!ArrayIsArray(value)) {
|
|
return false;
|
|
}
|
|
if (value[SymbolIterator] === NativeArrayPrototypeSymbolIterator) {
|
|
return true;
|
|
}
|
|
const iterator = value[SymbolIterator]();
|
|
return iterator[SymbolToStringTag] === "Array Iterator";
|
|
}
|
|
function isOrdinaryNativeTypedArray(value) {
|
|
if (!isNativeTypedArray(value)) {
|
|
return false;
|
|
}
|
|
if (value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator) {
|
|
return true;
|
|
}
|
|
const iterator = value[SymbolIterator]();
|
|
return iterator[SymbolToStringTag] === "Array Iterator";
|
|
}
|
|
function isCanonicalIntegerIndexString(value) {
|
|
if (typeof value !== "string") {
|
|
return false;
|
|
}
|
|
const number = +value;
|
|
if (value !== number + "") {
|
|
return false;
|
|
}
|
|
if (!NumberIsFinite(number)) {
|
|
return false;
|
|
}
|
|
return number === MathTrunc(number);
|
|
}
|
|
|
|
const brand = SymbolFor("__Float16Array__");
|
|
function hasFloat16ArrayBrand(target) {
|
|
if (!isObjectLike(target)) {
|
|
return false;
|
|
}
|
|
const prototype = ReflectGetPrototypeOf(target);
|
|
if (!isObjectLike(prototype)) {
|
|
return false;
|
|
}
|
|
const constructor = prototype.constructor;
|
|
if (constructor === undefined) {
|
|
return false;
|
|
}
|
|
if (!isObject(constructor)) {
|
|
throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);
|
|
}
|
|
return ReflectHas(constructor, brand);
|
|
}
|
|
|
|
const buffer = new NativeArrayBuffer(4);
|
|
const floatView = new NativeFloat32Array(buffer);
|
|
const uint32View = new NativeUint32Array(buffer);
|
|
const baseTable = new NativeUint32Array(512);
|
|
const shiftTable = new NativeUint32Array(512);
|
|
for (let i = 0; i < 256; ++i) {
|
|
const e = i - 127;
|
|
if (e < -27) {
|
|
baseTable[i] = 0x0000;
|
|
baseTable[i | 0x100] = 0x8000;
|
|
shiftTable[i] = 24;
|
|
shiftTable[i | 0x100] = 24;
|
|
} else if (e < -14) {
|
|
baseTable[i] = 0x0400 >> (-e - 14);
|
|
baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
|
|
shiftTable[i] = -e - 1;
|
|
shiftTable[i | 0x100] = -e - 1;
|
|
} else if (e <= 15) {
|
|
baseTable[i] = (e + 15) << 10;
|
|
baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
|
|
shiftTable[i] = 13;
|
|
shiftTable[i | 0x100] = 13;
|
|
} else if (e < 128) {
|
|
baseTable[i] = 0x7c00;
|
|
baseTable[i | 0x100] = 0xfc00;
|
|
shiftTable[i] = 24;
|
|
shiftTable[i | 0x100] = 24;
|
|
} else {
|
|
baseTable[i] = 0x7c00;
|
|
baseTable[i | 0x100] = 0xfc00;
|
|
shiftTable[i] = 13;
|
|
shiftTable[i | 0x100] = 13;
|
|
}
|
|
}
|
|
function roundToFloat16Bits(num) {
|
|
floatView[0] = (num);
|
|
const f = uint32View[0];
|
|
const e = (f >> 23) & 0x1ff;
|
|
return baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
|
|
}
|
|
const mantissaTable = new NativeUint32Array(2048);
|
|
const exponentTable = new NativeUint32Array(64);
|
|
const offsetTable = new NativeUint32Array(64);
|
|
for (let i = 1; i < 1024; ++i) {
|
|
let m = i << 13;
|
|
let e = 0;
|
|
while((m & 0x00800000) === 0) {
|
|
m <<= 1;
|
|
e -= 0x00800000;
|
|
}
|
|
m &= ~0x00800000;
|
|
e += 0x38800000;
|
|
mantissaTable[i] = m | e;
|
|
}
|
|
for (let i = 1024; i < 2048; ++i) {
|
|
mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);
|
|
}
|
|
for (let i = 1; i < 31; ++i) {
|
|
exponentTable[i] = i << 23;
|
|
}
|
|
exponentTable[31] = 0x47800000;
|
|
exponentTable[32] = 0x80000000;
|
|
for (let i = 33; i < 63; ++i) {
|
|
exponentTable[i] = 0x80000000 + ((i - 32) << 23);
|
|
}
|
|
exponentTable[63] = 0xc7800000;
|
|
for (let i = 1; i < 64; ++i) {
|
|
if (i !== 32) {
|
|
offsetTable[i] = 1024;
|
|
}
|
|
}
|
|
function convertToNumber(float16bits) {
|
|
const m = float16bits >> 10;
|
|
uint32View[0] = mantissaTable[offsetTable[m] + (float16bits & 0x3ff)] + exponentTable[m];
|
|
return floatView[0];
|
|
}
|
|
|
|
function ToIntegerOrInfinity(target) {
|
|
const number = +target;
|
|
if (NumberIsNaN(number) || number === 0) {
|
|
return 0;
|
|
}
|
|
return MathTrunc(number);
|
|
}
|
|
function ToLength(target) {
|
|
const length = ToIntegerOrInfinity(target);
|
|
if (length < 0) {
|
|
return 0;
|
|
}
|
|
return length < MAX_SAFE_INTEGER
|
|
? length
|
|
: MAX_SAFE_INTEGER;
|
|
}
|
|
function SpeciesConstructor(target, defaultConstructor) {
|
|
if (!isObject(target)) {
|
|
throw NativeTypeError(THIS_IS_NOT_AN_OBJECT);
|
|
}
|
|
const constructor = target.constructor;
|
|
if (constructor === undefined) {
|
|
return defaultConstructor;
|
|
}
|
|
if (!isObject(constructor)) {
|
|
throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);
|
|
}
|
|
const species = constructor[SymbolSpecies];
|
|
if (species == null) {
|
|
return defaultConstructor;
|
|
}
|
|
return species;
|
|
}
|
|
function IsDetachedBuffer(buffer) {
|
|
if (isSharedArrayBuffer(buffer)) {
|
|
return false;
|
|
}
|
|
try {
|
|
ArrayBufferPrototypeSlice(buffer, 0, 0);
|
|
return false;
|
|
} catch (e) {}
|
|
return true;
|
|
}
|
|
function defaultCompare(x, y) {
|
|
const isXNaN = NumberIsNaN(x);
|
|
const isYNaN = NumberIsNaN(y);
|
|
if (isXNaN && isYNaN) {
|
|
return 0;
|
|
}
|
|
if (isXNaN) {
|
|
return 1;
|
|
}
|
|
if (isYNaN) {
|
|
return -1;
|
|
}
|
|
if (x < y) {
|
|
return -1;
|
|
}
|
|
if (x > y) {
|
|
return 1;
|
|
}
|
|
if (x === 0 && y === 0) {
|
|
const isXPlusZero = ObjectIs(x, 0);
|
|
const isYPlusZero = ObjectIs(y, 0);
|
|
if (!isXPlusZero && isYPlusZero) {
|
|
return -1;
|
|
}
|
|
if (isXPlusZero && !isYPlusZero) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const BYTES_PER_ELEMENT = 2;
|
|
const float16bitsArrays = new NativeWeakMap();
|
|
function isFloat16Array(target) {
|
|
return WeakMapPrototypeHas(float16bitsArrays, target) ||
|
|
(!ArrayBufferIsView(target) && hasFloat16ArrayBrand(target));
|
|
}
|
|
function assertFloat16Array(target) {
|
|
if (!isFloat16Array(target)) {
|
|
throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT);
|
|
}
|
|
}
|
|
function assertSpeciesTypedArray(target, count) {
|
|
const isTargetFloat16Array = isFloat16Array(target);
|
|
const isTargetTypedArray = isNativeTypedArray(target);
|
|
if (!isTargetFloat16Array && !isTargetTypedArray) {
|
|
throw NativeTypeError(SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT);
|
|
}
|
|
if (typeof count === "number") {
|
|
let length;
|
|
if (isTargetFloat16Array) {
|
|
const float16bitsArray = getFloat16BitsArray(target);
|
|
length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
} else {
|
|
length = TypedArrayPrototypeGetLength(target);
|
|
}
|
|
if (length < count) {
|
|
throw NativeTypeError(
|
|
DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH
|
|
);
|
|
}
|
|
}
|
|
if (isNativeBigIntTypedArray(target)) {
|
|
throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);
|
|
}
|
|
}
|
|
function getFloat16BitsArray(float16) {
|
|
const float16bitsArray = WeakMapPrototypeGet(float16bitsArrays, float16);
|
|
if (float16bitsArray !== undefined) {
|
|
const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);
|
|
if (IsDetachedBuffer(buffer)) {
|
|
throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
|
|
}
|
|
return float16bitsArray;
|
|
}
|
|
const buffer = (float16).buffer;
|
|
if (IsDetachedBuffer(buffer)) {
|
|
throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
|
|
}
|
|
const cloned = ReflectConstruct(Float16Array, [
|
|
buffer,
|
|
(float16).byteOffset,
|
|
(float16).length,
|
|
], float16.constructor);
|
|
return WeakMapPrototypeGet(float16bitsArrays, cloned);
|
|
}
|
|
function copyToArray(float16bitsArray) {
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const array = [];
|
|
for (let i = 0; i < length; ++i) {
|
|
array[i] = convertToNumber(float16bitsArray[i]);
|
|
}
|
|
return array;
|
|
}
|
|
const TypedArrayPrototypeGetters = new NativeWeakSet();
|
|
for (const key of ReflectOwnKeys(TypedArrayPrototype)) {
|
|
if (key === SymbolToStringTag) {
|
|
continue;
|
|
}
|
|
const descriptor = ReflectGetOwnPropertyDescriptor(TypedArrayPrototype, key);
|
|
if (ObjectHasOwn(descriptor, "get") && typeof descriptor.get === "function") {
|
|
WeakSetPrototypeAdd(TypedArrayPrototypeGetters, descriptor.get);
|
|
}
|
|
}
|
|
const handler = ObjectFreeze( ({
|
|
get(target, key, receiver) {
|
|
if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {
|
|
return convertToNumber(ReflectGet(target, key));
|
|
}
|
|
if (WeakSetPrototypeHas(TypedArrayPrototypeGetters, ObjectPrototype__lookupGetter__(target, key))) {
|
|
return ReflectGet(target, key);
|
|
}
|
|
return ReflectGet(target, key, receiver);
|
|
},
|
|
set(target, key, value, receiver) {
|
|
if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {
|
|
return ReflectSet(target, key, roundToFloat16Bits(value));
|
|
}
|
|
return ReflectSet(target, key, value, receiver);
|
|
},
|
|
getOwnPropertyDescriptor(target, key) {
|
|
if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {
|
|
const descriptor = ReflectGetOwnPropertyDescriptor(target, key);
|
|
descriptor.value = convertToNumber(descriptor.value);
|
|
return descriptor;
|
|
}
|
|
return ReflectGetOwnPropertyDescriptor(target, key);
|
|
},
|
|
defineProperty(target, key, descriptor) {
|
|
if (
|
|
isCanonicalIntegerIndexString(key) &&
|
|
ObjectHasOwn(target, key) &&
|
|
ObjectHasOwn(descriptor, "value")
|
|
) {
|
|
descriptor.value = roundToFloat16Bits(descriptor.value);
|
|
return ReflectDefineProperty(target, key, descriptor);
|
|
}
|
|
return ReflectDefineProperty(target, key, descriptor);
|
|
},
|
|
}));
|
|
class Float16Array {
|
|
constructor(input, _byteOffset, _length) {
|
|
let float16bitsArray;
|
|
if (isFloat16Array(input)) {
|
|
float16bitsArray = ReflectConstruct(NativeUint16Array, [getFloat16BitsArray(input)], new.target);
|
|
} else if (isObject(input) && !isArrayBuffer(input)) {
|
|
let list;
|
|
let length;
|
|
if (isNativeTypedArray(input)) {
|
|
list = input;
|
|
length = TypedArrayPrototypeGetLength(input);
|
|
const buffer = TypedArrayPrototypeGetBuffer(input);
|
|
const BufferConstructor = !isSharedArrayBuffer(buffer)
|
|
? (SpeciesConstructor(
|
|
buffer,
|
|
NativeArrayBuffer
|
|
))
|
|
: NativeArrayBuffer;
|
|
if (IsDetachedBuffer(buffer)) {
|
|
throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
|
|
}
|
|
if (isNativeBigIntTypedArray(input)) {
|
|
throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);
|
|
}
|
|
const data = new BufferConstructor(
|
|
length * BYTES_PER_ELEMENT
|
|
);
|
|
float16bitsArray = ReflectConstruct(NativeUint16Array, [data], new.target);
|
|
} else {
|
|
const iterator = input[SymbolIterator];
|
|
if (iterator != null && typeof iterator !== "function") {
|
|
throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);
|
|
}
|
|
if (iterator != null) {
|
|
if (isOrdinaryArray(input)) {
|
|
list = input;
|
|
length = input.length;
|
|
} else {
|
|
list = [... (input)];
|
|
length = list.length;
|
|
}
|
|
} else {
|
|
list = (input);
|
|
length = ToLength(list.length);
|
|
}
|
|
float16bitsArray = ReflectConstruct(NativeUint16Array, [length], new.target);
|
|
}
|
|
for (let i = 0; i < length; ++i) {
|
|
float16bitsArray[i] = roundToFloat16Bits(list[i]);
|
|
}
|
|
} else {
|
|
float16bitsArray = ReflectConstruct(NativeUint16Array, arguments, new.target);
|
|
}
|
|
const proxy = (new NativeProxy(float16bitsArray, handler));
|
|
WeakMapPrototypeSet(float16bitsArrays, proxy, float16bitsArray);
|
|
return proxy;
|
|
}
|
|
static from(src, ...opts) {
|
|
const Constructor = this;
|
|
if (!ReflectHas(Constructor, brand)) {
|
|
throw NativeTypeError(
|
|
THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY
|
|
);
|
|
}
|
|
if (Constructor === Float16Array) {
|
|
if (isFloat16Array(src) && opts.length === 0) {
|
|
const float16bitsArray = getFloat16BitsArray(src);
|
|
const uint16 = new NativeUint16Array(
|
|
TypedArrayPrototypeGetBuffer(float16bitsArray),
|
|
TypedArrayPrototypeGetByteOffset(float16bitsArray),
|
|
TypedArrayPrototypeGetLength(float16bitsArray)
|
|
);
|
|
return new Float16Array(
|
|
TypedArrayPrototypeGetBuffer(TypedArrayPrototypeSlice(uint16))
|
|
);
|
|
}
|
|
if (opts.length === 0) {
|
|
return new Float16Array(
|
|
TypedArrayPrototypeGetBuffer(
|
|
Uint16ArrayFrom(src, roundToFloat16Bits)
|
|
)
|
|
);
|
|
}
|
|
const mapFunc = opts[0];
|
|
const thisArg = opts[1];
|
|
return new Float16Array(
|
|
TypedArrayPrototypeGetBuffer(
|
|
Uint16ArrayFrom(src, function (val, ...args) {
|
|
return roundToFloat16Bits(
|
|
ReflectApply(mapFunc, this, [val, ...safeIfNeeded(args)])
|
|
);
|
|
}, thisArg)
|
|
)
|
|
);
|
|
}
|
|
let list;
|
|
let length;
|
|
const iterator = src[SymbolIterator];
|
|
if (iterator != null && typeof iterator !== "function") {
|
|
throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);
|
|
}
|
|
if (iterator != null) {
|
|
if (isOrdinaryArray(src)) {
|
|
list = src;
|
|
length = src.length;
|
|
} else if (isOrdinaryNativeTypedArray(src)) {
|
|
list = src;
|
|
length = TypedArrayPrototypeGetLength(src);
|
|
} else {
|
|
list = [...src];
|
|
length = list.length;
|
|
}
|
|
} else {
|
|
if (src == null) {
|
|
throw NativeTypeError(
|
|
CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT
|
|
);
|
|
}
|
|
list = NativeObject(src);
|
|
length = ToLength(list.length);
|
|
}
|
|
const array = new Constructor(length);
|
|
if (opts.length === 0) {
|
|
for (let i = 0; i < length; ++i) {
|
|
array[i] = (list[i]);
|
|
}
|
|
} else {
|
|
const mapFunc = opts[0];
|
|
const thisArg = opts[1];
|
|
for (let i = 0; i < length; ++i) {
|
|
array[i] = ReflectApply(mapFunc, thisArg, [list[i], i]);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
static of(...items) {
|
|
const Constructor = this;
|
|
if (!ReflectHas(Constructor, brand)) {
|
|
throw NativeTypeError(
|
|
THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY
|
|
);
|
|
}
|
|
const length = items.length;
|
|
if (Constructor === Float16Array) {
|
|
const proxy = new Float16Array(length);
|
|
const float16bitsArray = getFloat16BitsArray(proxy);
|
|
for (let i = 0; i < length; ++i) {
|
|
float16bitsArray[i] = roundToFloat16Bits(items[i]);
|
|
}
|
|
return proxy;
|
|
}
|
|
const array = new Constructor(length);
|
|
for (let i = 0; i < length; ++i) {
|
|
array[i] = items[i];
|
|
}
|
|
return array;
|
|
}
|
|
keys() {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
return TypedArrayPrototypeKeys(float16bitsArray);
|
|
}
|
|
values() {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
return wrap((function* () {
|
|
for (const val of TypedArrayPrototypeValues(float16bitsArray)) {
|
|
yield convertToNumber(val);
|
|
}
|
|
})());
|
|
}
|
|
entries() {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
return wrap((function* () {
|
|
for (const [i, val] of TypedArrayPrototypeEntries(float16bitsArray)) {
|
|
yield ([i, convertToNumber(val)]);
|
|
}
|
|
})());
|
|
}
|
|
at(index) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const relativeIndex = ToIntegerOrInfinity(index);
|
|
const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;
|
|
if (k < 0 || k >= length) {
|
|
return;
|
|
}
|
|
return convertToNumber(float16bitsArray[k]);
|
|
}
|
|
map(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);
|
|
if (Constructor === Float16Array) {
|
|
const proxy = new Float16Array(length);
|
|
const array = getFloat16BitsArray(proxy);
|
|
for (let i = 0; i < length; ++i) {
|
|
const val = convertToNumber(float16bitsArray[i]);
|
|
array[i] = roundToFloat16Bits(
|
|
ReflectApply(callback, thisArg, [val, i, this])
|
|
);
|
|
}
|
|
return proxy;
|
|
}
|
|
const array = new Constructor(length);
|
|
assertSpeciesTypedArray(array, length);
|
|
for (let i = 0; i < length; ++i) {
|
|
const val = convertToNumber(float16bitsArray[i]);
|
|
array[i] = ReflectApply(callback, thisArg, [val, i, this]);
|
|
}
|
|
return (array);
|
|
}
|
|
filter(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
const kept = [];
|
|
for (let i = 0; i < length; ++i) {
|
|
const val = convertToNumber(float16bitsArray[i]);
|
|
if (ReflectApply(callback, thisArg, [val, i, this])) {
|
|
ArrayPrototypePush(kept, val);
|
|
}
|
|
}
|
|
const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);
|
|
const array = new Constructor(kept);
|
|
assertSpeciesTypedArray(array);
|
|
return (array);
|
|
}
|
|
reduce(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
if (length === 0 && opts.length === 0) {
|
|
throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);
|
|
}
|
|
let accumulator, start;
|
|
if (opts.length === 0) {
|
|
accumulator = convertToNumber(float16bitsArray[0]);
|
|
start = 1;
|
|
} else {
|
|
accumulator = opts[0];
|
|
start = 0;
|
|
}
|
|
for (let i = start; i < length; ++i) {
|
|
accumulator = callback(
|
|
accumulator,
|
|
convertToNumber(float16bitsArray[i]),
|
|
i,
|
|
this
|
|
);
|
|
}
|
|
return accumulator;
|
|
}
|
|
reduceRight(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
if (length === 0 && opts.length === 0) {
|
|
throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);
|
|
}
|
|
let accumulator, start;
|
|
if (opts.length === 0) {
|
|
accumulator = convertToNumber(float16bitsArray[length - 1]);
|
|
start = length - 2;
|
|
} else {
|
|
accumulator = opts[0];
|
|
start = length - 1;
|
|
}
|
|
for (let i = start; i >= 0; --i) {
|
|
accumulator = callback(
|
|
accumulator,
|
|
convertToNumber(float16bitsArray[i]),
|
|
i,
|
|
this
|
|
);
|
|
}
|
|
return accumulator;
|
|
}
|
|
forEach(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = 0; i < length; ++i) {
|
|
ReflectApply(callback, thisArg, [
|
|
convertToNumber(float16bitsArray[i]),
|
|
i,
|
|
this,
|
|
]);
|
|
}
|
|
}
|
|
find(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = 0; i < length; ++i) {
|
|
const value = convertToNumber(float16bitsArray[i]);
|
|
if (ReflectApply(callback, thisArg, [value, i, this])) {
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
findIndex(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = 0; i < length; ++i) {
|
|
const value = convertToNumber(float16bitsArray[i]);
|
|
if (ReflectApply(callback, thisArg, [value, i, this])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
findLast(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = length - 1; i >= 0; --i) {
|
|
const value = convertToNumber(float16bitsArray[i]);
|
|
if (ReflectApply(callback, thisArg, [value, i, this])) {
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
findLastIndex(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = length - 1; i >= 0; --i) {
|
|
const value = convertToNumber(float16bitsArray[i]);
|
|
if (ReflectApply(callback, thisArg, [value, i, this])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
every(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = 0; i < length; ++i) {
|
|
if (
|
|
!ReflectApply(callback, thisArg, [
|
|
convertToNumber(float16bitsArray[i]),
|
|
i,
|
|
this,
|
|
])
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
some(callback, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const thisArg = opts[0];
|
|
for (let i = 0; i < length; ++i) {
|
|
if (
|
|
ReflectApply(callback, thisArg, [
|
|
convertToNumber(float16bitsArray[i]),
|
|
i,
|
|
this,
|
|
])
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
set(input, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const targetOffset = ToIntegerOrInfinity(opts[0]);
|
|
if (targetOffset < 0) {
|
|
throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);
|
|
}
|
|
if (input == null) {
|
|
throw NativeTypeError(
|
|
CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT
|
|
);
|
|
}
|
|
if (isNativeBigIntTypedArray(input)) {
|
|
throw NativeTypeError(
|
|
CANNOT_MIX_BIGINT_AND_OTHER_TYPES
|
|
);
|
|
}
|
|
if (isFloat16Array(input)) {
|
|
return TypedArrayPrototypeSet(
|
|
getFloat16BitsArray(this),
|
|
getFloat16BitsArray(input),
|
|
targetOffset
|
|
);
|
|
}
|
|
if (isNativeTypedArray(input)) {
|
|
const buffer = TypedArrayPrototypeGetBuffer(input);
|
|
if (IsDetachedBuffer(buffer)) {
|
|
throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
|
|
}
|
|
}
|
|
const targetLength = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const src = NativeObject(input);
|
|
const srcLength = ToLength(src.length);
|
|
if (targetOffset === Infinity || srcLength + targetOffset > targetLength) {
|
|
throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);
|
|
}
|
|
for (let i = 0; i < srcLength; ++i) {
|
|
float16bitsArray[i + targetOffset] = roundToFloat16Bits(src[i]);
|
|
}
|
|
}
|
|
reverse() {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
TypedArrayPrototypeReverse(float16bitsArray);
|
|
return this;
|
|
}
|
|
fill(value, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
TypedArrayPrototypeFill(
|
|
float16bitsArray,
|
|
roundToFloat16Bits(value),
|
|
...safeIfNeeded(opts)
|
|
);
|
|
return this;
|
|
}
|
|
copyWithin(target, start, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
TypedArrayPrototypeCopyWithin(float16bitsArray, target, start, ...safeIfNeeded(opts));
|
|
return this;
|
|
}
|
|
sort(compareFn) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;
|
|
TypedArrayPrototypeSort(float16bitsArray, (x, y) => {
|
|
return sortCompare(convertToNumber(x), convertToNumber(y));
|
|
});
|
|
return this;
|
|
}
|
|
slice(start, end) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);
|
|
if (Constructor === Float16Array) {
|
|
const uint16 = new NativeUint16Array(
|
|
TypedArrayPrototypeGetBuffer(float16bitsArray),
|
|
TypedArrayPrototypeGetByteOffset(float16bitsArray),
|
|
TypedArrayPrototypeGetLength(float16bitsArray)
|
|
);
|
|
return new Float16Array(
|
|
TypedArrayPrototypeGetBuffer(
|
|
TypedArrayPrototypeSlice(uint16, start, end)
|
|
)
|
|
);
|
|
}
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
const relativeStart = ToIntegerOrInfinity(start);
|
|
const relativeEnd = end === undefined ? length : ToIntegerOrInfinity(end);
|
|
let k;
|
|
if (relativeStart === -Infinity) {
|
|
k = 0;
|
|
} else if (relativeStart < 0) {
|
|
k = length + relativeStart > 0 ? length + relativeStart : 0;
|
|
} else {
|
|
k = length < relativeStart ? length : relativeStart;
|
|
}
|
|
let final;
|
|
if (relativeEnd === -Infinity) {
|
|
final = 0;
|
|
} else if (relativeEnd < 0) {
|
|
final = length + relativeEnd > 0 ? length + relativeEnd : 0;
|
|
} else {
|
|
final = length < relativeEnd ? length : relativeEnd;
|
|
}
|
|
const count = final - k > 0 ? final - k : 0;
|
|
const array = new Constructor(count);
|
|
assertSpeciesTypedArray(array, count);
|
|
if (count === 0) {
|
|
return array;
|
|
}
|
|
const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);
|
|
if (IsDetachedBuffer(buffer)) {
|
|
throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
|
|
}
|
|
let n = 0;
|
|
while (k < final) {
|
|
array[n] = convertToNumber(float16bitsArray[k]);
|
|
++k;
|
|
++n;
|
|
}
|
|
return (array);
|
|
}
|
|
subarray(begin, end) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);
|
|
const uint16 = new NativeUint16Array(
|
|
TypedArrayPrototypeGetBuffer(float16bitsArray),
|
|
TypedArrayPrototypeGetByteOffset(float16bitsArray),
|
|
TypedArrayPrototypeGetLength(float16bitsArray)
|
|
);
|
|
const uint16Subarray = TypedArrayPrototypeSubarray(uint16, begin, end);
|
|
const array = new Constructor(
|
|
TypedArrayPrototypeGetBuffer(uint16Subarray),
|
|
TypedArrayPrototypeGetByteOffset(uint16Subarray),
|
|
TypedArrayPrototypeGetLength(uint16Subarray)
|
|
);
|
|
assertSpeciesTypedArray(array);
|
|
return (array);
|
|
}
|
|
indexOf(element, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
let from = ToIntegerOrInfinity(opts[0]);
|
|
if (from === Infinity) {
|
|
return -1;
|
|
}
|
|
if (from < 0) {
|
|
from += length;
|
|
if (from < 0) {
|
|
from = 0;
|
|
}
|
|
}
|
|
for (let i = from; i < length; ++i) {
|
|
if (
|
|
ObjectHasOwn(float16bitsArray, i) &&
|
|
convertToNumber(float16bitsArray[i]) === element
|
|
) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
lastIndexOf(element, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
let from = opts.length >= 1 ? ToIntegerOrInfinity(opts[0]) : length - 1;
|
|
if (from === -Infinity) {
|
|
return -1;
|
|
}
|
|
if (from >= 0) {
|
|
from = from < length - 1 ? from : length - 1;
|
|
} else {
|
|
from += length;
|
|
}
|
|
for (let i = from; i >= 0; --i) {
|
|
if (
|
|
ObjectHasOwn(float16bitsArray, i) &&
|
|
convertToNumber(float16bitsArray[i]) === element
|
|
) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
includes(element, ...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const length = TypedArrayPrototypeGetLength(float16bitsArray);
|
|
let from = ToIntegerOrInfinity(opts[0]);
|
|
if (from === Infinity) {
|
|
return false;
|
|
}
|
|
if (from < 0) {
|
|
from += length;
|
|
if (from < 0) {
|
|
from = 0;
|
|
}
|
|
}
|
|
const isNaN = NumberIsNaN(element);
|
|
for (let i = from; i < length; ++i) {
|
|
const value = convertToNumber(float16bitsArray[i]);
|
|
if (isNaN && NumberIsNaN(value)) {
|
|
return true;
|
|
}
|
|
if (value === element) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
join(separator) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const array = copyToArray(float16bitsArray);
|
|
return ArrayPrototypeJoin(array, separator);
|
|
}
|
|
toLocaleString(...opts) {
|
|
assertFloat16Array(this);
|
|
const float16bitsArray = getFloat16BitsArray(this);
|
|
const array = copyToArray(float16bitsArray);
|
|
return ArrayPrototypeToLocaleString(array, ...safeIfNeeded(opts));
|
|
}
|
|
get [SymbolToStringTag]() {
|
|
if (isFloat16Array(this)) {
|
|
return ("Float16Array");
|
|
}
|
|
}
|
|
}
|
|
ObjectDefineProperty(Float16Array, "BYTES_PER_ELEMENT", {
|
|
value: BYTES_PER_ELEMENT,
|
|
});
|
|
ObjectDefineProperty(Float16Array, brand, {});
|
|
ReflectSetPrototypeOf(Float16Array, TypedArray);
|
|
const Float16ArrayPrototype = Float16Array.prototype;
|
|
ObjectDefineProperty(Float16ArrayPrototype, "BYTES_PER_ELEMENT", {
|
|
value: BYTES_PER_ELEMENT,
|
|
});
|
|
ObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, {
|
|
value: Float16ArrayPrototype.values,
|
|
writable: true,
|
|
configurable: true,
|
|
});
|
|
ReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype);
|
|
|
|
function isTypedArray(target) {
|
|
return isNativeTypedArray(target) || isFloat16Array(target);
|
|
}
|
|
|
|
function getFloat16(dataView, byteOffset, ...opts) {
|
|
return convertToNumber(
|
|
DataViewPrototypeGetUint16(dataView, byteOffset, ...safeIfNeeded(opts))
|
|
);
|
|
}
|
|
function setFloat16(dataView, byteOffset, value, ...opts) {
|
|
return DataViewPrototypeSetUint16(
|
|
dataView,
|
|
byteOffset,
|
|
roundToFloat16Bits(value),
|
|
...safeIfNeeded(opts)
|
|
);
|
|
}
|
|
|
|
function hfround(x) {
|
|
const number = +x;
|
|
if (!NumberIsFinite(number) || number === 0) {
|
|
return number;
|
|
}
|
|
const x16 = roundToFloat16Bits(number);
|
|
return convertToNumber(x16);
|
|
}
|
|
|
|
exports.Float16Array = Float16Array;
|
|
exports.getFloat16 = getFloat16;
|
|
exports.hfround = hfround;
|
|
exports.isFloat16Array = isFloat16Array;
|
|
exports.isTypedArray = isTypedArray;
|
|
exports.setFloat16 = setFloat16;
|
|
|
|
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
|
|
|
|
return exports;
|
|
|
|
})({});
|