@cortex-js/compute-engine 0.31.0 → 0.32.0

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

@@ -1,170 +0,0 @@
-/* 0.31.0 */
-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

@@ -1,83 +0,0 @@
-/* 0.31.0 */
-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

@@ -1,46 +0,0 @@
-/* 0.31.0 */
-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

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

@@ -1,5 +0,0 @@
-/* 0.31.0 */
-/**
- * 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

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

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

@@ -1,13 +0,0 @@
-/* 0.31.0 */
-/**
- * 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

@@ -1,20 +0,0 @@
-/* 0.31.0 */
-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

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

@@ -1,10 +0,0 @@
-/* 0.31.0 */
-/** 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

@@ -1,25 +0,0 @@
-/* 0.31.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

@@ -1,10 +0,0 @@
-/* 0.31.0 */
-/** 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

@@ -1,19 +0,0 @@
-/* 0.31.0 */
-/**
- * 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`.
- *
- * <!--
- * @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

@@ -1,11 +0,0 @@
-/* 0.31.0 */
-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

@@ -1,34 +0,0 @@
-/* 0.31.0 */
-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

@@ -1,71 +0,0 @@
-/* 0.31.0 */
-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 {};

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

@@ -1,105 +0,0 @@
-/* 0.31.0 */
-/**
- * Coefficient of a univariate (single variable) polynomial.
- *
- * The first element is a constant.
- * The second element is the coefficient of the variable.
- * The third element is the coefficient of the variable squared.
- * ...etc
- *
- * `3x^3 + 5x + √5 + 2` -> ['√5 + 2', 5, null, 3]
- *
- * If a coefficient does not apply (there are no corresponding term), it is `null`.
- *
- */
-export type UnivariateCoefficients = (null | BoxedExpression)[];
-export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
-/**
- * Return a list of coefficient of powers of `vars` in `poly`,
- * starting with power 0.
- *
- * If `poly`  is not a polynomial, return `null`.
- */
-export declare function coefficients(poly: BoxedExpression, vars: string): UnivariateCoefficients | null;
-export declare function coefficients(poly: BoxedExpression, vars: string[]): MultivariateCoefficients | null;
-/**
- * The total degree of an expression is the sum of the
- * positive integer degrees of the factors in the expression:
- *
- * `3√2x^5y^3` -> 5 + 3 = 8
- */
-export declare function totalDegree(expr: BoxedExpression): number;
-/**
- * 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, 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;
-/**
- * Get the degree of a polynomial in a specific variable.
- * Returns -1 if the expression is not a polynomial in the variable.
- *
- * Examples:
- * - `polynomialDegree(x^3 + 2x + 1, 'x')` → 3
- * - `polynomialDegree(x*y + y^2, 'x')` → 1
- * - `polynomialDegree(sin(x), 'x')` → -1 (not a polynomial)
- */
-export declare function polynomialDegree(expr: BoxedExpression, variable: string): number;
-/**
- * Extract coefficients of a univariate polynomial.
- * Returns an array where index i contains the coefficient of x^i.
- * Returns null if the expression is not a polynomial in the variable.
- *
- * Examples:
- * - `getPolynomialCoefficients(x^3 + 2x + 1, 'x')` → [1, 2, 0, 1]
- * - `getPolynomialCoefficients(3x^2 - x + 5, 'x')` → [5, -1, 3]
- */
-export declare function getPolynomialCoefficients(expr: BoxedExpression, variable: string): BoxedExpression[] | null;
-/**
- * Construct a polynomial expression from its coefficients.
- * coeffs[i] is the coefficient of x^i.
- *
- * Examples:
- * - `fromCoefficients([1, 2, 0, 1], 'x')` → x^3 + 2x + 1
- * - `fromCoefficients([5, -1, 3], 'x')` → 3x^2 - x + 5
- */
-export declare function fromCoefficients(coeffs: BoxedExpression[], variable: string): BoxedExpression;
-/**
- * Polynomial long division.
- * Returns [quotient, remainder] such that dividend = divisor * quotient + remainder.
- * Returns null if inputs are not valid polynomials or divisor is zero.
- *
- * Examples:
- * - `polynomialDivide(x^3-1, x-1, 'x')` → [x^2+x+1, 0]
- * - `polynomialDivide(x^3+2x+1, x+1, 'x')` → [x^2-x+3, -2]
- */
-export declare function polynomialDivide(dividend: BoxedExpression, divisor: BoxedExpression, variable: string): [BoxedExpression, BoxedExpression] | null;
-/**
- * Compute the GCD of two polynomials using the Euclidean algorithm.
- * Returns a monic polynomial (leading coefficient = 1).
- *
- * Examples:
- * - `polynomialGCD(x^2-1, x-1, 'x')` → x-1
- * - `polynomialGCD(x^3-1, x^2-1, 'x')` → x-1
- */
-export declare function polynomialGCD(a: BoxedExpression, b: BoxedExpression, variable: string): BoxedExpression;
-/**
- * Cancel common polynomial factors in a rational expression (Divide).
- * Returns the simplified expression.
- *
- * Examples:
- * - `cancelCommonFactors((x^2-1)/(x-1), 'x')` → x+1
- * - `cancelCommonFactors((x+1)/(x^2+3x+2), 'x')` → 1/(x+2)
- */
-export declare function cancelCommonFactors(expr: BoxedExpression, variable: string): BoxedExpression;