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

package/src/modules/math/fp64/fp64-arithmetic-wgsl-hybrid.ts

@@ -0,0 +1,129 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {fp64arithmeticWGSLIntegerPrimitives} from './fp64-arithmetic-wgsl-integer';
+
+/**
+ * Optimizer-resistant double-single arithmetic that reconstructs the critical
+ * high-part residuals with integer operations while accumulating lower-order
+ * terms with native f32 arithmetic.
+ *
+ * This deliberately trades strict correctness for substantially less integer
+ * work than the fully integer-controlled implementation.
+ */
+export const fp64arithmeticWGSLHybrid = /* 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
+  );
+  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 = result.y + a.y;
+  return result;
+}
+
+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
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let highSum = fp64_two_sum_integer(a.x, b.x);
+  let lowSum = prevent_fp64_optimization((a.y + b.y) + highSum.y);
+  return fp64_two_sum_integer(highSum.x, lowSum);
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let highDifference = twoSub(a.x, b.x);
+  let lowDifference = prevent_fp64_optimization((a.y - b.y) + highDifference.y);
+  return fp64_two_sum_integer(highDifference.x, lowDifference);
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let highProduct = fp64_two_prod_integer(a.x, b.x);
+  let crossTerms = prevent_fp64_optimization(a.x * b.y + a.y * b.x);
+  let lowTerms = prevent_fp64_optimization((crossTerms + a.y * b.y) + highProduct.y);
+  return fp64_two_sum_integer(highProduct.x, lowTerms);
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let estimate = prevent_fp64_optimization(1.0 / b.x);
+  let quotient = mul_fp64(a, vec2f(estimate, fp64_runtime_zero()));
+  let remainder = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, quotient)).x);
+  return sum_fp64(quotient, twoProd(estimate, remainder));
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2f(0.0, 0.0);
+  }
+  if (a.x < 0.0) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  let reciprocalRoot = prevent_fp64_optimization(1.0 / sqrt(a.x));
+  let estimate = prevent_fp64_optimization(a.x * reciprocalRoot);
+  let difference = prevent_fp64_optimization(sub_fp64(a, twoSqr(estimate)).x);
+  let correction = twoProd(prevent_fp64_optimization(reciprocalRoot * 0.5), difference);
+  return sum_fp64(vec2f(estimate, 0.0), correction);
+}
+#endif
+`;

package/src/modules/math/fp64/fp64-arithmetic-wgsl-integer.ts

@@ -0,0 +1,564 @@
+// 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
+`;