@cortex-js/compute-engine 0.20.1 → 0.21.0

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.20.1 */
+/** CortexJS Compute Engine 0.21.0 */
     (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());
+  var import_complex20 = __toESM(require_complex(), 1);
 
   // node_modules/decimal.js/decimal.mjs
   var EXP_LIMIT = 9e15;
@@ -5965,23 +5965,7 @@ var ComputeEngine = (() => {
       kind: "environment",
       name: "Which",
       identifierTrigger: "cases",
-      parse: (parser) => {
-        const tabular = parser.parseTabular();
-        if (!tabular)
-          return ["Which"];
-        const result = ["Which"];
-        for (const row of tabular) {
-          if (row.length === 1) {
-            result.push("True");
-            result.push(row[0]);
-          } else if (row.length === 2) {
-            const s = stringValue(row[1]);
-            result.push(s ? "True" : stripText(row[1]) ?? "True");
-            result.push(row[0]);
-          }
-        }
-        return result;
-      },
+      parse: parseWhich,
       serialize: (serialize, expr) => {
         const rows = [];
         const args = ops(expr);
@@ -5995,6 +5979,16 @@ var ComputeEngine = (() => {
         }
         return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
       }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "dcases",
+      parse: parseWhich
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "rcases",
+      parse: parseWhich
     }
   ];
   function parseTextRun(parser, style) {
@@ -6315,6 +6309,23 @@ var ComputeEngine = (() => {
     }
     return ["Assign", lhs, rhs];
   }
+  function parseWhich(parser) {
+    const tabular = parser.parseTabular();
+    if (!tabular)
+      return ["Which"];
+    const result = ["Which"];
+    for (const row of tabular) {
+      if (row.length === 1) {
+        result.push("True");
+        result.push(row[0]);
+      } else if (row.length === 2) {
+        const s = stringValue(row[1]);
+        result.push(s ? "True" : stripText(row[1]) ?? "True");
+        result.push(row[0]);
+      }
+    }
+    return result;
+  }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-inequalities.ts
   var DEFINITIONS_INEQUALITIES = [
@@ -6723,103 +6734,239 @@ var ComputeEngine = (() => {
     // The third, optional, argument is the column specification.
     {
       name: "Matrix",
-      // https://ctan.math.illinois.edu/macros/latex/required/tools/array.pdf
       serialize: (serializer, expr) => {
-        const body = op(expr, 1);
-        const delims = op(expr, 2) ?? "()";
-        let columns = "";
-        if (op(expr, 3) !== null) {
-          const colsSpec = stringValue(op(expr, 3)) ?? "";
-          for (const c of colsSpec) {
-            if (c === "<")
-              columns += "l";
-            else if (c === ">")
-              columns += "r";
-            else if (c === "=")
-              columns += "c";
-            else if (c === "|")
-              columns += "|";
-            else if (c === ":")
-              columns += ":";
-          }
-        }
-        let [open, close] = ["", ""];
-        if (typeof delims === "string" && delims.length === 2)
-          [open, close] = delims;
-        const rows = [];
-        for (const row of ops(body) ?? []) {
-          const cells = [];
-          for (const cell of ops(row) ?? [])
-            cells.push(serializer.serialize(cell));
-          rows.push(cells.join(" & "));
-        }
-        const tabular = rows.join("\\\\\n");
-        const optColumns = columns.length > 0 ? `[${columns}]` : "";
-        if (open === "(" && close === ")")
-          return joinLatex([
-            "\\begin{pmatrix}",
-            optColumns,
-            tabular,
-            "\\end{pmatrix}"
-          ]);
-        if (open === "[" && close === "]")
-          return joinLatex([
-            "\\begin{bmatrix}",
-            optColumns,
-            tabular,
-            "\\end{bmatrix}"
-          ]);
-        if (open === "{" && close === "}")
-          return joinLatex([
-            "\\begin{Bmatrix}",
-            optColumns,
-            tabular,
-            "\\end{Bmatrix}"
-          ]);
-        if (open === "|" && close === "|")
-          return joinLatex([
-            "\\begin{vmatrix}",
-            optColumns,
-            tabular,
-            "\\end{vmatrix}"
-          ]);
-        if (open === "\u2016" && close === "\u2016")
-          return joinLatex([
-            "\\begin{Vmatrix}",
-            optColumns,
-            tabular,
-            "\\end{Vmatrix}"
-          ]);
-        if (open === "{" && close === ".")
-          return joinLatex([
-            "\\begin{dcases}",
-            optColumns,
-            tabular,
-            "\\end{dcases}"
-          ]);
-        if (open === "." && close === "}")
-          return joinLatex([
-            "\\begin{rcases}",
-            optColumns,
-            tabular,
-            "\\end{rcases}"
-          ]);
-        if (columns || open !== "." || close !== ".") {
-          return joinLatex([
-            "\\left",
-            DELIMITERS_SHORTHAND[open] ?? open,
-            "\\begin{array}",
-            `{${columns}}`,
-            tabular,
-            "\\end{array}",
-            "\\right",
-            DELIMITERS_SHORTHAND[close] ?? close
-          ]);
-        }
-        return joinLatex(["\\begin{matrix}", tabular, "\\end{matrix}"]);
+        const rows = ops(op(expr, 1)) ?? [];
+        return serializeTabular(
+          serializer,
+          rows,
+          stringValue(op(expr, 2)),
+          stringValue(op(expr, 3))
+        );
+      }
+    },
+    // Vector is a specialized collection to represent a column vector.
+    {
+      name: "Vector",
+      serialize: (serializer, expr) => {
+        const columns = ops(expr) ?? [];
+        return serializeTabular(
+          serializer,
+          columns.map((column) => ["List", column]),
+          stringValue(op(expr, 2)),
+          stringValue(op(expr, 3))
+        );
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "pmatrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: "()" }, { str: columns }];
+        return [head2, cells];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "bmatrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: "[]" }, { str: columns }];
+        return [head2, cells, { str: "[]" }];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "Bmatrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: "{}" }, { str: columns }];
+        return [head2, cells, { str: "{}" }];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "vmatrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: "||" }, { str: columns }];
+        return [head2, cells, { str: "||" }];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "Vmatrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: "\u2016\u2016" }, { str: columns }];
+        return [head2, cells, { str: "\u2016\u2016" }];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "smallmatrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: "()" }, { str: columns }];
+        return [head2, cells];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "array",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser, false);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: ".." }, { str: columns }];
+        return [head2, cells, { str: ".." }];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "matrix",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: ".." }, { str: columns }];
+        return [head2, cells, { str: ".." }];
+      }
+    },
+    {
+      kind: "environment",
+      identifierTrigger: "matrix*",
+      parse: (parser) => {
+        const columns = parseColumnFormat(parser);
+        const [head2, cells] = parseCells(parser);
+        if (columns)
+          return [head2, cells, { str: ".." }, { str: columns }];
+        return [head2, cells, { str: ".." }];
       }
     }
   ];
+  function parseCells(parser) {
+    const tabular = parser.parseTabular();
+    if (!tabular)
+      return ["", null];
+    return [
+      "Matrix",
+      ["List", ...tabular.map((row) => ["List", row])]
+    ];
+  }
+  function parseColumnFormat(parser, optional = true) {
+    const colFormat = parser.parseStringGroup(optional)?.trim();
+    if (!colFormat)
+      return "";
+    let result = "";
+    for (const c of colFormat) {
+      if (c === "c")
+        result += "=";
+      if (c === "l")
+        result += "<";
+      if (c === "r")
+        result += ">";
+      if (c === "|")
+        result += "|";
+      if (c === ":")
+        result += ":";
+    }
+    return result;
+  }
+  function serializeTabular(serializer, rows, delims, colSpec) {
+    delims ?? (delims = "()");
+    let [open, close] = ["", ""];
+    if (typeof delims === "string" && delims.length === 2)
+      [open, close] = delims;
+    let columns = "";
+    if (colSpec) {
+      for (const c of colSpec) {
+        if (c === "<")
+          columns += "l";
+        else if (c === ">")
+          columns += "r";
+        else if (c === "=")
+          columns += "c";
+        else if (c === "|")
+          columns += "|";
+        else if (c === ":")
+          columns += ":";
+      }
+    }
+    const serializedRows = [];
+    for (const row of rows ?? []) {
+      const cells = [];
+      for (const cell of ops(row) ?? [])
+        cells.push(serializer.serialize(cell));
+      serializedRows.push(cells.join(" & "));
+    }
+    const tabular = serializedRows.join("\\\\\n");
+    const optColumns = columns.length > 0 ? `[${columns}]` : "";
+    if (open === "(" && close === ")")
+      return joinLatex([
+        "\\begin{pmatrix}",
+        optColumns,
+        tabular,
+        "\\end{pmatrix}"
+      ]);
+    if (open === "[" && close === "]")
+      return joinLatex([
+        "\\begin{bmatrix}",
+        optColumns,
+        tabular,
+        "\\end{bmatrix}"
+      ]);
+    if (open === "{" && close === "}")
+      return joinLatex([
+        "\\begin{Bmatrix}",
+        optColumns,
+        tabular,
+        "\\end{Bmatrix}"
+      ]);
+    if (open === "|" && close === "|")
+      return joinLatex([
+        "\\begin{vmatrix}",
+        optColumns,
+        tabular,
+        "\\end{vmatrix}"
+      ]);
+    if (open === "\u2016" && close === "\u2016")
+      return joinLatex([
+        "\\begin{Vmatrix}",
+        optColumns,
+        tabular,
+        "\\end{Vmatrix}"
+      ]);
+    if (open === "{" && close === ".")
+      return joinLatex(["\\begin{dcases}", optColumns, tabular, "\\end{dcases}"]);
+    if (open === "." && close === "}")
+      return joinLatex(["\\begin{rcases}", optColumns, tabular, "\\end{rcases}"]);
+    if (columns || open !== "." || close !== ".") {
+      return joinLatex([
+        "\\left",
+        DELIMITERS_SHORTHAND[open] ?? open,
+        "\\begin{array}",
+        `{${columns}}`,
+        tabular,
+        "\\end{array}",
+        "\\right",
+        DELIMITERS_SHORTHAND[close] ?? close
+      ]);
+    }
+    return joinLatex(["\\begin{matrix}", tabular, "\\end{matrix}"]);
+  }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
   var DEFINITIONS_LOGIC = [
@@ -8729,7 +8876,7 @@ var ComputeEngine = (() => {
       });
       return false;
     }
-    if ("identifierTrigger" in entry) {
+    if ("identifierTrigger" in entry && (!("kind" in entry) || entry.kind !== "environment")) {
       if (typeof entry.identifierTrigger !== "string" || !isValidIdentifier(entry.identifierTrigger)) {
         onError({
           severity: "warning",
@@ -9698,12 +9845,14 @@ var ComputeEngine = (() => {
       return result;
     }
     /** Parse a group as a a string, for example for `\operatorname` or `\begin` */
-    parseStringGroup() {
+    parseStringGroup(optional) {
+      if (optional === void 0)
+        optional = false;
       const start = this.index;
       while (this.match("<space>")) {
       }
-      if (this.match("<{>")) {
-        this.addBoundary(["<}>"]);
+      if (this.match(optional ? "[" : "<{>")) {
+        this.addBoundary([optional ? "]" : "<}>"]);
         const arg = this.parseStringGroupContent();
         if (this.matchBoundary())
           return arg;
@@ -11454,13 +11603,13 @@ var ComputeEngine = (() => {
   };
 
   // src/compute-engine/domain-utils.ts
-  var import_complex3 = __toESM(require_complex());
+  var import_complex3 = __toESM(require_complex(), 1);
 
   // src/compute-engine/numerics/rationals.ts
-  var import_complex2 = __toESM(require_complex());
+  var import_complex2 = __toESM(require_complex(), 1);
 
   // src/compute-engine/numerics/numeric.ts
-  var import_complex = __toESM(require_complex());
+  var import_complex = __toESM(require_complex(), 1);
 
   // src/compute-engine/numerics/richardson.ts
   function extrapolate(f, x0, options = {}) {
@@ -13492,7 +13641,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/utils.ts
-  var import_complex4 = __toESM(require_complex());
+  var import_complex4 = __toESM(require_complex(), 1);
   function isLatexString(s) {
     if (typeof s === "string")
       return s.startsWith("$") && s.endsWith("$");
@@ -13712,7 +13861,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/order.ts
-  var import_complex5 = __toESM(require_complex());
+  var import_complex5 = __toESM(require_complex(), 1);
 
   // src/compute-engine/symbolic/polynomials.ts
   function totalDegree(expr) {
@@ -13760,7 +13909,7 @@ var ComputeEngine = (() => {
 
   // src/compute-engine/boxed-expression/order.ts
   var DEFAULT_COMPLEXITY = 1e5;
-  function sortAdd(ce, ops2) {
+  function sortAdd(ops2) {
     return ops2.sort((a, b) => {
       const aLex = lex(a);
       const bLex = lex(b);
@@ -13880,6 +14029,15 @@ var ComputeEngine = (() => {
     }
     return (a.complexity ?? DEFAULT_COMPLEXITY) - (b.complexity ?? DEFAULT_COMPLEXITY);
   }
+  function canonicalOrder(expr, { recursive = false }) {
+    if (expr.ops) {
+      const ops2 = recursive ? expr.ops.map((x) => canonicalOrder(x, { recursive })) : expr.ops;
+      if (expr.head === "Add")
+        return expr.engine._fn("Add", sortAdd(ops2));
+      return expr.engine._fn(expr.head, ops2.sort(order));
+    }
+    return expr;
+  }
   function getLeafCount(expr) {
     if (expr.keys !== null)
       return 1 + expr.keysCount;
@@ -13930,7 +14088,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/symbolic/sum.ts
-  var import_complex6 = __toESM(require_complex());
+  var import_complex6 = __toESM(require_complex(), 1);
 
   // src/compute-engine/collection-utils.ts
   function isCollection(col) {
@@ -14235,7 +14393,7 @@ var ComputeEngine = (() => {
         return ce.Zero;
       if (xs.length === 1 && !isIndexableCollection(xs[0]))
         return xs[0];
-      return ce._fn("Add", sortAdd(ce, xs));
+      return ce._fn("Add", sortAdd(xs));
     }
   };
 
@@ -14445,10 +14603,10 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
-  var import_complex8 = __toESM(require_complex());
+  var import_complex8 = __toESM(require_complex(), 1);
 
   // src/compute-engine/symbolic/utils.ts
-  var import_complex7 = __toESM(require_complex());
+  var import_complex7 = __toESM(require_complex(), 1);
   function makePositive(expr) {
     if (expr.head === "Negate")
       return [-1, expr.op1];
@@ -15625,6 +15783,7 @@ var ComputeEngine = (() => {
     set value(_value) {
       throw new Error(`Can't change the value of \\(${this.latex}\\)`);
     }
+    // @ts-ignore
     get domain() {
       return void 0;
     }
@@ -15990,7 +16149,7 @@ var ComputeEngine = (() => {
         return ce.number(ce.complex(re, im));
     }
     if (ops2.length > 1)
-      ops2 = sortAdd(ce, ops2);
+      ops2 = sortAdd(ops2);
     return ce._fn("Add", ops2);
   }
   function domainAdd(_ce, args) {
@@ -16094,12 +16253,16 @@ var ComputeEngine = (() => {
       }
       return result ?? void 0;
     }
-    const [index, lower, upper, isFinite2] = normalizeLimits(range);
+    const [index, lower, upper, isFinite2] = normalizeLimits(range.evaluate());
     if (!index)
       return void 0;
     const fn = expr;
-    if (mode == "simplify" && (lower >= upper || upper - lower >= MAX_SYMBOLIC_TERMS))
+    if (lower >= upper)
       return void 0;
+    if (mode === "simplify" && upper - lower >= MAX_SYMBOLIC_TERMS)
+      return void 0;
+    if (mode === "evaluate" && upper - lower >= MAX_SYMBOLIC_TERMS)
+      mode = "N";
     const savedContext = ce.swapScope(fn.scope);
     ce.pushScope();
     fn.bind();
@@ -16198,7 +16361,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/symbolic/negate.ts
-  var import_complex9 = __toESM(require_complex());
+  var import_complex9 = __toESM(require_complex(), 1);
   function negateLiteral(expr, metadata) {
     let n = expr.numericValue;
     if (n === null)
@@ -16730,10 +16893,10 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/box.ts
-  var import_complex14 = __toESM(require_complex());
+  var import_complex14 = __toESM(require_complex(), 1);
 
   // src/compute-engine/boxed-expression/serialize.ts
-  var import_complex11 = __toESM(require_complex());
+  var import_complex11 = __toESM(require_complex(), 1);
 
   // src/compute-engine/numerics/numeric-bignum.ts
   function gcd3(a, b) {
@@ -16858,7 +17021,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/symbolic/product.ts
-  var import_complex10 = __toESM(require_complex());
+  var import_complex10 = __toESM(require_complex(), 1);
   var Product = class {
     constructor(ce, xs, options) {
       this.options = options;
@@ -17806,7 +17969,7 @@ var ComputeEngine = (() => {
   };
 
   // src/compute-engine/boxed-expression/boxed-function.ts
-  var import_complex12 = __toESM(require_complex());
+  var import_complex12 = __toESM(require_complex(), 1);
 
   // src/compute-engine/simplify-rules.ts
   var SIMPLIFY_RULES = [];
@@ -17814,7 +17977,7 @@ var ComputeEngine = (() => {
   // src/compute-engine/function-utils.ts
   function canonicalFunctionExpression(expr) {
     if (expr.head === "N" && typeof expr.op1.head === "string") {
-      const newHead = { D: "ND", Integrate: "NIntegrate" }[expr.op1.head];
+      const newHead = { Integrate: "NIntegrate", Limit: "NLimit" }[expr.op1.head];
       if (newHead)
         expr = expr.engine._fn(newHead, expr.op1.ops);
     }
@@ -18285,6 +18448,11 @@ var ComputeEngine = (() => {
     evaluate(options) {
       if (!this.isValid)
         return this;
+      if (options?.numericMode) {
+        const h = this.head;
+        if (h === "Integrate" || h === "Limit")
+          return this.engine.box(["N", this], { canonical: true }).evaluate(options);
+      }
       if (!this.isCanonical) {
         this.engine.pushScope();
         const canonical2 = this.canonical;
@@ -18524,7 +18692,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/boxed-number.ts
-  var import_complex13 = __toESM(require_complex());
+  var import_complex13 = __toESM(require_complex(), 1);
 
   // src/compute-engine/numerics/primes.ts
   var LARGE_PRIME = 1125899906842597;
@@ -19412,7 +19580,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/library/arithmetic.ts
-  var import_complex16 = __toESM(require_complex());
+  var import_complex16 = __toESM(require_complex(), 1);
 
   // src/compute-engine/numerics/numeric-complex.ts
   function gamma3(c) {
@@ -19423,7 +19591,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/library/arithmetic-power.ts
-  var import_complex15 = __toESM(require_complex());
+  var import_complex15 = __toESM(require_complex(), 1);
   function canonicalPower(ce, base, exponent, metadata) {
     if (exponent.symbol === "ComplexInfinity")
       return ce.NaN;
@@ -21115,71 +21283,6 @@ var ComputeEngine = (() => {
           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",
-        threadable: false,
-        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) => {
-                  const y = fn([ce.number(x2)])?.value;
-                  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",
-        threadable: false,
-        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) => {
-                  const y = fn([ce.number(x2)])?.value;
-                  return typeof y === "number" ? y : Number.NaN;
-                },
-                target,
-                dir ? asFloat(dir) ?? 1 : 1
-              )
-            );
-          }
-        }
       }
     },
     //
@@ -21850,6 +21953,73 @@ var ComputeEngine = (() => {
           }
         }
       }
+    },
+    {
+      // Limits
+      Limit: {
+        description: "Limit of a function",
+        complexity: 5e3,
+        hold: "all",
+        threadable: false,
+        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) => {
+                  const y = fn([ce.number(x2)])?.value;
+                  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",
+        threadable: false,
+        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) => {
+                  const y = fn([ce.number(x2)])?.value;
+                  return typeof y === "number" ? y : Number.NaN;
+                },
+                target,
+                dir ? asFloat(dir) ?? 1 : 1
+              )
+            );
+          }
+        }
+      }
     }
   ];
 
@@ -22606,6 +22776,15 @@ var ComputeEngine = (() => {
     return result;
   }
   function canonicalList(ce, ops2) {
+    const op12 = ops2[0];
+    if (ops2.length === 1 && op12.head === "Matrix") {
+      const [body, delimiters, columns] = op12.ops;
+      if (!delimiters || delimiters.string === "..") {
+        if (!columns)
+          return ce._fn("Matrix", [body, delimiters]);
+        return ce._fn("Matrix", [body, ce.string("[]"), columns]);
+      }
+    }
     ops2 = ops2.map((op3) => {
       if (op3.head === "Delimiter") {
         if (op3.op1.head === "Sequence")
@@ -23449,12 +23628,44 @@ var ComputeEngine = (() => {
           evaluate: (_ce, ops2) => ops2[0].simplify()
         }
       },
+      // Can be used to sort arguments of an expression.
+      // Sorting arguments of commutative functions is a weak form of
+      // canonicalization that can be useful in some cases, for example
+      // to accept "x+1" and "1+x" while rejecting "x+1" and "2x-x+1"
+      CanonicalOrder: {
+        complexity: 8200,
+        hold: "all",
+        signature: {
+          domain: ["FunctionOf", "Anything", "Anything"],
+          canonical: (_ce, ops2) => canonicalOrder(ops2[0], { recursive: true })
+        }
+      },
       N: {
         hold: "all",
         signature: {
           domain: ["FunctionOf", "Anything", "Anything"],
           result: (_ce, ops2) => ops2[0].domain,
-          canonical: (ce, ops2) => ce._fn("N", checkArity(ce, ops2, 1)),
+          canonical: (ce, ops2) => {
+            if (ops2.length !== 1)
+              return ce._fn("N", checkArity(ce, ops2, 1));
+            const h = ops2[0].head;
+            if (h === "N")
+              return ops2[0].canonical;
+            if (h === "Integrate") {
+              const [index, lower, upper] = normalizeLimits(ops2[0].op2);
+              if (!index || lower === void 0 || upper === void 0)
+                return null;
+              const fn = ops2[0].op1;
+              return ce._fn("NIntegrate", [
+                ce.box(["Function", fn, index]),
+                ce.number(lower),
+                ce.number(upper)
+              ]);
+            }
+            if (h === "Limit")
+              return ce._fn("NLimit", ops2[0].ops);
+            return ce._fn("N", ops2);
+          },
           evaluate: (_ce, ops2) => ops2[0].N()
         }
       },
@@ -23712,22 +23923,40 @@ var ComputeEngine = (() => {
           evaluate: (_ce, ops2) => ops2[0].evaluate(),
           N: (_ce, ops2) => ops2[0].N()
         }
+      },
+      // 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: {
+        complexity: 9e3,
+        hold: "all",
+        signature: {
+          restParam: "Anything",
+          result: "Lists",
+          canonical: (ce, ops2) => {
+            return ce._fn("Matrix", [
+              ce._fn(
+                "List",
+                ce.canonical(ops2).map((op3) => ce._fn("List", [op3]))
+              )
+            ]);
+          }
+        }
       }
     }
   ];
-  function canonicalMatrix(ce, ops2) {
+  function canonicalMatrix(ce, ops2, head2 = "Matrix") {
     if (ops2.length === 0)
-      return ce._fn("Matrix", []);
-    const body = ops2[0].canonical;
+      return ce._fn(head2, []);
+    const body = ops2[0].head === "Vector" ? ops2[0].canonical.ops[0] : ops2[0].canonical;
     const delims = ops2[1]?.canonical;
     const columns = ops2[2]?.canonical;
     if (ops2.length > 3)
-      return ce._fn("Matrix", checkArity(ce, ops2, 3));
+      return ce._fn(head2, checkArity(ce, ops2, 3));
     if (columns)
-      return ce._fn("Matrix", [body, delims, columns]);
+      return ce._fn(head2, [body, delims, columns]);
     if (delims)
-      return ce._fn("Matrix", [body, delims]);
-    return ce._fn("Matrix", [body]);
+      return ce._fn(head2, [body, delims]);
+    return ce._fn(head2, [body]);
   }
 
   // src/compute-engine/library/logic.ts
@@ -23965,6 +24194,28 @@ var ComputeEngine = (() => {
         }
       }
     },
+    IsSame: {
+      description: "Compare two expressions for structural equality",
+      hold: "all",
+      signature: {
+        domain: "RelationalOperators",
+        // Since we want to work on non-canonical expressions,
+        // do nothing to canonicalize the arguments
+        evaluate: (ce, ops2) => {
+          if (ops2.length !== 2)
+            return void 0;
+          let [lhs, rhs] = ops2;
+          if (lhs.head === "CanonicalOrder")
+            lhs = lhs.canonical;
+          if (rhs.head === "CanonicalOrder")
+            rhs = rhs.canonical;
+          const test = lhs.isSame(rhs);
+          if (test === true)
+            return ce.True;
+          return ce.False;
+        }
+      }
+    },
     Equal: {
       commutative: true,
       complexity: 11e3,
@@ -25652,7 +25903,7 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/boxed-symbol-definition.ts
-  var import_complex17 = __toESM(require_complex());
+  var import_complex17 = __toESM(require_complex(), 1);
   var _BoxedSymbolDefinition = class {
     // @todo
     constructor(ce, name, def) {
@@ -26644,7 +26895,7 @@ ${JSON.stringify(entry)}`
   }
 
   // src/compute-engine/cost-function.ts
-  var import_complex19 = __toESM(require_complex());
+  var import_complex19 = __toESM(require_complex(), 1);
   function numericCostFunction(n) {
     if (Number.isInteger(n) && n !== 0) {
       return Math.floor(Math.log2(Math.abs(n)) / Math.log2(10)) + (n > 0 ? 1 : 2);
@@ -27226,6 +27477,7 @@ ${JSON.stringify(entry)}`
         });
       }
     }
+    // @ts-ignore
     get domain() {
       const def = this._def;
       if (def) {
@@ -27614,7 +27866,6 @@ ${JSON.stringify(entry)}`
         symbols: /* @__PURE__ */ new Set(),
         expressions: /* @__PURE__ */ new Set()
       };
-      this._defaultDomain = null;
       this._numericMode = options?.numericMode ?? "auto";
       this._precision = Math.max(
         options?.numericPrecision ?? 100,
@@ -27858,6 +28109,56 @@ ${JSON.stringify(entry)}`
         return 0;
       return n;
     }
+    /** Create an arbitrary precision number. 
+       * 
+       * The return value is an object with methods to perform arithmetic
+       * operations:
+       * - `toNumber()`: convert to a JavaScript `number` with potential loss of precision
+       * - `add()`
+       * - `sub()`
+       * - `neg()` (unary minus)
+       * - `mul()`
+       * - `div()`
+       * - `pow()`
+       * - `sqrt()` (square root)
+       * - `cbrt()` (cube root)
+       * - `exp()`  (e^x)
+       * - `log()` 
+       * - `ln()` (natural logarithm)
+       * - `mod()`
+    
+       * - `abs()`
+       * - `ceil()`
+       * - `floor()`
+       * - `round()`
+    
+       * - `equals()`
+       * - `gt()`
+       * - `gte()`
+       * - `lt()`
+       * - `lte()`
+       * 
+       * - `cos()`
+       * - `sin()`
+       * - `tanh()`
+       * - `acos()`
+       * - `asin()`
+       * - `atan()`
+       * - `cosh()`
+       * - `sinh()`
+       * - `acosh()`
+       * - `asinh()`
+       * - `atanh()`
+       * 
+       * - `isFinite()`
+       * - `isInteger()`
+       * - `isNaN()`
+       * - `isNegative()`
+       * - `isPositive()`
+       * - `isZero()`
+       * - `sign()` (1, 0 or -1)
+       * 
+       */
     bignum(a) {
       if (typeof a === "bigint")
         return new this._bignum(a.toString());
@@ -27868,6 +28169,51 @@ ${JSON.stringify(entry)}`
       }
       return this._BIGNUM_NAN;
     }
+    /** Create a complex number.
+       * The return value is an object with methods to perform arithmetic
+       * operations:
+       * - `re` (real part, as a JavaScript `number`)
+       * - `im` (imaginary part, as a JavaScript `number`)
+       * - `add()`
+       * - `sub()`
+       * - `neg()` (unary minus)
+       * - `mul()`
+       * - `div()`
+       * - `pow()`
+       * - `sqrt()` (square root)
+       * - `exp()`  (e^x)
+       * - `log()` 
+       * - `ln()` (natural logarithm)
+       * - `mod()`
+    
+       * - `abs()`
+       * - `ceil()`
+       * - `floor()`
+       * - `round()`
+    
+       * - `arg()` the angle of the complex number
+       * - `inverse()` the inverse of the complex number 1/z
+       * - `conjugate()` the conjugate of the complex number
+    
+       * - `equals()`
+       * 
+       * - `cos()`
+       * - `sin()`
+       * - `tanh()`
+       * - `acos()`
+       * - `asin()`
+       * - `atan()`
+       * - `cosh()`
+       * - `sinh()`
+       * - `acosh()`
+       * - `asinh()`
+       * - `atanh()`
+       * 
+       * - `isFinite()`
+       * - `isNaN()`
+       * - `isZero()`
+       * - `sign()` (1, 0 or -1)
+       */
     complex(a, b) {
       if (a instanceof Decimal)
         a = a.toNumber();
@@ -27971,7 +28317,14 @@ ${JSON.stringify(entry)}`
       return void 0;
     }
     /**
-     * Add (or replace) a definition for a symbol in the current scope.
+     * Associate a new definition to a symbol in the current context.
+     *
+     * If a definition existed previously, it is replaced.
+     *
+     *
+     * For internal use. Use `ce.declare()` instead.
+     *
+     * @internal
      */
     defineSymbol(name, def) {
       if (!this.context)
@@ -27988,6 +28341,15 @@ ${JSON.stringify(entry)}`
         this.context.ids.set(boxedDef.name, boxedDef);
       return boxedDef;
     }
+    /**
+     * Associate a new delookupSymbolfinition to a function in the current context.
+     *
+     * If a definition existed previously, it is replaced.
+     *
+     * For internal use. Use `ce.declare()` instead.
+     *
+     * @internal
+     */
     defineFunction(name, def) {
       if (!this.context)
         throw Error("Function cannot be defined: no scope available");
@@ -28032,8 +28394,8 @@ ${JSON.stringify(entry)}`
       };
       return this;
     }
-    /** Remove the topmost scope from the scope stack.
-     */
+    /** Remove the most recent scope from the scope stack, and set its
+     *  parent scope as current. */
     popScope() {
       if (!this.context)
         throw Error("No scope available");
@@ -28041,12 +28403,17 @@ ${JSON.stringify(entry)}`
       console.assert(this.context);
       return this;
     }
+    /** Set the current scope, return the previous scope. */
     swapScope(scope) {
       const oldScope = this.context;
       this.context = scope;
       console.assert(this.context);
       return oldScope;
     }
+    /**
+     * Reset the value of any identifiers that have been assigned a value
+     * in the current scope.
+     * @internal */
     resetContext() {
       if (!this.context)
         return;
@@ -28066,6 +28433,7 @@ ${JSON.stringify(entry)}`
         }
       }
     }
+    /** @internal */
     _printScope(options, scope, depth = 0) {
       options ?? (options = { details: false, maxDepth: 1 });
       scope ?? (scope = this.context);
@@ -28376,6 +28744,9 @@ ${JSON.stringify(entry)}`
       }
       return this._cache[cacheName]?.value;
     }
+    /**
+     * Return a boxed expression from the input.
+     */
     box(expr, options) {
       return box(this, expr, options);
     }
@@ -28385,6 +28756,16 @@ ${JSON.stringify(entry)}`
       const bxs = xs;
       return bxs.every((x) => x.isCanonical) ? bxs : bxs.map((x) => x.canonical);
     }
+    /**
+     * Return a function expression.
+     *
+     * Note that the result may not be a function, or may have a different
+     * `head` than the one specified.
+     *
+     * For example:
+     * `ce.fn("Rational", [ce.number(1),  ce.number(2)]))` \( \to \) `ce.number([1,2])`
+     *
+     */
     fn(head2, ops2, options) {
       return boxFunction(this, head2, ops2, options ?? { canonical: true });
     }
@@ -28429,18 +28810,33 @@ ${JSON.stringify(entry)}`
       const actual = actualDomain ? actualDomain : this.symbol("Undefined");
       return this.error(["incompatible-domain", expected, actual], where);
     }
+    /**
+     * Add a`["Hold"]` wrapper to `expr.
+     */
     hold(expr) {
       return this._fn("Hold", [this.box(expr, { canonical: false })]);
     }
+    /** Shortcut for `this.fn("Add"...)`.
+     *
+     * The result is canonical.
+     */
     add(ops2, metadata) {
       const result = canonicalAdd(this, flattenOps(flattenSequence(ops2), "Add"));
       if (metadata?.latex !== void 0)
         result.latex = metadata.latex;
       return result;
     }
+    /** Shortcut for `this.fn("Negate", [expr])`
+     *
+     * The result is canonical.
+     */
     neg(expr, metadata) {
       return canonicalNegate(expr, metadata);
     }
+    /** Shortcut for `this.fn("Multiply"...)`
+     *
+     * The result is canonical.
+     */
     mul(ops2, metadata) {
       const result = canonicalMultiply(
         this,
@@ -28450,15 +28846,27 @@ ${JSON.stringify(entry)}`
         result.latex = metadata.latex;
       return result;
     }
+    /** Shortcut for `this.fn("Divide", [num, denom])`
+     *
+     * The result is canonical.
+     */
     div(num, denom, metadata) {
       const result = canonicalDivide(this, num, denom);
       if (metadata?.latex !== void 0)
         result.latex = metadata.latex;
       return result;
     }
+    /** Shortcut for `this.fn("Sqrt"...)`
+     *
+     * The result is canonical.
+     */
     sqrt(base, metadata) {
       return canonicalPower(this, base, this.Half, metadata);
     }
+    /** Shortcut for `this.fn("Power"...)`
+     *
+     * The result is canonical.
+     */
     pow(base, exponent, metadata) {
       if (base.symbol === "ExponentialE" && exponent instanceof import_complex20.Complex) {
         const im = exponent.im;
@@ -28509,6 +28917,10 @@ ${JSON.stringify(entry)}`
         exponent = this.number(exponent);
       return canonicalPower(this, base, exponent, metadata);
     }
+    /** Shortcut for `this.fn("Divide", [1, expr])`
+     *
+     * The result is canonical.
+     */
     inv(expr, metadata) {
       if (expr.isOne)
         return this.One;
@@ -28541,21 +28953,33 @@ ${JSON.stringify(entry)}`
         return this._fn("Divide", [this.One, expr], metadata);
       return this._fn("Power", [expr, e], metadata);
     }
+    /** Shortcut for `this.fn("Pair"...)`
+     *
+     * The result is canonical.
+     */
     pair(first, second, metadata) {
       return new BoxedFunction(this, "Tuple", [first, second], {
         metadata,
         canonical: true
       });
     }
+    /** Shortcut for `this.fn("Tuple"...)`
+     *
+     * The result is canonical.
+     */
     tuple(elements, metadata) {
       return new BoxedFunction(this, "Tuple", canonical(elements), {
         metadata,
         canonical: true
       });
     }
+    array(elements, metadata) {
+      return this.Nothing;
+    }
     string(s, metadata) {
       return new BoxedString(this, s, metadata);
     }
+    /** Return a boxed symbol */
     symbol(name, options) {
       options = options ? { ...options } : {};
       if (!("canonical" in options))
@@ -28593,6 +29017,11 @@ ${JSON.stringify(entry)}`
         return makeCanonicalSymbol(this, name);
       return new BoxedSymbol(this, name, options);
     }
+    /** Return a canonical boxed domain.
+     *
+     * If the domain is invalid, may return an `["Error"]` expression
+     *
+     */
     domain(domain, metadata) {
       if (domain instanceof _BoxedDomain)
         return domain;
@@ -28626,7 +29055,7 @@ ${JSON.stringify(entry)}`
         throw Error("Expected a domain constructor, got " + constructor);
       return new _BoxedDomain(this, domain, metadata);
     }
-    /*
+    /**
      * This function tries to avoid creating a boxed number if `num` corresponds
      * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
      */
@@ -28678,6 +29107,9 @@ ${JSON.stringify(entry)}`
       const result = this.latexSyntax.parse(latexString(latex) ?? latex);
       return this.box(result, options);
     }
+    /** Serialize a `BoxedExpression` or a `MathJSON` expression to
+     * a LaTeX string
+     */
     serialize(x, options) {
       if (typeof x === "object" && "json" in x) {
         const ce = "engine" in x ? x.engine : this;
@@ -28688,6 +29120,16 @@ ${JSON.stringify(entry)}`
       }
       return this.latexSyntax.serialize(x, options);
     }
+    /**
+     * Options to control the serialization of MathJSON expression to LaTeX
+     * when using `this.latex` or `this.engine.serialize()`.
+     *
+     *
+     * {@inheritDoc  NumberFormattingOptions}
+     * {@inheritDoc  ParseLatexOptions}
+     * {@inheritDoc  SerializeLatexOptions}
+     *
+     */
     get latexOptions() {
       const latexSyntax = this.latexSyntax;
       return new Proxy(
@@ -28708,6 +29150,7 @@ ${JSON.stringify(entry)}`
     set latexOptions(opts) {
       this.latexSyntax.updateOptions(opts);
     }
+    /** {@inheritDoc  JsonSerializationOptions} */
     get jsonSerializationOptions() {
       if (this._useRawJsonSerializationOptions) {
         return new Proxy(this._rawJsonSerializationOptions, {
@@ -28796,6 +29239,21 @@ ${JSON.stringify(entry)}`
     verify(_query) {
       return false;
     }
+    /**
+     * Add an assumption.
+     *
+     * Note that the assumption is put into canonical form before being added.
+     *
+     * @param symbol - The symbol to make an assumption about
+     *
+     * Returns:
+     * - `contradiction` if the new assumption is incompatible with previous
+     * ones.
+     * - `tautology` if the new assumption is redundant with previous ones.
+     * - `ok` if the assumption was successfully added to the assumption set.
+     *
+     *
+     */
     assume(predicate) {
       try {
         return assume(this.box(predicate, { canonical: false }));
@@ -28804,6 +29262,7 @@ ${JSON.stringify(entry)}`
         return "internal-error";
       }
     }
+    /** Remove all assumptions about one or more symbols */
     forget(symbol2) {
       if (!this.context)
         throw Error("No scope available");
@@ -28851,10 +29310,10 @@ ${JSON.stringify(entry)}`
   }
 
   // src/compute-engine.ts
-  var version = "0.20.1";
+  var version = "0.21.0";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.20.1"
+    version: "0.21.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();