@cortex-js/compute-engine 0.20.0 → 0.20.2

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.20.0 */
+/** CortexJS Compute Engine 0.20.2 */
     (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;
@@ -3980,6 +3980,13 @@ var ComputeEngine = (() => {
       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;
@@ -5396,16 +5403,14 @@ var ComputeEngine = (() => {
           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")
@@ -5478,8 +5483,23 @@ var ComputeEngine = (() => {
       //   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))
         ]);
@@ -5585,107 +5605,6 @@ var ComputeEngine = (() => {
         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) => {
@@ -6326,11 +6245,11 @@ var ComputeEngine = (() => {
     "(": "(",
     ")": ")",
     "[": "\\lbrack",
+    "]": "\\rbrack",
     "\u27E6": "\\llbrack",
     // U+27E6 MATHEMATICAL LEFT WHITE SQUARE BRACKET
     "\u27E7": "\\rrbrack",
     // U+27E7 MATHEMATICAL RIGHT WHITE SQUARE BRACKET
-    "]": "\\rbrack",
     "{": "\\lbrace",
     "}": "\\rbrace",
     "<": "\\langle",
@@ -6377,6 +6296,16 @@ var ComputeEngine = (() => {
       }
       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 });
@@ -6787,6 +6716,111 @@ var ComputeEngine = (() => {
     }
   ];
 
+  // 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
@@ -8828,25 +8862,26 @@ var ComputeEngine = (() => {
     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
@@ -15168,7 +15203,7 @@ var ComputeEngine = (() => {
     }
     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)
       })})`;
@@ -17779,7 +17814,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);
     }
@@ -18250,6 +18285,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;
@@ -21080,71 +21120,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
-              )
-            );
-          }
-        }
       }
     },
     //
@@ -21815,6 +21790,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
+              )
+            );
+          }
+        }
+      }
     }
   ];
 
@@ -23172,18 +23214,6 @@ var ComputeEngine = (() => {
           }
         }
       },
-      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"]`
@@ -23335,7 +23365,7 @@ var ComputeEngine = (() => {
             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];
@@ -23431,7 +23461,27 @@ var ComputeEngine = (() => {
         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()
         }
       },
@@ -23674,6 +23724,24 @@ var ComputeEngine = (() => {
       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", []);
@@ -23689,9 +23757,6 @@ var ComputeEngine = (() => {
     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 },
@@ -28813,10 +28878,10 @@ ${JSON.stringify(entry)}`
   }
 
   // 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"
   };
   return __toCommonJS(compute_engine_exports);
 })();