@cortex-js/compute-engine 0.26.0 → 0.26.2

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.26.0 */
+/** Compute Engine 0.26.2 */
     (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 __defProp = Object.defineProperty;
@@ -4053,6 +4053,7 @@ Invalid type
   function parseType(s) {
     if (s === void 0) return void 0;
     if (isValidType(s)) return s;
+    if (typeof s !== "string") return void 0;
     if (PRIMITIVE_TYPES.includes(s)) return s;
     const parser = new TypeParser(s);
     return parser.parse();
@@ -4628,6 +4629,7 @@ Invalid type
   var ADDITION_PRECEDENCE = 275;
   var MULTIPLICATION_PRECEDENCE = 390;
   var DIVISION_PRECEDENCE = 600;
+  var EXPONENTIATION_PRECEDENCE = 700;
   var POSTFIX_PRECEDENCE = 810;
   function isExpressionEntry(entry) {
     return !("kind" in entry) || entry.kind === "expression";
@@ -6489,20 +6491,20 @@ Invalid type
     if (def === void 0 || def === null || typeof def !== "object")
       return false;
     if (isBoxedExpression(def)) return false;
-    if ("type" in def || "value" in def || "constant" in def) {
-      if (typeof def.type === "function") {
+    if ("value" in def || "constant" in def || "inferred" in def) {
+      if ("type" in def && typeof def.type === "function") {
         throw new Error(
-          "The type field of a symbol definition should be a type string"
+          "The `type` field of a symbol definition should be of type `string`"
         );
       }
       if ("signature" in def) {
         throw new Error(
-          "Symbol definition cannot have a signature field. Use a type field instead."
+          "Symbol definition cannot have a `signature` field. Use a `type` field instead."
         );
       }
       if ("sgn" in def) {
         throw new Error(
-          "Symbol definition cannot have a sgn field. Use a flags field instead."
+          "Symbol definition cannot have a `sgn` field. Use a `flags.sgn` field instead."
         );
       }
       return true;
@@ -6516,22 +6518,23 @@ Invalid type
     if ("signature" in def || "complexity" in def) {
       if ("constant" in def) {
         throw new Error(
-          "Function definition cannot have a constant field and symbol definition cannot have a signature field."
+          "Function definition cannot have a `constant` field and symbol definition cannot have a `signature` field."
         );
       }
-      if ("type" in def && typeof def.type !== "function") {
-        throw new Error(
-          "The type field of a function definition should be a function"
-        );
-      }
-      if ("sgn" in def && typeof def.sgn !== "function") {
-        throw new Error(
-          "The sgn field of a function definition should be a function"
-        );
-      }
-      return true;
     }
-    return false;
+    if (!("evaluate" in def) && !("signature" in def) && !("sgn" in def) && !("complexity" in def) && !("canonical" in def))
+      return false;
+    if ("type" in def && typeof def.type !== "function") {
+      throw new Error(
+        "The `type` field of a function definition should be a function"
+      );
+    }
+    if ("sgn" in def && typeof def.sgn !== "function") {
+      throw new Error(
+        "The `sgn` field of a function definition should be a function"
+      );
+    }
+    return true;
   }
   function semiCanonical(ce, xs) {
     if (!xs.every((x) => isBoxedExpression(x))) return xs.map((x) => ce.box(x));
@@ -7533,7 +7536,9 @@ Invalid type
     }
     return [value, ""];
   }
-  function numberToString(num) {
+  function numberToString(num, fractionalDigits) {
+    if (typeof fractionalDigits === "number" && typeof num === "number")
+      return num.toFixed(fractionalDigits);
     const numStr = num.toString();
     if (typeof num === "number" && Number.isInteger(num) && numStr.includes("e")) {
       const fixedStr = BigInt(num).toString();
@@ -7565,11 +7570,13 @@ Invalid type
     if (s === "-infinity") return null;
     return bigint(s);
   }
-  function numberToExpression(num) {
+  function numberToExpression(num, fractionalDigits) {
     if (typeof num === "number") {
       if (isNaN(num)) return "NaN";
       if (!Number.isFinite(num))
         return num < 0 ? "NegativeInfinity" : "PositiveInfinity";
+      if (typeof fractionalDigits === "number")
+        return { num: num.toFixed(fractionalDigits) };
       return num;
     }
     if (num >= Number.MIN_SAFE_INTEGER && num <= Number.MAX_SAFE_INTEGER)
@@ -7703,7 +7710,7 @@ Invalid type
       return result.mul(this.bignum(this.radical).sqrt());
     }
     get numerator() {
-      if (this.rational[1] === 1) return this;
+      if (this.rational[1] == 1) return this;
       return this.clone({
         rational: isMachineRational(this.rational) ? [this.rational[0], 1] : [this.rational[0], BigInt(1)],
         radical: this.radical
@@ -7745,10 +7752,10 @@ Invalid type
       return Number.isNaN(this.rational[0]);
     }
     get isPositiveInfinity() {
-      return this.rational[0] === Infinity;
+      return this.rational[0] == Infinity;
     }
     get isNegativeInfinity() {
-      return this.rational[0] === -Infinity;
+      return this.rational[0] == -Infinity;
     }
     get isComplexInfinity() {
       return false;
@@ -7890,7 +7897,7 @@ Invalid type
           exponent = { re: exponent.re, im: exponent.im };
         } else {
           if (exponent instanceof _ExactNumericValue) {
-            if (exponent.radical === 1 && exponent.rational[0] === 1)
+            if (exponent.radical === 1 && exponent.rational[0] == 1)
               return this.root(exponent.rational[0]);
           }
           exponent = exponent.re;
@@ -7972,7 +7979,7 @@ Invalid type
         return this.factory({ im: Math.pow(-this.re, 1 / exponent) });
       if (this.radical > SMALL_INTEGER || this.rational[0] > SMALL_INTEGER || this.rational[0] < -SMALL_INTEGER || this.rational[1] > SMALL_INTEGER)
         return this.factory(this.bignumRe).root(exponent);
-      if (this.rational[1] === 1) {
+      if (this.rational[1] == 1) {
         const root2 = Math.pow(this.rational[0], 1 / exponent);
         if (Number.isInteger(root2)) return this.clone(root2);
       }
@@ -8038,7 +8045,7 @@ Invalid type
     }
     eq(other) {
       if (typeof other === "number")
-        return this.radical === 1 && isInteger(this.rational) && this.rational[0] === other;
+        return this.radical === 1 && isInteger(this.rational) && this.rational[0] == other;
       if (other instanceof _ExactNumericValue) {
         return this.radical === other.radical && this.rational[0] == other.rational[0] && this.rational[1] == other.rational[1];
       }
@@ -8202,7 +8209,7 @@ Invalid type
   // src/compute-engine/boxed-expression/polynomials.ts
   function totalDegree(expr) {
     if (expr.symbol && !expr.isConstant) return 1;
-    if (expr.operator === "Power" && expr.op2.numericValue !== null) {
+    if (expr.operator === "Power" && expr.op2.isNumberLiteral) {
       if (totalDegree(expr.op1) === 0) return 0;
       const deg = asSmallInteger(expr.op2);
       if (deg !== null && deg > 0) return deg;
@@ -8227,7 +8234,7 @@ Invalid type
   }
   function maxDegree(expr) {
     if (expr.symbol && !expr.isConstant) return 1;
-    if (expr.operator === "Power" && expr.op2.numericValue !== null) {
+    if (expr.operator === "Power" && expr.op2.isNumberLiteral) {
       if (maxDegree(expr.op1) === 0) return 0;
       const deg = asSmallInteger(expr.op2);
       if (deg !== null && deg > 0) return deg;
@@ -9536,6 +9543,16 @@ Invalid type
   }
 
   // src/compute-engine/boxed-expression/negate.ts
+  function canonicalNegate(expr) {
+    let sign2 = -1;
+    while (expr.operator === "Negate") {
+      expr = expr.op1;
+      sign2 = -sign2;
+    }
+    if (sign2 === 1) return expr;
+    if (expr.isNumberLiteral) return expr.neg();
+    return expr.engine._fn("Negate", [expr]);
+  }
   function negate(expr) {
     let sign2 = -1;
     while (expr.operator === "Negate") {
@@ -9548,9 +9565,7 @@ Invalid type
     if (expr.operator === "Subtract") return expr.op2.sub(expr.op1);
     if (expr.operator === "Add") return add3(...expr.ops.map((x) => negate(x)));
     if (expr.operator === "Multiply") return negateProduct(ce, expr.ops);
-    if (expr.operator === "Divide") {
-      return negate(expr.op1).div(expr.op2);
-    }
+    if (expr.operator === "Divide") return negate(expr.op1).div(expr.op2);
     return ce._fn("Negate", [expr]);
   }
   function negateProduct(ce, args) {
@@ -13072,7 +13087,7 @@ Invalid type
         sgn: ([x]) => x.isNonNegative ? "positive" : x.isNegative || x.isReal === false ? "unsigned" : void 0,
         canonical: (args, { engine }) => {
           const x = args[0];
-          if (x.numericValue !== null && x.isNegative)
+          if (x.isNumberLiteral && x.isNegative)
             return engine._fn("Factorial", [x.neg()]).neg();
           return engine._fn("Factorial", [x]);
         },
@@ -18155,6 +18170,9 @@ ${e.message}`);
     fractionalPart += lastDigit;
     while (fractionalPart.endsWith("0"))
       fractionalPart = fractionalPart.slice(0, -1);
+    if (typeof options.fractionalDigits === "number") {
+      fractionalPart = fractionalPart.slice(0, options.fractionalDigits);
+    }
     if (exponent)
       return `${wholepart}.${fractionalPart}${exponent.toLowerCase()}`;
     return `${wholepart}.${fractionalPart}`;
@@ -18309,7 +18327,7 @@ ${e.message}`);
           metadata.latex = metadata.latex ?? ce.box({ num: value.toString() }).latex;
         if (metadata.latex !== void 0)
           return { num: value.toString(), latex: metadata.latex };
-        return shorthandAllowed ? numberToExpression(value) : { num: numberToString(value) };
+        return shorthandAllowed ? numberToExpression(value, options.fractionalDigits) : { num: numberToString(value, options.fractionalDigits) };
       }
     }
     let result;
@@ -18471,6 +18489,8 @@ ${e.message}`);
         }
         if (options.fractionalDigits === "auto")
           defaultOptions.fractionalDigits = -this.engine.precision;
+        if (typeof options.fractionalDigits === "number")
+          defaultOptions.fractionalDigits = options.fractionalDigits;
       }
       const opts = {
         ...defaultOptions,
@@ -18527,6 +18547,7 @@ ${e.message}`);
       };
       if (options?.fractionalDigits === "auto")
         effectiveOptions.fractionalDigits = -this.engine.precision;
+      else effectiveOptions.fractionalDigits = options?.fractionalDigits ?? "max";
       if (typeof effectiveOptions.fractionalDigits === "number" && effectiveOptions.fractionalDigits > this.engine.precision)
         effectiveOptions.fractionalDigits = this.engine.precision;
       effectiveOptions = {
@@ -18655,7 +18676,7 @@ ${e.message}`);
       return null;
     }
     get isNumberLiteral() {
-      return this.numericValue !== null;
+      return false;
     }
     get isFunctionExpression() {
       return false;
@@ -18828,6 +18849,9 @@ ${e.message}`);
     simplify(_options) {
       return this;
     }
+    expand() {
+      return expand2(this) ?? this;
+    }
     evaluate(_options) {
       return this.simplify();
     }
@@ -21324,7 +21348,7 @@ ${e.message}`);
     return expr.engine._fn(expr.operator, expr.ops.map(invisibleOperatorForm));
   }
   function numberForm(expr) {
-    if (expr.numericValue !== null) return expr.canonical;
+    if (expr.isNumberLiteral) return expr.canonical;
     if (expr.ops) return expr.engine._fn(expr.operator, expr.ops.map(numberForm));
     return expr;
   }
@@ -21455,10 +21479,10 @@ ${e.message}`);
         if (typeof op1 === "number") return ce.number(-op1, options);
         if (op1 instanceof Decimal) return ce.number(op1.neg(), options);
         const boxedop1 = ce.box(op1, options);
-        ops = [boxedop1];
         const num = boxedop1.numericValue;
         if (num !== null)
           return ce.number(typeof num === "number" ? -num : num.neg(), options);
+        ops = [boxedop1];
       }
     }
     if (options.canonical === true)
@@ -21607,7 +21631,7 @@ ${e.message}`);
     } else return null;
     if (!ops.every((x) => x.isValid)) return ce._fn(name, ops, metadata);
     if (name === "Add") return canonicalAdd(ce, ops);
-    if (name === "Negate") return ops[0].neg();
+    if (name === "Negate") return canonicalNegate(ops[0]);
     if (name === "Multiply") return canonicalMultiply(ce, ops);
     if (name === "Divide") {
       if (ops.length === 2)
@@ -21825,7 +21849,7 @@ ${e.message}`);
   function differentiate(expr, v) {
     const ce = expr.engine;
     if (expr.string) return void 0;
-    if (expr.numericValue !== null) return expr.engine.Zero;
+    if (expr.isNumberLiteral) return expr.engine.Zero;
     if (expr.symbol === v) return expr.engine.One;
     if (expr.symbol) return expr.engine.Zero;
     if (!expr.operator) return void 0;
@@ -23435,8 +23459,10 @@ ${e.message}`);
       evaluate: evaluateImplies
     },
     Exists: { signature: "function", hold: true },
+    NotExists: { signature: "function", hold: true },
     ExistsUnique: { signature: "function", hold: true },
     ForAll: { signature: "function", hold: true },
+    NotForAll: { signature: "function", hold: true },
     KroneckerDelta: {
       description: "Return 1 if the arguments are equal, 0 otherwise",
       signature: "(value, ...value) -> integer",
@@ -25296,6 +25322,9 @@ Error in definition of "${name}"`,
     get numericValue() {
       return this._value;
     }
+    get isNumberLiteral() {
+      return true;
+    }
     get re() {
       if (typeof this._value === "number") return this._value;
       return this._value.re;
@@ -25675,12 +25704,10 @@ Error in definition of "${name}"`,
     }
     const n = bigint(s);
     if (n !== null) {
-      if (n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER)
-        return Number(n);
+      if (n >= -SMALL_INTEGER && n <= SMALL_INTEGER) return Number(n);
       return ce._numericValue(n);
     }
-    const b = ce.bignum(s);
-    return isInMachineRange(b) ? b.toNumber() : ce._numericValue(b);
+    return ce._numericValue(ce.bignum(s));
   }
 
   // src/compute-engine/boxed-expression/boxed-symbol.ts
@@ -27039,14 +27066,12 @@ Error in definition of "${name}"`,
       name: "Negate",
       latexTrigger: ["-"],
       kind: "prefix",
-      precedence: ADDITION_PRECEDENCE + 2,
+      precedence: EXPONENTIATION_PRECEDENCE + 1,
       parse: (parser, terminator) => {
         parser.skipSpace();
-        if (/\d/.test(parser.peek)) return null;
-        if (parser.parseNumber() !== null) return null;
         const rhs = parser.parseExpression({
           ...terminator,
-          minPrec: ADDITION_PRECEDENCE + 3
+          minPrec: EXPONENTIATION_PRECEDENCE + 3
         });
         if (rhs === null) return null;
         return ["Negate", rhs];
@@ -27137,7 +27162,7 @@ Error in definition of "${name}"`,
       latexTrigger: ["^"],
       kind: "infix",
       serialize: serializePower
-      // Parsing is done as a special case in `parseExpression`
+      // Parsing is done as a special case in `parseSupsub`
     },
     {
       latexTrigger: "\\prod",
@@ -27861,6 +27886,24 @@ Error in definition of "${name}"`,
       serialize: "\\exists!",
       parse: parseQuantifier("ExistsUnique")
     },
+    {
+      name: "NotForAll",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\forall"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE
+      serialize: "\\lnot\\forall",
+      parse: parseQuantifier("NotForAll")
+    },
+    {
+      name: "NotExists",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\exists"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: "\\lnot\\exists",
+      parse: parseQuantifier("NotExists")
+    },
     {
       name: "KroneckerDelta",
       kind: "prefix",
@@ -27928,14 +27971,11 @@ Error in definition of "${name}"`,
       if (id) {
         parser.skipSpace();
         if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-          const body = parser.parseExpression(terminator);
-          return [kind, id, missingIfEmpty(body)];
-        }
-        if (parser.match("(")) {
-          const body = parser.parseExpression(terminator);
-          if (!parser.match(")")) return null;
-          return [kind, id, missingIfEmpty(body)];
+          const body2 = parser.parseExpression(terminator);
+          return [kind, id, missingIfEmpty(body2)];
         }
+        const body = parser.parseEnclosure();
+        if (body) return [kind, id, missingIfEmpty(body)];
       }
       parser.index = index;
       const condition = parser.parseExpression(terminator);
@@ -33251,11 +33291,19 @@ Invalid definition for ${id}`, err.message].join("\n|   ") + "\n"
       {
         const type2 = parseType(def);
         if (!isValidType(type2)) {
+          if (typeof def === "object" && "N" in def) {
+            throw Error(
+              [
+                `Invalid argument for "${id}"`,
+                "Use `evaluate` handler instead of `N`"
+              ].join("\n|   ")
+            );
+          }
           throw Error(
             [
               `Invalid argument for "${id}"`,
               def.toString(),
-              `Use a type, a FunctionDefinition or a SymbolDefinition`
+              `Use a type, a \`FunctionDefinition\` or a \`SymbolDefinition\``
             ].join("\n|   ")
           );
         }
@@ -34346,10 +34394,10 @@ ${lineNo.toString().padStart(maxDigits, " ")}`;
   }
 
   // src/compute-engine.ts
-  var version = "0.26.0";
+  var version = "0.26.2";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.26.0"
+    version: "0.26.2"
   };
   return __toCommonJS(compute_engine_exports);
 })();