@cortex-js/compute-engine 0.14.0 → 0.15.0

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.14.0 */
+/** CortexJS Compute Engine 0.15.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;
@@ -3427,7 +3427,7 @@ var ComputeEngine = (() => {
   var decimal_default = Decimal;
 
   // src/compute-engine/compute-engine.ts
-  var import_complex19 = __toESM(require_complex());
+  var import_complex20 = __toESM(require_complex());
 
   // src/common/grapheme-splitter.ts
   function stringToCodepoints(string) {
@@ -4291,7 +4291,7 @@ var ComputeEngine = (() => {
     if (name === "Negate") {
       result = "-" + serializer.wrap(arg, 276);
     } else if (name === "Add") {
-      if (nops(expr) === 2 && serializer.options.invisiblePlus !== "+") {
+      if (serializer.canonical && nops(expr) === 2 && serializer.options.invisiblePlus !== "+") {
         const [op12, op22] = [op(expr, 1), op(expr, 2)];
         let [lhs, rhs] = [op12, op22];
         let lhsValue = machineValue(lhs);
@@ -4352,21 +4352,23 @@ var ComputeEngine = (() => {
       return "";
     serializer.level -= 1;
     let result = "";
-    const [numer, denom] = numeratorDenominator(expr);
-    if (denom.length > 0) {
-      if (denom.length === 1 && denom[0] === 1) {
-        if (numer.length === 0)
-          result = "1";
-        else if (numer.length === 1)
-          result = serializer.serialize(numer[0]);
-        else
-          result = serializeMultiply(serializer, ["Multiply", ...numer]);
-      } else {
-        result = serializer.serialize([
-          "Divide",
-          numer.length === 1 ? numer[0] : ["Multiply", ...numer],
-          denom.length === 1 ? denom[0] : ["Multiply", ...denom]
-        ]);
+    if (serializer.canonical === true) {
+      const [numer, denom] = numeratorDenominator(expr);
+      if (denom.length > 0) {
+        if (denom.length === 1 && denom[0] === 1) {
+          if (numer.length === 0)
+            result = "1";
+          else if (numer.length === 1)
+            result = serializer.serialize(numer[0]);
+          else
+            result = serializeMultiply(serializer, ["Multiply", ...numer]);
+        } else {
+          result = serializer.serialize([
+            "Divide",
+            numer.length === 1 ? numer[0] : ["Multiply", ...numer],
+            denom.length === 1 ? denom[0] : ["Multiply", ...denom]
+          ]);
+        }
       }
     }
     if (result) {
@@ -4487,7 +4489,7 @@ var ComputeEngine = (() => {
       return "";
     const numer = missingIfEmpty(op(expr, 1));
     const denom = missingIfEmpty(op(expr, 2));
-    const style = getFractionStyle(expr, serializer.level);
+    const style = serializer.canonical ? getFractionStyle(expr, serializer.level) : "quotient";
     if (style === "inline-solidus" || style === "nice-solidus") {
       const numerStr = serializer.wrapShort(numer);
       const denomStr = serializer.wrapShort(denom);
@@ -4526,25 +4528,27 @@ var ComputeEngine = (() => {
         base,
         exp2
       );
-    const val2 = machineValue(exp2) ?? 1;
-    if (val2 === -1) {
-      return serializer.serialize(["Divide", "1", base]);
-    } else if (val2 < 0) {
-      return serializer.serialize(["Divide", "1", ["Power", base, -val2]]);
-    } else if (head(exp2) === "Divide" || head(exp2) === "Rational") {
-      if (machineValue(op(exp2, 1)) === 1) {
-        const style = getRootStyle(expr, serializer.level);
-        return serializeRoot(serializer, style, base, op(exp2, 2));
-      }
-      if (machineValue(op(exp2, 2)) === 2) {
-        return `${serializer.serialize(["Sqrt", base])}^{${serializer.serialize(
-          op(exp2, 1)
-        )}}`;
-      }
-    } else if (head(exp2) === "Power") {
-      if (machineValue(op(exp2, 2)) === -1) {
-        const style = getRootStyle(expr, serializer.level);
-        return serializeRoot(serializer, style, base, op(exp2, 1));
+    if (serializer.canonical) {
+      const val2 = machineValue(exp2) ?? 1;
+      if (val2 === -1) {
+        return serializer.serialize(["Divide", "1", base]);
+      } else if (val2 < 0) {
+        return serializer.serialize(["Divide", "1", ["Power", base, -val2]]);
+      } else if (head(exp2) === "Divide" || head(exp2) === "Rational") {
+        if (machineValue(op(exp2, 1)) === 1) {
+          const style = getRootStyle(expr, serializer.level);
+          return serializeRoot(serializer, style, base, op(exp2, 2));
+        }
+        if (machineValue(op(exp2, 2)) === 2) {
+          return `${serializer.serialize(["Sqrt", base])}^{${serializer.serialize(
+            op(exp2, 1)
+          )}}`;
+        }
+      } else if (head(exp2) === "Power") {
+        if (machineValue(op(exp2, 2)) === -1) {
+          const style = getRootStyle(expr, serializer.level);
+          return serializeRoot(serializer, style, base, op(exp2, 1));
+        }
       }
     }
     return serializer.wrapShort(base) + "^{" + serializer.serialize(exp2) + "}";
@@ -5388,15 +5392,9 @@ var ComputeEngine = (() => {
     {
       name: "List",
       kind: "matchfix",
-      openTrigger: "[",
-      closeTrigger: "]",
-      parse: (_parser, body) => {
-        if (body === null || isEmptySequence(body))
-          return ["List"];
-        if (head(body) !== "Sequence" && head(body) !== "List")
-          return ["List", body];
-        return ["List", ...ops(body) ?? []];
-      },
+      openTrigger: "\\lbrack",
+      closeTrigger: "\\rbrack",
+      parse: parseList,
       serialize: (serializer, expr) => {
         return joinLatex([
           "\\lbrack",
@@ -5405,20 +5403,31 @@ var ComputeEngine = (() => {
         ]);
       }
     },
+    // Synonyms for List
+    {
+      kind: "matchfix",
+      openTrigger: "[",
+      closeTrigger: "]",
+      parse: parseList
+    },
+    {
+      kind: "matchfix",
+      openTrigger: "\\[",
+      closeTrigger: "\\]",
+      parse: parseList
+    },
+    // Synonyms for Delimiter
     {
       kind: "matchfix",
       openTrigger: "(",
       closeTrigger: ")",
-      parse: (_parser, body) => {
-        if (body === null || isEmptySequence(body))
-          return ["Sequence"];
-        if (head(body) === "Sequence" || head(body) === "List") {
-          if (nops(body) === 0)
-            return ["Delimiter"];
-          return ["Delimiter", ["Sequence", ...ops(body) ?? []]];
-        }
-        return ["Delimiter", body];
-      }
+      parse: parseDelimiter
+    },
+    {
+      kind: "matchfix",
+      openTrigger: "\\lparen",
+      closeTrigger: "\\rparen",
+      parse: parseDelimiter
     },
     {
       latexTrigger: [","],
@@ -5491,9 +5500,7 @@ var ComputeEngine = (() => {
       kind: "postfix",
       parse: (_parser, lhs) => ["Superstar", lhs]
     },
-    // @todo: when lhs is a complex number, 'Conjugate'
-    // { name: 'Conjugate', trigger: ['\\star'], kind: 'infix' },
-    { name: "Superstar", latexTrigger: ["^", "\\star"], kind: "postfix" },
+    // { name: 'Superstar', latexTrigger: ['^', '\\star'], kind: 'postfix' },
     {
       latexTrigger: ["_", "*"],
       kind: "postfix",
@@ -5775,6 +5782,23 @@ var ComputeEngine = (() => {
       return ["Prime", missingIfEmpty(lhs)];
     return ["Prime", missingIfEmpty(lhs), order2];
   }
+  function parseDelimiter(parser, body) {
+    if (body === null || isEmptySequence(body))
+      return ["Sequence"];
+    if (head(body) === "Sequence") {
+      if (nops(body) === 0)
+        return ["Delimiter"];
+      return ["Delimiter", ["Sequence", ...ops(body) ?? []]];
+    }
+    return ["Delimiter", body];
+  }
+  function parseList(_parser, body) {
+    if (body === null || isEmptySequence(body))
+      return ["List"];
+    if (head(body) !== "Sequence" && head(body) !== "List")
+      return ["List", body];
+    return ["List", ...ops(body) ?? []];
+  }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-inequalities.ts
   var DEFINITIONS_INEQUALITIES = [
@@ -7703,6 +7727,59 @@ var ComputeEngine = (() => {
     })
   ];
 
+  // src/compute-engine/latex-syntax/dictionary/definitions-complex.ts
+  var DEFINITIONS_COMPLEX = [
+    {
+      name: "Real",
+      kind: "function",
+      latexTrigger: ["\\Re"]
+    },
+    {
+      name: "Imaginary",
+      kind: "function",
+      latexTrigger: ["\\Im"]
+    },
+    {
+      name: "Argument",
+      kind: "function",
+      latexTrigger: ["\\arg"]
+    },
+    {
+      name: "Conjugate",
+      latexTrigger: ["^", "\\star"],
+      kind: "postfix"
+    }
+  ];
+
+  // src/compute-engine/latex-syntax/dictionary/definitions-statistics.ts
+  var DEFINITIONS_STATISTICS = [
+    {
+      name: "Mean",
+      kind: "function",
+      identifierTrigger: "mean"
+    },
+    {
+      name: "Median",
+      kind: "function",
+      identifierTrigger: "median"
+    },
+    {
+      name: "StandarDeviation",
+      kind: "function",
+      identifierTrigger: "stddev"
+    },
+    {
+      latexTrigger: ["\\bar"],
+      kind: "expression",
+      parse: (parser, _until) => {
+        const expr = parser.parseGroup() ?? parser.parseToken();
+        if (!expr || !symbol(expr))
+          return null;
+        return ["Mean", expr];
+      }
+    }
+  ];
+
   // src/compute-engine/latex-syntax/dictionary/definitions.ts
   var DEFAULT_DELIMITER = {
     "(": "(",
@@ -7892,7 +7969,7 @@ var ComputeEngine = (() => {
       return entry.parse;
     const kind = "kind" in entry ? entry.kind : "expression";
     if (kind === "environment") {
-      const envName = entry.parse ?? idTrigger ?? entry.name;
+      const envName = entry.parse ?? entry.name ?? idTrigger;
       if (envName)
         return (parser, _until) => {
           const array = parser.parseTabular();
@@ -7902,7 +7979,7 @@ var ComputeEngine = (() => {
         };
     }
     if (kind === "function") {
-      const fnName = entry.parse ?? idTrigger ?? entry.name;
+      const fnName = entry.parse ?? entry.name ?? idTrigger;
       if (fnName)
         return (parser, until) => {
           const args = parser.parseArguments("enclosure", until);
@@ -7910,12 +7987,12 @@ var ComputeEngine = (() => {
         };
     }
     if (kind === "symbol") {
-      const symName = entry.parse ?? idTrigger ?? entry.name;
+      const symName = entry.parse ?? entry.name ?? idTrigger;
       if (symName)
         return (_parser, _terminator) => symName;
     }
     if (kind === "prefix") {
-      const h = entry.parse ?? idTrigger ?? entry.name;
+      const h = entry.parse ?? entry.name ?? idTrigger;
       if (h) {
         const prec = entry["precedence"] ?? 1e4;
         return (parser, until) => {
@@ -7941,7 +8018,7 @@ var ComputeEngine = (() => {
           missingIfEmpty(op(arg, 2))
         ];
       }
-      const h = entry.parse ?? idTrigger ?? entry.name;
+      const h = entry.parse ?? entry.name ?? idTrigger;
       const prec = entry["precedence"] ?? 1e4;
       const associativity = entry["associativity"] ?? "non";
       if (h)
@@ -7966,7 +8043,7 @@ var ComputeEngine = (() => {
         };
     }
     if (kind === "expression") {
-      const parseResult = entry.parse ?? idTrigger ?? entry.name;
+      const parseResult = entry.parse ?? entry.name ?? idTrigger;
       if (parseResult)
         return () => parseResult;
     }
@@ -7987,6 +8064,16 @@ var ComputeEngine = (() => {
     }
     if (Array.isArray(subject))
       subject = tokensToString(subject);
+    if ("trigger" in entry) {
+      onError({
+        severity: "warning",
+        message: [
+          "invalid-dictionary-entry",
+          subject,
+          `The 'trigger' property is deprecated. Use 'latexTrigger' or 'identifierTrigger' instead`
+        ]
+      });
+    }
     if ("kind" in entry && ![
       "expression",
       "symbol",
@@ -8153,6 +8240,7 @@ var ComputeEngine = (() => {
     algebra: DEFINITIONS_ALGEBRA,
     arithmetic: DEFINITIONS_ARITHMETIC,
     calculus: DEFINITIONS_CALCULUS,
+    complex: DEFINITIONS_COMPLEX,
     core: DEFINITIONS_CORE,
     logic: DEFINITIONS_LOGIC,
     relop: DEFINITIONS_INEQUALITIES,
@@ -8165,6 +8253,7 @@ var ComputeEngine = (() => {
       }
     ],
     sets: DEFINITIONS_SETS,
+    statistics: DEFINITIONS_STATISTICS,
     symbols: DEFINITIONS_SYMBOLS,
     trigonometry: DEFINITIONS_TRIGONOMETRY
   };
@@ -8688,7 +8777,7 @@ var ComputeEngine = (() => {
       }
       for (const def of defs) {
         if (def.identifierTrigger) {
-          const n = peekComplexId(this, def.identifierTrigger);
+          const n = parseComplexId(this, def.identifierTrigger);
           if (n > 0)
             result.push([def, n]);
         }
@@ -8831,6 +8920,65 @@ var ComputeEngine = (() => {
       this.index = index;
       return null;
     }
+    /** If the next token matches the open delimiter, set a boundary with
+     * the close token and return true.
+     *
+     * Note this method handles generic delimiters, i.e. '(' will math both
+     * '(', '\left(', '\bigl(', etc...
+     *
+     * Note that the definitions for matchfix may need to include synonyms
+     * for example:
+     *
+     * {
+     *    openDelimiter: '(',
+     *    closeDelimiter: ')'
+     * }
+     *
+     * and
+     *
+     * {
+     *   openDelimiter: '\\lparen',
+     *   closeDelimiter: '\\rparen'
+     * }
+     *
+     * For:
+     * - '[': '\\lbrack' and '\\['
+     * - ']': '\\rbrack' and '\\]'
+     * - '{': '\\lbrace' and '\\}'
+     * - '}': '\\rbrace' and '\\}'
+     * - '<': '\\langle'
+     * - '>': '\\rangle'
+     * - '|': '\\vert'
+     * - '||': '\\Vert'
+     * - '|': '\\lvert' and '\\rvert'
+     * - '||': '\\lVert' and '\\rVert'
+     */
+    matchDelimiter(open, close) {
+      if (this.peek === "[")
+        return false;
+      if (Array.isArray(open)) {
+        console.assert(Array.isArray(close));
+        if (this.matchAll(open)) {
+          this.addBoundary(close);
+          return true;
+        }
+        return false;
+      }
+      const start = this.index;
+      const closePrefix = OPEN_DELIMITER_PREFIX[this.peek];
+      if (closePrefix)
+        this.nextToken();
+      if (open === "||" && this.matchAll(["|", "|"])) {
+        this.addBoundary(["|", "|"]);
+        return true;
+      }
+      if (!this.match(open)) {
+        this.index = start;
+        return false;
+      }
+      this.addBoundary(closePrefix ? [closePrefix, close] : [close]);
+      return true;
+    }
     parseGroup() {
       const start = this.index;
       this.skipSpaceTokens();
@@ -9287,6 +9435,8 @@ var ComputeEngine = (() => {
      * return `['\right', '\rparen']`, which can be matched with `matchAll()`
      *
      * If you need to match several tokens, use `matchAll()`
+     *
+     * @internal
      */
     matchOpenDelimiter(openDelim, closeDelim) {
       const index = this.index;
@@ -9401,42 +9551,20 @@ var ComputeEngine = (() => {
       const start = this.index;
       for (const def of defs) {
         this.index = start;
-        if (Array.isArray(def.openDelimiter)) {
-          if (!this.matchAll(def.openDelimiter))
-            continue;
-          this.addBoundary(def.closeDelimiter);
-          const body2 = this.parseExpression();
-          this.skipSpace();
-          if (!this.matchBoundary()) {
-            this.removeBoundary();
-            continue;
-          }
-          const rhs = def.parse(this, body2 ?? ["Sequence"]);
-          if (rhs === null)
-            continue;
-          return rhs;
-        }
-        const closeDelimiter = this.matchOpenDelimiter(
-          def.openDelimiter,
-          def.closeDelimiter
-        );
-        if (closeDelimiter === null)
+        if (!this.matchDelimiter(def.openDelimiter, def.closeDelimiter))
           continue;
-        if (this.matchAll(closeDelimiter)) {
-          const result2 = def.parse(this, ["Sequence"]);
-          if (result2 === null)
-            continue;
-          return result2;
-        }
-        this.addBoundary(closeDelimiter);
         const bodyStart = this.index;
+        this.skipSpace();
         let body = this.parseExpression();
         this.skipSpace();
         if (!this.matchBoundary()) {
+          const boundary = this._boundaries[this._boundaries.length - 1].tokens;
           this.removeBoundary();
           this.index = bodyStart;
+          this.skipSpace();
           body = this.parseExpression();
-          if (!this.matchAll(closeDelimiter)) {
+          this.skipSpace();
+          if (!this.matchAll(boundary)) {
             if (!this.atEnd)
               continue;
             this.index = start;
@@ -10023,7 +10151,7 @@ var ComputeEngine = (() => {
       }
     }
   };
-  function peekComplexId(parser, id) {
+  function parseComplexId(parser, id) {
     const start = parser.index;
     const candidate = parseIdentifier(parser)?.trim();
     if (candidate === null)
@@ -10292,6 +10420,7 @@ var ComputeEngine = (() => {
       }
       this.onError = onError;
       this.dictionary = dictionary2;
+      this.canonical = void 0;
     }
     updateOptions(opt) {
       for (const k of Object.keys(this.options))
@@ -10411,9 +10540,16 @@ var ComputeEngine = (() => {
         return `\\textbf{${x}} & \\rightarrow & ${this.serialize(dict[x])}`;
       }).join("\\\\")}\\end{array}\\right\\rbrack`;
     }
-    serialize(expr) {
+    serialize(expr, options) {
       if (expr === null || expr === void 0)
         return "";
+      options ?? (options = {});
+      options = { ...options };
+      if (!("canonical" in options))
+        options.canonical = true;
+      const savedCanonical = this.canonical;
+      if (this.canonical === void 0)
+        this.canonical = options.canonical;
       this.level += 1;
       try {
         const result = (() => {
@@ -10450,10 +10586,12 @@ var ComputeEngine = (() => {
           ]);
         })();
         this.level -= 1;
+        this.canonical = savedCanonical;
         return result ?? "";
       } catch (e) {
       }
       this.level -= 1;
+      this.canonical = savedCanonical;
       return "";
     }
     applyFunctionStyle(expr, level) {
@@ -10791,8 +10929,8 @@ var ComputeEngine = (() => {
       }
       return expr ?? ["Sequence"];
     }
-    serialize(expr) {
-      return this.serializer.serialize(expr);
+    serialize(expr, options) {
+      return this.serializer.serialize(expr, options);
     }
     get serializer() {
       if (this._serializer)
@@ -12125,6 +12263,19 @@ var ComputeEngine = (() => {
       return 0;
     return n;
   }
+  function erf(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign2 = x < 0 ? -1 : 1;
+    x = Math.abs(x);
+    const t = 1 / (1 + p * x);
+    const y = ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t;
+    return sign2 * (1 - y * Math.exp(-x * x));
+  }
 
   // src/compute-engine/numerics/numeric-bigint.ts
   function bigint(a) {
@@ -18952,6 +19103,24 @@ ${js}`);
     console.assert(op12.isCanonical);
     console.assert(op22.isCanonical);
     const ce = op12.engine;
+    if (op12.symbol === "ImaginaryUnit") {
+      const f = asFloat(op22);
+      if (f !== null)
+        return ce.number(ce.complex(0, f));
+    }
+    if (op22.symbol === "ImaginaryUnit") {
+      const f = asFloat(op12);
+      if (f !== null)
+        return ce.number(ce.complex(0, f));
+    }
+    if (op12.numericValue !== null && op22.numericValue !== null) {
+      const f1 = asFloat(op12);
+      const f2 = asFloat(op22);
+      if (f1 !== null && ce.isComplex(op22))
+        return ce.number(ce.complex(f1 * op22.re, f1 * op22.im));
+      if (f2 !== null && ce.isComplex(op12))
+        return ce.number(ce.complex(f2 * op12.re, f2 * op12.im));
+    }
     if (op12.numericValue !== null && op22.numericValue !== null && op12.isInteger && op22.isInteger) {
       return apply2N(
         op12,
@@ -19367,14 +19536,6 @@ ${js}`);
           }
         }
       },
-      Erf: {
-        description: "Error Function",
-        complexity: 7500
-      },
-      Erfc: {
-        description: "Complementary Error Function",
-        complexity: 7500
-      },
       Factorial: {
         description: "Factorial Function",
         wikidata: "Q120976",
@@ -19519,7 +19680,7 @@ ${js}`);
         description: "Maximum of two or more numbers",
         complexity: 1200,
         signature: {
-          domain: ["Function", ["Sequence", "Number"], "Number"],
+          domain: ["Function", ["Sequence", "Value"], "Number"],
           simplify: (ce, ops2) => {
             if (ops2.length === 0)
               return ce._NEGATIVE_INFINITY;
@@ -19548,7 +19709,7 @@ ${js}`);
         description: "Minimum of two or more numbers",
         complexity: 1200,
         signature: {
-          domain: ["Function", ["Sequence", "Number"], "Number"],
+          domain: ["Function", ["Sequence", "Value"], "Number"],
           simplify: (ce, ops2) => {
             if (ops2.length === 0)
               return ce._NEGATIVE_INFINITY;
@@ -20106,6 +20267,125 @@ ${js}`);
     }
   };
 
+  // src/compute-engine/library/complex.ts
+  var COMPLEX_LIBRARY = [
+    {
+      Real: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", "Number", "Number"],
+          evaluate: (ce, ops2) => {
+            const op3 = ops2[0].numericValue;
+            if (op3 === null)
+              return void 0;
+            if (ce.isComplex(op3))
+              return ce.number(op3.re);
+            return ops2[0];
+          }
+        }
+      },
+      Imaginary: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", "Number", "Number"],
+          evaluate: (ce, ops2) => {
+            const op3 = ops2[0].numericValue;
+            if (op3 === null)
+              return void 0;
+            if (ce.isComplex(op3))
+              return ce.number(op3.im);
+            return ce._ZERO;
+          }
+        }
+      },
+      Argument: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", "Number", "Number"],
+          evaluate: (ce, ops2) => {
+            const op3 = ops2[0].numericValue;
+            if (op3 === null)
+              return void 0;
+            if (ce.isComplex(op3))
+              return ce.number(op3.arg());
+            const f = asFloat(ops2[0]);
+            if (f === null)
+              return void 0;
+            if (f >= 0)
+              return ce.number(0);
+            return ce.number(Math.PI);
+          }
+        }
+      },
+      AbsArg: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", "Number", "Tuple"],
+          evaluate: (ce, ops2) => {
+            const op3 = ops2[0].numericValue;
+            if (op3 === null)
+              return void 0;
+            if (ce.isComplex(op3))
+              return ce.tuple([ce.number(op3.abs()), ce.number(op3.arg())]);
+            const f = asFloat(ops2[0]);
+            if (f === null)
+              return void 0;
+            return ce.tuple([
+              ce.number(Math.abs(f)),
+              ce.number(f >= 0 ? 0 : Math.PI)
+            ]);
+          }
+        }
+      },
+      Conjugate: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", "Number", "Number"],
+          evaluate: (ce, ops2) => {
+            const op3 = ops2[0].numericValue;
+            if (op3 === null || !ce.isComplex(op3))
+              return void 0;
+            return ce.number(op3.conjugate());
+          }
+        }
+      },
+      ComplexRoots: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", "Number", "Number", "List"],
+          evaluate: (ce, ops2) => {
+            const x = asFloat(ops2[0]);
+            const n = asFloat(ops2[1]);
+            if (x === null || n === null || !Number.isInteger(n) || n <= 0)
+              return void 0;
+            const roots = [];
+            const [re, im] = ce.isComplex(x) ? [x.re, x.im] : [x, 0];
+            const arg = Math.atan2(im, re);
+            const mod2 = Math.sqrt(re * re + im * im);
+            for (let k = 0; k < n; k++) {
+              const theta = (arg + 2 * Math.PI * k) / n;
+              const r = Math.pow(mod2, 1 / n);
+              roots.push([r * Math.cos(theta), r * Math.sin(theta)]);
+            }
+            return ce.box([
+              "List",
+              ...roots.map(
+                (r) => ce.number(r[1] !== 0 ? ce.complex(r[0], r[1]) : r[0])
+              )
+            ]);
+          }
+        }
+      }
+      // For Abs (magnitude) see src/compute-engine/library/processAbs
+    }
+  ];
+
   // src/compute-engine/library/random-expression.ts
   function oneOf(xs) {
     return xs[Math.floor(Math.random() * xs.length)];
@@ -21604,6 +21884,328 @@ ${js}`);
     return ce._fn("Element", [lhs, rhs]);
   }
 
+  // src/compute-engine/library/statistics.ts
+  var STATISTICS_LIBRARY = [
+    {
+      Mean: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            let sum2 = 0;
+            let count = 0;
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              sum2 += v;
+              count++;
+            }
+            if (count === 0)
+              return ce._NAN;
+            return ce.number(sum2 / count);
+          }
+        }
+      },
+      Median: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            const values = [];
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              values.push(v);
+            }
+            if (values.length === 0)
+              return ce._NAN;
+            values.sort((a, b) => a - b);
+            const mid = Math.floor(values.length / 2);
+            if (values.length % 2 === 0)
+              return ce.number((values[mid - 1] + values[mid]) / 2);
+            return ce.number(values[mid]);
+          }
+        }
+      },
+      Variance: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            let sum2 = 0;
+            let sum22 = 0;
+            let count = 0;
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              sum2 += v;
+              sum22 += v * v;
+              count++;
+            }
+            if (count === 0)
+              return ce._NAN;
+            return ce.number((sum22 - sum2 * sum2 / count) / (count - 1));
+          }
+        }
+      },
+      StandardDeviation: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            let sum2 = 0;
+            let sum22 = 0;
+            let count = 0;
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              sum2 += v;
+              sum22 += v * v;
+              count++;
+            }
+            if (count === 0)
+              return ce._NAN;
+            return ce.number(
+              Math.sqrt((sum22 - sum2 * sum2 / count) / (count - 1))
+            );
+          }
+        }
+      },
+      Kurtosis: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            let sum2 = 0;
+            let sum22 = 0;
+            let sum4 = 0;
+            let count = 0;
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              sum2 += v;
+              sum22 += v * v;
+              sum4 += v * v * v * v;
+              count++;
+            }
+            if (count === 0)
+              return ce._NAN;
+            const s2 = (sum22 - sum2 * sum2 / count) / (count - 1);
+            const s4 = (sum4 - sum22 * sum22 / count) / (count - 1);
+            return ce.number((s4 / (s2 * s2) - 3) * (count * (count + 1)) / 6);
+          }
+        }
+      },
+      Skewness: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            let sum2 = 0;
+            let sum22 = 0;
+            let sum3 = 0;
+            let count = 0;
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              sum2 += v;
+              sum22 += v * v;
+              sum3 += v * v * v;
+              count++;
+            }
+            if (count === 0)
+              return ce._NAN;
+            const s2 = (sum22 - sum2 * sum2 / count) / (count - 1);
+            const s3 = (sum3 - sum22 * sum2 / count) / (count - 1);
+            return ce.number(s3 / Math.pow(s2, 3 / 2) * Math.sqrt(count * 1));
+          }
+        }
+      },
+      Mode: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            const values = [];
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              values.push(v);
+            }
+            if (values.length === 0)
+              return ce._NAN;
+            values.sort((a, b) => a - b);
+            const counts = {};
+            for (const v of values) {
+              counts[v] = (counts[v] ?? 0) + 1;
+            }
+            let max2 = 0;
+            let mode = values[0];
+            for (const v of values) {
+              const c = counts[v];
+              if (c > max2) {
+                max2 = c;
+                mode = v;
+              }
+            }
+            return ce.number(mode);
+          }
+        }
+      },
+      Quartiles: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "List"],
+          evaluate: (ce, ops2) => {
+            const values = [];
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              values.push(v);
+            }
+            if (values.length === 0)
+              return ce._NAN;
+            values.sort((a, b) => a - b);
+            const mid = Math.floor(values.length / 2);
+            const lower = values.slice(0, mid);
+            const upper = values.slice(mid + 1);
+            return ce.box([
+              "List",
+              ce.number(values[mid]),
+              ce.number(lower[Math.floor(lower.length / 2)]),
+              ce.number(upper[Math.floor(upper.length / 2)])
+            ]);
+          }
+        }
+      },
+      InterquartileRange: {
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            const values = [];
+            for (const op3 of each(ops2)) {
+              const v = asFloat(op3);
+              if (v === null)
+                return void 0;
+              values.push(v);
+            }
+            if (values.length === 0)
+              return ce._NAN;
+            values.sort((a, b) => a - b);
+            const mid = Math.floor(values.length / 2);
+            const lower = values.slice(0, mid);
+            const upper = values.slice(mid + 1);
+            return ce.number(
+              upper[Math.floor(upper.length / 2)] - lower[Math.floor(lower.length / 2)]
+            );
+          }
+        }
+      },
+      Count: {
+        threadable: true,
+        complexity: 1200,
+        signature: {
+          domain: ["Function", ["Sequence", "Value"], "Number"],
+          evaluate: (ce, ops2) => {
+            let count = 0;
+            for (const _op of each(ops2))
+              count++;
+            return ce.number(count);
+          }
+        }
+      },
+      Erf: {
+        complexity: 7500,
+        signature: {
+          domain: ["Function", "Number", "Number"],
+          evaluate: (ce, ops2) => {
+            const x = asFloat(ops2[0]);
+            if (x === null)
+              return void 0;
+            return ce.number(erf(x));
+          }
+        }
+      },
+      Erfc: {
+        complexity: 7500,
+        signature: {
+          domain: ["Function", "Number", "Number"],
+          evaluate: (ce, ops2) => {
+            const x = asFloat(ops2[0]);
+            if (x === null)
+              return void 0;
+            return ce.number(1 - erf(x));
+          }
+        }
+      }
+    }
+  ];
+  function* each(ops2) {
+    if (ops2.length === 0)
+      return;
+    const ce = ops2[0].engine;
+    for (const op3 of ops2) {
+      const h = op3.head;
+      if (h === "Range") {
+        let lower = asFloat(op3[1]);
+        if (lower === null)
+          return;
+        let upper = asFloat(op3[2]);
+        if (upper === null) {
+          upper = lower;
+          lower = 1;
+        }
+        if (lower > upper) {
+          const step2 = asFloat(op3[3] ?? -1) ?? -1;
+          if (step2 >= 0)
+            return;
+          for (let i = lower; i <= upper; i += step2)
+            yield ce.number(i);
+          return;
+        }
+        const step = asFloat(op3[3] ?? 1) ?? 1;
+        if (step <= 0)
+          return;
+        for (let i = lower; i <= upper; i += step)
+          yield ce.number(i);
+        return;
+      }
+      if (h === "Linspace") {
+        let start = asFloat(op3[1]);
+        if (start === null)
+          return;
+        let stop = asFloat(op3[2]);
+        if (stop === null) {
+          stop = start;
+          start = 0;
+        }
+        const num = asFloat(op3[3]) ?? 50;
+        if (!Number.isInteger(num))
+          return;
+        if (num <= 0)
+          return;
+        const step = (stop - start) / (num - 1);
+        for (let i = start; i <= stop; i += step)
+          yield ce.number(i);
+        return;
+      }
+      if (typeof h === "string" && /^(List|Sequence|Tuple|Single|Pair|Triple)$/.test(h)) {
+        yield* each(op3.ops);
+        return;
+      }
+      yield op3;
+    }
+  }
+
   // src/compute-engine/library/trigonometry.ts
   var domainNumberToRealNumber = (_head) => {
     return ["Function", "Number", "ExtendedRealNumber"];
@@ -23170,7 +23772,7 @@ ${js}`);
     //   // - factor
     //   // - simplify
     // ],
-    "arithmetic": ARITHMETIC_LIBRARY,
+    "arithmetic": [...ARITHMETIC_LIBRARY, ...COMPLEX_LIBRARY],
     "calculus": CALCULUS_LIBRARY,
     "combinatorics": [],
     // @todo fibonacci, binomial, etc...
@@ -23231,15 +23833,7 @@ ${js}`);
         // unit: ['Divide', 'N', ['Square', 'A']],
       }
     },
-    "statistics": [],
-    // @todo statistics: [
-    //   // average
-    //   // mean
-    //   // variance = size(l) * stddev(l)^2 / (size(l) - 1)
-    //   // stddev
-    //   // median
-    //   // quantile
-    // ],
+    "statistics": STATISTICS_LIBRARY,
     "trigonometry": TRIGONOMETRY_LIBRARY,
     "units": []
   };
@@ -23295,7 +23889,7 @@ ${JSON.stringify(entry)}`
   }
 
   // src/compute-engine/cost-function.ts
-  var import_complex18 = __toESM(require_complex());
+  var import_complex19 = __toESM(require_complex());
   function numericCostFunction(n) {
     if (Number.isInteger(n) && n !== 0) {
       return Math.floor(Math.log2(Math.abs(n)) / Math.log2(10)) + (n > 0 ? 1 : 2);
@@ -23317,7 +23911,7 @@ ${JSON.stringify(entry)}`
         else
           return numericCostFunction(Number(num[0])) + numericCostFunction(Number(num[1])) + 1;
       }
-      if (num instanceof import_complex18.default)
+      if (num instanceof import_complex19.default)
         return numericCostFunction(num.re) + numericCostFunction(num.im) + 1;
       if (expr.isNumber)
         return 2;
@@ -24259,11 +24853,11 @@ ${JSON.stringify(entry)}`
       this._ONE = new BoxedNumber(this, 1);
       this._HALF = new BoxedNumber(this, [1, 2]);
       this._NEGATIVE_ONE = new BoxedNumber(this, -1);
-      this._I = new BoxedNumber(this, import_complex19.Complex.I);
+      this._I = new BoxedNumber(this, import_complex20.Complex.I);
       this._NAN = new BoxedNumber(this, Number.NaN);
       this._POSITIVE_INFINITY = new BoxedNumber(this, Number.POSITIVE_INFINITY);
       this._NEGATIVE_INFINITY = new BoxedNumber(this, Number.NEGATIVE_INFINITY);
-      this._COMPLEX_INFINITY = new BoxedNumber(this, import_complex19.Complex.INFINITY);
+      this._COMPLEX_INFINITY = new BoxedNumber(this, import_complex20.Complex.INFINITY);
       this.reset();
       this.context = {
         assumptions: new ExpressionMap(),
@@ -24501,7 +25095,7 @@ ${JSON.stringify(entry)}`
         return 0;
       if (n instanceof Decimal && n.abs().lte(this._bignumTolerance))
         return 0;
-      if (n instanceof import_complex19.Complex && Math.abs(n.re) <= this._tolerance && Math.abs(n.im) <= this._tolerance)
+      if (n instanceof import_complex20.Complex && Math.abs(n.re) <= this._tolerance && Math.abs(n.im) <= this._tolerance)
         return 0;
       return n;
     }
@@ -24515,13 +25109,13 @@ ${JSON.stringify(entry)}`
         a = a.toNumber();
       if (b instanceof Decimal)
         b = b.toNumber();
-      return new import_complex19.Complex(a, b);
+      return new import_complex20.Complex(a, b);
     }
     isBignum(a) {
       return a instanceof Decimal;
     }
     isComplex(a) {
-      return a instanceof import_complex19.Complex;
+      return a instanceof import_complex20.Complex;
     }
     get latexSyntax() {
       if (!this._latexSyntax)
@@ -24881,6 +25475,10 @@ ${JSON.stringify(entry)}`
       return canonicalPower(this, base, this._HALF, metadata);
     }
     pow(base, exponent, metadata) {
+      if (base.symbol === "ExponentialE" && exponent instanceof import_complex20.Complex && exponent.re === 0) {
+        const im = exponent.im;
+        return this.number(this.complex(Math.cos(im), Math.sin(im)));
+      }
       if (exponent instanceof AbstractBoxedExpression) {
         const num = exponent.numericValue;
         if (num !== null) {
@@ -25062,14 +25660,15 @@ ${JSON.stringify(entry)}`
       const result = this.latexSyntax.parse(latexString(latex) ?? latex);
       return this.box(result, options);
     }
-    serialize(x) {
+    serialize(x, options) {
       if (typeof x === "object" && "json" in x) {
         const ce = "engine" in x ? x.engine : this;
         return this.latexSyntax.serialize(
-          this.rawJson(ce.box(x, { canonical: false }))
+          this.rawJson(ce.box(x, { canonical: false })),
+          options
         );
       }
-      return this.latexSyntax.serialize(x);
+      return this.latexSyntax.serialize(x, options);
     }
     get latexOptions() {
       const latexSyntax = this.latexSyntax;
@@ -25230,10 +25829,10 @@ ${JSON.stringify(entry)}`
   };
 
   // src/compute-engine.ts
-  var version = "0.14.0";
+  var version = "0.15.0";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.14.0"
+    version: "0.15.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();