@cortex-js/compute-engine 0.20.1 → 0.20.2

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.20.1 */
+/** CortexJS Compute Engine 0.20.2 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -17784,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);
   }
@@ -18255,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;
@@ -21085,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
-            )
-          );
-        }
-      }
     }
   },
   //
@@ -21820,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
+            )
+          );
+        }
+      }
+    }
   }
 ];
 
@@ -23424,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()
       }
     },
@@ -28821,10 +28848,10 @@ function isFunctionValue(value) {
 }
 
 // src/compute-engine.ts
-var version = "0.20.1";
+var version = "0.20.2";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.20.1"
+  version: "0.20.2"
 };
 export {
   ADDITION_PRECEDENCE,

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.20.1 */
+/** 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;
@@ -17814,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);
     }
@@ -18285,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;
@@ -21115,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
-              )
-            );
-          }
-        }
       }
     },
     //
@@ -21850,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
+              )
+            );
+          }
+        }
+      }
     }
   ];
 
@@ -23454,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()
         }
       },
@@ -28851,10 +28878,10 @@ ${JSON.stringify(entry)}`
   }
 
   // src/compute-engine.ts
-  var version = "0.20.1";
+  var version = "0.20.2";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.20.1"
+    version: "0.20.2"
   };
   return __toCommonJS(compute_engine_exports);
 })();