@cortex-js/compute-engine 0.53.0 → 0.54.0

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonExpression, MathJsonNumberObject, MathJsonStringObject, MathJsonSymbolObject, MathJsonFunctionObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeString } from '../common/type/types';
@@ -906,6 +906,56 @@ export interface Expression {
      * ```
      */
     factors(): ReadonlyArray<Expression>;
+    /**
+     * Return the coefficients of this expression as a polynomial in `variable`,
+     * in descending order of degree. Returns `undefined` if the expression is
+     * not a polynomial in the given variable.
+     *
+     * If `variable` is omitted, auto-detects when the expression has exactly
+     * one unknown. Returns `undefined` if there are zero or multiple unknowns.
+     *
+     * ```typescript
+     * ce.parse('x^2 + 2x + 1').polynomialCoefficients('x')  // [1, 2, 1]
+     * ce.parse('x^3 + 2x + 1').polynomialCoefficients('x')  // [1, 0, 2, 1]
+     * ce.parse('sin(x)').polynomialCoefficients('x')          // undefined
+     * ce.parse('x^2 + 5').polynomialCoefficients()            // [1, 0, 5]
+     * ```
+     *
+     * Subsumes `isPolynomial`:
+     * ```typescript
+     * const isPolynomial = expr.polynomialCoefficients('x') !== undefined;
+     * ```
+     *
+     * Subsumes `polynomialDegree`:
+     * ```typescript
+     * const degree = expr.polynomialCoefficients('x')?.length - 1;
+     * ```
+     *
+     * When `variable` is an array, the expression must be polynomial in ALL
+     * listed variables. Coefficients are decomposed by the first variable;
+     * remaining variables appear as symbolic coefficients.
+     *
+     * ```typescript
+     * ce.parse('x^2*y + 3x + y^2').polynomialCoefficients(['x', 'y'])
+     * // → [y, 3, y²]  (coefficients of x², x¹, x⁰)
+     * ```
+     */
+    polynomialCoefficients(variable?: string | string[]): ReadonlyArray<Expression> | undefined;
+    /**
+     * Return the roots of this expression treated as a polynomial in `variable`.
+     * Returns `undefined` if the expression is not a polynomial in the given
+     * variable. Returns an empty array if no roots can be found.
+     *
+     * If `variable` is omitted, auto-detects when the expression has exactly
+     * one unknown.
+     *
+     * ```typescript
+     * ce.parse('x^2 - 5x + 6').polynomialRoots('x')  // [2, 3]
+     * ce.parse('x^2 + 1').polynomialRoots('x')         // [] (no real roots)
+     * ce.parse('sin(x)').polynomialRoots('x')           // undefined
+     * ```
+     */
+    polynomialRoots(variable?: string): ReadonlyArray<Expression> | undefined;
     /**
      * The name of the operator of the expression.
      *
@@ -1078,6 +1128,15 @@ export interface Expression {
      * If this expression matches `pattern` but there are no named wildcards,
      * return the empty substitution, `{}`.
      *
+     * `pattern` can be:
+     * - A **string** (LaTeX): single-character symbols are auto-converted to
+     *   wildcards (e.g., `'ax^2+bx+c'` treats `a`, `b`, `c` as wildcards).
+     *   Results use unprefixed keys (`{a: 3}` not `{_a: 3}`) and self-matches
+     *   are filtered out. `useVariations` and `matchMissingTerms` default to
+     *   `true`. Unprefixed keys are accepted in `substitution`.
+     * - A **MathJSON array** (e.g., `['Add', '_a', '_b']`): boxed automatically.
+     * - A **BoxedExpression**: used directly.
+     *
      * Read more about [**patterns and rules**](/compute-engine/guides/patterns-and-rules/).
      *
      * :::info[Note]
@@ -1085,7 +1144,7 @@ export interface Expression {
      * :::
      *
      */
-    match(pattern: Expression, options?: PatternMatchOptions<Expression>): BoxedSubstitution<Expression> | null;
+    match(pattern: string | ExpressionInput, options?: PatternMatchOptions<Expression>): BoxedSubstitution<Expression> | null;
     /**
      *
      * The **shape** describes the **axes** of the expression, where each axis

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 import type { TypeReference } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString } from './latex-syntax/types';

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
 /**
  * Options to control serialization to MathJSON when using
@@ -74,6 +74,17 @@ export type PatternMatchOptions<T = unknown> = {
      * If false, operand order must match exactly.
      */
     matchPermutations?: boolean;
+    /**
+     * If true, allow matching when the expression has fewer operands than the
+     * pattern by treating missing terms as identity elements (0 for `Add`,
+     * 1 for `Multiply`). A free wildcard in a missing product term is set to 0
+     * (since 0 × anything = 0).
+     *
+     * For example, `3x²+5` matches `_a·x²+_b·x+_c` with `_b = 0`.
+     *
+     * **Default**: `true` when the pattern is a string, `false` otherwise.
+     */
+    matchMissingTerms?: boolean;
 };
 /**
  * Options for `Expression.replace()`.

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 import type { BoxedSubstitution as KernelBoxedSubstitution, CanonicalForm, CanonicalOptions, FormOption, Hold, JsonSerializationOptions, Metadata, PatternMatchOptions as KernelPatternMatchOptions, ReplaceOptions, Substitution as KernelSubstitution } from './types-kernel-serialization';
 export type { Hold, JsonSerializationOptions, ReplaceOptions, CanonicalForm, CanonicalOptions, FormOption, Metadata, };
 /**

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 export type { MathJsonExpression, MathJsonAttributes, MathJsonNumberObject, MathJsonSymbolObject, MathJsonStringObject, MathJsonFunctionObject, DictionaryValue, MathJsonDictionaryObject, ExpressionObject, MathJsonSymbol, } from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 export { ComputeEngine } from './compute-engine/index';
 export type * from './compute-engine/types';
 export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, ExecutableTarget, ComplexResult, CompiledRunner, ExpressionRunner, LambdaRunner, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
  * Return true if the string is a valid symbol.
  *
  * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
  * The following properties can be added to any MathJSON expression
  * to provide additional information about the expression.
  *

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

@@ -1,4 +1,4 @@
-/* 0.53.0 */
+/* 0.54.0 */
 export declare const MISSING: MathJsonExpression;
 export declare function isNumberExpression(expr: MathJsonExpression | null): expr is number | string | MathJsonNumberObject;
 export declare function isNumberObject(expr: MathJsonExpression | null): expr is MathJsonNumberObject;

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

@@ -1,3 +1,3 @@
-/* 0.53.0 */
+/* 0.54.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, stringValue, operator, operand, symbol, mapArgs, dictionaryFromExpression, } from './math-json/utils';
-export declare const version = "0.53.0";
+export declare const version = "0.54.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.53.0",
+  "version": "0.54.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -46,13 +46,13 @@
     ".": {
       "types": "./dist/types/compute-engine.d.ts",
       "import": "./dist/compute-engine.min.esm.js",
-      "require": "./dist/compute-engine.min.umd.js",
+      "require": "./dist/compute-engine.min.umd.cjs",
       "default": "./dist/compute-engine.min.esm.js"
     },
     "./math-json": {
       "types": "./dist/types/math-json.d.ts",
       "import": "./dist/math-json.min.esm.js",
-      "require": "./dist/math-json.min.umd.js",
+      "require": "./dist/math-json.min.umd.cjs",
       "default": "./dist/math-json.min.esm.js"
     }
   },