@cortex-js/compute-engine 0.35.5 → 0.35.6

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.5 */
+/** Compute Engine 0.35.6 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -15097,22 +15097,22 @@ function polynomialDivide(dividend, divisor, variable) {
   if (dividendDeg < divisorDeg) {
     return [ce.Zero, dividend];
   }
-  const remainder = dividendCoeffs.map((c) => c);
+  const remainder2 = dividendCoeffs.map((c) => c);
   const quotientCoeffs = new Array(
     dividendDeg - divisorDeg + 1
   ).fill(ce.Zero);
   const leadingDivisor = divisorCoeffs[divisorDeg];
   for (let i = dividendDeg; i >= divisorDeg; i--) {
-    if (remainder[i].is(0)) continue;
-    const quotientCoef = remainder[i].div(leadingDivisor);
+    if (remainder2[i].is(0)) continue;
+    const quotientCoef = remainder2[i].div(leadingDivisor);
     quotientCoeffs[i - divisorDeg] = quotientCoef;
     for (let j = 0; j <= divisorDeg; j++) {
       const product = quotientCoef.mul(divisorCoeffs[j]);
-      remainder[i - divisorDeg + j] = remainder[i - divisorDeg + j].sub(product);
+      remainder2[i - divisorDeg + j] = remainder2[i - divisorDeg + j].sub(product);
     }
   }
   const quotient = fromCoefficients(quotientCoeffs, variable);
-  const remainderPoly = fromCoefficients(remainder, variable);
+  const remainderPoly = fromCoefficients(remainder2, variable);
   return [quotient, remainderPoly];
 }
 function polynomialGCD(a, b, variable) {
@@ -15139,9 +15139,9 @@ function polynomialGCD(a, b, variable) {
     if (!divResult) {
       return ce.One;
     }
-    const [, remainder] = divResult;
+    const [, remainder2] = divResult;
     p = q;
-    q = remainder;
+    q = remainder2;
   }
   return makeMonic(p, variable);
 }
@@ -20812,6 +20812,7 @@ var init_abstract_boxed_expression = __esm({
           });
         } catch (e) {
           if (options?.fallback ?? true) {
+            console.warn(`Compilation fallback for "${this.operator}": ${e.message}`);
             const { applicableN1: applicableN12 } = (init_function_utils(), __toCommonJS(function_utils_exports));
             return applicableN12(this);
           }
@@ -32536,26 +32537,23 @@ function monteCarloEstimate(f, a, b, n = 1e5) {
     for (let i = 0; i < n; i++) {
       const u = Math.random();
       const x = Math.tan(Math.PI * (u - 0.5));
-      const jacobian = Math.PI * (1 + x * x);
-      const val = f(x) / jacobian;
+      const val = f(x) * Math.PI * (1 + x * x);
       sum2 += val;
       sumSq += val * val;
     }
   } else if (a === -Infinity) {
     for (let i = 0; i < n; i++) {
       const u = Math.random();
-      const x = b - Math.log(1 - u);
-      const jacobian = 1 / (1 - u);
-      const val = f(x) / jacobian;
+      const x = b + Math.log(u);
+      const val = f(x) / u;
       sum2 += val;
       sumSq += val * val;
     }
   } else if (b === Infinity) {
     for (let i = 0; i < n; i++) {
       const u = Math.random();
-      const x = a + Math.log(u);
-      const jacobian = 1 / u;
-      const val = f(x) / jacobian;
+      const x = a - Math.log(u);
+      const val = f(x) / u;
       sum2 += val;
       sumSq += val * val;
     }
@@ -32569,7 +32567,7 @@ function monteCarloEstimate(f, a, b, n = 1e5) {
   const mean2 = sum2 / n;
   const variance2 = (sumSq - n * mean2 * mean2) / (n - 1);
   const stdError = Math.sqrt(variance2 / n);
-  const scale = b - a;
+  const scale = isFinite(a) && isFinite(b) ? b - a : 1;
   const estimate = mean2 * scale;
   const error = stdError * scale;
   const rounded = roundEstimateToError(estimate, error);
@@ -34149,10 +34147,10 @@ function antiderivative(fn, index) {
     if (numDeg >= 0 && denDeg >= 0 && numDeg >= denDeg) {
       const divResult = polynomialDivide(fn.op1, fn.op2, index);
       if (divResult) {
-        const [quotient, remainder] = divResult;
+        const [quotient, remainder2] = divResult;
         const quotientIntegral = antiderivative(quotient, index);
-        if (!remainder.is(0)) {
-          const remainderFraction = remainder.div(fn.op2);
+        if (!remainder2.is(0)) {
+          const remainderFraction = remainder2.div(fn.op2);
           const remainderIntegral = antiderivative(remainderFraction, index);
           return add3(quotientIntegral, remainderIntegral);
         }
@@ -34407,8 +34405,8 @@ function antiderivative(fn, index) {
         const linearFactor = ce.symbol(index).sub(r);
         const quotient = polynomialDivide(denominator, linearFactor, index);
         if (quotient) {
-          const [quad, remainder] = quotient;
-          if (remainder.is(0)) {
+          const [quad, remainder2] = quotient;
+          if (remainder2.is(0)) {
             const quadCoeffs = getQuadraticCoefficients(quad, index);
             if (quadCoeffs) {
               const { a: qa, b: qb, c: qc } = quadCoeffs;
@@ -51709,7 +51707,18 @@ var JAVASCRIPT_FUNCTIONS = {
   Sinh: "Math.sinh",
   Sqrt: "Math.sqrt",
   Tan: "Math.tan",
-  Tanh: "Math.tanh"
+  Tanh: "Math.tanh",
+  Mod: ([a, b], compile) => {
+    if (a === null || b === null) throw new Error("Mod: missing argument");
+    const ca = compile(a);
+    const cb = compile(b);
+    return `((${ca} % ${cb}) + ${cb}) % ${cb}`;
+  },
+  Truncate: "Math.trunc",
+  Remainder: ([a, b], compile) => {
+    if (a === null || b === null) throw new Error("Remainder: missing argument");
+    return `(${compile(a)} - ${compile(b)} * Math.round(${compile(a)} / ${compile(b)}))`;
+  }
 };
 var ComputeEngineFunction = class extends Function {
   SYS = {
@@ -51997,6 +52006,11 @@ var GLSL_FUNCTIONS = {
   Sqrt: "sqrt",
   Step: "step",
   Tan: "tan",
+  Truncate: "trunc",
+  Remainder: ([a, b], compile) => {
+    if (a === null || b === null) throw new Error("Remainder: missing argument");
+    return `(${compile(a)} - ${compile(b)} * round(${compile(a)} / ${compile(b)}))`;
+  },
   // Reciprocal trigonometric functions (no GLSL built-ins)
   Cot: ([x], compile) => {
     if (x === null) throw new Error("Cot: no argument");
@@ -52658,6 +52672,22 @@ function fract(x) {
   }
   return { kind: "singular", at: flo + 1, continuity: "right" };
 }
+function trunc2(x) {
+  const unwrapped = unwrapOrPropagate(x);
+  if (!Array.isArray(unwrapped)) return unwrapped;
+  const [xVal] = unwrapped;
+  const tlo = Math.trunc(xVal.lo);
+  const thi = Math.trunc(xVal.hi);
+  if (tlo === thi) return ok({ lo: tlo, hi: thi });
+  if (xVal.lo >= 0) {
+    return { kind: "singular", at: tlo + 1, continuity: "right" };
+  }
+  const firstInt = Math.ceil(xVal.lo);
+  if (firstInt !== 0) {
+    return { kind: "singular", at: firstInt, continuity: "left" };
+  }
+  return { kind: "singular", at: 1, continuity: "right" };
+}
 function min2(a, b) {
   const unwrapped = unwrapOrPropagate(a, b);
   if (!Array.isArray(unwrapped)) return unwrapped;
@@ -52695,6 +52725,9 @@ function mod2(a, b) {
   const modHi = aVal.hi - period * flo;
   return ok({ lo: Math.min(modLo, modHi), hi: Math.max(modLo, modHi) });
 }
+function remainder(a, b) {
+  return sub2(a, mul4(b, round2(div3(a, b))));
+}
 function sign2(x) {
   const unwrapped = unwrapOrPropagate(x);
   if (!Array.isArray(unwrapped)) return unwrapped;
@@ -53185,9 +53218,11 @@ var IntervalArithmetic = {
   ceil: ceil2,
   round: round2,
   fract,
+  trunc: trunc2,
   min: min2,
   max: max2,
   mod: mod2,
+  remainder,
   sign: sign2,
   // Trigonometric
   sin: sin2,
@@ -53375,14 +53410,12 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   Arcoth: (args, compile) => `_IA.acoth(${compile(args[0])})`,
   Arcsch: (args, compile) => `_IA.acsch(${compile(args[0])})`,
   Arsech: (args, compile) => `_IA.asech(${compile(args[0])})`,
-  // Inverse trig (alternative names)
-  Asin: (args, compile) => `_IA.asin(${compile(args[0])})`,
-  Acos: (args, compile) => `_IA.acos(${compile(args[0])})`,
-  Atan: (args, compile) => `_IA.atan(${compile(args[0])})`,
   // Elementary
   Fract: (args, compile) => `_IA.fract(${compile(args[0])})`,
-  // Mod
+  Truncate: (args, compile) => `_IA.trunc(${compile(args[0])})`,
+  // Mod / Remainder
   Mod: (args, compile) => `_IA.mod(${compile(args[0])}, ${compile(args[1])})`,
+  Remainder: (args, compile) => `_IA.remainder(${compile(args[0])}, ${compile(args[1])})`,
   // Conditionals
   If: (args, compile) => {
     if (args.length !== 3) throw new Error("If: wrong number of arguments");
@@ -53702,6 +53735,22 @@ IntervalResult ia_ln(vec2 x) {
   return ia_partial(vec2(-IA_HUGE, log(x.y) + IA_EPS), IA_PARTIAL_LO);
 }
 
+// Log base 2
+IntervalResult ia_log2(vec2 x) {
+  const float INV_LN2 = 1.44269504089;
+  if (x.y <= 0.0) return ia_empty();
+  if (x.x > 0.0) return ia_ok(vec2(log2(x.x) - IA_EPS, log2(x.y) + IA_EPS));
+  return ia_partial(vec2(-IA_HUGE, log2(x.y) + IA_EPS), IA_PARTIAL_LO);
+}
+
+// Log base 10
+IntervalResult ia_log10(vec2 x) {
+  const float INV_LN10 = 0.43429448190;
+  if (x.y <= 0.0) return ia_empty();
+  if (x.x > 0.0) return ia_ok(vec2(log(x.x) * INV_LN10 - IA_EPS, log(x.y) * INV_LN10 + IA_EPS));
+  return ia_partial(vec2(-IA_HUGE, log(x.y) * INV_LN10 + IA_EPS), IA_PARTIAL_LO);
+}
+
 // Absolute value
 IntervalResult ia_abs(vec2 x) {
   if (x.x >= 0.0) {
@@ -53775,6 +53824,18 @@ IntervalResult ia_fract(vec2 x) {
   return ia_singular_right(flo + 1.0);
 }
 
+// Truncate toward zero - floor for positive, ceil for negative
+// Discontinuous at every non-zero integer, continuous at zero
+IntervalResult ia_trunc(vec2 x) {
+  float tlo = trunc(x.x);
+  float thi = trunc(x.y);
+  if (tlo == thi) return ia_ok(vec2(tlo, thi));
+  if (x.x >= 0.0) return ia_singular_right(tlo + 1.0);  // like floor
+  float firstInt = ceil(x.x);
+  if (firstInt != 0.0) return ia_singular_left(firstInt); // like ceil
+  return ia_singular_right(1.0); // spans zero, first discontinuity at +1
+}
+
 // Mod - periodic discontinuities at multiples of the modulus
 // mod(x, y) = x - y * floor(x / y)
 IntervalResult ia_mod(vec2 x, vec2 y) {
@@ -53808,6 +53869,16 @@ IntervalResult ia_mod(vec2 x, vec2 y) {
   return ia_sub(x, ia_mul_raw(y, fq.value));
 }
 
+// IEEE remainder: a - b * round(a / b)
+// Discontinuities arise from round when a/b spans a half-integer
+IntervalResult ia_remainder(vec2 a, vec2 b) {
+  IntervalResult q = ia_div(a, b);
+  if (ia_is_error(q.status)) return q;
+  IntervalResult rq = ia_round(q.value);
+  if (ia_is_error(rq.status)) return rq;
+  return ia_sub(a, ia_mul_raw(b, rq.value));
+}
+
 // Min of two intervals
 IntervalResult ia_min(vec2 a, vec2 b) {
   return ia_ok(vec2(min(a.x, b.x), min(a.y, b.y)));
@@ -54074,6 +54145,16 @@ IntervalResult ia_ln(IntervalResult x) {
   return ia_ln(x.value);
 }
 
+IntervalResult ia_log2(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_log2(x.value);
+}
+
+IntervalResult ia_log10(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_log10(x.value);
+}
+
 IntervalResult ia_abs(IntervalResult x) {
   if (ia_is_error(x.status)) return x;
   return ia_abs(x.value);
@@ -54104,6 +54185,11 @@ IntervalResult ia_fract(IntervalResult x) {
   return ia_fract(x.value);
 }
 
+IntervalResult ia_trunc(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_trunc(x.value);
+}
+
 IntervalResult ia_mod(IntervalResult a, IntervalResult b) {
   if (ia_is_error(a.status)) return a;
   if (ia_is_error(b.status)) return b;
@@ -54120,6 +54206,22 @@ IntervalResult ia_mod(vec2 a, IntervalResult b) {
   return ia_mod(a, b.value);
 }
 
+IntervalResult ia_remainder(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_remainder(a.value, b.value);
+}
+
+IntervalResult ia_remainder(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_remainder(a.value, b);
+}
+
+IntervalResult ia_remainder(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_remainder(a, b.value);
+}
+
 IntervalResult ia_min(IntervalResult a, IntervalResult b) {
   if (ia_is_error(a.status)) return a;
   if (ia_is_error(b.status)) return b;
@@ -54510,8 +54612,15 @@ var INTERVAL_GLSL_FUNCTIONS = {
   Exp: (args, compile) => `ia_exp(${compile(args[0])})`,
   Floor: (args, compile) => `ia_floor(${compile(args[0])})`,
   Fract: (args, compile) => `ia_fract(${compile(args[0])})`,
+  Truncate: (args, compile) => `ia_trunc(${compile(args[0])})`,
+  Lb: (args, compile) => `ia_log2(${compile(args[0])})`,
   Ln: (args, compile) => `ia_ln(${compile(args[0])})`,
+  Log: (args, compile) => {
+    if (args.length === 1) return `ia_log10(${compile(args[0])})`;
+    return `ia_div(ia_ln(${compile(args[0])}), ia_ln(${compile(args[1])}))`;
+  },
   Mod: (args, compile) => `ia_mod(${compile(args[0])}, ${compile(args[1])})`,
+  Remainder: (args, compile) => `ia_remainder(${compile(args[0])}, ${compile(args[1])})`,
   Max: (args, compile) => {
     if (args.length === 0) return "ia_point(-1e38)";
     if (args.length === 1) return compile(args[0]);
@@ -54544,6 +54653,15 @@ var INTERVAL_GLSL_FUNCTIONS = {
     }
     throw new Error("Interval GLSL does not support variable exponents");
   },
+  Root: (args, compile) => {
+    const [arg, exp3] = args;
+    if (arg === null) throw new Error("Root: no argument");
+    if (exp3 === null || exp3?.re === 2) return `ia_sqrt(${compile(arg)})`;
+    if (exp3?.isNumberLiteral && exp3.im === 0) {
+      return `ia_pow(${compile(arg)}, ${1 / exp3.re})`;
+    }
+    throw new Error("Interval GLSL does not support variable root indices");
+  },
   Round: (args, compile) => `ia_round(${compile(args[0])})`,
   Sign: (args, compile) => `ia_sign(${compile(args[0])})`,
   Sqrt: (args, compile) => `ia_sqrt(${compile(args[0])})`,
@@ -56486,10 +56604,10 @@ function defToString(name, def, v) {
 // src/compute-engine.ts
 init_types6();
 init_base_compiler();
-var version = "0.35.5";
+var version = "0.35.6";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.35.5"
+  version: "0.35.6"
 };
 export {
   BaseCompiler,