@cortex-js/compute-engine 0.26.0 → 0.26.2

package/README.md

@@ -9,7 +9,7 @@
 notation interchange format based on JSON.
 
 The Cortex Compute Engine can parse LaTeX to MathJSON, serialize MathJSON to
-LaTeX, format, simplify and evaluate MathJSON expressions.
+LaTeX or MathASCII, format, simplify and evaluate MathJSON expressions.
 
 Reference documentation and guides at
 [cortexjs.io/compute-engine](https://cortexjs.io/compute-engine/).
@@ -23,15 +23,12 @@ $ npm install --save @cortex-js/compute-engine
 ```
 
 ```js
-import { parse, evaluate } from "@cortex-js/compute-engine";
+import { ComputeEngine } from "@cortex-js/compute-engine";
 
-const expr = parse("2^{11}-1 \\in \\P");
+const ce = new ComputeEngine();
 
-console.log(expr);
-// ➔ ["Element", ["Subtract", ["Power", 2, 11] , 1], "PrimeNumber"]
-
-console.log(evaluate(expr));
-// ➔ "False"
+engine.parse("2^{11}-1 \\in \\Z").evaluate().print()
+// ➔ "True"
 ```
 
 ## More

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.26.0 */
+/** Compute Engine 0.26.2 */
 
 // src/compute-engine/boxed-expression/public.ts
 function isRuleStep(x) {
@@ -4022,6 +4022,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();
@@ -4597,6 +4598,7 @@ var ARROW_PRECEDENCE = 270;
 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";
@@ -6458,20 +6460,20 @@ function isSymbolDefinition(def) {
   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;
@@ -6485,22 +6487,23 @@ function isFunctionDefinition(def) {
   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));
@@ -7502,7 +7505,9 @@ function fromDigits(s, baseInput) {
   }
   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();
@@ -7534,11 +7539,13 @@ function bigintValue(expr) {
   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)
@@ -7672,7 +7679,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     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
@@ -7714,10 +7721,10 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     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;
@@ -7859,7 +7866,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
         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;
@@ -7941,7 +7948,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
       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);
     }
@@ -8007,7 +8014,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
   }
   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];
     }
@@ -8171,7 +8178,7 @@ function asSmallInteger(expr) {
 // 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;
@@ -8196,7 +8203,7 @@ function totalDegree(expr) {
 }
 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;
@@ -9505,6 +9512,16 @@ function expandAll(expr) {
 }
 
 // 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") {
@@ -9517,9 +9534,7 @@ function negate(expr) {
   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) {
@@ -13041,7 +13056,7 @@ var ARITHMETIC_LIBRARY = [
       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]);
       },
@@ -18124,6 +18139,9 @@ function serializeRepeatingDecimals(s, options) {
   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}`;
@@ -18278,7 +18296,7 @@ function serializeJsonNumber(ce, value, options, metadata) {
         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;
@@ -18440,6 +18458,8 @@ var _BoxedExpression = class {
       }
       if (options.fractionalDigits === "auto")
         defaultOptions.fractionalDigits = -this.engine.precision;
+      if (typeof options.fractionalDigits === "number")
+        defaultOptions.fractionalDigits = options.fractionalDigits;
     }
     const opts = {
       ...defaultOptions,
@@ -18496,6 +18516,7 @@ var _BoxedExpression = class {
     };
     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 = {
@@ -18624,7 +18645,7 @@ var _BoxedExpression = class {
     return null;
   }
   get isNumberLiteral() {
-    return this.numericValue !== null;
+    return false;
   }
   get isFunctionExpression() {
     return false;
@@ -18797,6 +18818,9 @@ var _BoxedExpression = class {
   simplify(_options) {
     return this;
   }
+  expand() {
+    return expand2(this) ?? this;
+  }
   evaluate(_options) {
     return this.simplify();
   }
@@ -21293,7 +21317,7 @@ function invisibleOperatorForm(expr) {
   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;
 }
@@ -21424,10 +21448,10 @@ function boxFunction(ce, name, ops, options) {
       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)
@@ -21576,7 +21600,7 @@ function makeNumericFunction(ce, name, semiOps, metadata) {
   } 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)
@@ -21794,7 +21818,7 @@ function derivative(fn, order2) {
 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;
@@ -23404,8 +23428,10 @@ var LOGIC_LIBRARY = {
     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",
@@ -25265,6 +25291,9 @@ var BoxedNumber = class extends _BoxedExpression {
   get numericValue() {
     return this._value;
   }
+  get isNumberLiteral() {
+    return true;
+  }
   get re() {
     if (typeof this._value === "number") return this._value;
     return this._value.re;
@@ -25644,12 +25673,10 @@ function canonicalNumberString(ce, s) {
   }
   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
@@ -27008,14 +27035,12 @@ var DEFINITIONS_ARITHMETIC = [
     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];
@@ -27106,7 +27131,7 @@ var DEFINITIONS_ARITHMETIC = [
     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",
@@ -27830,6 +27855,24 @@ var DEFINITIONS_LOGIC = [
     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",
@@ -27897,14 +27940,11 @@ function parseQuantifier(kind) {
     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);
@@ -33220,11 +33260,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|   ")
         );
       }
@@ -34315,10 +34363,10 @@ function mark(line, mark2) {
 }
 
 // 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"
 };
 export {
   ComputeEngine,