Implement DataView: Float16

* Implement Float16

Tests cover:
- Zero (positive and negative)
- Simple values (1, -1, 2, 0.5, etc.)
- Infinity (positive and negative)
- NaN
- Overflow cases (values > 65504)
- Underflow cases (values < 2^-24)
- Denormalized numbers
- Normal numbers
- Precision and rounding
- Endianness (little-endian vs big-endian)
- Bit pattern validation
- Round-trip consistency
- Powers of two
- Common float values

Also fixed floating-point literal precision warning.

* Add IEEE 754 Float16 reference tests with Node.js compatibility

Tests validate our Float16 implementation against IEEE 754 binary16
specification. All test cases use known bit patterns and expected values
from the specification.

Test coverage:
- Exact bit pattern validation for special values (0, ±1, ±Inf, NaN)
- Powers of two from 2^-14 to 2^15
- Denormalized number handling
- Rounding behavior (rounds to nearest representable value)
- Overflow and underflow edge cases
- Endianness (both little and big-endian)

---------

Co-authored-by: vladimir.zhuravlev <vladimir.zhuravlev@servicenow.com>

Author: zhurvla

rhino/src/main/java/org/mozilla/javascript/typedarrays/ByteIo.java

@@ -7,6 +7,11 @@
 package org.mozilla.javascript.typedarrays;
 
 public class ByteIo {
+
+    // Float16 constants
+    private static final double FLOAT16_MIN_NORMAL = 6.103515625e-5; // 2^-14
+    private static final double FLOAT16_MIN_SUBNORMAL = 5.960464477539063E-8; // 2^-24
+
     public static Byte readInt8(byte[] buf, int offset) {
         return Byte.valueOf(buf[offset]);
     }
@@ -162,6 +167,177 @@ public static void writeUint64(byte[] buf, int offset, long val, boolean littleE
         }
     }
 
+    public static Float readFloat16(byte[] buf, int offset, boolean littleEndian) {
+        int bits = doReadInt16(buf, offset, littleEndian) & 0xffff;
+
+        // Extract sign, exponent, and mantissa
+        int sign = (bits >>> 15) & 0x1;
+        int exponent = (bits >>> 10) & 0x1f;
+        int mantissa = bits & 0x3ff;
+
+        // Handle special cases
+        if (exponent == 0) {
+            if (mantissa == 0) {
+                // Zero
+                return sign == 0 ? 0.0f : -0.0f;
+            }
+
+            // Denormalized number
+            float value = (float) ((double) mantissa / (1 << 10) * FLOAT16_MIN_NORMAL);
+            return sign == 0 ? value : -value;
+
+        } else if (exponent == 31) {
+            if (mantissa == 0) {
+                // Infinity
+                return sign == 0 ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY;
+            }
+
+            // NaN
+            return Float.NaN;
+
+        } else {
+            // Normalized number
+            float value =
+                    (float) ((1.0 + (double) mantissa / (1 << 10)) * Math.pow(2, exponent - 15));
+            return sign == 0 ? value : -value;
+        }
+    }
+
+    public static void writeFloat16(byte[] buf, int offset, double val, boolean littleEndian) {
+        float fval = (float) val;
+
+        // Handle special cases
+        if (Float.isNaN(fval)) {
+            doWriteInt16(buf, offset, 0x7e00, littleEndian);
+            return;
+        }
+
+        int sign = (Float.floatToIntBits(fval) >>> 31) & 0x1;
+        float absVal = Math.abs(fval);
+
+        if (Float.isInfinite(fval)) {
+            // Infinity
+            doWriteInt16(buf, offset, (sign << 15) | 0x7c00, littleEndian);
+            return;
+        }
+
+        if (absVal == 0.0f) {
+            // Zero
+            doWriteInt16(buf, offset, sign << 15, littleEndian);
+            return;
+        }
+
+        // Convert to float16
+        int exponent;
+        int mantissa;
+
+        // Check overflow using original double precision
+        // Max representable float16 is 65504 (exp=30, mantissa=0x3ff)
+        // Values >= 65520 definitely overflow to infinity
+        // Values in [65504, 65520) might round to 65504 or infinity
+        double absValDouble = Math.abs(val);
+        if (absValDouble >= 65520.0) {
+            // Definite overflow to infinity
+            doWriteInt16(buf, offset, (sign << 15) | 0x7c00, littleEndian);
+            return;
+        } else if (absValDouble > 65504.0) {
+            // Near overflow: value is between max finite and definite overflow
+            // These values might round to 65504 or infinity depending on exact value
+            // 65504 = 0x7BFF: exp=30, mantissa=0x3ff (all 1s)
+            // Halfway point to next value would cause overflow
+            // Values < 65520 should round to 65504
+            doWriteInt16(buf, offset, (sign << 15) | 0x7BFF, littleEndian);
+            return;
+        }
+        if (absVal < (float) FLOAT16_MIN_NORMAL) {
+            // Denormalized number - IEEE 754 round-to-nearest-even
+            // Use original double precision for accuracy in denormalized range
+            exponent = 0;
+
+            double ratio = Math.abs(val) / FLOAT16_MIN_SUBNORMAL;
+            int mantissaBase = (int) ratio;
+            double fractional = ratio - mantissaBase;
+
+            // IEEE 754 round-to-nearest-even
+            if (fractional > 0.5) {
+                // More than halfway: round up
+                mantissa = mantissaBase + 1;
+            } else if (fractional == 0.5) {
+                // Tie: round to even
+                if ((mantissaBase & 1) != 0) {
+                    mantissa = mantissaBase + 1; // Round up if odd
+                } else {
+                    mantissa = mantissaBase; // Keep if even
+                }
+            } else {
+                // Less than halfway: round down
+                mantissa = mantissaBase;
+            }
+        } else {
+            // Normalized
+            int exp32 = ((Float.floatToIntBits(fval) >>> 23) & 0xff) - 127;
+            exponent = exp32 + 15;
+
+            // DEFENSIVE CHECK (UNCOVERED): Exponent overflow to infinity
+            // This check is unreachable through normal API usage because:
+            // - Guard at line 239 catches all values >= 65520 (which have exp32 >= 16)
+            // - For exponent >= 31: need exp32 >= 16, meaning Float32 >= 2^16 = 65536
+            // - But 65536 >= 65520, so caught by guard before reaching here
+            // - Mathematical impossibility: Can't pass guard (< 65520) AND overflow (>= 65536)
+            // This defensive check is kept for defense-in-depth in case guards are modified.
+            // See UNCOVERED_CODE_EXPLANATION.md for full mathematical proof.
+            if (exponent >= 31) {
+                // Overflow to infinity
+                doWriteInt16(buf, offset, (sign << 15) | 0x7c00, littleEndian);
+                return;
+            }
+
+            // Normalized mantissa processing
+            // Note: exponent > 0 is guaranteed here because:
+            // - We're in the normalized path (absVal >= FLOAT16_MIN_NORMAL = 2^-14)
+            // - Therefore exp32 >= -14, so exponent = exp32 + 15 >= 1
+            int mant32 = Float.floatToIntBits(fval) & 0x7fffff;
+
+            // Implement IEEE 754 round-to-nearest-even
+            int bitsToShift = mant32 & 0x1fff; // Bits [12:0] that will be lost
+            mantissa = mant32 >>> 13; // Bits [22:13] become the new mantissa
+
+            if (bitsToShift > 0x1000) {
+                // More than halfway: round up
+                mantissa++;
+            } else if (bitsToShift == 0x1000) {
+                // Exactly halfway: round to even (check LSB)
+                if ((mantissa & 1) != 0) {
+                    mantissa++; // Round up if odd
+                }
+            }
+            // else: Less than halfway, round down (mantissa already truncated)
+
+            // Handle rounding overflow
+            if (mantissa >= 0x400) {
+                exponent++;
+                mantissa = 0;
+                // DEFENSIVE CHECK (UNCOVERED): Mantissa rounding causes exponent overflow
+                // This check is unreachable through normal API usage because:
+                // - For this to execute: need exponent=30 initially, then mantissa rounds to 0x400
+                // - This requires Float32 values near 2^16 (approximately 65504-65536 range)
+                // - Guard at line 243 catches all values > 65504
+                // - Guard at line 239 catches all values >= 65520
+                // - Complete coverage: All overflow cases caught by guards before reaching here
+                // This defensive check is kept for defense-in-depth in case guards are modified.
+                // See UNCOVERED_CODE_EXPLANATION.md for full mathematical proof.
+                if (exponent >= 31) {
+                    // Overflow to infinity
+                    doWriteInt16(buf, offset, (sign << 15) | 0x7c00, littleEndian);
+                    return;
+                }
+            }
+        }
+
+        int bits = (sign << 15) | (exponent << 10) | mantissa;
+        doWriteInt16(buf, offset, bits, littleEndian);
+    }
+
     public static Float readFloat32(byte[] buf, int offset, boolean littleEndian) {
         long base = readUint32Primitive(buf, offset, littleEndian);
         return Float.valueOf(Float.intBitsToFloat((int) base));

rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeDataView.java

@@ -74,6 +74,7 @@ public static Object init(Context cx, Scriptable scope, boolean sealed) {
 
         constructor.definePrototypeProperty(
                 SymbolKey.TO_STRING_TAG, CLASS_NAME, DONTENUM | READONLY);
+        constructor.definePrototypeMethod(scope, "getFloat16", 1, NativeDataView::js_getFloat16);
         constructor.definePrototypeMethod(scope, "getFloat32", 1, NativeDataView::js_getFloat32);
         constructor.definePrototypeMethod(scope, "getFloat64", 1, NativeDataView::js_getFloat64);
         constructor.definePrototypeMethod(scope, "getInt8", 1, NativeDataView::js_getInt8);
@@ -85,6 +86,7 @@ public static Object init(Context cx, Scriptable scope, boolean sealed) {
         constructor.definePrototypeMethod(scope, "getBigInt64", 1, NativeDataView::js_getBigInt64);
         constructor.definePrototypeMethod(
                 scope, "getBigUint64", 1, NativeDataView::js_getBigUint64);
+        constructor.definePrototypeMethod(scope, "setFloat16", 2, NativeDataView::js_setFloat16);
         constructor.definePrototypeMethod(scope, "setFloat32", 2, NativeDataView::js_setFloat32);
         constructor.definePrototypeMethod(scope, "setFloat64", 2, NativeDataView::js_setFloat64);
         constructor.definePrototypeMethod(scope, "setInt8", 2, NativeDataView::js_setInt8);
@@ -239,6 +241,12 @@ private static Object js_getFloat64(
         return realThis.js_getFloat(cx, scope, 8, args);
     }
 
+    private static Object js_getFloat16(
+            Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
+        NativeDataView realThis = realThis(thisObj);
+        return realThis.js_getFloat(cx, scope, 2, args);
+    }
+
     private Object js_getFloat(Context cx, Scriptable scope, int bytes, Object[] args) {
         int pos = ScriptRuntime.toIndex(isArg(args, 0) ? args[0] : Undefined.instance);
 
@@ -254,6 +262,8 @@ private Object js_getFloat(Context cx, Scriptable scope, int bytes, Object[] arg
         }
 
         switch (bytes) {
+            case 2:
+                return ByteIo.readFloat16(arrayBuffer.buffer, offset + pos, littleEndian);
             case 4:
                 return ByteIo.readFloat32(arrayBuffer.buffer, offset + pos, littleEndian);
             case 8:
@@ -386,6 +396,13 @@ private static Object js_setFloat64(
         return Undefined.instance;
     }
 
+    private static Object js_setFloat16(
+            Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
+        NativeDataView realThis = realThis(thisObj);
+        realThis.js_setFloat(cx, scope, 2, args);
+        return Undefined.instance;
+    }
+
     private void js_setFloat(Context cx, Scriptable scope, int bytes, Object[] args) {
         int pos = ScriptRuntime.toIndex(isArg(args, 0) ? args[0] : Undefined.instance);
 
@@ -403,6 +420,9 @@ private void js_setFloat(Context cx, Scriptable scope, int bytes, Object[] args)
         }
 
         switch (bytes) {
+            case 2:
+                ByteIo.writeFloat16(arrayBuffer.buffer, offset + pos, val, littleEndian);
+                break;
             case 4:
                 ByteIo.writeFloat32(arrayBuffer.buffer, offset + pos, val, littleEndian);
                 break;