@cortex-js/compute-engine 0.4.3 → 0.4.4

package/README.md

@@ -5,8 +5,7 @@
 <h3><strong>Cortex Compute Engine</strong></h3>
 <h1>Symbolic manipulation and numeric evaluation of MathJSON expressions</h1>
 
-[MathJSON](https://cortexjs.io/math-json/) is a lightweight data interchange
-format for mathematical notation, based on JSON.
+[MathJSON](https://cortexjs.io/math-json/) is a lightweight mathematical 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.
@@ -40,7 +39,7 @@ console.log(evaluate(expr));
 
 <dl>
   <dt><a href="https://cortexjs.io/math-json/">MathJSON</a></dt>
-  <dd>A lightweight data interchange format for mathematical notation</dd>  
+  <dd>A lightweight mathematical notation interchange format</dd>  
   <dt><a href="https://cortexjs.io/mathlive">MathLive</a> (on <a href="https://github.com/arnog/mathlive">GitHub</a>)</dt>
   <dd>A Web Component for math input.</dd>  
   <dt><a href="https://cortexjs.io/cortex">Cortex</a> (on <a href="https://github.com/cortex-js/compute-engine/tree/master/src/cortex">GitHub</a>)</dt>

package/dist/compute-engine.esm.js

@@ -1,7 +1,4 @@
-/** CortexJS Compute Engine 0.4.3 */
-const DEFAULT_COMPLEXITY = 100000;
-const DEBUG = true;
-
+/** CortexJS Compute Engine 0.4.4 */
 function stringToCodepoints(string) {
     const result = [];
     for (let i = 0; i < string.length; i++) {
@@ -843,17 +840,17 @@ function numeratorDenominator(expr) {
     for (const arg of args) {
         if (head(arg) === 'Power') {
             if (head(op(arg, 2)) === 'Negate') {
-                const a = op(arg, 1) ?? 'Nothing';
-                const b = op(op(arg, 2), 1) ?? 'Nothing';
+                const a = op(arg, 1) ?? 'Missing';
+                const b = op(op(arg, 2), 1) ?? 'Missing';
                 denominator.push([POWER, a, b]);
             }
             else {
                 const exponentVal = machineValue(op(arg, 2)) ?? NaN;
                 if (exponentVal === -1) {
-                    denominator.push(op(arg, 1) ?? 'Nothing');
+                    denominator.push(op(arg, 1) ?? 'Missing');
                 }
                 else if (exponentVal < 0) {
-                    denominator.push([POWER, op(arg, 1) ?? 'Nothing', -exponentVal]);
+                    denominator.push([POWER, op(arg, 1) ?? 'Missing', -exponentVal]);
                 }
                 else {
                     numerator.push(arg);
@@ -871,8 +868,8 @@ function parseRoot(parser) {
     const base = parser.matchRequiredLatexArgument();
     if (base === null) {
         if (degree !== null)
-            return [ROOT, 'Nothing', degree];
-        return [SQRT, 'Nothing'];
+            return [ROOT, 'Missing', degree];
+        return [SQRT, 'Missing'];
     }
     if (degree !== null)
         return [ROOT, base, degree];
@@ -1103,11 +1100,11 @@ function parseFraction(parser) {
                 head(op(denom, 1)) === 'PartialDerivative'))) {
         // It's a Leibniz notation partial derivative
         // `∂f(x)/∂x` or `∂^2f(x)/∂x∂y` or `∂/∂x f(x)`
-        const degree = op(numer, 3) ?? 'Nothing';
+        const degree = op(numer, 3) ?? 'Missing';
         // Expect: getArg(numer, 2) === 'Nothing' -- no args
         let fn = op(numer, 1);
         if (fn === null || fn === 'Missing') {
-            fn = parser.matchExpression() ?? 'Nothing';
+            fn = parser.matchExpression() ?? 'Missing';
         }
         let vars = [];
         if (head(denom) === 'Multiply') {
@@ -1339,7 +1336,7 @@ const DEFINITIONS_ARITHMETIC = [
         name: 'Exp',
         serialize: (serializer, expr) => joinLatex([
             '\\exponentialE^{',
-            serializer.serialize(op(expr, 1) ?? 'Nothing'),
+            serializer.serialize(op(expr, 1) ?? 'Missing'),
             '}',
         ]),
     },
@@ -4934,10 +4931,10 @@ class _Parser {
                     if (sub)
                         this.match('<}>');
                 }
-                subscripts.push(sub ?? 'Nothing');
+                subscripts.push(sub ?? 'Missing');
             }
             else if (this.match('^'))
-                superscripts.push(this.matchRequiredLatexArgument() ?? 'Nothing');
+                superscripts.push(this.matchRequiredLatexArgument() ?? 'Missing');
             this.skipSpace();
         }
         if (superscripts.length === 0 && subscripts.length === 0) {
@@ -5205,13 +5202,13 @@ class _Parser {
             if (tokens.length === 0)
                 return [
                     'Error',
-                    'Nothing',
+                    'Missing',
                     { str: 'syntax-error' },
                     ['LatexForm', { str: command }],
                 ];
             return [
                 'Error',
-                'Nothing',
+                'Missing',
                 { str: 'unknown-command' },
                 ['LatexForm', { str: `${command}{${tokensToString(tokens)}}` }],
             ];
@@ -5251,7 +5248,7 @@ class _Parser {
         }
         return [
             'Error',
-            'Nothing',
+            'Missing',
             { str: 'unknown-command' },
             ['LatexForm', { str: `${command}${tokensToString(tokens)}` }],
         ];
@@ -5511,6 +5508,13 @@ function serializeNumber(expr, options) {
     // remove it (legacy format)
     if (/[0-9][nd]$/.test(num))
         num = num.slice(0, -1);
+    // Remove any whitespace
+    num = num.replace(/[\u0009-\u000d\u0020\u00a0]/g, '');
+    // Do we have repeating digits?
+    if (/\([0-9]+\)$/.test(num)) {
+        const [_, body, repeat] = num.match(/(.+)\(([0-9]+)\)$/) ?? [];
+        num = body + repeat.repeat(Math.ceil(options.precision / repeat.length));
+    }
     let sign = '';
     if (num[0] === '-') {
         sign = '-';
@@ -13045,6 +13049,9 @@ class AbstractBoxedExpression {
     }
     /** Object.valueOf(): return a primitive value for the object */
     valueOf() {
+        const [n, d] = this.rationalValue;
+        if (n !== null && d !== null)
+            return [n, d];
         return this.asFloat ?? this.string ?? this.symbol ?? this.toString();
     }
     /** Object.is() */
@@ -13564,6 +13571,7 @@ function hashCode(s) {
     return Math.abs(hash);
 }
 
+const DEFAULT_COMPLEXITY = 100000;
 /**
  * Sort by higher total degree (sum of degree), if tied, sort by max degree,
  * if tied,
@@ -14162,6 +14170,10 @@ function serializeJsonCanonicalFunction(ce, head, args, metadata) {
             return serializeJsonFunction(ce, 'Subtract', [args[1], args[0].op1], metadata);
         }
     }
+    if (head === 'Divide' &&
+        ce.jsonSerializationOptions.exclude.includes('Divide')) {
+        return serializeJsonFunction(ce, 'Multiply', [args[0], ce._fn('Power', [args[1], ce.NEGATIVE_ONE])], metadata);
+    }
     if (head === 'Multiply' &&
         !ce.jsonSerializationOptions.exclude.includes('Divide')) {
         // Display a product with negative exponents as a division if
@@ -14179,10 +14191,12 @@ function serializeJsonCanonicalFunction(ce, head, args, metadata) {
             const exp = args[1].asSmallInteger;
             if (!exclusions.includes('Square') && exp === 2)
                 return serializeJsonFunction(ce, 'Square', [args[0]], metadata);
-            if (exp === -1)
-                return serializeJsonFunction(ce, 'Divide', [ce.ONE, args[0]], metadata);
-            if (exp !== null && exp < 0) {
-                return serializeJsonFunction(ce, 'Divide', [ce.ONE, ce.power(args[0], -exp)], metadata);
+            if (!ce.jsonSerializationOptions.exclude.includes('Divide')) {
+                if (exp === -1)
+                    return serializeJsonFunction(ce, 'Divide', [ce.ONE, args[0]], metadata);
+                if (exp !== null && exp < 0) {
+                    return serializeJsonFunction(ce, 'Divide', [ce.ONE, ce.power(args[0], -exp)], metadata);
+                }
             }
             const [n, d] = args[1].rationalValue;
             if (n === 1) {
@@ -14430,7 +14444,9 @@ function serializeJsonNumber(ce, value, metadata) {
     if (shorthandAllowed)
         return value;
     const num = repeatingDecimal(ce, value.toString());
-    return metadata.latex !== num ? { latex: metadata.latex, num } : { num };
+    return metadata.latex.length > 0 && metadata.latex !== num
+        ? { latex: metadata.latex, num }
+        : { num };
 }
 function _escapeJsonString(s) {
     return s;
@@ -15105,12 +15121,8 @@ class BoxedFunction extends AbstractBoxedExpression {
         super(ce, metadata);
         this._head = typeof head === 'string' ? head : head.symbol ?? head;
         this._ops = ops;
-        if (typeof this._head === 'string') {
-            const def = ce.getFunctionDefinition(this._head, metadata?.wikidata);
-            if (def === null)
-                throw new Error(`Function \`${this._head}\` is not defined`);
-            this._def = def;
-        }
+        if (typeof this._head === 'string')
+            this._def = ce.getFunctionDefinition(this._head, metadata?.wikidata);
         this._isCanonical = false;
         // Note: _isPure is computed on demand and cached
         ce._register(this);
@@ -17090,6 +17102,8 @@ class BoxedSymbolDefinitionImpl {
     set value(val) {
         if (this.constant)
             throw new Error(`The value of the constant "${this.name}" cannot be changed`);
+        if (typeof val === 'number')
+            val = this._engine.box(val);
         this._value = val;
         if (val)
             this.setProps(valueToFlags(val));
@@ -20277,7 +20291,7 @@ const CORE_DICTIONARY = [
 /*
  DICTIONARY
  aka Association in Wolfram, Dictionary in Python and Swift, Record in Maple,
- Map Containers in mathlab, Map in Javascript
+ Map Containers in mathlab, Map in JavaScript
  Dictionary("field1", "value1", "field2", "value2"...)
  Need a new atomic 'dict' MathJSON type?
   {{name: 'dict',"field1": "value1", "field2": "value2"}}
@@ -22567,8 +22581,11 @@ class ComputeEngine {
      * Construct a new `ComputeEngine` environment.
      *
      * If no `options.dictionaries` is provided a default set of dictionaries
-     * is used. The `ComputeEngine.getDictionaries()` method can be called
-     * to access some subset of dictionaries, e.g. for arithmetic, calculus, etc...
+     * is used.
+     *
+     * The `ComputeEngine.getDictionaries()` method can be called
+     * to access a subset of dictionaries, e.g. for arithmetic, calculus, etc...
+     *
      * The order of the dictionaries matter: the definitions from the later ones
      * override the definitions from earlier ones. The first dictionary should
      * be the `'core'` dictionary which include some basic definitions such
@@ -22622,6 +22639,7 @@ class ComputeEngine {
             TranscendentalNumber: null,
             PositiveNumber: null,
         };
+        this._latexDictionary = options?.latexDictionary;
         this._jsonSerializationOptions = {
             exclude: [],
             shorthands: ['function', 'symbol', 'string', 'dictionary', 'number'],
@@ -22832,10 +22850,12 @@ class ComputeEngine {
             return;
         // Set the display precision as requested.
         // It may be less than the effective precision, which is never less than 15
-        this.latexSyntax.updateOptions({
-            precision: p,
-            avoidExponentsInRange: [-6, p],
-        });
+        if (this._latexSyntax) {
+            this.latexSyntax.updateOptions({
+                precision: p,
+                avoidExponentsInRange: [-6, p],
+            });
+        }
         this._precision = Math.max(p, Math.floor(MACHINE_PRECISION));
         this._decimal = this._decimal.config({ precision: this._precision });
         // Reset the caches
@@ -22865,7 +22885,8 @@ class ComputeEngine {
         if (f === 'complex' || f === 'machine')
             this._precision = Math.floor(MACHINE_PRECISION);
         // Make sure the display precision is not larger than the computation precision
-        if (this.latexSyntax.options.precision > this._precision)
+        if (this._latexSyntax &&
+            this.latexSyntax.options.precision > this._precision)
             this.latexSyntax.updateOptions({ precision: this._precision });
         // Reset the caches: the values in the cache depend on the numeric mode)
         this.purge();
@@ -22933,14 +22954,12 @@ class ComputeEngine {
         return n;
     }
     get latexSyntax() {
-        // We'll use this LatexSyntax instance internally, for example to parse
-        // rules, etc... Use our own custom error handler, which will throw
-        // on any error.
         if (!this._latexSyntax)
             this._latexSyntax = new LatexSyntax({
+                computeEngine: this,
+                dictionary: this._latexDictionary,
                 precision: this.precision,
                 avoidExponentsInRange: [-6, this.precision],
-                computeEngine: this,
                 onError: (err) => {
                     throw new Error(err[0].message.toString());
                 },
@@ -22992,7 +23011,7 @@ class ComputeEngine {
         }
         if (defs)
             return defs[0];
-        // If no definition matching the domain of the arguments, return `undefined`
+        // If no matching definition
         return undefined;
     }
     /**
@@ -23505,6 +23524,6 @@ class ComputeEngine {
 }
 
 // This file is the root of the `compute-engine` package
-const version = '0.4.3';
+const version = '0.4.4';
 
-export { ComputeEngine, DEBUG, DEFAULT_COMPLEXITY, version };
+export { ComputeEngine, version };