@cortex-js/compute-engine 0.30.2 → 0.32.0

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

@@ -1,300 +0,0 @@
-/* 0.30.2 */
- * A primitive type is a simple type that represents a concrete value.
- *
- * - `any`: the top type
- *    - `expression`
- *    - `error`: an invalid value, such as `["Error", "missing"]`
- *    - `nothing`: the type of the `Nothing` symbol, the unit type
- *    - `never`: the bottom type
- *    - `unknown`: a value whose type is not known
- *
- * - `expression`:
- *    - a symbolic expression, such as `["Add", "x", 1]`
- *    - `<value>`
- *    - `symbol`: a symbol, such as `x`.
- *    - `function`: a function literal
- *      such as `["Function", ["Add", "x", 1], "x"]`.
- *
- * - `value`
- *    - `scalar`
- *      - `<number>`
- *      - `boolean`: a boolean value: `True` or `False`.
- *      - `string`: a string of characters.
- *    - `collection`
- *       - `set`: a collection of unique expressions, e.g. `set<string>`.
- *       - `record`: a collection of specific key-value pairs,
- *          e.g. `record<x: number, y: boolean>`.
- *       - `dictionary`: a collection of arbitrary key-value pairs
- *          e.g. `dictionary<string, number>`.
- *       - `indexed_collection`: collections whose elements can be accessed
- *             by a numeric index
- *          - `list`: a collection of expressions, possibly recursive,
- *              with optional dimensions, e.g. `[number]`, `[boolean^32]`,
- *              `[number^(2x3)]`. Used to represent a vector, a matrix or a
- *              tensor when the type of its elements is a number
- *           - `tuple`: a fixed-size collection of named or unnamed elements,
- *              e.g. `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
- *
- *
- *
- */
-export type PrimitiveType = NumericPrimitiveType | 'collection' | 'indexed_collection' | 'list' | 'set' | 'dictionary' | 'record' | 'dictionary' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
-/**
- * - `number`: any numeric value = `complex` + `real` plus `NaN`
- * - `complex`: a number with non-zero real and imaginary parts = `finite_complex` plus `ComplexInfinity`
- * - `finite_complex`: a finite complex number = `imaginary` + `finite_real`
- * - `imaginary`: a complex number with a real part of 0 (pure imaginary)
- * - `finite_number`: a finite numeric value = `finite_complex`
- * - `finite_real`: a finite real number = `finite_rational` + `finite_integer`
- * - `finite_rational`: a pure rational number
- * - `finite_integer`: a whole number
- * - `real`: a complex number with an imaginary part of 0 = `finite_real` + `non_finite_number`
- * - `non_finite_number`: `PositiveInfinity`, `NegativeInfinity`
- * - `integer`: a whole number = `finite_integer` + `non_finite_number`
- * - `rational`: a pure rational number (not an integer) = `finite_rational` + `non_finite_number`
- *
- */
-export type NumericPrimitiveType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
-export type NamedElement = {
-    name?: string;
-    type: Type;
-};
-export type FunctionSignature = {
-    kind: 'signature';
-    args?: NamedElement[];
-    optArgs?: NamedElement[];
-    variadicArg?: NamedElement;
-    variadicMin?: 0 | 1;
-    result: Type;
-};
-export type AlgebraicType = {
-    kind: 'union' | 'intersection';
-    types: Type[];
-};
-export type NegationType = {
-    kind: 'negation';
-    type: Type;
-};
-export type ValueType = {
-    kind: 'value';
-    value: any;
-};
-/** A record is a collection of key-value pairs.
- *
- * The keys are strings. The set of keys is fixed.
- *
- * For a record type to be a subtype of another record type, it must have a
- * subset of the keys, and all their types must match (width subtyping).
- *
- */
-export type RecordType = {
-    kind: 'record';
-    elements: Record<string, Type>;
-};
-/** A dictionary is a collection of key-value pairs.
- *
- * The keys are strings. The set of keys is also not defined as part of the
- * type and can be modified at runtime.
- *
- * A dictionary is suitable for use as cache or data storage.
- */
-export type DictionaryType = {
-    kind: 'dictionary';
-    values: Type;
-};
-/**
- * `CollectionType` is a generic collection of elements of a certain type.
- *
- * - Indexed collections: List, Tuple
- * - Non-indexed: Set, Record, Dictionary
- *
- */
-export type CollectionType = {
-    kind: 'collection' | 'indexed_collection';
-    elements: Type;
-};
-/**
- * The elements of a list can be accessed by their one-based index.
- *
- * All elements of a list have the same type, but it can be a broad type,
- * up to `any`.
- *
- * The same element can be present in the list more than once.
- *
- * A list can be multi-dimensional. For example, a list of integers with
- * dimensions 2x3x4 is a 3D tensor with 2 layers, 3 rows and 4 columns.
- *
- */
-export type ListType = {
-    kind: 'list';
-    elements: Type;
-    dimensions?: number[];
-};
-export type SymbolType = {
-    kind: 'symbol';
-    name: string;
-};
-export type ExpressionType = {
-    kind: 'expression';
-    operator: string;
-};
-export type NumericType = {
-    kind: 'numeric';
-    type: NumericPrimitiveType;
-    lower?: number;
-    upper?: number;
-};
-/** Each element of a set is unique (is not present in the set more than once).
- * The elements of a set are not indexed.
- */
-export type SetType = {
-    kind: 'set';
-    elements: Type;
-};
-/** The elements of a tuple are indexed and may be named or unnamed.
- * If one element is named, all elements must be named.
- */
-export type TupleType = {
-    kind: 'tuple';
-    elements: NamedElement[];
-};
-/** Nominal typing */
-export type TypeReference = {
-    kind: 'reference';
-    name: string;
-    alias: boolean;
-    def: Type | undefined;
-};
-export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType | ListType | SetType | RecordType | DictionaryType | TupleType | SymbolType | ExpressionType | NumericType | NumericPrimitiveType | FunctionSignature | ValueType | TypeReference;
-/**
- * The type of a boxed expression indicates the kind of expression it is and
- * the value it represents.
- *
- * The type is represented either by a primitive type (e.g. number, complex, collection, etc.), or a compound type (e.g. tuple, function signature, etc.).
- *
- * Types are described using the following BNF grammar:
- *
- * ```bnf
- * <type> ::= <union_type> | "(" <type> ")"
- *
- * <union_type> ::= <intersection_type> (" | " <intersection_type>)*
- *
- * <intersection_type> ::= <primary_type> (" & " <primary_type>)*
- *
- * <primary_type> ::=  <primitive>
- *                | <tuple_type>
- *                | <signature>
- *                | <list_type>
- *
- * <primitive> ::= "any" | "unknown" | <value-type> | <symbolic-type> | <numeric-type>
- *
- * <numeric-type> ::= "number" | "complex" | "imaginary" | "real" | "rational" | "integer"
- *
- * <value-type> ::= "value" | <numeric-type> | "collection" | "boolean" | "string"
- *
- * <symbolic-type> ::= "expression" | "function" | "symbol"
- *
- * <tuple_type> ::= "tuple<" (<name> <type> "," <named_tuple_elements>*) ">"
- *            | "tuple<" (<type> "," <unnamed_tuple_elements>*) ">" |
- *            | "tuple<" <tuple_elements> ">"
- *
- * <tuple_elements> ::= <unnamed_tuple_elements> | <named_tuple_elements>
- *
- * <unnamed_tuple_elements> ::= <type> ("," <type>)*
- *
- * <named_tuple_elements> ::= <name> <type> ("," <name> <type>)*
- *
- * <signature> ::=  <arguments> " -> " <type>
- *
- * <arguments> ::= "()"
- *            | <argument>
- *            | "(" <argument-list> ")"
- *
- * <argument> ::= <type>
- *            | <name> <type>
- *
- * <rest_argument> ::= "..." <type>
- *            | <name> "..." <type>
- *
- * <optional_argument> ::= <argument> "?"
- *
- * <optional_arguments> ::= <optional_argument> ("," <optional_argument>)*
- *
- * <required_arguments> ::= <argument> ("," <argument>)*
- *
- * <argument-list> ::= <required_arguments> ("," <rest_argument>)?
- *            | <required_arguments> <optional_arguments>?
- *            | <optional_arguments>?
- *            | <rest_argument>
- *
- * <list_type> ::= "list<" <type> <dimensions>? ">"
- *
- * <dimensions> ::= "^" <fixed_size>
- *            | "^(" <multi_dimensional_size> ")"
- *
- * <fixed_size> ::= <positive-integer_literal>
- *
- * <multi_dimensional_size> ::= <positive-integer_literal> "x" <positive-integer_literal> ("x" <positive-integer_literal>)*
- *
- * <map> ::= "map" | "map<" <map_elements> ">"
- *
- * <map_elements> ::= <name> <type> ("," <name> <type>)*
- *
- * <set> ::= "set<" <type> ">"
- *
- * <collection ::= "collection<" <type> ">"
- *
- * <name> ::= <identifier> ":"
- *
- * <identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
- *
- * <positive-integer_literal> ::= [1-9][0-9]*
- *```
- *
- * Examples of types strings:
- * - `"number"`    -- a simple type primitive
- * - `"(number, boolean)"` -- a tuple type
- * - `"(x: number, y:boolean)"` -- a named tuple/record type. Either all arguments are named, or none are
- * - `"collection<any>"` -- an arbitrary collection type, with no length or element type restrictions
- * - `"collection<integer>"` -- a collection type where all the elements are integers
- * - `"collection<(number, boolean)>"` -- a collection of tuples
- * - `"collection<(value:number, seen:boolean)>"` -- a collection of named tuples
- * - `"[boolean]^32"` -- a collection type with a fixed size of 32 elements
- * - `"[integer]^(2x3)"` -- an integer matrix of 2 columns and 3 rows
- * - `"[integer]^(2x3x4)"` -- a tensor of dimensions 2x3x4
- * - `"number -> number"` -- a signature with a single argument
- * - `"(x: number, number) -> number"` -- a signature with a named argument
- * - `"(number, y:number?) -> number"` -- a signature with an optional named argument (can have several optional arguments, at the end)
- * - `"(number, number+) -> number"` -- a signature with a rest argument (can have only one, and no optional arguments if there is a rest argument).
- * - `"() -> number"` -- a signature with an empty argument list
- * - `"number | boolean"` -- a union type
- * - `"(x: number) & (y: number)"` -- an intersection type
- * - `"number | ((x: number) & (y: number))"` -- a union type with an intersection type
- * - `"(number -> number) | number"` -- a union type with a signature and a primitive type
- */
-export type TypeString = string;
-export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
-/** A type resolver should return a definition for a given type name.
- */
-export type TypeResolver = {
-    /** Return a list of all type names that are defined in the resolver. This is
-     * used to display error messages when a type is not found. */
-    get names(): string[];
-    forward: (name: string) => TypeReference | undefined;
-    resolve: (name: string) => TypeReference | undefined;
-};
-/**
- * ### Future considerations:
- * - Add support for generics (e.g. `list<T>`), i.e. parametric polymorphism,
- * - Add support for type constraints (e.g. `list<T: number>` or list<T> where T: number),
- * - Add support for type variants (e.g. a la Rust enums)
- *     Maybe something like
- *      `variant<Square, Circle>` or
- *      `variant<Square(side: integer), Circle(radius: integer)>`
- *      `variant<Square: {side: integer}, Circle: {radius: integer}>`
- * - Add support for dependent types, with type-level computations
- * - Add support for integers, booleans, symbols and strings, i.e. "T = "red" | "green" | "blue""
- * - Add support for conditional types (e.g. `T extends U ? X : Y`)
- *
- *
- */

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

@@ -1,36 +0,0 @@
-/* 0.30.2 */
-/** Convert two or more types into a more specific type that is a subtype of
- *  all the input types. The resulting type is usually more constrained and
- *  only encompasses values that belong to both input types.
- *
- * Examples:
- * narrow('integer', 'rational') => 'integer'
- * narrow('number', 'complex') => 'complex'
- * narrow('number', 'collection') => 'nothing'
- * narrow('number', 'value') => 'value'
- * narrow('number', 'expression') => 'expression'
- * narrow('number', 'string') => 'nothing'
- *
- *
- */
-export declare function narrow(...types: Readonly<Type>[]): Type;
-/**
- * Convert two or more types into a broader, more general type that can
- * accommodate all the input types. The resulting type is usually a supertype
- * that encompasses the possible values of the input types
- *
- * Examples:
- * widen('integer', 'rational') => 'rational'
- * widen('number', 'complex') => 'complex'
- * widen('number', 'collection') => 'collection'
- * widen('number', 'value') => 'value'
- * widen('number', 'expression') => 'expression'
- * widen('number', 'string') => 'any'
- */
-export declare function widen(...types: Readonly<Type>[]): Readonly<Type>;
-export declare function isSignatureType(type: Readonly<Type> | TypeString): type is FunctionSignature;
-export declare function functionSignature(type: Readonly<Type>): Type | undefined;
-export declare function functionResult(type: Readonly<Type> | undefined): Type | undefined;
-export declare function collectionElementType(type: Readonly<Type>): Type | undefined;
-export declare function isValidTypeName(name: string): boolean;
-export declare function isValidType(t: any): t is Readonly<Type>;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare function hidePrivateProperties(obj: any): void;

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

@@ -1,26 +0,0 @@
-/* 0.30.2 */
-/**
- * Add an assumption, in the form of a predicate, for example:
- *
- * - `x = 5`
- * - `x ∈ ℕ`
- * - `x > 3`
- * - `x + y = 5`
- *
- * Assumptions that represent a value definition (equality to an expression,
- * membership to a type, >0, <=0, etc...) are stored directly in the current
- * scope's symbols dictionary, and an entry for the symbol is created if
- * necessary.
- *
- * Predicates that involve multiple symbols are simplified (for example
- * `x + y = 5` becomes `x + y - 5 = 0`), then stored in the `assumptions`
- * record of the current context.
- *
- * New assumptions can 'refine' previous assumptions, if they don't contradict
- * previous assumptions.
- *
- * To set new assumptions that contradict previous ones, you must first
- * `forget` about any symbols in the new assumption.
- *
- */
-export declare function assume(proposition: BoxedExpression): AssumeResult;

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

@@ -1,165 +0,0 @@
-/* 0.30.2 */
-import type { Expression, MathJsonSymbol } from '../../math-json/types';
-import type { Type, TypeString } from '../../common/type/types';
-import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedSubstitution, Metadata, Substitution, CanonicalOptions, BoxedRuleSet, Rule, BoxedBaseDefinition, BoxedValueDefinition, BoxedOperatorDefinition, EvaluateOptions, Sign, BoxedExpression, JsonSerializationOptions, PatternMatchOptions, SimplifyOptions, ComputeEngine, Scope, Tensor } from '../global-types';
-import type { NumericValue } from '../numeric-value/types';
-import type { SmallInteger } from '../numerics/types';
-import type { LatexString, SerializeLatexOptions } from '../latex-syntax/types';
-/**
- * _BoxedExpression
- *
- * @internal
- */
-export declare abstract class _BoxedExpression implements BoxedExpression {
-    abstract readonly hash: number;
-    abstract readonly json: Expression;
-    abstract isCanonical: boolean;
-    abstract match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    readonly engine: ComputeEngine;
-    /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
-     *  not generated synthetically
-     */
-    readonly verbatimLatex?: string;
-    constructor(ce: ComputeEngine, metadata?: Metadata);
-    /**
-     *
-     * `Object.valueOf()`: return a JavaScript primitive value for the expression
-     *
-     * Primitive values are: boolean, number, bigint, string, null, undefined
-     *
-     */
-    valueOf(): number | number[] | number[][] | number[][][] | string | boolean;
-    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
-    /** Object.toString() */
-    toString(): string;
-    toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
-    get latex(): LatexString;
-    /** Called by `JSON.stringify()` when serializing to json.
-     *
-     * Note: this is a standard method of JavaScript objects.
-     *
-     */
-    toJSON(): Expression;
-    toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): Expression;
-    print(): void;
-    get isStructural(): boolean;
-    get canonical(): BoxedExpression;
-    get structural(): BoxedExpression;
-    get isValid(): boolean;
-    get isPure(): boolean;
-    get isConstant(): boolean;
-    get isNumberLiteral(): boolean;
-    get numericValue(): number | NumericValue | null;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    get isEven(): boolean | undefined;
-    get isOdd(): boolean | undefined;
-    get re(): number;
-    get im(): number;
-    get bignumRe(): Decimal | undefined;
-    get bignumIm(): Decimal | undefined;
-    get sgn(): Sign | undefined;
-    get isPositive(): boolean | undefined;
-    get isNonNegative(): boolean | undefined;
-    get isNegative(): boolean | undefined;
-    get isNonPositive(): boolean | undefined;
-    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;
-    ln(base?: number | BoxedExpression): BoxedExpression;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
-    is(other: BoxedExpression | number | bigint | boolean | string): boolean;
-    isSame(other: BoxedExpression): boolean;
-    isEqual(other: number | BoxedExpression): boolean | undefined;
-    isLess(other: number | BoxedExpression): boolean | undefined;
-    isLessEqual(other: number | BoxedExpression): boolean | undefined;
-    isGreater(other: number | BoxedExpression): boolean | undefined;
-    isGreaterEqual(other: number | BoxedExpression): boolean | undefined;
-    get symbol(): string | null;
-    get tensor(): null | Tensor<any>;
-    get string(): string | null;
-    getSubexpressions(operator: MathJsonSymbol): ReadonlyArray<BoxedExpression>;
-    get subexpressions(): ReadonlyArray<BoxedExpression>;
-    get symbols(): ReadonlyArray<string>;
-    get unknowns(): ReadonlyArray<string>;
-    get errors(): ReadonlyArray<BoxedExpression>;
-    get isFunctionExpression(): boolean;
-    get ops(): null | ReadonlyArray<BoxedExpression>;
-    get isScoped(): boolean;
-    get localScope(): Scope | undefined;
-    abstract readonly operator: string;
-    get nops(): SmallInteger;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
-    get isNaN(): boolean | undefined;
-    get isInfinity(): boolean | undefined;
-    get isFinite(): boolean | undefined;
-    get shape(): number[];
-    get rank(): number;
-    subs(_sub: Substitution, options?: {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    map(fn: (x: BoxedExpression) => BoxedExpression, options?: {
-        canonical: CanonicalOptions;
-        recursive?: boolean;
-    }): BoxedExpression;
-    solve(_vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
-    replace(_rules: BoxedRuleSet | Rule | Rule[]): null | BoxedExpression;
-    has(_v: string | string[]): boolean;
-    get description(): string[] | undefined;
-    get url(): string | undefined;
-    get wikidata(): string | undefined;
-    get complexity(): number | undefined;
-    get baseDefinition(): BoxedBaseDefinition | undefined;
-    get valueDefinition(): BoxedValueDefinition | undefined;
-    get operatorDefinition(): BoxedOperatorDefinition | undefined;
-    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
-    bind(): void;
-    reset(): void;
-    get value(): BoxedExpression | undefined;
-    set value(_value: any);
-    get type(): BoxedType;
-    set type(_type: Type | TypeString | BoxedType);
-    get isNumber(): boolean | undefined;
-    get isInteger(): boolean | undefined;
-    get isRational(): boolean | undefined;
-    get isReal(): boolean | undefined;
-    simplify(_options?: Partial<SimplifyOptions>): BoxedExpression;
-    expand(): BoxedExpression;
-    evaluate(_options?: Partial<EvaluateOptions>): BoxedExpression;
-    evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
-    N(): BoxedExpression;
-    compile(options?: {
-        to?: 'javascript';
-        functions?: Record<MathJsonSymbol, string | ((...any: any[]) => any)>;
-        vars?: Record<MathJsonSymbol, string>;
-        imports?: ((...any: any[]) => any)[];
-        preamble?: string;
-        fallback?: boolean;
-    }): ((...args: any[]) => any) & {
-        isCompiled?: boolean;
-    };
-    get isCollection(): boolean;
-    get isIndexedCollection(): boolean;
-    get isLazyCollection(): boolean;
-    xcontains(_rhs: BoxedExpression): boolean | undefined;
-    subsetOf(_target: BoxedExpression, _strict: boolean): boolean | undefined;
-    get xsize(): number | undefined;
-    get isEmptyCollection(): boolean | undefined;
-    get isFiniteCollection(): boolean | undefined;
-    each(): Generator<BoxedExpression>;
-    at(_index: number): BoxedExpression | undefined;
-    get(_key: string | BoxedExpression): BoxedExpression | undefined;
-    indexWhere(_predicate: (element: BoxedExpression) => boolean): number | undefined;
-}
-export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonSymbol): ReadonlyArray<BoxedExpression>;

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

@@ -1,5 +0,0 @@
-/* 0.30.2 */
-import { Decimal } from 'decimal.js';
-import type { BoxedExpression } from '../global-types';
-export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;
-export declare function apply2(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): BoxedExpression | undefined;

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

@@ -1,16 +0,0 @@
-/* 0.30.2 */
-import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedExpression, ComputeEngine } from '../global-types';
-/**
- *
- * The canonical form of `Add`:
- * - canonicalize the arguments
- * - remove `0`
- * - capture complex numbers (`a + ib` or `ai + b`)
- * - sort the terms
- *
- */
-export declare function canonicalAdd(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addType(args: ReadonlyArray<BoxedExpression>): Type | BoxedType;
-export declare function add(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;

package/dist/types/compute-engine/boxed-expression/arithmetic-mul-div.d.ts

@@ -1,27 +0,0 @@
-/* 0.30.2 */
-/**
- * Canonical form of 'Divide' (and 'Rational')
- * - remove denominator of 1
- * - simplify the signs
- * - factor out negate (make the numerator and denominator positive)
- * - if numerator and denominator are integer literals, return a rational number
- *   or Rational expression
- * - evaluate number literals
- */
-export declare function canonicalDivide(op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
-export declare function div(num: BoxedExpression, denom: number | BoxedExpression): BoxedExpression;
-/**
- * The canonical form of `Multiply`:
- * - removes `1` and `-1`
- * - simplifies the signs:
- *    - i.e. `-y \times -x` -> `x \times y`
- *    - `2 \times -x` -> `-2 \times x`
- * - arguments are sorted
- * - complex numbers promoted (['Multiply', 2, 'ImaginaryUnit'] -> 2i)
- * - Numeric values are promoted (['Multiply', 2, 'Sqrt', 3] -> 2√3)
- *
- * The input ops may not be canonical, the result is canonical.
- */
-export declare function canonicalMultiply(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function mul(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function mulN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -1,38 +0,0 @@
-/* 0.30.2 */
-import type { Rational } from '../numerics/types';
-export declare function asRadical(expr: BoxedExpression): Rational | null;
-/**
- *
- * Produce the canonical form of the operands of a Power expression, returning either the operation
- * result (e.g. 'a^1 -> a'), an alternate expr. representation ('a^{1/2} -> Sqrt(a)'), or an
- * unchanged 'Power' expression. Operations include:
- *
- * - @todo
- *
- * Both the given base and exponent can either be canonical or non-canonical: with fully
- * canonicalized args. lending to more simplifications.
- *
- * Returns a canonical expr. is both operands are canonical.
- 
- * @export
- * @param a
- * @param b
- * @returns
- */
-export declare function canonicalPower(a: BoxedExpression, b: BoxedExpression): BoxedExpression;
-export declare function canonicalRoot(a: BoxedExpression, b: BoxedExpression | number): BoxedExpression;
-/**
- * The power function.
- *
- * It follows the same conventions as SymPy, which do not always
- * conform to IEEE 754 floating point arithmetic.
- *
- * See https://docs.sympy.org/latest/modules/core.html#sympy.core.power.Pow
- *
- */
-export declare function pow(x: BoxedExpression, exp: number | BoxedExpression, { numericApproximation }: {
-    numericApproximation: boolean;
-}): BoxedExpression;
-export declare function root(a: BoxedExpression, b: BoxedExpression, { numericApproximation }: {
-    numericApproximation: boolean;
-}): BoxedExpression;

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

@@ -1,11 +0,0 @@
-/* 0.30.2 */
-export type AsciiMathSerializer = (expr: BoxedExpression, precedence?: number) => string;
-export type AsciiMathOptions = {
-    symbols: Record<string, string>;
-    operators: Record<string, [
-        string | ((expr: BoxedExpression) => string),
-        number
-    ]>;
-    functions: Record<string, string | ((expr: BoxedExpression, serialize: AsciiMathSerializer) => string)>;
-};
-export declare function toAsciiMath(expr: BoxedExpression, options?: Partial<AsciiMathOptions>, precedence?: number): string;