@cortex-js/compute-engine 0.12.4 → 0.12.5

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.12.4 */
+/** CortexJS Compute Engine 0.12.5 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -4587,6 +4587,15 @@ var DEFINITIONS_ARITHMETIC = [
     parse: "ExponentialE",
     serialize: "\\exponentialE"
   },
+  {
+    kind: "function",
+    trigger: "exp",
+    parse: (parser) => ["Exp", ...parser.matchArguments("enclosure") ?? []]
+  },
+  {
+    trigger: "\\exp",
+    parse: (parser) => ["Exp", ...parser.matchArguments("enclosure") ?? []]
+  },
   {
     name: "ImaginaryUnit",
     trigger: ["\\imaginaryI"]
@@ -4710,11 +4719,12 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "Exp",
-    serialize: (serializer, expr) => joinLatex([
-      "\\exponentialE^{",
-      serializer.serialize(missingIfEmpty(op(expr, 1))),
-      "}"
-    ])
+    serialize: (serializer, expr) => {
+      const op12 = op(expr, 1);
+      if (symbol(op12) || machineValue(op12) !== null)
+        return joinLatex(["\\exponentialE^{", serializer.serialize(op12)]);
+      return joinLatex(["\\exp", serializer.wrap(missingIfEmpty(op12))]);
+    }
   },
   {
     name: "Factorial",
@@ -4891,7 +4901,31 @@ var DEFINITIONS_ARITHMETIC = [
     trigger: ["\\pm"],
     kind: "infix",
     associativity: "both",
-    precedence: 270
+    precedence: 270,
+    serialize: (serializer, expr) => {
+      const op12 = op(expr, 1);
+      if (op12 === null)
+        return "\\pm";
+      if (nops(expr) === 1)
+        return joinLatex(["\\pm", serializer.serialize(op12)]);
+      const op22 = op(expr, 2);
+      return joinLatex([
+        serializer.serialize(op12),
+        "\\pm",
+        serializer.serialize(op22)
+      ]);
+    }
+  },
+  {
+    trigger: ["\\pm"],
+    kind: "prefix",
+    precedence: 270,
+    parse: (parser, terminator) => {
+      if (270 < terminator.minPrec)
+        return null;
+      const rhs = parser.matchExpression({ ...terminator, minPrec: 400 });
+      return ["PlusMinus", missingIfEmpty(rhs)];
+    }
   },
   {
     name: "Power",
@@ -5620,7 +5654,7 @@ var DEFINITIONS_INEQUALITIES = [
     kind: "infix",
     associativity: "right",
     precedence: 241,
-    parse: "Equal"
+    parse: "LessEqual"
   },
   {
     trigger: ["\\leqslant"],
@@ -7404,7 +7438,7 @@ function indexLatexDictionary(dic, onError) {
           message: [
             "invalid-dictionary-entry",
             indexedEntry.name,
-            "Duplicate definition"
+            "Duplicate definition. The name must be unique, but a trigger can be used by multiple definitions."
           ]
         });
       }
@@ -8701,6 +8735,8 @@ var _Parser = class {
    * - 'enclosure' : will look for an argument inside an enclosure (open/close fence)
    * - 'implicit': either an expression inside a pair of `()`, or just a product
    *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
+   *
+   * This returns an array of arguments, or null if there is no match.
    */
   matchArguments(kind, until) {
     if (!kind)
@@ -8709,23 +8745,15 @@ var _Parser = class {
       return null;
     const savedIndex = this.index;
     const group = this.matchEnclosure();
-    if (kind === "enclosure" && head(group) === "Delimiter") {
-      if (op(group, 1) === "Sequence")
-        return ops(op(group, 1)) ?? [];
-      return [op(group, 1) ?? ["Sequence"]];
-    }
+    if (kind === "enclosure")
+      return getSequence(group) ?? [];
     if (kind === "implicit") {
-      if (head(group) === "Delimiter") {
-        if (head(op(group, 1)) === "Sequence")
-          return getSequence(group) ?? [];
-        return [op(group, 1) ?? ["Sequence"]];
-      }
+      if (head(group) === "Delimiter")
+        return getSequence(group) ?? [];
       if (group !== null)
         return [group];
       const primary = this.matchExpression({ ...until, minPrec: 390 });
-      if (primary !== null)
-        return [primary];
-      return null;
+      return primary === null ? null : [primary];
     }
     this.index = savedIndex;
     return null;
@@ -8745,7 +8773,7 @@ var _Parser = class {
       fn = pf;
     } while (true);
     const seq = this.matchArguments("enclosure");
-    return seq ? [fn, ...seq] : id;
+    return seq ? [fn, ...seq] : fn;
   }
   /** A prime suffix is a sequence of `'`, `\prime` or `\doubleprime`
    * after a function or in a superscript.
@@ -9154,7 +9182,7 @@ var _Parser = class {
       this.index = index;
     return result;
   }
-  matchPostfix(lhs) {
+  matchPostfix(lhs, until) {
     console.assert(lhs !== null);
     if (lhs === null)
       return null;
@@ -9164,7 +9192,7 @@ var _Parser = class {
     const start = this.index;
     for (const [def, n] of defs) {
       this.index = start + n;
-      const result = def.parse(this, lhs);
+      const result = def.parse(this, lhs, until);
       if (result !== null)
         return result;
     }
@@ -9510,7 +9538,7 @@ var _Parser = class {
       let postfix = null;
       let index = this.index;
       do {
-        postfix = this.matchPostfix(result);
+        postfix = this.matchPostfix(result, until);
         result = postfix ?? result;
         if (this.index === index && postfix !== null) {
           console.assert(this.index !== index, "No token consumed");
@@ -15371,7 +15399,7 @@ function expandMultinomial(expr) {
   const ce = expr.engine;
   if (expr.op1.head === "Negate") {
     const sign2 = exp2 % 2 === 0 ? 1 : -1;
-    const result2 = expandMultinomial(ce.box(["Power", expr.op1.op1, expr.op2]));
+    const result2 = expandMultinomial(ce.pow(expr.op1.op1, expr.op2));
     if (result2 === null)
       return null;
     if (sign2 > 0)
@@ -15596,15 +15624,14 @@ function assumeEquality(proposition) {
     const sols = findUnivariateRoots(proposition, lhs2);
     if (sols.length === 0) {
       ce.assumptions.set(
-        ce.box([
-          "Equal",
+        ce.fn("Equal", [
           ce.add([proposition.op1.canonical, ce.neg(proposition.op2.canonical)]).simplify(),
           0
         ]),
         true
       );
     }
-    const val = sols.length === 1 ? sols[0] : ce.box(["List", ...sols]);
+    const val = sols.length === 1 ? sols[0] : ce.fn("List", sols);
     const def = ce.lookupSymbol(lhs2);
     if (!def) {
       ce.defineSymbol(lhs2, { value: val });
@@ -16586,7 +16613,6 @@ var BoxedFunction = class _BoxedFunction extends AbstractBoxedExpression {
     return result;
   }
   solve(vars) {
-    console.log("solve this:", this.toString());
     if (vars.length !== 1)
       return null;
     const roots = findUnivariateRoots(this.simplify(), vars[0]);
@@ -16665,6 +16691,8 @@ function makeCanonicalFunction(ce, head2, ops2, metadata) {
         xs.push(y);
     }
   }
+  if (!xs.every((x) => x.isValid))
+    return new BoxedFunction(ce, head2, xs, { metadata, canonical: false });
   const sig = def.signature;
   if (sig.canonical) {
     try {
@@ -16695,21 +16723,22 @@ function makeCanonicalFunction(ce, head2, ops2, metadata) {
   return new BoxedFunction(ce, head2, xs, { metadata, def, canonical: true });
 }
 function apply(fn, args) {
+  const ce = fn.engine;
   if (fn.head !== "Lambda")
-    return fn.engine._fn(fn.evaluate(), args);
+    return ce._fn(fn.evaluate(), args);
   const subs2 = {
-    "__": fn.engine.tuple(args),
-    "_#": fn.engine.number(args.length)
+    "__": ce.tuple(args),
+    "_#": ce.number(args.length)
   };
   let n = 1;
   for (const op3 of args)
     subs2[`_${n++}`] = op3;
   subs2["_"] = subs2["_1"];
-  const savedContext = this.context;
-  this.context = fn.scope ?? null;
-  const result = fn.subs(subs2).evaluate();
-  this.context = savedContext;
-  return result;
+  const savedContext = ce.context;
+  ce.context = fn.scope ?? null;
+  const result = fn.subs(subs2);
+  ce.context = savedContext;
+  return result.op1.evaluate();
 }
 function holdMap(xs, skip, associativeHead, f) {
   if (xs.length === 0)
@@ -18824,7 +18853,7 @@ var ARITHMETIC_LIBRARY = [
             return ce._NEGATIVE_INFINITY;
           if (ops2.length === 1)
             return ops2[0];
-          return ce.box(["Max", ...ops2]);
+          return ce.fn("Max", ops2);
         },
         evaluate: (ce, ops2) => {
           if (ops2.length === 0)
@@ -18853,7 +18882,7 @@ var ARITHMETIC_LIBRARY = [
             return ce._NEGATIVE_INFINITY;
           if (ops2.length === 1)
             return ops2[0];
-          return ce.box(["Min", ...ops2]);
+          return ce.fn("Min", ops2);
         },
         evaluate: (ce, ops2) => {
           if (ops2.length === 0)
@@ -19194,7 +19223,7 @@ var ARITHMETIC_LIBRARY = [
     e: {
       domain: "TranscendentalNumber",
       constant: true,
-      holdUntil: "never",
+      holdUntil: "N",
       value: "ExponentialE"
     },
     i: {
@@ -19220,14 +19249,13 @@ var ARITHMETIC_LIBRARY = [
     },
     Half: {
       constant: true,
-      holdUntil: "never",
+      holdUntil: "evaluate",
       value: ["Rational", 1, 2]
     },
     ImaginaryUnit: {
       domain: "ImaginaryNumber",
       constant: true,
-      holdUntil: "evaluate",
-      // @todo maybe?
+      holdUntil: "never",
       wikidata: "Q193796",
       flags: { imaginary: true },
       value: ["Complex", 0, 1]
@@ -20055,8 +20083,7 @@ var CORE_LIBRARY = [
       signature: {
         domain: ["Function", ["Maybe", ["Sequence", "Anything"]], "String"],
         evaluate: (ce, ops2) => {
-          return ce.box([
-            "Latex",
+          return ce.fn("Latex", [
             ce.string(tokensToString(ops2.map((x) => x.string ?? x.latex)))
           ]);
         }
@@ -20079,7 +20106,7 @@ var CORE_LIBRARY = [
       hold: "all",
       signature: {
         domain: ["Function", ["Maybe", ["Sequence", "Anything"]], "String"],
-        evaluate: (ce, ops2) => ce.box(["Latex", ce.string(joinLatex(ops2.map((x) => x.latex)))])
+        evaluate: (ce, ops2) => ce.fn("Latex", [ce.string(joinLatex(ops2.map((x) => x.latex)))])
       }
     },
     SplitAsLatexTokens: {
@@ -20916,13 +20943,13 @@ var TRIGONOMETRY_LIBRARY = [
             "Number"
           ]);
           if (ops2.length !== 1)
-            return ce.box(["Degrees", ops2]);
+            return ce.fn("Degrees", ops2, { canonical: false });
           const arg = ops2[0];
           if (arg.numericValue === null || !arg.isValid)
-            return ce.box(["Degrees", arg]);
+            return ce.fn("Degrees", ops2, { canonical: false });
           return ce.div(ce.mul([arg, ce.symbol("Pi")]), ce.number(180));
         },
-        evaluate: (ce, ops2) => ce.mul([ops2[0], ce.box(["Divide", "Pi", 180])])
+        evaluate: (ce, ops2) => ce.mul([ops2[0], ce.div(ce.symbol("Pi"), ce.number(180))])
       }
     },
     Hypot: {
@@ -21442,6 +21469,8 @@ var TRIG_IDENTITIES = {
   ]
 };
 function constructibleValues(ce, head2, x) {
+  if (!x)
+    return void 0;
   const specialValues = ce.cache(
     "constructible-trigonometric-values",
     () => {
@@ -21518,6 +21547,8 @@ function processInverseFunction(ce, xs) {
   return newHead ? ce.symbol(newHead) : void 0;
 }
 function evalTrig(ce, mode, head2, op3) {
+  if (!op3)
+    return void 0;
   if (mode === "evaluate") {
     const result = constructibleValues(ce, head2, op3)?.evaluate();
     if (result)
@@ -21715,7 +21746,7 @@ var BoxedSymbolDefinitionImpl = class {
     this._flags = def.flags ? normalizeFlags(def.flags) : void 0;
     this._domain = def.domain ? ce.domain(def.domain) : void 0;
     this.constant = def.constant ?? false;
-    this.holdUntil = def.holdUntil ?? "simplify";
+    this.holdUntil = def.holdUntil ?? "evaluate";
     if (this.constant) {
       this._defValue = def.value;
       this._value = null;
@@ -23371,17 +23402,20 @@ var BoxedSymbol = class _BoxedSymbol extends AbstractBoxedExpression {
   }
   simplify(options) {
     const def = this.symbolDefinition;
-    if ((def?.holdUntil === "never" || def?.holdUntil === "simplify") && def.value)
+    if (def?.holdUntil === "simplify" && def.value)
       return def.value.simplify(options);
     return options?.rules ? this.replace(options.rules) ?? this : this;
   }
   evaluate(options) {
     const def = this.symbolDefinition;
-    if (def?.holdUntil !== "N")
-      return def?.value?.evaluate(options) ?? this;
+    if (def && (def.holdUntil === "simplify" || def.holdUntil === "evaluate"))
+      return def.value?.evaluate(options) ?? this;
     return this;
   }
   N(options) {
+    const def = this.symbolDefinition;
+    if (def && def.holdUntil === "never")
+      return this;
     return this.symbolDefinition?.value?.N(options) ?? this;
   }
   replace(rules, options) {
@@ -23794,7 +23828,7 @@ var ComputeEngine = class _ComputeEngine {
         precision: this.precision,
         avoidExponentsInRange: [-6, this.precision],
         onError: (err) => {
-          throw new Error(err[0].message.toString());
+          throw new Error(JSON.stringify(err[0].message));
         }
       });
     return this._latexSyntax;
@@ -24058,8 +24092,8 @@ var ComputeEngine = class _ComputeEngine {
     const bxs = xs;
     return bxs.every((x) => x.isCanonical) ? bxs : bxs.map((x) => x.canonical);
   }
-  fn(head2, ops2, metadata) {
-    return boxFunction(this, head2, ops2, { metadata, canonical: true });
+  fn(head2, ops2, options) {
+    return boxFunction(this, head2, ops2, options ?? { canonical: true });
   }
   /** @internal */
   _fn(head2, ops2, metadata) {
@@ -24473,10 +24507,10 @@ var ComputeEngine = class _ComputeEngine {
 };
 
 // src/compute-engine.ts
-var version = "0.12.4";
+var version = "0.12.5";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.12.4"
+  version: "0.12.5"
 };
 export {
   ComputeEngine,