@cortex-js/compute-engine 0.20.0 → 0.20.2

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.20.0 */
+/** CortexJS Compute Engine 0.20.2 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3950,6 +3950,13 @@ function nops(expr) {
     return Math.max(0, expr.fn.length - 1);
   return 0;
 }
+function unhold(expr) {
+  if (expr === null || expr === void 0)
+    return null;
+  if (head(expr) === "Hold")
+    return op(expr, 1);
+  return expr;
+}
 function symbol(expr) {
   if (expr === null || expr === void 0)
     return null;
@@ -5366,16 +5373,14 @@ var DEFINITIONS_CORE = [
         lhs = op(lhs, 1) ?? "Nothing";
       if (head(lhs) === "Sequence") {
         for (const x of ops(lhs) ?? []) {
-          if (symbol(x))
-            params.push(symbol(x));
-          else
+          if (!symbol(x))
             return null;
+          params.push(symbol(x));
         }
       } else {
-        if (symbol(lhs))
-          params = [symbol(lhs)];
-        else
+        if (!symbol(lhs))
           return null;
+        params = [symbol(lhs)];
       }
       let rhs = parser.parseExpression({ minPrec: ARROW_PRECEDENCE }) ?? "Nothing";
       if (head(rhs) === "Delimiter")
@@ -5448,8 +5453,23 @@ var DEFINITIONS_CORE = [
     //   return ['Assign', lhs, rhs];
     // },
     serialize: (serializer, expr) => {
+      const id = unhold(op(expr, 1));
+      if (head(op(expr, 2)) === "Function") {
+        const op_2 = op(expr, 2);
+        const body = unhold(op(op_2, 1));
+        const args = ops(op_2)?.slice(1) ?? [];
+        return joinLatex([
+          serializer.serialize(id),
+          serializer.wrapString(
+            args.map((x) => serializer.serialize(x)).join(", "),
+            serializer.options.applyFunctionStyle(expr, serializer.level)
+          ),
+          "\\coloneq",
+          serializer.serialize(body)
+        ]);
+      }
       return joinLatex([
-        serializer.serialize(op(expr, 1)),
+        serializer.serialize(id),
         "\\coloneq",
         serializer.serialize(op(expr, 2))
       ]);
@@ -5555,107 +5575,6 @@ var DEFINITIONS_CORE = [
       return serializer.wrapString(body, style, open + close);
     }
   },
-  // The first argument is the matrix data.
-  // The second, optional, argument are the delimiters.
-  // 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}"]);
-    }
-  },
   {
     name: "Domain",
     serialize: (serializer, expr) => {
@@ -6296,11 +6215,11 @@ var DELIMITERS_SHORTHAND = {
   "(": "(",
   ")": ")",
   "[": "\\lbrack",
+  "]": "\\rbrack",
   "\u27E6": "\\llbrack",
   // U+27E6 MATHEMATICAL LEFT WHITE SQUARE BRACKET
   "\u27E7": "\\rrbrack",
   // U+27E7 MATHEMATICAL RIGHT WHITE SQUARE BRACKET
-  "]": "\\rbrack",
   "{": "\\lbrace",
   "}": "\\rbrace",
   "<": "\\langle",
@@ -6347,6 +6266,16 @@ function parseAssign(parser, lhs) {
     }
     return ["Assign", fn, ["Function", rhs2, ...args ?? []]];
   }
+  if (typeof head(lhs) === "string") {
+    const fn = head(lhs);
+    const args = ops(lhs) ?? [];
+    const rhs2 = parser.parseExpression({ minPrec: 0 });
+    if (rhs2 === null) {
+      parser.index = index;
+      return null;
+    }
+    return ["Assign", fn, ["Function", rhs2, ...args]];
+  }
   if (!symbol(lhs))
     return null;
   const rhs = parser.parseExpression({ minPrec: 0 });
@@ -6757,6 +6686,111 @@ var DEFINITIONS_INEQUALITIES = [
   }
 ];
 
+// src/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.ts
+var DEFINITIONS_LINEAR_ALGEBRA = [
+  // The first argument is the matrix data.
+  // The second, optional, argument are the delimiters.
+  // 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}"]);
+    }
+  }
+];
+
 // src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
 var DEFINITIONS_LOGIC = [
   // Constants
@@ -8798,25 +8832,26 @@ function isValidEntry(entry, onError) {
   return true;
 }
 var DEFAULT_LATEX_DICTIONARY = {
-  algebra: DEFINITIONS_ALGEBRA,
-  arithmetic: DEFINITIONS_ARITHMETIC,
-  calculus: DEFINITIONS_CALCULUS,
-  complex: DEFINITIONS_COMPLEX,
-  core: DEFINITIONS_CORE,
-  logic: DEFINITIONS_LOGIC,
-  relop: DEFINITIONS_INEQUALITIES,
-  other: DEFINITIONS_OTHERS,
-  physics: [
+  "algebra": DEFINITIONS_ALGEBRA,
+  "arithmetic": DEFINITIONS_ARITHMETIC,
+  "calculus": DEFINITIONS_CALCULUS,
+  "complex": DEFINITIONS_COMPLEX,
+  "core": DEFINITIONS_CORE,
+  "linear-algebra": DEFINITIONS_LINEAR_ALGEBRA,
+  "logic": DEFINITIONS_LOGIC,
+  "relop": DEFINITIONS_INEQUALITIES,
+  "other": DEFINITIONS_OTHERS,
+  "physics": [
     {
       name: "mu0",
       kind: "symbol",
       latexTrigger: "\\mu_0"
     }
   ],
-  sets: DEFINITIONS_SETS,
-  statistics: DEFINITIONS_STATISTICS,
-  symbols: DEFINITIONS_SYMBOLS,
-  trigonometry: DEFINITIONS_TRIGONOMETRY
+  "sets": DEFINITIONS_SETS,
+  "statistics": DEFINITIONS_STATISTICS,
+  "symbols": DEFINITIONS_SYMBOLS,
+  "trigonometry": DEFINITIONS_TRIGONOMETRY
 };
 
 // src/compute-engine/latex-syntax/parse-identifier.ts
@@ -15138,7 +15173,7 @@ function compileExpr(h, args, prec, target) {
   }
   if (h === "Function") {
     const params = args.slice(1).map((x) => x.symbol);
-    return `((${params.join(", ")}) => ${compile(args[0], {
+    return `((${params.join(", ")}) => ${compile(args[0].canonical, {
       ...target,
       var: (id) => params.includes(id) ? id : target.var(id)
     })})`;
@@ -17749,7 +17784,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);
   }
@@ -18220,6 +18255,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;
@@ -21050,71 +21090,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
-            )
-          );
-        }
-      }
     }
   },
   //
@@ -21785,6 +21760,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
+            )
+          );
+        }
+      }
+    }
   }
 ];
 
@@ -23142,18 +23184,6 @@ var CORE_LIBRARY = [
         }
       }
     },
-    Matrix: {
-      complexity: 9e3,
-      hold: "all",
-      signature: {
-        params: ["Lists"],
-        optParams: ["Strings", "Strings"],
-        result: "Lists",
-        canonical: canonicalMatrix,
-        evaluate: (_ce, ops2) => ops2[0].evaluate(),
-        N: (_ce, ops2) => ops2[0].N()
-      }
-    },
     Error: {
       /**
        * - The first argument is either a string or an `["ErrorCode"]`
@@ -23305,7 +23335,7 @@ var CORE_LIBRARY = [
           if (!op12.symbol)
             return null;
           const op22 = args[1];
-          return ce._fn("Assign", [ce.hold(op12), ce.hold(op22)]);
+          return ce._fn("Assign", [op12, op22]);
         },
         evaluate: (ce, ops2) => {
           const op12 = ops2[0];
@@ -23401,7 +23431,27 @@ var CORE_LIBRARY = [
       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()
       }
     },
@@ -23644,6 +23694,24 @@ function canonicalInvisibleOperator(ce, ops2) {
     return ce._fn("Multiply", flattenOps(ops2, "Multiply"));
   return ce._fn("Tuple", ops2);
 }
+
+// src/compute-engine/library/linear-algebra.ts
+var LINEAR_ALGEBRA_LIBRARY = [
+  {
+    Matrix: {
+      complexity: 9e3,
+      hold: "all",
+      signature: {
+        params: ["Lists"],
+        optParams: ["Strings", "Strings"],
+        result: "Lists",
+        canonical: canonicalMatrix,
+        evaluate: (_ce, ops2) => ops2[0].evaluate(),
+        N: (_ce, ops2) => ops2[0].N()
+      }
+    }
+  }
+];
 function canonicalMatrix(ce, ops2) {
   if (ops2.length === 0)
     return ce._fn("Matrix", []);
@@ -23659,9 +23727,6 @@ function canonicalMatrix(ce, ops2) {
   return ce._fn("Matrix", [body]);
 }
 
-// src/compute-engine/library/linear-algebra.ts
-var LINEAR_ALGEBRA_LIBRARY = [];
-
 // src/compute-engine/library/logic.ts
 var LOGIC_LIBRARY = {
   True: { wikidata: "Q16751793", domain: "Booleans", constant: true },
@@ -28783,10 +28848,10 @@ function isFunctionValue(value) {
 }
 
 // src/compute-engine.ts
-var version = "0.20.0";
+var version = "0.20.2";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.20.0"
+  version: "0.20.2"
 };
 export {
   ADDITION_PRECEDENCE,