@cortex-js/compute-engine 0.55.4 → 0.55.5

package/dist/compile.umd.cjs

@@ -1,4 +1,4 @@
-/** Compile 0.55.4 */
+/** Compile 0.55.5 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Compile = {}));})(this, (function (exports) { 'use strict';
 var Compile = (() => {
   var __defProp = Object.defineProperty;
@@ -15099,7 +15099,8 @@ ${lines.join("\n")}`;
         vars: options?.vars,
         imports: options?.imports,
         preamble: options?.preamble,
-        realOnly: options?.realOnly
+        realOnly: options?.realOnly,
+        hints: options?.hints
       });
     } catch (e) {
       if (options?.fallback ?? true) {
@@ -20782,12 +20783,22 @@ ${lines.join("\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);
@@ -21395,12 +21406,12 @@ ${lines.join("\n")}`;
       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})`;
     },
@@ -21410,14 +21421,14 @@ ${lines.join("\n")}`;
       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})`;
     },
@@ -22132,6 +22143,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
@@ -22172,6 +22200,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);
@@ -22257,6 +22300,16 @@ fn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {
 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;
@@ -22348,6 +22401,16 @@ float _fractal_julia_pt(vec2 z_delta, vec2 delta_c, int maxIter) {
 @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;
@@ -22945,8 +23008,32 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
             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(
@@ -25305,7 +25392,7 @@ ${code}`;
   }
 
   // src/compile.ts
-  var version = "0.55.4";
+  var version = "0.55.5";
   return __toCommonJS(compile_exports);
 })();
 /*! Bundled license information:

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 0.55.5 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -54763,7 +54763,8 @@ function compile(expr2, 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) {
@@ -61264,12 +61265,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);
@@ -61877,12 +61888,12 @@ var GPU_FUNCTIONS = {
     const iterCode = compileIntArg(maxIter, compile3, target);
     const strategy = selectFractalStrategy(target);
     if (strategy === "double") {
-      const cCode = compile3(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 = compile3(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(${compile3(c)}, ${iterCode})`;
   },
@@ -61892,14 +61903,14 @@ var GPU_FUNCTIONS = {
     const iterCode = compileIntArg(maxIter, compile3, target);
     const strategy = selectFractalStrategy(target);
     if (strategy === "double") {
-      const zCode = compile3(z);
+      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
       const cCode = compile3(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 = compile3(z);
+      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
       const cCode = compile3(c);
-      return `_fractal_julia_pt(${zCode}, ${cCode}, ${iterCode})`;
+      return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
     }
     return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
   },
@@ -62614,6 +62625,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
@@ -62654,6 +62682,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);
@@ -62739,6 +62782,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;
@@ -62830,6 +62883,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;
@@ -63427,8 +63490,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(
@@ -68857,19 +68944,20 @@ var ComputeEngine = class _ComputeEngine {
 _setDefaultEngineFactory(() => new ComputeEngine());
 
 // src/compute-engine.ts
-var version = "0.55.4";
+var version = "0.55.5";
 ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
 _setDefaultEngineFactory(
   () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
 );
 globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.55.4"
+  version: "0.55.5"
 };
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,
   BaseCompiler,
+  BigDecimal,
   DEFINITIONS_CALCULUS as CALCULUS_DICTIONARY,
   DEFINITIONS_COMPLEX as COMPLEX_DICTIONARY,
   DEFINITIONS_CORE as CORE_DICTIONARY,