#import "Float16";
The 16-bit IEEE half-precision storage format, with conversions to and from float32 and the Math vector and matrix types.
A Float16 holds only the bits (1 sign, 5 exponent, 10 significand): it has no arithmetic of its own, so convert to float32, compute, and convert back. Half precision has about three decimal digits, a largest finite value of 65504, and subnormals down to 2^-24.
The module parameter ASSERT_ON_OVERFLOW (default false) turns a finite value too large for a half, which otherwise becomes infinity, into a failed assert: #import "Float16"(ASSERT_ON_OVERFLOW = true).
Converts a half to float32. Every half value is exactly representable, so the conversion is exact: subnormals, signed zero and infinities carry over, and a NaN stays a NaN with its payload.
assert(half_to_float_fast4(cast(Float16) 0x3c00) == 1.0);
assert(half_to_float_fast4(cast(Float16) 0xc000) == -2.0);
assert(half_to_float_fast4(cast(Float16) 0x7bff) == 65504.0);
assert(half_to_float_fast4(cast(Float16) 0x0001) == 5.9604644775390625e-8); // smallest subnormalConverts a float32 to the nearest half, rounding ties to the even significand. Called float32_to_float16 too.
assert(cast(u16) float_to_half_fast3(1.0) == 0x3c00);
assert(cast(u16) float_to_half_fast3(-2.0) == 0xc000);
assert(cast(u16) float_to_half_fast3(65504.0) == 0x7bff);
assert(cast(u16) float_to_half_fast3(1.0 / 3.0) == 0x3555);
assert(cast(u16) float_to_half_fast3(100000.0) == 0x7c00); // overflow: infinity
assert(cast(u16) float_to_half_fast3(cast(float32) 1.00048828125) == 0x3c00); // tie rounds to evenThe same procedure as half_to_float_fast4.
The same procedure as float_to_half_fast3.
Converts a Math.Matrix3 to half precision, element by element in row-major order, rounding each as float_to_half_fast3 does.
#import "Math";
m := Matrix3_Identity;
h := matrix3_float16(m);
assert(cast(u16) h._11 == 0x3c00 && cast(u16) h._12 == 0);
assert(matrix3_float32(h)._22 == 1.0);Converts a Matrix3_Float16 back to a Math.Matrix3, exactly.
Converts a Vector2_Float16 to a Math.Vector2, exactly.
Converts a Math.Vector2 to half precision, rounding each component as float_to_half_fast3 does.
#import "Math";
h := vector2_float16(xy(0.5, -4));
v := vector2_float32(h);
assert(v.x == 0.5 && v.y == -4);Converts a Vector3_Float16 to a Math.Vector3, exactly.
Converts a Math.Vector3 to half precision, rounding each component as float_to_half_fast3 does.
#import "Math";
h := vector3_float16(xyz(1, 2, 3));
v := vector3_float32(h);
assert(v.x == 1 && v.y == 2 && v.z == 3);Converts a Vector4_Float16 to a Math.Vector4, exactly.
#import "Math";
h := vector4_float16(xyzw(0.5, -2, 8, 70000));
v := vector4_float32(h);
assert(v.x == 0.5 && v.y == -2 && v.z == 8);
assert(v.w > 1e30); // 70000 overflowed to infinity in half precisionConverts a Math.Vector4 to half precision, rounding each component as float_to_half_fast3 does.
#import "Math";
h := vector4_float16(xyzw(1, 2, 3, 70000));
assert(float16_to_float32(h.w) > 1e30); // 70000 overflows to infinity
assert(float16_to_float32(h.y) == 2);A half-precision float stored as its 16 bits. It is a distinct type based on u16, so a value cannot be mixed with integers or floats by accident; cast(u16) h gives the raw bits and cast(Float16) bits builds one from them.
one := float32_to_float16(1.0);
assert(cast(u16) one == 0x3c00);
assert(float16_to_float32(cast(Float16) 0x4000) == 2.0);Two Float16 components. Convert with vector2_float32 and vector2_float16.
Three Float16 components. Convert with vector3_float32 and vector3_float16.
Four Float16 components. Convert with vector4_float32 and vector4_float16.
A 3x3 matrix of Float16, with the same field names (_11 to _33) and the same row-major floats overlay as Math.Matrix3. Convert with matrix3_float32 and matrix3_float16.