@cortex-js/compute-engine 0.52.0 → 0.53.0

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString, LatexDictionaryEntry } from './latex-syntax/types';
@@ -14,7 +14,7 @@ import type { EvaluateOptions as KernelEvaluateOptions, Rule as KernelRule, Boxe
  */
 export interface ComputeEngine {
 }
-type EvaluateOptions = KernelEvaluateOptions<Expression>;
+type EvaluateOptions = KernelEvaluateOptions;
 type Rule = KernelRule<Expression, ExpressionInput, ComputeEngine>;
 type BoxedRule = KernelBoxedRule<Expression, ComputeEngine>;
 type BoxedRuleSet = KernelBoxedRuleSet<Expression, ComputeEngine>;
@@ -723,12 +723,11 @@ export interface BoxedValueDefinition extends BoxedBaseDefinition {
       * **Default:** `evaluate`
       */
     holdUntil: 'never' | 'evaluate' | 'N';
-    /** This is either the initial value of the symbol (i.e. when a new
-     *  evaluation context is created), or its constant value, if a constant.
-     *  Otherwise, the current value is tracked in the evaluation context.
-     *
+    /** The current value of the symbol. For constants, this is immutable.
+     *  The definition object is the single source of truth — there is no
+     *  separate evaluation-context values map.
      */
-    readonly value: Expression | undefined;
+    value: Expression | undefined;
     eq?: (a: Expression) => boolean | undefined;
     neq?: (a: Expression) => boolean | undefined;
     cmp?: (a: Expression) => '=' | '>' | '<' | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonSymbol, MathJsonNumberObject } from '../math-json';
 import type { Type, TypeString, TypeResolver } from '../common/type/types';
@@ -219,16 +219,8 @@ export interface IComputeEngine extends IBigNum {
      * Use `ce.assign(id, value)` instead.
      * @internal */
     _setSymbolValue(id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
-    /**
-     * Set a value directly in the current context's values map.
-     * Used for assumptions so values are properly scoped.
-     * @internal */
-    _setCurrentContextValue(id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
     /** A list of the function calls to the current evaluation context */
     trace: ReadonlyArray<string>;
-    lookupContext(id: MathJsonSymbol): undefined | EvalContext;
-    /** @internal */
-    _swapContext(context: EvalContext): void;
     lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
     assign(ids: {
         [id: MathJsonSymbol]: AssignValue;

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { IComputeEngine as ComputeEngine } from './types-engine';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Assumption as KernelAssumption, AssumeResult, AssignValue as KernelAssignValue, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, EvaluateOptions as KernelEvaluateOptions, EvalContext as KernelEvalContext, ExpressionMapInterface as KernelExpressionMapInterface, Rule as KernelRule, RuleConditionFunction as KernelRuleConditionFunction, RuleFunction as KernelRuleFunction, RuleReplaceFunction as KernelRuleReplaceFunction, RuleStep as KernelRuleStep, RuleSteps as KernelRuleSteps, Scope as KernelScope } from './types-kernel-evaluation';
@@ -10,7 +10,7 @@ export type { AssumeResult };
  *
  * @category Boxed Expression
  */
-export type EvaluateOptions = KernelEvaluateOptions<Expression>;
+export type EvaluateOptions = KernelEvaluateOptions;
 /**
  * Map-like interface keyed by boxed expressions.
  *

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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';
@@ -47,7 +47,7 @@ interface BoxedBaseDefinition extends Partial<BaseDefinition> {
 }
 interface BoxedValueDefinition extends BoxedBaseDefinition {
     holdUntil: 'never' | 'evaluate' | 'N';
-    readonly value: Expression | undefined;
+    value: Expression | undefined;
     eq?: (a: Expression) => boolean | undefined;
     neq?: (a: Expression) => boolean | undefined;
     cmp?: (a: Expression) => '=' | '>' | '<' | undefined;
@@ -103,7 +103,7 @@ type BoxedDefinition = {
     operator: BoxedOperatorDefinition;
 };
 type Scope = KernelScope<BoxedDefinition>;
-type EvaluateOptions = KernelEvaluateOptions<Expression>;
+type EvaluateOptions = KernelEvaluateOptions;
 type Rule = KernelRule<Expression, ExpressionInput, ExpressionComputeEngine>;
 type BoxedRule = KernelBoxedRule<Expression, ExpressionComputeEngine>;
 type BoxedRuleSet = KernelBoxedRuleSet<Expression, ExpressionComputeEngine>;
@@ -868,6 +868,44 @@ export interface Expression {
      * Return this expression expressed as a numerator and denominator.
      */
     get numeratorDenominator(): [Expression, Expression];
+    /**
+     * Return the value of this expression as a pair of integer numerator and
+     * denominator, or `null` if the expression is not a rational number.
+     *
+     * - For a `BoxedNumber` with an exact rational value, extracts from the
+     *   numeric representation.
+     * - For an integer, returns `[n, 1]`.
+     * - For a `Divide` or `Rational` function with integer operands, returns
+     *   `[num, den]`.
+     * - For everything else, returns `null`.
+     *
+     * The returned rational is always in lowest terms.
+     *
+     * ```typescript
+     * ce.parse('\\frac{6}{4}').toRational()  // [3, 2]
+     * ce.parse('7').toRational()              // [7, 1]
+     * ce.parse('x + 1').toRational()          // null
+     * ce.number(1.5).toRational()             // null (machine float)
+     * ```
+     */
+    toRational(): [number, number] | null;
+    /**
+     * Return the multiplicative factors of this expression as a flat array.
+     *
+     * This is a structural decomposition — it does not perform algebraic
+     * factoring (use `ce.function('Factor', [expr])` for that).
+     *
+     * - `Multiply(a, b, c)` returns `[a, b, c]`
+     * - `Negate(x)` returns `[-1, ...x.factors()]`
+     * - Anything else returns `[expr]`
+     *
+     * ```typescript
+     * ce.parse('2xyz').factors()     // [2, x, y, z]
+     * ce.parse('-3x').factors()      // [-1, 3, x]
+     * ce.parse('x + 1').factors()    // [x + 1]
+     * ```
+     */
+    factors(): ReadonlyArray<Expression>;
     /**
      * The name of the operator of the expression.
      *
@@ -1000,24 +1038,35 @@ export interface Expression {
     isSame(rhs: Expression | number | bigint | boolean | string): boolean;
     /**
      * Smart equality check: structural first, then numeric evaluation fallback.
+     * Symmetric: `a.is(b)` always equals `b.is(a)`.
      *
      * First tries an exact structural check (same as `isSame()`). If that fails
      * and the expression is constant (no free variables), evaluates numerically
      * and compares within `engine.tolerance`.
      *
-     * For literal numbers (`BoxedNumber`), behaves identically to `isSame()` —
-     * no tolerance is applied. Tolerance only applies to expressions that
-     * require evaluation (e.g., `\\sin(\\pi)`).
+     * For literal numbers compared to primitives (`number`, `bigint`), behaves
+     * identically to `isSame()` — no tolerance is applied. Tolerance only
+     * applies to expressions that require evaluation (e.g., `\\sin(\\pi)`).
      *
      * ```typescript
      * ce.parse('\\cos(\\frac{\\pi}{2})').is(0)  // true — evaluates, within tolerance
      * ce.number(1e-17).is(0)                     // false — literal, no tolerance
-     * ce.parse('x + 1').is(1)                    // false — not constant
+     * ce.parse('x + 1').is(1)                    // false — has free variables
+     * ce.parse('\\pi').is(3.14, 0.01)            // true — within custom tolerance
      * ```
      *
+     * After the structural check, attempts to expand both sides (distributing
+     * products, applying the multinomial theorem, etc.) and re-checks
+     * structural equality. This catches equivalences like `(x+1)^2` vs
+     * `x^2+2x+1` even when the expression has free variables.
+     *
+     * @param tolerance - If provided, overrides `engine.tolerance` for the
+     * numeric comparison. Has no effect when the comparison is structural
+     * (i.e., when `isSame()` succeeds or the expression has free variables).
+     *
      * @category Primitive Methods
      */
-    is(other: Expression | number | bigint | boolean | string): boolean;
+    is(other: Expression | number | bigint | boolean | string, tolerance?: number): boolean;
     /**
      * If this expression matches `pattern`, return a substitution that makes
      * `pattern` equal to `this`. Otherwise return `null`.
@@ -1568,6 +1617,7 @@ export interface Expression {
  */
 export interface NumberLiteralInterface {
     readonly numericValue: number | NumericValue;
+    readonly isExact: boolean;
     readonly isNumberLiteral: true;
 }
 /**

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { TypeReference } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString } from './latex-syntax/types';
@@ -43,7 +43,7 @@ export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction
  *
  * @category Boxed Expression
  */
-export type EvaluateOptions<Expr = unknown> = {
+export type EvaluateOptions = {
     /**
      * If `true`, the evaluation returns a numeric approximation of the expression,
      * when possible.
@@ -69,10 +69,6 @@ export type EvaluateOptions<Expr = unknown> = {
     materialization: boolean | number | [number, number];
     /** Cancellation signal for long-running evaluations. */
     signal: AbortSignal;
-    /**
-     * Temporary named argument bindings used while evaluating this expression.
-     */
-    withArguments: Record<MathJsonSymbol, Expr>;
 };
 /**
  * Given an expression and set of wildcards, return a replacement expression.
@@ -146,7 +142,7 @@ export type BoxedRuleSet<Expr = unknown, CE = unknown> = {
  *
  * @category Compute Engine
  */
-export type AssignValue<Expr = unknown, SemiExpr = unknown, CE = unknown> = boolean | number | bigint | SemiExpr | ((args: ReadonlyArray<Expr>, options: EvaluateOptions<Expr> & {
+export type AssignValue<Expr = unknown, SemiExpr = unknown, CE = unknown> = boolean | number | bigint | SemiExpr | ((args: ReadonlyArray<Expr>, options: EvaluateOptions & {
     engine: CE;
 }) => Expr) | undefined;
 /** @category Definitions */
@@ -154,11 +150,12 @@ export type Scope<Binding = unknown> = {
     parent: Scope<Binding> | null;
     bindings: Map<string, Binding>;
     types?: Record<string, TypeReference>;
+    /** When true, auto-declarations during canonicalization are promoted to parent scope. */
+    noAutoDeclare?: boolean;
 };
 /** @category Compute Engine */
 export type EvalContext<Expr = unknown, Binding = unknown> = {
     lexicalScope: Scope<Binding>;
     assumptions: ExpressionMapInterface<boolean, Expr>;
-    values: Record<string, Expr | undefined>;
     name: undefined | string;
 };

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
 /**
  * Options to control serialization to MathJSON when using

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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';
@@ -8,8 +8,6 @@ export { GLSLTarget } from './compute-engine/compilation/glsl-target';
 export { WGSLTarget } from './compute-engine/compilation/wgsl-target';
 export { PythonTarget } from './compute-engine/compilation/python-target';
 export { IntervalJavaScriptTarget } from './compute-engine/compilation/interval-javascript-target';
-export { IntervalGLSLTarget } from './compute-engine/compilation/interval-glsl-target';
-export { IntervalWGSLTarget } from './compute-engine/compilation/interval-wgsl-target';
 export { BaseCompiler } from './compute-engine/compilation/base-compiler';
 export type { Interval, IntervalResult, BoolInterval, } from './compute-engine/interval/types';
 export { parse, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './compute-engine/free-functions';

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, stringValue, operator, operand, symbol, mapArgs, dictionaryFromExpression, } from './math-json/utils';
-export declare const version = "0.52.0";
+export declare const version = "0.53.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.52.0",
+  "version": "0.53.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -69,33 +69,33 @@
     "@cortex-js/prettier-config": "^1.2.0",
     "@jest/console": "^29.7.0",
     "@types/jest": "^29.5.5",
-    "@types/node": "^24.0.13",
-    "@typescript-eslint/eslint-plugin": "^7.14.1",
-    "@typescript-eslint/parser": "^7.14.1",
-    "@typescript-eslint/typescript-estree": "^7.14.1",
-    "chalk": "^5.3.0",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "@typescript-eslint/typescript-estree": "^8.56.0",
+    "chalk": "^5.6.2",
     "check-node-version": "^4.2.1",
     "concat-md": "^0.5.1",
-    "esbuild": "^0.25.8",
+    "esbuild": "^0.27.3",
     "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-no-unsanitized": "^4.0.2",
-    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-no-unsanitized": "^4.1.5",
+    "eslint-plugin-prettier": "^5.5.5",
     "jest": "^29.7.0",
     "jest-silent-reporter": "^0.6.0",
     "madge": "^8.0.0",
-    "open": "^10.1.2",
-    "prettier": "^3.6.2",
+    "open": "^11.0.0",
+    "prettier": "^3.8.1",
     "prettier-2": "npm:prettier@^2.8.8",
     "serve-http": "^1.0.7",
-    "ts-jest": "^29.4.0",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.28.8",
-    "typedoc-plugin-markdown": "^4.8.0",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-markdown": "^4.10.0",
     "typedoc-plugin-no-inherit": "^1.6.1",
-    "typescript": "^5.8.3",
-    "update-notifier": "^7.0.0"
+    "typescript": "^5.9.3",
+    "update-notifier": "^7.3.1"
   },
   "prettier": "@cortex-js/prettier-config",
   "dependencies": {

package/dist/types/compute-engine/compilation/interval-glsl-target.d.ts

@@ -1,51 +0,0 @@
-/* 0.52.0 */
- * GLSL interval arithmetic compilation target
- *
- * Compiles mathematical expressions to GLSL code using interval arithmetic
- * for reliable function evaluation in shaders.
- *
- * Intervals are represented as vec2(lo, hi).
- * Status flags use float constants for shader compatibility.
- *
- * @module compilation/interval-glsl-target
- */
-import type { Expression } from '../global-types';
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
-/**
- * GLSL interval arithmetic target implementation.
- */
-export declare class IntervalGLSLTarget implements LanguageTarget<Expression> {
-    getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions<Expression>;
-    /**
-     * Get the GLSL interval library code.
-     *
-     * This should be included in shaders that use interval arithmetic.
-     */
-    getLibrary(): string;
-    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'interval-glsl'>;
-    /**
-     * Compile an expression to GLSL interval code string.
-     */
-    compileToSource(expr: Expression, _options?: CompilationOptions<Expression>): string;
-    /**
-     * Create a complete GLSL interval function from an expression.
-     *
-     * @param expr - The expression to compile
-     * @param functionName - Name of the GLSL function
-     * @param parameters - Parameter names (each becomes a vec2 interval input)
-     */
-    compileFunction(expr: Expression, functionName: string, parameters: string[]): string;
-    /**
-     * Create a complete GLSL fragment shader for interval function plotting.
-     *
-     * @param expr - The expression to compile
-     * @param options - Shader options
-     */
-    compileShaderFunction(expr: Expression, options?: {
-        functionName?: string;
-        version?: string;
-        parameters?: string[];
-    }): string;
-}

package/dist/types/compute-engine/compilation/interval-wgsl-target.d.ts

@@ -1,54 +0,0 @@
-/* 0.52.0 */
- * WGSL interval arithmetic compilation target
- *
- * Compiles mathematical expressions to WGSL code using interval arithmetic
- * for reliable function evaluation in WebGPU shaders.
- *
- * Intervals are represented as vec2f(lo, hi).
- * Status flags use f32 constants for shader compatibility.
- *
- * Since WGSL does not support function overloading, internal vec2f-parameter
- * implementations use a `_v` suffix (e.g., `ia_add_v`), while the public
- * IntervalResult wrappers keep the base name (e.g., `ia_add`).
- *
- * @module compilation/interval-wgsl-target
- */
-import type { Expression } from '../global-types';
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
-/**
- * WGSL interval arithmetic target implementation.
- */
-export declare class IntervalWGSLTarget implements LanguageTarget<Expression> {
-    getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions<Expression>;
-    /**
-     * Get the WGSL interval library code.
-     *
-     * This should be included in shaders that use interval arithmetic.
-     */
-    getLibrary(): string;
-    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'interval-wgsl'>;
-    /**
-     * Compile an expression to WGSL interval code string.
-     */
-    compileToSource(expr: Expression, _options?: CompilationOptions<Expression>): string;
-    /**
-     * Create a complete WGSL interval function from an expression.
-     *
-     * @param expr - The expression to compile
-     * @param functionName - Name of the WGSL function
-     * @param parameters - Parameter names (each becomes a vec2f interval input)
-     */
-    compileFunction(expr: Expression, functionName: string, parameters: string[]): string;
-    /**
-     * Create a complete WGSL compute shader for interval function evaluation.
-     *
-     * @param expr - The expression to compile
-     * @param options - Shader options
-     */
-    compileShaderFunction(expr: Expression, options?: {
-        functionName?: string;
-        parameters?: string[];
-    }): string;
-}