@cortex-js/compute-engine 0.32.0 → 0.32.1

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

@@ -0,0 +1,300 @@
+/* 0.32.1 */
+ * 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

@@ -0,0 +1,36 @@
+/* 0.32.1 */
+/** 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

@@ -0,0 +1,23 @@
+/* 0.32.1 */
+ *
+ * <!--
+ * !@consider?
+ * - In terms of BoxedExpressions - optimizations which are always desirable to take place are
+ * possible...
+ *  ^Perhaps then, a wrapper BoxedExpr. utility for specifying these permutations via 'condition'
+ *  would be apt...?
+ *
+ * - ^If wishing to take adv. of this, the 'condition' callback would likely benefit from a second parameter typed as a collection
+ * ('Set' if enforcing unique) with all hitherto (arbitrary representations) of generated
+ * permutations.
+ *  (See commented snippets within function signature below.)
+ * -->
+ *
+ * @export
+ * @template T
+ * @param xs
+ * @param [condition]
+ * @returns
+ */
+export declare function permutations<T>(xs: ReadonlyArray<T>, condition?: (xs: ReadonlyArray<T>) => boolean): ReadonlyArray<ReadonlyArray<T>>;
+export declare function hidePrivateProperties(obj: any): void;

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

@@ -0,0 +1,26 @@
+/* 0.32.1 */
+/**
+ * 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

@@ -0,0 +1,165 @@
+/* 0.32.1 */
+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' | 'wgsl' | 'python' | 'webassembly';
+        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;
+    contains(_rhs: BoxedExpression): boolean | undefined;
+    subsetOf(_target: BoxedExpression, _strict: boolean): boolean | undefined;
+    get count(): 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

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

@@ -0,0 +1,16 @@
+/* 0.32.1 */
+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

@@ -0,0 +1,27 @@
+/* 0.32.1 */
+/**
+ * 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

@@ -0,0 +1,38 @@
+/* 0.32.1 */
+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

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