@cortex-js/compute-engine 0.5.0 → 0.7.0

package/dist/math-json.esm.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.5.0 */
+/** 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
@@ -32,7 +32,7 @@ function isAtomic(expr) {
  * **U+0027 APOSTROPHE** : **`'`** or an object literal with a `str` key.
  */
 function stringValue(expr) {
-    if (expr === null)
+    if (expr === null || expr === undefined)
         return null;
     if (typeof expr === 'object' && 'str' in expr)
         return expr.str;
@@ -54,7 +54,7 @@ function stringValue(expr) {
  * * `[["Prime", "f"], "x"]` -> `["Prime", "f"]`
  */
 function head(expr) {
-    if (expr === null)
+    if (expr === null || expr === undefined)
         return null;
     if (Array.isArray(expr))
         return expr[0];
@@ -68,7 +68,7 @@ function headName(expr) {
     return typeof h === 'string' ? h : '';
 }
 function op(expr, n) {
-    if (expr === null)
+    if (expr === null || expr === undefined)
         return null;
     if (Array.isArray(expr))
         return expr[n] ?? null;
@@ -76,46 +76,73 @@ function op(expr, n) {
         return expr.fn[n] ?? null;
     return null;
 }
+/**
+ * Return all the elements but the first one, i.e. the arguments of a
+ * function.
+ */
+function ops(expr) {
+    if (expr === null || expr === undefined)
+        return null;
+    if (Array.isArray(expr))
+        return expr.slice(1);
+    if (isFunctionObject(expr))
+        return expr.fn.slice(1);
+    return null;
+}
 function nops(expr) {
-    if (Array.isArray(expr)) {
+    if (expr === null || expr === undefined)
+        return 0;
+    if (Array.isArray(expr))
         return Math.max(0, expr.length - 1);
-    }
-    if (isFunctionObject(expr)) {
+    if (isFunctionObject(expr))
         return Math.max(0, expr.fn.length - 1);
-    }
     return 0;
 }
 function symbol(expr) {
-    if (expr === null)
+    if (expr === null || expr === undefined)
+        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;
-    if (typeof expr === 'string') {
-        if (expr.length >= 2 && expr[0] === "'" && expr[expr.length - 1] === "'") {
-            // It's a string literal, not a symbol
+    return s;
+}
+function keyValuePair(expr) {
+    const h = head(expr);
+    if (h === 'KeyValuePair' || h === 'Tuple' || h === 'Pair') {
+        const key = stringValue(op(expr, 1));
+        if (!key)
             return null;
-        }
-        return expr;
+        return [key, op(expr, 2) ?? 'Nothing'];
     }
-    if (isSymbolObject(expr))
-        return expr.sym;
     return null;
 }
-/**
- * Return all the elements but the first one, i.e. the arguments of a
- * function.
- */
-function tail(expr) {
-    if (Array.isArray(expr)) {
-        return expr.slice(1);
-    }
-    if (isFunctionObject(expr)) {
-        return expr.fn.slice(1);
+function dictionary(expr) {
+    if (expr === null)
+        return null;
+    if (typeof expr === 'object' && 'dict' in expr)
+        return expr.dict;
+    const kv = keyValuePair(expr);
+    if (kv)
+        return { [kv[0]]: kv[1] };
+    const h = head(expr);
+    if (h === 'Dictionary') {
+        const result = {};
+        for (let i = 1; i < nops(expr); i++) {
+            const kv = keyValuePair(op(expr, i));
+            if (kv)
+                result[kv[0]] = kv[1];
+        }
+        return result;
     }
-    return [];
+    return null;
 }
 function applyRecursively(expr, fn) {
     const h = head(expr);
     if (h !== null) {
-        return [fn(h), ...tail(expr).map(fn)];
+        return [fn(h), ...(ops(expr) ?? []).map(fn)];
     }
     const dict = dictionary(expr);
     if (dict !== null) {
@@ -146,11 +173,6 @@ function mapArgs(expr, fn) {
     }
     return result;
 }
-function dictionary(expr) {
-    if (typeof expr === 'object' && 'dict' in expr)
-        return expr.dict;
-    return null;
-}
 /**
  * Return num as a number if it's a valid JSON number (that is
  * a valid JavaScript number but not NaN or +/-Infinity) or
@@ -172,9 +194,41 @@ function asValidJSONNumber(num) {
         }
     }
     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.5.0';
+const version = '0.7.0';
 
-export { applyRecursively, asValidJSONNumber, dictionary as getDictionary, stringValue as getStringValue, head, headName, isAtomic, isDictionaryObject, isFunctionObject, isStringObject, isSymbolObject, mapArgs, nops, op, symbol, tail, version };
+export { applyRecursively, asValidJSONNumber, dictionary as getDictionary, stringValue as getStringValue, head, headName, isAtomic, isDictionaryObject, isFunctionObject, isStringObject, isSymbolObject, mapArgs, nops, op, symbol, version };

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

@@ -1,2 +1,2 @@
-/** MathJSON 0.5.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 Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function s(t){return null===t?null:"string"==typeof t?t.length>=2&&"'"===t[0]&&"'"===t[t.length-1]?null:t:n(t)?t.sym:null}function y(n){return Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):[]}function a(n,t){const r=i(n);if(null!==r)return[t(r),...y(n).map(t)];const u=p(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 g(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 p(n){return"object"==typeof n&&"dict"in n?n.dict:null}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 h="0.5.0";export{a as applyRecursively,A as asValidJSONNumber,p 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,g as mapArgs,c as nops,f as op,s as symbol,y as tail,h as version};
+/** 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};

package/dist/math-json.min.js

@@ -1,2 +1,2 @@
-/** MathJSON 0.5.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 e(n){return null===n?null:Array.isArray(n)?n[0]:r(n)?n.fn[0]:null}function l(n){return Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):[]}function i(n){return"object"==typeof n&&"dict"in n?n.dict:null}n.applyRecursively=function(n,t){const r=e(n);if(null!==r)return[t(r),...l(n).map(t)];const o=i(n);if(null!==o){const n=Object.keys(o),r={};for(const e of n)r[e]=t(o[e]);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=i,n.getStringValue=function(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)},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 e=null;if(Array.isArray(n)&&(e=n),r(n)&&(e=n.fn),null===e)return[];let l=1;const i=[];for(;l<e.length;)i.push(t(e[l])),l+=1;return i},n.nops=function(n){return Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0},n.op=function(n,t){var e,l;return null===n?null:Array.isArray(n)?null!==(e=n[t])&&void 0!==e?e:null:r(n)&&null!==(l=n.fn[t])&&void 0!==l?l:null},n.symbol=function(n){return null===n?null:"string"==typeof n?n.length>=2&&"'"===n[0]&&"'"===n[n.length-1]?null:n:t(n)?n.sym:null},n.tail=l,n.version="0.5.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.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={});

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

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

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.7.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 = {

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.7.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -18,4 +18,4 @@
  * current context).
  *
  */
-export declare function assume(_proposition: BoxedExpression): AssumeResult;
+export declare function assume(proposition: BoxedExpression): AssumeResult;

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

@@ -1,7 +1,7 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import type { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOption, SemiBoxedExpression, SimplifyOptions, Substitution } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, BoxedDomain, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOption, SemiBoxedExpression, SimplifyOptions, Substitution, RuntimeScope, DomainCompatibility, DomainLiteral, BoxedBaseDefinition } from '../public';
 /**
  * AbstractBoxedExpression
  */
@@ -15,8 +15,9 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     abstract get hash(): number;
     abstract match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
     readonly engine: IComputeEngine;
-    /** Authentic LaTeX, obtained from a source, i.e. from parsing, not generated
-     * synthetically */
+    /** Verbatim LaTeX, obtained from a source, i.e. from parsing, not generated
+     * synthetically
+     */
     protected _latex?: string;
     protected _wikidata?: string;
     constructor(ce: IComputeEngine, metadata?: Metadata);
@@ -28,25 +29,35 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     valueOf(): number | string | [number, number];
     /** Object.is() */
     is(rhs: any): boolean;
+    isCompatible(_dom: BoxedDomain | DomainLiteral, _kind?: DomainCompatibility): boolean;
     has(_v: string | string[]): boolean;
     get description(): string[];
     get url(): string;
-    _purge(): undefined;
     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[];
+    getSubexpressions(head: string): BoxedExpression[];
+    get subexpressions(): BoxedExpression[];
+    get errors(): BoxedExpression[];
     get ops(): null | BoxedExpression[];
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
+    get basedDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    _repairDefinition(): void;
+    bind(_scope: RuntimeScope | null): void;
+    unbind(): void;
     get keys(): IterableIterator<string> | null;
     get keysCount(): number;
     getKey(_key: string): BoxedExpression | undefined;
@@ -60,13 +71,15 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     get asRational(): [number, number] | [null, null];
     get sgn(): -1 | 0 | 1 | undefined | null;
     get symbol(): string | null;
-    get isMissing(): boolean;
+    get isNothing(): boolean;
+    get isValid(): boolean;
     get value(): BoxedExpression | undefined;
     set value(_value: BoxedExpression | number | undefined);
     get numericValue(): BoxedExpression | undefined;
-    isSubsetOf(_d: BoxedExpression | string): undefined | boolean;
-    get domain(): BoxedExpression;
-    set domain(_domain: BoxedExpression);
+    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;

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

@@ -1,7 +1,7 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata } from '../public';
-import { Expression, MathJsonNumber } from '../../math-json/math-json-format';
+import { MathJsonNumber } from '../../math-json/math-json-format';
 /**
  * Notes about the boxed form:
  *
@@ -36,21 +36,7 @@ export declare function box(ce: IComputeEngine, expr: Decimal | Complex | [num:
  *
  *
  * Note that `boxNumber()` should only be called from `ComputeEngine`
- */
-export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | BoxedExpression | number | Complex | Decimal | [numer: number, denom: number], metadata?: Metadata): BoxedExpression | null;
-/**
- * Note that `boxDomain()` should only be called from `ComputeEngine`
- */
-export declare function boxDomain(ce: IComputeEngine, dom: string | BoxedExpression, metadata?: Metadata): BoxedExpression;
-/**
- * Given a head (either as a string or a lambda expression)
- * and a set of arguments, return a boxed function expression.
- *
- * If available, preserve LaTeX and wikidata metadata in the boxed expression.
  *
- * The result is *not* a canonical expression.
- *
- * Note that `boxFunction()` should only be called from `ComputeEngine` or
- * `box()`
+ * The result may not be canonical
  */
-export declare function boxFunction(ce: IComputeEngine, head: string, ops: Expression[], metadata?: Metadata): BoxedExpression;
+export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | BoxedExpression | number | Complex | Decimal | [numer: number, denom: number], metadata?: Metadata): BoxedExpression | null;

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

@@ -1,5 +1,5 @@
-/* 0.5.0 */
-import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOption } from '../public';
+/* 0.7.0 */
+import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOption, BoxedDomain } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedDictionary
@@ -10,7 +10,7 @@ export declare class BoxedDictionary extends AbstractBoxedExpression {
     constructor(ce: IComputeEngine, dict: {
         [key: string]: SemiBoxedExpression;
     }, metadata?: Metadata);
-    _purge(): undefined;
+    unbind(): undefined;
     get hash(): number;
     get complexity(): number;
     get head(): 'Dictionary';
@@ -20,7 +20,7 @@ export declare class BoxedDictionary extends AbstractBoxedExpression {
     get keys(): IterableIterator<string>;
     get keysCount(): number;
     has(x: string | string[]): boolean;
-    get domain(): BoxedExpression;
+    get domain(): BoxedDomain;
     get json(): Expression;
     /** Structural equality */
     isSame(rhs: BoxedExpression): boolean;

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

@@ -1,8 +1,51 @@
-/* 0.5.0 */
-import { BoxedExpression, IComputeEngine, Metadata } from '../public';
-export declare class Domain extends BoxedSymbol {
-    constructor(ce: IComputeEngine, dom: string, metadata?: Metadata);
+/* 0.7.0 */
+import { BoxedDomain, BoxedExpression, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/**
+ * A `_BoxedDomain` is a wrapper around a boxed, canonical, domain expression.
+ *
+ * If could also be an error, in which case, `isValid` is `false`.
+ *
+ */
+export declare class _BoxedDomain extends AbstractBoxedExpression implements BoxedDomain {
+    /** The value of a boxed domain is either a string if a domain literal, or a
+     * domain constructor function.
+     * Since the domains are alway canonicalized when boxed, their value can
+     * be represented by a simple array, without the need for extra boxing.
+     */
+    _value: DomainExpression<BoxedExpression>;
+    private _hash;
+    constructor(ce: IComputeEngine, dom: DomainExpression, metadata?: Metadata);
+    get isCanonical(): boolean;
+    /** Boxed domains are always canonical. */
+    get canonical(): _BoxedDomain;
+    get isValid(): boolean;
+    get json(): Expression;
+    get literal(): string | null;
+    get ctor(): DomainConstructor | null;
+    get domainArgs(): (string | BoxedExpression | DomainExpression<BoxedExpression>)[] | null;
+    get domainArg1(): string | BoxedExpression | DomainExpression<BoxedExpression> | null;
+    get codomain(): BoxedDomain | null;
+    get hash(): number;
+    isEqual(rhs: BoxedExpression): boolean;
+    isSame(rhs: BoxedExpression): boolean;
+    is(rhs: any): boolean;
+    isCompatible(dom: BoxedDomain | DomainLiteral, compatibility?: DomainCompatibility): boolean;
+    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
     get head(): string;
-    get domain(): BoxedExpression;
-    isSubsetOf(dom: BoxedExpression | string): boolean;
+    get domain(): BoxedDomain;
+    get isNothing(): boolean;
+    get isFunction(): boolean;
+    get isNumeric(): boolean;
+    get isRelationalOperator(): boolean;
 }
+/**
+ * Note that `boxDomain()` should only be called from `ComputeEngine`.
+ * This gives a chance for `ComputeEngine` to substitute cached objects.
+ */
+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.5.0 */
+/* 0.7.0 */
 export declare function makeFunctionDefinition(engine: IComputeEngine, def: FunctionDefinition): BoxedFunctionDefinition;

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

@@ -1,15 +1,18 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption, BoxedDomain, BoxedLambdaExpression, RuntimeScope } from '../public';
 /**
  * BoxedFunction
  */
 export declare class BoxedFunction extends AbstractBoxedExpression {
+    private _scope;
     private _head;
     private _ops;
     private _def;
     private _isCanonical;
     private _isPure;
+    /** The domain of the value of the function applied to its arguments */
+    private _codomain;
     /** The cached values of applying the tail to the head.
      * If the function is not pure, it is never cached.
      */
@@ -18,7 +21,7 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     private _hash;
     constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata);
     get hash(): number;
-    _purge(): undefined;
+    unbind(): void;
     get wikidata(): string;
     get description(): string[];
     get url(): string;
@@ -28,15 +31,15 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     get numericValue(): BoxedExpression | undefined;
     get isPure(): boolean;
     get isLiteral(): boolean;
+    get isValid(): boolean;
     get ops(): BoxedExpression[];
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    _repairDefinition(): void;
-    /** Domain of the value of the function */
-    get domain(): BoxedExpression;
+    bind(scope: RuntimeScope | null): void;
+    get domain(): BoxedDomain;
     isLess(rhs: BoxedExpression): boolean | undefined;
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     isGreater(rhs: BoxedExpression): boolean | undefined;
@@ -68,8 +71,8 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     map<T = BoxedExpression>(fn: (x: BoxedExpression) => T): IterableIterator<T>;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
-    get canonical(): BoxedExpression;
     apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
+    get canonical(): BoxedExpression;
     simplify(options?: SimplifyOptions): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;
@@ -77,8 +80,7 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
     subs(sub: Substitution): BoxedExpression;
 }
-export declare function lambda(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
-export declare function ungroup(expr: BoxedExpression): BoxedExpression;
+export declare function lambda(ce: IComputeEngine, fn: BoxedLambdaExpression, args: BoxedExpression[]): BoxedExpression;
 /** Apply the function `f` to elements of `xs`, except to the elements
  * described by `skip`:
  * - `all`: don't apply f to any elements
@@ -88,8 +90,9 @@ export declare function ungroup(expr: BoxedExpression): BoxedExpression;
  * - 'last': apply `f` to all elements except the last
  * - 'most': apply `f` to the last elements, skip the others
  *
- * Account for `Hold`, `ReleaseHold` and  `Nothing`.
+ * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
  *
  * If `f` returns `null`, the element is not added to the result
  */
-export declare function holdMap(xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', f: (BoxedExpression: any) => BoxedExpression | null): BoxedExpression[];
+export declare function holdMap(head: string, xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', associative: boolean, f: (x: BoxedExpression) => BoxedExpression | null): BoxedExpression[];
+export declare function canonicalHoldMap(head: string, xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', associative: boolean): BoxedExpression[];

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

@@ -1,7 +1,7 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedNumber
@@ -34,7 +34,7 @@ export declare class BoxedNumber extends AbstractBoxedExpression {
     get asFloat(): number | null;
     get asSmallInteger(): number | null;
     get asRational(): [number, number] | [null, null];
-    get domain(): BoxedExpression;
+    get domain(): BoxedDomain;
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     isSame(rhs: BoxedExpression): boolean;

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

@@ -1,20 +1,20 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
+import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
 export declare class BoxedPattern extends AbstractBoxedExpression implements Pattern {
     _pattern: BoxedExpression;
     _canonicalPattern: BoxedExpression | undefined;
     constructor(ce: IComputeEngine, pattern: LatexString | SemiBoxedExpression, metadata?: Metadata);
     get hash(): number;
-    _purge(): undefined;
+    unbind(): void;
     get json(): Expression;
     get head(): string | BoxedExpression;
-    get domain(): BoxedExpression;
+    get domain(): BoxedDomain;
     get isCanonical(): boolean;
     set isCanonical(_val: boolean);
     isSame(rhs: BoxedExpression): boolean;
     isEqual(rhs: BoxedExpression): boolean;
-    match(expr: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    match(expr: BoxedExpression, options?: PatternMatchOption): BoxedSubstitution | null;
     test(expr: BoxedExpression, options?: PatternMatchOption): boolean;
     count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOption): number;
     subs(sub: Substitution): BoxedPattern;

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

@@ -1,6 +1,6 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
 /**
  * BoxedString
  */
@@ -14,7 +14,7 @@ export declare class BoxedString extends AbstractBoxedExpression {
     get isLiteral(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get domain(): BoxedExpression;
+    get domain(): BoxedDomain;
     get complexity(): number;
     get string(): string;
     isEqual(rhs: BoxedExpression): boolean;

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

@@ -1,13 +1,14 @@
-/* 0.5.0 */
-export declare function domainToFlags(dom: BoxedExpression | undefined | null): Partial<SymbolFlags>;
+/* 0.7.0 */
+export declare function domainToFlags(dom: BoxedDomain | undefined | null): Partial<SymbolFlags>;
 export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
     private _engine;
+    readonly scope: RuntimeScope | undefined;
     private _value;
     readonly name: string;
     wikidata?: string;
     description?: string | string[];
-    readonly scope: RuntimeScope | undefined;
     private _domain;
+    private _inferedDomain;
     private _number;
     private _integer;
     private _rational;
@@ -38,13 +39,15 @@ export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition
     readonly hold: boolean;
     private _def;
     prototype?: BoxedFunctionDefinition;
-    self?: any;
+    self?: unknown;
     constructor(ce: IComputeEngine, def: SymbolDefinition);
-    _purge(): undefined;
+    reset(): void;
+    unbind(): void;
+    bind(): void;
     get value(): BoxedExpression | undefined;
     set value(val: BoxedExpression | number | undefined);
-    get domain(): BoxedExpression | undefined;
-    set domain(domain: BoxedExpression | undefined | string);
+    get domain(): BoxedDomain | undefined;
+    set domain(domain: BoxedDomain | DomainExpression | undefined);
     updateFlags(flags: Partial<SymbolFlags>): void;
     setProps(props: Omit<Partial<BoxedSymbolDefinition>, 'domain' | 'value'>): void;
     get number(): boolean | undefined;