@cortex-js/compute-engine 0.32.0 → 0.32.1

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

@@ -0,0 +1,170 @@
+/* 0.32.1 */
+import type { Type, TypeString } from '../../common/type/types';
+import type { OneOf } from '../../common/one-of';
+import { BoxedType } from '../../common/type/boxed-type';
+import type { BigNum } from '../numerics/types';
+import { NumericValue } from '../numeric-value/types';
+import type { BoxedExpression, SimplifyOptions, PatternMatchOptions, ReplaceOptions, BoxedValueDefinition, BoxedOperatorDefinition, ComputeEngine, Metadata, CanonicalOptions, BoxedBaseDefinition, BoxedSubstitution, EvaluateOptions, Rule, BoxedRule, BoxedRuleSet, Substitution, Sign, BoxedDefinition, CollectionHandlers } from '../global-types';
+import { _BoxedExpression } from './abstract-boxed-expression';
+/**
+ * ### BoxedSymbol
+ *
+ * A boxed symbol is a reference to a `BoxedDefinition`.
+ *
+ * A `BoxedDefinition` "owns" all the information about a symbol, its
+ * type and various attributes (is it a constant?, etc...).
+ *
+ * Boxed symbols are bound to a definition during construction if they
+ * are canonical.
+ *
+ * If a symbol is not canonical (and thus not bound to a definition),
+ * some properties and methods will return `undefined`, for example
+ * `isInteger`, `isRational`, `isReal`, etc...
+ *
+ * There is a single value definition for each symbol but the value of a
+ * symbol can be different in different evaluation contexts, for example
+ * a local variable during a recursion.
+ *
+ * The value of a symbol is tracked in the evaluation context and
+ * not in the value definition.
+ *
+ * The `value` property of a boxed symbol is the value of the symbol
+ * in the current evaluation context. It is `undefined` if the symbol
+ * is not bound to a definition or if the value is not known (a bound
+ * symbol may have no value).
+ *
+ */
+export declare class BoxedSymbol extends _BoxedExpression {
+    private _hash;
+    /** The name of the symbol */
+    protected _id: MathJsonSymbol;
+    /**
+     * The definition of the symbol, if the symbol is bound/canonical.
+     */
+    private readonly _def;
+    /** Note: to indicate that the symbol should be canonical, pass a def. */
+    constructor(ce: ComputeEngine, name: MathJsonSymbol, options?: {
+        metadata?: Metadata;
+        def?: BoxedDefinition;
+    });
+    get json(): Expression;
+    get hash(): number;
+    get isPure(): boolean;
+    get isConstant(): boolean;
+    bind(): void;
+    reset(): void;
+    get isCanonical(): boolean;
+    set isCanonical(val: boolean);
+    get canonical(): BoxedExpression;
+    is(other: any): boolean;
+    toNumericValue(): [NumericValue, BoxedExpression];
+    neg(): BoxedExpression;
+    inv(): BoxedExpression;
+    abs(): BoxedExpression;
+    add(rhs: number | BoxedExpression): BoxedExpression;
+    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
+    div(rhs: number | BoxedExpression): BoxedExpression;
+    pow(exp: number | BoxedExpression): BoxedExpression;
+    root(n: number | BoxedExpression): BoxedExpression;
+    sqrt(): BoxedExpression;
+    ln(semiBase?: number | BoxedExpression): BoxedExpression;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    get complexity(): number;
+    get operator(): MathJsonSymbol;
+    get symbol(): MathJsonSymbol;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
+    get valueDefinition(): BoxedValueDefinition | undefined;
+    get operatorDefinition(): BoxedOperatorDefinition | undefined;
+    /**
+     *
+     * Assuming the symbol is used as an argument, subsequent inferences will
+     * narrow the domain of the symbol:
+     *
+     * ```
+     * f: real -> number, g: integer -> number
+     * f(x) => x: inferred to real
+     * g(x) => x: narrowed to integer
+     * ```
+     *
+     * If the symbol is used as a return value, its domain should be widened:
+     *
+     * ```
+     * f: number -> integer, g: number -> real
+     * x = f(2) => x: inferred to integer
+     * x = g(2) => x: widened to real
+     * ```
+     *
+     * Arguments accumulate constraints and narrow.
+     * Return values accumulate possibilities and widen.
+     *
+     * @inheritdoc
+     */
+    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
+    /** Return the value of the symbol, undefined if an operator or not bound */
+    get _value(): BoxedExpression | undefined;
+    get value(): BoxedExpression | undefined;
+    set value(value: boolean | string | BigNum | number[] | OneOf<[
+        {
+            re: number;
+            im: number;
+        },
+        {
+            num: number;
+            denom: number;
+        },
+        BoxedExpression
+    ]> | number | undefined);
+    /**
+     * The type of the symbol.
+     *
+     * Note that the type of the value of the symbol may be more specific.'
+     * For example, a symbol could have a type of 'number' but the value
+     * could be 'integer'.
+     *
+     * If the symbol is not canonical (not bound to a definition), the type is
+     * 'unknown'
+     */
+    get type(): BoxedType;
+    set type(t: Type | TypeString | BoxedType);
+    has(x: MathJsonSymbol | MathJsonSymbol[]): boolean;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    get sgn(): Sign | undefined;
+    get isOdd(): boolean | undefined;
+    get isEven(): boolean | undefined;
+    get isFinite(): 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 isFunction(): boolean | undefined;
+    get isNumber(): boolean | undefined;
+    get isInteger(): boolean | undefined;
+    get isRational(): boolean | undefined;
+    get isReal(): boolean | undefined;
+    get re(): number;
+    get im(): number;
+    get bignumRe(): BigNum | undefined;
+    get bignumIm(): BigNum | undefined;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
+    N(): BoxedExpression;
+    replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): BoxedExpression | null;
+    subs(sub: Substitution, options?: {
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
+    get _asCollection(): CollectionHandlers | undefined;
+    get isCollection(): boolean;
+    get isIndexedCollection(): boolean;
+    get isLazyCollection(): boolean;
+    contains(rhs: BoxedExpression): boolean | undefined;
+    get count(): number;
+    get isEmptyCollection(): boolean;
+    get isFiniteCollection(): boolean | undefined;
+    each(): Generator<BoxedExpression>;
+    at(index: number): BoxedExpression | undefined;
+    get(index: BoxedExpression | string): BoxedExpression | undefined;
+    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
+    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
+}

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

@@ -0,0 +1,83 @@
+/* 0.32.1 */
+import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, BoxedExpression, SimplifyOptions, PatternMatchOptions, Tensor } from '../global-types';
+import { BoxedType } from '../../common/type/boxed-type';
+import { NumericValue } from '../numeric-value/types';
+import { _BoxedExpression } from './abstract-boxed-expression';
+/**
+ * A boxed tensor represents an expression that can be represented by a tensor.
+ * This could be a vector, matrix or multi-dimensional array.
+ *
+ * The object can be created either from a tensor or from an expression that
+ * can be represented as a tensor.
+ *
+ * The structural counterpart (expression if input is tensor, or tensor
+ * if input is expression) is created lazily.
+ *
+ */
+export declare class BoxedTensor<T extends TensorDataType> extends _BoxedExpression {
+    readonly input: {
+        ops: ReadonlyArray<BoxedExpression>;
+        shape: number[];
+        dtype: T;
+    };
+    readonly options?: {
+        metadata?: Metadata;
+    };
+    private _tensor;
+    private _expression?;
+    constructor(ce: ComputeEngine, input: {
+        ops: ReadonlyArray<BoxedExpression>;
+        shape: number[];
+        dtype: T;
+    }, options?: {
+        metadata?: Metadata;
+    });
+    get structural(): BoxedExpression;
+    /** Create the tensor on demand */
+    get tensor(): Tensor<T>;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
+    get operatorDefinition(): BoxedOperatorDefinition | undefined;
+    get hash(): number;
+    get canonical(): BoxedExpression;
+    get isCanonical(): boolean;
+    get isPure(): boolean;
+    get isValid(): boolean;
+    get complexity(): number;
+    get operator(): string;
+    get nops(): number;
+    get ops(): ReadonlyArray<BoxedExpression>;
+    get op1(): BoxedExpression;
+    get op2(): BoxedExpression;
+    get op3(): BoxedExpression;
+    neg(): BoxedExpression;
+    inv(): BoxedExpression;
+    abs(): BoxedExpression;
+    add(rhs: number | BoxedExpression): BoxedExpression;
+    sub(rhs: BoxedExpression): BoxedExpression;
+    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
+    div(rhs: number | BoxedExpression): BoxedExpression;
+    pow(exp: number | BoxedExpression): BoxedExpression;
+    root(exp: number | BoxedExpression): BoxedExpression;
+    sqrt(): BoxedExpression;
+    get shape(): number[];
+    get rank(): number;
+    get type(): BoxedType;
+    get json(): Expression;
+    /** Mathematical equality */
+    isEqual(rhs: number | BoxedExpression): boolean | undefined;
+    get isCollection(): boolean;
+    get isIndexedCollection(): boolean;
+    contains(other: BoxedExpression): boolean | undefined;
+    get count(): number;
+    each(): Generator<BoxedExpression>;
+    at(index: number): BoxedExpression | undefined;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    N(): BoxedExpression;
+}
+export declare function isBoxedTensor(val: unknown): val is BoxedTensor<any>;
+export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<BoxedExpression>): {
+    shape: number[];
+    dtype: TensorDataType;
+} | undefined;

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

@@ -0,0 +1,46 @@
+/* 0.32.1 */
+import type { Type, TypeString } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
+import { ConfigurationChangeListener } from '../../common/configuration-change';
+/**
+ * ### THEORY OF OPERATIONS
+ *
+ * - The value in the definition is the initial value of the symbol when
+ *   entering an evaluation context. Unless it is a constant, it is not the
+ *   value of the symbol itself, which is stored in the evaluation context.
+ *
+ * - The value or type of a constant cannot be changed.
+ *
+ * - When the type is changed, the value is preserved if it is compatible
+ *   with the new type, otherwise it is reset to no value.
+ *
+ * - When the value is changed, the type is unaffected. If the value is not
+ *   compatible with the type (setting a def with a numeric type to a value
+ *   of `True` for example), the value is discarded.
+ *
+ */
+export declare class _BoxedValueDefinition implements BoxedValueDefinition, ConfigurationChangeListener {
+    readonly name: string; /** Used for debugging and error messages */
+    wikidata?: string;
+    description?: string | string[];
+    url?: string;
+    private _engine;
+    private _defValue?;
+    private _value;
+    private _type;
+    inferredType: boolean;
+    _isConstant: boolean;
+    holdUntil: 'never' | 'evaluate' | 'N';
+    eq?: (a: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression) => boolean | undefined;
+    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    collection?: CollectionHandlers;
+    constructor(ce: ComputeEngine, name: string, def: Partial<ValueDefinition>);
+    /** For debugging */
+    toJSON(): any;
+    get isConstant(): boolean;
+    get value(): BoxedExpression | undefined;
+    get type(): BoxedType;
+    set type(t: Type | TypeString | BoxedType);
+    onConfigurationChange(): void;
+}

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

@@ -0,0 +1,7 @@
+/* 0.32.1 */
+    value: T | null;
+    generation: number | undefined;
+};
+/** The cache v will get updated if necessary */
+export declare function cachedValue<T>(v: CachedValue<T>, generation: number | undefined, fn: () => T): T;
+export declare function cachedValueAsync<T>(v: CachedValue<T>, generation: number | undefined, fn: () => Promise<T>): Promise<T>;

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

@@ -0,0 +1,5 @@
+/* 0.32.1 */
+/**
+ * Ensure all expressions in the array are in canonical form
+ */
+export declare function canonical(ce: ComputeEngine, xs: ReadonlyArray<BoxedExpression>, scope?: Scope): ReadonlyArray<BoxedExpression>;

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

@@ -0,0 +1,2 @@
+/* 0.32.1 */
+export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions, scope?: Scope): BoxedExpression;

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

@@ -0,0 +1,13 @@
+/* 0.32.1 */
+/**
+ * Structural equality of boxed expressions.
+ */
+export declare function same(a: BoxedExpression, b: BoxedExpression): boolean;
+/**
+ * Mathematical equality of two boxed expressions.
+ *
+ * In general, it is impossible to always prove equality
+ * ([Richardson's theorem](https://en.wikipedia.org/wiki/Richardson%27s_theorem)) but this works often...
+ */
+export declare function eq(a: BoxedExpression, inputB: number | BoxedExpression): boolean | undefined;
+export declare function cmp(a: BoxedExpression, b: number | BoxedExpression): '<' | '=' | '>' | '>=' | '<=' | undefined;

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

@@ -0,0 +1,20 @@
+/* 0.32.1 */
+export declare function expandProducts(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+export declare function choose(n: number, k: number): number;
+/** Attempt to transform the expression (h, ops) into a sum */
+export declare function expandFunction(ce: ComputeEngine, h: string, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+/** Apply the distributive law if the expression is a product of sums.
+ * For example, a(b + c) = ab + ac
+ * Expand the expression if it is a power of a sum.
+ * Expand the terms of the expression if it is a sum or negate.
+ * If the expression is a fraction, expand the numerator.
+ * If the exression is a relational operator, expand the operands.
+ * Return null if the expression cannot be expanded.
+ */
+export declare function expand(expr: BoxedExpression | undefined): BoxedExpression | null;
+/**
+ * Recursive expand of all terms in the expression.
+ *
+ * `expand()` only expands the top level of the expression.
+ */
+export declare function expandAll(expr: BoxedExpression): BoxedExpression | null;

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

@@ -0,0 +1,12 @@
+/* 0.32.1 */
+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/factor.d.ts

@@ -0,0 +1,10 @@
+/* 0.32.1 */
+/** Combine rational expressions into a single fraction */
+export declare function together(op: BoxedExpression): BoxedExpression;
+/**
+ * Return an expression factored as a product.
+ * - 2x + 4 -> 2(x + 2)
+ * - 2x < 4 -> x < 2
+ * - (2x) * (2y) -> 4xy
+ */
+export declare function factor(expr: BoxedExpression): BoxedExpression;

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

@@ -0,0 +1,25 @@
+/* 0.32.1 */
+/**
+ *
+ * Make all the arguments canonical.
+ *
+ * "Lift" Sequence expressions to the top level.
+ * e.g. `["Add", 1, ["Sequence", 2, 3]]` -> `["Add", 1, 2, 3]`
+ *
+ * Additionally, if an operator is provided, also lift nested expressions
+ * with the same operator.
+ *  e.g. `["f", a, ["f", b, c]]` -> `["f", a, b, c]`
+ *
+ * Note: *not* recursive
+ */
+export declare function flatten<T extends ReadonlyArray<BoxedExpression> | BoxedExpression[]>(ops: T, operator?: string): T;
+/**
+ * Flatten the arguments.
+ * @fixme replace with just flatten.
+ * @fixme consider adding flatternSort()
+ */
+export declare function flattenOps<T extends ReadonlyArray<BoxedExpression> | BoxedExpression[]>(ops: T, operator: string): T;
+/**
+ * @todo: this function should probably not be recursive. As it, it is semi-recursive.
+ */
+export declare function flattenSequence(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;

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

@@ -0,0 +1,10 @@
+/* 0.32.1 */
+/** Apply the function `f` to each operand of the expression `expr`,
+ * account for the 'lazy' property of the operator definition:
+ *
+ * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
+ *
+ * If `f` returns `null`, the element is not added to the result
+ */
+export declare function holdMap(expr: BoxedExpression, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;
+export declare function holdMapAsync(expr: BoxedExpression, f: (x: BoxedExpression) => Promise<BoxedExpression | null>): Promise<ReadonlyArray<BoxedExpression>>;

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

@@ -0,0 +1,41 @@
+/* 0.32.1 */
+/**
+ * The function attempts to match a subject expression to a
+ * [pattern](/compute-engine/guides/patterns-and-rules/).
+ *
+ * If the match is successful, it returns a `Substitution` indicating how to
+ * transform the pattern to become the subject.
+ *
+ * If the expression does not match the pattern, it returns `null`.
+ *
+ * ## Canonicalization-Aware Matching
+ *
+ * The matching handles expressions that have been canonicalized to different
+ * but mathematically equivalent forms:
+ *
+ * - **Rational/Divide**: A `Rational` pattern is treated as equivalent to
+ *   `Divide`. Expressions like `['Rational', 'x', 2]` which are canonicalized
+ *   to `['Multiply', ['Rational', 1, 2], 'x']` (i.e., `x * 1/2`) will still
+ *   match a `['Divide', '_num', '_den']` or `['Rational', '_num', '_den']`
+ *   pattern, returning `{_num: x, _den: 2}`.
+ *
+ * - **BoxedNumber rationals**: Numeric rationals like `['Rational', 3, 2]`
+ *   which become `BoxedNumber` values will match `Divide` or `Rational`
+ *   patterns by extracting the numerator and denominator.
+ *
+ * - **Power/Divide**: Expressions like `['Power', 'x', -1]` which are
+ *   canonicalized to `['Divide', 1, 'x']` will match a `Power` pattern,
+ *   returning `{_base: x, _exp: -1}`.
+ *
+ * - **Power/Root**: Expressions like `['Root', 'x', 3]` (cube root) will
+ *   match a `Power` pattern, returning `{_base: x, _exp: ['Divide', 1, 3]}`.
+ *
+ * <!--
+ * @consider?
+ * - pattern 'validation' (not quite the right term in this context) here? In a similar way to the
+ * check/condition supplied in 'matchPermutation()'? (i.e. inspect for redundant sequences of
+ * wildcard combinations).
+ * -->
+ *
+ */
+export declare function match(subject: BoxedExpression, pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -0,0 +1,11 @@
+/* 0.32.1 */
+export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
+/**
+ * Distribute `Negate` (multiply by -1) if expr is a number literal, an
+ * addition or multiplication or another `Negate`.
+ *
+ * It is important to do all these to handle cases like
+ * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
+ */
+export declare function negate(expr: BoxedExpression): BoxedExpression;
+export declare function negateProduct(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -0,0 +1,34 @@
+/* 0.32.1 */
+import { Decimal } from 'decimal.js';
+import type { Rational } from '../numerics/types';
+import type { BoxedExpression, SemiBoxedExpression } from '../global-types';
+export declare function asRational(expr: BoxedExpression): Rational | undefined;
+export declare function asBigint(x: Complex | Decimal | SemiBoxedExpression | undefined): bigint | null;
+export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
+/**
+ * Validate if the expression is a small integer.
+ * A small integer is an integer between -SMALL_INTEGER and SMALL_INTEGER (inclusive).
+ * Returns null if the expression is not a small integer.
+ *
+ * Unlike `toInteger()` this functions fails if the expression is not an
+ * integer. `toInteger()` will round the value to the nearest integer.
+ */
+export declare function asSmallInteger(expr: number | BoxedExpression | undefined): number | null;
+/**
+ * Convert a boxed expression to an integer.
+ * Returns null if the expression cannot be converted to an integer.
+ * If the expression is a complex number, only the real part is considered.
+ * If the real part is not an integer, it is rounded to the nearest integer.
+ *
+ * Unlike `asSmallInteger()`, this function does not check if the integer is
+ * within the range of -SMALL_INTEGER to SMALL_INTEGER, and it rounds the
+ * value to the nearest integer if it is a number.
+ *
+ */
+export declare function toInteger(expr: BoxedExpression | undefined): number | null;
+/** Convert a boxed expression to a bigint.
+ * Returns null if the expression cannot be converted to a bigint.
+ * If the expression is a complex number, only the real part is considered.
+ * If the real part is not an integer, it is rounded to the nearest integer.
+ */
+export declare function toBigint(expr: BoxedExpression | undefined): bigint | null;

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

@@ -0,0 +1,71 @@
+/* 0.32.1 */
+export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
+export declare const DEFAULT_COMPLEXITY = 100000;
+/**
+ * The sorting order of arguments of the Add function uses a modified degrevlex:
+ * - Sort by total degree (sum of degree)
+ * - Sort by max degree.
+ * - Sort reverse lexicographically
+ * - Sort by rank
+ *
+ *
+ * E.g.
+ * - 2x^2 + 3x + 1
+ * - 2x^2y^3 + 5x^3y
+ */
+export declare function addOrder(a: BoxedExpression, b: BoxedExpression): number;
+export declare function equalOrder(a: BoxedExpression, b: BoxedExpression): number;
+declare const RANKS: readonly ["integer", "rational", "radical", "real", "complex", "constant", "symbol", "multiply", "divide", "add", "trig", "fn", "power", "string", "other"];
+export type Rank = (typeof RANKS)[number];
+/**
+ * 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 their 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 operator 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.
+ *
+ * See https://reference.wolfram.com/language/ref/Sort.html for a
+ * description of the ordering of expressions in Mathematica.
+ *
+ */
+export declare function order(a: BoxedExpression, b: BoxedExpression): number;
+/** Return a version of the expression with its arguments sorted in
+ * canonical order
+ */
+export declare function canonicalOrder(expr: BoxedExpression, { recursive }: {
+    recursive?: boolean;
+}): BoxedExpression;
+export declare function sortOperands(operator: string, xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;
+/**
+ * Sort the terms of a polynomial expression (`Add` expression) according
+ * to the deglex polynomial ordering
+ *
+ */
+export declare function polynomialOrder(expr: BoxedExpression): BoxedExpression;
+export declare function lexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export declare function eliminationOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export {};