@cortex-js/compute-engine 0.52.0 → 0.52.1

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.52.0 */
+/** Compute Engine 0.52.1 */
     (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;
@@ -8194,6 +8194,58 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/latex-syntax/tokenizer.ts
+  var UNICODE_SUPERSCRIPT_MAP = {
+    "\u2070": "0",
+    // ⁰
+    "\xB9": "1",
+    // ¹
+    "\xB2": "2",
+    // ²
+    "\xB3": "3",
+    // ³
+    "\u2074": "4",
+    // ⁴
+    "\u2075": "5",
+    // ⁵
+    "\u2076": "6",
+    // ⁶
+    "\u2077": "7",
+    // ⁷
+    "\u2078": "8",
+    // ⁸
+    "\u2079": "9",
+    // ⁹
+    "\u207B": "-",
+    // ⁻
+    "\u2071": "i",
+    // ⁱ
+    "\u207F": "n"
+    // ⁿ
+  };
+  var UNICODE_SUBSCRIPT_MAP = {
+    "\u2080": "0",
+    // ₀
+    "\u2081": "1",
+    // ₁
+    "\u2082": "2",
+    // ₂
+    "\u2083": "3",
+    // ₃
+    "\u2084": "4",
+    // ₄
+    "\u2085": "5",
+    // ₅
+    "\u2086": "6",
+    // ₆
+    "\u2087": "7",
+    // ₇
+    "\u2088": "8",
+    // ₈
+    "\u2089": "9",
+    // ₉
+    "\u208B": "-"
+    // ₋
+  };
   var Tokenizer = class {
     s;
     pos;
@@ -8201,6 +8253,14 @@ var ComputeEngine = (() => {
     constructor(s) {
       s = s.replace(/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/g, "");
       s = s.replace(/\u2212/g, "-");
+      s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹⁻ⁱⁿ]+/g, (m) => {
+        const digits = Array.from(m).map((c) => UNICODE_SUPERSCRIPT_MAP[c]).join("");
+        return `^{${digits}}`;
+      });
+      s = s.replace(/[₀₁₂₃₄₅₆₇₈₉₋]+/g, (m) => {
+        const digits = Array.from(m).map((c) => UNICODE_SUBSCRIPT_MAP[c]).join("");
+        return `_{${digits}}`;
+      });
       this.s = splitGraphemes(s);
       this.pos = 0;
     }
@@ -9398,6 +9458,7 @@ var ComputeEngine = (() => {
         result.push("Nothing");
         parser.skipSpace();
       }
+      parser.skipVisualSpace();
       if (parser.atTerminator(terminator)) {
         result.push("Nothing");
       } else {
@@ -9408,6 +9469,7 @@ var ComputeEngine = (() => {
       if (!done) {
         parser.skipSpace();
         done = !parser.match(sep);
+        if (!done) parser.skipVisualSpace();
       }
     }
     return result;
@@ -9977,7 +10039,7 @@ var ComputeEngine = (() => {
         const args = operands(expr);
         if (!args || args.length === 0) return "";
         const parts = args.filter((a) => operator(a) !== "Declare").map((a) => serializer.serialize(a));
-        return parts.join(";\\; ");
+        return parts.join("; ");
       }
     },
     // Serializer for If expressions (separate from the parser entry
@@ -10764,6 +10826,7 @@ var ComputeEngine = (() => {
     // '⎿': '', // U+23BF RIGHT PARENTHESIS LOWER HOOK
   };
   function parseAssign(parser, lhs, until) {
+    const isLocalBindingContext = (until?.minPrec ?? 0) >= 19;
     const lhsSymbol = symbol(lhs);
     if (lhsSymbol && lhsSymbol.includes("_")) {
       const underscoreIndex = lhsSymbol.indexOf("_");
@@ -10771,7 +10834,10 @@ var ComputeEngine = (() => {
       const subscriptStr = lhsSymbol.substring(underscoreIndex + 1);
       const subscriptNum = parseInt(subscriptStr, 10);
       const subscript = !isNaN(subscriptNum) && String(subscriptNum) === subscriptStr ? subscriptNum : subscriptStr;
-      lhs = ["Subscript", baseName, subscript];
+      const simpleSequenceLikeSubscript = subscript !== "" && (typeof subscript === "number" || typeof subscript === "string" && subscript.length === 1);
+      if (parser.getSymbolType(baseName).matches("indexed_collection") || !isLocalBindingContext && simpleSequenceLikeSubscript) {
+        lhs = ["Subscript", baseName, subscript];
+      }
     }
     if (operator(lhs) === "InvisibleOperator" && nops(lhs) === 2 && operator(operand(lhs, 2)) === "Delimiter") {
       const fn2 = symbol(operand(lhs, 1));
@@ -10786,7 +10852,15 @@ var ComputeEngine = (() => {
     }
     if (operator(lhs) === "Subscript" && symbol(operand(lhs, 1))) {
       const fn2 = symbol(operand(lhs, 1));
-      if (!fn2) return null;
+      if (!parser.getSymbolType(fn2).matches("indexed_collection")) {
+        const sub4 = operand(lhs, 2);
+        const subStr = (sub4 !== null && typeof sub4 === "string" ? sub4 : void 0) ?? (sub4 !== null && typeof sub4 === "number" ? String(sub4) : void 0);
+        if (subStr && isLocalBindingContext) {
+          const rhs3 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
+          if (rhs3 === null) return null;
+          return ["Assign", fn2 + "_" + subStr, rhs3];
+        }
+      }
       const rhs2 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
       if (rhs2 === null) return null;
       const sub3 = operand(lhs, 2);
@@ -10867,6 +10941,7 @@ var ComputeEngine = (() => {
   }
   function matchKeyword(parser, keyword) {
     const start = parser.index;
+    parser.skipVisualSpace();
     if (parser.match("\\text")) {
       if (matchTextKeyword(parser, keyword)) return true;
       parser.index = start;
@@ -10884,18 +10959,21 @@ var ComputeEngine = (() => {
     return result;
   }
   function parseIfExpression(parser, until) {
+    parser.skipVisualSpace();
     const condition = parser.parseExpression({
       minPrec: 0,
       condition: (p) => peekKeyword(p, "then")
     });
     if (condition === null) return null;
     if (!matchKeyword(parser, "then")) return null;
+    parser.skipVisualSpace();
     const trueBranch = parser.parseExpression({
       minPrec: 0,
       condition: (p) => peekKeyword(p, "else")
     });
     if (trueBranch === null) return null;
     if (!matchKeyword(parser, "else")) return null;
+    parser.skipVisualSpace();
     const falseBranch = parser.parseExpression(until) ?? "Nothing";
     return ["If", condition, trueBranch, falseBranch];
   }
@@ -10950,11 +11028,12 @@ var ComputeEngine = (() => {
     if (bindings.length === 0) return null;
     const block = [];
     for (const b of bindings) {
-      if (operator(b) === "Assign") {
-        block.push(["Declare", operand(b, 1)]);
-        block.push(b);
+      const normalized = normalizeLocalAssign(b);
+      if (operator(normalized) === "Assign") {
+        block.push(["Declare", operand(normalized, 1)]);
+        block.push(normalized);
       } else {
-        block.push(b);
+        block.push(normalized);
       }
     }
     block.push(lhs);
@@ -10963,13 +11042,25 @@ var ComputeEngine = (() => {
   function buildBlockFromSequence(seq) {
     const block = [];
     for (const s of seq) {
-      if (operator(s) === "Assign") {
-        block.push(["Declare", operand(s, 1)]);
+      const normalized = normalizeLocalAssign(s);
+      if (operator(normalized) === "Assign") {
+        block.push(["Declare", operand(normalized, 1)]);
       }
-      block.push(s);
+      block.push(normalized);
     }
     return ["Block", ...block];
   }
+  function normalizeLocalAssign(expr) {
+    if (operator(expr) !== "Assign") return expr;
+    const lhs = operand(expr, 1);
+    if (operator(lhs) !== "Subscript") return expr;
+    const base = symbol(operand(lhs, 1));
+    if (!base) return expr;
+    const sub3 = operand(lhs, 2);
+    const subStr = (typeof sub3 === "string" ? sub3 : void 0) ?? (typeof sub3 === "number" ? String(sub3) : void 0);
+    if (!subStr) return expr;
+    return ["Assign", `${base}_${subStr}`, operand(expr, 2) ?? "Nothing"];
+  }
   function parseAt(...close) {
     return (parser, lhs) => {
       if (!symbol(lhs) && operator(lhs) !== "List") return null;
@@ -12426,14 +12517,14 @@ var ComputeEngine = (() => {
     get numeratorDenominator() {
       return [this, this.engine.One];
     }
-    is(other) {
+    is(other, tolerance) {
       if (this.isSame(other)) return true;
-      if (!this.isConstant) return false;
+      if (this.freeVariables.length > 0) return false;
       if (typeof other === "number" || typeof other === "bigint") {
         const n = this.N();
         if (n === this) return false;
         if (!isNumber(n)) return false;
-        const tol = this.engine.tolerance;
+        const tol = tolerance ?? this.engine.tolerance;
         const nRe = n.re;
         const nIm = n.im;
         if (typeof other === "number") {
@@ -12444,11 +12535,11 @@ var ComputeEngine = (() => {
         return Math.abs(nRe - Number(other)) <= tol && Math.abs(nIm) <= tol;
       }
       if (other instanceof __BoxedExpression) {
-        if (!other.isConstant) return false;
+        if (other.freeVariables.length > 0) return false;
         const nThis = this.N();
         const nOther = other.N();
         if (!isNumber(nThis) || !isNumber(nOther)) return false;
-        const tol = this.engine.tolerance;
+        const tol = tolerance ?? this.engine.tolerance;
         return Math.abs(nThis.re - nOther.re) <= tol && Math.abs(nThis.im - nOther.im) <= tol;
       }
       return false;
@@ -12829,7 +12920,6 @@ var ComputeEngine = (() => {
       if (def.neq) this.neq = def.neq;
       if (def.cmp) this.cmp = def.cmp;
       if (def.collection) {
-        if (name === "Take") debugger;
         this.collection = defaultCollectionHandlers(def.collection);
       }
       if (def.subscriptEvaluate) this.subscriptEvaluate = def.subscriptEvaluate;
@@ -13009,7 +13099,8 @@ var ComputeEngine = (() => {
     if (expr.re === 0) return ce.number(expr.im);
     if (isFunction2(expr, "Negate")) return getImaginaryFactor(expr.op1)?.neg();
     if (isFunction2(expr, "Complex")) {
-      if (expr.op1.isSame(0) && !isNaN(expr.op2.re)) return ce.number(expr.op2.re);
+      if (expr.op1.isSame(0) && !isNaN(expr.op2.re))
+        return ce.number(expr.op2.re);
       return void 0;
     }
     if (isFunction2(expr, "Multiply") && expr.nops === 2) {
@@ -23477,6 +23568,7 @@ ${lines.join("\n")}`;
       // Functions
       //
       Abs: {
+        description: "Absolute value (magnitude) of a number.",
         wikidata: "Q3317982",
         // magnitude 'Q120812 (for reals)
         broadcastable: true,
@@ -23492,6 +23584,7 @@ ${lines.join("\n")}`;
         evaluate: ([x]) => evaluateAbs(x)
       },
       Add: {
+        description: "Sum of two or more values.",
         wikidata: "Q32043",
         associative: true,
         commutative: true,
@@ -23546,6 +23639,7 @@ ${lines.join("\n")}`;
         )
       },
       Chop: {
+        description: "Replace tiny numeric values with zero.",
         associative: true,
         broadcastable: true,
         idempotent: true,
@@ -23569,6 +23663,7 @@ ${lines.join("\n")}`;
       //   complexity: 500,
       // },
       Divide: {
+        description: "Quotient of a numerator and one or more denominators.",
         wikidata: "Q1226939",
         complexity: 2500,
         broadcastable: true,
@@ -23617,6 +23712,7 @@ ${lines.join("\n")}`;
         }
       },
       Exp: {
+        description: "Natural exponential function: e^x.",
         wikidata: "Q168698",
         broadcastable: true,
         complexity: 3500,
@@ -23726,6 +23822,7 @@ ${lines.join("\n")}`;
         }
       },
       Floor: {
+        description: "Rounds a number down to the nearest integer.",
         wikidata: "Q56860783",
         complexity: 1250,
         broadcastable: true,
@@ -23765,6 +23862,7 @@ ${lines.join("\n")}`;
         )
       },
       Gamma: {
+        description: "Gamma function, extending factorial to complex numbers.",
         wikidata: "Q190573",
         complexity: 8e3,
         broadcastable: true,
@@ -23779,6 +23877,7 @@ ${lines.join("\n")}`;
         ) : void 0
       },
       GammaLn: {
+        description: "Natural logarithm of the gamma function.",
         complexity: 8e3,
         broadcastable: true,
         signature: "(number) -> number",
@@ -24050,6 +24149,7 @@ ${lines.join("\n")}`;
         )
       },
       Multiply: {
+        description: "Product of two or more values.",
         wikidata: "Q40276",
         associative: true,
         commutative: true,
@@ -24146,6 +24246,7 @@ ${lines.join("\n")}`;
         evaluate: ([x, y], { engine }) => engine.tuple(x.add(y.neg()), x.add(y))
       },
       Power: {
+        description: "Exponentiation: raise a base to a power.",
         wikidata: "Q33456",
         broadcastable: true,
         complexity: 3500,
@@ -24204,6 +24305,7 @@ ${lines.join("\n")}`;
         // https://proofwiki.org/wiki/Square_Root_of_Prime_is_Irrational
       },
       Rational: {
+        description: "Construct a rational number from a numerator and denominator.",
         complexity: 2400,
         signature: "(number, integer?) -> rational",
         sgn: ([n]) => n.sgn,
@@ -24240,6 +24342,7 @@ ${lines.join("\n")}`;
         }
       },
       Root: {
+        description: "n-th root of a value.",
         complexity: 3200,
         broadcastable: true,
         signature: "(number, number) -> number",
@@ -24300,6 +24403,7 @@ ${lines.join("\n")}`;
         )
       },
       Round: {
+        description: "Rounds a number to the nearest integer.",
         complexity: 1250,
         broadcastable: true,
         signature: "(number) -> integer",
@@ -24329,6 +24433,7 @@ ${lines.join("\n")}`;
       },
       /** Heaviside step function: H(x) = 0 for x < 0, 1/2 for x = 0, 1 for x > 0 */
       Heaviside: {
+        description: "Heaviside step function.",
         complexity: 1200,
         broadcastable: true,
         signature: "(number) -> real",
@@ -24342,6 +24447,7 @@ ${lines.join("\n")}`;
         }
       },
       Sign: {
+        description: "Sign of a number: -1, 0, or 1.",
         complexity: 1200,
         broadcastable: true,
         signature: "(number) -> integer",
@@ -24413,6 +24519,7 @@ ${lines.join("\n")}`;
         // https://proofwiki.org/wiki/Square_Root_of_Prime_is_Irrational
       },
       Square: {
+        description: "Square of a number: x^2.",
         wikidata: "Q3075175",
         complexity: 3100,
         broadcastable: true,
@@ -24435,6 +24542,7 @@ ${lines.join("\n")}`;
         }
       },
       Subtract: {
+        description: "Difference between two or more values.",
         wikidata: "Q40754",
         complexity: 1350,
         broadcastable: true,
@@ -24609,9 +24717,11 @@ ${lines.join("\n")}`;
     },
     {
       PreIncrement: {
+        description: "Increment a number by one.",
         signature: "(number) -> number"
       },
       PreDecrement: {
+        description: "Decrement a number by one.",
         signature: "(number) -> number"
       }
     },
@@ -29153,6 +29263,7 @@ ${e.message}
       // with values of the order that can be either fractional or negative
       //
       Derivative: {
+        description: "Derivative operator that returns a derivative function.",
         broadcastable: false,
         lazy: true,
         signature: "(function, order:number?) -> function",
@@ -29180,6 +29291,7 @@ ${e.message}
       //
       // This is equivalent to `["Apply", ["Derivative", "Sin"], "x"]`
       D: {
+        description: "Symbolic partial derivative with respect to one or more variables.",
         broadcastable: false,
         scoped: true,
         lazy: true,
@@ -29224,6 +29336,7 @@ ${e.message}
       },
       // Evaluate a numerical approximation of a derivative at point x
       ND: {
+        description: "Numerical derivative evaluated at a point.",
         broadcastable: false,
         lazy: true,
         signature: "(function, at:number) -> number",
@@ -29242,6 +29355,7 @@ ${e.message}
         }
       },
       Integrate: {
+        description: "Symbolic integral with optional bounds.",
         wikidata: "Q80091",
         broadcastable: false,
         lazy: true,
@@ -29322,6 +29436,7 @@ ${e.message}
         }
       },
       NIntegrate: {
+        description: "Numerical approximation of a definite integral.",
         broadcastable: false,
         lazy: true,
         signature: "(function, limits:(tuple|symbol)?) -> number",
@@ -33166,6 +33281,7 @@ ${e.message}
   var CONTROL_STRUCTURES_LIBRARY = [
     {
       Block: {
+        description: "Evaluate a sequence of expressions in a local scope.",
         lazy: true,
         scoped: true,
         signature: "(unknown*) -> unknown",
@@ -33179,6 +33295,7 @@ ${e.message}
       // A condition expression tests for one or more conditions of an expression
       // ['Condition', value, "positive"]
       Condition: {
+        description: "Test whether a value satisfies one or more conditions.",
         lazy: true,
         signature: "(value, symbol) -> boolean",
         evaluate: ([value, conds], { engine }) => {
@@ -33193,6 +33310,7 @@ ${e.message}
         }
       },
       If: {
+        description: "Conditional branch: evaluate one of two expressions.",
         lazy: true,
         signature: "(expression, expression, expression) -> any",
         type: ([_cond, ifTrue, ifFalse]) => widen(ifTrue.type.type, ifFalse.type.type),
@@ -33209,6 +33327,7 @@ ${e.message}
         }
       },
       Loop: {
+        description: "Evaluate a body expression over elements of a collection.",
         lazy: true,
         signature: "(body:expression, collection:expression) -> any",
         type: ([body]) => body.type,
@@ -33216,6 +33335,7 @@ ${e.message}
         evaluateAsync: async ([body, collection], { engine: ce, signal }) => runAsync(runLoop(body, collection, ce), ce._timeRemaining, signal)
       },
       Which: {
+        description: "Return the value for the first condition that is true.",
         lazy: true,
         signature: "(expression+) -> unknown",
         type: (args) => {
@@ -33233,7 +33353,11 @@ ${e.message}
         },
         evaluate: (ops, options) => evaluateWhich(ops, options)
       },
-      FixedPoint: { lazy: true, signature: "(any) -> unknown" }
+      FixedPoint: {
+        description: "Iterate a function until a fixed point is reached.",
+        lazy: true,
+        signature: "(any) -> unknown"
+      }
     }
   ];
   function evaluateWhich(args, options) {
@@ -33313,6 +33437,7 @@ ${e.message}
   var COMBINATORICS_LIBRARY = [
     {
       Choose: {
+        description: "Binomial coefficient: number of ways to choose k items from n.",
         complexity: 1200,
         signature: "(n:number, m:number) -> number",
         type: () => "finite_integer",
@@ -33570,6 +33695,7 @@ ${e.message}
   var COMPLEX_LIBRARY = [
     {
       Real: {
+        description: "Real part of a complex number.",
         // @todo: could be extended to return an expression, i.e. ["Real", ["Add", "x", ["Complex", 0, 5]]] -> "x". Not for any operator, but at least for Add, Multiply, Negate, etc.
         broadcastable: true,
         complexity: 1200,
@@ -33589,6 +33715,7 @@ ${e.message}
         }
       },
       Imaginary: {
+        description: "Imaginary part of a complex number.",
         broadcastable: true,
         complexity: 1200,
         signature: "(number) -> real",
@@ -33607,6 +33734,7 @@ ${e.message}
         }
       },
       Argument: {
+        description: "Complex argument (phase angle) of a number.",
         broadcastable: true,
         complexity: 1200,
         signature: "(number) -> real",
@@ -33621,6 +33749,7 @@ ${e.message}
       },
       // For Abs (magnitude) see src/compute-engine/library/processAbs
       AbsArg: {
+        description: "Tuple of magnitude and argument of a complex number.",
         broadcastable: true,
         complexity: 1200,
         signature: "(number) -> tuple<real, real>",
@@ -33633,6 +33762,7 @@ ${e.message}
         }
       },
       Conjugate: {
+        description: "Complex conjugate of a number.",
         broadcastable: true,
         complexity: 1200,
         signature: "(number) -> number",
@@ -33646,6 +33776,7 @@ ${e.message}
         }
       },
       ComplexRoots: {
+        description: "All n-th complex roots of a number.",
         broadcastable: true,
         complexity: 1200,
         signature: "(number, number) -> list<number>",
@@ -34597,6 +34728,7 @@ ${e.message}
        *
        */
       InvisibleOperator: {
+        description: "Implicit operator used for juxtapositions such as function application or multiplication.",
         complexity: 9e3,
         lazy: true,
         signature: "function",
@@ -34611,6 +34743,7 @@ ${e.message}
       },
       /** See above for a theory of operations */
       Sequence: {
+        description: "Ordered sequence of expressions.",
         lazy: true,
         signature: "function",
         type: (args) => {
@@ -34627,6 +34760,7 @@ ${e.message}
       },
       /** See above for a theory of operations */
       Delimiter: {
+        description: "Group expressions with explicit delimiters.",
         // Use to represent groups of expressions.
         // Named after https://en.wikipedia.org/wiki/Delimiter
         complexity: 9e3,
@@ -34669,6 +34803,7 @@ ${e.message}
         }
       },
       Error: {
+        description: "Represent an error expression.",
         /**
          * - The first argument is either a string or an `["ErrorCode"]`
          * expression indicating the nature of the error.
@@ -34683,6 +34818,7 @@ ${e.message}
         canonical: (args, { engine: ce }) => ce._fn("Error", args)
       },
       ErrorCode: {
+        description: "Structured error code with optional arguments.",
         complexity: 500,
         lazy: true,
         signature: "(string, any*) -> error",
@@ -34739,6 +34875,7 @@ ${e.message}
         }
       },
       HorizontalSpacing: {
+        description: "Horizontal spacing annotation.",
         signature: "(number) -> nothing",
         canonical: (args, { engine: ce }) => {
           if (args.length === 2) return args[0].canonical;
@@ -34746,6 +34883,7 @@ ${e.message}
         }
       },
       Annotated: {
+        description: "Attach metadata or style annotations to an expression.",
         signature: "(expression, dictionary) -> expression",
         type: ([x]) => x.type,
         complexity: 9e3,
@@ -34947,6 +35085,7 @@ ${e.message}
         evaluate: (ops, { engine: ce }) => ce.symbol(ce.assume(ops[0]))
       },
       Declare: {
+        description: "Declare a symbol and optionally assign a type.",
         lazy: true,
         pure: false,
         signature: "(symbol, type: string | symbol) -> nothing",
@@ -34977,11 +35116,13 @@ ${e.message}
       },
       /** Return the type of an expression */
       Type: {
+        description: "Return the type of an expression as a string.",
         lazy: true,
         signature: "(any) -> string",
         evaluate: ([x], { engine: ce }) => ce.string(x.type.toString() ?? "unknown")
       },
       Evaluate: {
+        description: "Evaluate an expression.",
         lazy: true,
         signature: "(any) -> unknown",
         type: ([x]) => x.type,
@@ -34991,6 +35132,7 @@ ${e.message}
       // Evaluate an expression at a specific point, potentially symbolically
       // i.e. it's the `f|_{a}` notation
       EvaluateAt: {
+        description: "Evaluate a function at one point or between two bounds.",
         lazy: true,
         signature: "(function, lower:number, upper:number) -> number",
         type: ([x]) => functionResult(x.type.type) ?? "number",
@@ -35018,6 +35160,7 @@ ${e.message}
         }
       },
       BuiltinFunction: {
+        description: "Return a built-in function symbol by name.",
         complexity: 9876,
         lazy: true,
         signature: "(symbol | string) -> symbol",
@@ -35037,6 +35180,7 @@ ${e.message}
         }
       },
       Rule: {
+        description: "Pattern replacement rule.",
         lazy: true,
         signature: "(match: expression, replace: expression, predicate: function?) -> expression",
         evaluate: ([_match, _replace, _predicate], { engine: _ce }) => {
@@ -35044,6 +35188,7 @@ ${e.message}
         }
       },
       Simplify: {
+        description: "Simplify an expression.",
         lazy: true,
         signature: "(any) -> expression",
         canonical: (ops, { engine: ce }) => ce._fn("Simplify", checkArity(ce, ops, 1)),
@@ -35112,6 +35257,7 @@ ${e.message}
       },
       // @todo: need review
       Signature: {
+        description: "Return the signature string of an operator.",
         lazy: true,
         signature: "(symbol) -> string | nothing",
         evaluate: ([x], { engine: ce }) => {
@@ -35120,6 +35266,7 @@ ${e.message}
         }
       },
       Subscript: {
+        description: "Subscript notation for indexing or compound symbols.",
         /**
          * The `Subscript` function can take several forms:
          *
@@ -35290,6 +35437,7 @@ ${e.message}
     //
     {
       Wildcard: {
+        description: "Single-expression pattern wildcard.",
         signature: "(symbol) -> symbol",
         canonical: (args, { engine: ce }) => {
           if (args.length !== 1) return ce.symbol("_");
@@ -35297,6 +35445,7 @@ ${e.message}
         }
       },
       WildcardSequence: {
+        description: "Pattern wildcard matching one or more expressions.",
         signature: "(symbol) -> symbol",
         canonical: (args, { engine: ce }) => {
           if (args.length !== 1) return ce.symbol("__");
@@ -35304,6 +35453,7 @@ ${e.message}
         }
       },
       WildcardOptionalSequence: {
+        description: "Pattern wildcard matching zero or more expressions.",
         signature: "(symbol) -> symbol",
         canonical: (args, { engine: ce }) => {
           if (args.length !== 1) return ce.symbol("___");
@@ -35524,6 +35674,7 @@ ${e.message}
     },
     {
       RandomExpression: {
+        description: "Generate a random expression.",
         signature: "() -> expression",
         evaluate: (_ops, { engine }) => engine.box(randomExpression())
       }
@@ -35534,6 +35685,7 @@ ${e.message}
   var LINEAR_ALGEBRA_LIBRARY = [
     {
       Matrix: {
+        description: "Matrix constructor and canonicalizer.",
         complexity: 9e3,
         lazy: true,
         signature: "(matrix, string?, string?) -> matrix",
@@ -35544,6 +35696,7 @@ ${e.message}
       // Vector is a specialized collection to represent a column vector.
       // ["Vector", a, b, c] is a shorthand for ["List", ["List", a], ["List", b], ["List", c]]
       Vector: {
+        description: "Construct a column vector.",
         complexity: 9e3,
         lazy: true,
         signature: "(number+) -> vector",
@@ -35564,6 +35717,7 @@ ${e.message}
     {
       // Corresponds to monadic Shape `⍴` in APL
       Shape: {
+        description: "Return the shape tuple of an expression.",
         complexity: 8200,
         signature: "(value) -> tuple",
         evaluate: ([xs], { engine: ce }) => ce.tuple(...xs.shape)
@@ -35578,6 +35732,7 @@ ${e.message}
       // Corresponds to ArrayReshape in Mathematica
       // and dyadic Shape `⍴` in APL
       Reshape: {
+        description: "Reshape a tensor or collection to a target shape.",
         complexity: 8200,
         signature: "(value, tuple) -> value",
         type: ([value, shape]) => {
@@ -35622,6 +35777,7 @@ ${e.message}
       // Corresponds to Ravel `,` in APL
       // Also Enlist `∊``⍋` in APL
       Flatten: {
+        description: "Flatten a tensor or collection into a list.",
         complexity: 8200,
         signature: "(value) -> list",
         evaluate: (ops, { engine: ce }) => {
@@ -35641,6 +35797,7 @@ ${e.message}
       // Ex: Transpose([[a, b, c], [1, 2, 3]]) = [[a, 1], [b, 2], [c, 3]]
       // For rank > 2: Default swaps last two axes, or specify explicit axes
       Transpose: {
+        description: "Transpose a matrix or swap two tensor axes.",
         complexity: 8200,
         signature: "(value, axis1: integer?, axis2: integer?) -> value",
         evaluate: (ops, { engine: ce }) => {
@@ -35669,6 +35826,7 @@ ${e.message}
       // Conjugate transpose (Hermitian adjoint): transpose + complex conjugate
       // For rank > 2: Default swaps last two axes, or specify explicit axes
       ConjugateTranspose: {
+        description: "Conjugate transpose (Hermitian adjoint) of a matrix or tensor.",
         complexity: 8200,
         signature: "(value, axis1: integer?, axis2: integer?) -> value",
         evaluate: (ops, { engine: ce }) => {
@@ -35698,6 +35856,7 @@ ${e.message}
         }
       },
       Determinant: {
+        description: "Determinant of a square matrix.",
         complexity: 8200,
         signature: "(matrix) -> number",
         evaluate: (ops, { engine: ce }) => {
@@ -35717,6 +35876,7 @@ ${e.message}
         }
       },
       Inverse: {
+        description: "Multiplicative inverse of a square matrix.",
         complexity: 8200,
         signature: "(matrix) -> matrix",
         type: ([matrix]) => matrix.type,
@@ -35737,6 +35897,7 @@ ${e.message}
         }
       },
       PseudoInverse: {
+        description: "Moore-Penrose pseudoinverse of a matrix.",
         complexity: 8200,
         signature: "(matrix) -> matrix",
         evaluate: ([matrix], { engine: ce }) => {
@@ -35761,6 +35922,7 @@ ${e.message}
       //   },
       // },
       AdjugateMatrix: {
+        description: "Adjugate (classical adjoint) of a square matrix.",
         complexity: 8200,
         signature: "(matrix) -> matrix",
         evaluate: (ops) => {
@@ -35785,6 +35947,7 @@ ${e.message}
       // For rank > 2 tensors: returns tensor of traces over last two axes (batch trace)
       // Optional axis1, axis2 to specify which axes to trace over (default: last two)
       Trace: {
+        description: "Trace of a matrix or pair of tensor axes.",
         complexity: 8200,
         signature: "(value, axis1: integer?, axis2: integer?) -> value",
         evaluate: (ops, { engine: ce }) => {
@@ -35893,6 +36056,7 @@ ${e.message}
       // Matrix multiplication: A (m×n) × B (n×p) → result (m×p)
       // Handles matrix × matrix, matrix × vector, vector × matrix
       MatrixMultiply: {
+        description: "Matrix and vector multiplication.",
         complexity: 8300,
         signature: "(matrix|vector, matrix|vector) -> matrix|vector",
         evaluate: (ops, { engine: ce }) => {
@@ -35978,6 +36142,7 @@ ${e.message}
       // 2. Extract the diagonal from a matrix as a vector
       // 3. For a scalar, return the scalar (or could create 1x1 matrix)
       Diagonal: {
+        description: "Extract a matrix diagonal or build a diagonal matrix.",
         complexity: 8200,
         signature: "(value) -> value",
         evaluate: (ops, { engine: ce }) => {
@@ -36014,6 +36179,7 @@ ${e.message}
       },
       // Creates an n×n identity matrix
       IdentityMatrix: {
+        description: "n-by-n identity matrix.",
         complexity: 8100,
         signature: "(integer) -> matrix",
         evaluate: (ops, { engine: ce }) => {
@@ -36034,6 +36200,7 @@ ${e.message}
       },
       // Creates an m×n matrix of zeros
       ZeroMatrix: {
+        description: "Matrix filled with zeros.",
         complexity: 8100,
         signature: "(integer, integer?) -> matrix",
         evaluate: (ops, { engine: ce }) => {
@@ -36061,6 +36228,7 @@ ${e.message}
       },
       // Creates an m×n matrix of ones
       OnesMatrix: {
+        description: "Matrix filled with ones.",
         complexity: 8100,
         signature: "(integer, integer?) -> matrix",
         evaluate: (ops, { engine: ce }) => {
@@ -36095,6 +36263,7 @@ ${e.message}
       // For matrices:
       //   - Frobenius (default): √(ΣΣ|aij|²)
       Norm: {
+        description: "Vector or matrix norm.",
         complexity: 8200,
         signature: "(value, number|string?) -> number",
         evaluate: (ops, { engine: ce }) => {
@@ -36216,6 +36385,7 @@ ${e.message}
       // For 2×2 matrices: uses characteristic polynomial (symbolic)
       // For larger matrices: uses QR algorithm (numeric)
       Eigenvalues: {
+        description: "Eigenvalues of a square matrix.",
         complexity: 8500,
         signature: "(matrix) -> list",
         evaluate: (ops, { engine: ce }) => {
@@ -36261,6 +36431,7 @@ ${e.message}
       // Compute the eigenvectors of a square matrix
       // Returns a list of eigenvectors (as column vectors)
       Eigenvectors: {
+        description: "Eigenvectors of a square matrix.",
         complexity: 8600,
         signature: "(matrix) -> list",
         evaluate: (ops, { engine: ce }) => {
@@ -36291,6 +36462,7 @@ ${e.message}
       // Compute both eigenvalues and eigenvectors
       // Returns a tuple: [eigenvalues, eigenvectors]
       Eigen: {
+        description: "Eigenvalue-eigenvector decomposition of a square matrix.",
         complexity: 8700,
         signature: "(matrix) -> tuple",
         evaluate: (ops, { engine: ce }) => {
@@ -36310,6 +36482,7 @@ ${e.message}
       // LU Decomposition: A = LU (or PA = LU with pivoting)
       // Returns [L, U] for no pivoting or [P, L, U] with pivoting
       LUDecomposition: {
+        description: "LU decomposition of a square matrix.",
         complexity: 8600,
         signature: "(matrix) -> tuple",
         evaluate: (ops, { engine: ce }) => {
@@ -36329,6 +36502,7 @@ ${e.message}
       // QR Decomposition: A = QR
       // Returns [Q, R] where Q is orthogonal and R is upper triangular
       QRDecomposition: {
+        description: "QR decomposition of a matrix.",
         complexity: 8600,
         signature: "(matrix) -> tuple",
         evaluate: (ops, { engine: ce }) => {
@@ -36348,6 +36522,7 @@ ${e.message}
       // Cholesky Decomposition: A = LL^T (for positive definite matrices)
       // Returns L (lower triangular matrix)
       CholeskyDecomposition: {
+        description: "Cholesky decomposition of a positive-definite matrix.",
         complexity: 8600,
         signature: "(matrix) -> matrix",
         evaluate: (ops, { engine: ce }) => {
@@ -36364,6 +36539,7 @@ ${e.message}
       // Singular Value Decomposition: A = UΣV^T
       // Returns [U, Σ, V] where U and V are orthogonal, Σ is diagonal
       SVD: {
+        description: "Singular value decomposition of a matrix.",
         complexity: 8700,
         signature: "(matrix) -> tuple",
         evaluate: (ops, { engine: ce }) => {
@@ -39821,6 +39997,7 @@ ${e.message}
   var STATISTICS_LIBRARY = [
     {
       Erf: {
+        description: "Gauss error function",
         complexity: 7500,
         signature: "(number) -> number",
         type: () => "finite_real",
@@ -39831,6 +40008,7 @@ ${e.message}
         }
       },
       Erfc: {
+        description: "Complementary error function: 1 - Erf(x)",
         complexity: 7500,
         signature: "(number) -> number",
         type: () => "finite_real",
@@ -39841,6 +40019,7 @@ ${e.message}
         }
       },
       ErfInv: {
+        description: "Inverse of the error function",
         complexity: 7500,
         signature: "(number) -> number",
         type: () => "finite_real",
@@ -39859,7 +40038,7 @@ ${e.message}
         broadcastable: false,
         signature: "((collection|number)+) -> number",
         type: () => "finite_real",
-        description: "The most frequently occurring value in the collection.",
+        description: "Arithmetic mean of a collection of numbers.",
         evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
           const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
           return engine.number(
@@ -39872,7 +40051,7 @@ ${e.message}
         broadcastable: false,
         signature: "((collection|number)+) -> number",
         type: () => "finite_real",
-        description: "The most frequently occurring value in the collection.",
+        description: "Median of a collection of numbers.",
         examples: ["Mode([1, 2, 2, 3])  // Returns 2"],
         evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
           const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
@@ -39882,6 +40061,7 @@ ${e.message}
         }
       },
       Variance: {
+        description: "Sample variance of a collection of numbers.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> number",
@@ -39894,6 +40074,7 @@ ${e.message}
         }
       },
       PopulationVariance: {
+        description: "Population variance of a collection of numbers.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> number",
@@ -39941,6 +40122,7 @@ ${e.message}
         }
       },
       Kurtosis: {
+        description: "Kurtosis of a collection of numbers.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> number",
@@ -39953,6 +40135,7 @@ ${e.message}
         }
       },
       Skewness: {
+        description: "Skewness of a collection of numbers.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> number",
@@ -39965,6 +40148,7 @@ ${e.message}
         }
       },
       Mode: {
+        description: "Most frequently occurring value in a collection.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> number",
@@ -39977,6 +40161,7 @@ ${e.message}
         }
       },
       Quartiles: {
+        description: "Lower quartile, median, and upper quartile of a collection.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> tuple<mid:number, lower:number, upper:number>",
@@ -39988,6 +40173,7 @@ ${e.message}
         }
       },
       InterquartileRange: {
+        description: "Interquartile range (Q3 - Q1) of a collection.",
         complexity: 1200,
         broadcastable: false,
         signature: "((collection|number)+) -> number",
@@ -40742,6 +40928,7 @@ ${e.message}
     },
     {
       Degrees: {
+        description: "Convert an angle in degrees.",
         /* = Pi / 180 */
         signature: "(real) -> real",
         type: () => "finite_real",
@@ -40771,6 +40958,7 @@ ${e.message}
       },
       // DMS(degrees, minutes?, seconds?) — programmatic angle construction
       DMS: {
+        description: "Construct an angle from degrees, minutes, and seconds.",
         signature: "(real, real?, real?) -> real",
         type: () => "finite_real",
         canonical: (ops, { engine: ce }) => {
@@ -40794,6 +40982,7 @@ ${e.message}
       },
       // Hypot: sqrt(x*x + y*y)
       Hypot: {
+        description: "Hypotenuse length: sqrt(x^2 + y^2).",
         broadcastable: true,
         signature: "(real, real) -> real",
         type: () => "finite_real",
@@ -40810,6 +40999,7 @@ ${e.message}
       // (may be used in the definition of other functions below)
       //
       Arctan: {
+        description: "Inverse tangent.",
         wikidata: "Q2257242",
         complexity: 5200,
         broadcastable: true,
@@ -40819,6 +41009,7 @@ ${e.message}
         evaluate: ([x], { numericApproximation: numericApproximation2 }) => numericApproximation2 ? evalTrig("Arctan", x) : constructibleValues("Arctan", x) ?? evalTrig("Arctan", x)
       },
       Arctan2: {
+        description: "Two-argument arctangent giving the angle of a vector.",
         wikidata: "Q776598",
         complexity: 5200,
         broadcastable: true,
@@ -40864,6 +41055,7 @@ ${e.message}
       Sinh: trigFunction("Sinh", 6e3),
       /** = sin(z/2)^2 = (1 - cos z) / 2*/
       Haversine: {
+        description: "Haversine function.",
         wikidata: "Q2528380",
         broadcastable: true,
         signature: "(real) -> number",
@@ -40872,6 +41064,7 @@ ${e.message}
       },
       /** = 2 * Arcsin(Sqrt(z)) */
       InverseHaversine: {
+        description: "Inverse haversine function.",
         //  Range ['Interval', [['Negate', 'Pi'], 'Pi'],
         broadcastable: true,
         signature: "(real) -> real",
@@ -40895,6 +41088,7 @@ ${e.message}
       Coth: trigFunction("Coth", 6300),
       /** sinc(x) = sin(x)/x with sinc(0) = 1 (unnormalized cardinal sine) */
       Sinc: {
+        description: "Unnormalized sinc function: sin(x)/x with sinc(0)=1.",
         complexity: 5100,
         broadcastable: true,
         signature: "(number) -> real",
@@ -40906,6 +41100,7 @@ ${e.message}
       },
       /** FresnelS(x) = ∫₀ˣ sin(πt²/2) dt — odd function, S(∞) = 1/2 */
       FresnelS: {
+        description: "Fresnel sine integral.",
         complexity: 5200,
         broadcastable: true,
         signature: "(number) -> real",
@@ -40917,6 +41112,7 @@ ${e.message}
       },
       /** FresnelC(x) = ∫₀ˣ cos(πt²/2) dt — odd function, C(∞) = 1/2 */
       FresnelC: {
+        description: "Fresnel cosine integral.",
         complexity: 5200,
         broadcastable: true,
         signature: "(number) -> real",
@@ -40932,6 +41128,7 @@ ${e.message}
       //   outputDomain: ['TupleOf', 'RealNumbers', 'RealNumbers'],
       // },
       InverseFunction: {
+        description: "Inverse of a function.",
         lazy: true,
         signature: "(function) -> function",
         canonical: (ops, { engine }) => {
@@ -41308,6 +41505,18 @@ ${e.message}
     if (degree !== null) return ["Root", base, degree];
     return ["Sqrt", base];
   }
+  function negateNumberLiteral(expr) {
+    if (typeof expr === "number") return -expr;
+    if (typeof expr === "string") {
+      if (expr.startsWith("-")) return expr.slice(1);
+      if (expr.startsWith("+")) return "-" + expr.slice(1);
+      return "-" + expr;
+    }
+    const num = expr.num;
+    if (num.startsWith("-")) return { num: num.slice(1) };
+    if (num.startsWith("+")) return { num: "-" + num.slice(1) };
+    return { num: "-" + num };
+  }
   function serializeRoot(serializer, style, base, degree) {
     if (base === null || base === void 0) return "\\sqrt{}";
     degree = degree ?? 2;
@@ -41873,6 +42082,11 @@ ${e.message}
           minPrec: ADDITION_PRECEDENCE
         });
         if (rhs === null) return null;
+        if (operator(rhs) === "Negate") {
+          const value = operand(rhs, 1);
+          if (isNumberExpression(value))
+            return foldAssociativeOperator("Add", lhs, negateNumberLiteral(value));
+        }
         return foldAssociativeOperator("Add", lhs, rhs);
       },
       serialize: serializeAdd
@@ -42531,13 +42745,12 @@ ${e.message}
       associativity: "left",
       precedence: ADDITION_PRECEDENCE + 2,
       parse: (parser, lhs, terminator) => {
-        parser.index -= 1;
         const rhs = parser.parseExpression({
           ...terminator,
           minPrec: ADDITION_PRECEDENCE + 3
         });
         if (rhs === null) return null;
-        return ["Add", lhs, rhs];
+        return ["Subtract", lhs, rhs];
       },
       serialize: (serializer, expr) => {
         const lhs = serializer.wrap(operand(expr, 1), ADDITION_PRECEDENCE + 2);
@@ -47742,7 +47955,8 @@ Error in definition of "${name}"`,
         const exponent = asSmallInteger(expr.op2);
         if (exponent !== null)
           return [coef.pow(exponent), ce.function("Power", [base, expr.op2])];
-        if (expr.op2.isSame(0.5)) return [coef.sqrt(), ce.function("Sqrt", [base])];
+        if (expr.op2.isSame(0.5))
+          return [coef.sqrt(), ce.function("Sqrt", [base])];
         return [ce._numericValue(1), this];
       }
       if (isFunction2(expr, "Sqrt")) {
@@ -50047,7 +50261,7 @@ Error in definition of "${name}"`,
       if (args.length === 1 && locals.length === 0) {
         return _BaseCompiler.compile(args[0], target);
       }
-      const result = args.map(
+      const result = args.filter((a) => !isSymbol2(a, "Nothing")).map(
         (arg) => _BaseCompiler.compile(arg, {
           ...target,
           var: (id) => {
@@ -50055,7 +50269,8 @@ Error in definition of "${name}"`,
             return target.var(id);
           }
         })
-      );
+      ).filter((s) => s !== "");
+      if (result.length === 0) return "";
       result[result.length - 1] = `return ${result[result.length - 1]}`;
       return `(() => {${target.ws("\n")}${result.join(
         `;${target.ws("\n")}`
@@ -53363,7 +53578,8 @@ Error in definition of "${name}"`,
       if (numBase && denomBase && numBase.isSame(denomBase)) {
         if (!asRational(numExp) || !asRational(denomExp)) {
           const diffExp = ce.function("Add", [numExp, denomExp.neg()]);
-          if (diffExp.isSame(0)) return { value: ce.One, because: "x^a/x^a -> 1" };
+          if (diffExp.isSame(0))
+            return { value: ce.One, because: "x^a/x^a -> 1" };
           if (diffExp.isSame(1))
             return { value: numBase, because: "x^a/x^b -> x when a-b=1" };
           return {
@@ -53819,7 +54035,8 @@ Error in definition of "${name}"`,
       const ce = expr.engine;
       if (y.isFinite === false && x.isFinite === false)
         return { value: ce.NaN, because: "arctan2" };
-      if (y.isSame(0) && x.isSame(0)) return { value: ce.Zero, because: "arctan2" };
+      if (y.isSame(0) && x.isSame(0))
+        return { value: ce.Zero, because: "arctan2" };
       if (x.isFinite === false)
         return { value: x.isPositive ? ce.Zero : ce.Pi, because: "arctan2" };
       if (y.isFinite === false)
@@ -55237,10 +55454,10 @@ Error in definition of "${name}"`,
       if (this._def) return this;
       return this.engine.symbol(this._id);
     }
-    is(other) {
-      if (this.isSame(other)) return true;
+    is(other, tolerance) {
+      if (tolerance === void 0 && this.isSame(other)) return true;
       const val = this.value;
-      if (val && val !== this) return val.is(other);
+      if (val && val !== this) return val.is(other, tolerance);
       return false;
     }
     isSame(other) {
@@ -57302,21 +57519,23 @@ Error in definition of "${name}"`,
   var GPU_GAMMA_PREAMBLE = `
 float _gpu_gamma(float z) {
   const float PI = 3.14159265358979;
-  if (z < 0.5) {
-    return PI / (sin(PI * z) * _gpu_gamma(1.0 - z));
-  }
-  z -= 1.0;
+  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)
+  float w = z;
+  if (z < 0.5) w = 1.0 - z;
+  w -= 1.0;
   float x = 0.99999999999980993;
-  x += 676.5203681218851 / (z + 1.0);
-  x += -1259.1392167224028 / (z + 2.0);
-  x += 771.32342877765313 / (z + 3.0);
-  x += -176.61502916214059 / (z + 4.0);
-  x += 12.507343278686905 / (z + 5.0);
-  x += -0.13857109526572012 / (z + 6.0);
-  x += 9.9843695780195716e-6 / (z + 7.0);
-  x += 1.5056327351493116e-7 / (z + 8.0);
-  float t = z + 7.5;
-  return sqrt(2.0 * PI) * pow(t, z + 0.5) * exp(-t) * x;
+  x += 676.5203681218851 / (w + 1.0);
+  x += -1259.1392167224028 / (w + 2.0);
+  x += 771.32342877765313 / (w + 3.0);
+  x += -176.61502916214059 / (w + 4.0);
+  x += 12.507343278686905 / (w + 5.0);
+  x += -0.13857109526572012 / (w + 6.0);
+  x += 9.9843695780195716e-6 / (w + 7.0);
+  x += 1.5056327351493116e-7 / (w + 8.0);
+  float t = w + 7.5;
+  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;
+  if (z < 0.5) return PI / (sin(PI * z) * g);
+  return g;
 }
 
 float _gpu_gammaln(float z) {
@@ -60677,21 +60896,23 @@ IntervalResult ia_asech(IntervalResult x) {
 // Poles at non-positive integers; minimum at x \u2248 1.4616
 float _gpu_gamma(float z) {
   const float PI = 3.14159265358979;
-  if (z < 0.5) {
-    return PI / (sin(PI * z) * _gpu_gamma(1.0 - z));
-  }
-  z -= 1.0;
+  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)
+  float w = z;
+  if (z < 0.5) w = 1.0 - z;
+  w -= 1.0;
   float x = 0.99999999999980993;
-  x += 676.5203681218851 / (z + 1.0);
-  x += -1259.1392167224028 / (z + 2.0);
-  x += 771.32342877765313 / (z + 3.0);
-  x += -176.61502916214059 / (z + 4.0);
-  x += 12.507343278686905 / (z + 5.0);
-  x += -0.13857109526572012 / (z + 6.0);
-  x += 9.9843695780195716e-6 / (z + 7.0);
-  x += 1.5056327351493116e-7 / (z + 8.0);
-  float t = z + 7.5;
-  return sqrt(2.0 * PI) * pow(t, z + 0.5) * exp(-t) * x;
+  x += 676.5203681218851 / (w + 1.0);
+  x += -1259.1392167224028 / (w + 2.0);
+  x += 771.32342877765313 / (w + 3.0);
+  x += -176.61502916214059 / (w + 4.0);
+  x += 12.507343278686905 / (w + 5.0);
+  x += -0.13857109526572012 / (w + 6.0);
+  x += 9.9843695780195716e-6 / (w + 7.0);
+  x += 1.5056327351493116e-7 / (w + 8.0);
+  float t = w + 7.5;
+  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;
+  if (z < 0.5) return PI / (sin(PI * z) * g);
+  return g;
 }
 
 // Interval gamma function
@@ -60864,6 +61085,128 @@ float ia_notEqual(IntervalResult a, IntervalResult b) {
   return ia_notEqual(a.value, b.value);
 }
 `;
+  var _preambleHeader = "";
+  var _preambleFunctions = /* @__PURE__ */ new Map();
+  var _preambleParsed = false;
+  var GLSL_FUNC_RE = /^(IntervalResult|vec2|float|bool|void)\s+(ia_\w+|_gpu_\w+)\s*\(/;
+  var GLSL_CALL_RE = /\b(ia_\w+|_gpu_\w+)\s*\(/g;
+  var GLSL_CONST_RE = /^const\s+float\s+(IA_\w+)\s*=/;
+  function parsePreamble() {
+    if (_preambleParsed) return;
+    _preambleParsed = true;
+    const lines = GLSL_INTERVAL_LIBRARY.split("\n");
+    let headerDone = false;
+    const headerLines = [];
+    let currentBlock = [];
+    let currentName = null;
+    let braceDepth = 0;
+    let inFunction = false;
+    let pendingComments = [];
+    let pendingConstants = [];
+    for (const line of lines) {
+      const constMatch = !inFunction && GLSL_CONST_RE.exec(line);
+      if (constMatch && headerDone) {
+        pendingConstants.push(line);
+        continue;
+      }
+      const funcMatch = !inFunction && GLSL_FUNC_RE.exec(line);
+      if (funcMatch) {
+        if (!headerDone) {
+          _preambleHeader = headerLines.join("\n");
+          headerDone = true;
+        }
+        currentName = funcMatch[2];
+        currentBlock = [...pendingComments, ...pendingConstants, line];
+        pendingComments = [];
+        pendingConstants = [];
+        inFunction = true;
+        braceDepth = 0;
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        if (braceDepth <= 0) {
+          finishFunction(currentName, currentBlock.join("\n"));
+          inFunction = false;
+          currentName = null;
+        }
+      } else if (inFunction) {
+        currentBlock.push(line);
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        if (braceDepth <= 0) {
+          finishFunction(currentName, currentBlock.join("\n"));
+          inFunction = false;
+          currentName = null;
+        }
+      } else if (!headerDone) {
+        headerLines.push(line);
+      } else {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed === "") {
+          pendingComments.push(line);
+        }
+      }
+    }
+    if (pendingConstants.length > 0) {
+      _preambleHeader += "\n" + pendingConstants.join("\n");
+    }
+  }
+  function finishFunction(name, source) {
+    const deps = /* @__PURE__ */ new Set();
+    let match2;
+    const callRe = new RegExp(GLSL_CALL_RE.source, "g");
+    while ((match2 = callRe.exec(source)) !== null) {
+      const callee = match2[1];
+      if (callee !== name) deps.add(callee);
+    }
+    const existing = _preambleFunctions.get(name);
+    if (existing) {
+      existing.source += "\n\n" + source;
+      for (const d of deps) existing.deps.push(d);
+    } else {
+      _preambleFunctions.set(name, {
+        name,
+        source,
+        deps: [...deps]
+      });
+    }
+  }
+  function buildIntervalPreamble(code) {
+    parsePreamble();
+    const needed = /* @__PURE__ */ new Set();
+    let match2;
+    const callRe = new RegExp(GLSL_CALL_RE.source, "g");
+    while ((match2 = callRe.exec(code)) !== null) {
+      needed.add(match2[1]);
+    }
+    if (needed.size === 0) return _preambleHeader;
+    const resolved = /* @__PURE__ */ new Set();
+    function resolve(name) {
+      if (resolved.has(name)) return;
+      const block = _preambleFunctions.get(name);
+      if (!block) return;
+      for (const dep of block.deps) resolve(dep);
+      resolved.add(name);
+    }
+    for (const name of needed) resolve(name);
+    const parts = [_preambleHeader];
+    const needsComparisonConstants = [...resolved].some(
+      (name) => name.startsWith("ia_less") || name.startsWith("ia_greater") || name.startsWith("ia_equal") || name.startsWith("ia_notEqual") || name === "ia_and" || name === "ia_or" || name === "ia_not"
+    );
+    if (needsComparisonConstants) {
+      parts.push(
+        "\nconst float IA_TRUE = 1.0;\nconst float IA_FALSE = 0.0;\nconst float IA_MAYBE = 0.5;"
+      );
+    }
+    for (const name of resolved) {
+      const block = _preambleFunctions.get(name);
+      if (block) parts.push("\n" + block.source);
+    }
+    return parts.join("\n");
+  }
   var INTERVAL_GLSL_OPERATORS = {
     Add: ["ia_add", 20],
     Negate: ["ia_negate", 20],
@@ -61089,7 +61432,7 @@ float ia_notEqual(IntervalResult a, IntervalResult b) {
         target: "interval-glsl",
         success: true,
         code: glslCode,
-        preamble: GLSL_INTERVAL_LIBRARY
+        preamble: buildIntervalPreamble(glslCode)
       };
     }
     /**
@@ -61132,7 +61475,7 @@ float ia_notEqual(IntervalResult a, IntervalResult b) {
       return `#version ${version2}
 precision highp float;
 
-${GLSL_INTERVAL_LIBRARY}
+${buildIntervalPreamble(body)}
 
 IntervalResult ${functionName}(${params}) {
   return ${body};
@@ -62243,6 +62586,122 @@ fn ia_notEqual(a: IntervalResult, b: IntervalResult) -> f32 {
   return ia_notEqual_v(a.value, b.value);
 }
 `;
+  var _wgslPreambleHeader = "";
+  var _wgslPreambleFunctions = /* @__PURE__ */ new Map();
+  var _wgslPreambleParsed = false;
+  var WGSL_FUNC_RE = /^fn\s+(ia_\w+|_gpu_\w+)\s*\(/;
+  var WGSL_CALL_RE = /\b(ia_\w+|_gpu_\w+)\s*\(/g;
+  var WGSL_CONST_RE = /^const\s+(IA_\w+)\s*:/;
+  function parseWGSLPreamble() {
+    if (_wgslPreambleParsed) return;
+    _wgslPreambleParsed = true;
+    const lines = WGSL_INTERVAL_LIBRARY.split("\n");
+    let headerDone = false;
+    const headerLines = [];
+    let currentBlock = [];
+    let currentName = null;
+    let braceDepth = 0;
+    let inFunction = false;
+    let pendingComments = [];
+    let pendingConstants = [];
+    for (const line of lines) {
+      const constMatch = !inFunction && WGSL_CONST_RE.exec(line);
+      if (constMatch && headerDone) {
+        pendingConstants.push(line);
+        continue;
+      }
+      const funcMatch = !inFunction && WGSL_FUNC_RE.exec(line);
+      if (funcMatch) {
+        if (!headerDone) {
+          _wgslPreambleHeader = headerLines.join("\n");
+          headerDone = true;
+        }
+        currentName = funcMatch[1];
+        currentBlock = [...pendingComments, ...pendingConstants, line];
+        pendingComments = [];
+        pendingConstants = [];
+        inFunction = true;
+        braceDepth = 0;
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        if (braceDepth <= 0) {
+          finishWGSLFunction(currentName, currentBlock.join("\n"));
+          inFunction = false;
+          currentName = null;
+        }
+      } else if (inFunction) {
+        currentBlock.push(line);
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        if (braceDepth <= 0) {
+          finishWGSLFunction(currentName, currentBlock.join("\n"));
+          inFunction = false;
+          currentName = null;
+        }
+      } else if (!headerDone) {
+        headerLines.push(line);
+      } else {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed === "") {
+          pendingComments.push(line);
+        }
+      }
+    }
+    if (pendingConstants.length > 0) {
+      _wgslPreambleHeader += "\n" + pendingConstants.join("\n");
+    }
+  }
+  function finishWGSLFunction(name, source) {
+    const deps = /* @__PURE__ */ new Set();
+    let match2;
+    const callRe = new RegExp(WGSL_CALL_RE.source, "g");
+    while ((match2 = callRe.exec(source)) !== null) {
+      const callee = match2[1];
+      if (callee !== name) deps.add(callee);
+    }
+    _wgslPreambleFunctions.set(name, {
+      name,
+      source,
+      deps: [...deps]
+    });
+  }
+  function buildIntervalWGSLPreamble(code) {
+    parseWGSLPreamble();
+    const needed = /* @__PURE__ */ new Set();
+    let match2;
+    const callRe = new RegExp(WGSL_CALL_RE.source, "g");
+    while ((match2 = callRe.exec(code)) !== null) {
+      needed.add(match2[1]);
+    }
+    if (needed.size === 0) return _wgslPreambleHeader;
+    const resolved = /* @__PURE__ */ new Set();
+    function resolve(name) {
+      if (resolved.has(name)) return;
+      const block = _wgslPreambleFunctions.get(name);
+      if (!block) return;
+      for (const dep of block.deps) resolve(dep);
+      resolved.add(name);
+    }
+    for (const name of needed) resolve(name);
+    const parts = [_wgslPreambleHeader];
+    const needsComparisonConstants = [...resolved].some(
+      (name) => name.startsWith("ia_less") || name.startsWith("ia_greater") || name.startsWith("ia_equal") || name.startsWith("ia_notEqual") || name === "ia_and" || name === "ia_or" || name === "ia_not"
+    );
+    if (needsComparisonConstants) {
+      parts.push(
+        "\nconst IA_TRUE: f32 = 1.0;\nconst IA_FALSE: f32 = 0.0;\nconst IA_MAYBE: f32 = 0.5;"
+      );
+    }
+    for (const name of resolved) {
+      const block = _wgslPreambleFunctions.get(name);
+      if (block) parts.push("\n" + block.source);
+    }
+    return parts.join("\n");
+  }
   var INTERVAL_WGSL_OPERATORS = {
     Add: ["ia_add", 20],
     Negate: ["ia_negate", 20],
@@ -62466,7 +62925,7 @@ fn ia_notEqual(a: IntervalResult, b: IntervalResult) -> f32 {
         target: "interval-wgsl",
         success: true,
         code: wgslCode,
-        preamble: WGSL_INTERVAL_LIBRARY
+        preamble: buildIntervalWGSLPreamble(wgslCode)
       };
     }
     /**
@@ -62502,7 +62961,8 @@ fn ia_notEqual(a: IntervalResult, b: IntervalResult) -> f32 {
       const target = this.createTarget();
       const body = BaseCompiler.compile(expr, target);
       const params = parameters.map((name) => `${name}: vec2f`).join(", ");
-      return `${WGSL_INTERVAL_LIBRARY}
+      const preamble = buildIntervalWGSLPreamble(body);
+      return `${preamble}
 
 fn ${functionName}(${params}) -> IntervalResult {
   return ${body};
@@ -62992,7 +63452,23 @@ fn ${functionName}(${params}) -> IntervalResult {
       if (typeof this._value === "number") return true;
       return isSubtype(this._value.type, "real");
     }
-    is(other) {
+    get isExact() {
+      const n = this._value;
+      if (typeof n === "number")
+        return !Number.isFinite(n) || Number.isInteger(n);
+      return n.isExact;
+    }
+    is(other, tolerance) {
+      if (tolerance === void 0) return this.isSame(other);
+      if (typeof other === "number") {
+        return Math.abs(this.re - other) <= tolerance && Math.abs(this.im) <= tolerance;
+      }
+      if (typeof other === "bigint") {
+        return Math.abs(this.re - Number(other)) <= tolerance && Math.abs(this.im) <= tolerance;
+      }
+      if (other instanceof _BoxedExpression && isNumber(other)) {
+        return Math.abs(this.re - other.re) <= tolerance && Math.abs(this.im - other.im) <= tolerance;
+      }
       return this.isSame(other);
     }
     isSame(other) {
@@ -65552,6 +66028,58 @@ fn ${functionName}(${params}) -> IntervalResult {
         return null;
       }
       this.skipSpace();
+      let subscript = null;
+      if (this.peek === "_") {
+        const underIndex = this.index;
+        this.index++;
+        subscript = this.parseGroup();
+        if (subscript === null) {
+          const subStart = this.index;
+          if (!this.atEnd && /^[a-zA-Z]$/.test(this.peek)) {
+            subscript = this.peek;
+            this.index++;
+          } else {
+            let digits = "";
+            while (!this.atEnd && /^[0-9]$/.test(this.peek)) {
+              digits += this.peek;
+              this.index++;
+            }
+            if (digits) subscript = parseInt(digits);
+          }
+          if (subscript === null) {
+            this.index = start;
+            return null;
+          }
+        }
+        this.skipSpace();
+      }
+      let exponent = null;
+      if (this.peek === "^") {
+        const caretIndex = this.index;
+        this.index++;
+        exponent = this.parseGroup();
+        if (exponent === null) {
+          const digitStart = this.index;
+          let neg2 = false;
+          if (this.peek === "-") {
+            neg2 = true;
+            this.index++;
+          }
+          let digits = "";
+          while (!this.atEnd && /^[0-9]$/.test(this.peek)) {
+            digits += this.peek;
+            this.index++;
+          }
+          if (digits) {
+            const num = parseInt(digits);
+            exponent = neg2 ? -num : num;
+          } else {
+            this.index = start;
+            return null;
+          }
+        }
+        this.skipSpace();
+      }
       if (this.peek !== "(") {
         this.index = start;
         return null;
@@ -65626,8 +66154,19 @@ fn ${functionName}(${params}) -> IntervalResult {
         this.index = start;
         return null;
       }
-      if (name === "cbrt") return ["Root", args[0] ?? "Nothing", 3];
-      return [fnName, ...args];
+      if (name === "cbrt") {
+        const result2 = ["Root", args[0] ?? "Nothing", 3];
+        return exponent !== null ? ["Power", result2, exponent] : result2;
+      }
+      let result;
+      if (name === "log" && subscript !== null) {
+        if (subscript === 2) result = ["Lb", ...args];
+        else if (subscript === 10) result = ["Log", ...args];
+        else result = ["Log", args[0], subscript];
+      } else {
+        result = [fnName, ...args];
+      }
+      return exponent !== null ? ["Power", result, exponent] : result;
     }
     static BARE_SYMBOL_MAP = {
       // Greek lowercase
@@ -69529,10 +70068,10 @@ ${code}`;
   _setComputeEngineClass(ComputeEngine);
 
   // src/compute-engine.ts
-  var version = "0.52.0";
+  var version = "0.52.1";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.52.0"
+    version: "0.52.1"
   };
   return __toCommonJS(compute_engine_exports);
 })();