@cortex-js/compute-engine 0.55.4 → 0.55.5

package/dist/compile.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 0.55.5 */
 
 // src/compute-engine/numerics/richardson.ts
 function extrapolate(f, x0, options = {}) {
@@ -15066,7 +15066,8 @@ function compile(expr, options) {
       vars: options?.vars,
       imports: options?.imports,
       preamble: options?.preamble,
-      realOnly: options?.realOnly
+      realOnly: options?.realOnly,
+      hints: options?.hints
     });
   } catch (e) {
     if (options?.fallback ?? true) {
@@ -20749,12 +20750,22 @@ function fibonacci(n) {
 }
 
 // src/compute-engine/compilation/fractal-orbit.ts
+function toBigDecimal(v) {
+  if (typeof v === "object" && "hi" in v)
+    return new BigDecimal(v.hi).add(new BigDecimal(v.lo));
+  return new BigDecimal(v);
+}
+function hpToNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return Number(v);
+  return v.hi + v.lo;
+}
 function computeReferenceOrbit(center, maxIter, precision) {
   const prevPrecision = BigDecimal.precision;
   BigDecimal.precision = precision;
   try {
-    const cr = new BigDecimal(center[0]);
-    const ci = new BigDecimal(center[1]);
+    const cr = toBigDecimal(center[0]);
+    const ci = toBigDecimal(center[1]);
     let zr = BigDecimal.ZERO;
     let zi = BigDecimal.ZERO;
     const ESCAPE = new BigDecimal(256);
@@ -21362,12 +21373,12 @@ var GPU_FUNCTIONS = {
     const iterCode = compileIntArg(maxIter, compile2, target);
     const strategy = selectFractalStrategy(target);
     if (strategy === "double") {
-      const cCode = compile2(c);
-      return `_fractal_mandelbrot_dp(vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
+      return `_fractal_mandelbrot_dp(${dpCoord}, ${iterCode})`;
     }
     if (strategy === "perturbation") {
-      const cCode = compile2(c);
-      return `_fractal_mandelbrot_pt(${cCode}, ${iterCode})`;
+      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
+      return `_fractal_mandelbrot_pt(${ptDelta}, ${iterCode})`;
     }
     return `_fractal_mandelbrot(${compile2(c)}, ${iterCode})`;
   },
@@ -21377,14 +21388,14 @@ var GPU_FUNCTIONS = {
     const iterCode = compileIntArg(maxIter, compile2, target);
     const strategy = selectFractalStrategy(target);
     if (strategy === "double") {
-      const zCode = compile2(z);
+      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
       const cCode = compile2(c);
-      return `_fractal_julia_dp(vec4(${zCode}, vec2(0.0)), vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+      return `_fractal_julia_dp(${dpCoord}, vec4(${cCode}, vec2(0.0)), ${iterCode})`;
     }
     if (strategy === "perturbation") {
-      const zCode = compile2(z);
+      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
       const cCode = compile2(c);
-      return `_fractal_julia_pt(${zCode}, ${cCode}, ${iterCode})`;
+      return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
     }
     return `_fractal_julia(${compile2(z)}, ${compile2(c)}, ${iterCode})`;
   },
@@ -22099,6 +22110,23 @@ fn ds_cmp(a: vec2f, b: vec2f) -> f32 {
 }
 `;
 var GPU_FRACTAL_DP_PREAMBLE_GLSL = `
+uniform float _dp_cx_hi;
+uniform float _dp_cx_lo;
+uniform float _dp_cy_hi;
+uniform float _dp_cy_lo;
+uniform float _dp_w;
+uniform float _dp_h;
+
+vec4 _dp_coord() {
+  // Per-pixel offset from center \u2014 small, so float-precise
+  float dx = (v_uv.x - 0.5) * _dp_w;
+  float dy = (v_uv.y - 0.5) * _dp_h;
+  // Combine center (hi+lo) + delta with emulated double precision
+  vec2 cre = ds_add(vec2(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
+  vec2 cim = ds_add(vec2(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
+  return vec4(cre.x, cim.x, cre.y, cim.y);
+}
+
 float _fractal_mandelbrot_dp(vec4 c, int maxIter) {
   // c = (re_hi, im_hi, re_lo, im_lo)
   vec2 cr = vec2(c.x, c.z);  // real part as ds
@@ -22139,6 +22167,21 @@ float _fractal_julia_dp(vec4 z_in, vec4 c, int maxIter) {
 }
 `;
 var GPU_FRACTAL_DP_PREAMBLE_WGSL = `
+@group(0) @binding(10) var<uniform> _dp_cx_hi: f32;
+@group(0) @binding(11) var<uniform> _dp_cx_lo: f32;
+@group(0) @binding(12) var<uniform> _dp_cy_hi: f32;
+@group(0) @binding(13) var<uniform> _dp_cy_lo: f32;
+@group(0) @binding(14) var<uniform> _dp_w: f32;
+@group(0) @binding(15) var<uniform> _dp_h: f32;
+
+fn _dp_coord(uv: vec2f) -> vec4f {
+  let dx = (uv.x - 0.5) * _dp_w;
+  let dy = (uv.y - 0.5) * _dp_h;
+  let cre = ds_add(vec2f(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
+  let cim = ds_add(vec2f(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
+  return vec4f(cre.x, cim.x, cre.y, cim.y);
+}
+
 fn _fractal_mandelbrot_dp(c: vec4f, maxIter: i32) -> f32 {
   let cr = vec2f(c.x, c.z);
   let ci = vec2f(c.y, c.w);
@@ -22224,6 +22267,16 @@ var GPU_FRACTAL_PT_PREAMBLE_GLSL = `
 uniform sampler2D _refOrbit;
 uniform int _refOrbitLen;
 uniform int _refOrbitTexWidth;
+uniform float _pt_offset_x;
+uniform float _pt_offset_y;
+uniform float _pt_w;
+uniform float _pt_h;
+
+vec2 _pt_delta() {
+  float dx = _pt_offset_x + (v_uv.x - 0.5) * _pt_w;
+  float dy = _pt_offset_y + (v_uv.y - 0.5) * _pt_h;
+  return vec2(dx, dy);
+}
 
 vec2 _pt_fetch_orbit(int i) {
   int y = i / _refOrbitTexWidth;
@@ -22315,6 +22368,16 @@ var GPU_FRACTAL_PT_PREAMBLE_WGSL = `
 @group(0) @binding(1) var _refOrbit: texture_2d<f32>;
 var<uniform> _refOrbitLen: i32;
 var<uniform> _refOrbitTexWidth: i32;
+var<uniform> _pt_offset_x: f32;
+var<uniform> _pt_offset_y: f32;
+var<uniform> _pt_w: f32;
+var<uniform> _pt_h: f32;
+
+fn _pt_delta(uv: vec2f) -> vec2f {
+  let dx = _pt_offset_x + (uv.x - 0.5) * _pt_w;
+  let dy = _pt_offset_y + (uv.y - 0.5) * _pt_h;
+  return vec2f(dx, dy);
+}
 
 fn _pt_fetch_orbit(i: i32) -> vec2f {
   let y = i / _refOrbitTexWidth;
@@ -22912,8 +22975,32 @@ var GPUShaderTarget = class {
           break;
       }
     }
+    if ((code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) && options.hints?.viewport) {
+      const cx = hpToNumber(options.hints.viewport.center[0]);
+      const cy = hpToNumber(options.hints.viewport.center[1]);
+      const size = options.hints.viewport.radius * 2;
+      const cx_hi = Math.fround(cx);
+      const cy_hi = Math.fround(cy);
+      result.uniforms = {
+        ...result.uniforms,
+        _dp_cx_hi: cx_hi,
+        _dp_cx_lo: cx - cx_hi,
+        _dp_cy_hi: cy_hi,
+        _dp_cy_lo: cy - cy_hi,
+        _dp_w: size,
+        _dp_h: size
+      };
+    }
     if ((code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
       const viewport = options.hints.viewport;
+      const size = viewport.radius * 2;
+      result.uniforms = {
+        ...result.uniforms,
+        _pt_offset_x: 0,
+        _pt_offset_y: 0,
+        _pt_w: size,
+        _pt_h: size
+      };
       const digits = Math.max(50, Math.ceil(-Math.log10(viewport.radius)) + 10);
       const maxIter = 1e3;
       const orbit = computeReferenceOrbit(
@@ -25272,7 +25359,7 @@ function compileToIntervalTarget(expr, target) {
 }
 
 // src/compile.ts
-var version = "0.55.4";
+var version = "0.55.5";
 export {
   BaseCompiler,
   GLSLTarget,