@cortex-js/compute-engine 0.30.2 → 0.32.0

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

@@ -1,46 +0,0 @@
-/* 0.30.2 */
-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.30.2 */
-    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.30.2 */
-/**
- * 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.30.2 */
-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.30.2 */
-/**
- * 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.30.2 */
-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.30.2 */
-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.30.2 */
-/** 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.30.2 */
-/**
- *
- * 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.30.2 */
-/** 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,12 +0,0 @@
-/* 0.30.2 */
-/**
- * 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`.
- *
- */
-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.30.2 */
-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.30.2 */
-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.30.2 */
-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,48 +0,0 @@
-/* 0.30.2 */
-/**
- * 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;

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

@@ -1,66 +0,0 @@
-/* 0.30.2 */
-import { NumericValue } from '../numeric-value/types';
-import type { Rational } from '../numerics/types';
-/**
- * Group terms in a product by common term.
- *
- * All the terms should be canonical.
- * - the arguments should have been flattened for `Multiply`
- *
- * - any argument of power been distributed, i.e.
- *      (ab)^2 ->  a^2 b^2
- * *
- * 3 + √5 + √(x+1) + x^2 + (a+b)^2 + d
- *  -> [ [[3, "d"], [1, 1]],
- *       [[5, "x+1"], [1, 2]],
- *       [[1, "a+b"], [2, 1]]
- *      ]
- *
- */
-export declare class Product {
-    readonly options?: {
-        canonical?: boolean;
-    };
-    engine: ComputeEngine;
-    coefficient: NumericValue;
-    terms: {
-        term: BoxedExpression;
-        exponent: Rational;
-    }[];
-    private _isCanonical;
-    static from(expr: BoxedExpression): Product;
-    constructor(ce: ComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
-        canonical?: boolean;
-    });
-    /**
-     * Add a term to the product.
-     *
-     * If `this._isCanonical` a running product of exact terms is kept.
-     * Otherwise, terms and their exponent are tallied.
-     */
-    mul(term: BoxedExpression, exp?: Rational): void;
-    /** Divide the product by a term of coefficient */
-    div(term: NumericValue | BoxedExpression): void;
-    /** The terms of the product, grouped by degrees.
-     *
-     * If `mode` is `rational`, rationals are split into separate numerator and
-     * denominator, so that a rational expression can be created later
-     * If `mode` is `expression`, a boxed expression is returned, without
-     * splitting rationals
-     * If `mode` is `numeric`, the literals are combined into one expression
-     *
-     */
-    groupedByDegrees(options?: {
-        mode?: 'rational' | 'expression' | 'numeric';
-    }): {
-        exponent: Rational;
-        terms: BoxedExpression[];
-    }[] | null;
-    asExpression(options?: {
-        numericApproximation: boolean;
-    }): BoxedExpression;
-    /** The product, expressed as a numerator and denominator */
-    asNumeratorDenominator(): [BoxedExpression, BoxedExpression];
-    asRationalExpression(): BoxedExpression;
-}
-export declare function commonTerms(lhs: Product, rhs: Product): [NumericValue, BoxedExpression];

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

@@ -1,129 +0,0 @@
-/* 0.30.2 */
-export declare const ConditionParent: {
-    boolean: string;
-    string: string;
-    expression: string;
-    numeric: string;
-    number: string;
-    symbol: string;
-    complex: string;
-    imaginary: string;
-    real: string;
-    notreal: string;
-    integer: string;
-    rational: string;
-    irrational: string;
-    notzero: string;
-    notone: string;
-    finite: string;
-    infinite: string;
-    positive: string;
-    negative: string;
-    nonnegative: string;
-    nonpositive: string;
-    even: string;
-    odd: string;
-    prime: string;
-    composite: string;
-    constant: string;
-    variable: string;
-    function: string;
-    operator: string;
-    relation: string;
-    equation: string;
-    inequality: string;
-    collection: string;
-    list: string;
-    set: string;
-    tuple: string;
-    single: string;
-    pair: string;
-    triple: string;
-    tensor: string;
-    vector: string;
-    matrix: string;
-    scalar: string;
-    unit: string;
-    dimension: string;
-    angle: string;
-    polynomial: string;
-};
-export declare const CONDITIONS: {
-    boolean: (x: BoxedExpression) => boolean;
-    string: (x: BoxedExpression) => boolean;
-    number: (x: BoxedExpression) => boolean;
-    symbol: (x: BoxedExpression) => boolean;
-    expression: (x: BoxedExpression) => boolean;
-    numeric: (x: BoxedExpression) => boolean;
-    integer: (x: BoxedExpression) => boolean;
-    rational: (x: BoxedExpression) => boolean;
-    irrational: (x: BoxedExpression) => boolean;
-    real: (x: BoxedExpression) => boolean;
-    notreal: (x: BoxedExpression) => boolean;
-    complex: (x: BoxedExpression) => boolean;
-    imaginary: (x: BoxedExpression) => boolean;
-    positive: (x: BoxedExpression) => boolean;
-    negative: (x: BoxedExpression) => boolean;
-    nonnegative: (x: BoxedExpression) => boolean;
-    nonpositive: (x: BoxedExpression) => boolean;
-    even: (x: BoxedExpression) => boolean;
-    odd: (x: BoxedExpression) => boolean;
-    prime: (x: BoxedExpression) => boolean;
-    composite: (x: BoxedExpression) => boolean;
-    notzero: (x: BoxedExpression) => boolean;
-    notone: (x: BoxedExpression) => boolean;
-    finite: (x: BoxedExpression) => boolean;
-    infinite: (x: BoxedExpression) => boolean;
-    constant: (x: BoxedExpression) => boolean;
-    variable: (x: BoxedExpression) => boolean;
-    function: (x: BoxedExpression) => boolean;
-    relation: (x: BoxedExpression) => boolean;
-    equation: (x: BoxedExpression) => boolean;
-    inequality: (x: BoxedExpression) => boolean;
-    collection: (x: BoxedExpression) => boolean;
-    list: (x: BoxedExpression) => boolean;
-    set: (x: BoxedExpression) => boolean;
-    tuple: (x: BoxedExpression) => boolean;
-    single: (x: BoxedExpression) => boolean;
-    pair: (x: BoxedExpression) => boolean;
-    triple: (x: BoxedExpression) => boolean;
-    scalar: (x: BoxedExpression) => boolean;
-    tensor: (x: BoxedExpression) => boolean;
-    vector: (x: BoxedExpression) => boolean;
-    matrix: (x: BoxedExpression) => boolean;
-    unit: (x: BoxedExpression) => boolean;
-    dimension: (x: BoxedExpression) => boolean;
-    angle: (x: BoxedExpression) => boolean;
-    polynomial: (x: BoxedExpression) => boolean;
-};
-export declare function checkConditions(x: BoxedExpression, conditions: string[]): boolean;
-/**
- * Create a boxed rule set from a collection of non-boxed rules
- */
-export declare function boxRules(ce: ComputeEngine, rs: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
-    canonical?: boolean;
-}): BoxedRuleSet;
-/**
- * Apply a rule to an expression, assuming an incoming substitution
- * @param rule the rule to apply
- * @param expr the expression to apply the rule to
- * @param substitution an incoming substitution
- * @param options
- * @returns A transformed expression, if the rule matched. `null` otherwise.
- */
-export declare function applyRule(rule: Readonly<BoxedRule>, expr: BoxedExpression, substitution: BoxedSubstitution, options?: Readonly<Partial<ReplaceOptions>>): RuleStep | null;
-/**
- * Apply the rules in the ruleset and return a modified expression
- * and the set of rules that were applied.
- *
- * The `replace` function can be used to apply a rule to a non-canonical
- * expression. @fixme: account for options.canonical
- *
- */
-export declare function replace(expr: BoxedExpression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): RuleSteps;
-/**
- * For each rules in the rule set that match, return the `replace` of the rule
- *
- * @param rules
- */
-export declare function matchAnyRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution, options?: Partial<ReplaceOptions>): BoxedExpression[];

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

@@ -1,3 +0,0 @@
-/* 0.30.2 */
-import type { ComputeEngine, BoxedExpression, JsonSerializationOptions } from '../global-types';
-export declare function serializeJson(ce: ComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

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

@@ -1,46 +0,0 @@
-/* 0.30.2 */
-export declare function sgn(expr: BoxedExpression): Sign | undefined;
-/**
- * Sign `s` is > 0.
- *
- * :::info[Note]
- * Returns `undefined` for cases where the given sign is either non-applicable to real numbers
- * ('nan', 'unsigned', 'complex-infinity') or does not convey enough information (e.g. 'real',
- * 'not-zero', 'real-not-zero', 'non-negative').
- * :::
- *
- * @param s
- */
-export declare function positiveSign(s: Sign | undefined): boolean | undefined;
-/**
- * Sign `s` is >= 0.
- *
- *
- * **note**: returns *undefined* where sign does not apply to the field of reals, or does not convey
- * enough information.
- *
- * @param s
- */
-export declare function nonNegativeSign(s: Sign | undefined): boolean | undefined;
-/**
- * Sign `s` is < 0.
- *
- * :::info[Note]
- * Returns `undefined` for cases where the given sign is either non-applicable to real numbers
- * ('nan', 'unsigned', 'complex-infinity') or does not convey enough information (e.g. 'real',
- * 'not-zero', 'real-not-zero', 'non-positive').
- * :::
- *
- * @param s
- */
-export declare function negativeSign(s: Sign | undefined): boolean | undefined;
-/**
- * Sign `s` is <= 0.
- *
- *
- * **note**: returns *undefined* where sign does not apply to the field of reals, or does not convey
- * enough information.
- *
- * @param s
- */
-export declare function nonPositiveSign(s: Sign | undefined): boolean | undefined;

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

@@ -1,6 +0,0 @@
-/* 0.30.2 */
-type InternalSimplifyOptions = SimplifyOptions & {
-    useVariations: boolean;
-};
-export declare function simplify(expr: BoxedExpression, options?: Partial<InternalSimplifyOptions>, steps?: RuleSteps): RuleSteps;
-export {};

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

@@ -1,20 +0,0 @@
-/* 0.30.2 */
-export declare const UNIVARIATE_ROOTS: Rule[];
-/**
- * Expression is a function of a single variable (`x`) or an Equality
- *
- * Return the roots of that variable
- *
- */
-export declare function findUnivariateRoots(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression>;
-/** Expr is an equation with an operator of
- * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
- *
- * Return an expression with the same operator, but with the first argument
- * a variable, if possible:
- * `2x < 4` => `x < 2`
- */
-export declare function univariateSolve(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression> | null;
-/** Harmonization rules transform an expr into one or more equivalent
- * expressions that are easier to solve */
-export declare const HARMONIZATION_RULES: Rule[];

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

@@ -1,10 +0,0 @@
-/* 0.30.2 */
-export declare class Terms {
-    private engine;
-    private terms;
-    constructor(ce: ComputeEngine, terms: ReadonlyArray<BoxedExpression>);
-    private add;
-    private find;
-    N(): BoxedExpression;
-    asExpression(): BoxedExpression;
-}

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

@@ -1,9 +0,0 @@
-/* 0.30.2 */
-export declare function Fu(exp: BoxedExpression): RuleStep | undefined;
-/** Assuming x in an expression in radians, convert to current angular unit. */
-export declare function radiansToAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
-export declare function evalTrig(name: string, op: BoxedExpression | undefined): BoxedExpression | undefined;
-export declare function processInverseFunction(ce: ComputeEngine, xs: ReadonlyArray<BoxedExpression>): BoxedExpression | undefined;
-export declare function trigSign(operator: string, x: BoxedExpression): Sign | undefined;
-export declare function isConstructible(x: string | BoxedExpression): boolean;
-export declare function constructibleValues(operator: string, x: BoxedExpression | undefined): undefined | BoxedExpression;