@cortex-js/compute-engine 0.8.0 → 0.9.0

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

@@ -1,4 +1,10 @@
-/* 0.8.0 */
+/* 0.9.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`.
+ * @param rules
+ */
+export declare function matchRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution): BoxedExpression[];
 export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedRuleSet;
 /**
  * Apply the rules in the ruleset and return a modified expression.

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -0,0 +1,17 @@
+/* 0.9.0 */
+export declare const UNIVARIATE_ROOTS: Rule[];
+/**
+ * Expression is a function of a single variable (`x`) or an Equality
+ *
+ * Return the roots of that variable
+ *
+ */
+export declare function findUnivariateRoots(expr: BoxedExpression, x: string): BoxedExpression[];
+/** Expr is an equation with a head of
+ * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
+ *
+ * Return an expression with the same head, but with the first argument
+ * a variable, if possible:
+ * `2x < 4` => `x < 2`
+ */
+export declare function univariateSolve(expr: BoxedExpression, x: string): SemiBoxedExpression[] | null;

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /**
  * Return the expansion of ['Multiply', lhs, rhs]
  * - lhs = 'a + b', rhs = '2'

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

@@ -1,7 +1,8 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.
  */
 export declare function flatten(expr: BoxedExpression, head: string): BoxedExpression;
 export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[] | null;
+export declare function flattenSequence(xs: BoxedExpression[]): BoxedExpression[];

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /**
  * Group terms in a product by common term.
  *
@@ -17,29 +17,47 @@
  */
 export declare class Product {
     engine: IComputeEngine;
+    private _sign;
+    private _rational;
+    private _complex;
+    private _bignum;
+    private _number;
     private _terms;
-    private _literal;
     private _hasInfinity;
     private _hasZero;
-    constructor(ce: IComputeEngine, xs?: BoxedExpression[]);
+    private _isCanonical;
+    constructor(ce: IComputeEngine, xs?: BoxedExpression[], options?: {
+        canonical?: boolean;
+    });
     get isEmpty(): boolean;
     /**
      * Add a term to the product.
-     * If the term is a literal rational, it is added to `this._literal`.
-     * Otherwise, if the term is already in the product, its degree is modified
-     * as appropriate.
+     *
+     * If `this._isCanonical` a running product of exact terms is kept.
+     * Otherwise, terms and their exponent are tallied.
      */
     addTerm(term: BoxedExpression): void;
-    /** The terms of the product, grouped by degrees */
+    unitTerms(mode: 'rational' | 'expression' | 'numeric'): {
+        exponent: Rational;
+        terms: BoxedExpression[];
+    }[] | null;
+    /** 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
+     * splitting rationals
+     * If `mode` is `numeric`, the literals are combined into one expression
+     *
+     */
     groupedByDegrees(options?: {
-        splitRational: boolean;
+        mode?: 'rational' | 'expression' | 'numeric';
     }): {
-        exponent: [exponentNumer: number, exponentDenom: number];
+        exponent: Rational;
         terms: BoxedExpression[];
-    }[];
-    terms(): BoxedExpression[];
+    }[] | null;
+    asExpression(mode?: 'N' | 'evaluate'): BoxedExpression;
     /** The product, expressed as a numerator and denominator */
     asNumeratorDenominator(): [BoxedExpression, BoxedExpression];
-    asExpression(): BoxedExpression;
     asRationalExpression(): BoxedExpression;
 }

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

@@ -1,15 +1,21 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare class Sum {
     private engine;
-    private _literal;
+    private _rational;
     private _imaginary;
+    private _number;
+    private _bignum;
     private _posInfinityCount;
     private _negInfinityCount;
     private _terms;
-    constructor(engine: IComputeEngine, terms?: BoxedExpression[]);
+    private _isCanonical;
+    constructor(ce: IComputeEngine, xs?: BoxedExpression[], options?: {
+        canonical?: boolean;
+    });
     get isEmpty(): boolean;
     /**
-     * Add a new term to the sum.
+     * Add a term to the sum.
+     *
      * A term is a rational coefficient and an expression.
      * Optionally, the term is multiplied by the constant `c` before being added.
      *
@@ -19,7 +25,7 @@ export declare class Sum {
      * E.g. "2x + x + 1/5 y"
      *  -> [['x', [3, 1]], ['y', [1, 5]]]
      */
-    addTerm(term: BoxedExpression, c?: [number, number]): void;
-    terms(): BoxedExpression[];
-    asExpression(): BoxedExpression;
+    addTerm(term: BoxedExpression, c?: Rational): void;
+    terms(mode: 'expression' | 'numeric'): BoxedExpression[];
+    asExpression(mode: 'expression' | 'numeric'): BoxedExpression;
 }

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

@@ -1,30 +1,9 @@
-/* 0.8.0 */
-/**
- * If expression is a product or a division, collect all the terms with a
- * negative exponents in the denominator, and all the terms
- * with a positive exponent (or no exponent) in the numerator, and put the
- * numerator and denominators of all the terms that are a division (or a rational)
- * into separate numerator/denominator
- */
-export declare function numeratorDenominator(expr: BoxedExpression): [SemiBoxedExpression[], SemiBoxedExpression[]];
-/**
- * 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: [numer: number, denom: number], rest: BoxedExpression];
+/* 0.9.0 */
+import Decimal from 'decimal.js';
+import { BoxedExpression, Rational } from '../public';
 /**
  * Return a rational coef and constant such that `coef * mod + constant = expr`
  */
-export declare function multiple(expr: BoxedExpression, mod: BoxedExpression): [coef: [number, number], constant: BoxedExpression];
 /**
  * Return a coef, term and constant such that:
  *
@@ -32,11 +11,6 @@ export declare function multiple(expr: BoxedExpression, mod: BoxedExpression): [
  *
  * Return null if no `coef`/`constant` can be found.
  */
-export declare function linear(expr: BoxedExpression): null | {
-    coef: [number, number];
-    term: BoxedExpression;
-    constant: [number, number];
-};
 /**
  * Apply the operator `op` to the left-hand-side and right-hand-side
  * expression. Applies the associativity rule specified by the definition,
@@ -45,3 +19,7 @@ export declare function linear(expr: BoxedExpression): null | {
  */
 export declare function applyAssociativeOperator(op: string, lhs: BoxedExpression, rhs: BoxedExpression, associativity?: 'right' | 'left' | 'non' | 'both'): BoxedExpression;
 export declare function makePositive(expr: BoxedExpression): [sign: number, expr: BoxedExpression];
+export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): number | Decimal | Complex;
+export declare function applyN(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;
+export declare function apply2(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex | Rational, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | Rational | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): number | Decimal | Complex | Rational;
+export declare function apply2N(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex | Rational, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number | Rational, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export { ComputeEngine } from './compute-engine/compute-engine';
-export declare const version = "0.8.0";
+export declare const version = "0.9.0";
 export { getVars } from './compute-engine/boxed-expression/utils';

package/dist/types/math-json/math-json-format.d.ts

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;
@@ -102,4 +102,4 @@ export declare type MathJsonDictionary = {
  * The dictionary and function nodes can contain expressions themselves.
  *
  */
-export declare type Expression = number | MathJsonNumber | MathJsonString | MathJsonSymbol | string | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];
+export declare type Expression = number | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];

package/dist/types/math-json/utils.d.ts

@@ -1,46 +1,19 @@
-/* 0.8.0 */
-/**
- * These constants are the 'primitive' functions and constants that are used
- * for some basic manipulations such as parsing, and transforming to canonical
- * form.
- *
- */
-export declare const IDENTITY = "Identity";
-export declare const LIST = "List";
-export declare const ADD = "Add";
-export declare const DERIVATIVE = "Derivative";
-export declare const DIVIDE = "Divide";
-export declare const EXP = "Exp";
-export declare const MULTIPLY = "Multiply";
-export declare const NEGATE = "Negate";
-export declare const POWER = "Power";
-export declare const PRIME = "Prime";
-export declare const ROOT = "Root";
-export declare const SQRT = "Sqrt";
-export declare const SUBTRACT = "Subtract";
-export declare const COMPLEX_INFINITY = "ComplexInfinity";
-export declare const PI = "Pi";
-export declare const EXPONENTIAL_E = "ExponentialE";
-export declare const IMAGINARY_UNIT = "ImaginaryUnit";
+/* 0.9.0 */
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
 export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
 export declare function isStringObject(expr: Expression | null): expr is MathJsonString;
 export declare function isFunctionObject(expr: Expression | null): expr is MathJsonFunction;
 export declare function isDictionaryObject(expr: Expression): expr is MathJsonNumber;
-/**
- * True if the expression is a number, a symbol or a string
- * (i.e. not a function and not a dictionary)
- */
-export declare function isAtomic(expr: Expression | null): boolean;
-export declare function isValidSymbolName(s: string): boolean;
+export declare function isValidIdentifier(s: string): boolean;
 /**  If expr is a string literal, return it.
  *
  * A string literal is a JSON string that begins and ends with
  * **U+0027 APOSTROPHE** : **`'`** or an object literal with a `str` key.
  */
 export declare function stringValue(expr: Expression | null | undefined): string | null;
+export declare function stripText(expr: Expression | null | undefined): Expression | null;
 /**
- * The head of a function can be a string or an expression.
+ * The head of a function can be an identifier or an expression.
  *
  * Return `null` if the expression is not a function.
  *
@@ -51,12 +24,13 @@ export declare function stringValue(expr: Expression | null | undefined): string
 export declare function head(expr: Expression | null | undefined): Expression | null;
 /** Return the head of an expression, only if it's a string */
 export declare function headName(expr: Expression | null): string;
-export declare function op(expr: Expression | null | undefined, n: number): Expression | null;
 /**
  * Return all the elements but the first one, i.e. the arguments of a
  * function.
  */
 export declare function ops(expr: Expression | null | undefined): Expression[] | null;
+/** Return the nth argument of a function expression */
+export declare function op(expr: Expression | null | undefined, n: number): Expression | null;
 export declare function op1(expr: Expression | null | undefined): Expression | null;
 export declare function op2(expr: Expression | null | undefined): Expression | null;
 export declare function nops(expr: Expression | null | undefined): number;
@@ -65,7 +39,7 @@ export declare function dictionary(expr: Expression | null): null | Record<strin
 export declare function machineValue(expr: Expression | null | undefined): number | null;
 /**
  * Return a rational (numer over denom) representation of the expression,
- * if possible, `[null, null]` otherwise.
+ * if possible, `null` otherwise.
  *
  * The expression can be:
  * - Some symbols: "Infinity", "Half"...
@@ -75,8 +49,8 @@ export declare function machineValue(expr: Expression | null | undefined): numbe
  *
  * The denominator is always > 0.
  */
-export declare function rationalValue(expr: Expression | undefined | null): [number, number] | [null, null];
-export declare function applyRecursively(expr: Expression, fn: (x: Expression) => Expression): Expression;
+export declare function rationalValue(expr: Expression | undefined | null): [number, number] | null;
+export declare function applyRecursively<T extends Expression = Expression>(expr: T, fn: (x: T) => T): Expression;
 export declare function subs(expr: Expression, s: {
     [symbol: string]: Expression;
 }): Expression;
@@ -84,12 +58,6 @@ export declare function subs(expr: Expression, s: {
  * Apply a function to the arguments of a function and return an array of T
  */
 export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
-/**
- * Return num as a number if it's a valid JSON number (that is
- * a valid JavaScript number but not NaN or +/-Infinity) or
- * as a string otherwise
- */
-export declare function asValidJSONNumber(num: string): string | number;
 /**
  * Apply the operator `op` to the left-hand-side and right-hand-side
  * expression. Applies the associativity rule specified by the definition,
@@ -100,3 +68,5 @@ export declare function applyAssociativeOperator(op: string, lhs: Expression, rh
 export declare function getSequence(expr: Expression | null): Expression[] | null;
 export declare function isEmptySequence(expr: Expression | null): boolean;
 export declare function missingIfEmpty(expr: Expression | null): Expression;
+/** The number of leaves (atomic expressions) in the expression */
+export declare function countLeaves(expr: Expression | null): number;

package/dist/types/math-json.d.ts

@@ -1,4 +1,4 @@
-/* 0.8.0 */
-export { isAtomic, isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, asValidJSONNumber, } from './math-json/utils';
+/* 0.9.0 */
+export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
 export type { LatexToken, ParseHandler, SerializeHandler, LatexDictionaryEntry, LatexDictionary, ParseLatexOptions, SerializeLatexOptions, NumberFormattingOptions, } from './compute-engine/latex-syntax/public';
-export declare const version = "0.8.0";
+export declare const version = "0.9.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.8.0",
+  "version": "0.9.0",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",