@cortex-js/compute-engine 0.25.0 → 0.26.0

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

@@ -0,0 +1,249 @@
+/* 0.26.0 */
+ * 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 expression
+ *      such as `["Function", ["Add", "x", 1], "x"]`.
+ *
+ * - `value`
+ *    - `scalar`
+ *      - <number>
+ *      - `boolean`: a boolean value: `True` or `False`.
+ *      - `string`: a string of characters.
+ *    - `collection`
+ *       - `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
+ *       - `set`: a collection of unique expressions, e.g. `set<string>`.
+ *       - `tuple`: a fixed-size collection of named or unnamed elements, e.g.
+ *          `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
+ *       - `map`: a set key-value pairs, e.g. `map<x: number, y: boolean>`.
+ *
+ * - `number`: any numeric value:
+ *    - `finite_number`: <finite_complex> or <finite_imaginary> or
+ *       <finite_real> or <finite_rational> or <finite_integer>
+ *    - `non_finite_number`: `NaN`, `PositiveInfinity`, `NegativeInfinity` or
+ *      `ComplexInfinity`
+ *    - `complex` and `finite_complex`: a complex number, with non-zero real
+ *       and imaginary parts.
+ *    - `imaginary` and `finite_imaginary`: a complex number with a real part
+ *       of 0 (pure imaginary).
+ *    - `real` and `finite_real`: a complex number with an imaginary part of 0.
+ *    - `rational` and `finite_rational`: a pure rational number
+ *       (not an integer)
+ *    - `integer` and `finite_integer`: a whole number
+ *
+ *
+ */
+export type PrimitiveType = NumericType | 'collection' | 'list' | 'set' | 'map' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
+export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'finite_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[];
+    restArg?: NamedElement;
+    result: Type;
+};
+export type AlgebraicType = {
+    kind: 'union' | 'intersection';
+    types: Type[];
+};
+export type NegationType = {
+    kind: 'negation';
+    type: Type;
+};
+export type ValueType = {
+    kind: 'value';
+    value: any;
+};
+/** Map is not a collection. It is a set of key/value pairs.
+ * An element of a map whose type is a subtype of `nothing` is optional.
+ * For example, in `{x: number, y: boolean | nothing}` the element `y` is optional.
+ */
+export type MapType = {
+    kind: 'map';
+    elements: Record<string, Type>;
+};
+/** Collection, List, Set, Tuple and Map are collections.
+ *
+ * `CollectionType` is a generic collection of elements of a certain type.
+ */
+export type CollectionType = {
+    kind: 'collection';
+    elements: Type;
+};
+/**
+ * The elements of a list are ordered.
+ *
+ * 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[];
+};
+/** Each element of a set is unique (is not present in the set more than once).
+ * The elements of a set are not ordered.
+ */
+export type SetType = {
+    kind: 'set';
+    elements: Type;
+};
+export type TupleType = {
+    kind: 'tuple';
+    elements: NamedElement[];
+};
+/** Nominal typing */
+export type TypeReference = {
+    kind: 'reference';
+    ref: string;
+};
+export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType | ListType | SetType | MapType | TupleType | 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>
+
+<union_type> ::= <intersection_type> (" | " <intersection_type>)*
+
+<intersection_type> ::= <primary_type> (" & " <primary_type>)*
+
+<primary_type> ::=  <primitive>
+                | <tuple_type>
+                | <function_type>
+                | <list_type>
+                | <wrapped_primary_type>
+
+<wrapped_primary_type> ::= "(" <primary_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> ::= "(" (<name> <type> "," <named_tuple_elements>*) ")"
+            | "(" (<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>)*
+
+<function_type> ::=  <arguments> " -> " <type>
+
+<arguments> ::= "()"
+            | <argument>
+            | "(" <argument-list> ")"
+            | <deferred_evaluation>
+
+<deferred_evaluation> ::= "???" <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> ::= "[" <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_elements> "}"
+            | "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:
+   "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
+
+   "[any]" -- an arbitrary collection type, with no length or element type restrictions
+   "[integer]" -- a collection type where all the elements are integers
+   "[(number, boolean)]" -- a collection of tuples
+   "[(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 function type with a single argument
+   "(x: number, number) -> number" -- a function type with a named argument
+   "(number, y:number?) -> number" -- a function type with an optional named argument (can have several optional arguments, at the end)
+   "(number, ...number) -> number" -- a function type with a rest argument (can have only one, and no optional arguments if there is a rest argument).
+   "() -> number" -- a function type 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 function type
+*/
+export type TypeString = string;
+export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
+export type TypeResolver = (name: string) => Type | undefined;

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

@@ -0,0 +1,39 @@
+/* 0.26.0 */
+/** 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>[]): 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>): Type | undefined;
+export declare function collectionElementType(type: Readonly<Type>): Type | undefined;
+export declare function isValidType(t: any): t is Readonly<Type>;
+/**
+ * Add a `toString()` method to the type object
+ */
+export declare function makeType(type: Type): Readonly<Type>;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.25.0 */
+/* 0.26.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -7,20 +7,20 @@
  * - `x > 3`
  * - `x + y = 5`
  *
- * Some assumptions are handled separately, specifically, those that can
- * be represented as a symbol definition (equality to an expression,
- * membership to Integers, RealNumbers, etc..., >0, <=0, etc...). The result
- * of these are stored directly in the current scope's symbols dictionary
- * (and an entry for the symbol is created if necessary).
- *
- * New assumptions can 'refine' previous assumptions, that is they are valid
- * 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.
+ * Assumptions that represent a symbol 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` of the
- * current context).
+ * `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,28 +1,35 @@
-/* 0.25.0 */
-import { Decimal } from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { LatexString } from '../public';
-import { Rational } from '../numerics/rationals';
-import { BoxedBaseDefinition, BoxedDomain, BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, BoxedSymbolDefinition, CanonicalOptions, DomainCompatibility, DomainLiteral, EvaluateOptions, IComputeEngine, JsonSerializationOptions, Metadata, NOptions, PatternMatchOptions, Rule, RuntimeScope, SemiBoxedExpression, SimplifyOptions, Substitution } from './public';
-import { SerializeLatexOptions } from '../latex-syntax/public';
+/* 0.26.0 */
+import { Expression, MathJsonIdentifier } from '../../math-json/types';
+import type { BoxedBaseDefinition, BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, BoxedSymbolDefinition, CanonicalOptions, EvaluateOptions, IComputeEngine, JsonSerializationOptions, Metadata, PatternMatchOptions, Rule, RuntimeScope, Sign, SimplifyOptions, Substitution } from './public';
+import type { LatexString } from '../public';
+import type { NumericValue } from '../numeric-value/public';
+import type { SmallInteger } from '../numerics/numeric';
+import type { SerializeLatexOptions } from '../latex-syntax/public';
+import { AsciiMathOptions } from './ascii-math';
 /**
  * _BoxedExpression
  */
 export declare abstract class _BoxedExpression implements BoxedExpression {
     abstract readonly hash: number;
     abstract readonly json: Expression;
-    abstract readonly head: BoxedExpression | string;
+    abstract readonly operator: string;
+    /** @deprecated */
+    get head(): string;
     abstract get isCanonical(): boolean;
     abstract set isCanonical(_val: boolean);
-    abstract isSame(rhs: BoxedExpression): boolean;
-    abstract isEqual(rhs: BoxedExpression): boolean;
-    abstract match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    abstract match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     readonly engine: IComputeEngine;
     /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
      *  not generated synthetically
      */
     verbatimLatex?: string;
     constructor(ce: IComputeEngine, metadata?: Metadata);
+    isSame(rhs: BoxedExpression): boolean;
+    isEqual(rhs: number | BoxedExpression): boolean | undefined;
+    isLess(_rhs: number | BoxedExpression): boolean | undefined;
+    isLessEqual(_rhs: number | BoxedExpression): boolean | undefined;
+    isGreater(_rhs: number | BoxedExpression): boolean | undefined;
+    isGreaterEqual(_rhs: number | BoxedExpression): boolean | undefined;
     /**
      *
      * `Object.valueOf()`: return a JavaScript primitive value for the expression
@@ -30,7 +37,8 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
      * Primitive values are: boolean, number, bigint, string, null, undefined
      *
      */
-    valueOf(): number | Object | string | boolean;
+    valueOf(): number | object | string | boolean;
+    toAsciiMath(options?: Partial<AsciiMathOptions>): string;
     /** Object.toString() */
     toString(): string;
     print(): void;
@@ -43,43 +51,62 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     toJSON(): Expression;
     toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): Expression;
     toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
+    toNumericValue(): [NumericValue, BoxedExpression];
     get scope(): RuntimeScope | null;
-    /** Object.is() */
     is(rhs: any): boolean;
     get canonical(): BoxedExpression;
+    get structural(): BoxedExpression;
+    get isStructural(): boolean;
     get latex(): LatexString;
     set latex(val: LatexString);
     get symbol(): string | null;
+    get tensor(): null | AbstractTensor<'expression'>;
     get string(): string | null;
-    getSubexpressions(head: string): ReadonlyArray<BoxedExpression>;
+    getSubexpressions(operator: MathJsonIdentifier): ReadonlyArray<BoxedExpression>;
     get subexpressions(): ReadonlyArray<BoxedExpression>;
     get symbols(): ReadonlyArray<string>;
     get unknowns(): ReadonlyArray<string>;
     get freeVariables(): ReadonlyArray<string>;
     get errors(): ReadonlyArray<BoxedExpression>;
     get ops(): null | ReadonlyArray<BoxedExpression>;
-    get nops(): number;
+    get nops(): SmallInteger;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
     get isValid(): boolean;
     get isPure(): boolean;
-    get isExact(): boolean;
-    /** For a symbol, true if the symbol is a constant (unchangeable value) */
+    /** Literals (number, string, boolean) are constants. Some symbols
+     * may also be constants (e.g. Pi, E, True, False). Expressions of constant
+     * symbols are also constants (if the function is pure).
+     */
     get isConstant(): boolean;
     get isNaN(): boolean | undefined;
-    get isZero(): boolean | undefined;
-    get isNotZero(): boolean | undefined;
-    get isOne(): boolean | undefined;
-    get isNegativeOne(): boolean | undefined;
     get isInfinity(): boolean | undefined;
     get isFinite(): boolean | undefined;
     get isEven(): boolean | undefined;
     get isOdd(): boolean | undefined;
-    get isPrime(): boolean | undefined;
-    get isComposite(): boolean | undefined;
-    get numericValue(): number | Decimal | Complex | Rational | null;
-    get sgn(): -1 | 0 | 1 | undefined | null;
+    get numericValue(): number | NumericValue | null;
+    get isNumberLiteral(): boolean;
+    get isFunctionExpression(): boolean;
+    get re(): number;
+    get im(): number;
+    get bignumRe(): Decimal | undefined;
+    get bignumIm(): Decimal | undefined;
+    get numerator(): BoxedExpression;
+    get denominator(): BoxedExpression;
+    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
+    neg(): BoxedExpression;
+    inv(): BoxedExpression;
+    abs(): BoxedExpression;
+    add(rhs: number | BoxedExpression): BoxedExpression;
+    sub(rhs: BoxedExpression): BoxedExpression;
+    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
+    div(rhs: number | BoxedExpression): BoxedExpression;
+    pow(exp: number | BoxedExpression): BoxedExpression;
+    root(exp: number | BoxedExpression): BoxedExpression;
+    sqrt(): BoxedExpression;
+    ln(base?: number | BoxedExpression): BoxedExpression;
+    get sgn(): Sign | undefined;
     get shape(): number[];
     get rank(): number;
     subs(_sub: Substitution, options?: {
@@ -87,19 +114,15 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     }): 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;
-    isLess(_rhs: BoxedExpression): boolean | undefined;
-    isLessEqual(_rhs: BoxedExpression): boolean | undefined;
-    isGreater(_rhs: BoxedExpression): boolean | undefined;
-    isGreaterEqual(_rhs: BoxedExpression): boolean | undefined;
     get isPositive(): boolean | undefined;
     get isNonNegative(): boolean | undefined;
     get isNegative(): boolean | undefined;
     get isNonPositive(): boolean | undefined;
-    isCompatible(_dom: BoxedDomain | DomainLiteral, _kind?: DomainCompatibility): boolean;
     get description(): string[] | undefined;
     get url(): string | undefined;
     get wikidata(): string | undefined;
@@ -107,31 +130,32 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    infer(_domain: BoxedDomain): boolean;
+    infer(t: Type): boolean;
     bind(): void;
     reset(): void;
-    get keys(): IterableIterator<string> | null;
-    get keysCount(): number;
-    getKey(_key: string): BoxedExpression | undefined;
-    hasKey(_key: string): boolean;
-    get value(): number | boolean | string | Object | undefined;
+    get value(): number | boolean | string | object | undefined;
     set value(_value: BoxedExpression | number | boolean | string | number[] | undefined);
-    get domain(): BoxedDomain | undefined;
-    set domain(_domain: BoxedDomain);
+    get type(): Type;
+    set type(_type: Type);
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
-    get isAlgebraic(): boolean | undefined;
     get isReal(): boolean | undefined;
-    get isExtendedReal(): boolean | undefined;
-    get isComplex(): boolean | undefined;
-    get isImaginary(): boolean | undefined;
-    get isExtendedComplex(): boolean | undefined;
-    simplify(_options?: SimplifyOptions): BoxedExpression;
-    evaluate(_options?: EvaluateOptions): BoxedExpression;
-    N(_options?: NOptions): BoxedExpression;
+    simplify(_options?: Partial<SimplifyOptions>): BoxedExpression;
+    evaluate(_options?: Partial<EvaluateOptions>): BoxedExpression;
+    N(): BoxedExpression;
     compile(to?: string, options?: {
         optimize: ('simplify' | 'evaluate')[];
     }): ((args: Record<string, any>) => any | undefined) | undefined;
+    get isCollection(): boolean;
+    contains(_rhs: BoxedExpression): boolean;
+    subsetOf(_target: BoxedExpression, _strict: boolean): boolean;
+    get size(): number;
+    each(_start?: number, _count?: number): Iterator<BoxedExpression, undefined>;
+    at(_index: number): BoxedExpression | undefined;
+    get(_key: string | BoxedExpression): BoxedExpression | undefined;
+    indexOf(_expr: BoxedExpression): number;
 }
-export declare function getSubexpressions(expr: BoxedExpression, head: string): ReadonlyArray<BoxedExpression>;
+export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonIdentifier): ReadonlyArray<BoxedExpression>;
+import { Type } from '../../common/type/types';
+import { AbstractTensor } from '../tensor/tensors';

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

@@ -0,0 +1,5 @@
+/* 0.26.0 */
+import { Decimal } from 'decimal.js';
+import type { BoxedExpression } from '../public';
+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,15 @@
+/* 0.26.0 */
+import { Type } from '../../common/type/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: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function addType(args: ReadonlyArray<BoxedExpression>): Type;
+export declare function add(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function addN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

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

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

@@ -0,0 +1,16 @@
+/* 0.26.0 */
+/**
+ * The canonical form of `Multiply`:
+ * - removes `1` anb `-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: IComputeEngine, 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,20 @@
+/* 0.26.0 */
+import type { Rational } from '../numerics/rationals';
+export declare function asRadical(expr: BoxedExpression): Rational | null;
+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.26.0 */
+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;