@cortex-js/compute-engine 0.12.7 → 0.13.0

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.12.7 */
+/** CortexJS Compute Engine 0.13.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __create = Object.create;
@@ -3971,6 +3971,14 @@ var ComputeEngine = (() => {
       return null;
     return s;
   }
+  function isListLike(expr) {
+    if (expr === null)
+      return false;
+    const h = head(expr);
+    if (!h || typeof h !== "string")
+      return false;
+    return /^(List|Sequence|Tuple|Single|Pair|Triple)$/.test(h);
+  }
   function keyValuePair(expr) {
     const h = head(expr);
     if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
@@ -4606,6 +4614,10 @@ var ComputeEngine = (() => {
       parse: "ExponentialE",
       serialize: "\\exponentialE"
     },
+    {
+      trigger: "\\mathrm{e}",
+      parse: "ExponentialE"
+    },
     {
       kind: "function",
       trigger: "exp",
@@ -4619,6 +4631,10 @@ var ComputeEngine = (() => {
       name: "ImaginaryUnit",
       trigger: ["\\imaginaryI"]
     },
+    {
+      trigger: "\\mathrm{i}",
+      parse: "ImaginaryUnit"
+    },
     // Operations
     {
       /** Could be the determinant if the argument is a matrix */
@@ -5178,7 +5194,7 @@ var ComputeEngine = (() => {
     }
     return result;
   }
-  function serializeSequence(sep = "") {
+  function serializeOps(sep = "") {
     return (serializer, expr) => (ops(expr) ?? []).map((x) => serializer.serialize(x)).join(sep);
   }
   var DEFINITIONS_CORE = [
@@ -5246,22 +5262,19 @@ var ComputeEngine = (() => {
           return "";
         const style = serializer.options.groupStyle(expr, serializer.level + 1);
         const arg1 = op(expr, 1);
-        if (argCount === 1)
-          return serializer.wrapString(serializer.serialize(arg1), style);
-        let sep = "";
-        let open = "";
-        let close = "";
+        const h1 = head(arg1);
+        const defaultFence = { List: "[],", Sequence: "" }[typeof h1 === "string" ? h1 : ""] ?? "(),";
+        let open = defaultFence[0] ?? "";
+        let close = defaultFence[1] ?? "";
+        let sep = defaultFence[2] ?? "";
         if (argCount > 1) {
           const op22 = stringValue(op(expr, 2)) ?? "";
-          open = op22[0] ?? "(";
-          close = op22[1] ?? ")";
-          sep = op22[2] ?? ",";
+          open = op22[0] ?? defaultFence[0];
+          close = op22[1] ?? defaultFence[1];
+          sep = op22[2] ?? defaultFence[2];
         }
-        const body = head(arg1) === "List" ? serializeSequence(sep)(serializer, arg1) : serializer.serialize(arg1);
-        serializer.wrapString(body, style, stringValue(op(expr, 2)) ?? void 0);
-        if (!open || !close)
-          return serializer.wrapString(body, style);
-        return `${open} ${body} ${close}`;
+        const body = isListLike(arg1) ? serializeOps(sep)(serializer, arg1) : serializer.serialize(arg1);
+        return serializer.wrapString(body, style, open + close);
       }
     },
     {
@@ -5362,7 +5375,7 @@ var ComputeEngine = (() => {
       serialize: (serializer, expr) => {
         return joinLatex([
           "\\lbrack",
-          serializeSequence(", ")(serializer, expr),
+          serializeOps(", ")(serializer, expr),
           "\\rbrack"
         ]);
       }
@@ -5400,7 +5413,7 @@ var ComputeEngine = (() => {
     },
     {
       name: "Sequence",
-      serialize: serializeSequence("")
+      serialize: serializeOps("")
     },
     {
       trigger: [";"],
@@ -5530,24 +5543,17 @@ var ComputeEngine = (() => {
         return result;
       },
       serialize: (serialize2, expr) => {
-        if (head(op(expr, 1)) !== "List")
-          return "";
-        const rows = ops(op(expr, 1)) ?? [];
-        const body = [];
-        let rowSep = "";
-        for (const row of rows) {
-          if (head(row) === "Tuple" || head(row) === "Pair") {
-            body.push(rowSep);
-            if (op(row, 2)) {
-              body.push(serialize2.serialize(op(row, 2)));
-              const condition = op(row, 1);
-              if (condition !== null)
-                body.push("&", serialize2.serialize(condition));
-            }
+        const rows = [];
+        const args = ops(expr);
+        if (args) {
+          for (let i = 0; i <= args.length - 2; i += 2) {
+            const row = [];
+            row.push(serialize2.serialize(args[i + 1]));
+            row.push(serialize2.serialize(args[i]));
+            rows.push(row.join("&"));
           }
-          rowSep = "\\\\";
         }
-        return joinLatex(["\\begin{cases}", ...body, "\\end{cases}"]);
+        return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
       }
     }
   ];
@@ -7449,11 +7455,6 @@ var ComputeEngine = (() => {
     "\\rceil": "\\rceil",
     "\\rfloor": "\\rfloor"
   };
-  function triggerLength(trigger) {
-    if (Array.isArray(trigger))
-      return trigger.length;
-    return 1;
-  }
   function addEntry(result, entry, onError) {
     const [trigger, indexedEntry] = makeIndexedEntry(entry, onError);
     if (indexedEntry === null)
@@ -7495,7 +7496,7 @@ var ComputeEngine = (() => {
     if (indexedEntry.kind === "matchfix") {
       result.matchfix.push(indexedEntry);
     } else if (indexedEntry.kind === "environment") {
-      const triggerString = tokensToString(entry.trigger ?? "");
+      const triggerString = tokensToString(entry.trigger ?? []);
       if (result.environment.has(triggerString)) {
         onError({
           severity: "warning",
@@ -7509,22 +7510,31 @@ var ComputeEngine = (() => {
       result.environment.set(triggerString, indexedEntry);
     } else if (trigger) {
       console.assert(entry.trigger);
-      const triggerString = tokensToString(entry.trigger ?? "");
-      const n = triggerLength(trigger);
-      result.lookahead = Math.max(result.lookahead, n);
       if (indexedEntry.kind === "function") {
-        if (!result.function.has(triggerString))
-          result.function.set(triggerString, [indexedEntry]);
+        console.assert(typeof entry.trigger === "string");
+        const fnName = entry.trigger;
+        if (!result.function.has(fnName))
+          result.function.set(fnName, [indexedEntry]);
         else
-          result.function.set(triggerString, [
-            ...result.function.get(triggerString),
+          result.function.set(fnName, [
+            ...result.function.get(fnName),
             indexedEntry
           ]);
       } else {
+        let triggerString;
+        let tokenCount;
+        if (typeof entry.trigger === "string") {
+          triggerString = entry.trigger;
+          tokenCount = countTokens(triggerString);
+        } else {
+          triggerString = tokensToString(entry.trigger ?? []);
+          tokenCount = entry.trigger.length;
+        }
+        result.lookahead = Math.max(result.lookahead, tokenCount);
         const kind2 = indexedEntry.kind;
-        if (result[kind2][n] === void 0)
-          result[kind2][n] = /* @__PURE__ */ new Map();
-        const list = result[kind2][n];
+        if (result[kind2][tokenCount] === void 0)
+          result[kind2][tokenCount] = /* @__PURE__ */ new Map();
+        const list = result[kind2][tokenCount];
         if (list.has(triggerString))
           list.get(triggerString).push(indexedEntry);
         else
@@ -7604,13 +7614,11 @@ var ComputeEngine = (() => {
     if (result.kind === "expression" && isExpressionEntry(entry)) {
       result.serialize = entry.serialize ?? triggerString;
       if (typeof result.serialize === "string") {
-        const serializeExpr = result.serialize;
+        const serializeStr = result.serialize;
         result.serialize = (serializer, expr) => {
           if (!head(expr))
-            return serializer.serialize(serializeExpr);
-          return `${serializer.serialize(
-            serializeExpr
-          )}${serializer.wrapArguments(expr)}`;
+            return serializeStr;
+          return `${serializeStr}${serializer.wrapArguments(expr)}`;
         };
       }
       {
@@ -8357,7 +8365,7 @@ var ComputeEngine = (() => {
         defs = this.lookAhead().map((x, n) => this._dictionary[kind][n]?.get(x));
       }
       const result = [];
-      for (let i = defs.length; i > 0; i--) {
+      for (let i = defs.length - 1; i > 0; i--) {
         if (defs[i] !== void 0) {
           console.assert(Array.isArray(defs[i]));
           for (const def of defs[i])
@@ -10111,14 +10119,16 @@ var ComputeEngine = (() => {
     wrapString(s, style, fence) {
       if (style === "none")
         return s;
-      const openFence = fence?.[0] ?? "(";
-      const closeFence = fence?.[1] ?? ")";
+      if (fence === void 0)
+        fence = "()";
+      const openFence = fence?.[0] ?? ".";
+      const closeFence = fence?.[1] ?? ".";
       if ((openFence === "." || closeFence === ".") && style === "paren")
         style = "leftright";
       if (style === "leftright")
-        return `${openFence === "." ? "" : `\\left(${openFence}`}${s}${closeFence === "." ? "" : `\\right(${closeFence}`})`;
+        return `\\left${openFence}${s}\\right${closeFence}}`;
       if (style === "big")
-        return `${openFence === "." ? "" : `\\Bigl(${openFence}`}${s}${closeFence === "." ? "" : `\\Bigr(${closeFence}`})`;
+        return `${openFence === "." ? "" : `\\Bigl${openFence}`}${s}${closeFence === "." ? "" : `\\Bigr${closeFence}`})`;
       return openFence + s + closeFence;
     }
     wrapArguments(expr) {
@@ -13171,6 +13181,246 @@ var ComputeEngine = (() => {
 
   // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
   var import_complex6 = __toESM(require_complex());
+
+  // src/compute-engine/compile.ts
+  function compileToJavascript(expr) {
+    const js = compile(expr, expr.freeVars);
+    try {
+      return new Function("_", `return ${js}`);
+    } catch (e) {
+      console.error(`${e}
+${expr.latex}
+${js}`);
+    }
+    return void 0;
+  }
+  function compile(expr, freeVars = [], prec = 0) {
+    const f = asFloat(expr);
+    if (f !== null)
+      return f.toString();
+    const s = expr.symbol;
+    if (s !== null) {
+      const result = {
+        True: "true",
+        False: "false",
+        Pi: "Math.PI",
+        ExponentialE: "Math.E",
+        I: "Math.I",
+        NaN: "Number.NaN",
+        ImaginaryUnit: "NaN"
+      }[s];
+      if (result !== void 0)
+        return result;
+      if (freeVars.includes(s))
+        return `_.${s}`;
+      return s;
+    }
+    const str = expr.string;
+    if (str !== null)
+      return JSON.stringify(str);
+    const keys = expr.keys;
+    if (keys !== null) {
+      const result = [];
+      for (const key of keys) {
+        const value = expr.getKey(key);
+        if (value)
+          result.push(`${key}: ${compile(value, freeVars, 0)}`);
+      }
+      return `{${result.join(", ")}}`;
+    }
+    const h = expr.head;
+    if (typeof h === "string") {
+      if (h === "Negate") {
+        const arg = expr.op1;
+        if (arg === null)
+          return "";
+        return `-${compile(arg, freeVars, 3)}`;
+      }
+      if (h === "Error") {
+        return "NaN";
+      }
+      if (h === "Sum")
+        return compileLoop(expr, "+");
+      if (h === "Product")
+        return compileLoop(expr, "*");
+      if (h === "Root") {
+        const arg = expr.op1;
+        if (arg === null)
+          return "";
+        const exp2 = expr.op2;
+        if (exp2 === null)
+          return `Math.sqrt(${compile(arg, freeVars, 0)})`;
+        return `Math.pow(${compile(arg, freeVars)}, 1/${compile(exp2, freeVars)}`;
+      }
+      if (h === "Factorial") {
+        const arg = expr.op1;
+        if (arg === null)
+          return "";
+        return `${compile(arg, freeVars, 3)}!`;
+      }
+      const OPS = {
+        Add: ["+", 1],
+        Subtract: ["-", 1],
+        Multiply: ["*", 2],
+        Divide: ["/", 3]
+      };
+      const op3 = OPS[h];
+      if (op3 !== void 0) {
+        const args2 = expr.ops;
+        if (args2 === null)
+          return "";
+        const result = [];
+        for (const arg of args2)
+          result.push(compile(arg, freeVars, op3[1]));
+        return op3[1] < prec ? `(${result.join(op3[0])})` : result.join(op3[0]);
+      }
+      const fn = {
+        Abs: "Math.abs",
+        Arccos: "Math.acos",
+        Arcosh: "Math.acosh",
+        Arsin: "Math.asin",
+        Arsinh: "Math.asinh",
+        Arctan: "Math.atan",
+        Artanh: "Math.atanh",
+        // Math.cbrt
+        Ceiling: "Math.ceil",
+        Cos: "Math.cos",
+        Cosh: "Math.cosh",
+        Exp: "Math.exp",
+        Floor: "Math.floor",
+        // Math.hypot
+        Ln: "Math.log",
+        Log: "Math.log10",
+        Lb: "Math.log2",
+        Max: "Math.max",
+        Min: "Math.min",
+        Power: "Math.pow",
+        Random: "Math.random",
+        Round: "Math.round",
+        Sgn: "Math.sign",
+        Sin: "Math.sin",
+        Sinh: "Math.sinh",
+        Sqrt: "Math.sqrt",
+        Tan: "Math.tan",
+        Tanh: "Math.tanh"
+        // Factorial: 'factorial',    // TODO: implement
+        // Hallucinated by Copilot, but interesting ideas...
+        // Cot: 'Math.cot',
+        // Sec: 'Math.sec',
+        // Csc: 'Math.csc',
+        // ArcCot: 'Math.acot',
+        // ArcSec: 'Math.asec',
+        // ArcCsc: 'Math.acsc',
+        // Coth: 'Math.coth',
+        // Sech: 'Math.sech',
+        // Csch: 'Math.csch',
+        // ArcCoth: 'Math.acoth',
+        // ArcSech: 'Math.asech',
+        // ArcCsch: 'Math.acsch',
+        // Root: 'Math.root',
+        // Gamma: 'Math.gamma',
+        // Erf: 'Math.erf',
+        // Erfc: 'Math.erfc',
+        // Erfi: 'Math.erfi',
+        // Zeta: 'Math.zeta',
+        // PolyGamma: 'Math.polygamma',
+        // HurwitzZeta: 'Math.hurwitzZeta',
+        // DirichletEta: 'Math.dirichletEta',
+        // Beta: 'Math.beta',
+        // Binomial: 'Math.binomial',
+        // Mod: 'Math.mod',
+        // Quotient: 'Math.quotient',
+        // GCD: 'Math.gcd',
+        // LCM: 'Math.lcm',
+        // Divisors: 'Math.divisors',
+        // PrimeQ: 'Math.isPrime',
+        // PrimePi: 'Math.primePi',
+        // Prime: 'Math.prime',
+        // NextPrime: 'Math.nextPrime',
+        // PreviousPrime: 'Math.prevPrime',
+        // PrimePowerQ: 'Math.isPrimePower',
+        // PrimePowerPi: 'Math.primePowerPi',
+        // PrimePower: 'Math.primePower',
+        // NextPrimePower: 'Math.nextPrimePower',
+        // PreviousPrimePower: 'Math.prevPrimePower',
+        // PrimeFactors: 'Math.primeFactors',
+        // DivisorSigma: 'Math.divisorSigma',
+        // DivisorSigma0: 'Math.divisorSigma0',
+        // DivisorSigma1: 'Math.divisorSigma1',
+        // DivisorSigma2: 'Math.divisorSigma2',
+        // DivisorSigma3: 'Math.divisorSigma3',
+        // DivisorSigma4: 'Math.divisorSigma4',
+        // DivisorCount: 'Math.divisorCount',
+        // DivisorSum: 'Math.divisorSum',
+        // MoebiusMu: 'Math.moebiusMu',
+        // LiouvilleLambda: 'Math.liouvilleLambda',
+        // CarmichaelLambda: 'Math.carmichaelLambda',
+        // EulerPhi: 'Math.eulerPhi',
+        // EulerPsi: 'Math.eulerPsi',
+        // EulerGamma: 'Math.eulerGamma',
+        // HarmonicNumber: 'Math.harmonicNumber',
+        // BernoulliB: 'Math.bernoulliB',
+        // StirlingS1: 'Math.stirlingS1',
+        // StirlingS2: 'Math.stirlingS2',
+        // BellB: 'Math.bellB',
+        // BellNumber: 'Math.bellNumber',
+        // LahS: 'Math.lahS',
+        // LahL: 'Math.lahL',
+        // RiemannR: 'Math.riemannR',
+        // RiemannZeta: 'Math.riemannZeta',
+        // RiemannXi: 'Math.riemannXi',
+        // RiemannH: 'Math.riemannH',
+        // RiemannZ: 'Math.riemannZ',
+        // RiemannS: 'Math.riemannS',
+        // RiemannXiZero: 'Math.riemannXiZero',
+        // RiemannZetaZero: 'Math.riemannZetaZero',
+        // RiemannHZero: 'Math.riemannHZero',
+        // RiemannSZero: 'Math.riemannSZero',
+        // RiemannPrimeCount: 'Math.riemannPrimeCount',
+        // RiemannRLog: 'Math.riemannRLog',
+        // RiemannRLogDerivative: 'Math.riemannRLogDerivative',
+        // RiemannRLogZero: 'Math.riemannRLogZero',
+        // RiemannRLogZeroDerivative: 'Math.riemannRLogZeroDerivative',
+        // RiemannRZero: 'Math.riemannRZero',
+        // RiemannRDerivative: 'Math.riemannRDerivative',
+        // RiemannXiZeroDerivative: 'Math.riemannXiZeroDerivative',
+        // RiemannZetaZeroDerivative: 'Math.riemannZetaZeroDerivative',
+        // RiemannHZeroDerivative: 'Math.riemannHZeroDerivative',
+        // RiemannSZeroDerivative: 'Math.riemannSZeroDerivative',
+        // RiemannSZeroDerivative2: 'Math.riemannSZeroDerivative2',
+        // RiemannSZeroDerivative3: 'Math.riemannSZeroDerivative3',
+        // RiemannSZeroDerivative4: 'Math.riemannSZeroDerivative4',
+        // RiemannSZeroDerivative5: 'Math.riemannSZeroDerivative5',
+        // RiemannSZeroDerivative6: 'Math.riemannSZeroDerivative6',
+      }[h] ?? h;
+      const args = expr.ops;
+      if (args !== null) {
+        const result = [];
+        for (const arg of args)
+          result.push(compile(arg, freeVars, 0));
+        return `${fn}(${result.join(", ")})`;
+      }
+    }
+    return "";
+  }
+  function compileLoop(expr, op3) {
+    const args = expr.ops;
+    if (args === null)
+      return "NaN";
+    if (!expr.op1 || !expr.op2)
+      return "NaN";
+    const [index, lower, upper, isFinite2] = normalizeLimits(expr.op2);
+    const fn = compile(expr.op1, [...expr.op1.freeVars, index], 0);
+    return `((_) => {
+    let acc = ${op3 === "+" ? "0" : "1"};
+    const fn = (_) => ${fn};
+    for (let i = ${lower}; i < ${upper}; i++)
+      acc ${op3}= fn({ ..._, ${index}: i });
+    return acc;
+  })()`;
+  }
+
+  // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
   var AbstractBoxedExpression = class {
     constructor(ce, metadata) {
       this.engine = ce;
@@ -13495,6 +13745,9 @@ var ComputeEngine = (() => {
     N(_options) {
       return this.evaluate();
     }
+    compile() {
+      return compileToJavascript(this);
+    }
   };
 
   // src/compute-engine/boxed-expression/serialize.ts
@@ -14957,7 +15210,7 @@ var ComputeEngine = (() => {
       }
     }
     return xs.map(
-      (op3) => !op3.isValid || op3.isNumber ? op3 : ce.error(["incompatible-domain", "Number", op3.domain], op3)
+      (op3) => op3 && !op3.isValid || op3.isNumber ? op3 : ce.error(["incompatible-domain", "Number", op3.domain], op3)
     );
   }
   function validateSignature(sig, ops2, codomain) {
@@ -15665,7 +15918,6 @@ var ComputeEngine = (() => {
     // ],
   ];
   function findUnivariateRoots(expr, x) {
-    console.log("findUnivariateRoots", expr.toString(), x);
     const ce = expr.engine;
     if (expr.head === "Equal") {
       expr = ce.add([expr.op1.canonical, ce.neg(expr.op2.canonical)]).simplify();
@@ -19604,6 +19856,18 @@ var ComputeEngine = (() => {
     level ?? (level = 1);
     if (level === 1) {
       const h = oneOf([
+        [
+          "Sqrt",
+          [
+            "Multiply",
+            6,
+            [
+              "Sum",
+              ["Divide", 1, ["Power", "n", 2]],
+              ["Triple", ["Hold", "n"], 1, { num: "+Infinity" }]
+            ]
+          ]
+        ],
         "Add",
         "Add",
         "Add",
@@ -19622,13 +19886,16 @@ var ComputeEngine = (() => {
         "Negate",
         "trig"
       ]);
-      return randomExpressionWithHead(h, 1);
+      if (typeof h === "string")
+        return randomExpressionWithHead(h, 1);
+      return h;
     }
     if (level === 2) {
-      if (Math.random() > 0.5)
-        return randomExpression(3);
-      if (Math.random() > 0.75)
+      const r = Math.random();
+      if (r > 0.75)
         return randomExpression(1);
+      if (r > 0.5)
+        return randomExpression(3);
       const h = oneOf([
         "Multiply",
         "Multiply",
@@ -19682,7 +19949,7 @@ var ComputeEngine = (() => {
       ["Rational", 12, 15],
       ["Rational", 15, 12],
       "ExponentialE",
-      "ImaginaryUnit",
+      // 'ImaginaryUnit',
       ["Sqrt", 3],
       ["Sqrt", 5],
       ["Sqrt", 15],
@@ -19700,8 +19967,8 @@ var ComputeEngine = (() => {
       ["Power", "x", 4],
       ["Subtract", "x", 1],
       ["Add", "x", 1],
-      "a",
-      "b",
+      // 'a',
+      // 'b',
       "Pi"
     ]);
   }
@@ -23947,6 +24214,10 @@ ${JSON.stringify(entry)}`
       return new this._bignum(a);
     }
     complex(a, b) {
+      if (a instanceof Decimal)
+        a = a.toNumber();
+      if (b instanceof Decimal)
+        b = b.toNumber();
       return new import_complex19.Complex(a, b);
     }
     isBignum(a) {
@@ -24642,10 +24913,10 @@ ${JSON.stringify(entry)}`
   };
 
   // src/compute-engine.ts
-  var version = "0.12.7";
+  var version = "0.13.0";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.12.7"
+    version: "0.13.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();