@cortex-js/compute-engine 0.17.0 → 0.18.1

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.17.0 */
+/** CortexJS Compute Engine 0.18.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 __create = Object.create;
@@ -1093,7 +1093,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/compute-engine.ts
-  var import_complex20 = __toESM(require_complex(), 1);
+  var import_complex20 = __toESM(require_complex());
 
   // node_modules/decimal.js/decimal.mjs
   var EXP_LIMIT = 9e15;
@@ -4889,8 +4889,41 @@ var ComputeEngine = (() => {
       identifierTrigger: "lcm",
       kind: "function"
     },
-    { name: "Max", identifierTrigger: "max", kind: "function" },
-    { name: "Min", identifierTrigger: "min", kind: "function" },
+    { identifierTrigger: "max", kind: "function", parse: "Max" },
+    { identifierTrigger: "min", kind: "function", parse: "Min" },
+    { name: "Max", latexTrigger: "\\max", kind: "function" },
+    { name: "Min", latexTrigger: "\\min", kind: "function" },
+    { name: "Supremum", latexTrigger: "\\sup", kind: "function" },
+    { name: "Infimum", latexTrigger: "\\inf", kind: "function" },
+    {
+      name: "Limit",
+      latexTrigger: "\\lim",
+      kind: "expression",
+      parse: (parser) => {
+        if (!parser.match("_"))
+          return void 0;
+        const base = parser.parseGroup();
+        if (head(base) !== "To")
+          return void 0;
+        const expr = parser.parseArguments("implicit");
+        if (!expr)
+          return void 0;
+        return ["Limit", ["Function", expr[0], op(base, 1)], op(base, 2)];
+      },
+      serialize: (serializer, expr) => {
+        const fn = op(expr, 1);
+        const fnVar = op(fn, 2);
+        const to = op(expr, 2);
+        return joinLatex([
+          "\\lim_{",
+          serializer.serialize(fnVar),
+          "\\to",
+          serializer.serialize(to),
+          "}",
+          serializer.serialize(op(fn, 1))
+        ]);
+      }
+    },
     {
       name: "MinusPlus",
       latexTrigger: ["\\mp"],
@@ -5328,13 +5361,14 @@ var ComputeEngine = (() => {
     },
     {
       name: "Assign",
-      kind: "function",
       latexTrigger: "\\coloneqq",
+      kind: "infix",
+      associativity: "right",
       precedence: 260,
-      parse: (parser, lhs) => {
-        const rhs = parser.parseExpression({ minPrec: 260 }) ?? "Nothing";
-        return ["Assign", lhs, rhs];
-      },
+      // parse: (parser: Parser, lhs: Expression) => {
+      //   const rhs = parser.parseExpression({ minPrec: 260 }) ?? 'Nothing';
+      //   return ['Assign', lhs, rhs];
+      // },
       serialize: (serializer, expr) => {
         return joinLatex([
           serializer.serialize(op(expr, 1)),
@@ -5344,22 +5378,31 @@ var ComputeEngine = (() => {
       }
     },
     {
-      kind: "function",
-      latexTrigger: ":=",
-      // \coloneqq
-      parse: (parser, lhs) => {
-        const rhs = parser.parseExpression({ minPrec: 270 }) ?? "Nothing";
-        return ["Assign", lhs, rhs];
-      }
+      latexTrigger: [":", "="],
+      kind: "infix",
+      associativity: "right",
+      precedence: 260,
+      parse: "Assign"
     },
+    // {
+    //   kind: 'function',
+    //   latexTrigger: ':=', // \coloneqq
+    //   parse: (parser: Parser, lhs: Expression) => {
+    //     const rhs = parser.parseExpression({ minPrec: 270 }) ?? 'Nothing';
+    //     return ['Assign', lhs, rhs];
+    //   },
+    // },
     {
-      kind: "function",
       latexTrigger: "\\colonequals",
       // \coloneqq
-      parse: (parser, lhs) => {
-        const rhs = parser.parseExpression({ minPrec: 270 }) ?? "Nothing";
-        return ["Assign", lhs, rhs];
-      }
+      kind: "infix",
+      associativity: "right",
+      precedence: 260,
+      parse: "Assign"
+      // parse: (parser: Parser, lhs: Expression) => {
+      //   const rhs = parser.parseExpression({ minPrec: 270 }) ?? 'Nothing';
+      //   return ['Assign', lhs, rhs];
+      // },
     },
     {
       name: "BaseForm",
@@ -6104,13 +6147,6 @@ var ComputeEngine = (() => {
       associativity: "right",
       precedence: 260
     },
-    {
-      latexTrigger: [":", "="],
-      kind: "infix",
-      associativity: "right",
-      precedence: 260,
-      parse: "Assign"
-    },
     {
       name: "Approx",
       // Note: Mathematica TildeTilde
@@ -8702,7 +8738,7 @@ var ComputeEngine = (() => {
     applyInvisibleOperator: "auto",
     skipSpace: true,
     parseArgumentsOfUnknownLatexCommands: true,
-    parseNumbers: true,
+    parseNumbers: "auto",
     parseUnknownIdentifier: (id, parser) => parser.computeEngine?.lookupFunction(id) !== void 0 ? "function" : "symbol",
     preserveLatex: false
   };
@@ -9312,27 +9348,27 @@ var ComputeEngine = (() => {
       if (this.matchAny(["e", "E"])) {
         const exponent = this.parseSignedInteger({ withGrouping: false });
         if (exponent)
-          return "e" + exponent;
+          return exponent;
       }
       this.index = start;
       if (this.match("\\times")) {
         this.skipSpaceTokens();
         if (this.match("1") && this.match("0") && this.match("^")) {
           if (/^[0-9]$/.test(this.peek))
-            return "e" + this.nextToken();
+            return this.nextToken();
           if (this.match("<{>")) {
             this.skipSpaceTokens();
             const exponent = this.parseSignedInteger();
             this.skipSpaceTokens();
             if (this.match("<}>") && exponent)
-              return "e" + exponent;
+              return exponent;
           }
         }
       }
       this.index = start;
       this.skipSpaceTokens();
       if (this.match("\\%"))
-        return `e-2`;
+        return `-2`;
       this.index = start;
       if (this.matchAll(this._exponentProductTokens)) {
         this.skipSpaceTokens();
@@ -9341,7 +9377,7 @@ var ComputeEngine = (() => {
           const exponent = this.parseSignedInteger();
           this.skipSpaceTokens();
           if (this.matchAll(this._endExponentMarkerTokens) && exponent)
-            return "e" + exponent;
+            return exponent;
         }
       }
       this.index = start;
@@ -9389,43 +9425,65 @@ var ComputeEngine = (() => {
      * repeating decimals, etc...
      */
     parseNumber() {
-      if (!this.options.parseNumbers)
+      if (this.options.parseNumbers === false || this.options.parseNumbers === "never")
         return null;
       const start = this.index;
       this.skipVisualSpace();
       this.match("+");
-      let result = "";
-      let dotPrefix = false;
+      let wholePart = "";
+      let fractionalPart = "";
+      let startsWithDecimalMarker = false;
       if (this.match(".") || this.matchAll(this._decimalMarkerTokens)) {
         const peek = this.peek;
-        if (peek !== "\\overline" && peek !== this._beginRepeatingDigitsTokens[0] && !/[0-9\(]/.test(peek)) {
-          this.index = start;
-          return null;
-        }
-        dotPrefix = true;
-      } else {
-        result = this.parseDecimalDigits({ withGrouping: true });
-        if (!result) {
-          this.index = start;
-          return null;
+        if (peek === "\\overline" || peek === this._beginRepeatingDigitsTokens[0] || /[0-9\(]/.test(peek)) {
+          startsWithDecimalMarker = true;
+          wholePart = "0";
         }
+      } else
+        wholePart = this.parseDecimalDigits({ withGrouping: true });
+      if (!wholePart) {
+        this.index = start;
+        return null;
       }
-      let hasDecimal = true;
-      if (!dotPrefix && (this.match(".") || this.matchAll(this._decimalMarkerTokens)))
-        result += "." + this.parseDecimalDigits({ withGrouping: true });
-      else if (dotPrefix)
-        result = "0." + this.parseDecimalDigits({ withGrouping: true });
+      let hasFractionalPart = true;
+      if (startsWithDecimalMarker || this.match(".") || this.matchAll(this._decimalMarkerTokens))
+        fractionalPart = this.parseDecimalDigits({ withGrouping: true });
       else
-        hasDecimal = false;
-      if (hasDecimal) {
+        hasFractionalPart = false;
+      let hasRepeatingPart = false;
+      if (hasFractionalPart) {
         const repeat = this.parseRepeatingDecimal();
-        if (repeat)
-          result += repeat;
-        else if (this.match("\\ldots") || this.matchAll(this._truncationMarkerTokens)) {
+        if (repeat) {
+          fractionalPart += repeat;
+          hasRepeatingPart = true;
+        } else if (this.match("\\ldots") || this.matchAll(this._truncationMarkerTokens)) {
         }
       }
       this.skipVisualSpace();
-      return result + this.parseExponent();
+      const exponent = this.parseExponent();
+      if (!hasRepeatingPart && this.options.parseNumbers === "rational") {
+        const whole = parseInt(wholePart, 10);
+        if (!fractionalPart) {
+          if (exponent)
+            return ["Multiply", whole, ["Power", 10, exponent]];
+          return whole;
+        }
+        const fraction = parseInt(fractionalPart, 10);
+        const n = fractionalPart.length;
+        const numerator = whole * Math.pow(10, n) + fraction;
+        const denominator = Math.pow(10, n);
+        if (exponent) {
+          return [
+            "Multiply",
+            ["Rational", numerator, denominator],
+            ["Power", 10, exponent]
+          ];
+        }
+        return ["Rational", numerator, denominator];
+      }
+      return {
+        num: wholePart + (hasFractionalPart ? "." + fractionalPart : "") + (exponent ? "e" + exponent : "")
+      };
     }
     /**
      * A Latex number can be a decimal, hex or octal number.
@@ -9873,18 +9931,24 @@ var ComputeEngine = (() => {
           (x) => x.latexTrigger === "^"
         );
         if (defs) {
-          const arg = [
-            "Superscript",
-            result,
-            superscripts.length === 1 ? superscripts[0] : ["List", ...superscripts]
-          ];
-          for (const def of defs) {
-            if (typeof def.parse === "function")
-              result = def.parse(this, arg, { minPrec: 0 });
-            else
-              result = arg;
-            if (result)
-              break;
+          let nonEmptySuperscripts = superscripts.filter(
+            (x) => head(x) !== "Sequence"
+          );
+          if (nonEmptySuperscripts.length !== 0) {
+            const superscriptExpression = nonEmptySuperscripts.length === 1 ? nonEmptySuperscripts[0] : ["List", ...nonEmptySuperscripts];
+            const arg = [
+              "Superscript",
+              result,
+              superscriptExpression
+            ];
+            for (const def of defs) {
+              if (typeof def.parse === "function")
+                result = def.parse(this, arg, { minPrec: 0 });
+              else
+                result = arg;
+              if (result)
+                break;
+            }
           }
         }
       }
@@ -10051,8 +10115,11 @@ var ComputeEngine = (() => {
           const [def, n] = opDefs[0];
           if (this.peek === "^") {
             this.index += 1;
-            this.parseGroup();
-            this.error("unexpected-operator", start);
+            return [
+              "Superscript",
+              this.error("missing", start),
+              missingIfEmpty(this.parseGroup())
+            ];
           }
           this.index += n;
           if (typeof def.parse === "function") {
@@ -10159,11 +10226,7 @@ var ComputeEngine = (() => {
           );
         }
       }
-      if (result === null) {
-        const num = this.parseNumber();
-        if (num !== null)
-          result = { num };
-      }
+      result ?? (result = this.parseNumber());
       result ?? (result = this.parseEnclosure());
       result ?? (result = this.parseEnvironment(until));
       if (result === null && this.matchAll(this._positiveInfinityTokens))
@@ -11091,10 +11154,65 @@ var ComputeEngine = (() => {
   };
 
   // src/compute-engine/boxed-expression/utils.ts
-  var import_complex2 = __toESM(require_complex(), 1);
+  var import_complex2 = __toESM(require_complex());
+
+  // src/compute-engine/numerics/numeric.ts
+  var import_complex = __toESM(require_complex());
+
+  // src/compute-engine/numerics/richardson.ts
+  function extrapolate(f, x0, options = {}) {
+    const {
+      contract = 0.125,
+      step = 1,
+      power = 2,
+      atol = 1e-16,
+      rtol = atol > 0 ? 0 : Math.sqrt(Number.EPSILON),
+      maxeval = 1e6,
+      // Number.MAX_SAFE_INTEGER
+      breaktol = 2
+    } = options;
+    if (!isFinite(x0)) {
+      return extrapolate((u) => f(1 / u), 1 / x0, {
+        rtol,
+        atol,
+        maxeval,
+        contract: Math.abs(contract) > 1 ? 1 / contract : contract,
+        step: 1 / step,
+        power
+      });
+    }
+    let h = step;
+    let invcontract = Math.pow(1 / contract, power);
+    let f0 = f(x0 + h);
+    let neville = [f0];
+    let err = Infinity;
+    let numeval = 1;
+    while (numeval < maxeval) {
+      numeval += 1;
+      h *= contract;
+      neville.push(f(x0 + h));
+      let c = invcontract;
+      let minerr = Infinity;
+      for (let i = neville.length - 2; i >= 0; i--) {
+        const old = neville[i];
+        neville[i] = neville[i + 1] + (neville[i + 1] - neville[i]) / (c - 1);
+        const err_ = Math.abs(neville[i] - old);
+        minerr = Math.min(minerr, err_);
+        if (err_ < err) {
+          f0 = neville[i];
+          err = err_;
+        }
+        c *= invcontract;
+      }
+      if (minerr > breaktol * err || !isFinite(minerr))
+        break;
+      if (err <= Math.max(rtol * Math.abs(f0), atol))
+        break;
+    }
+    return [f0, err];
+  }
 
   // src/compute-engine/numerics/numeric.ts
-  var import_complex = __toESM(require_complex(), 1);
   var MACHINE_PRECISION_BITS = 53;
   var MACHINE_PRECISION = Math.log10(
     Math.pow(2, MACHINE_PRECISION_BITS)
@@ -12426,10 +12544,10 @@ var ComputeEngine = (() => {
     const x7 = x5 * x2;
     return Math.sqrt(pi) / 2 * (x + pi / 12 * x3 + 7 * pi2 / 480 * x5 + 127 * pi3 / 40320 * x7 + 4369 * pi2 * pi2 / 5806080 * x7 * x2 + 34807 * pi3 * pi2 / 182476800 * x7 * x2 * x2);
   }
-  function centeredDiff8thOrder(f, x, h = 1e-4) {
-    return (-f(x - 4 * h) + 9 * f(x - 3 * h) - 45 * f(x - 2 * h) + 186 * f(x - h) - 186 * f(x + h) + 45 * f(x + 2 * h) - 9 * f(x + 3 * h) + f(x + 4 * h)) / (60 * h);
+  function centeredDiff8thOrder(f, x, h = 0.1) {
+    return (f(x - 4 * h) / 280 - 4 * f(x - 3 * h) / 105 + f(x - 2 * h) / 5 - 4 * f(x - h) / 5 + 4 * f(x + h) / 5 - f(x + 2 * h) / 5 + 4 * f(x + 3 * h) / 105 - f(x + 4 * h) / 280) / h;
   }
-  function monteCarloEstimate(f, a, b, n = 1e4) {
+  function monteCarloEstimate(f, a, b, n = 1e5) {
     let sum2 = 0;
     if (a === -Infinity && b === Infinity) {
       for (let i = 0; i < n; i++) {
@@ -12458,6 +12576,19 @@ var ComputeEngine = (() => {
     }
     return sum2 / n * (b - a);
   }
+  function limit(f, x, dir = 1) {
+    if (dir === 0) {
+      const left = limit(f, x, -1);
+      const right = limit(f, x, 1);
+      if (left === void 0 || right === void 0)
+        return NaN;
+      if (Math.abs(left - right) > 1e-5)
+        return NaN;
+      return (left + right) / 2;
+    }
+    const [val, err] = extrapolate(f, x, { step: dir > 0 ? 1 : -1 });
+    return val;
+  }
 
   // src/compute-engine/numerics/numeric-bigint.ts
   function bigint(a) {
@@ -12778,7 +12909,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/order.ts
-  var import_complex3 = __toESM(require_complex(), 1);
+  var import_complex3 = __toESM(require_complex());
 
   // src/compute-engine/symbolic/polynomials.ts
   function totalDegree(expr) {
@@ -12988,7 +13119,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/numerics/rationals.ts
-  var import_complex4 = __toESM(require_complex(), 1);
+  var import_complex4 = __toESM(require_complex());
   function isRational(x) {
     return x !== null && Array.isArray(x);
   }
@@ -13298,7 +13429,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/symbolic/sum.ts
-  var import_complex5 = __toESM(require_complex(), 1);
+  var import_complex5 = __toESM(require_complex());
   var Sum = class {
     constructor(ce, xs, options) {
       // If `false`, the running sums are not calculated
@@ -13734,7 +13865,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
-  var import_complex6 = __toESM(require_complex(), 1);
+  var import_complex6 = __toESM(require_complex());
 
   // src/compute-engine/library/utils.ts
   function normalizeLimits(range) {
@@ -13805,6 +13936,7 @@ var ComputeEngine = (() => {
     Gcd: "_SYS.gcd",
     // Math.hypot
     Lcm: "_SYS.lcm",
+    Limit: (args, compile2) => `_SYS.limit(${compile2(args[0])}, ${compile2(args[1])})`,
     Ln: "Math.log",
     Log: "Math.log10",
     LogGamma: "_SYS.lngamma",
@@ -13839,7 +13971,7 @@ var ComputeEngine = (() => {
     },
     Random: "Math.random",
     Round: "Math.round",
-    Sqaure: (args, compile2) => {
+    Square: (args, compile2) => {
       const arg = args[0];
       if (arg === null)
         throw new Error("Square: no argument");
@@ -13950,7 +14082,8 @@ var ComputeEngine = (() => {
         lngamma: gammaln,
         gcd,
         lcm,
-        chop
+        chop,
+        limit
       };
       return new Proxy(this, {
         apply: (target, thisArg, argumentsList) => super.apply(thisArg, [this.sys, ...argumentsList]),
@@ -13997,7 +14130,9 @@ ${js}`);
         return void 0;
       },
       string: (str) => JSON.stringify(str),
-      number: (n) => n.toString()
+      number: (n) => n.toString(),
+      indent: 0,
+      ws: (s) => s ?? ""
     });
   }
   function compileExpr(h, args, prec, target) {
@@ -14022,6 +14157,50 @@ ${js}`);
       }
       return op3[1] < prec ? `(${resultStr})` : resultStr;
     }
+    if (h === "Function") {
+      const params = args.slice(1).map((x) => x.symbol);
+      return `((${params.join(", ")}) => ${compile(args[0], {
+        ...target,
+        var: (id) => params.includes(id) ? id : target.var(id)
+      })})`;
+    }
+    if (h === "Declare")
+      return `let ${args[0].symbol}`;
+    if (h === "Assign")
+      return `${args[0].symbol} = ${compile(args[1], target)}`;
+    if (h === "Return")
+      return `return ${compile(args[0], target)}`;
+    if (h === "If") {
+      if (args.length !== 3)
+        throw new Error("If: wrong number of arguments");
+      return `((${compile(args[0], target)}) ? (${compile(
+        args[1],
+        target
+      )}) : (${compile(args[2], target)}))`;
+    }
+    if (h === "Block") {
+      const locals = [];
+      for (const arg of args) {
+        if (arg.head === "Declare")
+          locals.push(arg.ops[0].symbol);
+      }
+      if (args.length === 1 && locals.length === 0)
+        return compile(args[0], target);
+      const result = args.map(
+        (arg) => compile(arg, {
+          ...target,
+          var: (id) => {
+            if (locals.includes(id))
+              return id;
+            return target.var(id);
+          }
+        })
+      );
+      result[result.length - 1] = `return ${result[result.length - 1]}`;
+      return `(() => {${target.ws("\n")}${result.join(
+        `;${target.ws("\n")}`
+      )}${target.ws("\n")}})()`;
+    }
     const fn = target.functions?.(h);
     if (!fn)
       throw new Error(`Unknown function ${h}`);
@@ -14413,7 +14592,7 @@ ${js}`);
     compile(to = "javascript", options) {
       if (to !== "javascript")
         return void 0;
-      options ?? (options = { optimize: ["simplify", "evaluate"] });
+      options ?? (options = { optimize: ["simplify"] });
       let expr = this;
       if (options.optimize.includes("simplify"))
         expr = expr.simplify();
@@ -14787,7 +14966,7 @@ ${js}`);
   }
 
   // src/compute-engine/symbolic/utils.ts
-  var import_complex7 = __toESM(require_complex(), 1);
+  var import_complex7 = __toESM(require_complex());
   function makePositive(expr) {
     if (expr.head === "Negate")
       return [-1, expr.op1];
@@ -15342,7 +15521,7 @@ ${js}`);
   }
 
   // src/compute-engine/symbolic/negate.ts
-  var import_complex8 = __toESM(require_complex(), 1);
+  var import_complex8 = __toESM(require_complex());
   function negateLiteral(expr, metadata) {
     let n = expr.numericValue;
     if (n === null)
@@ -15874,10 +16053,10 @@ ${js}`);
   }
 
   // src/compute-engine/boxed-expression/box.ts
-  var import_complex14 = __toESM(require_complex(), 1);
+  var import_complex14 = __toESM(require_complex());
 
   // src/compute-engine/boxed-expression/serialize.ts
-  var import_complex10 = __toESM(require_complex(), 1);
+  var import_complex10 = __toESM(require_complex());
 
   // src/compute-engine/numerics/numeric-bignum.ts
   function factorial3(ce, n) {
@@ -15993,7 +16172,7 @@ ${js}`);
   }
 
   // src/compute-engine/symbolic/product.ts
-  var import_complex9 = __toESM(require_complex(), 1);
+  var import_complex9 = __toESM(require_complex());
   var Product = class {
     constructor(ce, xs, options) {
       this.options = options;
@@ -16932,7 +17111,7 @@ ${js}`);
   };
 
   // src/compute-engine/boxed-expression/boxed-function.ts
-  var import_complex11 = __toESM(require_complex(), 1);
+  var import_complex11 = __toESM(require_complex());
 
   // src/compute-engine/simplify-rules.ts
   var SIMPLIFY_RULES = [];
@@ -17625,10 +17804,12 @@ ${js}`);
       const sig = def?.signature;
       if (!result && sig) {
         const numericMode = options?.numericMode ?? false;
+        const context = this.engine.swapScope(this.scope);
         if (numericMode && sig.N)
           result = sig.N(this.engine, tail);
         if (!result && sig.evaluate)
           result = sig.evaluate(this.engine, tail);
+        this.engine.swapScope(context);
       }
       if (result) {
         const num = result.numericValue;
@@ -17821,10 +18002,10 @@ ${js}`);
   }
 
   // src/compute-engine/boxed-expression/boxed-number.ts
-  var import_complex13 = __toESM(require_complex(), 1);
+  var import_complex13 = __toESM(require_complex());
 
   // src/compute-engine/domain-utils.ts
-  var import_complex12 = __toESM(require_complex(), 1);
+  var import_complex12 = __toESM(require_complex());
   function inferNumericDomain(value) {
     if (typeof value === "number" && !isNaN(value)) {
       if (!isFinite(value))
@@ -18111,7 +18292,12 @@ ${js}`);
       return false;
     }
     isEqual(rhs) {
-      return this.isSame(rhs);
+      if (this === rhs)
+        return true;
+      if (!(rhs instanceof _BoxedNumber))
+        return false;
+      const s = signDiff(this, rhs);
+      return s === 0;
     }
     match(rhs, options) {
       if (this.isEqualWithTolerance(rhs, options?.numericTolerance ?? 0))
@@ -18766,7 +18952,7 @@ ${js}`);
   }
 
   // src/compute-engine/library/arithmetic.ts
-  var import_complex16 = __toESM(require_complex(), 1);
+  var import_complex16 = __toESM(require_complex());
 
   // src/compute-engine/numerics/numeric-complex.ts
   function gamma3(c) {
@@ -18777,7 +18963,7 @@ ${js}`);
   }
 
   // src/compute-engine/library/arithmetic-power.ts
-  var import_complex15 = __toESM(require_complex(), 1);
+  var import_complex15 = __toESM(require_complex());
   function canonicalPower(ce, base, exponent, metadata) {
     if (exponent.symbol === "ComplexInfinity")
       return ce.NaN;
@@ -20192,21 +20378,7 @@ ${js}`);
               return ops2[0];
             return ce.fn("Max", ops2);
           },
-          evaluate: (ce, ops2) => {
-            if (ops2.length === 0)
-              return ce.NegativeInfinity;
-            let result = void 0;
-            const rest = [];
-            for (const op3 of ops2) {
-              if (!op3.isNumber || op3.numericValue === void 0)
-                rest.push(op3);
-              else if (!result || op3.isGreater(result))
-                result = op3;
-            }
-            if (rest.length > 0)
-              return ce.box(result ? ["Max", result, ...rest] : ["Max", ...rest]);
-            return result ?? ce.NaN;
-          }
+          evaluate: (ce, ops2) => processMinMax(ce, ops2, "Max")
         }
       },
       Min: {
@@ -20216,26 +20388,42 @@ ${js}`);
           domain: ["FunctionOf", ["VarArg", "Values"], "Numbers"],
           simplify: (ce, ops2) => {
             if (ops2.length === 0)
-              return ce.NegativeInfinity;
+              return ce.PositiveInfinity;
             if (ops2.length === 1)
               return ops2[0];
             return ce.fn("Min", ops2);
           },
-          evaluate: (ce, ops2) => {
+          evaluate: (ce, ops2) => processMinMax(ce, ops2, "Min")
+        }
+      },
+      Supremum: {
+        description: "Like Max, but defined for open sets",
+        complexity: 1200,
+        signature: {
+          domain: ["FunctionOf", ["VarArg", "Values"], "Numbers"],
+          simplify: (ce, ops2) => {
             if (ops2.length === 0)
               return ce.NegativeInfinity;
-            let result = void 0;
-            const rest = [];
-            for (const op3 of ops2) {
-              if (!op3.isNumber || op3.numericValue === void 0)
-                rest.push(op3);
-              else if (!result || op3.isLess(result))
-                result = op3;
-            }
-            if (rest.length > 0)
-              return ce.box(result ? ["Min", result, ...rest] : ["Min", ...rest]);
-            return result ?? ce.NaN;
-          }
+            if (ops2.length === 1)
+              return ops2[0];
+            return ce.fn("Min", ops2);
+          },
+          evaluate: (ce, ops2) => processMinMax(ce, ops2, "Supremum")
+        }
+      },
+      Infimum: {
+        description: "Like Min, but defined for open sets",
+        complexity: 1200,
+        signature: {
+          domain: ["FunctionOf", ["VarArg", "Values"], "Numbers"],
+          simplify: (ce, ops2) => {
+            if (ops2.length === 0)
+              return ce.PositiveInfinity;
+            if (ops2.length === 1)
+              return ops2[0];
+            return ce.fn("Min", ops2);
+          },
+          evaluate: (ce, ops2) => processMinMax(ce, ops2, "Infimum")
         }
       },
       Product: {
@@ -20281,6 +20469,69 @@ ${js}`);
           evaluate: (ce, ops2) => evalSummation(ce, ops2[0], ops2[1], "evaluate"),
           N: (ce, ops2) => evalSummation(ce, ops2[0], ops2[1], "N")
         }
+      },
+      // Limits
+      Limit: {
+        description: "Limit of a function",
+        complexity: 5e3,
+        hold: "all",
+        signature: {
+          domain: [
+            "FunctionOf",
+            "Anything",
+            "Numbers",
+            ["OptArg", "Numbers"],
+            "Numbers"
+          ],
+          N: (ce, ops2) => {
+            const [f, x, dir] = ops2;
+            const target = asFloat(x.N());
+            if (target === null)
+              return void 0;
+            const fn = applicable(f);
+            return ce.number(
+              limit(
+                (x2) => {
+                  let y = fn([ce.number(x2)])?.valueOf();
+                  return typeof y === "number" ? y : Number.NaN;
+                },
+                target,
+                dir ? asFloat(dir) ?? 1 : 1
+              )
+            );
+          }
+        }
+      },
+      NLimit: {
+        description: "Numerical approximation of the limit of a function",
+        complexity: 5e3,
+        hold: "all",
+        signature: {
+          domain: [
+            "FunctionOf",
+            "Anything",
+            "Numbers",
+            ["OptArg", "Numbers"],
+            "Numbers"
+          ],
+          evaluate: (ce, ops2) => {
+            const [f, x, dir] = ops2;
+            const target = asFloat(x.N());
+            if (target === null)
+              return void 0;
+            const fn = applicable(f);
+            return ce.number(
+              limit(
+                (x2) => {
+                  let y = fn([ce.number(x2)])?.valueOf();
+                  return typeof y === "number" ? y : Number.NaN;
+                },
+                target,
+                dir ? asFloat(dir) ?? 1 : 1
+              )
+            );
+          }
+        }
       }
     },
     //
@@ -20387,6 +20638,24 @@ ${js}`);
       return ce.neg(arg);
     return void 0;
   }
+  function processMinMax(ce, ops2, mode) {
+    const upper = mode === "Max" || mode === "Supremum";
+    if (ops2.length === 0)
+      return upper ? ce.NegativeInfinity : ce.PositiveInfinity;
+    let result = void 0;
+    const rest = [];
+    for (const op3 of ops2) {
+      if (!op3.isNumber || op3.numericValue === void 0)
+        rest.push(op3);
+      else if (!result)
+        result = op3;
+      else if (upper && op3.isGreater(result) || !upper && op3.isLess(result))
+        result = op3;
+    }
+    if (rest.length > 0)
+      return ce.box(result ? [mode, result, ...rest] : [mode, ...rest]);
+    return result ?? (upper ? ce.NegativeInfinity : ce.PositiveInfinity);
+  }
 
   // src/compute-engine/symbolic/derivative.ts
   var DERIVATIVES_TABLE = {
@@ -20711,8 +20980,9 @@ ${js}`);
             const params = ops2.slice(1);
             f.bind();
             f = f.canonical;
+            const result = ce._fn("D", [f, ...params]);
             ce.popScope();
-            return ce._fn("D", [f, ...params]);
+            return result;
           },
           evaluate: (ce, ops2) => {
             let f = ops2[0].canonical;
@@ -20746,7 +21016,7 @@ ${js}`);
             if (typeof x !== "number")
               return void 0;
             const f = applicableN1(ce.box(ops2[0]));
-            return ce.number(centeredDiff8thOrder(f, x, 1e-6));
+            return ce.number(centeredDiff8thOrder(f, x));
           }
         }
       },
@@ -20802,11 +21072,17 @@ ${js}`);
         signature: {
           domain: ["FunctionOf", "Functions", "Numbers", "Numbers", "Numbers"],
           evaluate: (ce, ops2) => {
+            const numericMode = ce.numericMode;
+            const precision = ce.precision;
+            ce.numericMode = "machine";
             const f = applicableN1(ops2[0]);
             const [a, b] = ops2.slice(1).map((op3) => op3.valueOf());
-            if (typeof a !== "number" || typeof b !== "number")
-              return void 0;
-            return ce.number(monteCarloEstimate(f, a, b));
+            let result = void 0;
+            if (typeof a === "number" && typeof b === "number")
+              result = ce.number(monteCarloEstimate(f, a, b));
+            ce.numericMode = numericMode;
+            ce.precision = precision;
+            return result;
           }
         }
       }
@@ -21571,6 +21847,7 @@ ${js}`);
   var CONTROL_STRUCTURES_LIBRARY = [
     {
       Block: {
+        hold: "all",
         signature: {
           domain: "Functions",
           canonical: canonicalBlock,
@@ -21672,33 +21949,37 @@ ${js}`);
   function evaluateBlock(ce, ops2) {
     if (ops2.length === 0)
       return ce.Nothing;
+    ce.resetContext();
     let result = void 0;
     for (const op3 of ops2) {
-      result = op3.evaluate();
-      const h = result.head;
-      if (h === "Return" || h === "Break" || h === "Continue")
+      const h = op3.head;
+      if (h === "Return") {
+        result = op3.op1.evaluate();
         break;
+      }
+      if (h === "Break" || h === "Continue") {
+        result = ce.fn(h, [op3.op1.evaluate()]);
+        break;
+      }
+      result = op3.evaluate();
     }
     return result ?? ce.Nothing;
   }
   function canonicalBlock(ce, ops2) {
     if (ops2.length === 0)
       return null;
+    ce.pushScope();
     const declarations = [];
     const body = [];
     for (const op3 of ops2) {
-      if (op3.head === "Declare") {
+      if (op3.head === "Declare")
         declarations.push(op3);
-      } else if (op3.head === "Assign") {
-        const id = op3.op1.symbol;
-        const def = ce.lookupSymbol(id) ?? ce.lookupFunction(id);
-        if (!def) {
-          declarations.push(ce._fn("Declare", [op3.op1, ce.symbol("Undefined")]));
-        }
-      } else
+      else
         body.push(invalidateDeclare(op3));
     }
-    return ce._fn("Block", [...declarations, ...body]);
+    const result = ce._fn("Block", [...declarations, ...body]);
+    ce.popScope();
+    return result;
   }
   function invalidateDeclare(expr) {
     if (expr.head === "Declare")
@@ -22063,7 +22344,8 @@ ${js}`);
           },
           // By definition, for arguments of the canonical expression of
           // `Hold` are not canonicalized.
-          canonical: (ce, args) => args.length !== 1 ? null : ce._fn("Hold", args)
+          canonical: (ce, args) => args.length !== 1 ? null : ce._fn("Hold", args),
+          evaluate: (ce, ops2) => ops2[0]
         }
       },
       HorizontalSpacing: {
@@ -22103,6 +22385,32 @@ ${js}`);
           evaluate: (_ce, ops2) => apply3(ops2[0], ops2.slice(1))
         }
       },
+      Assign: {
+        hold: "all",
+        signature: {
+          domain: ["FunctionOf", "Symbols", "Anything", "Anything"],
+          canonical: (ce, args) => {
+            if (args.length !== 2)
+              return null;
+            const op12 = args[0];
+            const op22 = args[1];
+            if (!op12.symbol)
+              return null;
+            if (op22.symbol)
+              return ce._fn("Assign", args);
+            return ce._fn("Assign", [op12, ce._fn("Hold", [op22])]);
+          },
+          evaluate: (ce, ops2) => {
+            const op12 = ops2[0];
+            const op22 = ops2[1];
+            if (!op12.symbol)
+              return ce.Nothing;
+            const val = op22.evaluate();
+            ce.assign(op12.symbol, val);
+            return val;
+          }
+        }
+      },
       Assume: {
         hold: "all",
         signature: {
@@ -22112,6 +22420,32 @@ ${js}`);
       },
       // @todo
       About: { signature: { domain: "Functions" } },
+      Declare: {
+        hold: "all",
+        signature: {
+          domain: ["FunctionOf", "Symbols", "Anything"],
+          canonical: (ce, args) => {
+            if (args.length !== 2)
+              return null;
+            const op12 = args[0];
+            const op22 = args[1];
+            if (!op12.symbol)
+              return null;
+            if (op22.symbol)
+              return ce._fn("Declare", args);
+            return ce._fn("Declare", [op12, ce._fn("Hold", [op22])]);
+          },
+          evaluate: (ce, ops2) => {
+            const op12 = ops2[0];
+            const op22 = ops2[1];
+            if (!op12.symbol)
+              return ce.Nothing;
+            const val = op22.evaluate();
+            ce.declare(op12.symbol, val);
+            return val;
+          }
+        }
+      },
       Domain: {
         /** Return the domain of an expression */
         signature: {
@@ -24218,7 +24552,7 @@ ${js}`);
   }
 
   // src/compute-engine/boxed-expression/boxed-symbol-definition.ts
-  var import_complex17 = __toESM(require_complex(), 1);
+  var import_complex17 = __toESM(require_complex());
   var _BoxedSymbolDefinition = class {
     // @todo
     constructor(ce, name, def) {
@@ -25168,7 +25502,7 @@ ${JSON.stringify(entry)}`
   }
 
   // src/compute-engine/cost-function.ts
-  var import_complex19 = __toESM(require_complex(), 1);
+  var import_complex19 = __toESM(require_complex());
   function numericCostFunction(n) {
     if (Number.isInteger(n) && n !== 0) {
       return Math.floor(Math.log2(Math.abs(n)) / Math.log2(10)) + (n > 0 ? 1 : 2);
@@ -25560,6 +25894,16 @@ ${JSON.stringify(entry)}`
     }
     if (!options.recursive)
       return null;
+    if (subject.ops) {
+      const ops2 = subject.ops;
+      const result = {};
+      for (let i = 0; i < ops2.length; i++) {
+        const sub2 = match(ops2[i], pattern, options);
+        if (sub2 !== null)
+          return sub2;
+      }
+      return result;
+    }
     return null;
   }
 
@@ -27325,10 +27669,10 @@ ${JSON.stringify(entry)}`
   };
 
   // src/compute-engine.ts
-  var version = "0.17.0";
+  var version = "0.18.1";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.17.0"
+    version: "0.18.1"
   };
   return __toCommonJS(compute_engine_exports);
 })();