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

package/dist/modules/math/fp64/fp64-arithmetic-glsl.cjs

@@ -0,0 +1,229 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fp64_arithmetic_glsl_exports = {};
+__export(fp64_arithmetic_glsl_exports, {
+  fp64arithmeticShader: () => fp64arithmeticShader
+});
+module.exports = __toCommonJS(fp64_arithmetic_glsl_exports);
+const fp64arithmeticShader = (
+  /* glsl */
+  `
+layout(std140) uniform fp64arithmeticUniforms {
+  uniform float ONE;
+  uniform float SPLIT;
+} fp64;
+
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+
+The purpose of this workaround is to prevent shader compilers from
+optimizing away necessary arithmetic operations by swapping their sequences
+or transform the equation to some 'equivalent' form.
+
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
+The method is to multiply an artifical variable, ONE, which will be known to
+the compiler to be 1 only at runtime. The whole expression is then represented
+as a polynomial with respective to ONE. In the coefficients of all terms, only one a
+and one b should appear
+
+err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
+*/
+
+float prevent_fp64_optimization(float value) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  return value + fp64.ONE * 0.0;
+#else
+  return value;
+#endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
+  return vec2(a_hi, a_lo);
+}
+
+// Divide float number again when high float uses too many fraction bits
+vec2 split2(vec2 a) {
+  vec2 b = split(a.x);
+  b.y += a.y;
+  return b;
+}
+
+// Special sum operation when a > b
+vec2 quickTwoSum(float a, float b) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float sum = (a + b) * fp64.ONE;
+  float err = b - (sum - a) * fp64.ONE;
+#else
+  float sum = a + b;
+  float err = b - (sum - a);
+#endif
+  return vec2(sum, err);
+}
+
+// General sum operation
+vec2 twoSum(float a, float b) {
+  float s = (a + b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE + (b - v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) + (b - v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSub(float a, float b) {
+  float s = (a - b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE - (b + v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) - (b + v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSqr(float a) {
+  float prod = a * a;
+  vec2 a_fp64 = split(a);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err = ((a_fp64.x * a_fp64.x - prod) * fp64.ONE + 2.0 * a_fp64.x *
+    a_fp64.y * fp64.ONE * fp64.ONE) + a_fp64.y * a_fp64.y * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+#endif
+  return vec2(prod, err);
+}
+
+vec2 twoProd(float a, float b) {
+  float prod = a * b;
+  vec2 a_fp64 = split(a);
+  vec2 b_fp64 = split(b);
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
+  return vec2(prod, err);
+}
+
+vec2 sum_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSum(a.x, b.x);
+  t = twoSum(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 sub_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSub(a.x, b.x);
+  t = twoSub(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 mul_fp64(vec2 a, vec2 b) {
+  vec2 prod = twoProd(a.x, b.x);
+  // y component is for the error
+  prod.y += a.x * b.y;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  prod.y += a.y * b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+vec2 div_fp64(vec2 a, vec2 b) {
+  float xn = 1.0 / b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  vec2 yn = mul_fp64(a, vec2(xn, 0));
+#else
+  vec2 yn = a * xn;
+#endif
+  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+  vec2 prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+vec2 sqrt_fp64(vec2 a) {
+  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+
+  float x = 1.0 / sqrt(a.x);
+  float yn = a.x * x;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  vec2 yn_sqr = twoSqr(yn) * fp64.ONE;
+#else
+  vec2 yn_sqr = twoSqr(yn);
+#endif
+  float diff = sub_fp64(a, yn_sqr).x;
+  vec2 prod = twoProd(x * 0.5, diff);
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2(yn, 0.0), prod);
+#endif
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fp64arithmeticShader
+});

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

@@ -0,0 +1,2 @@
+export declare const fp64arithmeticShader = "\nlayout(std140) uniform fp64arithmeticUniforms {\n  uniform float ONE;\n  uniform float SPLIT;\n} fp64;\n\n/*\nAbout LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n\nThe purpose of this workaround is to prevent shader compilers from\noptimizing away necessary arithmetic operations by swapping their sequences\nor transform the equation to some 'equivalent' form.\n\nThese helpers implement Dekker/Veltkamp-style error tracking. If the compiler\nfolds constants or reassociates the arithmetic, the high/low split can stop\ntracking the rounding error correctly. That failure mode tends to look fine in\nsimple coordinate setup, but then breaks down inside iterative arithmetic such\nas fp64 Mandelbrot loops.\n\nThe method is to multiply an artifical variable, ONE, which will be known to\nthe compiler to be 1 only at runtime. The whole expression is then represented\nas a polynomial with respective to ONE. In the coefficients of all terms, only one a\nand one b should appear\n\nerr = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE\n*/\n\nfloat prevent_fp64_optimization(float value) {\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  return value + fp64.ONE * 0.0;\n#else\n  return value;\n#endif\n}\n\n// Divide float number to high and low floats to extend fraction bits\nvec2 split(float a) {\n  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker\n  // split into a constant expression and reassociate the recovery steps.\n  float split = prevent_fp64_optimization(fp64.SPLIT);\n  float t = prevent_fp64_optimization(a * split);\n  float temp = t - a;\n  float a_hi = t - temp;\n  float a_lo = a - a_hi;\n  return vec2(a_hi, a_lo);\n}\n\n// Divide float number again when high float uses too many fraction bits\nvec2 split2(vec2 a) {\n  vec2 b = split(a.x);\n  b.y += a.y;\n  return b;\n}\n\n// Special sum operation when a > b\nvec2 quickTwoSum(float a, float b) {\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float sum = (a + b) * fp64.ONE;\n  float err = b - (sum - a) * fp64.ONE;\n#else\n  float sum = a + b;\n  float err = b - (sum - a);\n#endif\n  return vec2(sum, err);\n}\n\n// General sum operation\nvec2 twoSum(float a, float b) {\n  float s = (a + b);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float v = (s * fp64.ONE - a) * fp64.ONE;\n  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE + (b - v);\n#else\n  float v = s - a;\n  float err = (a - (s - v)) + (b - v);\n#endif\n  return vec2(s, err);\n}\n\nvec2 twoSub(float a, float b) {\n  float s = (a - b);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float v = (s * fp64.ONE - a) * fp64.ONE;\n  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE - (b + v);\n#else\n  float v = s - a;\n  float err = (a - (s - v)) - (b + v);\n#endif\n  return vec2(s, err);\n}\n\nvec2 twoSqr(float a) {\n  float prod = a * a;\n  vec2 a_fp64 = split(a);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float err = ((a_fp64.x * a_fp64.x - prod) * fp64.ONE + 2.0 * a_fp64.x *\n    a_fp64.y * fp64.ONE * fp64.ONE) + a_fp64.y * a_fp64.y * fp64.ONE * fp64.ONE * fp64.ONE;\n#else\n  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;\n#endif\n  return vec2(prod, err);\n}\n\nvec2 twoProd(float a, float b) {\n  float prod = a * b;\n  vec2 a_fp64 = split(a);\n  vec2 b_fp64 = split(b);\n  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend\n  // on the split terms and cross terms staying in the original evaluation\n  // order. If the compiler folds or reassociates them, the low part tends to\n  // collapse to zero or NaN on some drivers.\n  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);\n  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);\n  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);\n  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float err1 = (highProduct - prod) * fp64.ONE;\n  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;\n  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;\n  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;\n#else\n  float err1 = highProduct - prod;\n  float err2 = crossProduct1;\n  float err3 = crossProduct2;\n  float err4 = lowProduct;\n#endif\n  float err = ((err1 + err2) + err3) + err4;\n  return vec2(prod, err);\n}\n\nvec2 sum_fp64(vec2 a, vec2 b) {\n  vec2 s, t;\n  s = twoSum(a.x, b.x);\n  t = twoSum(a.y, b.y);\n  s.y += t.x;\n  s = quickTwoSum(s.x, s.y);\n  s.y += t.y;\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nvec2 sub_fp64(vec2 a, vec2 b) {\n  vec2 s, t;\n  s = twoSub(a.x, b.x);\n  t = twoSub(a.y, b.y);\n  s.y += t.x;\n  s = quickTwoSum(s.x, s.y);\n  s.y += t.y;\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nvec2 mul_fp64(vec2 a, vec2 b) {\n  vec2 prod = twoProd(a.x, b.x);\n  // y component is for the error\n  prod.y += a.x * b.y;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  prod.y += a.y * b.x;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\nvec2 div_fp64(vec2 a, vec2 b) {\n  float xn = 1.0 / b.x;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  vec2 yn = mul_fp64(a, vec2(xn, 0));\n#else\n  vec2 yn = a * xn;\n#endif\n  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;\n  vec2 prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nvec2 sqrt_fp64(vec2 a) {\n  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);\n  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);\n\n  float x = 1.0 / sqrt(a.x);\n  float yn = a.x * x;\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  vec2 yn_sqr = twoSqr(yn) * fp64.ONE;\n#else\n  vec2 yn_sqr = twoSqr(yn);\n#endif\n  float diff = sub_fp64(a, yn_sqr).x;\n  vec2 prod = twoProd(x * 0.5, diff);\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2(yn, 0.0), prod);\n#endif\n}\n";
+//# sourceMappingURL=fp64-arithmetic-glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB,ijMAwMhC,CAAC"}

package/dist/modules/math/fp64/fp64-arithmetic-glsl.js

@@ -0,0 +1,205 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const fp64arithmeticShader = /* glsl */ `\
+
+layout(std140) uniform fp64arithmeticUniforms {
+  uniform float ONE;
+  uniform float SPLIT;
+} fp64;
+
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+
+The purpose of this workaround is to prevent shader compilers from
+optimizing away necessary arithmetic operations by swapping their sequences
+or transform the equation to some 'equivalent' form.
+
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
+The method is to multiply an artifical variable, ONE, which will be known to
+the compiler to be 1 only at runtime. The whole expression is then represented
+as a polynomial with respective to ONE. In the coefficients of all terms, only one a
+and one b should appear
+
+err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
+*/
+
+float prevent_fp64_optimization(float value) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  return value + fp64.ONE * 0.0;
+#else
+  return value;
+#endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
+  return vec2(a_hi, a_lo);
+}
+
+// Divide float number again when high float uses too many fraction bits
+vec2 split2(vec2 a) {
+  vec2 b = split(a.x);
+  b.y += a.y;
+  return b;
+}
+
+// Special sum operation when a > b
+vec2 quickTwoSum(float a, float b) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float sum = (a + b) * fp64.ONE;
+  float err = b - (sum - a) * fp64.ONE;
+#else
+  float sum = a + b;
+  float err = b - (sum - a);
+#endif
+  return vec2(sum, err);
+}
+
+// General sum operation
+vec2 twoSum(float a, float b) {
+  float s = (a + b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE + (b - v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) + (b - v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSub(float a, float b) {
+  float s = (a - b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE - (b + v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) - (b + v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSqr(float a) {
+  float prod = a * a;
+  vec2 a_fp64 = split(a);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err = ((a_fp64.x * a_fp64.x - prod) * fp64.ONE + 2.0 * a_fp64.x *
+    a_fp64.y * fp64.ONE * fp64.ONE) + a_fp64.y * a_fp64.y * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+#endif
+  return vec2(prod, err);
+}
+
+vec2 twoProd(float a, float b) {
+  float prod = a * b;
+  vec2 a_fp64 = split(a);
+  vec2 b_fp64 = split(b);
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
+  return vec2(prod, err);
+}
+
+vec2 sum_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSum(a.x, b.x);
+  t = twoSum(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 sub_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSub(a.x, b.x);
+  t = twoSub(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 mul_fp64(vec2 a, vec2 b) {
+  vec2 prod = twoProd(a.x, b.x);
+  // y component is for the error
+  prod.y += a.x * b.y;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  prod.y += a.y * b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+vec2 div_fp64(vec2 a, vec2 b) {
+  float xn = 1.0 / b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  vec2 yn = mul_fp64(a, vec2(xn, 0));
+#else
+  vec2 yn = a * xn;
+#endif
+  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+  vec2 prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+vec2 sqrt_fp64(vec2 a) {
+  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+
+  float x = 1.0 / sqrt(a.x);
+  float yn = a.x * x;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  vec2 yn_sqr = twoSqr(yn) * fp64.ONE;
+#else
+  vec2 yn_sqr = twoSqr(yn);
+#endif
+  float diff = sub_fp64(a, yn_sqr).x;
+  vec2 prod = twoProd(x * 0.5, diff);
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2(yn, 0.0), prod);
+#endif
+}
+`;
+//# sourceMappingURL=fp64-arithmetic-glsl.js.map

package/dist/modules/math/fp64/fp64-arithmetic-glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-glsl.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwM9C,CAAC"}

package/dist/modules/math/fp64/fp64-arithmetic-wgsl-hybrid.cjs

@@ -0,0 +1,144 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fp64_arithmetic_wgsl_hybrid_exports = {};
+__export(fp64_arithmetic_wgsl_hybrid_exports, {
+  fp64arithmeticWGSLHybrid: () => fp64arithmeticWGSLHybrid
+});
+module.exports = __toCommonJS(fp64_arithmetic_wgsl_hybrid_exports);
+var import_fp64_arithmetic_wgsl_integer = require("./fp64-arithmetic-wgsl-integer.cjs");
+const fp64arithmeticWGSLHybrid = (
+  /* wgsl */
+  `${import_fp64_arithmetic_wgsl_integer.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
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fp64arithmeticWGSLHybrid
+});

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

@@ -0,0 +1,10 @@
+/**
+ * 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 declare const fp64arithmeticWGSLHybrid = "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  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";
+//# sourceMappingURL=fp64-arithmetic-wgsl-hybrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-wgsl-hybrid.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl-hybrid.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,qsYAkHpC,CAAC"}