@cortex-js/compute-engine 0.4.2 → 0.4.3

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

@@ -0,0 +1,90 @@
+/* 0.4.3 */
+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 = {
+    url?: string;
+    source?: string;
+    offset?: number;
+    line?: number;
+    column?: number;
+    around?: string;
+};
+export declare type Signal = {
+    severity?: 'warning' | 'error';
+    /** An error/warning code or, a code with one or more arguments specific to
+     * the signal code.
+     */
+    message: SignalMessage;
+    /** If applicable, the head of the function about which the
+     * signal was raised
+     */
+    head?: string;
+    /** Location where the signal was raised. */
+    origin?: SignalOrigin;
+};
+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';
+};
+export declare type WarningSignalHandler = (warnings: WarningSignal[]) => void;
+/**
+ * The error codes can be used in an `ErrorCode` expression:
+ *
+ *        `["ErrorCode", "'syntax-error'", arg1]`
+ *
+ * It evaluates to a localized, human-readable string.
+ *
+ *
+ * * `unknown-symbol`: a symbol was encountered which does not have a
+ * definition.
+ *
+ * * `unknown-operator`: a presumed operator was encountered which does not
+ * have a definition.
+ *
+ * * `unknown-function`: a LaTeX command was encountered which does not
+ * have a definition.
+ *
+ * * `unexpected-command`: a LaTeX command was encountered when only a string
+ * was expected
+ *
+ * * `unexpected-superscript`: a superscript was encountered in an unexpected
+ * context, or no `powerFunction` was defined. By default, superscript can
+ * be applied to numbers, symbols or expressions, but not to operators (e.g.
+ * `2+^34`) or to punctuation.
+ *
+ * * `unexpected-subscript`: a subscript was encountered in an unexpected
+ * context or no 'subscriptFunction` was defined. By default, subscripts
+ * are not expected on numbers, operators or symbols. Some commands (e.g. `\sum`)
+ * do expected a subscript.
+ *
+ * * `unexpected-sequence`: some adjacent elements were encountered (for
+ * example `xy`), but no `invisibleOperator` is defined, therefore the elements
+ * can't be combined. The default `invisibleOperator` is `Multiply`, but you
+ * can also use `list`.
+ *
+ * * `expected-argument`: a LaTeX command that requires one or more argument
+ * was encountered without the required arguments.
+ *
+ * * `expected-operand`: an operator was encountered without its required
+ * operands.
+ *
+ * * `non-associative-operator`: an operator which is not associative was
+ * encountered in an associative context, for example: `a < b < c` (assuming
+ * `<` is defined as non-associative)
+ *
+ * * `postfix-operator-requires-one-operand`: a postfix operator which requires
+ * a single argument was encountered with no arguments or more than one argument
+ *
+ * * `prefix-operator-requires-one-operand`: a prefix operator which requires
+ * a single argument was encountered with no arguments or more than one argument
+ *
+ * * `base-out-of-range`:  The base is expected to be between 2 and 36.
+ *
+ */
+export declare type ErrorCode = 'expected-argument' | 'unexpected-argument' | 'expected-operator' | 'expected-operand' | 'invalid-name' | 'invalid-dictionary-entry' | 'unknown-symbol' | 'unknown-operator' | 'unknown-function' | 'unknown-command' | 'unexpected-command' | 'unbalanced-symbols' | 'unexpected-superscript' | 'unexpected-subscript' | 'unexpected-sequence' | 'non-associative-operator' | 'function-has-too-many-arguments' | 'function-has-too-few-arguments' | 'operator-requires-one-operand' | 'infix-operator-requires-two-operands' | 'prefix-operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'associative-function-has-too-few-arguments' | 'commutative-function-has-too-few-arguments' | 'threadable-function-has-too-few-arguments' | 'hold-first-function-has-too-few-arguments' | 'hold-rest-function-has-too-few-arguments' | 'base-out-of-range' | 'syntax-error';

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

@@ -1,6 +1,21 @@
-/* 0.4.2 */
-import { ComputeEngine, Numeric } from './public';
-export declare function internalIs(engine: ComputeEngine, proposition: Expression): boolean | undefined;
-export declare function normalizeProposition<T extends number = Numeric>(proposition: Expression<T>): [Expression<T>, boolean];
-export declare function internalAssume<T extends number = Numeric>(engine: ComputeEngine<T>, proposition: Expression<T>): 'contradiction' | 'tautology' | 'ok';
-export declare function forget<T extends number = Numeric>(engine: ComputeEngine<T>, arg: Expression<T>): void;
+/* 0.4.3 */
+/**
+ * Add an assumption, in the form of a predicate, for example:
+ *
+ * - `x = 5`
+ * - `x ∈ ℕ`
+ * - `x > 3`
+ * - `x + y = 5`
+ *
+ * Some assumptions are handled separately, specifically, those that can
+ * be represented as a symbol definition (equality to an expression,
+ * membership to Integer, RealNumber, etc..., >0, <=0, etc...). The result
+ * of these are stored directly in the current scope's symbols dictionary
+ * (and an entry for the symbol is created if necessary).
+ *
+ * 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).
+ *
+ */
+export declare function assume(_proposition: BoxedExpression): AssumeResult;

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

@@ -0,0 +1,107 @@
+/* 0.4.3 */
+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';
+/**
+ * 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 get isCanonical(): boolean;
+    abstract set isCanonical(_val: boolean);
+    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 */
+    protected _latex?: string;
+    protected _wikidata?: string;
+    constructor(ce: IComputeEngine, metadata?: Metadata);
+    /** Object.toJSON(), called by JSON.Stringify */
+    toJSON(): string;
+    /** Object.toString() */
+    toString(): string;
+    /** Object.valueOf(): return a primitive value for the object */
+    valueOf(): any;
+    /** Object.is() */
+    is(rhs: any): boolean;
+    has(_v: string | string[]): boolean;
+    get description(): string[];
+    get url(): string;
+    _purge(): undefined;
+    get isPure(): boolean;
+    get isLiteral(): boolean;
+    get latex(): LatexString;
+    set latex(val: LatexString);
+    get wikidata(): string;
+    set wikidata(val: string);
+    get complexity(): number;
+    get ops(): null | BoxedExpression[];
+    get nops(): number;
+    get op1(): BoxedExpression;
+    get op2(): BoxedExpression;
+    get op3(): BoxedExpression;
+    get symbolDefinition(): BoxedSymbolDefinition | undefined;
+    get functionDefinition(): BoxedFunctionDefinition | undefined;
+    _repairDefinition(): void;
+    get keys(): IterableIterator<string> | null;
+    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 isMissing(): boolean;
+    get value(): BoxedExpression | undefined;
+    set value(_value: BoxedExpression | undefined);
+    get numericValue(): BoxedExpression | undefined;
+    isSubsetOf(_d: BoxedExpression | string): undefined | boolean;
+    get domain(): BoxedExpression;
+    set domain(_domain: BoxedExpression);
+    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 isNumber(): boolean | undefined;
+    get isInteger(): boolean | undefined;
+    get isRational(): boolean | undefined;
+    get isAlgebraic(): boolean | undefined;
+    get isReal(): boolean | undefined;
+    get isExtendedReal(): boolean | undefined;
+    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;
+    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

@@ -0,0 +1,56 @@
+/* 0.4.3 */
+import { Decimal } from 'decimal.js';
+import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata } from '../public';
+import { Expression, MathJsonNumber } from '../../math-json/math-json-format';
+/**
+ * Notes about the boxed form:
+ *
+ * [1] Expression with a head of `Number`, `String`, `Symbol` and `Dictionary`
+ *      are converted to the corresponding atomic expression.
+ *
+ * [2] Expressions with a head of `Complex` are converted to a (complex) number
+ *     or a `Add`/`Multiply` expression.
+ *
+ *     The precedence of `Complex` (for serialization) is sometimes the
+ *     precedence of `Add` (when re and im != 0), sometimes the precedence of
+ *    `Multiply` (when im or re === 0). Using a number or an explicit
+ *    `Add`/`Multiply` expression avoids this ambiguity.
+ *
+ * [3] An expression with a `Rational` head is converted to a rational number.
+ *
+ * [4] A `Negate` function applied to a number literal is converted to a number.
+ *
+ *
+ * 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`
+ */
+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()`
+ */
+export declare function boxFunction(ce: IComputeEngine, head: string, ops: Expression[], metadata?: Metadata): BoxedExpression;

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

@@ -0,0 +1,39 @@
+/* 0.4.3 */
+import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOption } from '../public';
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/**
+ * BoxedDictionary
+ */
+export declare class BoxedDictionary extends AbstractBoxedExpression {
+    private _value;
+    private _isCanonical;
+    constructor(ce: IComputeEngine, dict: {
+        [key: string]: SemiBoxedExpression;
+    }, metadata?: Metadata);
+    _purge(): undefined;
+    get hash(): number;
+    get complexity(): number;
+    get head(): 'Dictionary';
+    get isPure(): boolean;
+    getKey(key: string): BoxedExpression | undefined;
+    hasKey(key: string): boolean;
+    get keys(): IterableIterator<string>;
+    get keysCount(): number;
+    has(x: string | string[]): boolean;
+    get domain(): BoxedExpression;
+    get json(): Expression;
+    /** Structural equality */
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    /** Mathematical equality */
+    isEqual(rhs: BoxedExpression): boolean;
+    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
+    evaluate(options?: EvaluateOptions): BoxedExpression;
+    get isCanonical(): boolean;
+    set isCanonical(val: boolean);
+    get canonical(): BoxedExpression;
+    simplify(options?: SimplifyOptions): BoxedExpression;
+    N(options?: NOptions): BoxedExpression;
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression;
+    subs(sub: Substitution): BoxedExpression;
+}

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

@@ -0,0 +1,8 @@
+/* 0.4.3 */
+import { BoxedExpression, IComputeEngine, Metadata } from '../public';
+export declare class Domain extends BoxedSymbol {
+    constructor(ce: IComputeEngine, dom: string, metadata?: Metadata);
+    get head(): string;
+    get domain(): BoxedExpression;
+    isSubsetOf(dom: BoxedExpression | string): boolean;
+}

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

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

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

@@ -0,0 +1,93 @@
+/* 0.4.3 */
+import { Expression } from '../../math-json/math-json-format';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption } from '../public';
+/**
+ * BoxedFunction
+ */
+export declare class BoxedFunction extends AbstractBoxedExpression {
+    private _head;
+    private _ops;
+    private _def;
+    private _isCanonical;
+    private _isPure;
+    /** The cached values of applying the tail to the head.
+     * If the function is not pure, it is never cached.
+     */
+    private _value;
+    private _numericValue;
+    private _hash;
+    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata);
+    get hash(): number;
+    _purge(): undefined;
+    get wikidata(): string;
+    get description(): string[];
+    get url(): string;
+    get complexity(): number;
+    get head(): string | BoxedExpression;
+    get value(): BoxedExpression | undefined;
+    get numericValue(): BoxedExpression | undefined;
+    get isPure(): boolean;
+    get isLiteral(): 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;
+    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 isOne(): boolean | undefined;
+    get isNegativeOne(): boolean | undefined;
+    get isPositive(): boolean | undefined;
+    get isNonPositive(): boolean | undefined;
+    get isNegative(): boolean | undefined;
+    get isNonNegative(): boolean | undefined;
+    get isNumber(): boolean | undefined;
+    get isInteger(): boolean | undefined;
+    get isRational(): boolean | undefined;
+    get isAlgebraic(): boolean | undefined;
+    get isReal(): boolean | undefined;
+    get isExtendedReal(): boolean | undefined;
+    get isComplex(): boolean | undefined;
+    get isImaginary(): boolean | undefined;
+    get json(): Expression;
+    has(x: string | string[]): boolean;
+    /** `isSame` is structural/symbolic equality */
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    /** `isEqual` is mathematical equality */
+    isEqual(rhs: BoxedExpression): boolean;
+    get sgn(): -1 | 0 | 1 | undefined | null;
+    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;
+    simplify(options?: SimplifyOptions): BoxedExpression;
+    evaluate(options?: EvaluateOptions): BoxedExpression;
+    N(options?: NOptions): BoxedExpression;
+    solve(_vars: Iterable<string>): null | BoxedExpression[];
+    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;
+/** Apply the function `f` to elements of `xs`, except to the elements
+ * described by `skip`:
+ * - `all`: don't apply f to any elements
+ * - `none`: apply `f` to all elements
+ * - `first`: apply `f` to all elements except the first
+ * - `rest`: apply `f` to the first element, skip the  others
+ * - 'last': apply `f` to all elements except the last
+ * - 'most': apply `f` to the last elements, skip the others
+ *
+ * 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[];

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

@@ -0,0 +1,83 @@
+/* 0.4.3 */
+import { Complex } from 'complex.js';
+import { Expression } from '../../math-json/math-json-format';
+import { BoxedExpression, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/**
+ * BoxedNumber
+ */
+export declare class BoxedNumber extends AbstractBoxedExpression {
+    protected readonly _value: number | Decimal | Complex | [numer: number, denom: number];
+    private _domain;
+    private _head;
+    private _hash;
+    protected _isCanonical: boolean;
+    /**
+     * By the time the constructor is called, the `value` should have been
+     * screened for cases where it's a well-known value (0, NaN, +Infinity, etc...)
+     * or non-normal (complex number with im = 0, rational with denom = 1, etc...)
+     * This is done in `ce.boxNumber()`. In general, use `ce.boxNumber()` rather
+     * than calling the constructor directly.
+     */
+    constructor(ce: IComputeEngine, value: string | number | Decimal | Complex | [numer: number, denom: number], metadata?: Metadata);
+    get hash(): number;
+    get head(): string;
+    get isPure(): boolean;
+    get isLiteral(): boolean;
+    get isCanonical(): boolean;
+    set isCanonical(val: boolean);
+    get numericValue(): BoxedExpression | undefined;
+    get machineValue(): number | null;
+    get decimalValue(): Decimal | null;
+    get complexValue(): Complex | null;
+    get rationalValue(): [numer: number, denom: number] | [null, null];
+    get asFloat(): number | null;
+    get asSmallInteger(): number | null;
+    get asRational(): [number, number] | [null, null];
+    get domain(): BoxedExpression;
+    get json(): Expression;
+    get sgn(): -1 | 0 | 1 | undefined | null;
+    isSame(rhs: BoxedExpression): boolean;
+    isEqual(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    /** Compare this with another BoxedNumber.
+     * `rhs` must be a BoxedNumber. Use `isEqualWithTolerance(rhs.numericValue)`
+     * if necessary.
+     */
+    isEqualWithTolerance(rhs: BoxedExpression, tolerance: number): boolean;
+    isLess(rhs: BoxedExpression): boolean | undefined;
+    isLessEqual(rhs: BoxedExpression): boolean | undefined;
+    isGreater(rhs: BoxedExpression): boolean | undefined;
+    isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    /** x > 0, same as `isGreater(0)` */
+    get isPositive(): boolean | undefined;
+    /** x >= 0, same as `isGreaterEqual(0)` */
+    get isNonNegative(): boolean | undefined;
+    /** x < 0, same as `isLess(0)` */
+    get isNegative(): boolean | undefined;
+    /** x <= 0, same as `isLessEqual(0)` */
+    get isNonPositive(): boolean | undefined;
+    get isZero(): boolean;
+    get isNotZero(): boolean;
+    get isOne(): boolean;
+    get isNegativeOne(): boolean;
+    get isOdd(): boolean | undefined;
+    get isEven(): boolean | undefined;
+    get isPrime(): boolean | undefined;
+    get isComposite(): boolean | undefined;
+    get isInfinity(): boolean;
+    get isNaN(): boolean;
+    get isFinite(): boolean;
+    get isNumber(): true;
+    get isInteger(): boolean;
+    get isRational(): boolean;
+    get isAlgebraic(): boolean | undefined;
+    get isReal(): boolean;
+    get isExtendedReal(): boolean;
+    get isComplex(): boolean | undefined;
+    get isImaginary(): boolean | undefined;
+    get isExtendedComplex(): boolean | undefined;
+    get canonical(): BoxedExpression;
+    simplify(_options?: SimplifyOptions): BoxedExpression;
+    N(_options?: NOptions): BoxedExpression;
+}

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

@@ -0,0 +1,21 @@
+/* 0.4.3 */
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, 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;
+    get json(): Expression;
+    get head(): string | BoxedExpression;
+    get domain(): BoxedExpression;
+    get isCanonical(): boolean;
+    set isCanonical(_val: boolean);
+    isSame(rhs: BoxedExpression): boolean;
+    isEqual(rhs: BoxedExpression): boolean;
+    match(expr: BoxedExpression, options?: PatternMatchOption): Substitution | 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

@@ -0,0 +1,23 @@
+/* 0.4.3 */
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+/**
+ * BoxedString
+ */
+export declare class BoxedString extends AbstractBoxedExpression {
+    private readonly _string;
+    constructor(ce: IComputeEngine, expr: string, metadata?: Metadata);
+    get hash(): number;
+    get json(): Expression;
+    get head(): string;
+    get isPure(): boolean;
+    get isLiteral(): boolean;
+    get isCanonical(): boolean;
+    set isCanonical(_va: boolean);
+    get domain(): BoxedExpression;
+    get complexity(): number;
+    get string(): string;
+    isEqual(rhs: BoxedExpression): boolean;
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+}

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

@@ -0,0 +1,98 @@
+/* 0.4.3 */
+export declare function domainToFlags(dom: BoxedExpression | undefined | null): Partial<SymbolFlags>;
+export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
+    private _engine;
+    private _value;
+    readonly name: string;
+    wikidata?: string;
+    description?: string | string[];
+    readonly scope: RuntimeScope | undefined;
+    private _domain;
+    private _number;
+    private _integer;
+    private _rational;
+    private _algebraic;
+    private _real;
+    private _extendedReal;
+    private _complex;
+    private _extendedComplex;
+    private _imaginary;
+    private _positive;
+    private _nonPositive;
+    private _negative;
+    private _nonNegative;
+    private _zero;
+    private _notZero;
+    private _one;
+    private _negativeOne;
+    private _infinity;
+    private _NaN;
+    private _finite;
+    private _even;
+    private _odd;
+    private _prime;
+    private _composite;
+    private _at;
+    at?: (index: string | number) => undefined | BoxedExpression;
+    readonly constant: boolean;
+    readonly hold: boolean;
+    private _def;
+    prototype?: BoxedFunctionDefinition;
+    self?: any;
+    constructor(ce: IComputeEngine, def: SymbolDefinition);
+    _purge(): undefined;
+    get value(): BoxedExpression | undefined;
+    set value(val: BoxedExpression | undefined);
+    get domain(): BoxedExpression | undefined;
+    set domain(domain: BoxedExpression | undefined | string);
+    updateFlags(flags: Partial<SymbolFlags>): void;
+    setProps(props: Omit<Partial<BoxedSymbolDefinition>, 'domain' | 'value'>): void;
+    get number(): boolean | undefined;
+    set number(val: boolean | undefined);
+    get integer(): boolean | undefined;
+    set integer(val: boolean | undefined);
+    get rational(): boolean | undefined;
+    set rational(val: boolean | undefined);
+    get algebraic(): boolean | undefined;
+    set algebraic(val: boolean | undefined);
+    get real(): boolean | undefined;
+    set real(val: boolean | undefined);
+    get extendedReal(): boolean | undefined;
+    set extendedReal(val: boolean | undefined);
+    get complex(): boolean | undefined;
+    set complex(val: boolean | undefined);
+    get extendedComplex(): boolean | undefined;
+    set extendedComplex(val: boolean | undefined);
+    get imaginary(): boolean | undefined;
+    set imaginary(val: boolean | undefined);
+    get positive(): boolean | undefined;
+    set positive(val: boolean | undefined);
+    get nonPositive(): boolean | undefined;
+    set nonPositive(val: boolean | undefined);
+    get negative(): boolean | undefined;
+    set negative(val: boolean | undefined);
+    get nonNegative(): boolean | undefined;
+    set nonNegative(val: boolean | undefined);
+    get zero(): boolean | undefined;
+    set zero(val: boolean | undefined);
+    get notZero(): boolean | undefined;
+    set notZero(val: boolean | undefined);
+    get one(): boolean | undefined;
+    set one(val: boolean | undefined);
+    get negativeOne(): boolean | undefined;
+    set negativeOne(val: boolean | undefined);
+    get infinity(): boolean | undefined;
+    set infinity(val: boolean | undefined);
+    get finite(): boolean | undefined;
+    set finite(val: boolean | undefined);
+    get NaN(): boolean | undefined;
+    set NaN(val: boolean | undefined);
+    get even(): boolean | undefined;
+    set even(val: boolean | undefined);
+    get odd(): boolean | undefined;
+    set odd(val: boolean | undefined);
+    get prime(): boolean | undefined;
+    set prime(val: boolean | undefined);
+    get composite(): boolean | undefined;
+    set composite(val: boolean | undefined);
+}