@cortex-js/compute-engine 0.4.2 → 0.5.0

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

@@ -0,0 +1,8 @@
+/* 0.5.0 */
+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.5.0 */
+export declare function makeFunctionDefinition(engine: IComputeEngine, def: FunctionDefinition): BoxedFunctionDefinition;

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

@@ -0,0 +1,95 @@
+/* 0.5.0 */
+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
+ *
+ * Account for `Hold`, `ReleaseHold` 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[];

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

@@ -0,0 +1,83 @@
+/* 0.5.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 { 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.5.0 */
+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.5.0 */
+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.5.0 */
+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 | number | 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);
+}

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

@@ -0,0 +1,74 @@
+/* 0.5.0 */
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption } from '../public';
+/**
+ * BoxedSymbol
+ *
+ * A boxed symbol is a reference to a BoxedSymbolDefinition.
+ * The BoxedSymbolDefinition "owns" all the information
+ * about the symbol, its value, domain and various attributes.
+ */
+export declare class BoxedSymbol extends AbstractBoxedExpression {
+    protected _name: string;
+    private _hash;
+    private _def;
+    constructor(ce: IComputeEngine, name: string, metadata?: Metadata);
+    get hash(): number;
+    _purge(): undefined;
+    get isPure(): boolean;
+    get isCanonical(): boolean;
+    set isCanonical(_va: boolean);
+    get wikidata(): string;
+    get description(): string[];
+    get url(): string;
+    get complexity(): number;
+    get head(): string;
+    get symbol(): string;
+    get isMissing(): boolean;
+    get isLiteral(): boolean;
+    get symbolDefinition(): BoxedSymbolDefinition | undefined;
+    _repairDefinition(): void;
+    get value(): BoxedExpression | undefined;
+    set value(value: BoxedExpression | number | undefined);
+    get numericValue(): BoxedExpression | undefined;
+    get domain(): BoxedExpression;
+    set domain(d: BoxedExpression);
+    get json(): Expression;
+    get sgn(): -1 | 0 | 1 | undefined | null;
+    has(x: string | string[]): boolean;
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    isEqual(rhs: BoxedExpression): boolean;
+    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 isOdd(): boolean | undefined;
+    get isEven(): boolean | undefined;
+    get isPrime(): boolean | undefined;
+    get isComposite(): boolean | undefined;
+    get isInfinity(): boolean | undefined;
+    get isNaN(): 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 canonical(): BoxedExpression;
+    simplify(options?: SimplifyOptions): BoxedExpression;
+    evaluate(options?: EvaluateOptions): BoxedExpression;
+    N(options?: NOptions): BoxedExpression;
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
+    subs(sub: Substitution): BoxedExpression;
+}

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

@@ -0,0 +1,12 @@
+/* 0.5.0 */
+export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
+    readonly _items: Map<BoxedExpression, U>;
+    constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);
+    has(expr: BoxedExpression): boolean;
+    get(expr: BoxedExpression): U | undefined;
+    clear(): void;
+    set(expr: BoxedExpression, value: U): void;
+    delete(expr: BoxedExpression): void;
+    [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
+    entries(): IterableIterator<[BoxedExpression, U]>;
+}

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

@@ -0,0 +1,53 @@
+/* 0.5.0 */
+export declare type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
+export declare const DEFAULT_COMPLEXITY = 100000;
+/**
+ * Sort by higher total degree (sum of degree), if tied, sort by max degree,
+ * if tied,
+ */
+export declare function sortAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression[];
+/**
+ * Given two expressions `a` and `b`, return:
+ * - `-1` if `a` should be ordered before `b`
+ * - `+1` if `b` should be ordered before `a`
+ * - `0` if they have the same order (they are structurally equal)
+ *
+ * The default order is as follow:
+ *
+ * 1/ Literal numeric values (rational,  machine numbers and Decimal numbers),
+ *  ordered by they numeric value (smaller numbers before larger numbers)
+ *
+ * 2/ Literal complex numbers, ordered by their real parts. In case of a tie,
+ * ordered by the absolute value of their imaginary parts. In case of a tie,
+ * ordered by the value of their imaginary parts.
+ *
+ * 3/ Symbols, ordered by their name as strings
+ *
+ * 4/ Addition, ordered as a polynom, with higher degree terms first
+ *
+ * 5/ Other functions, ordered by their `complexity` property. In case
+ * of a tie, ordered by the head of the expression as a string. In case of a
+ * tie, by the leaf count of each expression. In case of a tie, by the order
+ * of each argument, left to right.
+ *
+ * 6/ Strings, ordered by comparing their Unicode code point values. While this
+ * sort order is quick to calculate, it can produce unexpected results, for
+ * example "E" < "e" < "È" and "11" < "2". This ordering is not suitable to
+ * collate natural language strings.
+ *
+ * 7/ Dictionaries, ordered by the number of keys. If there is a tie, by the
+ * sum of the complexities of the values of the dictionary
+ *
+ *
+ */
+export declare function order(a: BoxedExpression, b: BoxedExpression): number;
+/**
+ * Sort the terms of a polynomial expression (`Add` expression) according
+ * to the deglex polynomial ordering
+ *
+ */
+export declare function polynomialOrder(expr: BoxedExpression): SemiBoxedExpression;
+export declare function lexicographicOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;
+export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;
+export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;
+export declare function eliminationOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;

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

@@ -0,0 +1,15 @@
+/* 0.5.0 */
+import Decimal from 'decimal.js';
+import { Expression } from '../../math-json/math-json-format';
+import { BoxedExpression, IComputeEngine, Metadata } from '../public';
+/**
+ * The canonical version of `serializeJsonFunction()` applies
+ * additional transformations to "reverse" some of the effects
+ * of canonicalization (or boxing), for example it uses `Divide`
+ * instead of `Multiply`/`Power` when applicable.
+ */
+export declare function serializeJsonCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, args: BoxedExpression[], metadata?: Metadata): Expression;
+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;

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

@@ -0,0 +1,37 @@
+/* 0.5.0 */
+export declare function isLatexString(s: any): s is string;
+export declare function latexString(s: any): string | null;
+/**
+ * Return a multiple of the imaginary unit, e.g.
+ * - 'ImaginaryUnit'
+ * - ['Negate', 'ImaginaryUnit']
+ * - ['Negate', ['Multiply', 3, 'ImaginaryUnit']]
+ * - ['Multiply', 5, 'ImaginaryUnit']
+ * - ['Multiply', 'ImaginaryUnit', 5]
+ */
+export declare function getImaginaryCoef(expr: BoxedExpression): number;
+/**
+ * Return the free symbols in the expression, recursively.
+ * A variable, or free symbol,is a symbol that is not bound to a value.
+ */
+export declare function getVars(expr: BoxedExpression): string[];
+/**
+ * For any numeric result, or when boxing numbers,
+ * if `ce.useDecimal` is true, create them as Decimal number
+ * if `ce.useDecimal` is false, create them as machine number
+ */
+export declare function useDecimal(ce: IComputeEngine): boolean;
+/** If result of a numeric evaluation is a complex number,
+ * return `NaN` if `ce.useComplex` is false
+ */
+export declare function complexAllowed(ce: IComputeEngine): boolean;
+/**
+ * Assert that `expr` is  in fact canonical.
+ *
+ * Called for example from within a `canonical` handler.
+ *
+ * To make an expression whose canonical status is unknown, canonical, call
+ * `expr.canonical`.
+ */
+export declare function asCanonical(expr: BoxedExpression): BoxedExpression;
+export declare function hashCode(s: string): number;