@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -0,0 +1,25 @@
+/* 0.26.2 */
+/**
+ *
+ * Make all the arguments canonical.
+ *
+ * "Lift" Sequence expressions to the top level.
+ * e.g. `["Add", 1, ["Sequence", 2, 3]]` -> `["Add", 1, 2, 3]`
+ *
+ * Additionally, if an operator is provided, also lift nested expressions
+ * with the same operator.
+ *  e.g. `["f", a, ["f", b, c]]` -> `["f", a, b, c]`
+ *
+ * Note: *not* recursive
+ */
+export declare function flatten<T extends ReadonlyArray<BoxedExpression> | BoxedExpression[]>(ops: T, operator?: string): T;
+/**
+ * Flatten the arguments.
+ * @fixme replace with just flatten.
+ * @fixme consider adding flatternSort()
+ */
+export declare function flattenOps<T extends ReadonlyArray<BoxedExpression> | BoxedExpression[]>(ops: T, operator: string): T;
+/**
+ * @todo: this function should probably not be recursive. As it, it is semi-recursive.
+ */
+export declare function flattenSequence(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;

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

@@ -0,0 +1,9 @@
+/* 0.26.2 */
+/** Apply the function `f` to each operand of the expression `expr`,
+ * account for the 'hold' property of the function definition:
+ *
+ * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
+ *
+ * If `f` returns `null`, the element is not added to the result
+ */
+export declare function holdMap(expr: BoxedExpression, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;

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

@@ -1,6 +1,4 @@
-/* 0.25.1 */
-import Decimal from 'decimal.js';
-import { BoxedSubstitution, PatternMatchOptions, BoxedExpression, SemiBoxedExpression } from './public';
+/* 0.26.2 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).
@@ -11,4 +9,4 @@ import { BoxedSubstitution, PatternMatchOptions, BoxedExpression, SemiBoxedExpre
  * If the expression does not match the pattern, it returns `null`.
  *
  */
-export declare function match(subject: BoxedExpression, pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+export declare function match(subject: BoxedExpression, pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

package/dist/types/compute-engine/{symbolic → boxed-expression}/negate.d.ts

@@ -1,4 +1,5 @@
-/* 0.25.1 */
+/* 0.26.2 */
+export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.
@@ -6,6 +7,5 @@
  * It is important to do all these to handle cases like
  * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
-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;
+export declare function negate(expr: BoxedExpression): BoxedExpression;
+export declare function negateProduct(ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -1,41 +1,7 @@
-/* 0.25.1 */
-import { Rational } from '../numerics/rationals';
-import { BoxedExpression } 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).
- *
- * For example:
- *
- * ['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];
+/* 0.26.2 */
+import type { Rational } from '../numerics/rationals';
+import type { BoxedExpression } from './public';
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
-export declare function asApproximateRational(expr: BoxedExpression): Rational | undefined;
-export declare function div(lhs: Rational, rhs: Rational): Rational;
-/**
- * Add a literal numeric value to a rational.
- * 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
- * @returns
- */
-export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
-export declare function mul(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
-export declare function asFloat(expr: BoxedExpression | undefined): number | null;
+export declare function asBigint(expr: BoxedExpression | undefined): bigint | null;
 export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
-export declare function asMachineInteger(expr: BoxedExpression | undefined): number | null;
-/**
- *
- * @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;
+export declare function asSmallInteger(expr: number | BoxedExpression | undefined): number | null;

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

@@ -1,11 +1,22 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**
- * Sort by higher total degree (sum of degree), if tied, sort by max degree,
- * if tied,
+ * The sorting order of arguments of the Add function uses a modified degrevlex:
+ * - Sort by total degree (sum of degree)
+ * - Sort by max degree.
+ * - Sort reverse lexicographically
+ * - Sort by rank
+ *
+ *
+ * E.g.
+ * - 2x^2 + 3x + 1
+ * - 2x^2y^3 + 5x^3y
  */
-export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;
+export declare function addOrder(a: BoxedExpression, b: BoxedExpression): number;
+export declare function equalOrder(a: BoxedExpression, b: BoxedExpression): number;
+declare const RANKS: readonly ["integer", "rational", "radical", "real", "complex", "constant", "symbol", "multiply", "divide", "add", "trig", "fn", "power", "string", "other"];
+export type Rank = (typeof RANKS)[number];
 /**
  * Given two expressions `a` and `b`, return:
  * - `-1` if `a` should be ordered before `b`
@@ -15,7 +26,7 @@ export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyAr
  * The default order is as follow:
  *
  * 1/ Literal numeric values (rational,  machine numbers and Decimal numbers),
- *  ordered by they numeric value (smaller numbers before larger numbers)
+ *  ordered by their numeric value (smaller numbers before larger numbers)
  *
  * 2/ Literal complex numbers, ordered by their real parts. In case of a tie,
  * ordered by the absolute value of their imaginary parts. In case of a tie,
@@ -26,7 +37,7 @@ export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyAr
  * 4/ Addition, ordered as a polynom, with higher degree terms first
  *
  * 5/ Other functions, ordered by their `complexity` property. In case
- * of a tie, ordered by the head of the expression as a string. In case of a
+ * of a tie, ordered by the operator of the expression as a string. In case of a
  * tie, by the leaf count of each expression. In case of a tie, by the order
  * of each argument, left to right.
  *
@@ -35,9 +46,8 @@ export declare function sortAdd(ops: ReadonlyArray<BoxedExpression>): ReadonlyAr
  * example "E" < "e" < "È" and "11" < "2". This ordering is not suitable to
  * collate natural language strings.
  *
- * 7/ Dictionaries, ordered by the number of keys. If there is a tie, by the
- * sum of the complexities of the values of the dictionary
- *
+ * See https://reference.wolfram.com/language/ref/Sort.html for a
+ * description of the ordering of expressions in Mathematica.
  *
  */
 export declare function order(a: BoxedExpression, b: BoxedExpression): number;
@@ -47,13 +57,15 @@ export declare function order(a: BoxedExpression, b: BoxedExpression): number;
 export declare function canonicalOrder(expr: BoxedExpression, { recursive }: {
     recursive?: boolean;
 }): BoxedExpression;
+export declare function sortOperands(operator: string, xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;
 /**
  * Sort the terms of a polynomial expression (`Add` expression) according
  * to the deglex polynomial ordering
  *
  */
-export declare function polynomialOrder(expr: BoxedExpression): SemiBoxedExpression;
-export declare function lexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
-export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
-export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
-export declare function eliminationOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): SemiBoxedExpression;
+export declare function polynomialOrder(expr: BoxedExpression): BoxedExpression;
+export declare function lexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export declare function eliminationOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
+export {};

package/dist/types/compute-engine/{symbolic → boxed-expression}/polynomials.d.ts

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *
@@ -22,31 +22,27 @@ export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
  */
 export declare function coefficients(poly: BoxedExpression, vars: string): UnivariateCoefficients | null;
 export declare function coefficients(poly: BoxedExpression, vars: string[]): MultivariateCoefficients | null;
-/**
- * Return a polynomial expression of `vars` with coefficient
- * of powers `coefs`.
- *
- * `poly === polynomial(coefficients(poly), getVars(poly))`
- *
- */
-export declare function polynomial(coefs: UnivariateCoefficients, vars: string): SemiBoxedExpression;
-export declare function polynomial(coefs: MultivariateCoefficients, vars: string[]): SemiBoxedExpression;
 /**
  * The total degree of an expression is the sum of the
- * of the positive integer degrees of the factors in the expression:
+ * positive integer degrees of the factors in the expression:
  *
- * `3√2x^5y^3` -> 8 (5 + 3)
+ * `3√2x^5y^3` -> 5 + 3 = 8
  */
 export declare function totalDegree(expr: BoxedExpression): number;
 /**
- * The max degree of an expression is the largest positive integer degree
- * in the factors of the expression
+ * The max degree of a polynomial is the largest positive integer degree
+ * in the factors (monomials) of the expression
  *
  * `3√2x^5y^3` -> 5
  *
  */
 export declare function maxDegree(expr: BoxedExpression): number;
 /**
- * Return a lexicographic key of the expression
+ * Return a lexicographic key of the expression, for example
+ * `xy^2` -> `x y`
+ * `x\frac{1}{y}` -> `x y`
+ * `2xy + y^2` -> `x y y`
+ *
  */
 export declare function lex(expr: BoxedExpression): string;
+export declare function revlex(expr: BoxedExpression): string;

package/dist/types/compute-engine/{symbolic → boxed-expression}/product.d.ts

@@ -1,18 +1,19 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { Rational } from '../numerics/rationals';
+import { NumericValue } from '../numeric-value/public';
 /**
  * Group terms in a product by common term.
  *
  * All the terms should be canonical.
  * - the arguments should have been flattened for `Multiply`
  *
- * - any argument of power been factored out, i.e.
+ * - any argument of power been distributed, i.e.
  *      (ab)^2 ->  a^2 b^2
  * *
  * 3 + √5 + √(x+1) + x^2 + (a+b)^2 + d
  *  -> [ [[3, "d"], [1, 1]],
  *       [[5, "x+1"], [1, 2]],
- *       [[x, "a+b"], [2, 1]]
+ *       [[1, "a+b"], [2, 1]]
  *      ]
  *
  */
@@ -21,40 +22,30 @@ export declare class Product {
         canonical?: boolean;
     };
     engine: IComputeEngine;
-    private _sign;
-    private _number;
-    private _complex;
-    private _bignum;
-    private _rational;
-    private _rationalSqrt;
-    private _terms;
-    private _hasInfinity;
-    private _hasZero;
+    coefficient: NumericValue;
+    terms: {
+        term: BoxedExpression;
+        exponent: Rational;
+    }[];
     private _isCanonical;
+    static from(expr: BoxedExpression): Product;
     constructor(ce: IComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
         canonical?: boolean;
     });
-    get isEmpty(): boolean;
     /**
      * Add a term to the product.
      *
      * If `this._isCanonical` a running product of exact terms is kept.
      * Otherwise, terms and their exponent are tallied.
      */
-    addTerm(term: BoxedExpression): void;
-    /** Return all the 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[];
-    }[] | null;
+    mul(term: BoxedExpression, exp?: Rational): void;
+    /** Divide the product by a term of coefficient */
+    div(term: NumericValue | BoxedExpression): void;
     /** The terms of the product, grouped by degrees.
      *
      * If `mode` is `rational`, rationals are split into separate numerator and
      * denominator, so that a rational expression can be created later
-     * If `mode` is `expression`, a regular expression is returned, without
+     * If `mode` is `expression`, a boxed expression is returned, without
      * splitting rationals
      * If `mode` is `numeric`, the literals are combined into one expression
      *
@@ -65,8 +56,11 @@ export declare class Product {
         exponent: Rational;
         terms: BoxedExpression[];
     }[] | null;
-    asExpression(mode?: 'N' | 'evaluate'): BoxedExpression;
+    asExpression(options?: {
+        numericApproximation: boolean;
+    }): BoxedExpression;
     /** The product, expressed as a numerator and denominator */
     asNumeratorDenominator(): [BoxedExpression, BoxedExpression];
     asRationalExpression(): BoxedExpression;
 }
+export declare function commonTerms(lhs: Product, rhs: Product): [NumericValue, BoxedExpression];