@cortex-js/compute-engine 0.12.3 → 0.12.5

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -36,7 +36,7 @@ export type Metadata = {
  */
 export type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
 /** Options for `BoxedExpression.simplify()` */
-export type SimplifyOptions = EvaluateOptions & {
+export type SimplifyOptions = {
     recursive?: boolean;
     rules?: BoxedRuleSet;
 };
@@ -126,9 +126,9 @@ export type BoxedRule = [
 export type BoxedRuleSet = Set<BoxedRule>;
 export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 /** A domain constructor is the head of a domain expression. */
-export type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
+export type DomainConstructor = 'InvalidDomain' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
 export type DomainLiteral = string;
-export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
+export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['InvalidDomain', T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
 export interface BoxedDomain extends BoxedExpression {
     is(s: BoxedDomain): boolean;
     /** True if a valid domain, and compatible with `dom` */
@@ -284,6 +284,9 @@ export interface BoxedExpression {
      *
      */
     readonly json: Expression;
+    /** For debugging, the raw MathJSON representation of this expression without decanonicalization.
+     * @internal */
+    readonly rawJson: Expression;
     /**
      * The scope in which this expression has been defined.
      * Is null when the expression is not canonical.
@@ -841,7 +844,9 @@ export interface BoxedExpression {
      * The result is in canonical form.
      *
      */
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(ids?: {
+        [id: string]: SemiBoxedExpression | null | undefined;
+    }): BoxedExpression;
     /** Return a numeric approximation of the canonical form of this expression.
      *
      * Any necessary calculations, including on decimal numbers (non-integers),
@@ -1481,7 +1486,7 @@ export type SymbolAttributes = {
     * - `x` has `holdUntil: 'evaluate'` (variables)
     * - `Pi` has `holdUntil: 'N'` (special numeric constant)
     *
-    * **Default:** `simplify`
+    * **Default:** `evaluate`
     */
     holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
 };
@@ -1633,7 +1638,9 @@ export interface IComputeEngine {
      * `ce.fn("Rational", [ce.number(1),  ce.number(2)]))` \( \to \) `ce.number([1,2])`
      *
      */
-    fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
+    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.
@@ -1734,7 +1741,9 @@ export interface IComputeEngine {
     pushScope(identifiers?: Readonly<IdTable> | Readonly<IdTable>[], scope?: Partial<Scope>): void;
     popScope(): void;
     /** Assign a value to an identifier in the current scope. Use `null` to reset the identifier to no value */
-    set(identifiers: Substitution<SemiBoxedExpression | null | undefined>): void;
+    set(ids: {
+        [id: string]: SemiBoxedExpression | null | undefined;
+    }): void;
     /** Declare identifiers (specify their domain without necessarily assigning them a value in the current scope) */
     let(identifiers: IdTable): void;
     /**

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * 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`.

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,11 +1,19 @@
-/* 0.12.3 */
-/**
- * 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'
+/* 0.12.5 */
+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.
+ * The power must be a positive integer.
+ * - expr = '(a + b)^2'
+ *     ->  'a^2 + 2ab + b^2'
+ * - expr = '(a + b)^3'
+ *    -> 'a^3 + 3a^2b + 3ab^2 + b^3'
  */
-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;
+export declare function expandMultinomial(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.
+ * Expand the terms of the expression if it is a sum or negate.
+ * If the expression is a fraction, expand the numerator.
+ * Return null if the expression cannot be expanded.
+ */
+export declare function expand(expr: BoxedExpression | undefined): BoxedExpression | null;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * 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.12.3 */
+/* 0.12.5 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * Group terms in a product by common term.
  *
@@ -16,6 +16,9 @@
  *
  */
 export declare class Product {
+    readonly options?: {
+        canonical?: boolean;
+    };
     engine: IComputeEngine;
     private _sign;
     private _rational;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare class Sum {
     private engine;
     private _isCanonical;
@@ -27,6 +27,7 @@ export declare class Sum {
      *  -> [['x', [3, 1]], ['y', [1, 5]]]
      */
     addTerm(term: BoxedExpression, c?: Rational): void;
+    toString(): string;
     terms(mode: 'expression' | 'numeric'): BoxedExpression[];
     asExpression(mode: 'expression' | 'numeric'): BoxedExpression;
 }

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import Decimal from 'decimal.js';
 import { BoxedExpression, Rational } from '../public';
 /**

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

@@ -1,3 +1,3 @@
-/* 0.12.3 */
-export declare const version = "0.12.3";
+/* 0.12.5 */
+export declare const version = "0.12.5";
 export { ComputeEngine } from './compute-engine/compute-engine';

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;

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

@@ -1,4 +1,5 @@
-/* 0.12.3 */
+/* 0.12.5 */
+export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
 export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
@@ -6,6 +7,8 @@ export declare function isStringObject(expr: Expression | null): expr is MathJso
 export declare function isFunctionObject(expr: Expression | null): expr is MathJsonFunction;
 export declare function isDictionaryObject(expr: Expression): expr is MathJsonNumber;
 export declare function isValidIdentifier(s: string): boolean;
+export declare const ONLY_EMOJIS: RegExp;
+export declare function validateIdentifier(s: unknown): 'valid' | 'not-a-string' | 'empty-string' | 'expected-nfc' | 'unexpected-mixed-emoji' | 'unexpected-bidi-marker' | 'unexpected-script' | 'invalid-first-char' | 'invalid-char';
 /**  If expr is a string literal, return it.
  *
  * A string literal is a JSON string that begins and ends with

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

@@ -1,3 +1,3 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
-export declare const version = "0.12.3";
+export declare const version = "0.12.5";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.3",
+  "version": "0.12.5",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",
@@ -48,35 +48,26 @@
   "devDependencies": {
     "@cortex-js/prettier-config": "^1.1.1",
     "@jest/console": "^29.0.3",
-    "@rollup/plugin-commonjs": "^22.0.2",
-    "@rollup/plugin-node-resolve": "^14.0.1",
     "@types/jest": "^29.0.0",
-    "@types/node": "^18.7.16",
+    "@types/node": "^20.3.2",
     "@typescript-eslint/eslint-plugin": "^5.36.2",
     "@typescript-eslint/parser": "^5.36.2",
     "@typescript-eslint/typescript-estree": "^5.36.2",
     "chalk": "^5.0.1",
     "check-node-version": "^4.2.1",
-    "child_process": "^1.0.2",
-    "chokidar": "^3.5.3",
+    "esbuild": "^0.18.10",
     "eslint": "^8.23.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-no-unsanitized": "^4.0.1",
     "eslint-plugin-prettier": "^4.2.1",
-    "estrella": "^1.4.1",
     "jest": "^29.0.3",
     "jest-silent-reporter": "^0.5.0",
-    "open": "^8.4.0",
+    "open": "^9.1.0",
     "prettier": "^2.7.1",
-    "rollup": "^2.79.0",
-    "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.7",
     "ts-jest": "^29.0.0",
-    "typescript": "^4.8.3",
+    "typescript": "^5.1.5",
     "update-notifier": "^6.0.2"
   },
   "prettier": "@cortex-js/prettier-config",