@cortex-js/compute-engine 0.23.1 → 0.24.0

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

@@ -1,20 +1,31 @@
-/* 0.23.1 */
- * The most important classes are {@link ComputeEngine} and
- * {@link BoxedExpression}.
+/* 0.24.0 */
  *
- * With `ComputeEngine` you create `BoxedExpression` objects. With
- * `BoxedExpression` you simplify, evaluate and serialize expressions.
+ * The Compute Engine is a symbolic computation engine that can be used to
+ * manipulate and evaluate mathematical expressions.
+ *
+ * Use an instance of {@linkcode ComputeEngine} to create boxed expressions
+ * with {@linkcode ComputeEngine.parse} and {@linkcode ComputeEngine.box}.
+ *
+ * Use a {@linkcode BoxedExpression} object to manipulate and evaluate
+ * mathematical expressions.
+ *
+ * @module "compute-engine"
  *
- * @module ComputeEngine
  */
 import type { Complex } from 'complex.js';
 import type { Decimal } from 'decimal.js';
 import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
 import type { LatexDictionaryEntry, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 export * from './latex-syntax/public';
+export * from './compute-engine';
+/**
+ * @category Boxed Expression
+ */
 export type Rational = [number, number] | [bigint, bigint];
 /**
  * Metadata that can be associated with a `BoxedExpression`
+ *
+ * @category Boxed Expression
  */
 export type Metadata = {
     latex?: string | undefined;
@@ -23,7 +34,7 @@ export type Metadata = {
 /**
  * The numeric evaluation mode:
  *
-<div class=symbols-table>
+<div className="symbols-table">
 
 | Mode | |
 | :--- | :----- |
@@ -33,29 +44,41 @@ export type Metadata = {
 | `"complex"` | Complex number represented by two machine numbers, a real and an imaginary part, as provided by the "complex.js" library |
 
 </div>
+
+ * @category Compute Engine
  */
 export type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
+/** @category Compute Engine */
 export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
-/** Options for `BoxedExpression.simplify()` */
+/** Options for `BoxedExpression.simplify()`
+ *
+ * @category Compute Engine
+ */
 export type SimplifyOptions = {
     recursive?: boolean;
     rules?: BoxedRuleSet;
 };
 /** Options for `BoxedExpression.evaluate()`
  *
+ * @category Boxed Expression
  */
 export type EvaluateOptions = {
     numericMode?: boolean;
 };
 /** Options for `BoxedExpression.N()`
- * @internal
+ *
+ * @category Boxed Expression
  */
 export type NOptions = {};
+/**
+ * @category Boxed Expression
+ *
+ */
 export type ReplaceOptions = {
     /** If `true`, apply replacement rules to all sub-expressions.
      * If `false`, only consider the top-level expression.
      *
-     * **Default**: `true`
+     * **Default**: `false`
      */
     recursive?: boolean;
     /**
@@ -63,7 +86,7 @@ export type ReplaceOptions = {
      *
      * If `false`, apply all the remaining rules even after the first match.
      *
-     * **Default**: `true`
+     * **Default**: `false`
      */
     once?: boolean;
     /**
@@ -82,16 +105,26 @@ export type ReplaceOptions = {
  *
  * A substitution can also be considered a more constrained version of a
  * rule whose `lhs` is always a symbol.
+
+* @category Boxed Expression
  */
 export type Substitution<T = SemiBoxedExpression> = {
     [symbol: string]: T;
 };
+/**
+ * @category Boxed Expression
+ *
+ */
 export type BoxedSubstitution = Substitution<BoxedExpression>;
 /** A LaTeX string starts and end with `$`, for example
  * `"$\frac{\pi}{2}$"`.
+ *
+ * @category Latex Parsing and Serialization
  */
 export type LatexString = string;
+/** @category Rules */
 export type PatternReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression;
+/** @category Rules */
 export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: IComputeEngine) => boolean;
 /**
  *  A rule describes how to modify an expressions that matches a pattern `match`
@@ -100,15 +133,19 @@ export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: ICompu
  * `x-1` \( \to \) `1-x`
  * `(x+1)(x-1)` \( \to \) `x^2-1
  *
- * The `match` pattern can be expressed as a LaTeX string or a MathJSON expression.
+ * The `match` pattern can be expressed as a LaTeX string or a
+ * MathJSON expression.
  *
  *
  * Anonymous wildcards (`_`) will match any
  * expression. Named wildcards (`_x`, `_a`, etc...) will match any expression
  * and bind the expression to the wildcard name.
  *
- * In addition the sequence wildcard (`__1`, `__a`, etc...) will match a sequence
- * of one or more expressions, and bind the sequence to the wildcard name.
+ * In addition the sequence wildcard (`__1`, `__a`, etc...) will match
+ * a sequence of one or more expressions, and bind the sequence to the
+ * wildcard name.
+ *
+ * @category Rules
  */
 export type Rule = {
     match: LatexString | SemiBoxedExpression | Pattern;
@@ -117,6 +154,7 @@ export type Rule = {
     priority?: number;
     id?: string;
 };
+/** @category Rules */
 export type BoxedRule = {
     match: Pattern;
     replace: BoxedExpression | PatternReplaceFunction;
@@ -124,12 +162,25 @@ export type BoxedRule = {
     priority: number;
     id?: string;
 };
+/** @category Rules */
 export type BoxedRuleSet = Set<BoxedRule>;
+/** @category Boxed Expression */
 export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
-/** A domain constructor is the head of a domain expression. */
+/** A domain constructor is the head of a domain expression.
+ *
+ * @category Boxed Expression
+ *
+ */
 export type DomainConstructor = 'FunctionOf' | 'ListOf' | 'DictionaryOf' | 'TupleOf' | 'Intersection' | 'Union' | 'OptArg' | 'VarArg' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
+/** @category Boxed Expression */
 export type DomainLiteral = 'Anything' | 'Values' | 'Domains' | 'Void' | 'NothingDomain' | 'Booleans' | 'Strings' | 'Symbols' | 'Collections' | 'Lists' | 'Dictionaries' | 'Sequences' | 'Tuples' | 'Sets' | 'Functions' | 'Predicates' | 'LogicOperators' | 'RelationalOperators' | 'NumericFunctions' | 'RealFunctions' | 'Numbers' | 'ComplexNumbers' | 'ExtendedRealNumbers' | 'ImaginaryNumbers' | 'Integers' | 'Rationals' | 'PositiveNumbers' | 'PositiveIntegers' | 'NegativeNumbers' | 'NegativeIntegers' | 'NonNegativeNumbers' | 'NonNegativeIntegers' | 'NonPositiveNumbers' | 'NonPositiveIntegers' | 'ExtendedComplexNumbers' | 'TranscendentalNumbers' | 'AlgebraicNumbers' | 'RationalNumbers' | 'RealNumbers';
+/** @category Boxed Expression */
 export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['ListOf', DomainExpression<T>] | ['DictionaryOf', DomainExpression<T>] | ['TupleOf', ...DomainExpression<T>[]] | ['OptArg', ...DomainExpression<T>[]] | ['VarArg', DomainExpression<T>] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['FunctionOf', ...DomainExpression<T>[]];
+/**
+ * @noInheritDoc
+ *
+ * @category Boxed Expression
+ */
 export interface BoxedDomain extends BoxedExpression {
     get canonical(): BoxedDomain;
     get json(): Expression;
@@ -145,6 +196,8 @@ export interface BoxedDomain extends BoxedExpression {
 }
 /**
  * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
+ *
+ * @category Compute Engine
  */
 export type JsonSerializationOptions = {
     /** A list of space separated function names that should be excluded from
@@ -188,9 +241,12 @@ export type JsonSerializationOptions = {
      */
     precision: 'auto' | 'max' | number;
 };
+/**
+ * @category Boxed Expression
+ */
 export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
 /**
- * ## THEORY OF OPERATIONS
+ * :::info[THEORY OF OPERATIONS]
  *
  * The `BoxedExpression` interface includes most of the member functions
  * applicable to any kind of expression, for example `get symbol()` or
@@ -201,6 +257,11 @@ export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add'
  *
  * This convention makes it convenient to manipulate expressions without
  * having to check what kind of instance they are before manipulating them.
+ * :::
+ *
+ * To get a boxed expression, use `ce.box()` or `ce.parse()`.
+ *
+ * @category Boxed Expression
  *
  */
 export interface BoxedExpression {
@@ -208,7 +269,6 @@ export interface BoxedExpression {
      * a context in which to interpret it, such as definition of symbols
      * and functions.
      *
-     * {@link ComputeEngine} is the class that implements IComputeEngine.
      */
     readonly engine: IComputeEngine;
     /** From `Object.valueOf()`, return a primitive value for the expression.
@@ -492,7 +552,8 @@ export interface BoxedExpression {
     }): BoxedExpression;
     /**
      * Transform the expression by applying the rules:
-     * if the `lhs` of a rule matches, it is replaced by its `rhs`.
+     * if an expression matches the `match` pattern, replace it with
+     * the `replace` pattern.
      *
      * If no rules apply, return `null`.
      *
@@ -502,7 +563,7 @@ export interface BoxedExpression {
      * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): null | BoxedExpression;
     /**
      * True if the expression includes a symbol `v` or a function head `v`.
      *
@@ -518,23 +579,21 @@ export interface BoxedExpression {
      * @category Relational Operator
      */
     isSame(rhs: BoxedExpression): boolean;
-    /** Attempt to match this expression to the `rhs` expression.
-     *
-     * If `rhs` does not match, return `null`.
-     *
-     * Otherwise return an object literal.
+    /**
+     * If this expression matches `pattern`, return a substitution that makes
+     * `pattern` equal to `this`. Otherwise return `null`.
      *
-     * If this expression includes wildcards (symbols with a name that starts
-     * with `_`), the object literal will include a prop for each matching named
+     * If `pattern` includes wildcards (identifiers that starts
+     * with `_`), the substitution will include a prop for each matching named
      * wildcard.
      *
-     * If `rhs` matches this pattern but there are no named wildcards, return
-     * the empty object literal, `{}`.
+     * If this expression matches `pattern` but there are no named wildcards,
+     * return the empty substitution, `{}`.
      *
      * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     /**
      * "Not a Number".
      *
@@ -677,7 +736,7 @@ export interface BoxedExpression {
      * @category Expression Properties
      */
     readonly isNegative: boolean | undefined;
-    /** The numeric value of this expression is <= 0, same as `isLessEqual(0)`
+    /** The numeric value of this expression is &lt;= 0, same as `isLessEqual(0)`
      *
      * @category Expression Properties
      */
@@ -992,11 +1051,13 @@ export interface BoxedExpression {
      */
     isEqual(rhs: BoxedExpression): boolean;
 }
-/** A semi boxed expression is an MathJSON expression which can include some
+/** A semi boxed expression is a MathJSON expression which can include some
  * boxed terms.
  *
  * This is convenient when creating new expressions from portions
  * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
+ *
+ * @category Boxed Expression
  */
 export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
 /**
@@ -1006,6 +1067,9 @@ export type SemiBoxedExpression = number | string | Decimal | Complex | MathJson
  * - `recursive`: if true, match recursively, otherwise match only the top level.
  * - `numericTolerance`: if present, the tolerance for numeric comparison.
  * - `exact`: if true, only match expressions that are structurally identical. If false, match expressions that are structurally identical or equivalent. For example, when false, `["Add", '_a', 2]` matches `2`, with a value of `_a` of `0`. If true, the expression does not match.
+ *
+ * @category Pattern Matching
+ *
  */
 export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
@@ -1013,12 +1077,13 @@ export type PatternMatchOptions = {
     numericTolerance?: number;
     exact?: boolean;
 };
-export interface Pattern extends BoxedExpression {
-    /** If `expr` matches the pattern, return `true`, otherwise `false` */
-    test(expr: BoxedExpression, options?: PatternMatchOptions): boolean;
-    /** Return the number of exprs that matched the pattern */
-    count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOptions): number;
-}
+/**
+ * @noInheritDoc
+ *
+ * @category Pattern Matching
+ */
+export type Pattern = BoxedExpression;
+/** @category Assumptions */
 export interface ExpressionMapInterface<U> {
     has(expr: BoxedExpression): boolean;
     get(expr: BoxedExpression): U | undefined;
@@ -1039,9 +1104,14 @@ export interface ExpressionMapInterface<U> {
  * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
  *
  * If a semi boxed expression
+ * @category Definitions
  *
  */
 export type IdentifierDefinition = SymbolDefinition | FunctionDefinition | SemiBoxedExpression;
+/**
+ * @category Definitions
+ *
+ */
 export type IdentifierDefinitions = Readonly<{
     [id: string]: IdentifierDefinition;
 }>;
@@ -1050,6 +1120,8 @@ export type IdentifierDefinitions = Readonly<{
  *
  * When a new scope is created with `pushScope()` or when creating a new
  * engine instance, new instances of this type are created as needed.
+ *
+ * @category Definitions
  */
 export type RuntimeIdentifierDefinitions = Map<string, BoxedSymbolDefinition | BoxedFunctionDefinition>;
 /**
@@ -1066,6 +1138,7 @@ export type RuntimeIdentifierDefinitions = Map<string, BoxedSymbolDefinition | B
  * Scopes are lexical (also called a static scope): they are defined based on
  * where they are in an expression, they are not determined at runtime.
  *
+ * @category Compute Engine
  */
 export type Scope = {
     /** Signal `timeout` when the execution time for this scope is exceeded.
@@ -1095,11 +1168,16 @@ export type Scope = {
      */
     iterationLimit: number;
 };
+/** @category Compute Engine */
 export type RuntimeScope = Scope & {
     parentScope?: RuntimeScope;
     ids?: RuntimeIdentifierDefinitions;
     assumptions: undefined | ExpressionMapInterface<boolean>;
 };
+/**
+ * @category Definitions
+ *
+ */
 export type BaseDefinition = {
     /** A short (about 1 line) description. May contain Markdown. */
     description?: string | string[];
@@ -1113,6 +1191,10 @@ export type BaseDefinition = {
      */
     wikidata?: string;
 };
+/**
+ * @category Definitions
+ *
+ */
 export interface BoxedBaseDefinition {
     name: string;
     wikidata?: string;
@@ -1132,6 +1214,7 @@ export interface BoxedBaseDefinition {
 /**
  * A function definition can have some flags to indicate specific
  * properties of the function.
+ * @category Definitions
  */
 export type FunctionDefinitionFlags = {
     /**  If `true`, the function is applied element by element to lists, matrices
@@ -1218,6 +1301,7 @@ export type FunctionDefinitionFlags = {
     numeric: boolean;
 };
 /**
+ * @category Definitions
  *
  */
 export type FunctionSignature = {
@@ -1379,6 +1463,10 @@ export type FunctionSignature = {
     /** Return a compiled (optimized) expression. */
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
+/**
+ * @category Definitions
+ *
+ */
 export type BoxedFunctionSignature = {
     inferredSignature: boolean;
     params: BoxedDomain[];
@@ -1404,20 +1492,23 @@ export type BoxedFunctionSignature = {
  *  The `size()` handler of infinite collections returns `Infinity`
  *  Infinite collections are not indexable, they have no `at()` handler.
  *
+ *  @category Definitions
  */
 export type CollectionHandlers = {
     /** Return an iterator
      * - start is optional and is a 1-based index.
      * - if start is not specified, start from index 1
      * - count is optional and is the number of elements to return
-     * - if count is not specified or negative, return all the elements from start to the end
+     * - if count is not specified or negative, return all the elements from start to the endna
      *
      * If there is a `keys()` handler, there is no `iterator()` handler.
+     *
+     * @category Definitions
      */
     iterator: (expr: BoxedExpression, start?: number, count?: number) => Iterator<BoxedExpression, undefined>;
     /** Return the element at the specified index.
      * The first element is `at(1)`, the last element is `at(-1)`.
-     * If the index is <0, return the element at index `size() + index + 1`.
+     * If the index is &lt;0, return the element at index `size() + index + 1`.
      * The index can also be a string for example for dictionaries.
      * If the index is invalid, return `undefined`.
      */
@@ -1446,6 +1537,7 @@ export type CollectionHandlers = {
 };
 /**
  * Definition record for a function.
+ * @category Definitions
  *
  */
 export type FunctionDefinition = BaseDefinition & Partial<CollectionHandlers> & Partial<FunctionDefinitionFlags> & {
@@ -1483,6 +1575,10 @@ export type FunctionDefinition = BaseDefinition & Partial<CollectionHandlers> &
     hold?: Hold;
     signature: FunctionSignature;
 };
+/**
+ * @category Definitions
+ *
+ */
 export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHandlers> & FunctionDefinitionFlags & {
     complexity: number;
     hold: Hold;
@@ -1496,6 +1592,8 @@ export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHa
  *
  * For example, it might be useful to override `algebraic = false`
  * for a transcendental number.
+ *
+ * @category Definitions
  */
 export type NumericFlags = {
     number: boolean | undefined;
@@ -1523,6 +1621,10 @@ export type NumericFlags = {
     prime: boolean | undefined;
     composite: boolean | undefined;
 };
+/**
+ * @category Definitions
+ *
+ */
 export type SymbolAttributes = {
     /**
      * If `true` the value of the symbol is constant. The value or domain of
@@ -1537,7 +1639,7 @@ export type SymbolAttributes = {
      * If the symbol has a value, it is held as indicated in the table below.
      * A green checkmark indicate that the symbol is substituted.
   
-  <div class=symbols-table>
+  <div className="symbols-table">
   
   | Operation | `"never"` | `"simplify"` | `"evaluate"` | `"N"` |
   | :--- | :----- |
@@ -1561,6 +1663,7 @@ export type SymbolAttributes = {
 /**
  * A bound symbol (i.e. one with an associated definition) has either a domain
  * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... domain = TranscendentalNumbers)
+ * @category Definitions
  */
 export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
     domain?: DomainLiteral | BoxedDomain;
@@ -1575,24 +1678,33 @@ export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
     flags?: Partial<NumericFlags>;
 };
+/**
+ * @noInheritDoc
+ * @category Definitions
+ */
 export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<NumericFlags> {
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);
     domain: BoxedDomain | undefined;
     inferredDomain: boolean;
 }
+/** @category Assumptions */
 export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
+/** @category Compiling */
 export type CompiledExpression = {
     evaluate?: (scope: {
         [symbol: string]: BoxedExpression;
     }) => number | BoxedExpression;
 };
+/** @internal */
 export interface ComputeEngineStats {
     symbols: Set<BoxedExpression>;
     expressions: null | Set<BoxedExpression>;
     highwaterMark: number;
 }
-export type AssignValue = boolean | number | string | Decimal | Complex | LatexString | SemiBoxedExpression | ((ce: any, args: any) => BoxedExpression) | undefined;
+/** @category Compute Engine */
+export type AssignValue = boolean | number | string | Decimal | Complex | LatexString | SemiBoxedExpression | ((ce: IComputeEngine, args: any) => BoxedExpression) | undefined;
+/** @category Compute Engine */
 export type ArrayValue = boolean | number | string | Decimal | Complex | BoxedExpression | undefined;
 /** @internal */
 export interface IComputeEngine {
@@ -1636,13 +1748,12 @@ export interface IComputeEngine {
      * @internal
      */
     deadline?: number;
-    /** @experimental */
+    /** @hidden */
     readonly timeLimit: number;
-    /** @experimental */
+    /** @hidden */
     readonly iterationLimit: number;
-    /** @experimental */
+    /** @hidden */
     readonly recursionLimit: number;
-    /** {@inheritDoc  NumericMode} */
     numericMode: NumericMode;
     tolerance: number;
     chop(n: number): number;
@@ -1656,16 +1767,8 @@ export interface IComputeEngine {
     set precision(p: number | 'machine');
     get precision(): number;
     costFunction: (expr: BoxedExpression) => number;
-    /** In strict mode the compute engine performs additional checks,
-     * for example to ensure the correct number and domain of arguments. These
-     * checks may impact performance.
-     */
     strict: boolean;
-    /** Return a canonical version of an array of semi-boxed-expressions. */
     canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
-    /** Return as boxed expression from a number, string or semiboxed expression.
-     * Calls `function()`, `number()` or `symbol()` as appropriate.
-     */
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
         canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
@@ -1698,7 +1801,6 @@ export interface IComputeEngine {
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
-    pattern(expr: LatexString | SemiBoxedExpression): Pattern;
     /**
      * This is a primitive to create a boxed function.
      *

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  * For each rules in the rule set that match, return the `replace` of the rule
  *
@@ -17,4 +17,4 @@ export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedR
  *
  * If no rule applied, return `null`.
  */
-export declare function replace(expr: BoxedExpression, ruleSet: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
+export declare function replace(expr: BoxedExpression, ruleSet: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  * @todo: a set to "tidy" an expression. Different from a canonical form, but
  * inline with the user's expectations.

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  *
  * @param fn The function to differentiate, a `["Function"]` expression or

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 export declare function distribute(expr: BoxedExpression[]): BoxedExpression;
 /** Use the multinomial theorem (https://en.wikipedia.org/wiki/Multinomial_theorem) to expand the expression.
  * The expression must be a power of a sum of terms.

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  * Flatten the arguments.
  */

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 /**
  * Group terms in a product by common term.
  *

package/dist/types/compute-engine/symbolic/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 import { BoxedExpression, IComputeEngine } from '../public';
 export type DataTypeMap = {
     float64: number;

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

@@ -1,5 +1,8 @@
-/* 0.23.1 */
+/* 0.24.0 */
 import { DataTypeMap, TensorDataType, TensorField } from './tensor-fields';
+/**
+ * @noInheritDoc
+ */
 export interface TensorData<DT extends keyof DataTypeMap = 'float64'> {
     dtype: DT;
     shape: number[];

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

@@ -1,4 +1,4 @@
-/* 0.23.1 */
+/* 0.24.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression, Hold, Rational } from '../public';
 /**

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

@@ -1,3 +1,3 @@
-/* 0.23.1 */
-export declare const version = "0.23.1";
+/* 0.24.0 */
+export declare const version = "0.24.0";
 export { ComputeEngine } from './compute-engine/compute-engine';