@cortex-js/compute-engine 0.14.0 → 0.15.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.14.0 */
+/** CortexJS Compute Engine 0.15.0 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3405,7 +3405,7 @@ PI = new Decimal(PI);
 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) {
@@ -4269,7 +4269,7 @@ function serializeAdd(serializer, expr) {
   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);
@@ -4330,21 +4330,23 @@ function serializeMultiply(serializer, expr) {
     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) {
@@ -4465,7 +4467,7 @@ function serializeFraction(serializer, expr) {
     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);
@@ -4504,25 +4506,27 @@ function serializePower(serializer, expr) {
       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) + "}";
@@ -5366,15 +5370,9 @@ var DEFINITIONS_CORE = [
   {
     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",
@@ -5383,20 +5381,31 @@ var DEFINITIONS_CORE = [
       ]);
     }
   },
+  // 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: [","],
@@ -5469,9 +5478,7 @@ var DEFINITIONS_CORE = [
     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",
@@ -5753,6 +5760,23 @@ function parsePrime(parser, lhs, order2) {
     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 = [
@@ -7681,6 +7705,59 @@ var DEFINITIONS_SYMBOLS = [
   })
 ];
 
+// 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 = {
   "(": "(",
@@ -7870,7 +7947,7 @@ function makeParseHandler(entry, latexTrigger, idTrigger) {
     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();
@@ -7880,7 +7957,7 @@ function makeParseHandler(entry, latexTrigger, idTrigger) {
       };
   }
   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);
@@ -7888,12 +7965,12 @@ function makeParseHandler(entry, latexTrigger, idTrigger) {
       };
   }
   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) => {
@@ -7919,7 +7996,7 @@ function makeParseHandler(entry, latexTrigger, idTrigger) {
         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)
@@ -7944,7 +8021,7 @@ function makeParseHandler(entry, latexTrigger, idTrigger) {
       };
   }
   if (kind === "expression") {
-    const parseResult = entry.parse ?? idTrigger ?? entry.name;
+    const parseResult = entry.parse ?? entry.name ?? idTrigger;
     if (parseResult)
       return () => parseResult;
   }
@@ -7965,6 +8042,16 @@ function isValidEntry(entry, onError) {
   }
   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",
@@ -8131,6 +8218,7 @@ 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,
@@ -8143,6 +8231,7 @@ var DEFAULT_LATEX_DICTIONARY = {
     }
   ],
   sets: DEFINITIONS_SETS,
+  statistics: DEFINITIONS_STATISTICS,
   symbols: DEFINITIONS_SYMBOLS,
   trigonometry: DEFINITIONS_TRIGONOMETRY
 };
@@ -8666,7 +8755,7 @@ var _Parser = class {
     }
     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]);
       }
@@ -8809,6 +8898,65 @@ var _Parser = class {
     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();
@@ -9265,6 +9413,8 @@ var _Parser = class {
    * 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;
@@ -9379,42 +9529,20 @@ var _Parser = class {
     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;
@@ -10001,7 +10129,7 @@ var _Parser = class {
     }
   }
 };
-function peekComplexId(parser, id) {
+function parseComplexId(parser, id) {
   const start = parser.index;
   const candidate = parseIdentifier(parser)?.trim();
   if (candidate === null)
@@ -10270,6 +10398,7 @@ var Serializer = class {
     }
     this.onError = onError;
     this.dictionary = dictionary2;
+    this.canonical = void 0;
   }
   updateOptions(opt) {
     for (const k of Object.keys(this.options))
@@ -10389,9 +10518,16 @@ var Serializer = class {
       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 = (() => {
@@ -10428,10 +10564,12 @@ var Serializer = class {
         ]);
       })();
       this.level -= 1;
+      this.canonical = savedCanonical;
       return result ?? "";
     } catch (e) {
     }
     this.level -= 1;
+    this.canonical = savedCanonical;
     return "";
   }
   applyFunctionStyle(expr, level) {
@@ -10769,8 +10907,8 @@ var LatexSyntax = class _LatexSyntax {
     }
     return expr ?? ["Sequence"];
   }
-  serialize(expr) {
-    return this.serializer.serialize(expr);
+  serialize(expr, options) {
+    return this.serializer.serialize(expr, options);
   }
   get serializer() {
     if (this._serializer)
@@ -12103,6 +12241,19 @@ function chop(n, tolerance) {
     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) {
@@ -18930,6 +19081,24 @@ function multiply2(op12, op22, metadata) {
   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,
@@ -19345,14 +19514,6 @@ var ARITHMETIC_LIBRARY = [
         }
       }
     },
-    Erf: {
-      description: "Error Function",
-      complexity: 7500
-    },
-    Erfc: {
-      description: "Complementary Error Function",
-      complexity: 7500
-    },
     Factorial: {
       description: "Factorial Function",
       wikidata: "Q120976",
@@ -19497,7 +19658,7 @@ var ARITHMETIC_LIBRARY = [
       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;
@@ -19526,7 +19687,7 @@ var ARITHMETIC_LIBRARY = [
       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;
@@ -20084,6 +20245,125 @@ var COLLECTIONS_LIBRARY = {
   }
 };
 
+// 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)];
@@ -21582,6 +21862,328 @@ function evaluateElement(ce, ops2) {
   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"];
@@ -23148,7 +23750,7 @@ var LIBRARIES = {
   //   // - factor
   //   // - simplify
   // ],
-  "arithmetic": ARITHMETIC_LIBRARY,
+  "arithmetic": [...ARITHMETIC_LIBRARY, ...COMPLEX_LIBRARY],
   "calculus": CALCULUS_LIBRARY,
   "combinatorics": [],
   // @todo fibonacci, binomial, etc...
@@ -23209,15 +23811,7 @@ var LIBRARIES = {
       // 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": []
 };
@@ -23273,7 +23867,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);
@@ -23295,7 +23889,7 @@ function costFunction(expr) {
       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;
@@ -24237,11 +24831,11 @@ var ComputeEngine = class _ComputeEngine {
     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(),
@@ -24479,7 +25073,7 @@ var ComputeEngine = class _ComputeEngine {
       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;
   }
@@ -24493,13 +25087,13 @@ var ComputeEngine = class _ComputeEngine {
       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)
@@ -24859,6 +25453,10 @@ var ComputeEngine = class _ComputeEngine {
     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) {
@@ -25040,14 +25638,15 @@ var ComputeEngine = class _ComputeEngine {
     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;
@@ -25208,10 +25807,10 @@ var ComputeEngine = class _ComputeEngine {
 };
 
 // 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"
 };
 export {
   ComputeEngine,