@cortex-js/compute-engine 0.7.0 → 0.9.0

package/dist/math-json.esm.js

@@ -1,10 +1,4 @@
-/** MathJSON 0.7.0 */
-/**
- * These constants are the 'primitive' functions and constants that are used
- * for some basic manipulations such as parsing, and transforming to canonical
- * form.
- *
- */
+/** MathJSON 0.9.0 */
 function isSymbolObject(expr) {
     return expr !== null && typeof expr === 'object' && 'sym' in expr;
 }
@@ -17,14 +11,12 @@ function isFunctionObject(expr) {
 function isDictionaryObject(expr) {
     return expr !== null && typeof expr === 'object' && 'dict' in expr;
 }
-/**
- * True if the expression is a number, a symbol or a string
- * (i.e. not a function and not a dictionary)
- */
-function isAtomic(expr) {
-    return (expr === null ||
-        (!Array.isArray(expr) &&
-            (typeof expr !== 'object' || !('fn' in expr || 'dic' in expr))));
+function isValidIdentifier(s) {
+    // An identifier must not contain any of these characters
+    if (/[\u0000-\u0020\u0022\u0060\ufffe\uffff]/.test(s))
+        return false;
+    // A symbol name must not start with one these characters
+    return !/^[\u0021\u0022\u0024-\u0029\u002e\u003a\u003f\u0040\u005b\u005d\u005e\u007b\u007d\u007e\+\-[0-9]]/.test(s);
 }
 /**  If expr is a string literal, return it.
  *
@@ -45,7 +37,7 @@ function stringValue(expr) {
     return expr.substring(1, expr.length - 1);
 }
 /**
- * The head of a function can be a string or an expression.
+ * The head of a function can be an identifier or an expression.
  *
  * Return `null` if the expression is not a function.
  *
@@ -56,8 +48,11 @@ function stringValue(expr) {
 function head(expr) {
     if (expr === null || expr === undefined)
         return null;
-    if (Array.isArray(expr))
+    if (Array.isArray(expr)) {
+        console.assert(expr.length > 0 &&
+            (typeof expr[0] !== 'string' || isValidIdentifier(expr[0])));
         return expr[0];
+    }
     if (isFunctionObject(expr))
         return expr.fn[0];
     return null;
@@ -67,15 +62,6 @@ function headName(expr) {
     const h = head(expr);
     return typeof h === 'string' ? h : '';
 }
-function op(expr, n) {
-    if (expr === null || expr === undefined)
-        return null;
-    if (Array.isArray(expr))
-        return expr[n] ?? null;
-    if (isFunctionObject(expr))
-        return expr.fn[n] ?? null;
-    return null;
-}
 /**
  * Return all the elements but the first one, i.e. the arguments of a
  * function.
@@ -89,6 +75,22 @@ function ops(expr) {
         return expr.fn.slice(1);
     return null;
 }
+/** Return the nth argument of a function expression */
+function op(expr, n) {
+    if (expr === null || expr === undefined)
+        return null;
+    if (Array.isArray(expr))
+        return expr[n] ?? null;
+    if (isFunctionObject(expr))
+        return expr.fn[n] ?? null;
+    return null;
+}
+function op1(expr) {
+    return op(expr, 1);
+}
+function op2(expr) {
+    return op(expr, 2);
+}
 function nops(expr) {
     if (expr === null || expr === undefined)
         return 0;
@@ -101,21 +103,26 @@ function nops(expr) {
 function symbol(expr) {
     if (expr === null || expr === undefined)
         return null;
+    if (typeof expr === 'string') {
+        // Is it a number?
+        if (/^[+\-\.0-9]/.test(expr))
+            return null;
+        // Is it a string literal?
+        if (expr.length >= 2 && expr[0] === "'" && expr[expr.length - 1] === "'")
+            return null;
+    }
     const s = isSymbolObject(expr) ? expr.sym : expr;
     if (typeof s !== 'string')
         return null;
-    // Is it a string literal?
-    if (s.length >= 2 && s[0] === "'" && s[s.length - 1] === "'")
-        return null;
     return s;
 }
 function keyValuePair(expr) {
     const h = head(expr);
     if (h === 'KeyValuePair' || h === 'Tuple' || h === 'Pair') {
-        const key = stringValue(op(expr, 1));
+        const key = stringValue(op1(expr));
         if (!key)
             return null;
-        return [key, op(expr, 2) ?? 'Nothing'];
+        return [key, op2(expr) ?? 'Nothing'];
     }
     return null;
 }
@@ -172,63 +179,9 @@ function mapArgs(expr, fn) {
         i += 1;
     }
     return result;
-}
-/**
- * Return num as a number if it's a valid JSON number (that is
- * a valid JavaScript number but not NaN or +/-Infinity) or
- * as a string otherwise
- */
-function asValidJSONNumber(num) {
-    if (typeof num === 'string') {
-        const val = Number(num);
-        if (num[0] === '+')
-            num = num.slice(1);
-        if (val.toString() === num) {
-            // If the number roundtrips, it can be represented by a
-            // JavaScript number
-            // However, NaN and Infinity cannot be represented by JSON
-            if (isNaN(val) || !isFinite(val)) {
-                return val.toString();
-            }
-            return val;
-        }
-    }
-    return num;
-}
-//  function number(
-//   expr: Expression | null | undefined
-// ): number | string | null {
-//   if (expr === null || expr === undefined) return null;
-//   if (typeof expr === 'number') return expr;
-//   if (isNumberObject(expr)) return expr.num;
-//   return null;
-// }
-// export function isEqual(lhs: Expression, rhs: Expression): boolean {
-//   const symbLhs = symbol(lhs);
-//   if (symbLhs) return symbLhs === symbol(rhs);
-//   const strLhs = string(lhs);
-//   if (strLhs) return strLhs === string(rhs);
-//   if (Array.isArray(lhs) || isFunctionObject(lhs)) {
-//     if (!(Array.isArray(rhs) || isFunctionObject(rhs))) return false;
-//     if (nops(lhs) !== nops(rhs)) return false;
-//     if (!isEqual(head(lhs)!, head(rhs)!)) return false;
-//     const lhsTail = tail(lhs);
-//     const rhsTail = tail(rhs);
-//     for (let i = 0; i <= nops(lhs); i += 1)
-//       if (!isEqual(lhsTail[i], rhsTail[i])) return false;
-//     return true;
-//   }
-//   if (typeof lhs === 'number' || isNumberObject(lhs)) {
-//     if (!(typeof rhs === 'number' || isNumberObject(rhs))) return false;
-//     const mLhs = number(lhs);
-//     const mRhs = number(rhs);
-//     if (mLhs !== null) return mLhs === mRhs;
-//     return false;
-//   }
-//   return false;
-// }
+}
 
 // This is the root of the `math-json` package (i.e.  `math-json.js` and
-const version = '0.7.0';
+const version = '0.9.0';
 
-export { applyRecursively, asValidJSONNumber, dictionary as getDictionary, stringValue as getStringValue, head, headName, isAtomic, isDictionaryObject, isFunctionObject, isStringObject, isSymbolObject, mapArgs, nops, op, symbol, version };
+export { applyRecursively, dictionary as getDictionary, stringValue as getStringValue, head, headName, isDictionaryObject, isFunctionObject, isStringObject, isSymbolObject, mapArgs, nops, op, symbol, version };

package/dist/math-json.min.esm.js

@@ -1,2 +1,2 @@
-/** MathJSON 0.7.0 */
-function n(n){return null!==n&&"object"==typeof n&&"sym"in n}function t(n){return null!==n&&"object"==typeof n&&"str"in n}function r(n){return null!==n&&"object"==typeof n&&"fn"in n}function u(n){return null!==n&&"object"==typeof n&&"dict"in n}function l(n){return null===n||!Array.isArray(n)&&("object"!=typeof n||!("fn"in n||"dic"in n))}function e(n){return null==n?null:"object"==typeof n&&"str"in n?n.str:"string"!=typeof n||n.length<2||"'"!==n[0]||"'"!==n[n.length-1]?null:n.substring(1,n.length-1)}function i(n){return null==n?null:Array.isArray(n)?n[0]:r(n)?n.fn[0]:null}function o(n){const t=i(n);return"string"==typeof t?t:""}function f(n,t){return null==n?null:Array.isArray(n)?n[t]??null:r(n)?n.fn[t]??null:null}function c(n){return null==n?null:Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):null}function s(n){return null==n?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function y(t){if(null==t)return null;const r=n(t)?t.sym:t;return"string"!=typeof r||r.length>=2&&"'"===r[0]&&"'"===r[r.length-1]?null:r}function a(n){const t=i(n);if("KeyValuePair"===t||"Tuple"===t||"Pair"===t){const t=e(f(n,1));return t?[t,f(n,2)??"Nothing"]:null}return null}function g(n){if(null===n)return null;if("object"==typeof n&&"dict"in n)return n.dict;const t=a(n);if(t)return{[t[0]]:t[1]};if("Dictionary"===i(n)){const t={};for(let r=1;r<s(n);r++){const u=a(f(n,r));u&&(t[u[0]]=u[1])}return t}return null}function p(n,t){const r=i(n);if(null!==r)return[t(r),...(c(n)??[]).map(t)];const u=g(n);if(null!==u){const n=Object.keys(u),r={};for(const l of n)r[l]=t(u[l]);return{dict:r}}return t(n)}function h(n,t){let u=null;if(Array.isArray(n)&&(u=n),r(n)&&(u=n.fn),null===u)return[];let l=1;const e=[];for(;l<u.length;)e.push(t(u[l])),l+=1;return e}function A(n){if("string"==typeof n){const t=Number(n);if("+"===n[0]&&(n=n.slice(1)),t.toString()===n)return isNaN(t)||!isFinite(t)?t.toString():t}return n}const b="0.7.0";export{p as applyRecursively,A as asValidJSONNumber,g as getDictionary,e as getStringValue,i as head,o as headName,l as isAtomic,u as isDictionaryObject,r as isFunctionObject,t as isStringObject,n as isSymbolObject,h as mapArgs,s as nops,f as op,y as symbol,b as version};
+/** MathJSON 0.9.0 */
+function n(n){return null!==n&&"object"==typeof n&&"sym"in n}function t(n){return null!==n&&"object"==typeof n&&"str"in n}function r(n){return null!==n&&"object"==typeof n&&"fn"in n}function u(n){return null!==n&&"object"==typeof n&&"dict"in n}function l(n){return null==n?null:"object"==typeof n&&"str"in n?n.str:"string"!=typeof n||n.length<2||"'"!==n[0]||"'"!==n[n.length-1]?null:n.substring(1,n.length-1)}function e(n){return null==n?null:Array.isArray(n)?n[0]:r(n)?n.fn[0]:null}function i(n){const t=e(n);return"string"==typeof t?t:""}function o(n){return null==n?null:Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):null}function f(n,t){return null==n?null:Array.isArray(n)?n[t]??null:r(n)?n.fn[t]??null:null}function c(n){return f(n,2)}function s(n){return null==n?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function y(t){if(null==t)return null;if("string"==typeof t){if(/^[+\-\.0-9]/.test(t))return null;if(t.length>=2&&"'"===t[0]&&"'"===t[t.length-1])return null}const r=n(t)?t.sym:t;return"string"!=typeof r?null:r}function a(n){const t=e(n);if("KeyValuePair"===t||"Tuple"===t||"Pair"===t){const t=l(function(n){return f(n,1)}(n));return t?[t,c(n)??"Nothing"]:null}return null}function g(n){if(null===n)return null;if("object"==typeof n&&"dict"in n)return n.dict;const t=a(n);if(t)return{[t[0]]:t[1]};if("Dictionary"===e(n)){const t={};for(let r=1;r<s(n);r++){const u=a(f(n,r));u&&(t[u[0]]=u[1])}return t}return null}function p(n,t){const r=e(n);if(null!==r)return[t(r),...(o(n)??[]).map(t)];const u=g(n);if(null!==u){const n=Object.keys(u),r={};for(const l of n)r[l]=t(u[l]);return{dict:r}}return t(n)}function h(n,t){let u=null;if(Array.isArray(n)&&(u=n),r(n)&&(u=n.fn),null===u)return[];let l=1;const e=[];for(;l<u.length;)e.push(t(u[l])),l+=1;return e}const A="0.9.0";export{p as applyRecursively,g as getDictionary,l as getStringValue,e as head,i as headName,u as isDictionaryObject,r as isFunctionObject,t as isStringObject,n as isSymbolObject,h as mapArgs,s as nops,f as op,y as symbol,A as version};

package/dist/math-json.min.js

@@ -1,2 +1,2 @@
-/** MathJSON 0.7.0 */
-var global,factory;global=this,factory=function(n){function t(n){return null!==n&&"object"==typeof n&&"sym"in n}function r(n){return null!==n&&"object"==typeof n&&"fn"in n}function l(n){return null==n?null:"object"==typeof n&&"str"in n?n.str:"string"!=typeof n||n.length<2||"'"!==n[0]||"'"!==n[n.length-1]?null:n.substring(1,n.length-1)}function e(n){return null==n?null:Array.isArray(n)?n[0]:r(n)?n.fn[0]:null}function i(n,t){var l,e;return null==n?null:Array.isArray(n)?null!==(l=n[t])&&void 0!==l?l:null:r(n)&&null!==(e=n.fn[t])&&void 0!==e?e:null}function u(n){return null==n?null:Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):null}function o(n){return null==n?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function f(n){var t;const r=e(n);if("KeyValuePair"===r||"Tuple"===r||"Pair"===r){const r=l(i(n,1));return r?[r,null!==(t=i(n,2))&&void 0!==t?t:"Nothing"]:null}return null}function c(n){if(null===n)return null;if("object"==typeof n&&"dict"in n)return n.dict;const t=f(n);if(t)return{[t[0]]:t[1]};if("Dictionary"===e(n)){const t={};for(let r=1;r<o(n);r++){const l=f(i(n,r));l&&(t[l[0]]=l[1])}return t}return null}n.applyRecursively=function(n,t){var r;const l=e(n);if(null!==l)return[t(l),...(null!==(r=u(n))&&void 0!==r?r:[]).map(t)];const i=c(n);if(null!==i){const n=Object.keys(i),r={};for(const l of n)r[l]=t(i[l]);return{dict:r}}return t(n)},n.asValidJSONNumber=function(n){if("string"==typeof n){const t=Number(n);if("+"===n[0]&&(n=n.slice(1)),t.toString()===n)return isNaN(t)||!isFinite(t)?t.toString():t}return n},n.getDictionary=c,n.getStringValue=l,n.head=e,n.headName=function(n){const t=e(n);return"string"==typeof t?t:""},n.isAtomic=function(n){return null===n||!Array.isArray(n)&&("object"!=typeof n||!("fn"in n||"dic"in n))},n.isDictionaryObject=function(n){return null!==n&&"object"==typeof n&&"dict"in n},n.isFunctionObject=r,n.isStringObject=function(n){return null!==n&&"object"==typeof n&&"str"in n},n.isSymbolObject=t,n.mapArgs=function(n,t){let l=null;if(Array.isArray(n)&&(l=n),r(n)&&(l=n.fn),null===l)return[];let e=1;const i=[];for(;e<l.length;)i.push(t(l[e])),e+=1;return i},n.nops=o,n.op=i,n.symbol=function(n){if(null==n)return null;const r=t(n)?n.sym:n;return"string"!=typeof r||r.length>=2&&"'"===r[0]&&"'"===r[r.length-1]?null:r},n.version="0.7.0",Object.defineProperty(n,"__esModule",{value:!0})},"object"==typeof exports&&"undefined"!=typeof module?factory(exports):"function"==typeof define&&define.amd?define(["exports"],factory):factory((global="undefined"!=typeof globalThis?globalThis:global||self).MathJson={});
+/** MathJSON 0.9.0 */
+var global,factory;global=this,factory=function(n){function t(n){return null!==n&&"object"==typeof n&&"sym"in n}function r(n){return null!==n&&"object"==typeof n&&"fn"in n}function l(n){return null==n?null:"object"==typeof n&&"str"in n?n.str:"string"!=typeof n||n.length<2||"'"!==n[0]||"'"!==n[n.length-1]?null:n.substring(1,n.length-1)}function e(n){return null==n?null:Array.isArray(n)?n[0]:r(n)?n.fn[0]:null}function u(n){return null==n?null:Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):null}function o(n,t){var l,e;return null==n?null:Array.isArray(n)?null!==(l=n[t])&&void 0!==l?l:null:r(n)&&null!==(e=n.fn[t])&&void 0!==e?e:null}function i(n){return o(n,2)}function f(n){return null==n?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function c(n){var t;const r=e(n);if("KeyValuePair"===r||"Tuple"===r||"Pair"===r){const r=l(function(n){return o(n,1)}(n));return r?[r,null!==(t=i(n))&&void 0!==t?t:"Nothing"]:null}return null}function s(n){if(null===n)return null;if("object"==typeof n&&"dict"in n)return n.dict;const t=c(n);if(t)return{[t[0]]:t[1]};if("Dictionary"===e(n)){const t={};for(let r=1;r<f(n);r++){const l=c(o(n,r));l&&(t[l[0]]=l[1])}return t}return null}n.applyRecursively=function(n,t){var r;const l=e(n);if(null!==l)return[t(l),...(null!==(r=u(n))&&void 0!==r?r:[]).map(t)];const o=s(n);if(null!==o){const n=Object.keys(o),r={};for(const l of n)r[l]=t(o[l]);return{dict:r}}return t(n)},n.getDictionary=s,n.getStringValue=l,n.head=e,n.headName=function(n){const t=e(n);return"string"==typeof t?t:""},n.isDictionaryObject=function(n){return null!==n&&"object"==typeof n&&"dict"in n},n.isFunctionObject=r,n.isStringObject=function(n){return null!==n&&"object"==typeof n&&"str"in n},n.isSymbolObject=t,n.mapArgs=function(n,t){let l=null;if(Array.isArray(n)&&(l=n),r(n)&&(l=n.fn),null===l)return[];let e=1;const u=[];for(;e<l.length;)u.push(t(l[e])),e+=1;return u},n.nops=f,n.op=o,n.symbol=function(n){if(null==n)return null;if("string"==typeof n){if(/^[+\-\.0-9]/.test(n))return null;if(n.length>=2&&"'"===n[0]&&"'"===n[n.length-1])return null}const r=t(n)?n.sym:n;return"string"!=typeof r?null:r},n.version="0.9.0",Object.defineProperty(n,"__esModule",{value:!0})},"object"==typeof exports&&"undefined"!=typeof module?factory(exports):"function"==typeof define&&define.amd?define(["exports"],factory):factory((global="undefined"!=typeof globalThis?globalThis:global||self).MathJson={});

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.7.0 */
+/* 0.9.0 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.7.0 */
+/* 0.9.0 */
 export declare type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');
 export declare type SignalMessage = SignalCode | [SignalCode, ...any[]];
 export declare type SignalOrigin = {
@@ -25,10 +25,6 @@ export declare type Signal = {
 export declare type ErrorSignal = Signal & {
     severity: 'error';
 };
-export declare class CortexError extends Error {
-    constructor(errorSignal: Signal);
-    toString(): string;
-}
 export declare type WarningSignal = Signal & {
     severity: 'warning';
 };

package/dist/types/common/utils.d.ts

@@ -0,0 +1 @@
+/* 0.9.0 */

package/dist/types/compute-engine/assume.d.ts

@@ -1,4 +1,4 @@
-/* 0.7.0 */
+/* 0.9.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -13,6 +13,11 @@
  * of these are stored directly in the current scope's symbols dictionary
  * (and an entry for the symbol is created if necessary).
  *
+ * New assumptions can 'refine' previous assumptions, that is they are valid
+ * if they don't contradict previous assumptions. To set new assumptions
+ * that contradict previous ones, you must first `forget` about any symbols
+ * in the new assumption.
+ *
  * Predicates that involve multiple symbols are simplified (for example
  * `x + y = 5` becomes `x + y - 5 = 0`, then stored in the `assumptions` of the
  * current context).

package/dist/types/compute-engine/boxed-expression/abstract-boxed-expression.d.ts

@@ -1,58 +1,95 @@
-/* 0.7.0 */
-import type { Complex } from 'complex.js';
+/* 0.9.0 */
+import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, BoxedDomain, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOption, SemiBoxedExpression, SimplifyOptions, Substitution, RuntimeScope, DomainCompatibility, DomainLiteral, BoxedBaseDefinition } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, BoxedDomain, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOptions, SemiBoxedExpression, SimplifyOptions, Substitution, RuntimeScope, DomainCompatibility, DomainLiteral, BoxedBaseDefinition, Rational, BoxedSubstitution } from '../public';
 /**
  * AbstractBoxedExpression
  */
 export declare abstract class AbstractBoxedExpression implements BoxedExpression {
-    abstract get json(): Expression;
-    abstract get head(): BoxedExpression | string;
-    abstract isSame(rhs: BoxedExpression): boolean;
-    abstract isEqual(rhs: BoxedExpression): boolean;
+    abstract readonly hash: number;
+    abstract readonly json: Expression;
+    abstract readonly head: BoxedExpression | string;
     abstract get isCanonical(): boolean;
     abstract set isCanonical(_val: boolean);
-    abstract get hash(): number;
-    abstract match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    abstract isSame(rhs: BoxedExpression): boolean;
+    abstract isEqual(rhs: BoxedExpression): boolean;
+    abstract match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     readonly engine: IComputeEngine;
     /** Verbatim LaTeX, obtained from a source, i.e. from parsing, not generated
      * synthetically
      */
     protected _latex?: string;
-    protected _wikidata?: string;
+    protected _wikidata: string | undefined;
     constructor(ce: IComputeEngine, metadata?: Metadata);
-    /** Object.toJSON(), called by JSON.Stringify */
-    toJSON(): string;
+    /** `Object.valueOf()`: return a primitive value for the object
+     *
+     */
+    valueOf(): number | string | boolean;
     /** Object.toString() */
     toString(): string;
-    /** Object.valueOf(): return a primitive value for the object */
-    valueOf(): number | string | [number, number];
+    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
+    /** Called by `JSON.stringify()` when serializing to json */
+    toJSON(): Expression;
+    get scope(): RuntimeScope | null;
     /** Object.is() */
     is(rhs: any): boolean;
-    isCompatible(_dom: BoxedDomain | DomainLiteral, _kind?: DomainCompatibility): boolean;
-    has(_v: string | string[]): boolean;
-    get description(): string[];
-    get url(): string;
-    get isPure(): boolean;
-    /** For a symbol, true if the symbol is a free variable (no value) */
-    get isFree(): boolean;
-    /** For a symbol, true if the symbol is a constant (unchangeable value) */
-    get isConstant(): boolean;
-    get isLiteral(): boolean;
     get latex(): LatexString;
     set latex(val: LatexString);
-    get wikidata(): string;
-    set wikidata(val: string);
-    get complexity(): number;
-    get symbols(): BoxedExpression[];
+    get symbol(): string | null;
+    get isNothing(): boolean;
+    get string(): string | null;
     getSubexpressions(head: string): BoxedExpression[];
     get subexpressions(): BoxedExpression[];
+    get symbols(): BoxedExpression[];
     get errors(): BoxedExpression[];
     get ops(): null | BoxedExpression[];
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
+    get isValid(): boolean;
+    get isPure(): boolean;
+    get isExact(): boolean;
+    /** For a symbol, true if the symbol is a free variable (no value) */
+    get isFree(): boolean;
+    /** For a symbol, true if the symbol is a constant (unchangeable value) */
+    get isConstant(): boolean;
+    get canonical(): BoxedExpression;
+    apply(_fn: (x: BoxedExpression) => SemiBoxedExpression, _head?: string): BoxedExpression;
+    subs(_sub: Substitution, options?: {
+        canonical: boolean;
+    }): BoxedExpression;
+    solve(_vars: Iterable<string>): null | BoxedExpression[];
+    replace(_rules: BoxedRuleSet): null | BoxedExpression;
+    has(_v: string | string[]): boolean;
+    get isNaN(): boolean | undefined;
+    get isZero(): boolean | undefined;
+    get isNotZero(): boolean | undefined;
+    get isOne(): boolean | undefined;
+    get isNegativeOne(): boolean | undefined;
+    get isInfinity(): boolean | undefined;
+    get isFinite(): boolean | undefined;
+    get isEven(): boolean | undefined;
+    get isOdd(): boolean | undefined;
+    get isPrime(): boolean | undefined;
+    get isComposite(): boolean | undefined;
+    get numericValue(): number | Decimal | Complex | Rational | null;
+    get sgn(): -1 | 0 | 1 | undefined | null;
+    isLess(_rhs: BoxedExpression): boolean | undefined;
+    isLessEqual(_rhs: BoxedExpression): boolean | undefined;
+    isGreater(_rhs: BoxedExpression): boolean | undefined;
+    isGreaterEqual(_rhs: BoxedExpression): boolean | undefined;
+    get isPositive(): boolean | undefined;
+    get isNonNegative(): boolean | undefined;
+    get isNegative(): boolean | undefined;
+    get isNonPositive(): boolean | undefined;
+    isCompatible(_dom: BoxedDomain | DomainLiteral, _kind?: DomainCompatibility): boolean;
+    get description(): string[] | undefined;
+    get url(): string | undefined;
+    get isLiteral(): boolean;
+    get wikidata(): string | undefined;
+    set wikidata(val: string | undefined);
+    get complexity(): number | undefined;
     get basedDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
@@ -62,38 +99,11 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     get keysCount(): number;
     getKey(_key: string): BoxedExpression | undefined;
     hasKey(_key: string): boolean;
-    get machineValue(): number | null;
-    get rationalValue(): [numer: number, denom: number] | [null, null];
-    get decimalValue(): Decimal | null;
-    get complexValue(): Complex | null;
-    get asFloat(): number | null;
-    get asSmallInteger(): number | null;
-    get asRational(): [number, number] | [null, null];
-    get sgn(): -1 | 0 | 1 | undefined | null;
-    get symbol(): string | null;
-    get isNothing(): boolean;
-    get isValid(): boolean;
     get value(): BoxedExpression | undefined;
     set value(_value: BoxedExpression | number | undefined);
-    get numericValue(): BoxedExpression | undefined;
-    isSubdomainOf(_d: BoxedExpression | string): undefined | boolean;
     get domain(): BoxedDomain;
     set domain(_domain: BoxedDomain);
-    get explicitDomain(): BoxedDomain | null;
-    get string(): string | null;
-    isLess(_rhs: BoxedExpression): boolean | undefined;
-    isLessEqual(_rhs: BoxedExpression): boolean | undefined;
-    isGreater(_rhs: BoxedExpression): boolean | undefined;
-    isGreaterEqual(_rhs: BoxedExpression): boolean | undefined;
-    get isZero(): boolean | undefined;
-    get isNotZero(): boolean | undefined;
-    get isPositive(): boolean | undefined;
-    get isNonNegative(): boolean | undefined;
-    get isNegative(): boolean | undefined;
-    get isNonPositive(): boolean | undefined;
-    get isInfinity(): boolean | undefined;
-    get isNaN(): boolean | undefined;
-    get isFinite(): boolean | undefined;
+    get explicitDomain(): BoxedDomain | undefined;
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
@@ -103,18 +113,7 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     get isComplex(): boolean | undefined;
     get isImaginary(): boolean | undefined;
     get isExtendedComplex(): boolean | undefined;
-    get isOne(): boolean | undefined;
-    get isNegativeOne(): boolean | undefined;
-    get isEven(): boolean | undefined;
-    get isOdd(): boolean | undefined;
-    get isPrime(): boolean | undefined;
-    get isComposite(): boolean | undefined;
-    get canonical(): BoxedExpression;
-    apply(_fn: (x: BoxedExpression) => SemiBoxedExpression, _head?: string): BoxedExpression;
-    evaluate(options?: EvaluateOptions): BoxedExpression;
     simplify(_options?: SimplifyOptions): BoxedExpression;
+    evaluate(options?: EvaluateOptions): BoxedExpression;
     N(_options?: NOptions): BoxedExpression;
-    replace(_rules: BoxedRuleSet): null | BoxedExpression;
-    subs(_sub: Substitution): BoxedExpression;
-    solve(_vars: Iterable<string>): null | BoxedExpression[];
 }

package/dist/types/compute-engine/boxed-expression/box.d.ts

@@ -1,7 +1,74 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { Decimal } from 'decimal.js';
-import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata } from '../public';
+import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, Rational } from '../public';
 import { MathJsonNumber } from '../../math-json/math-json-format';
+/**
+ * **Theory of Operations**
+ *
+ * 1/ Boxing does not depend on the numeric mode. The numeric mode could be
+ * changed later, but the previously boxed numbers could not be retroactively
+ * upgraded.
+ *
+ * The `numericMode` is taken into account only during evaluation.
+ *
+ * Therefore, a boxed expression may contain a mix of number representations.
+ *
+ * 2/ The result of boxing is canonical by default.
+ *
+ * This is the most common need (i.e. as soon as you want to evaluate an
+ * expression you need a canonical expression). Creating a boxed expression
+ * which is canonical from the start avoid going through an intermediary step
+ * with a non-canonical expression.
+ *
+ * 3/ When implementing an `evaluate()`:
+ * - if `bignumPreferred()` all operations should be done in bignum and complex,
+ *    otherwise, they should all be done in machine numbers and complex.
+ * - if not `complexAllowed()`, return `NaN` if a complex value is encountered
+ * - if a `Sqrt` (of a rational) is encountered, preserve it
+ * - if a `hold` constant is encountered, preserve it
+ * - if a rational is encountered, preserve it
+ * - if one of the arguments is not exact, return an approximation
+ *
+ * EXACT
+ * - 2 + 5 -> 7
+ * - 2 + 5/7 -> 19/7
+ * - 2 + √2 -> 2 + √2
+ * - 2 + √(5/7) -> 2 + √(5/7)
+ * - 5/7 + 9/11 -> 118/77
+ * - 5/7 + √2 -> 5/7 + √2
+ * - 10/14 + √(18/9) -> 5/7 + √2
+ * - √2 + √5 -> √2 + √5
+ * - √2 + √2 -> 2√2
+ * - sin(2) -> sin(2)
+ * - sin(pi/3) -> √3/2
+ *
+ * APPROXIMATE
+ * - 2 + 2.1 -> 4.1
+ * - 2 + √2.1 -> 3.44914
+ * - 5/7 + √2.1 -> 2.16342
+ * - sin(2) + √2.1 -> 2.35844
+ */
+/**
+ * Return a boxed number representing `num`.
+ *
+ * Note: `boxNumber()` should only be called from `ce.number()` in order to
+ * benefit from number expression caching.
+ */
+export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | number | string | Complex | Decimal | Rational, options?: {
+    metadata?: Metadata;
+    canonical?: boolean;
+}): BoxedExpression | null;
+/**
+ * Given a head and a set of arguments, return a boxed function expression.
+ *
+ * If available, preserve LaTeX and wikidata metadata in the boxed expression.
+ *
+ * Note that `boxFunction()` should only be called from `ce.fn()` or `box()`
+ */
+export declare function boxFunction(ce: IComputeEngine, head: string, ops: SemiBoxedExpression[], options: {
+    metadata?: Metadata;
+    canonical?: boolean;
+}): BoxedExpression;
 /**
  * Notes about the boxed form:
  *
@@ -17,6 +84,7 @@ import { MathJsonNumber } from '../../math-json/math-json-format';
  *    `Add`/`Multiply` expression avoids this ambiguity.
  *
  * [3] An expression with a `Rational` head is converted to a rational number.
+ *    if possible, to a `Divide` otherwise.
  *
  * [4] A `Negate` function applied to a number literal is converted to a number.
  *
@@ -24,19 +92,9 @@ import { MathJsonNumber } from '../../math-json/math-json-format';
  * Note that `Negate` is only distributed over addition. In practice, having
  * `Negate` factored on multiply/divide is more useful to detect patterns.
  *
- * Note that the `box()` function should only be called from `ComputeEngine`
- *
- */
-export declare function box(ce: IComputeEngine, expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression): BoxedExpression;
-/**
- * Return a boxed number representing `num`.
- *
- * This function tries to avoid creating a boxed number if `num` corresponds
- * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
- *
- *
- * Note that `boxNumber()` should only be called from `ComputeEngine`
+ * Note that the `box()` function should only be called from `ce.box()`
  *
- * The result may not be canonical
  */
-export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | BoxedExpression | number | Complex | Decimal | [numer: number, denom: number], metadata?: Metadata): BoxedExpression | null;
+export declare function box(ce: IComputeEngine, expr: null | undefined | Decimal | Complex | Rational | SemiBoxedExpression, options?: {
+    canonical?: boolean;
+}): BoxedExpression;

package/dist/types/compute-engine/boxed-expression/boxed-dictionary.d.ts

@@ -1,5 +1,5 @@
-/* 0.7.0 */
-import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOption, BoxedDomain } from '../public';
+/* 0.9.0 */
+import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, BoxedSubstitution } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedDictionary
@@ -9,7 +9,10 @@ export declare class BoxedDictionary extends AbstractBoxedExpression {
     private _isCanonical;
     constructor(ce: IComputeEngine, dict: {
         [key: string]: SemiBoxedExpression;
-    }, metadata?: Metadata);
+    }, options?: {
+        canonical?: boolean;
+        metadata?: Metadata;
+    });
     unbind(): undefined;
     get hash(): number;
     get complexity(): number;
@@ -24,7 +27,7 @@ export declare class BoxedDictionary extends AbstractBoxedExpression {
     get json(): Expression;
     /** Structural equality */
     isSame(rhs: BoxedExpression): boolean;
-    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    match(rhs: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
     /** Mathematical equality */
     isEqual(rhs: BoxedExpression): boolean;
     apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
@@ -35,5 +38,7 @@ export declare class BoxedDictionary extends AbstractBoxedExpression {
     simplify(options?: SimplifyOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;
     replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression;
-    subs(sub: Substitution): BoxedExpression;
+    subs(sub: Substitution, options?: {
+        canonical: boolean;
+    }): BoxedExpression;
 }

package/dist/types/compute-engine/boxed-expression/boxed-domain.d.ts

@@ -1,5 +1,5 @@
-/* 0.7.0 */
-import { BoxedDomain, BoxedExpression, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+/* 0.9.0 */
+import { BoxedDomain, BoxedExpression, BoxedSubstitution, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOptions } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
  * A `_BoxedDomain` is a wrapper around a boxed, canonical, domain expression.
@@ -31,7 +31,7 @@ export declare class _BoxedDomain extends AbstractBoxedExpression implements Box
     isSame(rhs: BoxedExpression): boolean;
     is(rhs: any): boolean;
     isCompatible(dom: BoxedDomain | DomainLiteral, compatibility?: DomainCompatibility): boolean;
-    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    match(rhs: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
     get head(): string;
     get domain(): BoxedDomain;
     get isNothing(): boolean;
@@ -46,6 +46,5 @@ export declare class _BoxedDomain extends AbstractBoxedExpression implements Box
 export declare function boxDomain(ce: IComputeEngine, dom: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
 /** Validate that `expr` is a Domain */
 export declare function isDomain(expr: Expression | BoxedExpression | BoxedDomain | DomainExpression): expr is BoxedDomain | DomainExpression;
-export declare function isSubdomainOf(lhs: DomainExpression<BoxedExpression>, rhs: DomainExpression<BoxedExpression>): boolean;
 /** Return the ancestor domain that is shared by both `a` and `b` */
 export declare function sharedAncestorDomain(a: BoxedDomain, b: BoxedDomain): BoxedDomain;

package/dist/types/compute-engine/boxed-expression/boxed-function-definition.d.ts

@@ -1,2 +1,2 @@
-/* 0.7.0 */
+/* 0.9.0 */
 export declare function makeFunctionDefinition(engine: IComputeEngine, def: FunctionDefinition): BoxedFunctionDefinition;