@cortex-js/compute-engine 0.35.4 → 0.35.6

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.4 */
+/** Compute Engine 0.35.6 */
     (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.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -15099,22 +15099,22 @@ var ComputeEngine = (() => {
     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) {
@@ -15141,9 +15141,9 @@ var ComputeEngine = (() => {
       if (!divResult) {
         return ce.One;
       }
-      const [, remainder] = divResult;
+      const [, remainder2] = divResult;
       p = q;
-      q = remainder;
+      q = remainder2;
     }
     return makeMonic(p, variable);
   }
@@ -20814,6 +20814,7 @@ var ComputeEngine = (() => {
             });
           } 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);
             }
@@ -23826,7 +23827,8 @@ ${e.message}`);
     }
     if (type2.kind === "list" || type2.kind === "set" || type2.kind === "tuple")
       return true;
-    if (type2.kind === "union") return type2.types.some((t) => typeCouldBeCollection(t));
+    if (type2.kind === "union")
+      return type2.types.some((t) => typeCouldBeCollection(t));
     return false;
   }
   function typeCouldBeNumericCollection(type2) {
@@ -24634,6 +24636,16 @@ ${lines.join("\n")}`;
               return engine.function("Power", [engine.E, ...args]);
             }
           },
+          Exp2: {
+            description: "Base-2 exponential: 2^x",
+            complexity: 3500,
+            broadcastable: true,
+            signature: "(number) -> number",
+            canonical: (args, { engine }) => {
+              args = checkNumericArgs(engine, args, 1);
+              return engine.function("Power", [engine.number(2), ...args]);
+            }
+          },
           Factorial: {
             description: "Factorial function: the product of all positive integers less than or equal to n",
             wikidata: "Q120976",
@@ -24723,6 +24735,22 @@ ${lines.join("\n")}`;
               (z) => z.floor(0)
             )
           },
+          Fract: {
+            description: "Fractional part of a number: x - floor(x)",
+            complexity: 1250,
+            broadcastable: true,
+            signature: "(number) -> number",
+            sgn: ([x]) => {
+              if (x.isNonNegative) return "non-negative";
+              return void 0;
+            },
+            evaluate: ([x]) => apply(
+              x,
+              (x2) => x2 - Math.floor(x2),
+              (x2) => x2.sub(x2.floor()),
+              (z) => z.sub(z.floor(0))
+            )
+          },
           Gamma: {
             wikidata: "Q190573",
             complexity: 8e3,
@@ -24938,6 +24966,22 @@ ${lines.join("\n")}`;
             sgn: ([x]) => lnSign(x),
             canonical: ([x], { engine }) => engine._fn("Log", [x])
           },
+          Log10: {
+            description: "Base-10 Logarithm",
+            complexity: 4100,
+            broadcastable: true,
+            signature: "(number) -> number",
+            sgn: ([x]) => lnSign(x),
+            canonical: ([x], { engine }) => engine._fn("Log", [x])
+          },
+          Log2: {
+            description: "Base-2 Logarithm",
+            complexity: 4100,
+            broadcastable: true,
+            signature: "(number) -> number",
+            sgn: ([x]) => lnSign(x),
+            canonical: ([x], { engine }) => engine._fn("Log", [x, engine.number(2)])
+          },
           Mod: {
             description: "Modulo",
             wikidata: "Q1799665",
@@ -25180,6 +25224,18 @@ ${lines.join("\n")}`;
             },
             evaluate: ([x, n], { numericApproximation }) => root(x, n, { numericApproximation })
           },
+          Remainder: {
+            description: "IEEE remainder: the signed remainder after dividing x by y, with the quotient rounded to the nearest integer",
+            complexity: 2500,
+            broadcastable: true,
+            signature: "(number, number) -> number",
+            evaluate: ([a, b]) => apply2(
+              a,
+              b,
+              (a2, b2) => a2 - b2 * Math.round(a2 / b2),
+              (a2, b2) => a2.sub(b2.mul(a2.div(b2).round()))
+            )
+          },
           Round: {
             complexity: 1250,
             broadcastable: true,
@@ -25311,6 +25367,19 @@ ${lines.join("\n")}`;
               const rest = args.slice(1);
               return canonicalAdd(engine, [first, ...rest.map((x) => x.neg())]);
             }
+          },
+          Truncate: {
+            description: "Rounds a number towards zero (removes the fractional part)",
+            complexity: 1250,
+            broadcastable: true,
+            signature: "(number) -> integer",
+            sgn: ([x]) => x.sgn,
+            evaluate: ([x]) => apply(
+              x,
+              Math.trunc,
+              (x2) => x2.trunc(),
+              (z) => z.trunc(0)
+            )
           }
         },
         {
@@ -32482,26 +32551,23 @@ ${lines.join("\n")}`;
       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;
       }
@@ -32515,7 +32581,7 @@ ${lines.join("\n")}`;
     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);
@@ -32617,7 +32683,7 @@ ${lines.join("\n")}`;
       ]
     ],
     // d/dx ln(Γ(x)) = ψ(x) (digamma function)
-    LogGamma: ["Digamma", "_"],
+    GammaLn: ["Digamma", "_"],
     // d/dx ψ(x) = ψ₁(x) (trigamma function)
     // https://en.wikipedia.org/wiki/Trigamma_function
     Digamma: ["Trigamma", "_"],
@@ -34095,10 +34161,10 @@ ${lines.join("\n")}`;
       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);
           }
@@ -34353,8 +34419,8 @@ ${lines.join("\n")}`;
           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;
@@ -35609,8 +35675,7 @@ ${lines.join("\n")}`;
   function multiplyForm(expr) {
     if (!expr.ops) return expr;
     const ops = expr.ops.map(multiplyForm);
-    if (expr.operator === "Multiply")
-      return canonicalMultiply(expr.engine, ops);
+    if (expr.operator === "Multiply") return canonicalMultiply(expr.engine, ops);
     if (expr.operator === "Negate")
       return canonicalMultiply(expr.engine, [ops[0], expr.engine.NegativeOne]);
     return expr;
@@ -45983,7 +46048,8 @@ Error in definition of "${name}"`,
       return this.numeratorDenominator[1];
     }
     get numeratorDenominator() {
-      if (!(this.isCanonical || this.isStructural)) return [this, this.engine.One];
+      if (!(this.isCanonical || this.isStructural))
+        return [this, this.engine.One];
       if (this.isNumber !== true)
         return [this.engine.Nothing, this.engine.Nothing];
       const operator2 = this.operator;
@@ -46021,11 +46087,13 @@ Error in definition of "${name}"`,
     // ALGEBRAIC OPERATIONS
     //
     neg() {
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       return negate(this);
     }
     inv() {
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       if (this.isOne) return this;
       if (this.isNegativeOne) return this;
       if (this.operator === "Sqrt") return this.op1.inv().sqrt();
@@ -46046,7 +46114,8 @@ Error in definition of "${name}"`,
       return this.engine._fn("Divide", [this.engine.One, this]);
     }
     abs() {
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       if (this.operator === "Abs" || this.operator === "Negate") return this;
       if (this.isNonNegative) return this;
       if (this.isNonPositive) return this.neg();
@@ -46054,11 +46123,13 @@ Error in definition of "${name}"`,
     }
     add(rhs) {
       if (rhs === 0) return this;
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       return add3(this, this.engine.box(rhs));
     }
     mul(rhs) {
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       if (rhs === 0) return this.engine.Zero;
       if (rhs === 1) return this;
       if (rhs === -1) return this.neg();
@@ -46070,7 +46141,8 @@ Error in definition of "${name}"`,
       return mul3(this, this.engine.box(rhs));
     }
     div(rhs) {
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       return div2(this, rhs);
     }
     pow(exp3) {
@@ -46136,7 +46208,8 @@ Error in definition of "${name}"`,
     }
     ln(semiBase) {
       const base = semiBase ? this.engine.box(semiBase) : void 0;
-      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural))
+        throw new Error("Not canonical");
       if (this.is(0)) return this.engine.NegativeInfinity;
       if (this.operator === "Exp") {
         if (!base) return this.op1;
@@ -51471,7 +51544,7 @@ Error in definition of "${name}"`,
     Arsinh: "Math.asinh",
     Arctan: "Math.atan",
     Artanh: "Math.atanh",
-    Ceiling: "Math.ceil",
+    Ceil: "Math.ceil",
     Chop: "_SYS.chop",
     Cos: "Math.cos",
     Cosh: "Math.cosh",
@@ -51501,10 +51574,7 @@ Error in definition of "${name}"`,
     Floor: "Math.floor",
     Fract: ([x], compile) => {
       if (x === null) throw new Error("Fract: no argument");
-      return BaseCompiler.inlineExpression(
-        "${x} - Math.floor(${x})",
-        compile(x)
-      );
+      return BaseCompiler.inlineExpression("${x} - Math.floor(${x})", compile(x));
     },
     Gamma: "_SYS.gamma",
     GCD: "_SYS.gcd",
@@ -51517,7 +51587,7 @@ Error in definition of "${name}"`,
       if (args.length === 1) return `Math.log10(${compile(args[0])})`;
       return `(Math.log(${compile(args[0])}) / Math.log(${compile(args[1])}))`;
     },
-    LogGamma: "_SYS.lngamma",
+    GammaLn: "_SYS.lngamma",
     Lb: "Math.log2",
     Max: "Math.max",
     Mean: (args, compile) => {
@@ -51646,12 +51716,23 @@ Error in definition of "${name}"`,
       if (arg === null) throw new Error("Sech: no argument");
       return `1 / Math.cosh(${compile(arg)})`;
     },
-    Sgn: "Math.sign",
+    Sign: "Math.sign",
     Sin: "Math.sin",
     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 = {
@@ -51914,7 +51995,7 @@ Error in definition of "${name}"`,
     Arccos: "acos",
     Arcsin: "asin",
     Arctan: "atan",
-    Ceiling: "ceil",
+    Ceil: "ceil",
     Clamp: "clamp",
     Cos: "cos",
     Degrees: "degrees",
@@ -51939,6 +52020,11 @@ Error in definition of "${name}"`,
     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");
@@ -52002,7 +52088,7 @@ Error in definition of "${name}"`,
       return `acosh(1.0 / (${compile(x)}))`;
     },
     // Additional math functions
-    Sgn: "sign",
+    // Sign is already registered in the standard functions above
     Lb: "log2",
     Log: (args, compile) => {
       if (args.length === 0) throw new Error("Log: no argument");
@@ -52600,6 +52686,22 @@ Error in definition of "${name}"`,
     }
     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;
@@ -52625,7 +52727,9 @@ Error in definition of "${name}"`,
     if (containsZero(bVal)) {
       return { kind: "singular" };
     }
-    const period = Math.abs(bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi)));
+    const period = Math.abs(
+      bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi))
+    );
     const flo = Math.floor(aVal.lo / period);
     const fhi = Math.floor(aVal.hi / period);
     if (flo !== fhi) {
@@ -52635,6 +52739,9 @@ Error in definition of "${name}"`,
     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;
@@ -53125,9 +53232,11 @@ Error in definition of "${name}"`,
     ceil: ceil2,
     round: round2,
     fract,
+    trunc: trunc2,
     min: min2,
     max: max2,
     mod: mod2,
+    remainder,
     sign: sign2,
     // Trigonometric
     sin: sin2,
@@ -53233,7 +53342,7 @@ Error in definition of "${name}"`,
     Negate: (args, compile) => `_IA.negate(${compile(args[0])})`,
     // Elementary functions
     Abs: (args, compile) => `_IA.abs(${compile(args[0])})`,
-    Ceiling: (args, compile) => `_IA.ceil(${compile(args[0])})`,
+    Ceil: (args, compile) => `_IA.ceil(${compile(args[0])})`,
     Exp: (args, compile) => `_IA.exp(${compile(args[0])})`,
     Floor: (args, compile) => `_IA.floor(${compile(args[0])})`,
     Ln: (args, compile) => `_IA.ln(${compile(args[0])})`,
@@ -53286,7 +53395,7 @@ Error in definition of "${name}"`,
       return `_IA.powInterval(${compile(arg)}, _IA.div(_IA.point(1), ${compile(exp3)}))`;
     },
     Round: (args, compile) => `_IA.round(${compile(args[0])})`,
-    Sgn: (args, compile) => `_IA.sign(${compile(args[0])})`,
+    Sign: (args, compile) => `_IA.sign(${compile(args[0])})`,
     Sqrt: (args, compile) => `_IA.sqrt(${compile(args[0])})`,
     Square: (args, compile) => `_IA.square(${compile(args[0])})`,
     // Trigonometric functions
@@ -53315,14 +53424,12 @@ Error in definition of "${name}"`,
     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");
@@ -53642,6 +53749,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) {
@@ -53715,6 +53838,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) {
@@ -53748,6 +53883,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)));
@@ -54014,6 +54159,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);
@@ -54044,6 +54199,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;
@@ -54060,6 +54220,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;
@@ -54446,12 +54622,19 @@ float ia_notEqual(IntervalResult a, IntervalResult b) {
     Negate: (args, compile) => `ia_negate(${compile(args[0])})`,
     // Elementary functions
     Abs: (args, compile) => `ia_abs(${compile(args[0])})`,
-    Ceiling: (args, compile) => `ia_ceil(${compile(args[0])})`,
+    Ceil: (args, compile) => `ia_ceil(${compile(args[0])})`,
     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]);
@@ -54484,8 +54667,17 @@ float ia_notEqual(IntervalResult a, IntervalResult b) {
       }
       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])})`,
-    Sgn: (args, compile) => `ia_sign(${compile(args[0])})`,
+    Sign: (args, compile) => `ia_sign(${compile(args[0])})`,
     Sqrt: (args, compile) => `ia_sqrt(${compile(args[0])})`,
     Square: (args, compile) => `ia_square(${compile(args[0])})`,
     // Trigonometric functions
@@ -56426,10 +56618,10 @@ IntervalResult ${functionName}(${params}) {
   // src/compute-engine.ts
   init_types6();
   init_base_compiler();
-  var version = "0.35.4";
+  var version = "0.35.6";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.35.4"
+    version: "0.35.6"
   };
   return __toCommonJS(compute_engine_exports);
 })();

package/dist/math-json.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.4 */
+/** Compute Engine 0.35.6 */
 
 // src/math-json/utils.ts
 function isNumberObject(expr) {
@@ -115,7 +115,7 @@ function expressionToDictionaryValue(expr) {
 }
 
 // src/math-json.ts
-var version = "0.35.4";
+var version = "0.35.6";
 export {
   dictionaryFromExpression,
   isFunctionObject,

package/dist/math-json.min.esm.js

@@ -1,2 +1,2 @@
-/** Compute Engine 0.35.4 */
-function d(n){return n!==null&&typeof n=="object"&&"num"in n}function s(n){return n!==null&&typeof n=="object"&&"sym"in n}function a(n){return n!==null&&typeof n=="object"&&"str"in n}function m(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function u(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):M(n)||b(n)?null:n}function l(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function y(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function E(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function h(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function g(n){return typeof n=="string"&&b(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:s(n)?n.sym:null}function f(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,r]=y(n),e=c(i);return e?[e,r??"Nothing"]:null}return null}function j(n){if(n===null)return null;if(m(n))return n;let t=f(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={},r=y(n);for(let e=1;e<h(n);e++){let o=f(r[e]);o&&(i[o[0]]=A(o[1])??"Nothing")}return{dict:i}}return null}function O(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let r=1,e=[];for(;r<i.length;)e.push(t(i[r])),r+=1;return e}function M(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function b(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function A(n){return n==null?null:a(n)?n.str:d(n)?parseFloat(n.num):s(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var S="0.35.4";export{j as dictionaryFromExpression,u as isFunctionObject,a as isStringObject,s as isSymbolObject,O as mapArgs,E as operand,l as operator,c as stringValue,g as symbol,S as version};
+/** Compute Engine 0.35.6 */
+function d(n){return n!==null&&typeof n=="object"&&"num"in n}function s(n){return n!==null&&typeof n=="object"&&"sym"in n}function a(n){return n!==null&&typeof n=="object"&&"str"in n}function m(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function u(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):M(n)||b(n)?null:n}function l(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function y(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function E(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function h(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function g(n){return typeof n=="string"&&b(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:s(n)?n.sym:null}function f(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,r]=y(n),e=c(i);return e?[e,r??"Nothing"]:null}return null}function j(n){if(n===null)return null;if(m(n))return n;let t=f(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={},r=y(n);for(let e=1;e<h(n);e++){let o=f(r[e]);o&&(i[o[0]]=A(o[1])??"Nothing")}return{dict:i}}return null}function O(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let r=1,e=[];for(;r<i.length;)e.push(t(i[r])),r+=1;return e}function M(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function b(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function A(n){return n==null?null:a(n)?n.str:d(n)?parseFloat(n.num):s(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var S="0.35.6";export{j as dictionaryFromExpression,u as isFunctionObject,a as isStringObject,s as isSymbolObject,O as mapArgs,E as operand,l as operator,c as stringValue,g as symbol,S as version};