@cortex-js/compute-engine 0.4.2 → 0.5.0

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

@@ -1,8 +1,18 @@
-/* 0.4.2 */
-import { ComputeEngine, Numeric, Rule, RuleSet } from './public';
-export declare function rules<T extends number = Numeric>(ce: ComputeEngine<T>, rs: Iterable<Rule>): RuleSet;
-export declare function applyRule<T extends number = Numeric>(ce: ComputeEngine<T>, [lhs, rhs, condition]: Rule<T>, expr: Expression<T>): Expression<T> | null;
+/* 0.5.0 */
+export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedRuleSet;
 /**
- * Repeatedely apply rules in the ruleset until no rules apply
+ * Apply the rules in the ruleset and return a modified expression.
+ *
+ * If no rule applied, return `null`.
  */
-export declare function replace<T extends number = Numeric>(ce: ComputeEngine, rules: RuleSet, expr: Expression<T>): Expression<T> | 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

@@ -0,0 +1,17 @@
+/* 0.5.0 */
+/**
+ * A set of simplification rules.
+ *
+ * The rules are expressed as
+ *
+ *    `[lhs, rhs, condition]`
+ *
+ * where `lhs` is rewritten as `rhs` if `condition` is true.
+ *
+ * `lhs` and `rhs` can be either an Expression or a LaTeX string.
+ *
+ * If using an Expression, the expression is *not* canonicalized before being
+ * used. Therefore in some cases using Expression, while more verbose,
+ * may be necessary as the expression could be simplified by the canonicalization.
+ */
+export declare const SIMPLIFY_RULES: Rule[];

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

@@ -0,0 +1,11 @@
+/* 0.5.0 */
+/**
+ * Return the expansion of ['Multiply', lhs, rhs]
+ * - lhs = 'a + b', rhs = '2'
+ *      ->  '2a + 2b'
+ * - lhs = 'a + b', rhs = 'a + c'
+ *      -> 'a^2 + ac + ab + bc'
+ */
+export declare function expand2(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+export declare function expandN(expr: BoxedExpression, n: number): BoxedExpression;
+export declare function expand(expr: BoxedExpression): BoxedExpression;

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

@@ -0,0 +1,7 @@
+/* 0.5.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;

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

@@ -0,0 +1,12 @@
+/* 0.5.0 */
+/**
+ * Distribute `Negate` (multiply by -1) if expr is a number literal, an
+ * addition or another `Negate`.
+ *
+ * This is appropriate to call during a `canonical` chain.
+ *
+ * For more thorough distribution (including multiplication), see `distributeNegate`,
+ * applicable  during a `simplify` or `evaluate` chain.
+ */
+export declare function canonicalNegate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+export declare function processNegate(_ce: IComputeEngine, x: BoxedExpression, _mode?: 'simplify' | 'evaluate' | 'N'): BoxedExpression;

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

@@ -0,0 +1,52 @@
+/* 0.5.0 */
+/**
+ * Coefficient of a univariate (single variable) polynomial.
+ *
+ * The first element is a constant.
+ * The second element is the coefficient of the variable.
+ * The third element is the coefficient of the variable squared.
+ * ...etc
+ *
+ * `3x^3 + 5x + √5 + 2` -> ['√5 + 2', 5, null, 3]
+ *
+ * If a coefficient does not apply (there are no corresponding term), it is `null`.
+ *
+ */
+export declare type UnivariateCoefficients = (null | BoxedExpression)[];
+export declare type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
+/**
+ * Return a list of coefficient of powers of `vars` in `poly`,
+ * starting with power 0.
+ *
+ * If `poly`  is not a polynomial, return `null`.
+ */
+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:
+ *
+ * `3√2x^5y^3` -> 8 (5 + 3)
+ */
+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
+ *
+ * `3√2x^5y^3` -> 5
+ *
+ */
+export declare function maxDegree(expr: BoxedExpression): number;
+/**
+ * Return a lexicographic key of the expression
+ */
+export declare function lex(expr: BoxedExpression): string;

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

@@ -0,0 +1,45 @@
+/* 0.5.0 */
+/**
+ * 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.
+ *      (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]]
+ *      ]
+ *
+ */
+export declare class Product {
+    engine: IComputeEngine;
+    private _terms;
+    private _literal;
+    private _hasInfinity;
+    private _hasZero;
+    constructor(ce: IComputeEngine, xs?: BoxedExpression[]);
+    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.
+     */
+    addTerm(term: BoxedExpression): void;
+    /** The terms of the product, grouped by degrees */
+    groupedByDegrees(options?: {
+        splitRational: boolean;
+    }): {
+        exponent: [exponentNumer: number, exponentDenom: number];
+        terms: BoxedExpression[];
+    }[];
+    terms(): 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

@@ -0,0 +1,25 @@
+/* 0.5.0 */
+export declare class Sum {
+    private engine;
+    private _literal;
+    private _imaginary;
+    private _posInfinityCount;
+    private _negInfinityCount;
+    private _terms;
+    constructor(engine: IComputeEngine, terms?: BoxedExpression[]);
+    get isEmpty(): boolean;
+    /**
+     * Add a new term to the sum.
+     * A term is a rational coefficient and an expression.
+     * Optinally, the term is multiplied by the constant `c` before beind added.
+     *
+     * If the sum already has this term, the coefficient is added
+     * to the previous one. Otherwise, a new entry is added.
+     *
+     * E.g. "2x + x + 1/5 y"
+     *  -> [['x', [3, 1]], ['y', [1, 5]]]
+     */
+    addTerm(term: BoxedExpression, c?: [number, number]): void;
+    terms(): BoxedExpression[];
+    asExpression(): BoxedExpression;
+}

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

@@ -0,0 +1,47 @@
+/* 0.5.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];
+/**
+ * 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:
+ *
+ * `coef * term + constant = expr`
+ *
+ * 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,
+ * i.e. 'op(a, op(b, c))` -> `op(a, b, c)`, etc...
+ *
+ */
+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];

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

@@ -1,5 +1,3 @@
-/* 0.4.2 */
-export { LatexSyntax, parse, serialize } from './math-json';
-export { ComputeEngine, format, evaluate, } from './compute-engine/compute-engine';
-export { match, substitute } from './compute-engine/patterns';
-export declare const version = "0.4.2";
+/* 0.5.0 */
+export { ComputeEngine } from './compute-engine/compute-engine';
+export declare const version = "0.5.0";

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

@@ -0,0 +1,101 @@
+/* 0.5.0 */
+    /** A human readable string to annotate an expression, since JSON does not
+     * allow comments in its encoding */
+    comment?: string;
+    /** A Markdown-encoded string providing documentation about this expression.
+     */
+    documentation?: string;
+    /** A human readable string to indicate a syntax error or
+     * other problem when parsing or evaluating an expression.
+     */
+    error?: string;
+    /** A visual representation in LaTeX of the expression.
+     *
+     * This can be useful to preserve non-semantic details, for example
+     * parentheses in an expression or styling attributes
+     */
+    latex?: string;
+    /**
+     * A short string indicating an entry in a wikibase.
+     *
+     * For example
+     * `"Q167"` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
+     *  for the `Pi` constant.
+     */
+    wikidata?: string;
+    /** A base URL for the `wikidata` key.
+     *
+     * A full URL can be produced by concatenating this key with the `wikidata`
+     * key. This key applies to this node and all its children.
+     *
+     * The default value is "https://www.wikidata.org/wiki/"
+     */
+    wikibase?: string;
+    /** A short string indicating an entry in an OpenMath Content Dictionary.
+     *
+     * For example: `arith1/#abs`.
+     *
+     */
+    openmathSymbol?: string;
+    /** A base URL for an OpenMath content dictionary. This key applies to this
+     * node and all its children.
+     *
+     * The default value is "http://www.openmath.org/cd".
+     */
+    openmathCd?: string;
+    /**  A url to the source of this expression.
+     */
+    sourceUrl?: string;
+    /** The source from which this expression was generated.
+     *
+     * It could be a LaTeX expression, or some other source language
+     */
+    sourceContent?: string;
+    /**
+     * A character offset in `sourceContent` or `sourceUrl` from which this
+     * expression was generated
+     */
+    sourceOffsets?: [start: number, end: number];
+};
+/**
+ * A MathJSON numeric quantity.
+ *
+ * The string is made of:
+ * - an optional `-` minus sign
+ * - a string of decimal digits
+ * - an optional fraction part (a `.` decimal point followed by decimal digits)
+ * - an optional exponent part (a `e` or `E` exponent marker followed by an
+ *   optional `-` minus sign, followed by a string of digits).
+ * - an optional format suffix:
+ *    - `n` to indicate the number is a BigInt
+ *    - `d` to indicate the number is an arbitrary precision Decimal number
+ *      and may contain more digits or exponents with a greater magnitude than
+ *      can be represented with a 64-bit floating point number.
+ *
+ * For example: `-12.34`, `0.234e-56`, `123454e9999d`.
+ */
+export declare type MathJsonNumber = {
+    num: 'NaN' | '-Infinity' | '+Infinity' | string;
+} & Attributes;
+export declare type MathJsonSymbol = {
+    sym: string;
+} & Attributes;
+export declare type MathJsonString = {
+    str: string;
+} & Attributes;
+export declare type MathJsonFunction = {
+    fn: [Expression, ...Expression[]];
+} & Attributes;
+export declare type MathJsonDictionary = {
+    dict: {
+        [key: string]: Expression;
+    };
+} & Attributes;
+/**
+ * A MathJSON expression is a recursive data structure.
+ *
+ * The leaf nodes of an expression are numbers, strings and symbols.
+ * The dictionary and function nodes can contain expressions themselves.
+ *
+ */
+export declare type Expression = number | MathJsonNumber | MathJsonString | MathJsonSymbol | string | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];

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

@@ -0,0 +1,97 @@
+/* 0.5.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";
+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;
+/**  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): string | null;
+/**
+ * The head of a function can be a string or an expression.
+ *
+ * Return `null` if the expression is not a function.
+ *
+ * Examples:
+ * * `["Negate", 5]`  -> `"Negate"`
+ * * `[["Prime", "f"], "x"]` -> `["Prime", "f"]`
+ */
+export declare function head(expr: Expression | null): 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, n: number): Expression | null;
+export declare function nops(expr: Expression): number;
+export declare function symbol(expr: Expression | null): string | null;
+export declare function machineValue(expr: Expression | null): number | null;
+/**
+ * Return a rational (numer over denom) representation of the expression,
+ * if possible, `[null, null]` otherwise.
+ *
+ * The expression can be:
+ * - Some symbols: "ThreeQuarte", "Half"...
+ * - ["Power", d, -1]
+ * - ["Power", n, 1]
+ * - ["Divide", n, d]
+ *
+ * The denominator is always > 0.
+ */
+export declare function rationalValue(expr: Expression): [number, number] | [null, null];
+/**
+ * Return all the elements but the first one, i.e. the arguments of a
+ * function.
+ */
+export declare function tail(expr: Expression | null): Expression[];
+export declare function applyRecursively(expr: Expression, fn: (x: Expression) => Expression): Expression;
+/**
+ * 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[];
+export declare function dictionary(expr: Expression): {
+    [key: string]: Expression;
+} | null;
+/**
+ * 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,
+ * i.e. 'op(a, op(b, c))` -> `op(a, b, c)`, etc...
+ *
+ */
+export declare function applyAssociativeOperator(op: string, lhs: Expression, rhs: Expression, associativity?: 'right' | 'left' | 'non' | 'both'): Expression;
+export declare function getSequence(expr: Expression | null): Expression[] | null;
+export declare function isValidSymbolName(s: string): boolean;

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

@@ -1,3 +1,4 @@
-/* 0.4.2 */
-export { LatexSyntax, parse, serialize } from './latex-syntax/latex-syntax';
-export declare const version = "0.4.2";
+/* 0.5.0 */
+export { isAtomic, isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, tail, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, asValidJSONNumber, } 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.5.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.4.2",
+  "version": "0.5.0",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",
@@ -42,46 +42,47 @@
   "module": "./dist/compute-engine.min.esm.js",
   "types": "./dist/types/compute-engine.d.ts",
   "engines": {
-    "npm": ">=6.14.8",
-    "node": ">=12.0.0"
+    "npm": ">=8.5.0",
+    "node": ">=16.14.2"
   },
   "devDependencies": {
-    "@cortex-js/prettier-config": "^1.1.0",
-    "@rollup/plugin-commonjs": "^19.0.0",
-    "@rollup/plugin-node-resolve": "^13.0.0",
-    "@types/jest": "^26.0.23",
-    "@types/node": "^15.12.2",
-    "@typescript-eslint/eslint-plugin": "^4.27.0",
-    "@typescript-eslint/parser": "^4.27.0",
-    "@typescript-eslint/typescript-estree": "^4.27.0",
-    "chalk": "^4.1.1",
-    "check-node-version": "^4.1.0",
+    "@cortex-js/prettier-config": "^1.1.1",
+    "@jest/console": "^27.5.1",
+    "@rollup/plugin-commonjs": "^21.0.3",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@types/jest": "^27.4.1",
+    "@types/node": "^17.0.23",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
+    "@typescript-eslint/typescript-estree": "^5.17.0",
+    "chalk": "^5.0.1",
+    "check-node-version": "^4.2.1",
     "child_process": "^1.0.2",
-    "chokidar": "^3.5.2",
-    "eslint": "^7.28.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.23.4",
-    "eslint-plugin-no-unsanitized": "^3.1.5",
-    "eslint-plugin-prettier": "^3.4.0",
+    "chokidar": "^3.5.3",
+    "eslint": "^8.12.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-no-unsanitized": "^4.0.1",
+    "eslint-plugin-prettier": "^4.0.0",
     "estrella": "^1.4.1",
-    "http-server": "^0.12.3",
-    "jest": "^27.0.4",
+    "http-server": "^14.1.0",
+    "jest": "^27.5.1",
     "jest-silent-reporter": "^0.5.0",
-    "open": "^8.2.0",
-    "prettier": "^2.3.1",
-    "rollup": "^2.52.1",
+    "open": "^8.4.0",
+    "prettier": "^2.6.1",
+    "rollup": "^2.70.1",
     "rollup-plugin-copy": "^3.4.0",
     "rollup-plugin-eslint": "^7.0.0",
     "rollup-plugin-terser": "^7.0.2",
     "rollup-plugin-typescript2": "latest",
     "serve-http": "^1.0.6",
-    "ts-jest": "^27.0.3",
-    "typescript": "^4.3.3",
+    "ts-jest": "^27.1.4",
+    "typescript": "^4.6.3",
     "update-notifier": "^5.1.0"
   },
   "prettier": "@cortex-js/prettier-config",
   "dependencies": {
-    "complex.js": "^2.0.13",
-    "decimal.js": "^10.2.1"
+    "complex.js": "^2.1.0",
+    "decimal.js": "^10.3.1"
   }
 }