@cortex-js/compute-engine 0.20.2 → 0.22.0

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -91,40 +91,39 @@ export type BoxedSubstitution = Substitution<BoxedExpression>;
  * `"$\frac{\pi}{2}$"`.
  */
 export type LatexString = string;
+export type PatternReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression;
+export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: IComputeEngine) => boolean;
 /**
- *  A rule describes how to modify an expressions that matches a `lhs` pattern
- * into a new expressions matching `rhs`.
+ *  A rule describes how to modify an expressions that matches a pattern `match`
+ * into a new expression `replace`.
  *
  * `x-1` \( \to \) `1-x`
  * `(x+1)(x-1)` \( \to \) `x^2-1
  *
- * The `lhs` 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.
  *
- * Unbound variables (`x`, but not `Pi`) are matched structurally with a
- * a target expression, then the expression is rewritten as the `rhs`, with
- * the corresponding unbound variables in the `rhs` replaced by their values
- * in the `lhs.
  *
- * Pattern symbols (e.g. `_1`, `_a`) can be used as well.
+ * 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:
- *  - `__1` (`__a`, etc..) match a sequence of one or more expressions
- *  - `___1` (`___a`, etc...) match a sequence of zero or more expressions
+ * 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.
  */
-export type Rule = [
-    lhs: LatexString | SemiBoxedExpression | Pattern,
-    rhs: LatexString | SemiBoxedExpression,
-    options?: {
-        condition?: LatexString | ((wildcards: BoxedSubstitution) => boolean);
-        priority?: number;
-    }
-];
-export type BoxedRule = [
-    lhs: Pattern,
-    rhs: BoxedExpression,
-    priority: number,
-    condition: undefined | ((wildcards: BoxedSubstitution) => boolean)
-];
+export type Rule = {
+    match: LatexString | SemiBoxedExpression | Pattern;
+    replace: LatexString | SemiBoxedExpression | PatternReplaceFunction;
+    condition?: LatexString | PatternConditionFunction;
+    priority?: number;
+    id?: string;
+};
+export type BoxedRule = {
+    match: Pattern;
+    replace: BoxedExpression | PatternReplaceFunction;
+    condition: undefined | PatternConditionFunction;
+    priority: number;
+    id?: string;
+};
 export type BoxedRuleSet = Set<BoxedRule>;
 export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 /** A domain constructor is the head of a domain expression. */
@@ -189,6 +188,7 @@ export type JsonSerializationOptions = {
      */
     precision: 'auto' | 'max' | number;
 };
+export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
 /**
  * ## THEORY OF OPERATIONS
  *
@@ -207,6 +207,8 @@ export interface BoxedExpression {
     /** The Compute Engine associated with this expression provides
      * 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.
@@ -231,6 +233,12 @@ export interface BoxedExpression {
      * @category Primitive Methods
      */
     toString(): string;
+    /**
+     * Output to the console a string representation of the expression.
+     *
+     * @category Primitive Methods
+     */
+    print(): void;
     /** Similar to`expr.valueOf()` but includes a hint.
      * @category Primitive Methods
      */
@@ -588,10 +596,22 @@ export interface BoxedExpression {
      * Note it is possible for `numericValue` to be `null`, and for `isNotZero`
      * to be true. For example, when a symbol has been defined with an assumption.
      *
+     * Conversely, `isNumber` may be true even if `numericValue` is `null`,
+     * example the symbol `Pi` return true for `isNumber` but `numericValue` is
+     * `null`. It's value can be accessed with `.value.numericValue`
+     *
      * @category Numeric Expression
      *
      */
     readonly numericValue: number | Decimal | Complex | Rational | null;
+    /** The shape describes the axis of the expression.
+     * When the expression is a scalar (number), the shape is `[]`.
+     * When the expression is a vector, the shape is `[n]`.
+     * When the expression is a matrix, the shape is `[n, m]`.
+     */
+    readonly shape: number[];
+    /** Return 0 for a scalar, 1 for a vector, 2 for a matrix, > 2 for a multidimensional matrix. It's the length of `expr.shape` */
+    readonly rank: number;
     /**
      * Return the following, depending on the value of this expression:
      *
@@ -974,6 +994,14 @@ export interface BoxedExpression {
  * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
  */
 export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
+/**
+ * Control how a pattern is matched to an expression.
+ *
+ * - `substitution`: if present, assumes these values for the named wildcards, and ensure that subsequent occurence of the same wildcard have the same value.
+ * - `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.
+ */
 export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
     recursive?: boolean;
@@ -1560,6 +1588,7 @@ export interface ComputeEngineStats {
     highwaterMark: number;
 }
 export type AssignValue = boolean | number | string | Decimal | Complex | LatexString | SemiBoxedExpression | ((ce: any, args: any) => BoxedExpression) | undefined;
+export type ArrayValue = boolean | number | string | Decimal | Complex | BoxedExpression | undefined;
 /** @internal */
 export interface IComputeEngine {
     latexDictionary: readonly LatexDictionaryEntry[];
@@ -1615,174 +1644,38 @@ export interface IComputeEngine {
     chop(n: Decimal): Decimal | 0;
     chop(n: Complex): Complex | 0;
     chop(n: number | Decimal | Complex): number | Decimal | Complex;
-    /** Create an arbitrary precision number.
-     *
-     * The return value is an object with methods to perform arithmetic
-     * operations:
-     * - `toNumber()`: convert to a JavaScript `number` with potential loss of precision
-     * - `add()`
-     * - `sub()`
-     * - `neg()` (unary minus)
-     * - `mul()`
-     * - `div()`
-     * - `pow()`
-     * - `sqrt()` (square root)
-     * - `cbrt()` (cube root)
-     * - `exp()`  (e^x)
-     * - `log()`
-     * - `ln()` (natural logarithm)
-     * - `mod()`
-  
-     * - `abs()`
-     * - `ceil()`
-     * - `floor()`
-     * - `round()`
-  
-     * - `equals()`
-     * - `gt()`
-     * - `gte()`
-     * - `lt()`
-     * - `lte()`
-     *
-     * - `cos()`
-     * - `sin()`
-     * - `tanh()`
-     * - `acos()`
-     * - `asin()`
-     * - `atan()`
-     * - `cosh()`
-     * - `sinh()`
-     * - `acosh()`
-     * - `asinh()`
-     * - `atanh()`
-     *
-     * - `isFinite()`
-     * - `isInteger()`
-     * - `isNaN()`
-     * - `isNegative()`
-     * - `isPositive()`
-     * - `isZero()`
-     * - `sign()` (1, 0 or -1)
-     *
-     */
     bignum: (a: Decimal.Value | bigint) => Decimal;
-    /** Create a complex number.
-     * The return value is an object with methods to perform arithmetic
-     * operations:
-     * - `re` (real part, as a JavaScript `number`)
-     * - `im` (imaginary part, as a JavaScript `number`)
-     * - `add()`
-     * - `sub()`
-     * - `neg()` (unary minus)
-     * - `mul()`
-     * - `div()`
-     * - `pow()`
-     * - `sqrt()` (square root)
-     * - `exp()`  (e^x)
-     * - `log()`
-     * - `ln()` (natural logarithm)
-     * - `mod()`
-  
-     * - `abs()`
-     * - `ceil()`
-     * - `floor()`
-     * - `round()`
-  
-     * - `arg()` the angle of the complex number
-     * - `inverse()` the inverse of the complex number 1/z
-     * - `conjugate()` the conjugate of the complex number
-  
-     * - `equals()`
-     *
-     * - `cos()`
-     * - `sin()`
-     * - `tanh()`
-     * - `acos()`
-     * - `asin()`
-     * - `atan()`
-     * - `cosh()`
-     * - `sinh()`
-     * - `acosh()`
-     * - `asinh()`
-     * - `atanh()`
-     *
-     * - `isFinite()`
-     * - `isNaN()`
-     * - `isZero()`
-     * - `sign()` (1, 0 or -1)
-     */
     complex: (a: number | Complex, b?: number) => Complex;
     isBignum(a: unknown): a is Decimal;
     isComplex(a: unknown): a is Complex;
     set precision(p: number | 'machine');
     get precision(): number;
     costFunction: (expr: BoxedExpression) => number;
-    /** In strict mode (the default) the Compute Engine performs
-     * validation of domains and signature and may report errors.
-     *
-     * When strict mode is off, results may be incorrect or generate JavaScript
-     * errors if the input is not valid.
-     *
-     */
     strict: boolean;
-    /**
-     * Associate a new definition to a symbol in the current context.
-     *
-     * If a definition existed previously, it is replaced.
-     *
-     *
-     * For internal use. Use `ce.declare()` instead.
-     *
-     * @internal
-     */
     defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
-    /**
-     * Associate a new definition to a function in the current context.
-     *
-     * If a definition existed previously, it is replaced.
-     *
-     * For internal use. Use `ce.declare()` instead.
-     *
-     * @internal
-     */
     defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
-    /** Return `undefined` if no definition exist for this `head` */
     lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
-    /**
-     * Return a boxed expression from the input.
-     */
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
     canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
-    /** Return a boxed number */
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
-    /** Return a canonical boxed symbol */
     symbol(sym: string, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
-    /** Return a canonical boxed string */
     string(s: string, metadata?: Metadata): BoxedExpression;
-    /** Return a canonical boxed domain.
-     *
-     * If the domain is invalid, may return an `["Error"]` expression
-     *
-     */
     domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
     /**
-     * Return a canonical expression.
-     *
-     * Note that the result may not be a function, or may have a different
-     * `head` than the one specified.
-     *
-     * For example:
-     * `ce.fn("Rational", [ce.number(1),  ce.number(2)]))` \( \to \) `ce.number([1,2])`
+     * Create a boxed function expression.
      *
+     * @param head
+     * @param ops
+     * @param options
      */
     fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], options?: {
         canonical: boolean;
@@ -1796,128 +1689,46 @@ export interface IComputeEngine {
      * The result is canonical, but the caller has to ensure that all the
      * conditions are met (i.e. `ops` properly normalized and sorted, all
      * `ops` canonical, etc..) so that the result is actually canonical.
-     */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Error"...)`.
      *
-     * The result is canonical.
+     * @internal
      */
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
-    /**
-     * Add a`["Hold"]` wrapper to `expr.
-     */
     hold(expr: SemiBoxedExpression): BoxedExpression;
-    /** Shortcut for `this.fn("Add"...)`.
-     *
-     * The result is canonical.
-     */
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Multiply"...)`
-     *
-     * The result is canonical.
-     */
     mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Power"...)`
-     *
-     * The result is canonical.
-     */
     pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Sqrt"...)`
-     *
-     * The result is canonical.
-     */
-    sqrt(base: BoxedExpression, metadata?: Metadata): any;
-    /** Shortcut for `this.fn("Divide", [1, expr])`
-     *
-     * The result is canonical.
-     */
+    sqrt(base: BoxedExpression, metadata?: Metadata): BoxedExpression;
     inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Negate", [expr])`
-     *
-     * The result is canonical.
-     */
     neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Divide", [num, denom])`
-     *
-     * The result is canonical.
-     */
     div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Pair"...)`
-     *
-     * The result is canonical.
-     */
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    /** Shortcut for `this.fn("Tuple"...)`
-     *
-     * The result is canonical.
-     */
+    tuple(elements: number[], metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
-    /**
-     * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
-     *
-     * The result may not be canonical.
-     *
-     */
     parse(s: LatexString | string, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
     parse(s: null, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): null;
     parse(s: LatexString | string | null, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): null | BoxedExpression;
-    /** Serialize a `BoxedExpression` or a `MathJSON` expression to
-     * a LaTeX string
-     */
     serialize(expr: SemiBoxedExpression, options?: {
         canonical?: boolean;
     }): LatexString;
-    /**
-     * Options to control the serialization of MathJSON expression to LaTeX
-     * when using `this.latex` or `this.engine.serialize()`.
-     *
-     *
-     * {@inheritDoc  NumberFormattingOptions}
-     * {@inheritDoc  ParseLatexOptions}
-     * {@inheritDoc  SerializeLatexOptions}
-     *
-     */
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
-    /** {@inheritDoc  JsonSerializationOptions} */
     get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
-    /** Create a new scope on top of the scope stack, and set it as current */
     pushScope(scope?: Partial<Scope>): IComputeEngine;
-    /** Remove the most recent scope from the scope stack, and set its
-     *  parent scope as current. */
     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;
-    /** Assign a value to an identifier in the current scope.
-     * Use `undefined` to reset the identifier to no value.
-     *
-     * The identifier should be a valid MathJSON identifier
-     * not a LaTeX string.
-     *
-     * 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
-     * attributes of the identifier.
-     */
     assign(ids: {
         [id: string]: AssignValue;
     }): IComputeEngine;
@@ -1925,18 +1736,6 @@ export interface IComputeEngine {
     assign(arg1: string | {
         [id: string]: AssignValue;
     }, arg2?: AssignValue): IComputeEngine;
-    /**
-     * Declare an identifier: specify their domain, 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
-     * after the fact, previously valid expressions could become invalid.
-     *
-     * Use the `Anyting` domain for a very generic domain.
-     *
-     */
     declare(identifiers: {
         [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
     }): IComputeEngine;
@@ -1944,27 +1743,10 @@ export interface IComputeEngine {
     declare(arg1: string | {
         [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
     }, arg2?: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
-    /**
-     * Add an assumption.
-     *
-     * Note that the assumption is put into canonical form before being added.
-     *
-     * @param symbol - The symbol to make an assumption about
-     *
-     * Returns:
-     * - `contradiction` if the new assumption is incompatible with previous
-     * ones.
-     * - `tautology` if the new assumption is redundant with previous ones.
-     * - `ok` if the assumption was successfully added to the assumption set.
-     *
-     *
-     */
     assume(predicate: SemiBoxedExpression): AssumeResult;
-    /** Remove all assumptions about one or more symbols */
     forget(symbol?: string | string[]): void;
     get assumptions(): ExpressionMapInterface<boolean>;
     ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
-    /** Using the current assumptions, answer a query. */
     verify(query: SemiBoxedExpression): boolean;
     /** @internal */
     shouldContinueExecution(): boolean;

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

@@ -1,10 +1,16 @@
-/* 0.20.2 */
+/* 0.22.0 */
 /**
- * Go through all the rules in the rule set, and for all the rules that match
- * return the rhs of the rule applied to `expr`.
+ * For each rules in the rule set that match, return the `replace` of the rule
+ *
  * @param rules
  */
 export declare function matchRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution): BoxedExpression[];
+/**
+ * Create a boxed rule set from a non-boxed rule set
+ * @param ce
+ * @param rs
+ * @returns
+ */
 export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedRuleSet;
 /**
  * Apply the rules in the ruleset and return a modified expression.
@@ -12,13 +18,3 @@ 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;
-/**
- * Substitute some symbols with an expression.
- *
- * This is applied recursively to all subexpressions.
- *
- * While `replace()` applies a rule which may include expressions in
- * its `lhs` to an expression, `substitute` is a specialized version
- * that only apply rules that have a `lhs` made of a symbol.
- */
-export declare function getWildcardName(s: string): string;

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality
@@ -15,3 +15,4 @@ export declare function findUnivariateRoots(expr: BoxedExpression, x: string): B
  * `2x < 4` => `x < 2`
  */
 export declare function univariateSolve(expr: BoxedExpression, x: string): SemiBoxedExpression[] | null;
+export declare const HARMONIZATION_RULES: Rule[];

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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,6 +1,7 @@
-/* 0.20.2 */
+/* 0.22.0 */
 /**
  * Flatten the arguments.
  */
 export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[];
 export declare function flattenSequence(xs: BoxedExpression[]): BoxedExpression[];
+export declare function flattenDelimiter(ce: IComputeEngine, body: undefined | BoxedExpression): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

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

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare class Sum {
     private engine;
     private _isCanonical;