@cortex-js/compute-engine 0.25.0 → 0.26.0

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

@@ -1,8 +1,11 @@
-/* 0.25.0 */
-import { Decimal } from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
+/* 0.26.0 */
+import type { Expression } from '../../math-json/types';
+import type { Type, TypeString } from '../../common/type/types';
+import type { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, BoxedSubstitution, Rule, CanonicalOptions, BoxedRule, Sign } from './public';
+import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution, Rule, SemiBoxedExpression, CanonicalOptions } from './public';
+import { BigNum } from '../numerics/bignum';
+import type { OneOf } from '../../common/one-of';
 /**
  * BoxedSymbol
  *
@@ -24,16 +27,23 @@ export declare class BoxedSymbol extends _BoxedExpression {
     protected _id: string;
     private _hash;
     private _def;
+    private _isStructural;
     constructor(ce: IComputeEngine, name: string, options?: {
         metadata?: Metadata;
         canonical?: CanonicalOptions;
-        def?: BoxedSymbolDefinition | BoxedFunctionDefinition;
+        structural?: boolean;
+        def?: OneOf<[BoxedSymbolDefinition, BoxedFunctionDefinition]>;
     });
     get json(): Expression;
     get hash(): number;
     get isPure(): boolean;
+    get isStructural(): boolean;
+    get structural(): BoxedExpression;
     get scope(): RuntimeScope | null;
     get isConstant(): boolean;
+    private _lookupDef;
+    /** This method returns the definition associated with the value of this symbol, or associated with the symbol if it has no value. This is the definition to use with most operations on the symbol. Indeed, "x[2]" is accessing the second element of **the value** of "x".*/
+    private _getDef;
     /**
      * Associate a definition with this symbol
      */
@@ -41,49 +51,53 @@ export declare class BoxedSymbol extends _BoxedExpression {
     reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
+    is(rhs: any): boolean;
     get canonical(): BoxedExpression;
+    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 head(): string;
+    get operator(): string;
     get symbol(): string;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     /**
      * Subsequence inferences will narrow the domain of the symbol.
-     * f(:integer), g(:real)
-     * g(x) => x:real
-     * f(x) => x:integer narrowed from integer to real
+     * f: integer -> real, g: real -> real
+     * g(x) => x: real
+     * f(x) => x: integer narrowed from integer to real
      */
-    infer(domain: BoxedDomain): boolean;
-    get value(): number | boolean | string | Object | undefined;
-    set value(value: boolean | string | Decimal | Complex | {
-        re: number;
-        im: number;
-    } | {
-        num: number;
-        denom: number;
-    } | number[] | BoxedExpression | number | undefined);
-    get domain(): BoxedDomain | undefined;
-    set domain(inDomain: DomainExpression | BoxedDomain);
-    get sgn(): -1 | 0 | 1 | undefined | null;
+    infer(t: Type): boolean;
+    get value(): number | boolean | string | object | undefined;
+    set value(value: boolean | string | Decimal | number[] | OneOf<[
+        {
+            re: number;
+            im: number;
+        },
+        {
+            num: number;
+            denom: number;
+        },
+        BoxedExpression
+    ]> | number | object | undefined);
+    get type(): Type;
+    set type(t: Type | TypeString);
+    get sgn(): Sign | undefined;
     has(x: string | string[]): boolean;
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | 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;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     get isFunction(): 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;
@@ -93,17 +107,25 @@ export declare class BoxedSymbol extends _BoxedExpression {
     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;
-    simplify(options?: SimplifyOptions): BoxedExpression;
+    get re(): number;
+    get im(): number;
+    get bignumRe(): BigNum | undefined;
+    get bignumIm(): BigNum | undefined;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    N(options?: NOptions): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;
+    N(): BoxedExpression;
+    replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): BoxedExpression | null;
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
+    get isCollection(): boolean;
+    contains(rhs: BoxedExpression): boolean;
+    get size(): number;
+    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
+    at(index: number): BoxedExpression | undefined;
+    get(index: BoxedExpression | string): BoxedExpression | undefined;
+    indexOf(expr: BoxedExpression): number;
+    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
 }
 export declare function makeCanonicalSymbol(ce: IComputeEngine, name: string): BoxedExpression;

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

@@ -1,37 +1,40 @@
-/* 0.25.0 */
-import Decimal from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, SimplifyOptions, Metadata, BoxedDomain, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition, SemiBoxedExpression } from '../public';
-import { DataTypeMap, TensorDataType } from '../symbolic/tensor-fields';
-import { AbstractTensor, TensorData } from '../symbolic/tensors';
+/* 0.26.0 */
+import type { BoxedExpression, IComputeEngine, EvaluateOptions, SimplifyOptions, Metadata, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition } from '../public';
+import { TensorDataType } from './tensor-fields';
+import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
+import { AbstractTensor, TensorData } from '../tensor/tensors';
+import { Type } from '../../common/type/types';
 /**
- * A boxed tensor represents an expression that can be
- * represented by a tensor. This could be a vector, matrix
- * or multi-dimensional array.
+ * 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 object can be created either from a tensor or from an expression that
+ * can be represented as a tensor.
  *
- * The counterpart (expression if input is tensor, or tensor
+ * The structural counterpart (expression if input is tensor, or tensor
  * if input is expression) is created lazily.
  *
  * @noInheritDoc
  *
  */
 export declare class BoxedTensor extends _BoxedExpression {
+    readonly options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    };
     private _tensor;
-    private readonly _head?;
+    private readonly _operator?;
     private readonly _ops?;
     private _expression;
     constructor(ce: IComputeEngine, input: {
-        head?: string;
+        op?: string;
         ops: ReadonlyArray<BoxedExpression>;
     } | AbstractTensor<'expression'>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
-    get expression(): BoxedExpression;
+    get structural(): BoxedExpression;
     /** Create the tensor on demand */
     get tensor(): AbstractTensor<'expression'>;
     get baseDefinition(): BoxedBaseDefinition | undefined;
@@ -45,28 +48,42 @@ export declare class BoxedTensor extends _BoxedExpression {
     get isPure(): boolean;
     get isValid(): boolean;
     get complexity(): number;
-    get head(): string;
+    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 domain(): BoxedDomain | undefined;
+    get type(): Type;
     get json(): Expression;
-    /** Structural equality */
-    isSame(rhs: BoxedExpression): boolean;
     /** Mathematical equality */
-    isEqual(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    isEqual(rhs: number | BoxedExpression): boolean | undefined;
+    get isCollection(): boolean;
+    contains(rhs: BoxedExpression): boolean;
+    get size(): number;
+    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
+    at(_index: number): BoxedExpression | undefined;
+    indexOf(_expr: BoxedExpression): number;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    simplify(options?: SimplifyOptions): BoxedExpression;
-    N(options?: NOptions): BoxedExpression;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    N(): BoxedExpression;
 }
 export declare function isBoxedTensor(val: unknown): val is BoxedTensor;
-export declare function expressionTensorInfo(head: string, rows: ReadonlyArray<BoxedExpression>): {
+export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<BoxedExpression>): {
     shape: number[];
-    dtype: keyof DataTypeMap;
-};
-export declare function expressionAsTensor<T extends TensorDataType>(head: string, rows: ReadonlyArray<BoxedExpression>): TensorData<T> | undefined;
+    dtype: TensorDataType | undefined;
+} | undefined;
+export declare function expressionAsTensor<T extends TensorDataType = 'expression'>(operator: string, rows: ReadonlyArray<BoxedExpression>): TensorData<T> | undefined;

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

@@ -0,0 +1,6 @@
+/* 0.26.0 */
+    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;

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

@@ -1,2 +1,2 @@
-/* 0.25.0 */
+/* 0.26.0 */
 export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions): BoxedExpression;

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

@@ -0,0 +1,13 @@
+/* 0.26.0 */
+/**
+ * Structural equality of boxed expressions.
+ */
+export declare function same(a: BoxedExpression, b: BoxedExpression): boolean;
+/**
+ * Mathematically 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, b: 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.26.0 */
+export declare function expandProducts(ce: IComputeEngine, 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: IComputeEngine, 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

@@ -1,4 +1,4 @@
-/* 0.25.0 */
+/* 0.26.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/factor.d.ts

@@ -1,11 +1,12 @@
-/* 0.25.0 */
-import Decimal from 'decimal.js';
-import { Rational } from '../numerics/rationals';
-import { BoxedExpression } from './public';
-export declare function applyCoefficient(value: number | Decimal | Complex | Rational | null, coef: Rational): number | Decimal | Complex | Rational | null;
+/* 0.26.0 */
+import { NumericValue } from '../numeric-value/public';
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;
 /**
- * Return a list of expressions that multiply together to form `expr`.
+ * 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;
+export declare function getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];

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

@@ -0,0 +1,25 @@
+/* 0.26.0 */
+/**
+ *
+ * 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,9 @@
+/* 0.26.0 */
+/** Apply the function `f` to each operand of the expression `expr`,
+ * account for the 'hold' property of the function 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>;

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

@@ -1,6 +1,4 @@
-/* 0.25.0 */
-import Decimal from 'decimal.js';
-import { BoxedSubstitution, PatternMatchOptions, BoxedExpression, SemiBoxedExpression } from './public';
+/* 0.26.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).
@@ -11,4 +9,4 @@ import { BoxedSubstitution, PatternMatchOptions, BoxedExpression, SemiBoxedExpre
  * If the expression does not match the pattern, it returns `null`.
  *
  */
-export declare function match(subject: BoxedExpression, pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+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,10 @@
+/* 0.26.0 */
+/**
+ * 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: IComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -1,41 +1,7 @@
-/* 0.25.0 */
-import { Rational } from '../numerics/rationals';
-import { BoxedExpression } from './public';
-/**
- * Attempt to factor a numeric coefficient `c` and a `rest` out of a
- * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
- *
- * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
- *
- * For example:
- *
- * ['Multiply', 2, 'x', 3, 'a']
- *    -> [6, ['Multiply', 'x', 'a']]
- *
- * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
- *    -> [['Rational', 2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
- */
-export declare function asCoefficient(expr: BoxedExpression): [coef: Rational, rest: BoxedExpression];
+/* 0.26.0 */
+import type { Rational } from '../numerics/rationals';
+import type { BoxedExpression } from './public';
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
-export declare function asApproximateRational(expr: BoxedExpression): Rational | undefined;
-export declare function div(lhs: Rational, rhs: Rational): Rational;
-/**
- * Add a literal numeric value to a rational.
- * If the rational is a bigint, this is a hint to do the calculation in bigint
- * (no need to check `bignumPreferred()`).
- * @param lhs
- * @param rhs
- * @returns
- */
-export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
-export declare function mul(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
-export declare function asFloat(expr: BoxedExpression | undefined): number | null;
+export declare function asBigint(expr: BoxedExpression | undefined): bigint | null;
 export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
-export declare function asMachineInteger(expr: BoxedExpression | undefined): number | null;
-/**
- *
- * @param lhs
- * @param rhs
- * @returns the sign (-1, 0, 1) of the difference between `lhs` and `rhs`
- */
-export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;
+export declare function asSmallInteger(expr: number | BoxedExpression | undefined): number | null;

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

@@ -1,11 +1,22 @@
-/* 0.25.0 */
+/* 0.26.0 */
 export 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,
+ * 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 sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;
+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`
@@ -15,7 +26,7 @@ export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyAr
  * 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)
+ *  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,
@@ -26,7 +37,7 @@ export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyAr
  * 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
+ * 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.
  *
@@ -35,9 +46,8 @@ export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyAr
  * 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
- *
+ * 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;
@@ -47,13 +57,15 @@ export declare function order(a: BoxedExpression, b: BoxedExpression): number;
 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): SemiBoxedExpression;
-export declare function lexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
-export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
-export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
-export declare function eliminationOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
+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 {};

package/dist/types/compute-engine/{symbolic → boxed-expression}/polynomials.d.ts

@@ -1,4 +1,4 @@
-/* 0.25.0 */
+/* 0.26.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *
@@ -22,31 +22,27 @@ export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
  */
 export declare function coefficients(poly: BoxedExpression, vars: string): UnivariateCoefficients | null;
 export declare function coefficients(poly: BoxedExpression, vars: string[]): MultivariateCoefficients | null;
-/**
- * Return a polynomial expression of `vars` with coefficient
- * of powers `coefs`.
- *
- * `poly === polynomial(coefficients(poly), getVars(poly))`
- *
- */
-export declare function polynomial(coefs: UnivariateCoefficients, vars: string): SemiBoxedExpression;
-export declare function polynomial(coefs: MultivariateCoefficients, vars: string[]): SemiBoxedExpression;
 /**
  * The total degree of an expression is the sum of the
- * of the positive integer degrees of the factors in the expression:
+ * positive integer degrees of the factors in the expression:
  *
- * `3√2x^5y^3` -> 8 (5 + 3)
+ * `3√2x^5y^3` -> 5 + 3 = 8
  */
 export declare function totalDegree(expr: BoxedExpression): number;
 /**
- * The max degree of an expression is the largest positive integer degree
- * in the factors of the expression
+ * The max degree of a polynomial is the largest positive integer degree
+ * in the factors (monomials) of the expression
  *
  * `3√2x^5y^3` -> 5
  *
  */
 export declare function maxDegree(expr: BoxedExpression): number;
 /**
- * Return a lexicographic key of the expression
+ * Return a lexicographic key of the expression, for example
+ * `xy^2` -> `x y`
+ * `x\frac{1}{y}` -> `x y`
+ * `2xy + y^2` -> `x y y`
+ *
  */
 export declare function lex(expr: BoxedExpression): string;
+export declare function revlex(expr: BoxedExpression): string;