@cortex-js/compute-engine 0.7.0 → 0.9.0

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

@@ -1,15 +1,15 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption, BoxedDomain, BoxedLambdaExpression, RuntimeScope } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution } from '../public';
 /**
  * BoxedFunction
  */
 export declare class BoxedFunction extends AbstractBoxedExpression {
     private _scope;
-    private _head;
-    private _ops;
+    private readonly _head;
+    private readonly _ops;
+    private _canonical;
     private _def;
-    private _isCanonical;
     private _isPure;
     /** The domain of the value of the function applied to its arguments */
     private _codomain;
@@ -19,27 +19,45 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     private _value;
     private _numericValue;
     private _hash;
-    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata);
+    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+        def?: BoxedFunctionDefinition;
+    });
     get hash(): number;
-    unbind(): void;
-    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 isCanonical(): boolean;
+    set isCanonical(val: boolean);
     get isLiteral(): boolean;
-    get isValid(): boolean;
+    get isPure(): boolean;
+    get json(): Expression;
+    get scope(): RuntimeScope | null;
+    get head(): string | BoxedExpression;
     get ops(): BoxedExpression[];
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
+    get isValid(): boolean;
+    get canonical(): BoxedExpression;
+    map<T = BoxedExpression>(fn: (x: BoxedExpression) => T): IterableIterator<T>;
+    subs(sub: Substitution, options?: {
+        canonical?: boolean;
+    }): BoxedExpression;
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
+    has(x: string | string[]): boolean;
+    /** `isSame` is structural/symbolic equality */
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    unbind(): void;
+    get wikidata(): string | undefined;
+    get description(): string[] | undefined;
+    get url(): string | undefined;
+    get complexity(): number | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    bind(scope: RuntimeScope | null): void;
-    get domain(): BoxedDomain;
+    bind(_scope: RuntimeScope | null): void;
+    get value(): BoxedExpression | undefined;
+    /** `isEqual` is mathematical equality */
+    isEqual(rhs: BoxedExpression): boolean;
     isLess(rhs: BoxedExpression): boolean | undefined;
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     isGreater(rhs: BoxedExpression): boolean | undefined;
@@ -60,27 +78,19 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     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);
-    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
-    get canonical(): BoxedExpression;
+    get domain(): BoxedDomain;
     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;
+    solve(vars: string[]): null | BoxedExpression[];
 }
-export declare function lambda(ce: IComputeEngine, fn: BoxedLambdaExpression, args: BoxedExpression[]): BoxedExpression;
+export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
+/** Apply arguments to an expression. If the expression is a lambda expression
+ * it's wildcard arguments are substituted before being evaluated. Otherwise
+ * the expression is just evaluated.
+ */
+export declare function apply(fn: BoxedExpression, 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
@@ -94,5 +104,4 @@ export declare function lambda(ce: IComputeEngine, fn: BoxedLambdaExpression, ar
  *
  * If `f` returns `null`, the element is not added to the result
  */
-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[];
+export declare function holdMap(xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): BoxedExpression[];

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

@@ -1,47 +1,50 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, Rational, SimplifyOptions, BoxedSubstitution } 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];
+    protected readonly _value: number | Decimal | Complex | Rational;
     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.
+     * 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.number()`. In general, use `ce.number()` rather
+     * than calling this constructor directly.
+     *
+     * We may store as a machine number if a Decimal is passed that is in machine
+     * range
      */
-    constructor(ce: IComputeEngine, value: string | number | Decimal | Complex | [numer: number, denom: number], metadata?: Metadata);
+    constructor(ce: IComputeEngine, value: number | Decimal | Complex | Rational, options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    });
     get hash(): number;
     get head(): string;
     get isPure(): boolean;
     get isLiteral(): boolean;
+    get isExact(): 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 complexity(): number;
+    get value(): BoxedExpression;
+    get numericValue(): number | Decimal | Complex | Rational | null;
     get domain(): BoxedDomain;
     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;
+    match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     /** Compare this with another BoxedNumber.
-     * `rhs` must be a BoxedNumber. Use `isEqualWithTolerance(rhs.numericValue)`
+     * `rhs` must be a BoxedNumber. Use `isEqualWithTolerance(rhs.N())`
      * if necessary.
      */
     isEqualWithTolerance(rhs: BoxedExpression, tolerance: number): boolean;

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

@@ -1,9 +1,8 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
+import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOptions, 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;
     unbind(): void;
@@ -14,8 +13,10 @@ export declare class BoxedPattern extends AbstractBoxedExpression implements Pat
     set isCanonical(_val: boolean);
     isSame(rhs: BoxedExpression): boolean;
     isEqual(rhs: BoxedExpression): boolean;
-    match(expr: BoxedExpression, options?: PatternMatchOption): BoxedSubstitution | null;
-    test(expr: BoxedExpression, options?: PatternMatchOption): boolean;
-    count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOption): number;
-    subs(sub: Substitution): BoxedPattern;
+    match(expr: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    test(expr: BoxedExpression, options?: PatternMatchOptions): boolean;
+    count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOptions): number;
+    subs(sub: Substitution, options?: {
+        canonical: boolean;
+    }): BoxedExpression;
 }

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

@@ -1,6 +1,6 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution } from '../public';
 /**
  * BoxedString
  */
@@ -19,5 +19,5 @@ export declare class BoxedString extends AbstractBoxedExpression {
     get string(): string;
     isEqual(rhs: BoxedExpression): boolean;
     isSame(rhs: BoxedExpression): boolean;
-    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    match(rhs: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
 }

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

@@ -1,14 +1,15 @@
-/* 0.7.0 */
+/* 0.9.0 */
 export declare function domainToFlags(dom: BoxedDomain | undefined | null): Partial<SymbolFlags>;
 export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
+    readonly name: string;
+    private _def;
+    private _value;
+    private _domain;
+    private _inferedDomain;
     private _engine;
     readonly scope: RuntimeScope | undefined;
-    private _value;
-    readonly name: string;
     wikidata?: string;
     description?: string | string[];
-    private _domain;
-    private _inferedDomain;
     private _number;
     private _integer;
     private _rational;
@@ -37,7 +38,6 @@ export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition
     at?: (index: string | number) => undefined | BoxedExpression;
     readonly constant: boolean;
     readonly hold: boolean;
-    private _def;
     prototype?: BoxedFunctionDefinition;
     self?: unknown;
     constructor(ce: IComputeEngine, def: SymbolDefinition);

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

@@ -1,6 +1,6 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition } from '../public';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution } from '../public';
 /**
  * BoxedSymbol
  *
@@ -19,19 +19,24 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     protected _name: string;
     private _hash;
     private _def;
-    constructor(ce: IComputeEngine, name: string, metadata?: Metadata);
+    constructor(ce: IComputeEngine, name: string, options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    });
     get hash(): number;
-    unbind(): undefined;
+    unbind(): void;
     get isPure(): boolean;
+    get json(): Expression;
+    get scope(): RuntimeScope | null;
     /** A free variable either has no definition, or it has a definition, but no value */
     get isFree(): boolean;
     get isConstant(): boolean;
     get isCanonical(): boolean;
-    set isCanonical(_va: boolean);
+    set isCanonical(val: boolean);
     get canonical(): BoxedExpression;
-    get wikidata(): string;
-    get description(): string[];
-    get url(): string;
+    get wikidata(): string | undefined;
+    get description(): string[] | undefined;
+    get url(): string | undefined;
     get complexity(): number;
     get head(): string;
     get symbol(): string;
@@ -43,15 +48,13 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     bind(scope: RuntimeScope | null): void;
     get value(): BoxedExpression | undefined;
     set value(value: BoxedExpression | number | undefined);
-    get numericValue(): BoxedExpression | undefined;
     get domain(): BoxedDomain;
-    set domain(d: BoxedDomain);
-    get explicitDomain(): BoxedDomain | null;
-    get json(): Expression;
+    set domain(inDomain: BoxedExpression | DomainExpression | BoxedDomain);
+    get explicitDomain(): BoxedDomain | undefined;
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;
     isSame(rhs: BoxedExpression): boolean;
-    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    match(rhs: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
     isEqual(rhs: BoxedExpression): boolean;
     isLess(rhs: BoxedExpression): boolean | undefined;
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
@@ -81,8 +84,11 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get isComplex(): boolean | undefined;
     get isImaginary(): boolean | undefined;
     simplify(options?: SimplifyOptions): BoxedExpression;
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(_options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;
     replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
-    subs(sub: Substitution): BoxedExpression;
+    subs(sub: Substitution, options?: {
+        canonical: boolean;
+    }): BoxedExpression;
 }
+export declare function makeCanonicalSymbol(ce: IComputeEngine, name: string): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.7.0 */
+/* 0.9.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

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

@@ -1,4 +1,4 @@
-/* 0.7.0 */
+/* 0.9.0 */
 export declare type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

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

@@ -1,7 +1,7 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, Metadata } from '../public';
+import { BoxedExpression, IComputeEngine, Metadata, Rational } from '../public';
 /**
  * The canonical version of `serializeJsonFunction()` applies
  * additional transformations to "reverse" some of the effects
@@ -12,4 +12,4 @@ export declare function serializeJsonCanonicalFunction(ce: IComputeEngine, head:
 export declare function serializeJsonFunction(ce: IComputeEngine, head: string | BoxedExpression, args: BoxedExpression[], metadata?: Metadata): Expression;
 export declare function serializeJsonString(ce: IComputeEngine, s: string): Expression;
 export declare function serializeJsonSymbol(ce: IComputeEngine, sym: string, metadata?: Metadata): Expression;
-export declare function serializeJsonNumber(ce: IComputeEngine, value: number | Decimal | Complex | [number, number], metadata?: Metadata): Expression;
+export declare function serializeJsonNumber(ce: IComputeEngine, value: number | Decimal | Complex | Rational, metadata?: Metadata): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;
@@ -20,13 +20,12 @@ export declare function getVars(expr: BoxedExpression): string[];
 export declare function getSymbols(expr: BoxedExpression, set: Set<string>): Set<string>;
 export declare function getSubexpressions(expr: BoxedExpression, head: string): BoxedExpression[];
 /**
- * For any numeric result, or when boxing numbers,
- * if `preferDecimal` is true, create them as Decimal number
- * if `preferDecimal` is false, create them as machine number
+ * For any numeric result, if `bignumPreferred()` is true, calculate using
+ * bignums. If `bignumPreferred()` is false, calculate using machine numbers
  */
-export declare function preferDecimal(ce: IComputeEngine): boolean;
-/** If result of a numeric evaluation is a complex number,
- * return `NaN` if `ce.useComplex` is false
+export declare function bignumPreferred(ce: IComputeEngine): boolean;
+/** When result of a numeric evaluation is a complex number,
+ * return `NaN` if not `complexallowed()`
  */
 export declare function complexAllowed(ce: IComputeEngine): boolean;
 /**
@@ -49,6 +48,7 @@ export declare function getListLike(expr: BoxedExpression): BoxedExpression[];
  * If `expr` is a number, return it as a Decimal (it might be
  * in the machine value range or not). Use `isInMachineRange()` to check.
  *
- * Use this instead of `machineValue()` when possible, as `machineValue` will truncate decimal numbers to machine numbers
+ * Use this instead of `machineValue()` when possible, as `machineValue` will
+ * truncate bignums to machine numbers
  */
-export declare function decimalValue(ce: IComputeEngine, expr: Expression | null | undefined): Decimal | null;
+export declare function bignumValue(ce: IComputeEngine, expr: Expression | null | undefined): Decimal | null;

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

@@ -0,0 +1,18 @@
+/* 0.9.0 */
+export declare function validateArgumentCount(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
+/**
+ * Validation of arguments is normally done by checking the signature of the
+ * function vs the arguments of the expression. However, we have a fastpath
+ * for some common operations (add, multiply, power, neg, etc...) that bypasses
+ * the regular checks. This is its replacements. Since all those fastpath
+ * functions are numeric (i.e. have numeric arguments and return a numeric
+ * value), we do a simple numeric check of all arguments, and verify we have
+ * the number of expected arguments.
+ */
+export declare function validateNumericArgs(ce: IComputeEngine, ops: SemiBoxedExpression[], count?: number): BoxedExpression[];
+/** Return `null` if the `ops` match the sig. Otherwise, return an array
+ * of expressions indicating the mismatched arguments.
+ *
+ */
+export declare function validateSignature(sig: BoxedDomain, ops: BoxedExpression[], codomain?: BoxedExpression): BoxedExpression[] | null;
+export declare function validateArgument(ce: IComputeEngine, arg: BoxedExpression | undefined, expect: DomainExpression<BoxedExpression> | undefined): BoxedExpression;

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

@@ -1,10 +1,9 @@
-/* 0.7.0 */
+/* 0.9.0 */
 import { Complex } from 'complex.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 import { SignalMessage, WarningSignal } from '../common/signals';
 import type { LibraryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, SymbolTable, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, BoxedLambdaExpression, FunctionDefinition } from './public';
-import { BoxedFunction } from './boxed-expression/boxed-function';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, SymbolTable, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution } from './public';
 /**
  *
  * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
@@ -30,8 +29,6 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     readonly _ONE: BoxedExpression;
     /** @internal */
-    readonly _TWO: BoxedExpression;
-    /** @internal */
     readonly _HALF: BoxedExpression;
     /** @internal */
     readonly _NEGATIVE_ONE: BoxedExpression;
@@ -46,19 +43,19 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     readonly _COMPLEX_INFINITY: BoxedExpression;
     /** @internal */
-    _DECIMAL_NAN: Decimal;
+    _BIGNUM_NAN: Decimal;
     /** @internal */
-    _DECIMAL_ZERO: Decimal;
+    _BIGNUM_ZERO: Decimal;
     /** @internal */
-    _DECIMAL_ONE: Decimal;
+    _BIGNUM_ONE: Decimal;
     /** @internal */
-    _DECIMAL_TWO: Decimal;
+    _BIGNUM_TWO: Decimal;
     /** @internal */
-    _DECIMAL_HALF: Decimal;
+    _BIGNUM_HALF: Decimal;
     /** @internal */
-    _DECIMAL_PI: Decimal;
+    _BIGNUM_PI: Decimal;
     /** @internal */
-    _DECIMAL_NEGATIVE_ONE: Decimal;
+    _BIGNUM_NEGATIVE_ONE: Decimal;
     /** @internal */
     private _precision;
     /** @internal */
@@ -68,7 +65,7 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     private _tolerance;
     /** @internal */
-    private _decimalTolerance;
+    private _bignumTolerance;
     /** @internal */
     private _cache;
     /** @internal */
@@ -77,6 +74,14 @@ export declare class ComputeEngine implements IComputeEngine {
     private _cost?;
     /** @internal */
     private _jsonSerializationOptions;
+    /**
+     * During certain operations  (serializing to LaTeX, constructing error
+     * messages) we need to use a "raw" JSON serialization without any customization. Setting the `_useRawJsonSerializationOptions` will bypass
+     * the `_jsonSerializationOptions` and use `_rawJsonSerializationOptions`
+     * instead
+     * @internal */
+    private _useRawJsonSerializationOptions;
+    private _rawJsonSerializationOptions;
     /** The domain of unknown symbols. If `null` unknown symbols do not have a
      * definition automatically associated with them.
      *
@@ -128,9 +133,10 @@ export declare class ComputeEngine implements IComputeEngine {
      * be the `'core'` dictionary which include some basic definitions such
      * as domains (`Boolean`, `Number`, etc...) that are used by later dictionaries.
      *
-     * @param options.numericMode The default mode is `auto`. Use `machine` to only
-     * use 64-bit float, use `decimal` to always use arbitrary precision floating
-     * point numbers or `complex` for complex numbers.
+     * @param options.numericMode The default mode is `"auto"`. Use `"machine"`
+     * to perform numeric calculations using 64-bit floats. Use `"bignum"` to
+     * perform calculations using arbitrary precision floating point numbers.
+     * Use `"auto"` or `"complex"` to allow calculations on complex numbers.
      *
      * @param options.numericPrecision Specific how many digits of precision for the
      * numeric calculations. Default is 100.
@@ -164,13 +170,15 @@ export declare class ComputeEngine implements IComputeEngine {
     _unregister(_expr: BoxedExpression): void;
     get stats(): ComputeEngineStats;
     /** @internal */
-    _decimal: Decimal.Constructor;
-    /** The precision, or number of significant digits, for numeric calculations
-     * such as when calling `ce.N()`.
+    _bignum: Decimal.Constructor;
+    /** The precision, or number of significant digits, of numeric
+     * calculations when the numeric mode is `"auto"` or `"bignum"`.
      *
-     * To  make calculations using more digits, at the cost of expended memory
+     * To make calculations using more digits, at the cost of expanded memory
      * usage and slower computations, set the `precision` higher.
      *
+     * If the numeric mode is not `"auto"` or `"bignum"`, it is set to `"auto"`.
+     *
      * Trigonometric operations are accurate for precision up to 1,000.
      *
      */
@@ -202,7 +210,7 @@ export declare class ComputeEngine implements IComputeEngine {
     get tolerance(): number;
     set tolerance(val: number);
     /** @internal */
-    decimal(a: Decimal.Value): Decimal;
+    bignum(a: Decimal.Value): Decimal;
     /** @internal */
     complex(a: number | Complex, b?: number): Complex;
     /** Replace a number that is close to 0 with the exact integer 0.
@@ -231,7 +239,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * of the argument or the codomain. However, it is useful during parsing
      * to differentiate between symbols that might represent a function application, e.g. `f` vs `x`.
      */
-    lookupFunction(head: string, scope?: RuntimeScope): undefined | BoxedFunctionDefinition;
+    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     /**
      * Add (or replace) a definition for a symbol in the current scope.
      */
@@ -253,6 +261,12 @@ export declare class ComputeEngine implements IComputeEngine {
     /** Remove the topmost scope from the scope stack.
      */
     popScope(): void;
+    set(identifiers: {
+        [identifier: string]: SemiBoxedExpression;
+    }): void;
+    let(identifiers: {
+        [identifier: string]: SymbolDefinition | FunctionDefinition;
+    }): void;
     get assumptions(): ExpressionMapInterface<boolean>;
     /**
      * Return false if the execution should stop.
@@ -281,35 +295,51 @@ export declare class ComputeEngine implements IComputeEngine {
     signal(sig: WarningSignal): void;
     /** @internal */
     cache<T>(cacheName: string, build: () => T, purge: (T: any) => T | undefined): T;
-    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression): BoxedExpression;
+    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
+        canonical?: boolean;
+    }): BoxedExpression;
     fn(head: string, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     /** @internal */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedFunction;
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     error(message: ['invalid-domain', ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedDomain;
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
+    hold(expr: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    power(base: BoxedExpression, exponent: number | [number, number] | BoxedExpression, metadata?: Metadata): BoxedExpression;
-    inverse(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     negate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     divide(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    sqrt(base: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    power(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    inverse(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
-    symbol(name: string, metadata?: Metadata): BoxedExpression;
+    symbol(name: string, options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    }): BoxedExpression;
     domain(domain: BoxedExpression | DomainExpression | BoxedDomain, metadata?: Metadata): BoxedDomain;
-    lambda(expr: SemiBoxedExpression, sig: BoxedDomain): BoxedLambdaExpression;
-    number(value: number | MathJsonNumber | Decimal | Complex | [num: number, denom: number], metadata?: Metadata): BoxedExpression;
+    number(value: number | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
+        canonical?: boolean;
+        metadata?: Metadata;
+    }): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
-    parse(latex: LatexString | string): BoxedExpression;
-    parse(s: null): null;
-    parse(latex: LatexString | string | null): null | BoxedExpression;
+    parse(latex: LatexString | string, options?: {
+        canonical?: boolean;
+    }): BoxedExpression;
+    parse(s: null, options?: {
+        canonical?: boolean;
+    }): null;
+    parse(latex: LatexString | string | null, options?: {
+        canonical?: boolean;
+    }): null | BoxedExpression;
     serialize(x: Expression | BoxedExpression): string;
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
-    get jsonSerializationOptions(): JsonSerializationOptions;
+    get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
+    rawJson(expr: BoxedExpression): Expression;
     /**
      * Return a list of all the assumptions that match a pattern.
      *
@@ -319,7 +349,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *  //  -> [{'val': 0}]
      * ```
      */
-    ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
+    ask(pattern: LatexString | SemiBoxedExpression): BoxedSubstitution[];
     infer(symbol: BoxedExpression | string, _domain: BoxedDomain | DomainExpression): AssumeResult;
     assume(symbol: LatexString | SemiBoxedExpression, domainValue: BoxedDomain | DomainExpression | Expression | BoxedExpression): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,3 +1,3 @@
-/* 0.7.0 */
+/* 0.9.0 */
 export declare function costFunction(expr: BoxedExpression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;