@cortex-js/compute-engine 0.25.1 → 0.26.0

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

@@ -1,28 +1,35 @@
-/* 0.25.1 */
-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?: {
@@ -92,15 +119,10 @@ export declare abstract class _BoxedExpression implements 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;
@@ -108,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;

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

@@ -1,87 +1,27 @@
-/* 0.25.1 */
+/* 0.26.0 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, CanonicalOptions } from './public';
-import { MathJsonNumber } from '../../math-json/math-json-format';
-import { Rational } from '../numerics/rationals';
+import { MathJsonIdentifier } from '../../math-json/types';
+import { NumericValue } from '../numeric-value/public';
 /**
- * ### THEORY OF OPERATIONS
- *
- * 1/ Boxing does not depend on the numeric mode. The numeric mode could be
- * changed later, but the previously boxed numbers could not be retroactively
- * upgraded.
- *
- * The `numericMode` is taken into account only during evaluation.
- *
- * Therefore, a boxed expression may contain a mix of number representations.
- *
- * 2/ The result of boxing is canonical by default.
- *
- * This is the most common need (i.e. as soon as you want to evaluate an
- * expression you need a canonical expression). Creating a boxed expression
- * which is canonical from the start avoid going through an intermediary step
- * with a non-canonical expression.
- *
- * 3/ When boxing (and canonicalizing), if the function is "scoped", a new
- *    scope is created before the canonicalization, so that any declaration
- *    are done within that scope. Example of scoped functions include `Block`
- *    and `Sum`.
- *
- * 4/ When implementing an `evaluate()`:
- * - if `bignumPreferred()` all operations should be done in bignum and complex,
- *    otherwise, they should all be done in machine numbers and complex.
- * - if not `complexAllowed()`, return `NaN` if a complex value is encountered
- * - if a `Sqrt` (of a rational) is encountered, preserve it
- * - if a `hold` constant is encountered, preserve it
- * - if a rational is encountered, preserve it
- * - if one of the arguments is not exact, return an approximation
- *
- * EXACT
- * - 2 + 5 -> 7
- * - 2 + 5/7 -> 19/7
- * - 2 + √2 -> 2 + √2
- * - 2 + √(5/7) -> 2 + √(5/7)
- * - 5/7 + 9/11 -> 118/77
- * - 5/7 + √2 -> 5/7 + √2
- * - 10/14 + √(18/9) -> 5/7 + √2
- * - √2 + √5 -> √2 + √5
- * - √2 + √2 -> 2√2
- * - sin(2) -> sin(2)
- * - sin(pi/3) -> √3/2
- *
- * APPROXIMATE
- * - 2 + 2.1 -> 4.1
- * - 2 + √2.1 -> 3.44914
- * - 5/7 + √2.1 -> 2.16342
- * - sin(2) + √2.1 -> 2.35844
- */
-/**
- * Return a boxed number representing `num`.
- *
- * Note: `boxNumber()` should only be called from `ce.number()` in order to
- * benefit from number expression caching.
- */
-export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | number | string | Complex | Decimal | Rational | [Decimal, Decimal], options?: {
-    metadata?: Metadata;
-    canonical?: boolean;
-}): BoxedExpression | null;
-/**
- * Given a head and a set of arguments, return a boxed function expression.
+ * Given a name and a set of arguments, return a boxed function expression.
  *
  * If available, preserve LaTeX and wikidata metadata in the boxed expression.
  *
  * Note that `boxFunction()` should only be called from `ce.function()`
  */
-export declare function boxFunction(ce: IComputeEngine, head: string, ops: readonly SemiBoxedExpression[], options?: {
+export declare function boxFunction(ce: IComputeEngine, name: MathJsonIdentifier, ops: readonly SemiBoxedExpression[], options?: {
     metadata?: Metadata;
     canonical?: CanonicalOptions;
+    structural?: boolean;
 }): BoxedExpression;
 /**
  * Notes about the boxed form:
  *
- * [1] Expression with a head of `Number`, `String`, `Symbol` and `Dictionary`
+ * [1] Expression with an operator of `Number`, `String`, `Symbol` and `Dictionary`
  *      are converted to the corresponding atomic expression.
  *
- * [2] Expressions with a head of `Complex` are converted to a (complex) number
+ * [2] Expressions with an operator of `Complex` are converted to a (complex) number
  *     or a `Add`/`Multiply` expression.
  *
  *     The precedence of `Complex` (for serialization) is sometimes the
@@ -89,8 +29,8 @@ export declare function boxFunction(ce: IComputeEngine, head: string, ops: reado
  *    `Multiply` (when im or re === 0). Using a number or an explicit
  *    `Add`/`Multiply` expression avoids this ambiguity.
  *
- * [3] An expression with a `Rational` head is converted to a rational number.
- *    if possible, to a `Divide` otherwise.
+ * [3] An expression with a `Rational` operator is converted to a rational
+ *    number if possible, to a `Divide` otherwise.
  *
  * [4] A `Negate` function applied to a number literal is converted to a number.
  *
@@ -100,6 +40,8 @@ export declare function boxFunction(ce: IComputeEngine, head: string, ops: reado
  * Note that this function should only be called from `ce.box()`
  *
  */
-export declare function box(ce: IComputeEngine, expr: null | undefined | Decimal | Complex | Rational | SemiBoxedExpression, options?: {
+export declare function box(ce: IComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
     canonical?: CanonicalOptions;
+    structural?: boolean;
 }): BoxedExpression;
+export declare function toBigint(x: Complex | Decimal | SemiBoxedExpression): bigint | null;

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

@@ -1,5 +1,7 @@
-/* 0.25.1 */
-import { BoxedExpression } from './public';
+/* 0.26.0 */
+import type { BoxedExpression, CollectionHandlers, CompiledExpression, EvaluateOptions, Sign } from './public';
+import { Type } from '../../common/type/types';
+import { OneOf } from '../../common/one-of';
 export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
     engine: IComputeEngine;
     scope: RuntimeScope;
@@ -9,21 +11,37 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     threadable: boolean;
     associative: boolean;
     commutative: boolean;
+    commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
     idempotent: boolean;
     involution: boolean;
     pure: boolean;
-    inert: boolean;
-    numeric: boolean;
     complexity: number;
-    hold: Hold;
-    dynamic: boolean;
-    signature: BoxedFunctionSignature;
-    iterator?: (expr: BoxedExpression, start?: number, count?: number) => Iterator<BoxedExpression>;
-    at?: (expr: BoxedExpression, index: number | string) => undefined | BoxedExpression;
-    size?: (expr: BoxedExpression) => number;
-    keys?: (expr: BoxedExpression) => undefined | Iterator<string>;
-    indexOf?: (expr: BoxedExpression, target: BoxedExpression, from?: number) => number | string | undefined;
+    hold: boolean;
+    signature: Type;
+    inferredSignature: boolean;
+    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Type | undefined;
+    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Sign | undefined;
+    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    even?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => boolean | undefined;
+    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression | null;
+    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => BoxedExpression | undefined;
+    evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression;
+    compile?: (expr: BoxedExpression) => CompiledExpression;
+    collection?: Partial<CollectionHandlers>;
     constructor(ce: IComputeEngine, name: string, def: FunctionDefinition);
     reset(): void;
 }
-export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: FunctionDefinition | BoxedFunctionDefinition): BoxedFunctionDefinition;
+export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;

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

@@ -1,47 +1,55 @@
-/* 0.25.1 */
-import { Decimal } from 'decimal.js';
+/* 0.26.0 */
+import type { BoxedFunctionDefinition, IComputeEngine, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Rule, CanonicalOptions } from '../public';
+import type { BoxedExpression, Sign } from './public';
+import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Hold, Rule, CanonicalOptions } from '../public';
-import { BoxedExpression, SemiBoxedExpression } from './public';
+import { Type } from '../../common/type/types';
 /**
  * A boxed function represent an expression that can be
  * represented by a function call.
  *
- * It is composed of a head (the name of the function) and
+ * It is composed of an operator (the name of the function) and
  * a list of arguments.
  *
- * It has a definition associated with it, based
- * on the head. The definition contains the signature of the function,
- * and the implementation of the function.
+ * It has a definition associated with it, based on the operator.
+ * The definition contains the signature of the function, and the
+ * implementation of the function.
  *
  * @noInheritDoc
  *
  */
 export declare class BoxedFunction extends _BoxedExpression {
-    private readonly _head;
+    private readonly _name;
     private readonly _ops;
     private _canonical;
     private _scope;
-    private _def;
+    _def: BoxedFunctionDefinition | undefined;
     private _isPure;
-    private _result;
+    private _isStructural;
     private _hash;
-    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: ReadonlyArray<BoxedExpression>, options?: {
+    private _value;
+    private _valueN;
+    private _sgn;
+    private _type;
+    constructor(ce: IComputeEngine, name: string, ops: ReadonlyArray<BoxedExpression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
+        structural?: boolean;
     });
     get hash(): number;
-    infer(domain: BoxedDomain): boolean;
+    infer(t: Type): boolean;
     bind(): void;
     reset(): void;
-    get isExact(): boolean;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get isPure(): boolean;
+    /** The value of the function is constant if the function is
+     * pure, and all its arguments are constant.
+     */
+    get isConstant(): boolean;
     get json(): Expression;
     get scope(): RuntimeScope | null;
-    get head(): string | BoxedExpression;
+    get operator(): string;
     get ops(): ReadonlyArray<BoxedExpression>;
     get nops(): number;
     get op1(): BoxedExpression;
@@ -49,45 +57,58 @@ export declare class BoxedFunction extends _BoxedExpression {
     get op3(): BoxedExpression;
     get isValid(): boolean;
     get canonical(): BoxedExpression;
+    get structural(): BoxedExpression;
+    get isStructural(): boolean;
+    toNumericValue(): [NumericValue, BoxedExpression];
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;
-    has(x: string | string[]): boolean;
-    /** `isSame` is structural/symbolic equality */
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    has(v: string | string[]): boolean;
+    get sgn(): Sign | undefined;
+    get isNaN(): boolean | undefined;
+    get isInfinity(): boolean | undefined;
+    get isFinite(): boolean | undefined;
+    get isOne(): boolean | undefined;
+    get isNegativeOne(): boolean | undefined;
+    get isPositive(): boolean | undefined;
+    get isNonNegative(): boolean | undefined;
+    get isNegative(): boolean | undefined;
+    get isNonPositive(): boolean | undefined;
+    get numerator(): BoxedExpression;
+    get denominator(): BoxedExpression;
+    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
+    neg(): BoxedExpression;
+    inv(): BoxedExpression;
+    abs(): BoxedExpression;
+    add(rhs: number | 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(semiBase?: number | BoxedExpression): BoxedExpression;
     get complexity(): number | undefined;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    /** `isEqual` is mathematical equality */
-    isEqual(rhs: BoxedExpression): boolean;
     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 domain(): BoxedDomain | undefined;
-    simplify(options?: SimplifyOptions): BoxedExpression;
+    get isFunctionExpression(): boolean;
+    /** The type of the value of the function */
+    get type(): Type;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    N(options?: NOptions): BoxedExpression;
+    N(): BoxedExpression;
     solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    get isCollection(): boolean;
+    contains(rhs: BoxedExpression): boolean;
+    get size(): number;
+    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
+    at(index: number): BoxedExpression | undefined;
+    get(index: BoxedExpression | string): BoxedExpression | undefined;
+    indexOf(expr: BoxedExpression): number;
+    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
 }
-export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: ReadonlyArray<SemiBoxedExpression>, metadata?: Metadata): BoxedExpression;
-/** Apply the function `f` to elements of `xs`, except to the elements
- * described by `skip`:
- * - `all`: don't apply f to any elements
- * - `none`: apply `f` to all elements
- * - `first`: apply `f` to all elements except the first
- * - `rest`: apply `f` to the first element, skip the  others
- * - 'last': apply `f` to all elements except the last
- * - 'most': apply `f` to the last elements, skip the others
- *
- * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
- *
- * If `f` returns `null`, the element is not added to the result
- */
-export declare function holdMap(xs: ReadonlyArray<BoxedExpression>, skip: Hold, associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;