export declare const fp64arithmeticWGSL = "struct Fp64ArithmeticUniforms {\n  ONE: f32,\n  SPLIT: f32,\n};\n\n@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;\n\nfn fp64_nan(seed: f32) -> f32 {\n  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);\n  return bitcast<f32>(nanBits);\n}\n\nfn fp64_runtime_zero() -> f32 {\n  return fp64arithmetic.ONE * 0.0;\n}\n\nfn prevent_fp64_optimization(value: f32) -> f32 {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  return value + fp64_runtime_zero();\n#else\n  return value;\n#endif\n}\n\nfn split(a: f32) -> vec2f {\n  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());\n  let t = prevent_fp64_optimization(a * splitValue);\n  let temp = prevent_fp64_optimization(t - a);\n  let aHi = prevent_fp64_optimization(t - temp);\n  let aLo = prevent_fp64_optimization(a - aHi);\n  return vec2f(aHi, aLo);\n}\n\nfn split2(a: vec2f) -> vec2f {\n  var b = split(a.x);\n  b.y = b.y + a.y;\n  return b;\n}\n\nfn quickTwoSum(a: f32, b: f32) -> vec2f {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);\n  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);\n#else\n  let sum = prevent_fp64_optimization(a + b);\n  let err = prevent_fp64_optimization(b - (sum - a));\n#endif\n  return vec2f(sum, err);\n}\n\nfn twoSum(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a + b);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);\n  let err =\n    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE) +\n    prevent_fp64_optimization(b - v);\n#else\n  let v = prevent_fp64_optimization(s - a);\n  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);\n#endif\n  return vec2f(s, err);\n}\n\nfn twoSub(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a - b);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);\n  let err =\n    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE) -\n    prevent_fp64_optimization(b + v);\n#else\n  let v = prevent_fp64_optimization(s - a);\n  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);\n#endif\n  return vec2f(s, err);\n}\n\nfn twoSqr(a: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * a);\n  let aFp64 = split(a);\n  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);\n  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err =\n    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +\n      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +\n    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n#else\n  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);\n#endif\n  return vec2f(prod, err);\n}\n\nfn twoProd(a: f32, b: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * b);\n  let aFp64 = split(a);\n  let bFp64 = split(b);\n  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);\n  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);\n  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err1 = (highProduct - prod) * fp64arithmetic.ONE;\n  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err4 =\n    lowProduct *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE;\n#else\n  let err1 = highProduct - prod;\n  let err2 = crossProduct1;\n  let err3 = crossProduct2;\n  let err4 = lowProduct;\n#endif\n  let err12InputA = prevent_fp64_optimization(err1);\n  let err12InputB = prevent_fp64_optimization(err2);\n  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);\n  let err123InputA = prevent_fp64_optimization(err12);\n  let err123InputB = prevent_fp64_optimization(err3);\n  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);\n  let err1234InputA = prevent_fp64_optimization(err123);\n  let err1234InputB = prevent_fp64_optimization(err4);\n  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);\n  return vec2f(prod, err);\n}\n\nfn sum_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSum(a.x, b.x);\n  let t = twoSum(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn sub_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSub(a.x, b.x);\n  let t = twoSub(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn mul_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var prod = twoProd(a.x, b.x);\n  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\nfn div_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let xn = prevent_fp64_optimization(1.0 / b.x);\n  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));\n  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);\n  let prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nfn sqrt_fp64(a: vec2f) -> vec2f {\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2f(0.0, 0.0);\n  }\n  if (a.x < 0.0) {\n    let nanValue = fp64_nan(a.x);\n    return vec2f(nanValue, nanValue);\n  }\n\n  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));\n  let yn = prevent_fp64_optimization(a.x * x);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;\n#else\n  let ynSqr = twoSqr(yn);\n#endif\n  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);\n  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2f(yn, 0.0), prod);\n#endif\n}\n";
//# sourceMappingURL=fp64-arithmetic-wgsl.d.ts.map