@cortex-js/compute-engine 0.20.1 → 0.21.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.20.1 */
+/** CortexJS Compute Engine 0.21.0 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1063,7 +1063,7 @@ function isEnvironmentEntry(entry) {
 }
 
 // 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;
@@ -5935,23 +5935,7 @@ var DEFINITIONS_CORE = [
     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);
@@ -5965,6 +5949,16 @@ var DEFINITIONS_CORE = [
       }
       return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
     }
+  },
+  {
+    kind: "environment",
+    identifierTrigger: "dcases",
+    parse: parseWhich
+  },
+  {
+    kind: "environment",
+    identifierTrigger: "rcases",
+    parse: parseWhich
   }
 ];
 function parseTextRun(parser, style) {
@@ -6285,6 +6279,23 @@ function parseAssign(parser, lhs) {
   }
   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 = [
@@ -6693,103 +6704,239 @@ var DEFINITIONS_LINEAR_ALGEBRA = [
   // 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 = [
@@ -8699,7 +8846,7 @@ function isValidEntry(entry, onError) {
     });
     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",
@@ -9668,12 +9815,14 @@ var _Parser = class {
     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;
@@ -11424,13 +11573,13 @@ var LatexSyntax = class _LatexSyntax {
 };
 
 // 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 = {}) {
@@ -13462,7 +13611,7 @@ function signatureToDomain(ce, sig) {
 }
 
 // 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("$");
@@ -13682,7 +13831,7 @@ function getWildcardName(s) {
 }
 
 // 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) {
@@ -13730,7 +13879,7 @@ function lex(expr) {
 
 // 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);
@@ -13850,6 +13999,15 @@ function order(a, b) {
   }
   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;
@@ -13900,7 +14058,7 @@ function flattenSequence(xs) {
 }
 
 // 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) {
@@ -14205,7 +14363,7 @@ var Sum = class {
       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));
   }
 };
 
@@ -14415,10 +14573,10 @@ function domainSetsLibrary() {
 }
 
 // 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];
@@ -15595,6 +15753,7 @@ var _BoxedExpression = class {
   set value(_value) {
     throw new Error(`Can't change the value of \\(${this.latex}\\)`);
   }
+  // @ts-ignore
   get domain() {
     return void 0;
   }
@@ -15960,7 +16119,7 @@ function canonicalAdd(ce, ops2) {
       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) {
@@ -16064,12 +16223,16 @@ function evalSummation(ce, expr, range, mode) {
     }
     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();
@@ -16168,7 +16331,7 @@ function evalSummation(ce, expr, range, mode) {
 }
 
 // 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)
@@ -16700,10 +16863,10 @@ function isInequality(expr) {
 }
 
 // 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) {
@@ -16828,7 +16991,7 @@ function isInMachineRange(d) {
 }
 
 // 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;
@@ -17776,7 +17939,7 @@ var BoxedDictionary = class _BoxedDictionary extends _BoxedExpression {
 };
 
 // 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 = [];
@@ -17784,7 +17947,7 @@ var SIMPLIFY_RULES = [];
 // 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);
   }
@@ -18255,6 +18418,11 @@ var BoxedFunction = class _BoxedFunction extends _BoxedExpression {
   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;
@@ -18494,7 +18662,7 @@ function cheapest(oldExpr, newExpr) {
 }
 
 // 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;
@@ -19382,7 +19550,7 @@ function asString(expr) {
 }
 
 // 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) {
@@ -19393,7 +19561,7 @@ function gammaln3(c) {
 }
 
 // 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;
@@ -21085,71 +21253,6 @@ var ARITHMETIC_LIBRARY = [
         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
-            )
-          );
-        }
-      }
     }
   },
   //
@@ -21820,6 +21923,73 @@ var CALCULUS_LIBRARY = [
         }
       }
     }
+  },
+  {
+    // 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
+            )
+          );
+        }
+      }
+    }
   }
 ];
 
@@ -22576,6 +22746,15 @@ function indexes(ranges) {
   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")
@@ -23419,12 +23598,44 @@ var CORE_LIBRARY = [
         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()
       }
     },
@@ -23682,22 +23893,40 @@ var LINEAR_ALGEBRA_LIBRARY = [
         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
@@ -23935,6 +24164,28 @@ var RELOP_LIBRARY = {
       }
     }
   },
+  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,
@@ -25622,7 +25873,7 @@ function evalTrig(ce, mode, head2, op3) {
 }
 
 // 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) {
@@ -26614,7 +26865,7 @@ function isFunctionDefinition(def) {
 }
 
 // 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);
@@ -27196,6 +27447,7 @@ var BoxedSymbol = class _BoxedSymbol extends _BoxedExpression {
       });
     }
   }
+  // @ts-ignore
   get domain() {
     const def = this._def;
     if (def) {
@@ -27584,7 +27836,6 @@ var ComputeEngine = class _ComputeEngine {
       symbols: /* @__PURE__ */ new Set(),
       expressions: /* @__PURE__ */ new Set()
     };
-    this._defaultDomain = null;
     this._numericMode = options?.numericMode ?? "auto";
     this._precision = Math.max(
       options?.numericPrecision ?? 100,
@@ -27828,6 +28079,56 @@ var ComputeEngine = class _ComputeEngine {
       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());
@@ -27838,6 +28139,51 @@ var ComputeEngine = class _ComputeEngine {
     }
     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();
@@ -27941,7 +28287,14 @@ var ComputeEngine = class _ComputeEngine {
     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)
@@ -27958,6 +28311,15 @@ var ComputeEngine = class _ComputeEngine {
       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");
@@ -28002,8 +28364,8 @@ var ComputeEngine = class _ComputeEngine {
     };
     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");
@@ -28011,12 +28373,17 @@ var ComputeEngine = class _ComputeEngine {
     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;
@@ -28036,6 +28403,7 @@ var ComputeEngine = class _ComputeEngine {
       }
     }
   }
+  /** @internal */
   _printScope(options, scope, depth = 0) {
     options ?? (options = { details: false, maxDepth: 1 });
     scope ?? (scope = this.context);
@@ -28346,6 +28714,9 @@ var ComputeEngine = class _ComputeEngine {
     }
     return this._cache[cacheName]?.value;
   }
+  /**
+   * Return a boxed expression from the input.
+   */
   box(expr, options) {
     return box(this, expr, options);
   }
@@ -28355,6 +28726,16 @@ var ComputeEngine = class _ComputeEngine {
     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 });
   }
@@ -28399,18 +28780,33 @@ var ComputeEngine = class _ComputeEngine {
     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,
@@ -28420,15 +28816,27 @@ var ComputeEngine = class _ComputeEngine {
       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;
@@ -28479,6 +28887,10 @@ var ComputeEngine = class _ComputeEngine {
       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;
@@ -28511,21 +28923,33 @@ var ComputeEngine = class _ComputeEngine {
       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))
@@ -28563,6 +28987,11 @@ var ComputeEngine = class _ComputeEngine {
       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;
@@ -28596,7 +29025,7 @@ var ComputeEngine = class _ComputeEngine {
       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...)
    */
@@ -28648,6 +29077,9 @@ var ComputeEngine = class _ComputeEngine {
     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;
@@ -28658,6 +29090,16 @@ var ComputeEngine = class _ComputeEngine {
     }
     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(
@@ -28678,6 +29120,7 @@ var ComputeEngine = class _ComputeEngine {
   set latexOptions(opts) {
     this.latexSyntax.updateOptions(opts);
   }
+  /** {@inheritDoc  JsonSerializationOptions} */
   get jsonSerializationOptions() {
     if (this._useRawJsonSerializationOptions) {
       return new Proxy(this._rawJsonSerializationOptions, {
@@ -28766,6 +29209,21 @@ var ComputeEngine = class _ComputeEngine {
   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 }));
@@ -28774,6 +29232,7 @@ var ComputeEngine = class _ComputeEngine {
       return "internal-error";
     }
   }
+  /** Remove all assumptions about one or more symbols */
   forget(symbol2) {
     if (!this.context)
       throw Error("No scope available");
@@ -28821,10 +29280,10 @@ function isFunctionValue(value) {
 }
 
 // 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"
 };
 export {
   ADDITION_PRECEDENCE,