@cortex-js/compute-engine 0.21.0 → 0.23.0

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

@@ -1,14 +1,34 @@
-/* 0.21.0 */
+/* 0.23.0 */
 /**
  * Assume the caller has setup a scope. The index
  * variable will be declared in that scope.
  *
- * @param limits
+ * @param indexingSet
+
+ * IndexingSet is an expression describing an index variable
+ * and a range of values for that variable.
+ *
+ * The MultiIndexingSet function takes an expression of the form
+ * \sum_{i=1,j=1}^{10,10} x and returns an array of expressions
+ * ["Sum","x",["Triple","i",1,10],["Triple","j",1,10]
+ */
+export declare function MultiIndexingSet(indexingSet: BoxedExpression | undefined): BoxedExpression[] | undefined;
+/**
+ * Assume the caller has setup a scope. The index
+ * variable will be declared in that scope.
+ *
+ * @param indexingSet
+
+ * IndexingSet is an expression describing an index variable
+ * and a range of values for that variable.
  *
+ * The SingleIndexingSet function takes an expression of the form
+ * \sum_{i=1}^{10} x and returns an array of expressions
+ * ["Sum","x",["Triple","i",1,10]
  */
-export declare function canonicalLimits(limits: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function SingleIndexingSet(indexingSet: BoxedExpression | undefined): BoxedExpression | undefined;
 /**
- * Limits is an expression describing an index variable
+ * IndexingSet is an expression describing an index variable
  * and a range of values for that variable.
  *
  * This can take several valid forms:
@@ -21,9 +41,11 @@ export declare function canonicalLimits(limits: BoxedExpression | undefined): Bo
  * @param limits
  * @returns
  */
-export declare function normalizeLimits(limits: BoxedExpression | undefined): [
+export declare function normalizeIndexingSet(limits: BoxedExpression | undefined): [
     index: string | undefined,
     lower: number,
     upper: number,
     isFinite: boolean
 ];
+export declare function cartesianProduct(array1: number[], array2: number[]): number[][];
+export declare function range(start: number, end: number): number[];

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

@@ -0,0 +1,27 @@
+/* 0.23.0 */
+import Decimal from 'decimal.js';
+import { BoxedExpression, Rational } from '../public';
+/**
+ * Attempt to factor a numeric coefficient `c` and a `rest` out of a
+ * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
+ *
+ * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
+ *
+ * The numeric coefficient could be an expression, for example:
+ * ['Multiply', 2, ['Sqrt', 5], 'x']
+ *    -> [['Multiply', 2, ['Sqrt', 5]], 'x']
+ *
+ * ['Multiply', 2, 'x', 3, 'a']
+ *    -> [6, ['Multiply', 'x', 'a']]
+ *
+ * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
+ *    -> [['Rational', 2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
+ */
+export declare function asCoefficient(expr: BoxedExpression): [coef: Rational, rest: BoxedExpression];
+export declare function applyCoefficient(value: number | Decimal | Complex | Rational | null, coef: Rational): number | Decimal | Complex | Rational | null;
+/** Combine rational expressions into a single fraction */
+export declare function together(op: BoxedExpression): BoxedExpression;
+/**
+ * Return a list of expressions that multiply together to form `expr`.
+ */
+export declare function factor(expr: BoxedExpression): BoxedExpression;

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -1,4 +1,6 @@
-/* 0.21.0 */
+/* 0.23.0 */
+import { Expression } from '../../math-json.js';
+export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
 export declare function bigint(a: Decimal | number | bigint | string): bigint;
 export declare function gcd(a: bigint, b: bigint): bigint;
 export declare function lcm(a: bigint, b: bigint): bigint;

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.23.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.21.0 */
+/* 0.23.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.23.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;
@@ -109,3 +109,10 @@ export declare function monteCarloEstimate(f: (x: number) => number, a: number,
 export declare function limit(f: (x: number) => number, x: number, dir?: number): number;
 export declare function fromRoman(roman: string): [result: number, rest: string];
 export declare function fromDigits(s: string, baseInput?: string | number): [result: number, rest: string];
+/**
+ *
+ * @param lhs
+ * @param rhs
+ * @returns the sign (-1, 0, 1) of the difference between `lhs` and `rhs`
+ */
+export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.23.0 */
 export declare function isPrime(n: number): boolean | undefined;

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

@@ -1,9 +1,10 @@
-/* 0.21.0 */
+/* 0.23.0 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [number, number];
 export declare function isBigRational(x: any | null): x is [bigint, bigint];
 export declare function isRationalZero(x: Rational): boolean;
 export declare function isRationalOne(x: Rational): boolean;
+export declare function isRationalInteger(x: Rational): boolean;
 export declare function isRationalNegativeOne(x: Rational): boolean;
 export declare function machineNumerator(x: Rational): number;
 export declare function machineDenominator(x: Rational): number;
@@ -17,7 +18,7 @@ export declare function inverse(x: Rational): Rational;
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
 /**
  * Add a literal numeric value to a rational.
- * If the rational is a bignum, this is a hint to do the calculation in bignum
+ * If the rational is a bigint, this is a hint to do the calculation in bigint
  * (no need to check `bignumPreferred()`).
  * @param lhs
  * @param rhs
@@ -25,30 +26,15 @@ export declare function asRational(expr: BoxedExpression): Rational | undefined;
  */
 export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
 export declare function mul(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
+export declare function div(lhs: Rational, rhs: Rational): Rational;
 export declare function pow(r: Rational, exp: number): Rational;
+export declare function sqrt(r: Rational): Rational | undefined;
 export declare function reducedRational(r: [number, number]): [number, number];
 export declare function reducedRational(r: [bigint, bigint]): [bigint, bigint];
 export declare function reducedRational(r: Rational): Rational;
 /** Return a rational approximation of x */
 export declare function rationalize(x: number): [n: number, d: number] | number;
-/**
- * Attempt to factor a rational coefficient `c` and a `rest` out of a
- * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
- *
- * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
- *
- *
- * ['Multiply', 2, 'x', 3, 'a', ['Sqrt', 5]]
- *    -> [[6, 1], ['Multiply', 'x', 'a', ['Sqrt', 5]]]
- *
- * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
- *    -> [[2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
- */
-export declare function asCoefficient(expr: BoxedExpression): [coef: Rational, rest: BoxedExpression];
-/**
- *
- * @param lhs
- * @param rhs
- * @returns the sign (-1, 0, 1) of the difference between `lhs` and `rhs`
+/** Return [factor, root] such that factor * sqrt(root) = n
+ * when factor and root are rationals
  */
-export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;
+export declare function reduceRationalSquareRoot(n: Rational): [factor: Rational, root: Rational];

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.23.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

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

@@ -0,0 +1,14 @@
+/* 0.23.0 */
+export declare class Terms {
+    private engine;
+    private terms;
+    constructor(ce: IComputeEngine, terms: BoxedExpression[]);
+    sub(term: BoxedExpression): void;
+    add(term2: BoxedExpression, coef2?: Rational): void;
+    find(term: BoxedExpression): number;
+    /** If `exact` is true, keep exact numbers */
+    reduceNumbers({ exact }?: {
+        exact: boolean;
+    }): void;
+    asExpression(): BoxedExpression;
+}

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.23.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
  *
@@ -233,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
      */
@@ -428,6 +434,11 @@ export interface BoxedExpression {
      * An exact value is not further transformed when evaluated. To get an
      * approximate evaluation of an exact value, use `.N()`.
      *
+     * Exact numbers are:
+     * - rationals (including integers)
+     * - complex numbers with integer real and imaginary parts (Gaussian integers)
+     * - square root of rationals
+     *
      * Non-exact values includes:
      * - numbers with a fractional part
      * - complex numbers with a real or imaginary fractional part
@@ -590,10 +601,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:
      *
@@ -976,6 +999,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;
@@ -1619,21 +1650,29 @@ export interface IComputeEngine {
     chop(n: Complex): Complex | 0;
     chop(n: number | Decimal | Complex): number | Decimal | Complex;
     bignum: (a: Decimal.Value | bigint) => Decimal;
-    complex: (a: number | Complex, b?: number) => Complex;
     isBignum(a: unknown): a is Decimal;
+    complex: (a: number | Complex, b?: number) => Complex;
     isComplex(a: unknown): a is Complex;
     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;
-    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
-    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
-    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
-    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
+    /** 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;
+    function(head: string | BoxedExpression, ops: SemiBoxedExpression[], options?: {
+        metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
-    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         metadata?: Metadata;
         canonical?: boolean;
@@ -1644,45 +1683,43 @@ export interface IComputeEngine {
     }): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
     domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
-    fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], options?: {
-        canonical: boolean;
-    }): BoxedExpression;
-    /**
-     * This is a primitive to create a boxed function. It doesn't perform
-     * any checks or normalization on its arguments.
-     *
-     * In general, consider using `ce.fn()` or `ce.box()` instead.
-     *
-     * 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.
-     *
-     * @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;
     hold(expr: SemiBoxedExpression): BoxedExpression;
-    add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
-    sqrt(base: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    add(...ops: BoxedExpression[]): BoxedExpression;
+    mul(...ops: BoxedExpression[]): BoxedExpression;
+    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression): BoxedExpression;
+    sqrt(base: BoxedExpression): BoxedExpression;
+    inv(expr: BoxedExpression): BoxedExpression;
+    neg(expr: BoxedExpression): BoxedExpression;
+    div(num: BoxedExpression, denom: BoxedExpression): BoxedExpression;
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    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;
+    /**
+     * This is a primitive to create a boxed function.
+     *
+     * In general, consider using `ce.box()` or `canonicalXXX()` instead.
+     *
+     * The caller must ensure that the arguments are in canonical form:
+     * - arguments are `canonical()`
+     * - arguments are sorted
+     * - arguments are flattened and desequenced
+     *
+     * @internal
+     */
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     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(expr: SemiBoxedExpression, options?: {
         canonical?: boolean;
@@ -1695,6 +1732,10 @@ export interface IComputeEngine {
     popScope(): IComputeEngine;
     swapScope(scope: RuntimeScope | null): RuntimeScope | null;
     resetContext(): void;
+    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
+    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
+    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
+    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     assign(ids: {
         [id: string]: AssignValue;
     }): IComputeEngine;
@@ -1720,6 +1761,7 @@ export interface IComputeEngine {
     checkContinueExecution(): void;
     /** @internal */
     cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
+    /** @internal */
     readonly stats: ComputeEngineStats;
     /** @internal */
     reset(): void;

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

@@ -1,10 +1,16 @@
-/* 0.21.0 */
+/* 0.23.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,14 @@
-/* 0.21.0 */
+/* 0.23.0 */
+/**
+ * @todo: a set to "tidy" an expression. Different from a canonical form, but
+ * inline with the user's expectations.
+ *
+ * Example:
+ *
+ * - a^n * a^m -> a^(n+m)
+ * - a / √b -> (a * √b) / b
+ *
+ */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.23.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.21.0 */
+/* 0.23.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.21.0 */
+/* 0.23.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.
@@ -9,6 +9,10 @@ export declare function distribute(expr: BoxedExpression[]): BoxedExpression;
  *    -> 'a^3 + 3a^2b + 3ab^2 + b^3'
  */
 export declare function expandMultinomial(expr: BoxedExpression): BoxedExpression | null;
+/** Expand all
+ * Recursive expand of all terms in the expression
+ */
+export declare function expandAll(expr: BoxedExpression): BoxedExpression | null;
 /** Apply the distributive law if the expression is a product of sums.
  * For example, a(b + c) = ab + ac
  * Expand the expression if it is a power of a sum.

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

@@ -1,6 +1,7 @@
-/* 0.21.0 */
+/* 0.23.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.21.0 */
+/* 0.23.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.
@@ -6,5 +6,6 @@
  * It is important to do all these to handle cases like
  * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
-export declare function canonicalNegate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+export declare function evalNegate(expr: BoxedExpression): BoxedExpression;
+export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 export declare function processNegate(_ce: IComputeEngine, x: BoxedExpression, _mode?: 'simplify' | 'evaluate' | 'N'): BoxedExpression;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.23.0 */
 /**
  * Group terms in a product by common term.
  *
@@ -21,10 +21,11 @@ export declare class Product {
     };
     engine: IComputeEngine;
     private _sign;
-    private _rational;
+    private _number;
     private _complex;
     private _bignum;
-    private _number;
+    private _rational;
+    private _rationalSqrt;
     private _terms;
     private _hasInfinity;
     private _hasZero;
@@ -40,6 +41,10 @@ export declare class Product {
      * Otherwise, terms and their exponent are tallied.
      */
     addTerm(term: BoxedExpression): void;
+    /** Return all ther terms with an exponent of 1 and
+     * the square root of rationals (which technically have an
+     * exponent of 1/2, but are considered as degree 1 terms)
+     */
     unitTerms(mode: 'rational' | 'expression' | 'numeric'): {
         exponent: Rational;
         terms: BoxedExpression[];