@cortex-js/compute-engine 0.12.6 → 0.13.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.12.6 */
+/** CortexJS Compute Engine 0.13.0 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3949,6 +3949,14 @@ function symbol(expr) {
     return null;
   return s;
 }
+function isListLike(expr) {
+  if (expr === null)
+    return false;
+  const h = head(expr);
+  if (!h || typeof h !== "string")
+    return false;
+  return /^(List|Sequence|Tuple|Single|Pair|Triple)$/.test(h);
+}
 function keyValuePair(expr) {
   const h = head(expr);
   if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
@@ -4584,6 +4592,10 @@ var DEFINITIONS_ARITHMETIC = [
     parse: "ExponentialE",
     serialize: "\\exponentialE"
   },
+  {
+    trigger: "\\mathrm{e}",
+    parse: "ExponentialE"
+  },
   {
     kind: "function",
     trigger: "exp",
@@ -4597,6 +4609,10 @@ var DEFINITIONS_ARITHMETIC = [
     name: "ImaginaryUnit",
     trigger: ["\\imaginaryI"]
   },
+  {
+    trigger: "\\mathrm{i}",
+    parse: "ImaginaryUnit"
+  },
   // Operations
   {
     /** Could be the determinant if the argument is a matrix */
@@ -5156,7 +5172,7 @@ function parseSequence(parser, terminator, lhs, prec, sep) {
   }
   return result;
 }
-function serializeSequence(sep = "") {
+function serializeOps(sep = "") {
   return (serializer, expr) => (ops(expr) ?? []).map((x) => serializer.serialize(x)).join(sep);
 }
 var DEFINITIONS_CORE = [
@@ -5224,22 +5240,19 @@ var DEFINITIONS_CORE = [
         return "";
       const style = serializer.options.groupStyle(expr, serializer.level + 1);
       const arg1 = op(expr, 1);
-      if (argCount === 1)
-        return serializer.wrapString(serializer.serialize(arg1), style);
-      let sep = "";
-      let open = "";
-      let close = "";
+      const h1 = head(arg1);
+      const defaultFence = { List: "[],", Sequence: "" }[typeof h1 === "string" ? h1 : ""] ?? "(),";
+      let open = defaultFence[0] ?? "";
+      let close = defaultFence[1] ?? "";
+      let sep = defaultFence[2] ?? "";
       if (argCount > 1) {
         const op22 = stringValue(op(expr, 2)) ?? "";
-        open = op22[0] ?? "(";
-        close = op22[1] ?? ")";
-        sep = op22[2] ?? ",";
+        open = op22[0] ?? defaultFence[0];
+        close = op22[1] ?? defaultFence[1];
+        sep = op22[2] ?? defaultFence[2];
       }
-      const body = head(arg1) === "List" ? serializeSequence(sep)(serializer, arg1) : serializer.serialize(arg1);
-      serializer.wrapString(body, style, stringValue(op(expr, 2)) ?? void 0);
-      if (!open || !close)
-        return serializer.wrapString(body, style);
-      return `${open} ${body} ${close}`;
+      const body = isListLike(arg1) ? serializeOps(sep)(serializer, arg1) : serializer.serialize(arg1);
+      return serializer.wrapString(body, style, open + close);
     }
   },
   {
@@ -5340,7 +5353,7 @@ var DEFINITIONS_CORE = [
     serialize: (serializer, expr) => {
       return joinLatex([
         "\\lbrack",
-        serializeSequence(", ")(serializer, expr),
+        serializeOps(", ")(serializer, expr),
         "\\rbrack"
       ]);
     }
@@ -5378,7 +5391,7 @@ var DEFINITIONS_CORE = [
   },
   {
     name: "Sequence",
-    serialize: serializeSequence("")
+    serialize: serializeOps("")
   },
   {
     trigger: [";"],
@@ -5508,24 +5521,17 @@ var DEFINITIONS_CORE = [
       return result;
     },
     serialize: (serialize2, expr) => {
-      if (head(op(expr, 1)) !== "List")
-        return "";
-      const rows = ops(op(expr, 1)) ?? [];
-      const body = [];
-      let rowSep = "";
-      for (const row of rows) {
-        if (head(row) === "Tuple" || head(row) === "Pair") {
-          body.push(rowSep);
-          if (op(row, 2)) {
-            body.push(serialize2.serialize(op(row, 2)));
-            const condition = op(row, 1);
-            if (condition !== null)
-              body.push("&", serialize2.serialize(condition));
-          }
+      const rows = [];
+      const args = ops(expr);
+      if (args) {
+        for (let i = 0; i <= args.length - 2; i += 2) {
+          const row = [];
+          row.push(serialize2.serialize(args[i + 1]));
+          row.push(serialize2.serialize(args[i]));
+          rows.push(row.join("&"));
         }
-        rowSep = "\\\\";
       }
-      return joinLatex(["\\begin{cases}", ...body, "\\end{cases}"]);
+      return joinLatex(["\\begin{cases}", rows.join("\\\\"), "\\end{cases}"]);
     }
   }
 ];
@@ -7427,11 +7433,6 @@ var DEFAULT_DELIMITER = {
   "\\rceil": "\\rceil",
   "\\rfloor": "\\rfloor"
 };
-function triggerLength(trigger) {
-  if (Array.isArray(trigger))
-    return trigger.length;
-  return 1;
-}
 function addEntry(result, entry, onError) {
   const [trigger, indexedEntry] = makeIndexedEntry(entry, onError);
   if (indexedEntry === null)
@@ -7473,7 +7474,7 @@ function addEntry(result, entry, onError) {
   if (indexedEntry.kind === "matchfix") {
     result.matchfix.push(indexedEntry);
   } else if (indexedEntry.kind === "environment") {
-    const triggerString = tokensToString(entry.trigger ?? "");
+    const triggerString = tokensToString(entry.trigger ?? []);
     if (result.environment.has(triggerString)) {
       onError({
         severity: "warning",
@@ -7487,22 +7488,31 @@ function addEntry(result, entry, onError) {
     result.environment.set(triggerString, indexedEntry);
   } else if (trigger) {
     console.assert(entry.trigger);
-    const triggerString = tokensToString(entry.trigger ?? "");
-    const n = triggerLength(trigger);
-    result.lookahead = Math.max(result.lookahead, n);
     if (indexedEntry.kind === "function") {
-      if (!result.function.has(triggerString))
-        result.function.set(triggerString, [indexedEntry]);
+      console.assert(typeof entry.trigger === "string");
+      const fnName = entry.trigger;
+      if (!result.function.has(fnName))
+        result.function.set(fnName, [indexedEntry]);
       else
-        result.function.set(triggerString, [
-          ...result.function.get(triggerString),
+        result.function.set(fnName, [
+          ...result.function.get(fnName),
           indexedEntry
         ]);
     } else {
+      let triggerString;
+      let tokenCount;
+      if (typeof entry.trigger === "string") {
+        triggerString = entry.trigger;
+        tokenCount = countTokens(triggerString);
+      } else {
+        triggerString = tokensToString(entry.trigger ?? []);
+        tokenCount = entry.trigger.length;
+      }
+      result.lookahead = Math.max(result.lookahead, tokenCount);
       const kind2 = indexedEntry.kind;
-      if (result[kind2][n] === void 0)
-        result[kind2][n] = /* @__PURE__ */ new Map();
-      const list = result[kind2][n];
+      if (result[kind2][tokenCount] === void 0)
+        result[kind2][tokenCount] = /* @__PURE__ */ new Map();
+      const list = result[kind2][tokenCount];
       if (list.has(triggerString))
         list.get(triggerString).push(indexedEntry);
       else
@@ -7514,12 +7524,12 @@ function indexLatexDictionary(dic, onError) {
   const result = {
     lookahead: 1,
     name: /* @__PURE__ */ new Map(),
-    expression: /* @__PURE__ */ new Map(),
-    function: /* @__PURE__ */ new Map(),
+    expression: [],
     symbol: [],
     infix: [],
     prefix: [],
     postfix: [],
+    function: /* @__PURE__ */ new Map(),
     environment: /* @__PURE__ */ new Map(),
     matchfix: []
   };
@@ -7582,13 +7592,11 @@ function makeIndexedEntry(entry, onError) {
   if (result.kind === "expression" && isExpressionEntry(entry)) {
     result.serialize = entry.serialize ?? triggerString;
     if (typeof result.serialize === "string") {
-      const serializeExpr = result.serialize;
+      const serializeStr = result.serialize;
       result.serialize = (serializer, expr) => {
         if (!head(expr))
-          return serializer.serialize(serializeExpr);
-        return `${serializer.serialize(
-          serializeExpr
-        )}${serializer.wrapArguments(expr)}`;
+          return serializeStr;
+        return `${serializeStr}${serializer.wrapArguments(expr)}`;
       };
     }
     {
@@ -8335,7 +8343,7 @@ var _Parser = class {
       defs = this.lookAhead().map((x, n) => this._dictionary[kind][n]?.get(x));
     }
     const result = [];
-    for (let i = defs.length; i > 0; i--) {
+    for (let i = defs.length - 1; i > 0; i--) {
       if (defs[i] !== void 0) {
         console.assert(Array.isArray(defs[i]));
         for (const def of defs[i])
@@ -10089,14 +10097,16 @@ var Serializer = class {
   wrapString(s, style, fence) {
     if (style === "none")
       return s;
-    const openFence = fence?.[0] ?? "(";
-    const closeFence = fence?.[1] ?? ")";
+    if (fence === void 0)
+      fence = "()";
+    const openFence = fence?.[0] ?? ".";
+    const closeFence = fence?.[1] ?? ".";
     if ((openFence === "." || closeFence === ".") && style === "paren")
       style = "leftright";
     if (style === "leftright")
-      return `${openFence === "." ? "" : `\\left(${openFence}`}${s}${closeFence === "." ? "" : `\\right(${closeFence}`})`;
+      return `\\left${openFence}${s}\\right${closeFence}}`;
     if (style === "big")
-      return `${openFence === "." ? "" : `\\Bigl(${openFence}`}${s}${closeFence === "." ? "" : `\\Bigr(${closeFence}`})`;
+      return `${openFence === "." ? "" : `\\Bigl${openFence}`}${s}${closeFence === "." ? "" : `\\Bigr${closeFence}`})`;
     return openFence + s + closeFence;
   }
   wrapArguments(expr) {
@@ -10445,11 +10455,19 @@ var LatexSyntax = class _LatexSyntax {
       ...DEFAULT_SERIALIZE_LATEX_OPTIONS,
       ...opts
     };
+    this._dictionaryInput = options.dictionary ?? _LatexSyntax.getDictionary();
     this._dictionary = indexLatexDictionary(
-      options.dictionary ?? _LatexSyntax.getDictionary(),
+      this._dictionaryInput,
       (sig) => this.onError([sig])
     );
   }
+  get dictionary() {
+    return this._dictionaryInput;
+  }
+  set dictionary(val) {
+    this._dictionaryInput = val;
+    this._dictionary = indexLatexDictionary(val, (sig) => this.onError([sig]));
+  }
   updateOptions(opt) {
     for (const k of Object.keys(this.options))
       if (k in opt)
@@ -13141,6 +13159,246 @@ function domainSetsLibrary() {
 
 // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
 var import_complex6 = __toESM(require_complex());
+
+// src/compute-engine/compile.ts
+function compileToJavascript(expr) {
+  const js = compile(expr, expr.freeVars);
+  try {
+    return new Function("_", `return ${js}`);
+  } catch (e) {
+    console.error(`${e}
+${expr.latex}
+${js}`);
+  }
+  return void 0;
+}
+function compile(expr, freeVars = [], prec = 0) {
+  const f = asFloat(expr);
+  if (f !== null)
+    return f.toString();
+  const s = expr.symbol;
+  if (s !== null) {
+    const result = {
+      True: "true",
+      False: "false",
+      Pi: "Math.PI",
+      ExponentialE: "Math.E",
+      I: "Math.I",
+      NaN: "Number.NaN",
+      ImaginaryUnit: "NaN"
+    }[s];
+    if (result !== void 0)
+      return result;
+    if (freeVars.includes(s))
+      return `_.${s}`;
+    return s;
+  }
+  const str = expr.string;
+  if (str !== null)
+    return JSON.stringify(str);
+  const keys = expr.keys;
+  if (keys !== null) {
+    const result = [];
+    for (const key of keys) {
+      const value = expr.getKey(key);
+      if (value)
+        result.push(`${key}: ${compile(value, freeVars, 0)}`);
+    }
+    return `{${result.join(", ")}}`;
+  }
+  const h = expr.head;
+  if (typeof h === "string") {
+    if (h === "Negate") {
+      const arg = expr.op1;
+      if (arg === null)
+        return "";
+      return `-${compile(arg, freeVars, 3)}`;
+    }
+    if (h === "Error") {
+      return "NaN";
+    }
+    if (h === "Sum")
+      return compileLoop(expr, "+");
+    if (h === "Product")
+      return compileLoop(expr, "*");
+    if (h === "Root") {
+      const arg = expr.op1;
+      if (arg === null)
+        return "";
+      const exp2 = expr.op2;
+      if (exp2 === null)
+        return `Math.sqrt(${compile(arg, freeVars, 0)})`;
+      return `Math.pow(${compile(arg, freeVars)}, 1/${compile(exp2, freeVars)}`;
+    }
+    if (h === "Factorial") {
+      const arg = expr.op1;
+      if (arg === null)
+        return "";
+      return `${compile(arg, freeVars, 3)}!`;
+    }
+    const OPS = {
+      Add: ["+", 1],
+      Subtract: ["-", 1],
+      Multiply: ["*", 2],
+      Divide: ["/", 3]
+    };
+    const op3 = OPS[h];
+    if (op3 !== void 0) {
+      const args2 = expr.ops;
+      if (args2 === null)
+        return "";
+      const result = [];
+      for (const arg of args2)
+        result.push(compile(arg, freeVars, op3[1]));
+      return op3[1] < prec ? `(${result.join(op3[0])})` : result.join(op3[0]);
+    }
+    const fn = {
+      Abs: "Math.abs",
+      Arccos: "Math.acos",
+      Arcosh: "Math.acosh",
+      Arsin: "Math.asin",
+      Arsinh: "Math.asinh",
+      Arctan: "Math.atan",
+      Artanh: "Math.atanh",
+      // Math.cbrt
+      Ceiling: "Math.ceil",
+      Cos: "Math.cos",
+      Cosh: "Math.cosh",
+      Exp: "Math.exp",
+      Floor: "Math.floor",
+      // Math.hypot
+      Ln: "Math.log",
+      Log: "Math.log10",
+      Lb: "Math.log2",
+      Max: "Math.max",
+      Min: "Math.min",
+      Power: "Math.pow",
+      Random: "Math.random",
+      Round: "Math.round",
+      Sgn: "Math.sign",
+      Sin: "Math.sin",
+      Sinh: "Math.sinh",
+      Sqrt: "Math.sqrt",
+      Tan: "Math.tan",
+      Tanh: "Math.tanh"
+      // Factorial: 'factorial',    // TODO: implement
+      // Hallucinated by Copilot, but interesting ideas...
+      // Cot: 'Math.cot',
+      // Sec: 'Math.sec',
+      // Csc: 'Math.csc',
+      // ArcCot: 'Math.acot',
+      // ArcSec: 'Math.asec',
+      // ArcCsc: 'Math.acsc',
+      // Coth: 'Math.coth',
+      // Sech: 'Math.sech',
+      // Csch: 'Math.csch',
+      // ArcCoth: 'Math.acoth',
+      // ArcSech: 'Math.asech',
+      // ArcCsch: 'Math.acsch',
+      // Root: 'Math.root',
+      // Gamma: 'Math.gamma',
+      // Erf: 'Math.erf',
+      // Erfc: 'Math.erfc',
+      // Erfi: 'Math.erfi',
+      // Zeta: 'Math.zeta',
+      // PolyGamma: 'Math.polygamma',
+      // HurwitzZeta: 'Math.hurwitzZeta',
+      // DirichletEta: 'Math.dirichletEta',
+      // Beta: 'Math.beta',
+      // Binomial: 'Math.binomial',
+      // Mod: 'Math.mod',
+      // Quotient: 'Math.quotient',
+      // GCD: 'Math.gcd',
+      // LCM: 'Math.lcm',
+      // Divisors: 'Math.divisors',
+      // PrimeQ: 'Math.isPrime',
+      // PrimePi: 'Math.primePi',
+      // Prime: 'Math.prime',
+      // NextPrime: 'Math.nextPrime',
+      // PreviousPrime: 'Math.prevPrime',
+      // PrimePowerQ: 'Math.isPrimePower',
+      // PrimePowerPi: 'Math.primePowerPi',
+      // PrimePower: 'Math.primePower',
+      // NextPrimePower: 'Math.nextPrimePower',
+      // PreviousPrimePower: 'Math.prevPrimePower',
+      // PrimeFactors: 'Math.primeFactors',
+      // DivisorSigma: 'Math.divisorSigma',
+      // DivisorSigma0: 'Math.divisorSigma0',
+      // DivisorSigma1: 'Math.divisorSigma1',
+      // DivisorSigma2: 'Math.divisorSigma2',
+      // DivisorSigma3: 'Math.divisorSigma3',
+      // DivisorSigma4: 'Math.divisorSigma4',
+      // DivisorCount: 'Math.divisorCount',
+      // DivisorSum: 'Math.divisorSum',
+      // MoebiusMu: 'Math.moebiusMu',
+      // LiouvilleLambda: 'Math.liouvilleLambda',
+      // CarmichaelLambda: 'Math.carmichaelLambda',
+      // EulerPhi: 'Math.eulerPhi',
+      // EulerPsi: 'Math.eulerPsi',
+      // EulerGamma: 'Math.eulerGamma',
+      // HarmonicNumber: 'Math.harmonicNumber',
+      // BernoulliB: 'Math.bernoulliB',
+      // StirlingS1: 'Math.stirlingS1',
+      // StirlingS2: 'Math.stirlingS2',
+      // BellB: 'Math.bellB',
+      // BellNumber: 'Math.bellNumber',
+      // LahS: 'Math.lahS',
+      // LahL: 'Math.lahL',
+      // RiemannR: 'Math.riemannR',
+      // RiemannZeta: 'Math.riemannZeta',
+      // RiemannXi: 'Math.riemannXi',
+      // RiemannH: 'Math.riemannH',
+      // RiemannZ: 'Math.riemannZ',
+      // RiemannS: 'Math.riemannS',
+      // RiemannXiZero: 'Math.riemannXiZero',
+      // RiemannZetaZero: 'Math.riemannZetaZero',
+      // RiemannHZero: 'Math.riemannHZero',
+      // RiemannSZero: 'Math.riemannSZero',
+      // RiemannPrimeCount: 'Math.riemannPrimeCount',
+      // RiemannRLog: 'Math.riemannRLog',
+      // RiemannRLogDerivative: 'Math.riemannRLogDerivative',
+      // RiemannRLogZero: 'Math.riemannRLogZero',
+      // RiemannRLogZeroDerivative: 'Math.riemannRLogZeroDerivative',
+      // RiemannRZero: 'Math.riemannRZero',
+      // RiemannRDerivative: 'Math.riemannRDerivative',
+      // RiemannXiZeroDerivative: 'Math.riemannXiZeroDerivative',
+      // RiemannZetaZeroDerivative: 'Math.riemannZetaZeroDerivative',
+      // RiemannHZeroDerivative: 'Math.riemannHZeroDerivative',
+      // RiemannSZeroDerivative: 'Math.riemannSZeroDerivative',
+      // RiemannSZeroDerivative2: 'Math.riemannSZeroDerivative2',
+      // RiemannSZeroDerivative3: 'Math.riemannSZeroDerivative3',
+      // RiemannSZeroDerivative4: 'Math.riemannSZeroDerivative4',
+      // RiemannSZeroDerivative5: 'Math.riemannSZeroDerivative5',
+      // RiemannSZeroDerivative6: 'Math.riemannSZeroDerivative6',
+    }[h] ?? h;
+    const args = expr.ops;
+    if (args !== null) {
+      const result = [];
+      for (const arg of args)
+        result.push(compile(arg, freeVars, 0));
+      return `${fn}(${result.join(", ")})`;
+    }
+  }
+  return "";
+}
+function compileLoop(expr, op3) {
+  const args = expr.ops;
+  if (args === null)
+    return "NaN";
+  if (!expr.op1 || !expr.op2)
+    return "NaN";
+  const [index, lower, upper, isFinite2] = normalizeLimits(expr.op2);
+  const fn = compile(expr.op1, [...expr.op1.freeVars, index], 0);
+  return `((_) => {
+    let acc = ${op3 === "+" ? "0" : "1"};
+    const fn = (_) => ${fn};
+    for (let i = ${lower}; i < ${upper}; i++)
+      acc ${op3}= fn({ ..._, ${index}: i });
+    return acc;
+  })()`;
+}
+
+// src/compute-engine/boxed-expression/abstract-boxed-expression.ts
 var AbstractBoxedExpression = class {
   constructor(ce, metadata) {
     this.engine = ce;
@@ -13465,6 +13723,9 @@ var AbstractBoxedExpression = class {
   N(_options) {
     return this.evaluate();
   }
+  compile() {
+    return compileToJavascript(this);
+  }
 };
 
 // src/compute-engine/boxed-expression/serialize.ts
@@ -14927,7 +15188,7 @@ function validateNumericArgs(ce, ops2, count) {
     }
   }
   return xs.map(
-    (op3) => !op3.isValid || op3.isNumber ? op3 : ce.error(["incompatible-domain", "Number", op3.domain], op3)
+    (op3) => op3 && !op3.isValid || op3.isNumber ? op3 : ce.error(["incompatible-domain", "Number", op3.domain], op3)
   );
 }
 function validateSignature(sig, ops2, codomain) {
@@ -15635,7 +15896,6 @@ var UNIVARIATE_ROOTS = [
   // ],
 ];
 function findUnivariateRoots(expr, x) {
-  console.log("findUnivariateRoots", expr.toString(), x);
   const ce = expr.engine;
   if (expr.head === "Equal") {
     expr = ce.add([expr.op1.canonical, ce.neg(expr.op2.canonical)]).simplify();
@@ -19574,6 +19834,18 @@ function randomExpression(level) {
   level ?? (level = 1);
   if (level === 1) {
     const h = oneOf([
+      [
+        "Sqrt",
+        [
+          "Multiply",
+          6,
+          [
+            "Sum",
+            ["Divide", 1, ["Power", "n", 2]],
+            ["Triple", ["Hold", "n"], 1, { num: "+Infinity" }]
+          ]
+        ]
+      ],
       "Add",
       "Add",
       "Add",
@@ -19592,13 +19864,16 @@ function randomExpression(level) {
       "Negate",
       "trig"
     ]);
-    return randomExpressionWithHead(h, 1);
+    if (typeof h === "string")
+      return randomExpressionWithHead(h, 1);
+    return h;
   }
   if (level === 2) {
-    if (Math.random() > 0.5)
-      return randomExpression(3);
-    if (Math.random() > 0.75)
+    const r = Math.random();
+    if (r > 0.75)
       return randomExpression(1);
+    if (r > 0.5)
+      return randomExpression(3);
     const h = oneOf([
       "Multiply",
       "Multiply",
@@ -19652,7 +19927,7 @@ function randomExpression(level) {
     ["Rational", 12, 15],
     ["Rational", 15, 12],
     "ExponentialE",
-    "ImaginaryUnit",
+    // 'ImaginaryUnit',
     ["Sqrt", 3],
     ["Sqrt", 5],
     ["Sqrt", 15],
@@ -19670,8 +19945,8 @@ function randomExpression(level) {
     ["Power", "x", 4],
     ["Subtract", "x", 1],
     ["Add", "x", 1],
-    "a",
-    "b",
+    // 'a',
+    // 'b',
     "Pi"
   ]);
 }
@@ -23717,6 +23992,12 @@ var ComputeEngine = class _ComputeEngine {
   static getStandardLibrary(categories = "all") {
     return getStandardLibrary(categories);
   }
+  get latexDictionary() {
+    return this.latexSyntax.dictionary;
+  }
+  set latexDictionary(dic) {
+    this.latexSyntax.dictionary = dic;
+  }
   /** After the configuration of the engine has changed, clear the caches
    * so that new values can be recalculated.
    *
@@ -23911,6 +24192,10 @@ var ComputeEngine = class _ComputeEngine {
     return new this._bignum(a);
   }
   complex(a, b) {
+    if (a instanceof Decimal)
+      a = a.toNumber();
+    if (b instanceof Decimal)
+      b = b.toNumber();
     return new import_complex19.Complex(a, b);
   }
   isBignum(a) {
@@ -24606,10 +24891,10 @@ var ComputeEngine = class _ComputeEngine {
 };
 
 // src/compute-engine.ts
-var version = "0.12.6";
+var version = "0.13.0";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.12.6"
+  version: "0.13.0"
 };
 export {
   ComputeEngine,