@cortex-js/compute-engine 0.4.1 → 0.4.4

package/dist/types/common/debug.d.ts

@@ -1,28 +0,0 @@
-/* 0.4.1 */
-export declare type Terminal = {
-    joinLines(lines: string[]): string;
-    grey(s: string): string;
-    red(s: string): string;
-    highlightBackground(s: string): string;
-};
-export declare const colorTerminal: Terminal;
-export declare class Origin {
-    url: string;
-    source: string;
-    _lines: string[];
-    _lineOffsets: number[];
-    constructor(source: string, url?: string);
-    get lines(): string[];
-    get lineOffsets(): number[];
-    getLinecol(offset: number): [line: number, col: number];
-    signalOrigin(offset: number): SignalOrigin;
-    chalkGutter(s: string): string;
-    chalkMarker(s: string): string;
-    chalkMessage(s: string): string;
-    /** line: 1..., column: 1... */
-    sourceAround(line: number, column: number, message?: string): string;
-}
-/** Word-wrap a string that contains ANSI escape sequences.
- *  ANSI escape sequences do not add to the string length.
- */
-export declare const wrapAnsiString: (string: string, terminalWidth: number) => string;

package/dist/types/common/utils.d.ts

@@ -1,153 +0,0 @@
-/* 0.4.1 */
-import { Decimal } from 'decimal.js';
-import { Complex } from 'complex.js';
-import { Numeric } from '../compute-engine/public';
-/**
- * The `ExpressionX` type is used internally to make computations with
- * arbitrarily large floating point and complex numbers
- *
- */
-export declare type ExpressionX = Expression<Numeric>;
-/**
- * These constants are the 'primitive' functions and constants that are used
- * for some basic manipulations such as parsing, and transforming to canonical
- * form.
- *
- */
-export declare const PARENTHESES = "Parentheses";
-export declare const IDENTITY = "Identity";
-export declare const LATEX_TOKENS = "LatexTokens";
-export declare const LIST = "List";
-export declare const MISSING = "Missing";
-export declare const NOTHING = "Nothing";
-export declare const SEQUENCE = "Sequence";
-export declare const SEQUENCE2 = "Sequence2";
-export declare const ADD = "Add";
-export declare const DERIVATIVE = "Derivative";
-export declare const DIVIDE = "Divide";
-export declare const EXP = "Exp";
-export declare const INVERSE_FUNCTION = "InverseFunction";
-export declare const MULTIPLY = "Multiply";
-export declare const NEGATE = "Negate";
-export declare const POWER = "Power";
-export declare const PRIME = "Prime";
-export declare const ROOT = "Root";
-export declare const SQRT = "Sqrt";
-export declare const SUBTRACT = "Subtract";
-export declare const COMPLEX_INFINITY = "ComplexInfinity";
-export declare const PI = "Pi";
-export declare const EXPONENTIAL_E = "ExponentialE";
-export declare const IMAGINARY_UNIT = "ImaginaryUnit";
-export declare function isNumberObject(expr: Expression | null): expr is MathJsonRealNumber;
-export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
-export declare function isStringObject(expr: Expression | null): expr is MathJsonString;
-export declare function isFunctionObject<T extends number = number>(expr: Expression<T> | null): expr is MathJsonFunction<T>;
-export declare function isDictionaryObject<T extends number = number>(expr: Expression<T>): expr is MathJsonRealNumber;
-export declare function getNumberValue<T extends number = number>(expr: Expression<T> | null): number | null;
-/** Only return non-null if the expression is a Complex number.
- * Return null if it's a number, or a symbol (other than  `ImaginaryUnit` or
- * `ComplexInfinity`)
- *
- */
-export declare function getComplexValue(expr: Complex | Expression | null): Complex | null;
-/**
- * Return a multiple of the imaginary unit, e.g.
- * - 'ImaginaryUnit'
- * - ['Negate', 'ImaginaryUnit']
- * - ['Multiply', 5, 'ImaginaryUnit']
- * - ['Multiply', 'ImaginaryUnit', 5]
- */
-export declare function getImaginaryValue(expr: Expression): number | null;
-export declare function getDecimalValue(expr: Decimal | Expression | null): Decimal | null;
-/**  If expr is a string literal, return it.
- *
- * A string literal is a JSON string that begins and ends with
- * **U+0027 APOSTROPHE** : **`'`** or an object literal with a `str` key.
- */
-export declare function getStringValue(expr: Expression | null): string | null;
-/**
- * Return a rational (numer over denom) representation of the expression,
- * if possible, `[null, null]` otherwise.
- *
- * The expression can be:
- * - Some symbols: "ThreeQuarte", "Half"...
- * - ["Power", d, -1]
- * - ["Power", n, 1]
- * - ["Divide", n, d]
- *
- * The denominator is always > 0.
- */
-export declare function getRationalValue(expr: Expression): [number, number] | [null, null];
-/**
- *  Reduce the numerator and denominator:
- * `\frac{2}{4} -> \frac{1}{2})`
- */
-export declare function simplifyRational([numer, denom]: [number, number] | [null, null]): [number, number] | [null, null];
-/**
- * Return the numerator and denominator of a product with the specified symbol.
- * For example:
- * `3π` -> [3, 1]
- * `3π/2` -> [3, 2]
- * `1/2 * π` -> [1, 2]
- */
-export declare function getRationalSymbolicValue(expr: Expression, symbol: string): [number, number] | [null, null];
-/** True if the expression is of the form \frac{n}{m} where n and m are both integers
- *
- * Note this detects fewer patterns than `getRationalValue()`, but it is
- * intended to detect rational numbers used with invisible plus, i.e. `1\frac{1}{2}`
- *
- */
-export declare function isRationalNumber(expr: Expression): boolean;
-/**
- * Return the head of any expression, including symbols and numbers.
- *
- */
-export declare function getHead(expr: Expression): Expression | null;
-/**
- * The head of a function can be a string or an expression.
- *
- * Return `null` if the expression is not a function.
- *
- * Examples:
- * * `["Negate", 5]`  -> `"Negate"`
- * * `[["Prime", "f"], "x"]` -> `["Prime", "f"]`
- */
-export declare function getFunctionHead<T extends number = number>(expr: Expression<T> | null): Expression<T> | null;
-/**
- * True if the expression is a number, a symbol or a string
- * (i.e. not a function and not a dictionary)
- */
-export declare function isAtomic(expr: Expression | null): boolean;
-export declare function getFunctionName<T extends number = number>(expr: Expression<T> | null): typeof MULTIPLY | typeof POWER | typeof DIVIDE | typeof ADD | typeof SUBTRACT | typeof NEGATE | typeof DERIVATIVE | typeof INVERSE_FUNCTION | typeof LATEX_TOKENS | typeof SQRT | typeof ROOT | typeof PARENTHESES | typeof LIST | typeof MISSING | typeof PRIME | typeof IDENTITY | typeof NOTHING | typeof SEQUENCE | typeof SEQUENCE2 | typeof PRIME | 'PartialDerivative' | 'Union' | 'Intersection' | 'SetMinus' | 'Cosh' | 'Exp' | 'Re' | 'And' | 'Not' | 'Equal' | 'NotEqual' | 'Element' | 'NotElement' | 'Complex' | 'Hold' | 'Evaluate' | '';
-export declare function getSymbolName(expr: Expression | null): string | null;
-/**
- * Return all the elements but the first one, i.e. the arguments of a
- * function.
- */
-export declare function getTail<T extends number = number>(expr: Expression<T> | null): Expression<T>[];
-export declare function applyRecursively<T extends number = number>(expr: Expression<T>, fn: (x: Expression<T>) => Expression<T>): Expression<T>;
-/**
- * Apply a function to the arguments of a function and return an array of T
- */
-export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
-export declare function getArg<T extends number = number>(expr: Expression<T> | null, n: number): Expression<T> | null;
-export declare function getArgCount<T extends number = number>(expr: Expression<T>): number;
-export declare function getDictionary<T extends number = number>(expr: Expression<T>): {
-    [key: string]: Expression<T>;
-} | null;
-/**
- * Structurally compare two expressions, ignoring metadata.
- *
- * Compare with `match()` which ignores differences in representation.
- *
- * @revisit: is this really needed? Or just use `match()`?
- */
-export declare function equalExpr<T extends number = number>(lhs: Expression<T> | null, rhs: Expression<T> | null): boolean;
-/**
- * Return the nth term in expr.
- * If expr is not a "add" function, returns null.
- */
-/**
- * Return the coefficient of the expression, assuming vars are variables.
- */
-export declare function coef(_expr: Expression, _vars: string[]): Expression | null;

package/dist/types/compute-engine/canonical-forms.d.ts

@@ -1,74 +0,0 @@
-/* 0.4.1 */
-import { Form, ComputeEngine } from './public';
-export declare function canonicalNumberForm(expr: Expression, engine: ComputeEngine): Expression;
-/**
- * Transform the expression so that object literals for numbers, symbols and
- * functions are used only when necessary, i.e. when they have associated
- * metadata attributes. Otherwise, use a plain number, string or array
- *
- * For example:
- *
- * ```
- * {num: 2} -> 2
- * {sym: "x"} -> "x"
- * {fn:['add', {num: 1}, {sym: "x"}]} -> ['add', 1, "x"]
- * ```
- *
- */
-export declare function jsonForm(expr: Expression | null, engine: ComputeEngine): Expression | null;
-export declare function strippedMetadataForm(expr: Expression | null, engine: ComputeEngine): Expression | null;
-export declare function objectLiteralForm(expr: Expression, engine: ComputeEngine): Expression;
-/**
- * Transform the expression so that the arguments of functions that have the
- * `isCommutative` attributes are ordered as follow:
- *
- * - Real numbers
- * - Complex numbers
- * - Symbols
- * - Functions
- *
- * Within Real Numbers:
- * - by their value
- *
- * Within Complex numbers:
- * - by the value of their imaginary component,
- * - then by the value of their real component
- *
- * Within Symbols:
- * - constants (`isConstant === true`) before non-constants
- * - then alphabetically
- *
- * Within Functions:
- * - if a `[MULTIPLY]` or a `[POWER]`... @todo
- *
- */
-export declare function sortedForm(expr: Expression, engine: ComputeEngine): Expression;
-/**
- *  Return the expression in canonical form:
- *
- * - `"divide"`, `"exp"`,` `"subtract"`, `"root"`, `"exp"` replaced with
- *      `"add"`, `"multiply"`, "`power"`
- * - some trivial simplifications (multiply by 1, addition of 0, division by 1)
- * - terms sorted
- *
- */
-export declare function canonicalForm(expr: Expression | null, engine: ComputeEngine): Expression | null;
-/**
- * Return a string escaped as necessary to comply with the JSON format
- *
- */
-export declare function escapeText(s: string): string;
-/**
- * Transform an expression by applying one or more rewriting rules to it,
- * recursively.
- *
- * There are many ways to symbolically manipulate an expression, but
- * transformations with `form` have the following characteristics:
- *
- * - they don't require calculations or assumptions about the domain of free
- * variables or the value of constants
- * - the output expression is expressed with more primitive functions,
- * for example subtraction is replaced with addition
- *
- */
-export declare function format(engine: ComputeEngine, expr: Expression | null, forms: Form[]): Expression | null;

package/dist/types/compute-engine/dictionary/domains.d.ts

@@ -1,26 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine, Dictionary, Domain } from '../public';
-/**
- * The set of domains form a lattice with 'Anything' at the top and 'Nothing'
- * at the bottom.
- *
- * The DOMAIN_PARENT table represents this lattice by indicating the parent(s)
- * for each domain.
- */
-/**
- * These synonyms are shortcuts that get normalized to their definition.
- */
-export declare const DOMAIN_SYNONYMS: {
-    [synonym: string]: Expression;
-};
-export declare function getDomainsDictionary(): Dictionary;
-/**
- * Check the domains of the entries in a dictionary for logical consistency
- *
- */
-/**
- * Return a simplified form of the domain
- *
- */
-export declare function simplifyDomain(dom: Domain, _engine: ComputeEngine): Domain;
-export declare function canonicalDomain(engine: ComputeEngine, expr: Expression): Expression;

package/dist/types/compute-engine/dictionary/utils.d.ts

@@ -1,5 +0,0 @@
-/* 0.4.1 */
-export declare function isSetDefinition(def: number | Definition<any> | undefined | null): def is SetDefinition<Numeric>;
-export declare function isSymbolDefinition(def: number | Definition<any> | undefined | null): def is SymbolDefinition<Numeric>;
-export declare function isFunctionDefinition(def: number | Definition<any> | undefined | null): def is FunctionDefinition<Numeric>;
-export declare function isCollectionDefinition(def: number | Definition<any> | undefined | null): def is CollectionDefinition<Numeric>;

package/dist/types/compute-engine/domains.d.ts

@@ -1,4 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine } from './public';
-export declare function internalDomain(engine: ComputeEngine, expr: Expression): Expression | null;
-export declare function inferNumericDomain(value: Expression | undefined): Expression | null;

package/dist/types/compute-engine/evaluate.d.ts

@@ -1,13 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine } from './public';
-export declare function evaluateOnce(engine: ComputeEngine, expr: Expression | null): Expression | null;
-/**
- * Evaluate until:
- * - the timeLimit is reached
- * - the iterationLimit is reached
- * - the expression stops changing
- */
-export declare function internalEvaluate(engine: ComputeEngine, expr: Expression, options?: {
-    timeLimit?: number;
-    iterationLimit?: number;
-}): Promise<Expression | null>;

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

@@ -1,11 +0,0 @@
-/* 0.4.1 */
-export declare class ExpressionMap<T extends number, U> {
-    readonly _items: Map<Expression<T>, U>;
-    constructor(source?: ExpressionMap<T, U> | Iterable<[T, U]>);
-    has(expr: Expression<T>): boolean;
-    get(expr: Expression<T>): U | undefined;
-    set(expr: Expression<T>, value: U): void;
-    delete(expr: Expression<T>): void;
-    [Symbol.iterator](): IterableIterator<[Expression<T>, U]>;
-    entries(): IterableIterator<[Expression<T>, U]>;
-}

package/dist/types/compute-engine/internal-compute-engine.d.ts

@@ -1,108 +0,0 @@
-/* 0.4.1 */
-import { CollectionDefinition, ComputeEngine, Definition, Dictionary, Domain, Form, FunctionDefinition, Numeric, NumericFormat, RuleSet, RuntimeScope, Scope, SetDefinition, Simplification, SymbolDefinition } from './public';
-import { ExpressionMap } from './expression-map';
-import { LatexSyntax } from '../latex-syntax/latex-syntax';
-/**
- * The internal  compute engine implements the ComputeEngine interface
- * but does not:
- * - account for time limits
- * - account for iteration limits
- * - apply a canonical form
- *
- * It is used for recursive calls, and by the "top-level" `ComputeEngine`.
- */
-export declare class InternalComputeEngine implements ComputeEngine<Numeric> {
-    static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary<Numeric>>[];
-    private _precision;
-    private _numericFormat;
-    private _latexSyntax?;
-    private _tolerance;
-    private _rules?;
-    /**
-     * The current scope.
-     *
-     * A scope is a dictionary that contains the definition of local symbols.
-     *
-     * Scopes form a stack, and definitions in more recent
-     * scopes can obscure definitions from older scopes.
-     *
-     */
-    context: RuntimeScope<Numeric>;
-    /** Absolute time beyond which evaluation should not proceed */
-    deadline?: number;
-    constructor(options?: {
-        dictionaries?: Readonly<Dictionary<Numeric>>[];
-    });
-    get precision(): number;
-    set precision(p: number | 'machine');
-    get numericFormat(): NumericFormat;
-    set numericFormat(f: NumericFormat);
-    get tolerance(): number;
-    set tolerance(val: number);
-    /** Generator function (indicated by the leading '*') that returns all the
-     *  rules in all the topics requested.
-     */
-    getRules(topics: string | string[]): RuleSet;
-    get latexSyntax(): LatexSyntax;
-    pushScope(dictionary: Readonly<Dictionary<Numeric>>, scope?: Partial<Scope>): void;
-    popScope(): void;
-    get assumptions(): ExpressionMap<Numeric, boolean>;
-    signal(_sig: ErrorSignal | WarningSignal): void;
-    get timeLimit(): undefined | number;
-    get recursionLimit(): undefined | number;
-    get iterationLimit(): undefined | number;
-    shouldContinueExecution(): boolean;
-    checkContinueExecution(): void;
-    getFunctionDefinition(name: string): FunctionDefinition | null;
-    getSymbolDefinition(name: string): SymbolDefinition<Numeric> | null;
-    getSetDefinition(name: string): SetDefinition<Numeric> | null;
-    getCollectionDefinition(name: string): CollectionDefinition<Numeric> | null;
-    getDefinition(name: string): Definition<Numeric> | null;
-    canonical(expr: Expression | null): Expression | null;
-    format(expr: Expression | null, forms?: Form | Form[]): Expression | null;
-    evaluate(expr: Expression, options?: {
-        timeLimit?: number;
-        iterationLimit?: number;
-    }): Promise<Expression | null>;
-    simplify(expr: Expression, options?: {
-        simplifications?: Simplification[];
-    }): Expression | null;
-    N(expr: Expression, options?: {
-        precision?: number;
-    }): Expression | null;
-    is(arg1: Expression, arg2?: Domain): boolean | undefined;
-    ask(pattern: Expression): {
-        [symbol: string]: Expression;
-    }[];
-    assume(arg1: Expression, arg2?: Domain): 'contradiction' | 'tautology' | 'ok';
-    replace(rules: RuleSet, expr: Expression<Numeric>): Expression<Numeric>;
-    domain(expr: Expression): Domain | null;
-    getVars(expr: Expression): Set<string>;
-    chop(n: Numeric): Numeric;
-    parse(s: string): Expression;
-    serialize(x: Expression): string;
-    isZero(x: Expression): boolean | undefined;
-    isNotZero(x: Expression): boolean | undefined;
-    isNumeric(x: Expression): boolean | undefined;
-    isInfinity(x: Expression): boolean | undefined;
-    isFinite(x: Expression): boolean | undefined;
-    isNonNegative(x: Expression): boolean | undefined;
-    isPositive(x: Expression): boolean | undefined;
-    isNegative(x: Expression): boolean | undefined;
-    isNonPositive(x: Expression): boolean | undefined;
-    isInteger(x: Expression): boolean | undefined;
-    isRational(x: Expression): boolean | undefined;
-    isAlgebraic(x: Expression): boolean | undefined;
-    isReal(x: Expression): boolean | undefined;
-    isExtendedReal(x: Expression): boolean | undefined;
-    isComplex(x: Expression): boolean | undefined;
-    isOne(x: Expression): boolean | undefined;
-    isNegativeOne(x: Expression): boolean | undefined;
-    isElement(x: Expression, set: Expression): boolean | undefined;
-    isSubsetOf(lhs: Domain | null, rhs: Domain | null): boolean;
-    isEqual(lhs: Expression, rhs: Expression): boolean | undefined;
-    isLess(lhs: Expression, rhs: Expression): boolean | undefined;
-    isLessEqual(lhs: Expression, rhs: Expression): boolean | undefined;
-    isGreater(lhs: Expression, rhs: Expression): boolean | undefined;
-    isGreaterEqual(lhs: Expression, rhs: Expression): boolean | undefined;
-}

package/dist/types/compute-engine/numeric-complex.d.ts

@@ -1,2 +0,0 @@
-/* 0.4.1 */
-export declare function gamma(c: Complex): Complex;

package/dist/types/compute-engine/numeric-decimal.d.ts

@@ -1,12 +0,0 @@
-/* 0.4.1 */
-export declare const DECIMAL_ZERO: Decimal;
-export declare const DECIMAL_ONE: Decimal;
-export declare const DECIMAL_MINUS_ONE: Decimal;
-export declare const DECIMAL_NAN: Decimal;
-export declare const DECIMAL_POS_INFINITY: Decimal;
-export declare const DECIMAL_NEG_INFINITY: Decimal;
-export declare function gcd(a: Decimal, b: Decimal): Decimal;
-export declare function lcm(a: Decimal, b: Decimal): Decimal;
-export declare function factorial(n: Decimal | number): Decimal;
-export declare function lngamma(z: Decimal | number): Decimal;
-export declare function gamma(z: Decimal | number): Decimal;

package/dist/types/compute-engine/numeric.d.ts

@@ -1,21 +0,0 @@
-/* 0.4.1 */
-export declare const MACHINE_PRECISION: number;
-export declare const MACHINE_TOLERANCE_BITS = 7;
-export declare const MACHINE_TOLERANCE: number;
-export declare const NUMERICAL_TOLERANCE: number;
-/**
- * Returns the smallest floating-point number greater than x.
- * Denormalized values may not be supported.
- */
-export declare function nextUp(x: number): number;
-export declare function nextDown(x: number): number;
-export declare const SMALL_PRIMES: Set<number>;
-export declare const LARGEST_SMALL_PRIME = 7919;
-export declare function primeFactors(_n: number): {
-    [factor: number]: number;
-};
-export declare function gcd(a: number, b: number): number;
-export declare function lcm(a: number, b: number): number;
-export declare function factorial(n: number): number;
-export declare function lngamma(z: number): number;
-export declare function gamma(z: number): number;

package/dist/types/compute-engine/numerical-eval.d.ts

@@ -1,5 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine, Numeric } from './public';
-/**
- */
-export declare function internalN(engine: ComputeEngine, expr: Expression<Numeric>): Numeric | Expression<Numeric> | null;

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

@@ -1,18 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine } from './public';
-export declare function order(a: Expression, b: Expression): number;
-/**
- * Return the (total) degree of the term
- */
-export declare function degree(expr: Expression, sortedVars: string[]): number;
-/**
- * The deglex order is used for sum of factors:
- * - first by total degree of each factor
- * - then lexicographically for each variable
- * - then lexicographically for other symbols
- * - then by length
- * - then by value
- *
- */
-export declare function deglex(a: Expression, b: Expression, sortedVars: string[]): number;
-export declare function canonicalOrder(engine: ComputeEngine, sortedVars: string[], expr: Expression): Expression;

package/dist/types/compute-engine/patterns.d.ts

@@ -1,22 +0,0 @@
-/* 0.4.1 */
-import { Expression } from '../public';
-import { Numeric } from './public';
-export declare type Substitution<T extends number = number> = {
-    [symbol: string]: Expression<T>;
-};
-export declare function matchRecursive(expr: ExpressionX, pattern: ExpressionX, substitution: Substitution<Numeric>, options: {
-    numericalTolerance: number;
-}): Substitution<Numeric> | null;
-export declare function match<T extends number = number>(pattern: Expression<T>, expr: Expression<T>, options?: {
-    numericalTolerance: number;
-}): Substitution<T> | null;
-export declare function match1(expr: Expression, pattern: Expression, options: {
-    numericalTolerance: number;
-}): Expression | null;
-export declare function count(exprs: Iterable<Expression>, pattern: Expression, options: {
-    numericalTolerance: number;
-}): number;
-export declare function matchList(exprs: Iterable<Expression>, pattern: Expression, options: {
-    numericalTolerance: number;
-}): Substitution[];
-export declare function substitute<T extends number = Numeric>(expr: Expression<T>, substitution: Substitution<T>): Expression<T>;

package/dist/types/compute-engine/predicates.d.ts

@@ -1,42 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine, Domain } from './public';
-export declare function isInteger(ce: ComputeEngine, expr: Expression): boolean;
-export declare function isNumeric(_ce: ComputeEngine, _expr: Expression | null): boolean | undefined;
-export declare function isZero(ce: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isNotZero(engine: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isInfinity(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isFinite(_ce: ComputeEngine, _expr: Expression | null): boolean | undefined;
-export declare function isPosInfinity(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isNegInfinity(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isPositive(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isOne(ce: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isNegativeOne(ce: ComputeEngine, expr: Expression): boolean | undefined;
-/** Is `expr` >= 0? */
-export declare function isNonNegative(ce: ComputeEngine, expr: Expression): boolean | undefined;
-/** Is `expr` < 0? */
-export declare function isNegative(ce: ComputeEngine, expr: Expression): boolean | undefined;
-/** Is `expr` <= 0? */
-export declare function isNonPositive(ce: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isReal(_ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-/** Is `expr` an element of RR, including ±∞? */
-export declare function isExtendedReal(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` an element of QQ (can be written as p/q)? */
-export declare function isRational(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` an algebraic number, i.e. not transcendental (π, e)? */
-export declare function isAlgebraic(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` a complex number? */
-export declare function isComplex(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` an element of `dom`? */
-export declare function isElement(_ce: ComputeEngine, _expr: Expression, _set: Expression): boolean | undefined;
-/** Test if `lhs` is a subset of `rhs`.
- *
- * `lhs` and `rhs` can be set expressions, i.e.
- * `["SetMinus", "ComplexNumber", 0]`
- *
- */
-export declare function isSubsetOf(ce: ComputeEngine, lhs: Domain | null, rhs: Domain | null): boolean;
-export declare function isEqual(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isLess(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isLessEqual(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isGreater(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isGreaterEqual(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;

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

@@ -1,6 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine, Rule, Simplification } from './public';
-export declare const SIMPLIFY_RULES: {
-    [topic: string]: Rule[];
-};
-export declare function internalSimplify(engine: ComputeEngine, expr: Expression | null, simplifications?: Simplification[]): Expression | null;

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

@@ -1,15 +0,0 @@
-/* 0.4.1 */
-import { ComputeEngine } from './public';
-export declare class CortexError {
-    signal: ErrorSignal;
-    constructor(errorSignal: Signal);
-    toString(): string;
-}
-/**
- * Return the set of variables (free or not) in an expression.
- * Doesn't return free varas because doesn't account for variable declaration
- * and scopes.
- */
-export declare function getVariables(ce: ComputeEngine, expr: Expression): Set<string>;
-export declare function isCanonical(ce: ComputeEngine, expr: Expression): boolean;
-export declare function hasWildcards(expr: Expression): boolean;