@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.10

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.d.ts

@@ -0,0 +1,3 @@
+/** WGSL source for fp64 arithmetic helpers and raw binary64 subtraction. */
+export declare const fp64arithmeticWGSL = "struct Fp64ArithmeticUniforms {\n  ONE: f32,\n  SPLIT: f32,\n};\n\n@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\nstruct Fp64Bits {\n  sign: u32,\n  exponent: i32,\n  significand: vec2u,\n  isZero: bool,\n  isInf: bool,\n  isNan: bool,\n};\n#endif\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn fp64_nan(seed: f32) -> f32 {\n  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);\n  return bitcast<f32>(nanBits);\n}\n#endif\n\nfn fp64_u64_is_zero(value: vec2u) -> bool {\n  return value.x == 0u && value.y == 0u;\n}\n\nfn fp64_u64_compare(a: vec2u, b: vec2u) -> i32 {\n  if (a.x != b.x) {\n    return select(-1, 1, a.x > b.x);\n  }\n  if (a.y != b.y) {\n    return select(-1, 1, a.y > b.y);\n  }\n  return 0;\n}\n\nfn fp64_u64_add(a: vec2u, b: vec2u) -> vec2u {\n  let low = a.y + b.y;\n  let carry = select(0u, 1u, low < a.y);\n  return vec2u(a.x + b.x + carry, low);\n}\n\nfn fp64_u64_sub(a: vec2u, b: vec2u) -> vec2u {\n  let borrow = select(0u, 1u, a.y < b.y);\n  return vec2u(a.x - b.x - borrow, a.y - b.y);\n}\n\nfn fp64_u64_shift_left(value: vec2u, shift: u32) -> vec2u {\n  if (shift == 0u) {\n    return value;\n  }\n  if (shift < 32u) {\n    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);\n  }\n  if (shift == 32u) {\n    return vec2u(value.y, 0u);\n  }\n  if (shift < 64u) {\n    return vec2u(value.y << (shift - 32u), 0u);\n  }\n  return vec2u(0u);\n}\n\nfn fp64_u64_shift_right(value: vec2u, shift: u32) -> vec2u {\n  if (shift == 0u) {\n    return value;\n  }\n  if (shift < 32u) {\n    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));\n  }\n  if (shift == 32u) {\n    return vec2u(0u, value.x);\n  }\n  if (shift < 64u) {\n    return vec2u(0u, value.x >> (shift - 32u));\n  }\n  return vec2u(0u);\n}\n\nfn fp64_u64_get_bit(value: vec2u, bitIndex: u32) -> bool {\n  if (bitIndex >= 64u) {\n    return false;\n  }\n  if (bitIndex >= 32u) {\n    return ((value.x >> (bitIndex - 32u)) & 1u) != 0u;\n  }\n  return ((value.y >> bitIndex) & 1u) != 0u;\n}\n\nfn fp64_u64_has_bits_below(value: vec2u, bitCount: u32) -> bool {\n  if (bitCount == 0u) {\n    return false;\n  }\n  if (bitCount >= 64u) {\n    return !fp64_u64_is_zero(value);\n  }\n  if (bitCount > 32u) {\n    let highBitCount = bitCount - 32u;\n    let highMask = (1u << highBitCount) - 1u;\n    return value.y != 0u || (value.x & highMask) != 0u;\n  }\n  if (bitCount == 32u) {\n    return value.y != 0u;\n  }\n  let lowMask = (1u << bitCount) - 1u;\n  return (value.y & lowMask) != 0u;\n}\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\nfn fp64_u64_shift_right_sticky(value: vec2u, shift: u32) -> vec2u {\n  var shifted = fp64_u64_shift_right(value, shift);\n  if (fp64_u64_has_bits_below(value, shift)) {\n    shifted.y = shifted.y | 1u;\n  }\n  return shifted;\n}\n#endif\n\nfn fp64_u64_count_leading_zeros(value: vec2u) -> u32 {\n  if (value.x != 0u) {\n    return countLeadingZeros(value.x);\n  }\n  return 32u + countLeadingZeros(value.y);\n}\n\nfn fp64_round_shift_right_to_u32(value: vec2u, shift: u32) -> u32 {\n  if (shift == 0u) {\n    return value.y;\n  }\n\n  let truncated = fp64_u64_shift_right(value, shift);\n  var rounded = truncated.y;\n  let guard = fp64_u64_get_bit(value, shift - 1u);\n  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);\n  if (guard && (hasTrailingBits || (rounded & 1u) == 1u)) {\n    rounded = rounded + 1u;\n  }\n  return rounded;\n}\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\nfn fp64_round_shift_right(value: vec2u, shift: u32) -> vec2u {\n  if (shift == 0u) {\n    return value;\n  }\n\n  var rounded = fp64_u64_shift_right(value, shift);\n  let guard = fp64_u64_get_bit(value, shift - 1u);\n  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);\n  if (guard && (hasTrailingBits || (rounded.y & 1u) == 1u)) {\n    rounded = fp64_u64_add(rounded, vec2u(0u, 1u));\n  }\n  return rounded;\n}\n#endif\n\nfn fp64_make_f32_bits_from_u64(sign: u32, significand: vec2u, baseExponent: i32) -> u32 {\n  if (fp64_u64_is_zero(significand)) {\n    return sign << 31u;\n  }\n\n  let leadingZeros = fp64_u64_count_leading_zeros(significand);\n  let mostSignificantBit = 63u - leadingZeros;\n  var exponent = baseExponent + i32(mostSignificantBit);\n\n  if (exponent > 127) {\n    return (sign << 31u) | 0x7f800000u;\n  }\n\n  if (exponent >= -126) {\n    let shift = i32(mostSignificantBit) - 23;\n    var significand24: u32;\n    if (shift > 0) {\n      significand24 = fp64_round_shift_right_to_u32(significand, u32(shift));\n    } else {\n      significand24 = fp64_u64_shift_left(significand, u32(-shift)).y;\n    }\n\n    if (significand24 >= 0x1000000u) {\n      significand24 = significand24 >> 1u;\n      exponent = exponent + 1;\n      if (exponent > 127) {\n        return (sign << 31u) | 0x7f800000u;\n      }\n    }\n\n    return (sign << 31u) | (u32(exponent + 127) << 23u) | (significand24 & 0x7fffffu);\n  }\n\n  let scaleExponent = baseExponent + 149;\n  var mantissa: u32;\n  if (scaleExponent >= 0) {\n    mantissa = fp64_u64_shift_left(significand, u32(scaleExponent)).y;\n  } else {\n    mantissa = fp64_round_shift_right_to_u32(significand, u32(-scaleExponent));\n  }\n\n  if (mantissa >= 0x800000u) {\n    return (sign << 31u) | 0x00800000u;\n  }\n  return (sign << 31u) | mantissa;\n}\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\nfn fp64_decode_bits(bits: vec2u) -> Fp64Bits {\n  let sign = bits.x >> 31u;\n  let exponentBits = (bits.x >> 20u) & 0x7ffu;\n  let fractionHigh = bits.x & 0xfffffu;\n  let fractionLow = bits.y;\n  let fraction = vec2u(fractionHigh, fractionLow);\n\n  if (exponentBits == 0x7ffu) {\n    let isInf = fp64_u64_is_zero(fraction);\n    return Fp64Bits(sign, 0, vec2u(0u), false, isInf, !isInf);\n  }\n\n  if (exponentBits == 0u) {\n    let isZero = fp64_u64_is_zero(fraction);\n    return Fp64Bits(sign, -1022, fraction, isZero, false, false);\n  }\n\n  return Fp64Bits(sign, i32(exponentBits) - 1023, vec2u((1u << 20u) | fractionHigh, fractionLow), false, false, false);\n}\n\nfn fp64_finite_magnitude_compare(a: Fp64Bits, b: Fp64Bits) -> i32 {\n  if (a.exponent != b.exponent) {\n    return select(-1, 1, a.exponent > b.exponent);\n  }\n  return fp64_u64_compare(a.significand, b.significand);\n}\n#endif\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\nstruct Fp64RawF32Bits {\n  sign: u32,\n  baseExponent: i32,\n  significand: u32,\n  isZero: bool,\n  isInf: bool,\n  isNan: bool,\n};\n\n// Decode an f32 as (-1)^sign * significand * 2^baseExponent. This shared\n// integer representation lets normalization remain independent of the\n// selected double-single arithmetic implementation.\nfn fp64_decode_raw_f32_bits(bits: u32) -> Fp64RawF32Bits {\n  let sign = bits >> 31u;\n  let exponentBits = (bits >> 23u) & 0xffu;\n  let fraction = bits & 0x7fffffu;\n\n  if (exponentBits == 0xffu) {\n    return Fp64RawF32Bits(sign, 0, 0u, false, fraction == 0u, fraction != 0u);\n  }\n  if (exponentBits == 0u) {\n    return Fp64RawF32Bits(sign, -149, fraction, fraction == 0u, false, false);\n  }\n  return Fp64RawF32Bits(\n    sign,\n    i32(exponentBits) - 150,\n    0x800000u | fraction,\n    false,\n    false,\n    false\n  );\n}\n\nfn fp64_raw_f32_magnitude_compare(aBits: u32, bBits: u32) -> i32 {\n  let aMagnitude = aBits & 0x7fffffffu;\n  let bMagnitude = bBits & 0x7fffffffu;\n  if (aMagnitude == bMagnitude) {\n    return 0;\n  }\n  return select(-1, 1, aMagnitude > bMagnitude);\n}\n\nfn fp64_make_raw_residual_f32_bits(\n  exactSign: u32,\n  exactMagnitude: vec2u,\n  exactBaseExponent: i32,\n  highBits: u32\n) -> u32 {\n  if (fp64_u64_is_zero(exactMagnitude)) {\n    return 0u;\n  }\n\n  let high = fp64_decode_raw_f32_bits(highBits);\n  if (high.isInf || high.isNan) {\n    return 0u;\n  }\n  if (high.isZero) {\n    return fp64_make_f32_bits_from_u64(exactSign, exactMagnitude, exactBaseExponent);\n  }\n\n  let commonBaseExponent = min(exactBaseExponent, high.baseExponent);\n  let exactShift = exactBaseExponent - commonBaseExponent;\n  let highShift = high.baseExponent - commonBaseExponent;\n  if (exactShift >= 64 || highShift >= 64) {\n    return 0u;\n  }\n\n  let exactAligned = fp64_u64_shift_left(exactMagnitude, u32(exactShift));\n  let highAligned = fp64_u64_shift_left(vec2u(0u, high.significand), u32(highShift));\n  let comparison = fp64_u64_compare(exactAligned, highAligned);\n  if (comparison == 0) {\n    return 0u;\n  }\n\n  var residualSign = exactSign;\n  var residualMagnitude: vec2u;\n  if (comparison > 0) {\n    residualMagnitude = fp64_u64_sub(exactAligned, highAligned);\n  } else {\n    residualSign = exactSign ^ 1u;\n    residualMagnitude = fp64_u64_sub(highAligned, exactAligned);\n  }\n  return fp64_make_f32_bits_from_u64(\n    residualSign,\n    residualMagnitude,\n    commonBaseExponent\n  );\n}\n\nfn fp64_split_raw_accumulator_bits(\n  sign: u32,\n  magnitude: vec2u,\n  baseExponent: i32\n) -> vec2u {\n  if (fp64_u64_is_zero(magnitude)) {\n    return vec2u(0u);\n  }\n  let highBits = fp64_make_f32_bits_from_u64(sign, magnitude, baseExponent);\n  let rawLowBits = fp64_make_raw_residual_f32_bits(sign, magnitude, baseExponent, highBits);\n  let lowBits = select(rawLowBits, 0u, (rawLowBits & 0x7fffffffu) == 0u);\n  if ((highBits & 0x7fffffffu) == 0u && (lowBits & 0x7fffffffu) == 0u) {\n    return vec2u(0u);\n  }\n  return vec2u(highBits, lowBits);\n}\n#endif\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\n// Round an arithmetic accumulator to binary64 before splitting it. The\n// aligned add/subtract paths retain three guard bits plus a sticky bit, which\n// is sufficient for round-to-nearest-even at the binary64 boundary.\nfn fp64_split_binary64_accumulator_bits(\n  sign: u32,\n  magnitude: vec2u,\n  baseExponent: i32\n) -> vec2u {\n  if (fp64_u64_is_zero(magnitude)) {\n    return vec2u(0u);\n  }\n\n  let mostSignificantBit = 63u - fp64_u64_count_leading_zeros(magnitude);\n  let exponent = baseExponent + i32(mostSignificantBit);\n  if (exponent > 1023) {\n    return vec2u((sign << 31u) | 0x7f800000u, 0u);\n  }\n\n  var roundedMagnitude = magnitude;\n  var roundedBaseExponent = baseExponent;\n  if (exponent >= -1022) {\n    if (mostSignificantBit > 52u) {\n      let shift = mostSignificantBit - 52u;\n      roundedMagnitude = fp64_round_shift_right(magnitude, shift);\n      roundedBaseExponent = baseExponent + i32(shift);\n    }\n  } else {\n    let shift = -1074 - baseExponent;\n    if (shift > 0) {\n      roundedMagnitude = fp64_round_shift_right(magnitude, u32(shift));\n      roundedBaseExponent = -1074;\n    }\n  }\n\n  if (fp64_u64_is_zero(roundedMagnitude)) {\n    return vec2u(0u);\n  }\n  return fp64_split_raw_accumulator_bits(sign, roundedMagnitude, roundedBaseExponent);\n}\n#endif\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn fp64_add_raw_f32_bits(aBits: u32, bBits: u32) -> vec2u {\n  let a = fp64_decode_raw_f32_bits(aBits);\n  let b = fp64_decode_raw_f32_bits(bBits);\n\n  if (a.isNan || b.isNan) {\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf || b.isInf) {\n    if (a.isInf && b.isInf && a.sign != b.sign) {\n      return vec2u(0x7fc00000u, 0u);\n    }\n    return select(vec2u(bBits, 0u), vec2u(aBits, 0u), a.isInf);\n  }\n  if (a.isZero && b.isZero) {\n    return vec2u(0u);\n  }\n  if (a.isZero) {\n    return vec2u(bBits, 0u);\n  }\n  if (b.isZero) {\n    return vec2u(aBits, 0u);\n  }\n\n  let exponentDifference = abs(a.baseExponent - b.baseExponent);\n  if (exponentDifference > 25) {\n    if (fp64_raw_f32_magnitude_compare(aBits, bBits) >= 0) {\n      return vec2u(aBits, bBits);\n    }\n    return vec2u(bBits, aBits);\n  }\n\n  let commonBaseExponent = min(a.baseExponent, b.baseExponent);\n  let aMagnitude = fp64_u64_shift_left(\n    vec2u(0u, a.significand),\n    u32(a.baseExponent - commonBaseExponent)\n  );\n  let bMagnitude = fp64_u64_shift_left(\n    vec2u(0u, b.significand),\n    u32(b.baseExponent - commonBaseExponent)\n  );\n\n  var resultSign = a.sign;\n  var resultMagnitude: vec2u;\n  if (a.sign == b.sign) {\n    resultMagnitude = fp64_u64_add(aMagnitude, bMagnitude);\n  } else {\n    let comparison = fp64_u64_compare(aMagnitude, bMagnitude);\n    if (comparison == 0) {\n      return vec2u(0u);\n    }\n    if (comparison > 0) {\n      resultMagnitude = fp64_u64_sub(aMagnitude, bMagnitude);\n    } else {\n      resultSign = b.sign;\n      resultMagnitude = fp64_u64_sub(bMagnitude, aMagnitude);\n    }\n  }\n\n  return fp64_split_raw_accumulator_bits(\n    resultSign,\n    resultMagnitude,\n    commonBaseExponent\n  );\n}\n#endif\n\n#ifndef LUMA_FP64_F32_INPUT_ONLY\nfn fp64_add_aligned_magnitudes_to_fp64_bits(\n  sign: u32,\n  larger: Fp64Bits,\n  smaller: Fp64Bits\n) -> vec2u {\n  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);\n  let smallSignificand = fp64_u64_shift_right_sticky(\n    fp64_u64_shift_left(smaller.significand, 3u),\n    u32(larger.exponent - smaller.exponent)\n  );\n  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);\n  return fp64_split_binary64_accumulator_bits(\n    sign,\n    resultSignificand,\n    larger.exponent - 55\n  );\n}\n\nfn fp64_sub_aligned_magnitudes_to_fp64_bits(\n  sign: u32,\n  larger: Fp64Bits,\n  smaller: Fp64Bits\n) -> vec2u {\n  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);\n  let smallSignificand = fp64_u64_shift_right_sticky(\n    fp64_u64_shift_left(smaller.significand, 3u),\n    u32(larger.exponent - smaller.exponent)\n  );\n  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);\n  return fp64_split_binary64_accumulator_bits(\n    sign,\n    resultSignificand,\n    larger.exponent - 55\n  );\n}\n\nfn fp64_add_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {\n  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);\n  let smallSignificand = fp64_u64_shift_right_sticky(\n    fp64_u64_shift_left(smaller.significand, 3u),\n    u32(larger.exponent - smaller.exponent)\n  );\n  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);\n  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);\n}\n\nfn fp64_sub_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {\n  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);\n  let smallSignificand = fp64_u64_shift_right_sticky(\n    fp64_u64_shift_left(smaller.significand, 3u),\n    u32(larger.exponent - smaller.exponent)\n  );\n  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);\n  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);\n}\n\n// Subtract two raw binary64 values and round the exact result once to f32.\n// The input words are canonical high/low words: .x contains sign/exponent/high\n// fraction bits, and .y contains the low 32 fraction bits.\nfn sub_fp64u32_to_f32_bits(aBits: vec2u, bBits: vec2u) -> u32 {\n  let a = fp64_decode_bits(aBits);\n  let b = fp64_decode_bits(bBits);\n  let bSubtractionSign = b.sign ^ 1u;\n\n  if (a.isNan || b.isNan) {\n    return 0x7fc00000u;\n  }\n  if (a.isInf && b.isInf) {\n    if (a.sign == bSubtractionSign) {\n      return (a.sign << 31u) | 0x7f800000u;\n    }\n    return 0x7fc00000u;\n  }\n  if (a.isInf) {\n    return (a.sign << 31u) | 0x7f800000u;\n  }\n  if (b.isInf) {\n    return (bSubtractionSign << 31u) | 0x7f800000u;\n  }\n  if (a.isZero && b.isZero) {\n    return select(0u, 0x80000000u, a.sign == 1u && b.sign == 0u);\n  }\n\n  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);\n  if (a.sign == bSubtractionSign) {\n    if (magnitudeComparison >= 0) {\n      return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, a, b);\n    }\n    return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, b, a);\n  }\n\n  if (magnitudeComparison == 0) {\n    return 0u;\n  }\n  if (magnitudeComparison > 0) {\n    return fp64_sub_aligned_magnitudes_to_f32_bits(a.sign, a, b);\n  }\n  return fp64_sub_aligned_magnitudes_to_f32_bits(bSubtractionSign, b, a);\n}\n\nfn sub_fp64u32_to_f32(aBits: vec2u, bBits: vec2u) -> f32 {\n  return bitcast<f32>(sub_fp64u32_to_f32_bits(aBits, bBits));\n}\n\n// Subtract two raw binary64 values, round once to binary64, then split the\n// result into normalized f32 limbs. Finite results must fit within the f32\n// exponent range; larger magnitudes map to infinity and smaller magnitudes\n// map to zero. The input words use canonical high/low word order.\nfn sub_fp64u32_to_fp64_bits(aBits: vec2u, bBits: vec2u) -> vec2u {\n  let a = fp64_decode_bits(aBits);\n  let b = fp64_decode_bits(bBits);\n  let bSubtractionSign = b.sign ^ 1u;\n\n  if (a.isNan || b.isNan) {\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf && b.isInf) {\n    if (a.sign == bSubtractionSign) {\n      return vec2u((a.sign << 31u) | 0x7f800000u, 0u);\n    }\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf) {\n    return vec2u((a.sign << 31u) | 0x7f800000u, 0u);\n  }\n  if (b.isInf) {\n    return vec2u((bSubtractionSign << 31u) | 0x7f800000u, 0u);\n  }\n  if (a.isZero && b.isZero) {\n    return vec2u(0u);\n  }\n\n  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);\n  if (a.sign == bSubtractionSign) {\n    if (magnitudeComparison >= 0) {\n      return fp64_add_aligned_magnitudes_to_fp64_bits(a.sign, a, b);\n    }\n    return fp64_add_aligned_magnitudes_to_fp64_bits(a.sign, b, a);\n  }\n\n  if (magnitudeComparison == 0) {\n    return vec2u(0u);\n  }\n  if (magnitudeComparison > 0) {\n    return fp64_sub_aligned_magnitudes_to_fp64_bits(a.sign, a, b);\n  }\n  return fp64_sub_aligned_magnitudes_to_fp64_bits(bSubtractionSign, b, a);\n}\n\nfn sub_fp64u32_to_fp64(aBits: vec2u, bBits: vec2u) -> vec2f {\n  let resultBits = sub_fp64u32_to_fp64_bits(aBits, bBits);\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n#endif\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\n// Zero bits the compiler cannot prove are zero: the uniform ONE is 1.0 at runtime.\n// Some WGSL backends compile with fast-math flags (e.g. Firefox WebGPU on Windows, where DXC\n// runs without IEEE strictness). There, a float barrier such as `x + ONE * 0.0` folds away,\n// and the error terms of the double-single transforms are re-associated and lost. An integer\n// OR is opaque to floating-point simplification, and unlike XOR two nested barriers do not\n// cancel. Each rounding step the transforms rely on gets its own barrier.\nfn fp64_runtime_zero_bits() -> u32 {\n  return bitcast<u32>(fp64arithmetic.ONE) ^ 0x3f800000u;\n}\n\nfn fp64_runtime_zero() -> f32 {\n  return bitcast<f32>(fp64_runtime_zero_bits());\n}\n\nfn prevent_fp64_optimization(value: f32) -> f32 {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  return bitcast<f32>(bitcast<u32>(value) | fp64_runtime_zero_bits());\n#else\n  return value;\n#endif\n}\n#endif\n\n#ifdef LUMA_FP64_INTEGER_ARITHMETIC\nstruct Fp64F32Bits {\n  sign: u32,\n  baseExponent: i32,\n  significand: u32,\n  isZero: bool,\n  isInf: bool,\n  isNan: bool,\n};\n\n// Decode an f32 as (-1)^sign * significand * 2^baseExponent.\nfn fp64_decode_f32_bits(bits: u32) -> Fp64F32Bits {\n  let sign = bits >> 31u;\n  let exponentBits = (bits >> 23u) & 0xffu;\n  let fraction = bits & 0x7fffffu;\n\n  if (exponentBits == 0xffu) {\n    return Fp64F32Bits(sign, 0, 0u, false, fraction == 0u, fraction != 0u);\n  }\n  if (exponentBits == 0u) {\n    return Fp64F32Bits(sign, -149, fraction, fraction == 0u, false, false);\n  }\n  return Fp64F32Bits(sign, i32(exponentBits) - 150, 0x800000u | fraction, false, false, false);\n}\n\nfn fp64_f32_magnitude_compare(aBits: u32, bBits: u32) -> i32 {\n  let aMagnitude = aBits & 0x7fffffffu;\n  let bMagnitude = bBits & 0x7fffffffu;\n  if (aMagnitude == bMagnitude) {\n    return 0;\n  }\n  return select(-1, 1, aMagnitude > bMagnitude);\n}\n\nfn fp64_make_residual_f32_bits(\n  exactSign: u32,\n  exactMagnitude: vec2u,\n  exactBaseExponent: i32,\n  highBits: u32\n) -> u32 {\n  if (fp64_u64_is_zero(exactMagnitude)) {\n    return 0u;\n  }\n\n  let high = fp64_decode_f32_bits(highBits);\n  if (high.isInf || high.isNan) {\n    return exactSign << 31u;\n  }\n  if (high.isZero) {\n    return fp64_make_f32_bits_from_u64(exactSign, exactMagnitude, exactBaseExponent);\n  }\n\n  let commonBaseExponent = min(exactBaseExponent, high.baseExponent);\n  let exactShift = exactBaseExponent - commonBaseExponent;\n  let highShift = high.baseExponent - commonBaseExponent;\n\n  // A normal two-sum/two-product residual never needs a shift this large.\n  // This guard gives deterministic underflow behavior outside that contract.\n  if (exactShift >= 64 || highShift >= 64) {\n    return exactSign << 31u;\n  }\n\n  let exactAligned = fp64_u64_shift_left(exactMagnitude, u32(exactShift));\n  let highAligned = fp64_u64_shift_left(vec2u(0u, high.significand), u32(highShift));\n  let comparison = fp64_u64_compare(exactAligned, highAligned);\n  if (comparison == 0) {\n    return 0u;\n  }\n\n  var residualSign = exactSign;\n  var residualMagnitude: vec2u;\n  if (comparison > 0) {\n    residualMagnitude = fp64_u64_sub(exactAligned, highAligned);\n  } else {\n    residualSign = exactSign ^ 1u;\n    residualMagnitude = fp64_u64_sub(highAligned, exactAligned);\n  }\n  return fp64_make_f32_bits_from_u64(\n    residualSign,\n    residualMagnitude,\n    commonBaseExponent\n  );\n}\n\nfn fp64_split_accumulator_bits(\n  sign: u32,\n  magnitude: vec2u,\n  baseExponent: i32\n) -> vec2u {\n  let highBits = fp64_make_f32_bits_from_u64(sign, magnitude, baseExponent);\n  let lowBits = fp64_make_residual_f32_bits(sign, magnitude, baseExponent, highBits);\n  return vec2u(highBits, lowBits);\n}\n\nfn fp64_two_sum_integer_bits(aBits: u32, bBits: u32) -> vec2u {\n  let a = fp64_decode_f32_bits(aBits);\n  let b = fp64_decode_f32_bits(bBits);\n\n  if (a.isNan || b.isNan) {\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf || b.isInf) {\n    if (a.isInf && b.isInf && a.sign != b.sign) {\n      return vec2u(0x7fc00000u, 0u);\n    }\n    return select(vec2u(bBits, 0u), vec2u(aBits, 0u), a.isInf);\n  }\n  if (a.isZero && b.isZero) {\n    return vec2u((a.sign & b.sign) << 31u, 0u);\n  }\n  if (a.isZero) {\n    return vec2u(bBits, 0u);\n  }\n  if (b.isZero) {\n    return vec2u(aBits, 0u);\n  }\n\n  let exponentDifference = select(\n    b.baseExponent - a.baseExponent,\n    a.baseExponent - b.baseExponent,\n    a.baseExponent >= b.baseExponent\n  );\n\n  // Beyond half an ulp, rounding cannot change the larger operand. Returning\n  // the smaller operand intact also avoids an unbounded integer alignment.\n  // At a power-of-two boundary the spacing below the larger operand is half\n  // the spacing above it, so an opposite-sign gap-25 operand can still change\n  // the rounded high limb. Gap 26 is the first universally safe early-out.\n  if (exponentDifference > 25) {\n    if (fp64_f32_magnitude_compare(aBits, bBits) >= 0) {\n      return vec2u(aBits, bBits);\n    }\n    return vec2u(bBits, aBits);\n  }\n\n  let commonBaseExponent = min(a.baseExponent, b.baseExponent);\n  let aMagnitude = fp64_u64_shift_left(\n    vec2u(0u, a.significand),\n    u32(a.baseExponent - commonBaseExponent)\n  );\n  let bMagnitude = fp64_u64_shift_left(\n    vec2u(0u, b.significand),\n    u32(b.baseExponent - commonBaseExponent)\n  );\n\n  var resultSign = a.sign;\n  var resultMagnitude: vec2u;\n  if (a.sign == b.sign) {\n    resultMagnitude = fp64_u64_add(aMagnitude, bMagnitude);\n  } else {\n    let comparison = fp64_u64_compare(aMagnitude, bMagnitude);\n    if (comparison == 0) {\n      return vec2u(0u, 0u);\n    }\n    if (comparison > 0) {\n      resultMagnitude = fp64_u64_sub(aMagnitude, bMagnitude);\n    } else {\n      resultSign = b.sign;\n      resultMagnitude = fp64_u64_sub(bMagnitude, aMagnitude);\n    }\n  }\n\n  return fp64_split_accumulator_bits(resultSign, resultMagnitude, commonBaseExponent);\n}\n\nfn fp64_two_sum_integer(a: f32, b: f32) -> vec2f {\n  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bitcast<u32>(b));\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\nfn fp64_multiply_significands(a: u32, b: u32) -> vec2u {\n  let aLow = a & 0xffffu;\n  let aHigh = a >> 16u;\n  let bLow = b & 0xffffu;\n  let bHigh = b >> 16u;\n  let lowProduct = aLow * bLow;\n  let crossProduct = aLow * bHigh + aHigh * bLow;\n  let highProduct = aHigh * bHigh;\n\n  var result = vec2u(0u, lowProduct);\n  result = fp64_u64_add(\n    result,\n    fp64_u64_shift_left(vec2u(0u, crossProduct), 16u)\n  );\n  result = fp64_u64_add(result, vec2u(highProduct, 0u));\n  return result;\n}\n\nfn fp64_two_prod_integer_bits(aBits: u32, bBits: u32) -> vec2u {\n  let a = fp64_decode_f32_bits(aBits);\n  let b = fp64_decode_f32_bits(bBits);\n  let resultSign = a.sign ^ b.sign;\n\n  if (a.isNan || b.isNan || ((a.isZero || b.isZero) && (a.isInf || b.isInf))) {\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf || b.isInf) {\n    return vec2u((resultSign << 31u) | 0x7f800000u, resultSign << 31u);\n  }\n  if (a.isZero || b.isZero) {\n    return vec2u(resultSign << 31u, resultSign << 31u);\n  }\n\n  let magnitude = fp64_multiply_significands(a.significand, b.significand);\n  return fp64_split_accumulator_bits(\n    resultSign,\n    magnitude,\n    a.baseExponent + b.baseExponent\n  );\n}\n\nfn fp64_two_prod_integer(a: f32, b: f32) -> vec2f {\n  let resultBits = fp64_two_prod_integer_bits(bitcast<u32>(a), bitcast<u32>(b));\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\nfn fp64_round_add_integer(a: f32, b: f32) -> f32 {\n  return fp64_two_sum_integer(a, b).x;\n}\n\nfn fp64_round_mul_integer(a: f32, b: f32) -> f32 {\n  return fp64_two_prod_integer(a, b).x;\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn fp64_f32_finite_exponent(value: Fp64F32Bits) -> i32 {\n  let mostSignificantBit = 31u - countLeadingZeros(value.significand);\n  return value.baseExponent + i32(mostSignificantBit);\n}\n\nfn fp64_scale_f32_integer(value: f32, exponent: i32) -> f32 {\n  let decoded = fp64_decode_f32_bits(bitcast<u32>(value));\n  if (decoded.isZero || decoded.isInf || decoded.isNan) {\n    return value;\n  }\n  let resultBits = fp64_make_f32_bits_from_u64(\n    decoded.sign,\n    vec2u(0u, decoded.significand),\n    decoded.baseExponent + exponent\n  );\n  return bitcast<f32>(resultBits);\n}\n\n// Divide normalized significands so the hardware operation cannot overflow,\n// underflow, or flush a subnormal result. Reapply the exponent with integer\n// packing, which also produces subnormal correction limbs without relying on\n// floating-point arithmetic to preserve them.\nfn fp64_divide_f32_integer(aValue: f32, bValue: f32) -> f32 {\n  let a = fp64_decode_f32_bits(bitcast<u32>(aValue));\n  let b = fp64_decode_f32_bits(bitcast<u32>(bValue));\n  if (a.isZero || b.isZero || a.isInf || b.isInf || a.isNan || b.isNan) {\n    return aValue / bValue;\n  }\n\n  let aMostSignificantBit = 31u - countLeadingZeros(a.significand);\n  let bMostSignificantBit = 31u - countLeadingZeros(b.significand);\n  let normalizedABits = fp64_make_f32_bits_from_u64(\n    a.sign,\n    vec2u(0u, a.significand),\n    -i32(aMostSignificantBit)\n  );\n  let normalizedBBits = fp64_make_f32_bits_from_u64(\n    b.sign,\n    vec2u(0u, b.significand),\n    -i32(bMostSignificantBit)\n  );\n  let normalizedQuotient = bitcast<f32>(normalizedABits) / bitcast<f32>(normalizedBBits);\n  let quotient = fp64_decode_f32_bits(bitcast<u32>(normalizedQuotient));\n  let exponentShift =\n    a.baseExponent + i32(aMostSignificantBit) -\n    b.baseExponent - i32(bMostSignificantBit);\n  let quotientBits = fp64_make_f32_bits_from_u64(\n    quotient.sign,\n    vec2u(0u, quotient.significand),\n    quotient.baseExponent + exponentShift\n  );\n  return bitcast<f32>(quotientBits);\n}\n#endif\n\n\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn split(a: f32) -> vec2f {\n  let aBits = bitcast<u32>(a);\n  let decoded = fp64_decode_f32_bits(aBits);\n  if (decoded.isZero || decoded.isInf || decoded.isNan) {\n    return vec2f(a, 0.0);\n  }\n\n  var roundedHigh = decoded.significand >> 12u;\n  let remainder = decoded.significand & 0xfffu;\n  if (remainder > 0x800u || (remainder == 0x800u && (roundedHigh & 1u) == 1u)) {\n    roundedHigh = roundedHigh + 1u;\n  }\n  var highMagnitude = vec2u(0u, roundedHigh << 12u);\n  var highBits = fp64_make_f32_bits_from_u64(\n    decoded.sign,\n    highMagnitude,\n    decoded.baseExponent\n  );\n  // Rounding the high limb of a maximum-exponent value can overflow even\n  // though the original value is finite. Truncate only in that boundary case\n  // so split remains an exact finite decomposition.\n  if (fp64_decode_f32_bits(highBits).isInf) {\n    roundedHigh = decoded.significand >> 12u;\n    highMagnitude = vec2u(0u, roundedHigh << 12u);\n    highBits = fp64_make_f32_bits_from_u64(\n      decoded.sign,\n      highMagnitude,\n      decoded.baseExponent\n    );\n  }\n  let lowBits = fp64_make_residual_f32_bits(\n    decoded.sign,\n    vec2u(0u, decoded.significand),\n    decoded.baseExponent,\n    highBits\n  );\n  return vec2f(bitcast<f32>(highBits), bitcast<f32>(lowBits));\n}\n\nfn split2(a: vec2f) -> vec2f {\n  var result = split(a.x);\n  result.y = fp64_round_add_integer(result.y, a.y);\n  return result;\n}\n#endif\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn quickTwoSum(a: f32, b: f32) -> vec2f {\n  return fp64_two_sum_integer(a, b);\n}\n#endif\n\nfn twoSum(a: f32, b: f32) -> vec2f {\n  return fp64_two_sum_integer(a, b);\n}\n\nfn twoSub(a: f32, b: f32) -> vec2f {\n  let bBits = bitcast<u32>(b) ^ 0x80000000u;\n  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bBits);\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn twoSqr(a: f32) -> vec2f {\n  return fp64_two_prod_integer(a, a);\n}\n\nfn twoProd(a: f32, b: f32) -> vec2f {\n  return fp64_two_prod_integer(a, b);\n}\n#endif\n\nstruct Fp64IntegerAccumulator {\n  sign: u32,\n  magnitude: vec2u,\n};\n\nfn fp64_accumulate_f32_integer(\n  accumulator: Fp64IntegerAccumulator,\n  value: Fp64F32Bits,\n  commonBaseExponent: i32\n) -> Fp64IntegerAccumulator {\n  if (value.isZero) {\n    return accumulator;\n  }\n\n  let magnitude = fp64_u64_shift_left(\n    vec2u(0u, value.significand),\n    u32(value.baseExponent - commonBaseExponent)\n  );\n  if (fp64_u64_is_zero(accumulator.magnitude)) {\n    return Fp64IntegerAccumulator(value.sign, magnitude);\n  }\n  if (accumulator.sign == value.sign) {\n    return Fp64IntegerAccumulator(\n      accumulator.sign,\n      fp64_u64_add(accumulator.magnitude, magnitude)\n    );\n  }\n\n  let comparison = fp64_u64_compare(accumulator.magnitude, magnitude);\n  if (comparison == 0) {\n    return Fp64IntegerAccumulator(0u, vec2u(0u));\n  }\n  if (comparison > 0) {\n    return Fp64IntegerAccumulator(\n      accumulator.sign,\n      fp64_u64_sub(accumulator.magnitude, magnitude)\n    );\n  }\n  return Fp64IntegerAccumulator(\n    value.sign,\n    fp64_u64_sub(magnitude, accumulator.magnitude)\n  );\n}\n\nfn fp64_sum_integer_unfused(a: vec2f, b: vec2f) -> vec2f {\n  var sum = fp64_two_sum_integer(a.x, b.x);\n  let lowSum = fp64_two_sum_integer(a.y, b.y);\n  sum.y = fp64_round_add_integer(sum.y, lowSum.x);\n  sum = fp64_two_sum_integer(sum.x, sum.y);\n  sum.y = fp64_round_add_integer(sum.y, lowSum.y);\n  return fp64_two_sum_integer(sum.x, sum.y);\n}\n\nfn sum_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let aHigh = fp64_decode_f32_bits(bitcast<u32>(a.x));\n  let aLow = fp64_decode_f32_bits(bitcast<u32>(a.y));\n  let bHigh = fp64_decode_f32_bits(bitcast<u32>(b.x));\n  let bLow = fp64_decode_f32_bits(bitcast<u32>(b.y));\n  if (\n    aHigh.isInf || aHigh.isNan || aLow.isInf || aLow.isNan ||\n    bHigh.isInf || bHigh.isNan || bLow.isInf || bLow.isNan\n  ) {\n    return fp64_sum_integer_unfused(a, b);\n  }\n\n  var minimumBaseExponent = 2147483647;\n  var maximumBaseExponent = -2147483647;\n  if (!aHigh.isZero) {\n    minimumBaseExponent = min(minimumBaseExponent, aHigh.baseExponent);\n    maximumBaseExponent = max(maximumBaseExponent, aHigh.baseExponent);\n  }\n  if (!aLow.isZero) {\n    minimumBaseExponent = min(minimumBaseExponent, aLow.baseExponent);\n    maximumBaseExponent = max(maximumBaseExponent, aLow.baseExponent);\n  }\n  if (!bHigh.isZero) {\n    minimumBaseExponent = min(minimumBaseExponent, bHigh.baseExponent);\n    maximumBaseExponent = max(maximumBaseExponent, bHigh.baseExponent);\n  }\n  if (!bLow.isZero) {\n    minimumBaseExponent = min(minimumBaseExponent, bLow.baseExponent);\n    maximumBaseExponent = max(maximumBaseExponent, bLow.baseExponent);\n  }\n  if (maximumBaseExponent < minimumBaseExponent) {\n    return vec2f(0.0, 0.0);\n  }\n\n  // Four 24-bit significands spanning at most 38 bits fit in the 64-bit\n  // accumulator, including the two extra carry bits needed by their sum.\n  if (maximumBaseExponent - minimumBaseExponent > 38) {\n    return fp64_sum_integer_unfused(a, b);\n  }\n\n  var accumulator = Fp64IntegerAccumulator(0u, vec2u(0u));\n  accumulator = fp64_accumulate_f32_integer(accumulator, aHigh, minimumBaseExponent);\n  accumulator = fp64_accumulate_f32_integer(accumulator, aLow, minimumBaseExponent);\n  accumulator = fp64_accumulate_f32_integer(accumulator, bHigh, minimumBaseExponent);\n  accumulator = fp64_accumulate_f32_integer(accumulator, bLow, minimumBaseExponent);\n  let resultBits = fp64_split_accumulator_bits(\n    accumulator.sign,\n    accumulator.magnitude,\n    minimumBaseExponent\n  );\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\nfn sub_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let negatedB = vec2f(\n    bitcast<f32>(bitcast<u32>(b.x) ^ 0x80000000u),\n    bitcast<f32>(bitcast<u32>(b.y) ^ 0x80000000u)\n  );\n  return sum_fp64(a, negatedB);\n}\n\nfn mul_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var product = fp64_two_prod_integer(a.x, b.x);\n  let crossProduct1 = fp64_round_mul_integer(a.x, b.y);\n  product = sum_fp64(product, vec2f(crossProduct1, 0.0));\n  let crossProduct2 = fp64_round_mul_integer(a.y, b.x);\n  return sum_fp64(product, vec2f(crossProduct2, 0.0));\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn fp64_scale_fp64_integer(value: vec2f, exponent: i32) -> vec2f {\n  let high = fp64_scale_f32_integer(value.x, exponent);\n  let low = fp64_scale_f32_integer(value.y, exponent);\n  return sum_fp64(vec2f(high, 0.0), vec2f(low, 0.0));\n}\n\nfn fp64_div_fp64_normalized(a: vec2f, b: vec2f) -> vec2f {\n  let quotientHigh = fp64_divide_f32_integer(a.x, b.x);\n  var quotient = vec2f(quotientHigh, 0.0);\n\n  let remainder = sub_fp64(a, mul_fp64(b, quotient));\n  let quotientLow = fp64_divide_f32_integer(remainder.x, b.x);\n  quotient = sum_fp64(quotient, vec2f(quotientLow, 0.0));\n\n  let secondRemainder = sub_fp64(a, mul_fp64(b, quotient));\n  let correction = fp64_divide_f32_integer(secondRemainder.x, b.x);\n  return sum_fp64(quotient, vec2f(correction, 0.0));\n}\n\nfn div_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let decodedA = fp64_decode_f32_bits(bitcast<u32>(a.x));\n  let decodedB = fp64_decode_f32_bits(bitcast<u32>(b.x));\n  if (\n    decodedA.isZero || decodedB.isZero ||\n    decodedA.isInf || decodedB.isInf ||\n    decodedA.isNan || decodedB.isNan\n  ) {\n    return fp64_div_fp64_normalized(a, b);\n  }\n\n  let exponentA = fp64_f32_finite_exponent(decodedA);\n  let exponentB = fp64_f32_finite_exponent(decodedB);\n  // Correct the quotient near unity so b * q and the remainder stay clear of\n  // both f32 underflow and overflow. The exponent difference is applied once.\n  let normalizedA = fp64_scale_fp64_integer(a, -exponentA);\n  let normalizedB = fp64_scale_fp64_integer(b, -exponentB);\n  let normalizedQuotient = fp64_div_fp64_normalized(normalizedA, normalizedB);\n  return fp64_scale_fp64_integer(normalizedQuotient, exponentA - exponentB);\n}\n\nfn fp64_sqrt_fp64_normalized(a: vec2f) -> vec2f {\n  let estimate = sqrt(a.x);\n  let difference = sub_fp64(a, fp64_two_prod_integer(estimate, estimate)).x;\n  let denominator = fp64_round_add_integer(estimate, estimate);\n  let correction = fp64_divide_f32_integer(difference, denominator);\n  return sum_fp64(vec2f(estimate, 0.0), vec2f(correction, 0.0));\n}\n\nfn sqrt_fp64(a: vec2f) -> vec2f {\n  let decoded = fp64_decode_f32_bits(bitcast<u32>(a.x));\n  let decodedLow = fp64_decode_f32_bits(bitcast<u32>(a.y));\n  if (decoded.isZero && decodedLow.isZero) {\n    return vec2f(0.0, 0.0);\n  }\n  if (decoded.sign == 1u) {\n    let nanValue = fp64_nan(a.x);\n    return vec2f(nanValue, nanValue);\n  }\n\n  if (decoded.isInf || decoded.isNan) {\n    return fp64_sqrt_fp64_normalized(a);\n  }\n  let exponent = fp64_f32_finite_exponent(decoded);\n  // An even scale lets the final square-root rescale use an integer exponent.\n  let evenExponent = exponent - (exponent & 1);\n  let normalizedA = fp64_scale_fp64_integer(a, -evenExponent);\n  let normalizedRoot = fp64_sqrt_fp64_normalized(normalizedA);\n  return fp64_scale_fp64_integer(normalizedRoot, evenExponent / 2);\n}\n#endif\n\n#else\n#ifdef LUMA_FP64_HYBRID_ARITHMETIC\nstruct Fp64F32Bits {\n  sign: u32,\n  baseExponent: i32,\n  significand: u32,\n  isZero: bool,\n  isInf: bool,\n  isNan: bool,\n};\n\n// Decode an f32 as (-1)^sign * significand * 2^baseExponent.\nfn fp64_decode_f32_bits(bits: u32) -> Fp64F32Bits {\n  let sign = bits >> 31u;\n  let exponentBits = (bits >> 23u) & 0xffu;\n  let fraction = bits & 0x7fffffu;\n\n  if (exponentBits == 0xffu) {\n    return Fp64F32Bits(sign, 0, 0u, false, fraction == 0u, fraction != 0u);\n  }\n  if (exponentBits == 0u) {\n    return Fp64F32Bits(sign, -149, fraction, fraction == 0u, false, false);\n  }\n  return Fp64F32Bits(sign, i32(exponentBits) - 150, 0x800000u | fraction, false, false, false);\n}\n\nfn fp64_f32_magnitude_compare(aBits: u32, bBits: u32) -> i32 {\n  let aMagnitude = aBits & 0x7fffffffu;\n  let bMagnitude = bBits & 0x7fffffffu;\n  if (aMagnitude == bMagnitude) {\n    return 0;\n  }\n  return select(-1, 1, aMagnitude > bMagnitude);\n}\n\nfn fp64_make_residual_f32_bits(\n  exactSign: u32,\n  exactMagnitude: vec2u,\n  exactBaseExponent: i32,\n  highBits: u32\n) -> u32 {\n  if (fp64_u64_is_zero(exactMagnitude)) {\n    return 0u;\n  }\n\n  let high = fp64_decode_f32_bits(highBits);\n  if (high.isInf || high.isNan) {\n    return exactSign << 31u;\n  }\n  if (high.isZero) {\n    return fp64_make_f32_bits_from_u64(exactSign, exactMagnitude, exactBaseExponent);\n  }\n\n  let commonBaseExponent = min(exactBaseExponent, high.baseExponent);\n  let exactShift = exactBaseExponent - commonBaseExponent;\n  let highShift = high.baseExponent - commonBaseExponent;\n\n  // A normal two-sum/two-product residual never needs a shift this large.\n  // This guard gives deterministic underflow behavior outside that contract.\n  if (exactShift >= 64 || highShift >= 64) {\n    return exactSign << 31u;\n  }\n\n  let exactAligned = fp64_u64_shift_left(exactMagnitude, u32(exactShift));\n  let highAligned = fp64_u64_shift_left(vec2u(0u, high.significand), u32(highShift));\n  let comparison = fp64_u64_compare(exactAligned, highAligned);\n  if (comparison == 0) {\n    return 0u;\n  }\n\n  var residualSign = exactSign;\n  var residualMagnitude: vec2u;\n  if (comparison > 0) {\n    residualMagnitude = fp64_u64_sub(exactAligned, highAligned);\n  } else {\n    residualSign = exactSign ^ 1u;\n    residualMagnitude = fp64_u64_sub(highAligned, exactAligned);\n  }\n  return fp64_make_f32_bits_from_u64(\n    residualSign,\n    residualMagnitude,\n    commonBaseExponent\n  );\n}\n\nfn fp64_split_accumulator_bits(\n  sign: u32,\n  magnitude: vec2u,\n  baseExponent: i32\n) -> vec2u {\n  let highBits = fp64_make_f32_bits_from_u64(sign, magnitude, baseExponent);\n  let lowBits = fp64_make_residual_f32_bits(sign, magnitude, baseExponent, highBits);\n  return vec2u(highBits, lowBits);\n}\n\nfn fp64_two_sum_integer_bits(aBits: u32, bBits: u32) -> vec2u {\n  let a = fp64_decode_f32_bits(aBits);\n  let b = fp64_decode_f32_bits(bBits);\n\n  if (a.isNan || b.isNan) {\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf || b.isInf) {\n    if (a.isInf && b.isInf && a.sign != b.sign) {\n      return vec2u(0x7fc00000u, 0u);\n    }\n    return select(vec2u(bBits, 0u), vec2u(aBits, 0u), a.isInf);\n  }\n  if (a.isZero && b.isZero) {\n    return vec2u((a.sign & b.sign) << 31u, 0u);\n  }\n  if (a.isZero) {\n    return vec2u(bBits, 0u);\n  }\n  if (b.isZero) {\n    return vec2u(aBits, 0u);\n  }\n\n  let exponentDifference = select(\n    b.baseExponent - a.baseExponent,\n    a.baseExponent - b.baseExponent,\n    a.baseExponent >= b.baseExponent\n  );\n\n  // Beyond half an ulp, rounding cannot change the larger operand. Returning\n  // the smaller operand intact also avoids an unbounded integer alignment.\n  // At a power-of-two boundary the spacing below the larger operand is half\n  // the spacing above it, so an opposite-sign gap-25 operand can still change\n  // the rounded high limb. Gap 26 is the first universally safe early-out.\n  if (exponentDifference > 25) {\n    if (fp64_f32_magnitude_compare(aBits, bBits) >= 0) {\n      return vec2u(aBits, bBits);\n    }\n    return vec2u(bBits, aBits);\n  }\n\n  let commonBaseExponent = min(a.baseExponent, b.baseExponent);\n  let aMagnitude = fp64_u64_shift_left(\n    vec2u(0u, a.significand),\n    u32(a.baseExponent - commonBaseExponent)\n  );\n  let bMagnitude = fp64_u64_shift_left(\n    vec2u(0u, b.significand),\n    u32(b.baseExponent - commonBaseExponent)\n  );\n\n  var resultSign = a.sign;\n  var resultMagnitude: vec2u;\n  if (a.sign == b.sign) {\n    resultMagnitude = fp64_u64_add(aMagnitude, bMagnitude);\n  } else {\n    let comparison = fp64_u64_compare(aMagnitude, bMagnitude);\n    if (comparison == 0) {\n      return vec2u(0u, 0u);\n    }\n    if (comparison > 0) {\n      resultMagnitude = fp64_u64_sub(aMagnitude, bMagnitude);\n    } else {\n      resultSign = b.sign;\n      resultMagnitude = fp64_u64_sub(bMagnitude, aMagnitude);\n    }\n  }\n\n  return fp64_split_accumulator_bits(resultSign, resultMagnitude, commonBaseExponent);\n}\n\nfn fp64_two_sum_integer(a: f32, b: f32) -> vec2f {\n  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bitcast<u32>(b));\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\nfn fp64_multiply_significands(a: u32, b: u32) -> vec2u {\n  let aLow = a & 0xffffu;\n  let aHigh = a >> 16u;\n  let bLow = b & 0xffffu;\n  let bHigh = b >> 16u;\n  let lowProduct = aLow * bLow;\n  let crossProduct = aLow * bHigh + aHigh * bLow;\n  let highProduct = aHigh * bHigh;\n\n  var result = vec2u(0u, lowProduct);\n  result = fp64_u64_add(\n    result,\n    fp64_u64_shift_left(vec2u(0u, crossProduct), 16u)\n  );\n  result = fp64_u64_add(result, vec2u(highProduct, 0u));\n  return result;\n}\n\nfn fp64_two_prod_integer_bits(aBits: u32, bBits: u32) -> vec2u {\n  let a = fp64_decode_f32_bits(aBits);\n  let b = fp64_decode_f32_bits(bBits);\n  let resultSign = a.sign ^ b.sign;\n\n  if (a.isNan || b.isNan || ((a.isZero || b.isZero) && (a.isInf || b.isInf))) {\n    return vec2u(0x7fc00000u, 0u);\n  }\n  if (a.isInf || b.isInf) {\n    return vec2u((resultSign << 31u) | 0x7f800000u, resultSign << 31u);\n  }\n  if (a.isZero || b.isZero) {\n    return vec2u(resultSign << 31u, resultSign << 31u);\n  }\n\n  let magnitude = fp64_multiply_significands(a.significand, b.significand);\n  return fp64_split_accumulator_bits(\n    resultSign,\n    magnitude,\n    a.baseExponent + b.baseExponent\n  );\n}\n\nfn fp64_two_prod_integer(a: f32, b: f32) -> vec2f {\n  let resultBits = fp64_two_prod_integer_bits(bitcast<u32>(a), bitcast<u32>(b));\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\nfn fp64_round_add_integer(a: f32, b: f32) -> f32 {\n  return fp64_two_sum_integer(a, b).x;\n}\n\nfn fp64_round_mul_integer(a: f32, b: f32) -> f32 {\n  return fp64_two_prod_integer(a, b).x;\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn fp64_f32_finite_exponent(value: Fp64F32Bits) -> i32 {\n  let mostSignificantBit = 31u - countLeadingZeros(value.significand);\n  return value.baseExponent + i32(mostSignificantBit);\n}\n\nfn fp64_scale_f32_integer(value: f32, exponent: i32) -> f32 {\n  let decoded = fp64_decode_f32_bits(bitcast<u32>(value));\n  if (decoded.isZero || decoded.isInf || decoded.isNan) {\n    return value;\n  }\n  let resultBits = fp64_make_f32_bits_from_u64(\n    decoded.sign,\n    vec2u(0u, decoded.significand),\n    decoded.baseExponent + exponent\n  );\n  return bitcast<f32>(resultBits);\n}\n\n// Divide normalized significands so the hardware operation cannot overflow,\n// underflow, or flush a subnormal result. Reapply the exponent with integer\n// packing, which also produces subnormal correction limbs without relying on\n// floating-point arithmetic to preserve them.\nfn fp64_divide_f32_integer(aValue: f32, bValue: f32) -> f32 {\n  let a = fp64_decode_f32_bits(bitcast<u32>(aValue));\n  let b = fp64_decode_f32_bits(bitcast<u32>(bValue));\n  if (a.isZero || b.isZero || a.isInf || b.isInf || a.isNan || b.isNan) {\n    return aValue / bValue;\n  }\n\n  let aMostSignificantBit = 31u - countLeadingZeros(a.significand);\n  let bMostSignificantBit = 31u - countLeadingZeros(b.significand);\n  let normalizedABits = fp64_make_f32_bits_from_u64(\n    a.sign,\n    vec2u(0u, a.significand),\n    -i32(aMostSignificantBit)\n  );\n  let normalizedBBits = fp64_make_f32_bits_from_u64(\n    b.sign,\n    vec2u(0u, b.significand),\n    -i32(bMostSignificantBit)\n  );\n  let normalizedQuotient = bitcast<f32>(normalizedABits) / bitcast<f32>(normalizedBBits);\n  let quotient = fp64_decode_f32_bits(bitcast<u32>(normalizedQuotient));\n  let exponentShift =\n    a.baseExponent + i32(aMostSignificantBit) -\n    b.baseExponent - i32(bMostSignificantBit);\n  let quotientBits = fp64_make_f32_bits_from_u64(\n    quotient.sign,\n    vec2u(0u, quotient.significand),\n    quotient.baseExponent + exponentShift\n  );\n  return bitcast<f32>(quotientBits);\n}\n#endif\n\n\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn split(a: f32) -> vec2f {\n  let aBits = bitcast<u32>(a);\n  let decoded = fp64_decode_f32_bits(aBits);\n  if (decoded.isZero || decoded.isInf || decoded.isNan) {\n    return vec2f(a, 0.0);\n  }\n\n  var roundedHigh = decoded.significand >> 12u;\n  let remainder = decoded.significand & 0xfffu;\n  if (remainder > 0x800u || (remainder == 0x800u && (roundedHigh & 1u) == 1u)) {\n    roundedHigh = roundedHigh + 1u;\n  }\n  var highMagnitude = vec2u(0u, roundedHigh << 12u);\n  var highBits = fp64_make_f32_bits_from_u64(\n    decoded.sign,\n    highMagnitude,\n    decoded.baseExponent\n  );\n  if (fp64_decode_f32_bits(highBits).isInf) {\n    roundedHigh = decoded.significand >> 12u;\n    highMagnitude = vec2u(0u, roundedHigh << 12u);\n    highBits = fp64_make_f32_bits_from_u64(\n      decoded.sign,\n      highMagnitude,\n      decoded.baseExponent\n    );\n  }\n  let lowBits = fp64_make_residual_f32_bits(\n    decoded.sign,\n    vec2u(0u, decoded.significand),\n    decoded.baseExponent,\n    highBits\n  );\n  return vec2f(bitcast<f32>(highBits), bitcast<f32>(lowBits));\n}\n\nfn split2(a: vec2f) -> vec2f {\n  var result = split(a.x);\n  result.y = result.y + a.y;\n  return result;\n}\n\nfn quickTwoSum(a: f32, b: f32) -> vec2f {\n  return fp64_two_sum_integer(a, b);\n}\n#endif\n\nfn twoSum(a: f32, b: f32) -> vec2f {\n  return fp64_two_sum_integer(a, b);\n}\n\nfn twoSub(a: f32, b: f32) -> vec2f {\n  let bBits = bitcast<u32>(b) ^ 0x80000000u;\n  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bBits);\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn twoSqr(a: f32) -> vec2f {\n  return fp64_two_prod_integer(a, a);\n}\n\nfn twoProd(a: f32, b: f32) -> vec2f {\n  return fp64_two_prod_integer(a, b);\n}\n#endif\n\nfn sum_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let highSum = fp64_two_sum_integer(a.x, b.x);\n  let lowSum = prevent_fp64_optimization((a.y + b.y) + highSum.y);\n  return fp64_two_sum_integer(highSum.x, lowSum);\n}\n\nfn sub_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let highDifference = twoSub(a.x, b.x);\n  let lowDifference = prevent_fp64_optimization((a.y - b.y) + highDifference.y);\n  return fp64_two_sum_integer(highDifference.x, lowDifference);\n}\n\nfn mul_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let highProduct = fp64_two_prod_integer(a.x, b.x);\n  let crossTerms = prevent_fp64_optimization(a.x * b.y + a.y * b.x);\n  let lowTerms = prevent_fp64_optimization((crossTerms + a.y * b.y) + highProduct.y);\n  return fp64_two_sum_integer(highProduct.x, lowTerms);\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn div_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let estimate = prevent_fp64_optimization(1.0 / b.x);\n  let quotient = mul_fp64(a, vec2f(estimate, fp64_runtime_zero()));\n  let remainder = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, quotient)).x);\n  return sum_fp64(quotient, twoProd(estimate, remainder));\n}\n\nfn sqrt_fp64(a: vec2f) -> vec2f {\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2f(0.0, 0.0);\n  }\n  if (a.x < 0.0) {\n    let nanValue = fp64_nan(a.x);\n    return vec2f(nanValue, nanValue);\n  }\n\n  let reciprocalRoot = prevent_fp64_optimization(1.0 / sqrt(a.x));\n  let estimate = prevent_fp64_optimization(a.x * reciprocalRoot);\n  let difference = prevent_fp64_optimization(sub_fp64(a, twoSqr(estimate)).x);\n  let correction = twoProd(prevent_fp64_optimization(reciprocalRoot * 0.5), difference);\n  return sum_fp64(vec2f(estimate, 0.0), correction);\n}\n#endif\n\n#else\nfn split(a: f32) -> vec2f {\n  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());\n  let t = prevent_fp64_optimization(a * splitValue);\n  let temp = prevent_fp64_optimization(t - a);\n  let aHi = prevent_fp64_optimization(t - temp);\n  let aLo = prevent_fp64_optimization(a - aHi);\n  return vec2f(aHi, aLo);\n}\n\nfn split2(a: vec2f) -> vec2f {\n  var b = split(a.x);\n  b.y = prevent_fp64_optimization(b.y + a.y);\n  return b;\n}\n\nfn quickTwoSum(a: f32, b: f32) -> vec2f {\n  let sum = prevent_fp64_optimization(a + b);\n  let err = prevent_fp64_optimization(b - prevent_fp64_optimization(sum - a));\n  return vec2f(sum, err);\n}\n\nfn twoSum(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a + b);\n  let v = prevent_fp64_optimization(s - a);\n  let aErr = prevent_fp64_optimization(a - prevent_fp64_optimization(s - v));\n  let bErr = prevent_fp64_optimization(b - v);\n  let err = prevent_fp64_optimization(aErr + bErr);\n  return vec2f(s, err);\n}\n\nfn twoSub(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a - b);\n  let v = prevent_fp64_optimization(s - a);\n  let aErr = prevent_fp64_optimization(a - prevent_fp64_optimization(s - v));\n  let bErr = prevent_fp64_optimization(b + v);\n  let err = prevent_fp64_optimization(aErr - bErr);\n  return vec2f(s, err);\n}\n\nfn twoSqr(a: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * a);\n  let aFp64 = split(a);\n  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);\n  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);\n  let highErr = prevent_fp64_optimization(highProduct - prod);\n  let err = prevent_fp64_optimization(\n    prevent_fp64_optimization(highErr + crossProduct) + lowProduct\n  );\n  return vec2f(prod, err);\n}\n\nfn twoProd(a: f32, b: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * b);\n  let aFp64 = split(a);\n  let bFp64 = split(b);\n  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);\n  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);\n  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err1 = (highProduct - prod) * fp64arithmetic.ONE;\n  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err4 =\n    lowProduct *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE;\n#else\n  let err1 = highProduct - prod;\n  let err2 = crossProduct1;\n  let err3 = crossProduct2;\n  let err4 = lowProduct;\n#endif\n  let err12InputA = prevent_fp64_optimization(err1);\n  let err12InputB = prevent_fp64_optimization(err2);\n  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);\n  let err123InputA = prevent_fp64_optimization(err12);\n  let err123InputB = prevent_fp64_optimization(err3);\n  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);\n  let err1234InputA = prevent_fp64_optimization(err123);\n  let err1234InputB = prevent_fp64_optimization(err4);\n  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);\n  return vec2f(prod, err);\n}\n\nfn sum_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSum(a.x, b.x);\n  let t = twoSum(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn sub_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSub(a.x, b.x);\n  let t = twoSub(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn mul_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var prod = twoProd(a.x, b.x);\n  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn div_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let xn = prevent_fp64_optimization(1.0 / b.x);\n  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));\n  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);\n  let prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nfn sqrt_fp64(a: vec2f) -> vec2f {\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2f(0.0, 0.0);\n  }\n  if (a.x < 0.0) {\n    let nanValue = fp64_nan(a.x);\n    return vec2f(nanValue, nanValue);\n  }\n\n  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));\n  let yn = prevent_fp64_optimization(a.x * x);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;\n#else\n  let ynSqr = twoSqr(yn);\n#endif\n  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);\n  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2f(yn, 0.0), prod);\n#endif\n}\n#endif\n#endif\n#endif\n\n#ifndef LUMA_FP64_PREDICATE_ONLY\nfn fp64_f32_bits_is_nan(bits: u32) -> bool {\n  return (bits & 0x7fffffffu) > 0x7f800000u;\n}\n\nfn fp64_f32_bits_is_inf(bits: u32) -> bool {\n  return (bits & 0x7fffffffu) == 0x7f800000u;\n}\n\nfn fp64_compare_f32_bits(aBits: u32, bBits: u32) -> i32 {\n  let aMagnitude = aBits & 0x7fffffffu;\n  let bMagnitude = bBits & 0x7fffffffu;\n  if (aMagnitude == 0u && bMagnitude == 0u) {\n    return 0;\n  }\n  let aSign = aBits >> 31u;\n  let bSign = bBits >> 31u;\n  if (aSign != bSign) {\n    return select(1, -1, aSign == 1u);\n  }\n  if (aMagnitude == bMagnitude) {\n    return 0;\n  }\n  let magnitudeComparison = select(-1, 1, aMagnitude > bMagnitude);\n  return select(magnitudeComparison, -magnitudeComparison, aSign == 1u);\n}\n\n// Normalize an arbitrary pair of finite f32 limbs with integer accumulation.\n// This is independent of LUMA_FP64_INTEGER_ARITHMETIC and canonicalizes every\n// representation of zero to vec2f(+0.0, +0.0).\nfn normalize_fp64(value: vec2f) -> vec2f {\n  let resultBits = fp64_add_raw_f32_bits(bitcast<u32>(value.x), bitcast<u32>(value.y));\n  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));\n}\n\nfn is_nan_fp64(value: vec2f) -> bool {\n  let normalized = normalize_fp64(value);\n  return fp64_f32_bits_is_nan(bitcast<u32>(normalized.x)) ||\n    fp64_f32_bits_is_nan(bitcast<u32>(normalized.y));\n}\n\nfn is_finite_fp64(value: vec2f) -> bool {\n  let normalized = normalize_fp64(value);\n  let highBits = bitcast<u32>(normalized.x);\n  let lowBits = bitcast<u32>(normalized.y);\n  return !fp64_f32_bits_is_nan(highBits) && !fp64_f32_bits_is_nan(lowBits) &&\n    !fp64_f32_bits_is_inf(highBits) && !fp64_f32_bits_is_inf(lowBits);\n}\n\n// Returns -1, 0, or 1. NaN is unordered and returns 0; call is_nan_fp64 or\n// is_finite_fp64 first when 0 must mean a finite zero.\nfn sign_fp64(value: vec2f) -> i32 {\n  let normalized = normalize_fp64(value);\n  let highBits = bitcast<u32>(normalized.x);\n  let lowBits = bitcast<u32>(normalized.y);\n  if (fp64_f32_bits_is_nan(highBits) || fp64_f32_bits_is_nan(lowBits)) {\n    return 0;\n  }\n  if ((highBits & 0x7fffffffu) != 0u) {\n    return select(1, -1, (highBits >> 31u) == 1u);\n  }\n  if ((lowBits & 0x7fffffffu) != 0u) {\n    return select(1, -1, (lowBits >> 31u) == 1u);\n  }\n  return 0;\n}\n\n// Compares double-single values and returns -1, 0, or 1. NaN is unordered\n// and returns 0; callers that require equality semantics must first check\n// is_nan_fp64 or is_finite_fp64.\nfn compare_fp64(a: vec2f, b: vec2f) -> i32 {\n  let normalizedA = normalize_fp64(a);\n  let normalizedB = normalize_fp64(b);\n  let aHighBits = bitcast<u32>(normalizedA.x);\n  let aLowBits = bitcast<u32>(normalizedA.y);\n  let bHighBits = bitcast<u32>(normalizedB.x);\n  let bLowBits = bitcast<u32>(normalizedB.y);\n  if (fp64_f32_bits_is_nan(aHighBits) || fp64_f32_bits_is_nan(aLowBits) ||\n      fp64_f32_bits_is_nan(bHighBits) || fp64_f32_bits_is_nan(bLowBits)) {\n    return 0;\n  }\n  let highComparison = fp64_compare_f32_bits(aHighBits, bHighBits);\n  if (highComparison != 0) {\n    return highComparison;\n  }\n  return fp64_compare_f32_bits(aLowBits, bLowBits);\n}\n\n// Scale by 2^exponent under either arithmetic. The classic path repacks each limb with\n// integer operations and no floating-point arithmetic, so hardware that flushes subnormal\n// results cannot zero a subnormal limb. Its result has the value of the integer path's,\n// which also renormalizes the limbs; that renormalization would flush them here.\nfn fp64_scale_fp64(value: vec2f, exponent: i32) -> vec2f {\n#ifdef LUMA_FP64_INTEGER_ARITHMETIC\n  return fp64_scale_fp64_integer(value, exponent);\n#else\n  let high = fp64_decode_raw_f32_bits(bitcast<u32>(value.x));\n  let low = fp64_decode_raw_f32_bits(bitcast<u32>(value.y));\n  var scaledHigh = value.x;\n  if (!(high.isZero || high.isInf || high.isNan)) {\n    scaledHigh = bitcast<f32>(\n      fp64_make_f32_bits_from_u64(high.sign, vec2u(0u, high.significand), high.baseExponent + exponent)\n    );\n  }\n  var scaledLow = value.y;\n  if (!(low.isZero || low.isInf || low.isNan)) {\n    scaledLow = bitcast<f32>(\n      fp64_make_f32_bits_from_u64(low.sign, vec2u(0u, low.significand), low.baseExponent + exponent)\n    );\n  }\n  return vec2f(scaledHigh, scaledLow);\n#endif\n}\n#endif\n";
+//# sourceMappingURL=fp64-arithmetic-wgsl.d.ts.map

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAOA,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,yn0DAm5B9B,CAAC"}