@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -1,12 +1,16 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { Decimal } from 'decimal.js';
-import { MathJsonIdentifier, MathJsonNumber } from '../math-json/math-json-format';
+import { Expression, MathJsonIdentifier, MathJsonNumber } from '../math-json/types';
 import type { LibraryCategory, LatexDictionaryEntry, LatexString, ParseLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, RuntimeScope, Scope, SymbolDefinition, BoxedRuleSet, Rule, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, BoxedSubstitution, AssignValue, DomainLiteral, ArrayValue, AngularUnit, CanonicalOptions } from './public';
+import { AssumeResult, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, RuntimeScope, Scope, SymbolDefinition, BoxedRuleSet, Rule, ComputeEngineStats, Metadata, FunctionDefinition, BoxedSubstitution, AssignValue, AngularUnit, CanonicalOptions } from './public';
 import { Rational } from './numerics/rationals';
-import { IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
-import { BoxedExpression, SemiBoxedExpression } from './boxed-expression/public';
+import { type IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
+import { BoxedExpression, BoxedRule, EvaluateOptions, SemiBoxedExpression } from './boxed-expression/public';
 import './boxed-expression/serialize';
+import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/public';
+import { Type, TypeString } from '../common/type/types';
+import { OneOf } from '../common/one-of';
+import { BigNum } from './numerics/bignum';
 /**
  *
  * To use the Compute Engine, create a `ComputeEngine` instance:
@@ -40,11 +44,6 @@ import './boxed-expression/serialize';
  *
  */
 export declare class ComputeEngine implements IComputeEngine {
-    readonly Anything: BoxedDomain;
-    readonly Void: BoxedDomain;
-    readonly Strings: BoxedDomain;
-    readonly Booleans: BoxedDomain;
-    readonly Numbers: BoxedDomain;
     readonly True: BoxedExpression;
     readonly False: BoxedExpression;
     readonly Pi: BoxedExpression;
@@ -54,13 +53,14 @@ export declare class ComputeEngine implements IComputeEngine {
     readonly One: BoxedExpression;
     readonly Half: BoxedExpression;
     readonly NegativeOne: BoxedExpression;
+    readonly Two: BoxedExpression;
     readonly I: BoxedExpression;
     readonly NaN: BoxedExpression;
     readonly PositiveInfinity: BoxedExpression;
     readonly NegativeInfinity: BoxedExpression;
     readonly ComplexInfinity: BoxedExpression;
     /** The symbol separating the whole part of a number from its fractional
-     *  part.
+     *  part in a LaTeX string.
      *
      * Commonly a period (`.`) in English, but a comma (`,`) in many European
      * languages. For the comma, use `"{,}"` so that the spacing is correct.
@@ -86,14 +86,13 @@ export declare class ComputeEngine implements IComputeEngine {
     _BIGNUM_NEGATIVE_ONE: Decimal;
     /** @internal */
     private _precision;
-    /** @internal */
-    private _numericMode;
     /** @ internal */
     private _angularUnit;
     /** @internal */
     private _tolerance;
     /** @internal */
     private _bignumTolerance;
+    private _negBignumTolerance;
     /** @internal */
     private _cache;
     /** @internal */
@@ -104,8 +103,6 @@ export declare class ComputeEngine implements IComputeEngine {
     private _commonSymbols;
     /** @internal */
     private _commonNumbers;
-    /** @internal */
-    private _commonDomains;
     /**
      * The current scope.
      *
@@ -118,6 +115,14 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     context: RuntimeScope | null;
+    /**
+     * Generation.
+     *
+     * The generation is incremented each time the context changes.
+     * It is used to invalidate caches.
+     * @internal
+     */
+    generation: number;
     /** In strict mode (the default) the Compute Engine performs
      * validation of domains and signature and may report errors.
      *
@@ -141,11 +146,45 @@ export declare class ComputeEngine implements IComputeEngine {
      * manipulate them.
      *
      */
-    /** @private */
+    /** @internal */
     private _latexDictionaryInput;
-    /** @private */
+    /** @internal */
     _indexedLatexDictionary: IndexedLatexDictionary;
+    /** @internal */
+    _bignum: Decimal.Constructor;
     static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
+    /**
+     * Return a LaTeX dictionary suitable for the specified category, or `"all"`
+     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
+     *
+     * A LaTeX dictionary is needed to translate between LaTeX and MathJSON.
+     *
+     * Each entry in the dictionary indicate how a LaTeX token (or string of
+     * tokens) should be parsed into a MathJSON expression.
+     *
+     * For example an entry can define that the `\pi` LaTeX token should map to the
+     * symbol `"Pi"`, or that the token `-` should map to the function
+     * `["Negate",...]` when in a prefix position and to the function
+     * `["Subtract", ...]` when in an infix position.
+     *
+     * Furthermore, the information in each dictionary entry is used to serialize
+     * the LaTeX string corresponding to a MathJSON expression.
+     *
+     * Use with `ce.latexDictionary` to set the dictionary. You can complement
+     * it with your own definitions, for example with:
+     *
+     * ```ts
+     * ce.latexDictionary = [
+     *  ...ce.getLatexDictionary("all"),
+     *  {
+     *    kind: "function",
+     *    identifierTrigger: "concat",
+     *    parse: "Concatenate"
+     *  }
+     * ];
+     * ```
+     */
+    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];
     /**
      * Construct a new `ComputeEngine` instance.
      *
@@ -160,13 +199,9 @@ export declare class ComputeEngine implements IComputeEngine {
      * as domains (`Booleans`, `Numbers`, etc...) that are used by later
      * dictionaries.
      *
-     * @param options.numericMode The default mode is `"auto"`. Use `"machine"`
-     * to perform numeric calculations using 64-bit floats. Use `"bignum"` to
-     * perform calculations using arbitrary precision floating point numbers.
-     * Use `"auto"` or `"complex"` to allow calculations on complex numbers.
      *
-     * @param options.numericPrecision Specific how many digits of precision
-     * for the numeric calculations. Default is 100.
+     * @param options.precision Specific how many digits of precision
+     * for the numeric calculations. Default is 300.
      *
      * @param options.tolerance If the absolute value of the difference of two
      * numbers is less than `tolerance`, they are considered equal. Used by
@@ -174,9 +209,8 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     constructor(options?: {
         ids?: readonly IdentifierDefinitions[];
-        numericMode?: NumericMode;
-        numericPrecision?: number;
-        tolerance?: number;
+        precision?: number | 'machine';
+        tolerance?: number | 'auto';
     });
     get latexDictionary(): Readonly<LatexDictionaryEntry[]>;
     set latexDictionary(dic: Readonly<LatexDictionaryEntry[]>);
@@ -195,8 +229,6 @@ export declare class ComputeEngine implements IComputeEngine {
     _unregister(_expr: BoxedExpression): void;
     /** @internal */
     get stats(): ComputeEngineStats;
-    /** @internal */
-    _bignum: Decimal.Constructor;
     get precision(): number;
     /** The precision, or number of significant digits, of numeric
      * calculations when the numeric mode is `"auto"` or `"bignum"`.
@@ -209,12 +241,10 @@ export declare class ComputeEngine implements IComputeEngine {
      * Trigonometric operations are accurate for precision up to 1,000.
      *
      */
-    set precision(p: number | 'machine');
-    get numericMode(): NumericMode;
-    /** {@inheritDoc  NumericMode} */
-    set numericMode(f: NumericMode);
+    set precision(p: number | 'machine' | 'auto');
     /**
      * The unit used for angles in trigonometric functions.
+     *
      * Default is `"rad"` (radians).
      */
     get angularUnit(): AngularUnit;
@@ -231,7 +261,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
      * equal to `a`.
      */
-    set tolerance(val: number);
+    set tolerance(val: number | 'auto');
     /** Replace a number that is close to 0 with the exact integer 0.
      *
      * How close to 0 the number has to be to be considered 0 is determined by {@linkcode tolerance}.
@@ -336,40 +366,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * - `sign()` (1, 0 or -1)
      */
     complex(a: number | Decimal | Complex, b?: number | Decimal): Complex;
-    isBignum(a: unknown): a is Decimal;
-    isComplex(a: unknown): a is Complex;
     /**
-     * Return a LaTeX dictionary suitable for the specified category, or `"all"`
-     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
      *
-     * A LaTeX dictionary is needed to translate between LaTeX and MathJSON.
+     * Create a Numeric Value.
      *
-     * Each entry in the dictionary indicate how a LaTeX token (or string of
-     * tokens) should be parsed into a MathJSON expression.
-     *
-     * For example an entry can define that the `\pi` LaTeX token should map to the
-     * symbol `"Pi"`, or that the token `-` should map to the function
-     * `["Negate",...]` when in a prefix position and to the function
-     * `["Subtract", ...]` when in an infix position.
-     *
-     * Furthermore, the information in each dictionary entry is used to serialize
-     * the LaTeX string corresponding to a MathJSON expression.
-     *
-     * Use with `ce.latexDictionary` to set the dictionary. You can complement
-     * it with your own definitions, for example with:
-     *
-     * ```ts
-     * ce.latexDictionary = [
-     *  ...ce.getLatexDictionary("all"),
-     *  {
-     *    kind: "function",
-     *    identifierTrigger: "concat",
-     *    parse: "Concatenate"
-     *  }
-     * ];
-     * ```
+     * @internal
      */
-    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];
+    _numericValue(value: number | bigint | Complex | OneOf<[BigNum | NumericValueData | ExactNumericValueData]>): NumericValue;
     /**
      * The cost function is used to determine the "cost" of an expression. For example, when simplifying an expression, the simplification that results in the lowest cost is chosen.
      */
@@ -382,7 +385,7 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     lookupSymbol(symbol: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
     /**
-     * Return the definition for a function matching this head.
+     * Return the definition for a function with this operator name.
      *
      * Start looking in the current context, than up the scope chain.
      *
@@ -390,7 +393,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * of the argument or the codomain. However, it is useful during parsing
      * to differentiate between symbols that might represent a function application, e.g. `f` vs `x`.
      */
-    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
+    lookupFunction(name: MathJsonIdentifier, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     /**
      * Associate a new definition to a symbol in the current context.
      *
@@ -404,7 +407,7 @@ export declare class ComputeEngine implements IComputeEngine {
     defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     _defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     /**
-     * Associate a new delookupSymbolfinition to a function in the current context.
+     * Associate a new FunctionDefinition to a function in the current context.
      *
      * If a definition existed previously, it is replaced.
      *
@@ -418,43 +421,45 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * Create a new scope and add it to the top of the scope stack
      *
-     * The `scope` argument can be used to specify custom precision,
-     * etc... for this scope
-     *
-     *
      */
-    pushScope(scope?: Partial<Scope>): ComputeEngine;
+    pushScope(scope?: Partial<Scope>): IComputeEngine;
     /** Remove the most recent scope from the scope stack, and set its
-     *  parent scope as current. */
-    popScope(): ComputeEngine;
+     *  parent scope as the current scope. */
+    popScope(): IComputeEngine;
     /** Set the current scope, return the previous scope. */
     swapScope(scope: RuntimeScope | null): RuntimeScope | null;
-    /**
-     * Reset the value of any identifiers that have been assigned a value
-     * in the current scope.
-     * @internal */
-    resetContext(): void;
     /** @internal */
     _printScope(options?: {
         details?: boolean;
         maxDepth?: number;
     }, scope?: RuntimeScope | null, depth?: number): RuntimeScope | null;
     /**
-     * Declare an identifier: specify their domain, and other attributes,
+     * Reset the value of any identifiers that have been assigned a value
+     * in the current scope.
+     * @internal */
+    resetContext(): void;
+    /**
+     * Declare an identifier: specify their type and other attributes,
      * including optionally a value.
      *
-     * Once the domain of an identifier has been declared, it cannot be changed.
-     * The domain information is used to calculate the canonical form of
-     * expressions and ensure they are valid. If the domain could be changed
+     * Once the type of an identifier has been declared, it cannot be changed.
+     * The type information is used to calculate the canonical form of
+     * expressions and ensure they are valid. If the type could be changed
      * after the fact, previously valid expressions could become invalid.
      *
-     * Use the `Anyting` domain for a very generic domain.
+     * Set the type to `any` type for a very generic type, or use `unknown`
+     * if the type is not known yet. If `unknown`, the type will be inferred
+     * based on usage.
+     *
+     * An identifier can be redeclared with a different type, but only if
+     * the type of the identifier was inferred. If the domain was explicitly
+     * set, the identifier cannot be redeclared.
      *
      */
-    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): ComputeEngine;
+    declare(id: string, def: TypeString | OneOf<[Type, SymbolDefinition, FunctionDefinition]>): IComputeEngine;
     declare(identifiers: {
-        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
-    }): ComputeEngine;
+        [id: string]: Type | TypeString | OneOf<[SymbolDefinition, FunctionDefinition]>;
+    }): IComputeEngine;
     /** Assign a value to an identifier in the current scope.
      * Use `undefined` to reset the identifier to no value.
      *
@@ -464,16 +469,17 @@ export declare class ComputeEngine implements IComputeEngine {
      * The identifier can take the form "f(x, y") to create a function
      * with two parameters, "x" and "y".
      *
-     * If the id was not previously declared, an automatic declaration
-     * is done. The domain of the identifier is inferred from the value.
-     * To more precisely define the domain of the identifier, use `ce.declare()`
-     * instead, which allows you to specify the domain, value and other
+     * If the id was not previously declared, assigning a value will declare it.
+     * Its type is inferred from the value.
+     *
+     * To more precisely define the type of the identifier, use `ce.declare()`
+     * instead, which allows you to specify the type, value and other
      * attributes of the identifier.
      */
-    assign(id: string, value: AssignValue): ComputeEngine;
+    assign(id: string, value: AssignValue): IComputeEngine;
     assign(ids: {
         [id: string]: AssignValue;
-    }): ComputeEngine;
+    }): IComputeEngine;
     /**
      * Same as assign(), but for internal use:
      * - skips validity checks
@@ -482,8 +488,9 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * @internal
      */
-    _assign(id: string, value: AssignValue): ComputeEngine;
-    get assumptions(): ExpressionMapInterface<boolean>;
+    _assign(id: string, value: BoxedExpression | ((ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => BoxedExpression | undefined)): void;
     /**
      * Return false if the execution should stop.
      *
@@ -497,16 +504,18 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     checkContinueExecution(): void;
     /** @internal */
-    cache<T>(cacheName: string, build: () => T, purge?: (T: any) => T | undefined): T;
+    cache<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     /** Return a boxed expression from a number, string or semiboxed expression.
      * Calls `ce.function()`, `ce.number()` or `ce.symbol()` as appropriate.
      */
-    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
+    box(expr: NumericValue | SemiBoxedExpression, options?: {
         canonical?: CanonicalOptions;
+        structural?: boolean;
     }): BoxedExpression;
-    function(head: string, ops: SemiBoxedExpression[], options?: {
+    function(name: string, ops: ReadonlyArray<BoxedExpression> | ReadonlyArray<Expression>, options?: {
         metadata?: Metadata;
-        canonical?: CanonicalOptions;
+        canonical: CanonicalOptions;
+        structural: boolean;
     }): BoxedExpression;
     /**
      *
@@ -514,94 +523,51 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * The result is canonical.
      */
-    error(message: MathJsonIdentifier | [MathJsonIdentifier, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
-    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
+    error(message: string | string[], where?: string): BoxedExpression;
+    typeError(expected: Type, actual: undefined | Type, where?: string): BoxedExpression;
     /**
      * Add a`["Hold"]` wrapper to `expr.
      */
-    hold(expr: SemiBoxedExpression): BoxedExpression;
-    /**
-     * Shortcut for `this.box(["Add", ...]).evaluate()`.
-     *
-     */
-    add(...ops: BoxedExpression[]): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Negate", expr]).evaluate()`
-     *
-     */
-    neg(expr: BoxedExpression): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Multiply", ...]).evaluate()`
-     *
-     */
-    mul(...ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Divide", num, denom]).evaluate()`
-     *
-     * The result is canonical.
-     */
-    div(num: BoxedExpression, denom: BoxedExpression): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Sqrt", base]).evaluate()`
-     *
-     */
-    sqrt(base: BoxedExpression): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Power", base, exponent]).evaluate()`
-     *
-     */
-    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Divide", 1, expr]).evaluate()`
-     *
-     */
-    inv(expr: BoxedExpression): BoxedExpression;
-    /** Shortcut for `this.box(["Pair", ...])`
-     *
-     * The result is canonical.
-     */
-    pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    hold(expr: BoxedExpression): BoxedExpression;
     /** Shortcut for `this.box(["Tuple", ...])`
      *
      * The result is canonical.
      */
-    tuple(elements: number[], metadata?: Metadata): BoxedExpression;
-    tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
+    tuple(...elements: ReadonlyArray<number>): BoxedExpression;
+    tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
     /** Return a boxed symbol */
     symbol(name: string, options?: {
         metadata?: Metadata;
         canonical?: CanonicalOptions;
     }): BoxedExpression;
-    /** Return a canonical boxed domain.
-     *
-     * If the domain is invalid, may return an `["Error"]` expression
-     *
-     */
-    domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
     /**
      * This function tries to avoid creating a boxed number if `num` corresponds
      * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
      */
-    number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
-        metadata?: Metadata;
-        canonical?: CanonicalOptions;
+    number(value: number | bigint | string | NumericValue | MathJsonNumber | Decimal | Complex | Rational, options?: {
+        metadata: Metadata;
+        canonical: CanonicalOptions;
     }): BoxedExpression;
-    rules(rules: Rule[]): BoxedRuleSet;
+    rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
+        canonical?: boolean;
+    }): BoxedRuleSet;
     getRuleSet(id?: string): BoxedRuleSet | undefined;
     /**
      * Return a function expression, but the caller is responsible for making
      * sure that the arguments are canonical.
      *
+     * Unlike ce.function(), the operator of the  result is the name argument.
+     * Calling this function directly is potentially unsafe, as it bypasses
+     * the canonicalization of the arguments.
+     *
+     * For example:
+     *
+     * - `ce._fn('Multiply', [1, 'x'])` returns `['Multiply', 1, 'x']` as a canonical expression, even though it doesn't follow the canonical form
+     * - `ce.function('Multiply', [1, 'x']` returns `'x'` which is the correct canonical form
+     *
      * @internal */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], options?: Metadata & {
+    _fn(name: MathJsonIdentifier, ops: ReadonlyArray<BoxedExpression>, options?: Metadata & {
         canonical?: boolean;
     }): BoxedExpression;
     /**
@@ -616,6 +582,7 @@ export declare class ComputeEngine implements IComputeEngine {
     parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
+    get assumptions(): ExpressionMapInterface<boolean>;
     /**
      * Return a list of all the assumptions that match a pattern.
      *
@@ -625,12 +592,12 @@ export declare class ComputeEngine implements IComputeEngine {
      *  //  -> [{'val': 0}]
      * ```
      */
-    ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
+    ask(pattern: BoxedExpression): BoxedSubstitution[];
     /**
      * Answer a query based on the current assumptions.
      *
      */
-    verify(_query: SemiBoxedExpression): boolean;
+    verify(_query: BoxedExpression): boolean;
     /**
      * Add an assumption.
      *
@@ -644,7 +611,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      *
      */
-    assume(predicate: SemiBoxedExpression): AssumeResult;
+    assume(predicate: BoxedExpression): AssumeResult;
     /** Remove all assumptions about one or more symbols */
     forget(symbol: undefined | string | string[]): void;
 }

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,3 +1,13 @@
-/* 0.25.1 */
+/* 0.26.2 */
+/**
+ * The default cost function, used to determine if a new expression is simpler
+ * than the old one.
+ *
+ * To change the cost function used by the engine, set the
+ * `ce.costFunction` property of the engine or pass a custom cost function
+ * to the `simplify` function.
+ *
+ */
 export declare function costFunction(expr: BoxedExpression): number;
+export declare function leafCount(expr: BoxedExpression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 /***
  * ### THEORY OF OPERATIONS
  *
@@ -18,7 +18,7 @@
  * #### DURING BOXING (in makeLambda())
  *
  * During the boxing/canonicalization phase of a function
- * (`["Function"]` expression or head expression):
+ * (`["Function"]` expression or operator of expression):
  *
  * 1/ If not a `["Function"]` expression, the expression is rewritten
  *    to a `["Function"]` expression with anonymous parameters
@@ -50,7 +50,6 @@ export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: B
 /**
  * Given an expression, rewrite it to a canonical Function form.
  *
- *
  * - explicit parameters (no change)
  *      ["Function", ["Add, "x", 1], "x"]
  *      -> ["Function", ["Add, "x", 1], "x"]
@@ -63,8 +62,9 @@ export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: B
  *      ["Add", "_1", "_2"]
  *      -> ["Function", ["Add", "_1", "_2"], "_1", "_2"]
  *
+ *
  */
-export declare function canonicalFunctionExpression(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function canonicalFunctionExpression(body: BoxedExpression, args?: BoxedExpression[]): [body: BoxedExpression, ...params: string[]];
 /**
  * Apply arguments to an expression which is either
  * - a '["Function"]' expression
@@ -87,7 +87,7 @@ export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => n
  *
  * return a JS function that can be called with arguments.
  */
-export declare function applicable(fn: BoxedExpression): (args: BoxedExpression[]) => BoxedExpression | undefined;
+export declare function applicable(fn: BoxedExpression): (xs: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
 /**
  * Use applicableN when the function is known to be a function of a single
  * variable and the argument is a number.

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-relational-operators.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,3 +1,3 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;