@cortex-js/compute-engine 0.35.4 → 0.35.6

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.4 */
+/** 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);
           }
@@ -23824,7 +23825,8 @@ function typeCouldBeCollection(type2) {
   }
   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) {
@@ -24632,6 +24634,16 @@ var init_arithmetic = __esm({
             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",
@@ -24721,6 +24733,22 @@ var init_arithmetic = __esm({
             (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,
@@ -24936,6 +24964,22 @@ var init_arithmetic = __esm({
           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",
@@ -25178,6 +25222,18 @@ var init_arithmetic = __esm({
           },
           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,
@@ -25309,6 +25365,19 @@ var init_arithmetic = __esm({
             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)
+          )
         }
       },
       {
@@ -32468,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;
     }
@@ -32501,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);
@@ -32603,7 +32669,7 @@ var DERIVATIVES_TABLE = {
     ]
   ],
   // 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", "_"],
@@ -34081,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);
         }
@@ -34339,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;
@@ -35595,8 +35661,7 @@ function numberForm(expr) {
 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;
@@ -45969,7 +46034,8 @@ var BoxedFunction = class extends _BoxedExpression {
     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;
@@ -46007,11 +46073,13 @@ var BoxedFunction = class extends _BoxedExpression {
   // 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();
@@ -46032,7 +46100,8 @@ var BoxedFunction = class extends _BoxedExpression {
     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();
@@ -46040,11 +46109,13 @@ var BoxedFunction = class extends _BoxedExpression {
   }
   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();
@@ -46056,7 +46127,8 @@ var BoxedFunction = class extends _BoxedExpression {
     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) {
@@ -46122,7 +46194,8 @@ var BoxedFunction = class extends _BoxedExpression {
   }
   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;
@@ -51457,7 +51530,7 @@ var JAVASCRIPT_FUNCTIONS = {
   Arsinh: "Math.asinh",
   Arctan: "Math.atan",
   Artanh: "Math.atanh",
-  Ceiling: "Math.ceil",
+  Ceil: "Math.ceil",
   Chop: "_SYS.chop",
   Cos: "Math.cos",
   Cosh: "Math.cosh",
@@ -51487,10 +51560,7 @@ var JAVASCRIPT_FUNCTIONS = {
   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",
@@ -51503,7 +51573,7 @@ var JAVASCRIPT_FUNCTIONS = {
     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) => {
@@ -51632,12 +51702,23 @@ var JAVASCRIPT_FUNCTIONS = {
     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 = {
@@ -51900,7 +51981,7 @@ var GLSL_FUNCTIONS = {
   Arccos: "acos",
   Arcsin: "asin",
   Arctan: "atan",
-  Ceiling: "ceil",
+  Ceil: "ceil",
   Clamp: "clamp",
   Cos: "cos",
   Degrees: "degrees",
@@ -51925,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");
@@ -51988,7 +52074,7 @@ var GLSL_FUNCTIONS = {
     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");
@@ -52586,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;
@@ -52611,7 +52713,9 @@ function mod2(a, b) {
   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) {
@@ -52621,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;
@@ -53111,9 +53218,11 @@ var IntervalArithmetic = {
   ceil: ceil2,
   round: round2,
   fract,
+  trunc: trunc2,
   min: min2,
   max: max2,
   mod: mod2,
+  remainder,
   sign: sign2,
   // Trigonometric
   sin: sin2,
@@ -53219,7 +53328,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   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])})`,
@@ -53272,7 +53381,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
     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
@@ -53301,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");
@@ -53628,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) {
@@ -53701,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) {
@@ -53734,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)));
@@ -54000,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);
@@ -54030,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;
@@ -54046,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;
@@ -54432,12 +54608,19 @@ var INTERVAL_GLSL_FUNCTIONS = {
   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]);
@@ -54470,8 +54653,17 @@ 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])})`,
-  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
@@ -56412,10 +56604,10 @@ function defToString(name, def, v) {
 // 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"
 };
 export {
   BaseCompiler,