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

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

@@ -0,0 +1,11 @@
+/**
+ * Optimizer-independent double-single arithmetic for WGSL implementations that
+ * cannot preserve the rounding points required by the classic floating-point
+ * error-free transforms.
+ *
+ * This source is interpolated into fp64-arithmetic-wgsl.ts after the shared
+ * integer helpers. It intentionally keeps the public vec2<f32> API unchanged.
+ */
+export declare const fp64arithmeticWGSLIntegerPrimitives = "struct 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";
+export declare const fp64arithmeticWGSLInteger = "struct 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";
+//# sourceMappingURL=fp64-arithmetic-wgsl-integer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-wgsl-integer.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl-integer.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,6uRAwR/C,CAAC;AAEF,eAAO,MAAM,yBAAyB,qvjBA6QrC,CAAC"}

package/dist/modules/math/fp64/fp64-arithmetic-wgsl-integer.js

@@ -0,0 +1,563 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/**
+ * Optimizer-independent double-single arithmetic for WGSL implementations that
+ * cannot preserve the rounding points required by the classic floating-point
+ * error-free transforms.
+ *
+ * This source is interpolated into fp64-arithmetic-wgsl.ts after the shared
+ * integer helpers. It intentionally keeps the public vec2<f32> API unchanged.
+ */
+export const fp64arithmeticWGSLIntegerPrimitives = /* wgsl */ `\
+struct Fp64F32Bits {
+  sign: u32,
+  baseExponent: i32,
+  significand: u32,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+
+// Decode an f32 as (-1)^sign * significand * 2^baseExponent.
+fn fp64_decode_f32_bits(bits: u32) -> Fp64F32Bits {
+  let sign = bits >> 31u;
+  let exponentBits = (bits >> 23u) & 0xffu;
+  let fraction = bits & 0x7fffffu;
+
+  if (exponentBits == 0xffu) {
+    return Fp64F32Bits(sign, 0, 0u, false, fraction == 0u, fraction != 0u);
+  }
+  if (exponentBits == 0u) {
+    return Fp64F32Bits(sign, -149, fraction, fraction == 0u, false, false);
+  }
+  return Fp64F32Bits(sign, i32(exponentBits) - 150, 0x800000u | fraction, false, false, false);
+}
+
+fn fp64_f32_magnitude_compare(aBits: u32, bBits: u32) -> i32 {
+  let aMagnitude = aBits & 0x7fffffffu;
+  let bMagnitude = bBits & 0x7fffffffu;
+  if (aMagnitude == bMagnitude) {
+    return 0;
+  }
+  return select(-1, 1, aMagnitude > bMagnitude);
+}
+
+fn fp64_make_residual_f32_bits(
+  exactSign: u32,
+  exactMagnitude: vec2u,
+  exactBaseExponent: i32,
+  highBits: u32
+) -> u32 {
+  if (fp64_u64_is_zero(exactMagnitude)) {
+    return 0u;
+  }
+
+  let high = fp64_decode_f32_bits(highBits);
+  if (high.isInf || high.isNan) {
+    return exactSign << 31u;
+  }
+  if (high.isZero) {
+    return fp64_make_f32_bits_from_u64(exactSign, exactMagnitude, exactBaseExponent);
+  }
+
+  let commonBaseExponent = min(exactBaseExponent, high.baseExponent);
+  let exactShift = exactBaseExponent - commonBaseExponent;
+  let highShift = high.baseExponent - commonBaseExponent;
+
+  // A normal two-sum/two-product residual never needs a shift this large.
+  // This guard gives deterministic underflow behavior outside that contract.
+  if (exactShift >= 64 || highShift >= 64) {
+    return exactSign << 31u;
+  }
+
+  let exactAligned = fp64_u64_shift_left(exactMagnitude, u32(exactShift));
+  let highAligned = fp64_u64_shift_left(vec2u(0u, high.significand), u32(highShift));
+  let comparison = fp64_u64_compare(exactAligned, highAligned);
+  if (comparison == 0) {
+    return 0u;
+  }
+
+  var residualSign = exactSign;
+  var residualMagnitude: vec2u;
+  if (comparison > 0) {
+    residualMagnitude = fp64_u64_sub(exactAligned, highAligned);
+  } else {
+    residualSign = exactSign ^ 1u;
+    residualMagnitude = fp64_u64_sub(highAligned, exactAligned);
+  }
+  return fp64_make_f32_bits_from_u64(
+    residualSign,
+    residualMagnitude,
+    commonBaseExponent
+  );
+}
+
+fn fp64_split_accumulator_bits(
+  sign: u32,
+  magnitude: vec2u,
+  baseExponent: i32
+) -> vec2u {
+  let highBits = fp64_make_f32_bits_from_u64(sign, magnitude, baseExponent);
+  let lowBits = fp64_make_residual_f32_bits(sign, magnitude, baseExponent, highBits);
+  return vec2u(highBits, lowBits);
+}
+
+fn fp64_two_sum_integer_bits(aBits: u32, bBits: u32) -> vec2u {
+  let a = fp64_decode_f32_bits(aBits);
+  let b = fp64_decode_f32_bits(bBits);
+
+  if (a.isNan || b.isNan) {
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf || b.isInf) {
+    if (a.isInf && b.isInf && a.sign != b.sign) {
+      return vec2u(0x7fc00000u, 0u);
+    }
+    return select(vec2u(bBits, 0u), vec2u(aBits, 0u), a.isInf);
+  }
+  if (a.isZero && b.isZero) {
+    return vec2u((a.sign & b.sign) << 31u, 0u);
+  }
+  if (a.isZero) {
+    return vec2u(bBits, 0u);
+  }
+  if (b.isZero) {
+    return vec2u(aBits, 0u);
+  }
+
+  let exponentDifference = select(
+    b.baseExponent - a.baseExponent,
+    a.baseExponent - b.baseExponent,
+    a.baseExponent >= b.baseExponent
+  );
+
+  // Beyond half an ulp, rounding cannot change the larger operand. Returning
+  // the smaller operand intact also avoids an unbounded integer alignment.
+  // At a power-of-two boundary the spacing below the larger operand is half
+  // the spacing above it, so an opposite-sign gap-25 operand can still change
+  // the rounded high limb. Gap 26 is the first universally safe early-out.
+  if (exponentDifference > 25) {
+    if (fp64_f32_magnitude_compare(aBits, bBits) >= 0) {
+      return vec2u(aBits, bBits);
+    }
+    return vec2u(bBits, aBits);
+  }
+
+  let commonBaseExponent = min(a.baseExponent, b.baseExponent);
+  let aMagnitude = fp64_u64_shift_left(
+    vec2u(0u, a.significand),
+    u32(a.baseExponent - commonBaseExponent)
+  );
+  let bMagnitude = fp64_u64_shift_left(
+    vec2u(0u, b.significand),
+    u32(b.baseExponent - commonBaseExponent)
+  );
+
+  var resultSign = a.sign;
+  var resultMagnitude: vec2u;
+  if (a.sign == b.sign) {
+    resultMagnitude = fp64_u64_add(aMagnitude, bMagnitude);
+  } else {
+    let comparison = fp64_u64_compare(aMagnitude, bMagnitude);
+    if (comparison == 0) {
+      return vec2u(0u, 0u);
+    }
+    if (comparison > 0) {
+      resultMagnitude = fp64_u64_sub(aMagnitude, bMagnitude);
+    } else {
+      resultSign = b.sign;
+      resultMagnitude = fp64_u64_sub(bMagnitude, aMagnitude);
+    }
+  }
+
+  return fp64_split_accumulator_bits(resultSign, resultMagnitude, commonBaseExponent);
+}
+
+fn fp64_two_sum_integer(a: f32, b: f32) -> vec2f {
+  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bitcast<u32>(b));
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+fn fp64_multiply_significands(a: u32, b: u32) -> vec2u {
+  let aLow = a & 0xffffu;
+  let aHigh = a >> 16u;
+  let bLow = b & 0xffffu;
+  let bHigh = b >> 16u;
+  let lowProduct = aLow * bLow;
+  let crossProduct = aLow * bHigh + aHigh * bLow;
+  let highProduct = aHigh * bHigh;
+
+  var result = vec2u(0u, lowProduct);
+  result = fp64_u64_add(
+    result,
+    fp64_u64_shift_left(vec2u(0u, crossProduct), 16u)
+  );
+  result = fp64_u64_add(result, vec2u(highProduct, 0u));
+  return result;
+}
+
+fn fp64_two_prod_integer_bits(aBits: u32, bBits: u32) -> vec2u {
+  let a = fp64_decode_f32_bits(aBits);
+  let b = fp64_decode_f32_bits(bBits);
+  let resultSign = a.sign ^ b.sign;
+
+  if (a.isNan || b.isNan || ((a.isZero || b.isZero) && (a.isInf || b.isInf))) {
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf || b.isInf) {
+    return vec2u((resultSign << 31u) | 0x7f800000u, resultSign << 31u);
+  }
+  if (a.isZero || b.isZero) {
+    return vec2u(resultSign << 31u, resultSign << 31u);
+  }
+
+  let magnitude = fp64_multiply_significands(a.significand, b.significand);
+  return fp64_split_accumulator_bits(
+    resultSign,
+    magnitude,
+    a.baseExponent + b.baseExponent
+  );
+}
+
+fn fp64_two_prod_integer(a: f32, b: f32) -> vec2f {
+  let resultBits = fp64_two_prod_integer_bits(bitcast<u32>(a), bitcast<u32>(b));
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+fn fp64_round_add_integer(a: f32, b: f32) -> f32 {
+  return fp64_two_sum_integer(a, b).x;
+}
+
+fn fp64_round_mul_integer(a: f32, b: f32) -> f32 {
+  return fp64_two_prod_integer(a, b).x;
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn fp64_f32_finite_exponent(value: Fp64F32Bits) -> i32 {
+  let mostSignificantBit = 31u - countLeadingZeros(value.significand);
+  return value.baseExponent + i32(mostSignificantBit);
+}
+
+fn fp64_scale_f32_integer(value: f32, exponent: i32) -> f32 {
+  let decoded = fp64_decode_f32_bits(bitcast<u32>(value));
+  if (decoded.isZero || decoded.isInf || decoded.isNan) {
+    return value;
+  }
+  let resultBits = fp64_make_f32_bits_from_u64(
+    decoded.sign,
+    vec2u(0u, decoded.significand),
+    decoded.baseExponent + exponent
+  );
+  return bitcast<f32>(resultBits);
+}
+
+// Divide normalized significands so the hardware operation cannot overflow,
+// underflow, or flush a subnormal result. Reapply the exponent with integer
+// packing, which also produces subnormal correction limbs without relying on
+// floating-point arithmetic to preserve them.
+fn fp64_divide_f32_integer(aValue: f32, bValue: f32) -> f32 {
+  let a = fp64_decode_f32_bits(bitcast<u32>(aValue));
+  let b = fp64_decode_f32_bits(bitcast<u32>(bValue));
+  if (a.isZero || b.isZero || a.isInf || b.isInf || a.isNan || b.isNan) {
+    return aValue / bValue;
+  }
+
+  let aMostSignificantBit = 31u - countLeadingZeros(a.significand);
+  let bMostSignificantBit = 31u - countLeadingZeros(b.significand);
+  let normalizedABits = fp64_make_f32_bits_from_u64(
+    a.sign,
+    vec2u(0u, a.significand),
+    -i32(aMostSignificantBit)
+  );
+  let normalizedBBits = fp64_make_f32_bits_from_u64(
+    b.sign,
+    vec2u(0u, b.significand),
+    -i32(bMostSignificantBit)
+  );
+  let normalizedQuotient = bitcast<f32>(normalizedABits) / bitcast<f32>(normalizedBBits);
+  let quotient = fp64_decode_f32_bits(bitcast<u32>(normalizedQuotient));
+  let exponentShift =
+    a.baseExponent + i32(aMostSignificantBit) -
+    b.baseExponent - i32(bMostSignificantBit);
+  let quotientBits = fp64_make_f32_bits_from_u64(
+    quotient.sign,
+    vec2u(0u, quotient.significand),
+    quotient.baseExponent + exponentShift
+  );
+  return bitcast<f32>(quotientBits);
+}
+#endif
+
+`;
+export const fp64arithmeticWGSLInteger = /* wgsl */ `\
+${fp64arithmeticWGSLIntegerPrimitives}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn split(a: f32) -> vec2f {
+  let aBits = bitcast<u32>(a);
+  let decoded = fp64_decode_f32_bits(aBits);
+  if (decoded.isZero || decoded.isInf || decoded.isNan) {
+    return vec2f(a, 0.0);
+  }
+
+  var roundedHigh = decoded.significand >> 12u;
+  let remainder = decoded.significand & 0xfffu;
+  if (remainder > 0x800u || (remainder == 0x800u && (roundedHigh & 1u) == 1u)) {
+    roundedHigh = roundedHigh + 1u;
+  }
+  var highMagnitude = vec2u(0u, roundedHigh << 12u);
+  var highBits = fp64_make_f32_bits_from_u64(
+    decoded.sign,
+    highMagnitude,
+    decoded.baseExponent
+  );
+  // Rounding the high limb of a maximum-exponent value can overflow even
+  // though the original value is finite. Truncate only in that boundary case
+  // so split remains an exact finite decomposition.
+  if (fp64_decode_f32_bits(highBits).isInf) {
+    roundedHigh = decoded.significand >> 12u;
+    highMagnitude = vec2u(0u, roundedHigh << 12u);
+    highBits = fp64_make_f32_bits_from_u64(
+      decoded.sign,
+      highMagnitude,
+      decoded.baseExponent
+    );
+  }
+  let lowBits = fp64_make_residual_f32_bits(
+    decoded.sign,
+    vec2u(0u, decoded.significand),
+    decoded.baseExponent,
+    highBits
+  );
+  return vec2f(bitcast<f32>(highBits), bitcast<f32>(lowBits));
+}
+
+fn split2(a: vec2f) -> vec2f {
+  var result = split(a.x);
+  result.y = fp64_round_add_integer(result.y, a.y);
+  return result;
+}
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn quickTwoSum(a: f32, b: f32) -> vec2f {
+  return fp64_two_sum_integer(a, b);
+}
+#endif
+
+fn twoSum(a: f32, b: f32) -> vec2f {
+  return fp64_two_sum_integer(a, b);
+}
+
+fn twoSub(a: f32, b: f32) -> vec2f {
+  let bBits = bitcast<u32>(b) ^ 0x80000000u;
+  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bBits);
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn twoSqr(a: f32) -> vec2f {
+  return fp64_two_prod_integer(a, a);
+}
+
+fn twoProd(a: f32, b: f32) -> vec2f {
+  return fp64_two_prod_integer(a, b);
+}
+#endif
+
+struct Fp64IntegerAccumulator {
+  sign: u32,
+  magnitude: vec2u,
+};
+
+fn fp64_accumulate_f32_integer(
+  accumulator: Fp64IntegerAccumulator,
+  value: Fp64F32Bits,
+  commonBaseExponent: i32
+) -> Fp64IntegerAccumulator {
+  if (value.isZero) {
+    return accumulator;
+  }
+
+  let magnitude = fp64_u64_shift_left(
+    vec2u(0u, value.significand),
+    u32(value.baseExponent - commonBaseExponent)
+  );
+  if (fp64_u64_is_zero(accumulator.magnitude)) {
+    return Fp64IntegerAccumulator(value.sign, magnitude);
+  }
+  if (accumulator.sign == value.sign) {
+    return Fp64IntegerAccumulator(
+      accumulator.sign,
+      fp64_u64_add(accumulator.magnitude, magnitude)
+    );
+  }
+
+  let comparison = fp64_u64_compare(accumulator.magnitude, magnitude);
+  if (comparison == 0) {
+    return Fp64IntegerAccumulator(0u, vec2u(0u));
+  }
+  if (comparison > 0) {
+    return Fp64IntegerAccumulator(
+      accumulator.sign,
+      fp64_u64_sub(accumulator.magnitude, magnitude)
+    );
+  }
+  return Fp64IntegerAccumulator(
+    value.sign,
+    fp64_u64_sub(magnitude, accumulator.magnitude)
+  );
+}
+
+fn fp64_sum_integer_unfused(a: vec2f, b: vec2f) -> vec2f {
+  var sum = fp64_two_sum_integer(a.x, b.x);
+  let lowSum = fp64_two_sum_integer(a.y, b.y);
+  sum.y = fp64_round_add_integer(sum.y, lowSum.x);
+  sum = fp64_two_sum_integer(sum.x, sum.y);
+  sum.y = fp64_round_add_integer(sum.y, lowSum.y);
+  return fp64_two_sum_integer(sum.x, sum.y);
+}
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let aHigh = fp64_decode_f32_bits(bitcast<u32>(a.x));
+  let aLow = fp64_decode_f32_bits(bitcast<u32>(a.y));
+  let bHigh = fp64_decode_f32_bits(bitcast<u32>(b.x));
+  let bLow = fp64_decode_f32_bits(bitcast<u32>(b.y));
+  if (
+    aHigh.isInf || aHigh.isNan || aLow.isInf || aLow.isNan ||
+    bHigh.isInf || bHigh.isNan || bLow.isInf || bLow.isNan
+  ) {
+    return fp64_sum_integer_unfused(a, b);
+  }
+
+  var minimumBaseExponent = 2147483647;
+  var maximumBaseExponent = -2147483647;
+  if (!aHigh.isZero) {
+    minimumBaseExponent = min(minimumBaseExponent, aHigh.baseExponent);
+    maximumBaseExponent = max(maximumBaseExponent, aHigh.baseExponent);
+  }
+  if (!aLow.isZero) {
+    minimumBaseExponent = min(minimumBaseExponent, aLow.baseExponent);
+    maximumBaseExponent = max(maximumBaseExponent, aLow.baseExponent);
+  }
+  if (!bHigh.isZero) {
+    minimumBaseExponent = min(minimumBaseExponent, bHigh.baseExponent);
+    maximumBaseExponent = max(maximumBaseExponent, bHigh.baseExponent);
+  }
+  if (!bLow.isZero) {
+    minimumBaseExponent = min(minimumBaseExponent, bLow.baseExponent);
+    maximumBaseExponent = max(maximumBaseExponent, bLow.baseExponent);
+  }
+  if (maximumBaseExponent < minimumBaseExponent) {
+    return vec2f(0.0, 0.0);
+  }
+
+  // Four 24-bit significands spanning at most 38 bits fit in the 64-bit
+  // accumulator, including the two extra carry bits needed by their sum.
+  if (maximumBaseExponent - minimumBaseExponent > 38) {
+    return fp64_sum_integer_unfused(a, b);
+  }
+
+  var accumulator = Fp64IntegerAccumulator(0u, vec2u(0u));
+  accumulator = fp64_accumulate_f32_integer(accumulator, aHigh, minimumBaseExponent);
+  accumulator = fp64_accumulate_f32_integer(accumulator, aLow, minimumBaseExponent);
+  accumulator = fp64_accumulate_f32_integer(accumulator, bHigh, minimumBaseExponent);
+  accumulator = fp64_accumulate_f32_integer(accumulator, bLow, minimumBaseExponent);
+  let resultBits = fp64_split_accumulator_bits(
+    accumulator.sign,
+    accumulator.magnitude,
+    minimumBaseExponent
+  );
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let negatedB = vec2f(
+    bitcast<f32>(bitcast<u32>(b.x) ^ 0x80000000u),
+    bitcast<f32>(bitcast<u32>(b.y) ^ 0x80000000u)
+  );
+  return sum_fp64(a, negatedB);
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var product = fp64_two_prod_integer(a.x, b.x);
+  let crossProduct1 = fp64_round_mul_integer(a.x, b.y);
+  product = sum_fp64(product, vec2f(crossProduct1, 0.0));
+  let crossProduct2 = fp64_round_mul_integer(a.y, b.x);
+  return sum_fp64(product, vec2f(crossProduct2, 0.0));
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn fp64_scale_fp64_integer(value: vec2f, exponent: i32) -> vec2f {
+  let high = fp64_scale_f32_integer(value.x, exponent);
+  let low = fp64_scale_f32_integer(value.y, exponent);
+  return sum_fp64(vec2f(high, 0.0), vec2f(low, 0.0));
+}
+
+fn fp64_div_fp64_normalized(a: vec2f, b: vec2f) -> vec2f {
+  let quotientHigh = fp64_divide_f32_integer(a.x, b.x);
+  var quotient = vec2f(quotientHigh, 0.0);
+
+  let remainder = sub_fp64(a, mul_fp64(b, quotient));
+  let quotientLow = fp64_divide_f32_integer(remainder.x, b.x);
+  quotient = sum_fp64(quotient, vec2f(quotientLow, 0.0));
+
+  let secondRemainder = sub_fp64(a, mul_fp64(b, quotient));
+  let correction = fp64_divide_f32_integer(secondRemainder.x, b.x);
+  return sum_fp64(quotient, vec2f(correction, 0.0));
+}
+
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let decodedA = fp64_decode_f32_bits(bitcast<u32>(a.x));
+  let decodedB = fp64_decode_f32_bits(bitcast<u32>(b.x));
+  if (
+    decodedA.isZero || decodedB.isZero ||
+    decodedA.isInf || decodedB.isInf ||
+    decodedA.isNan || decodedB.isNan
+  ) {
+    return fp64_div_fp64_normalized(a, b);
+  }
+
+  let exponentA = fp64_f32_finite_exponent(decodedA);
+  let exponentB = fp64_f32_finite_exponent(decodedB);
+  // Correct the quotient near unity so b * q and the remainder stay clear of
+  // both f32 underflow and overflow. The exponent difference is applied once.
+  let normalizedA = fp64_scale_fp64_integer(a, -exponentA);
+  let normalizedB = fp64_scale_fp64_integer(b, -exponentB);
+  let normalizedQuotient = fp64_div_fp64_normalized(normalizedA, normalizedB);
+  return fp64_scale_fp64_integer(normalizedQuotient, exponentA - exponentB);
+}
+
+fn fp64_sqrt_fp64_normalized(a: vec2f) -> vec2f {
+  let estimate = sqrt(a.x);
+  let difference = sub_fp64(a, fp64_two_prod_integer(estimate, estimate)).x;
+  let denominator = fp64_round_add_integer(estimate, estimate);
+  let correction = fp64_divide_f32_integer(difference, denominator);
+  return sum_fp64(vec2f(estimate, 0.0), vec2f(correction, 0.0));
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  let decoded = fp64_decode_f32_bits(bitcast<u32>(a.x));
+  let decodedLow = fp64_decode_f32_bits(bitcast<u32>(a.y));
+  if (decoded.isZero && decodedLow.isZero) {
+    return vec2f(0.0, 0.0);
+  }
+  if (decoded.sign == 1u) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  if (decoded.isInf || decoded.isNan) {
+    return fp64_sqrt_fp64_normalized(a);
+  }
+  let exponent = fp64_f32_finite_exponent(decoded);
+  // An even scale lets the final square-root rescale use an integer exponent.
+  let evenExponent = exponent - (exponent & 1);
+  let normalizedA = fp64_scale_fp64_integer(a, -evenExponent);
+  let normalizedRoot = fp64_sqrt_fp64_normalized(normalizedA);
+  return fp64_scale_fp64_integer(normalizedRoot, evenExponent / 2);
+}
+#endif
+`;
+//# sourceMappingURL=fp64-arithmetic-wgsl-integer.js.map

package/dist/modules/math/fp64/fp64-arithmetic-wgsl-integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-wgsl-integer.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl-integer.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwR7D,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;EAClD,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4QpC,CAAC"}