Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-canvas

Source of release 0.5.1

0.5.1 / src / half.lucb

## IEEE 754 binary16 conversion, for rgba16_float texel data. Round to nearest
## even; out-of-range values become infinities, NaN stays NaN.
from luce_std import math32

pub func to_half(value: f32) -> u16:
    let bits = value.bits()
    let sign = (u16)((bits >> 16) & 0x8000)
    let exponent = (i32)((bits >> 23) & 0xff) - 127 + 15
    let mantissa = bits & 0x7fffff
    if (bits & 0x7fffffff) > 0x7f800000:
        return sign | 0x7e00
    if exponent >= 31:
        return sign | 0x7c00
    if exponent <= 0:
        if exponent < -10:
            return sign
        let shifted = mantissa | 0x800000
        let shift = (u32)(14 - exponent)
        var half = (u16)(shifted >> shift)
        let remainder = shifted & ((1u32 << shift) - 1)
        let halfway = 1u32 << (shift - 1)
        if remainder > halfway or (remainder == halfway and (half & 1) == 1):
            half += 1
        return sign | half
    var half = (u16)(((u32)exponent << 10) | (mantissa >> 13))
    let remainder = mantissa & 0x1fff
    if remainder > 0x1000 or (remainder == 0x1000 and (half & 1) == 1):
        half += 1
    return sign | half

pub func from_half(half: u16) -> f32:
    let sign = ((u32)half & 0x8000) << 16
    var exponent = (i32)(((u32)half >> 10) & 0x1f)
    var mantissa = (u32)half & 0x3ff
    if exponent == 31:
        return f32.bits(sign | 0x7f800000 | (mantissa << 13))
    if exponent == 0:
        if mantissa == 0:
            return f32.bits(sign)
        exponent = 1
        while (mantissa & 0x400) == 0:
            mantissa <<= 1
            exponent -= 1
        mantissa &= 0x3ff
    return f32.bits(sign | ((u32)(exponent + 127 - 15) << 23) | (mantissa << 13))

test "half round trips and rounds":
    for value in [0.0f32, 1.0, -1.0, 0.5, 0.333251953125, 65504.0, 0.00006103515625, 0.000000059604645]:
        assert(from_half(to_half(value)) == value)
    assert(to_half(1.0) == 0x3c00 and to_half(-2.0) == 0xc000)
    assert(to_half(70000.0) == 0x7c00 and to_half(-70000.0) == 0xfc00)
    assert(from_half(0x7c00) == math32.infinity)
    assert(math32.is_nan(from_half(to_half(math32.nan))))
    # 1 + 2^-11 lies halfway between two halves and rounds to even (1.0).
    assert(to_half(1.00048828125) == 0x3c00)
    assert(to_half(1.00048828125 + 0.0000002) == 0x3c01)