@cortex-js/compute-engine 0.35.6 → 0.50.1

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * Fu Algorithm Transformation Rules
  *
  * Programmatic implementations of TR1-TR22 from the Fu trigonometric
@@ -14,117 +14,117 @@
  * IMPORTANT: These functions should NOT call .simplify() on their results
  * to avoid infinite recursion when called from the simplification pipeline.
  */
-import type { BoxedExpression } from '../global-types';
+import type { Expression } from '../global-types';
 /**
  * Check if an expression contains any trigonometric functions
  */
-export declare function hasTrigFunction(expr: BoxedExpression): boolean;
+export declare function hasTrigFunction(expr: Expression): boolean;
 /**
  * Check if expression contains specific operators anywhere in the tree
  */
-export declare function hasOperator(expr: BoxedExpression, ...ops: string[]): boolean;
-export declare function TR1(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function hasOperator(expr: Expression, ...ops: string[]): boolean;
+export declare function TR1(expr: Expression): Expression | undefined;
 /**
  * Apply TR1 to all subexpressions
  */
-export declare function applyTR1(expr: BoxedExpression): BoxedExpression;
-export declare function TR2(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR1(expr: Expression): Expression;
+export declare function TR2(expr: Expression): Expression | undefined;
 /**
  * Apply TR2 to all subexpressions
  */
-export declare function applyTR2(expr: BoxedExpression): BoxedExpression;
-export declare function TR2i(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR2(expr: Expression): Expression;
+export declare function TR2i(expr: Expression): Expression | undefined;
 /**
  * Apply TR2i to all subexpressions
  */
-export declare function applyTR2i(expr: BoxedExpression): BoxedExpression;
-export declare function TR3(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR2i(expr: Expression): Expression;
+export declare function TR3(expr: Expression): Expression | undefined;
 /**
  * Apply TR3 to all subexpressions
  */
-export declare function applyTR3(expr: BoxedExpression): BoxedExpression;
-export declare function TR5(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR3(expr: Expression): Expression;
+export declare function TR5(expr: Expression): Expression | undefined;
 /**
  * Apply TR5 to all subexpressions
  */
-export declare function applyTR5(expr: BoxedExpression): BoxedExpression;
-export declare function TR6(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR5(expr: Expression): Expression;
+export declare function TR6(expr: Expression): Expression | undefined;
 /**
  * Apply TR6 to all subexpressions
  */
-export declare function applyTR6(expr: BoxedExpression): BoxedExpression;
-export declare function TR7(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR6(expr: Expression): Expression;
+export declare function TR7(expr: Expression): Expression | undefined;
 /**
  * Apply TR7 to all subexpressions
  */
-export declare function applyTR7(expr: BoxedExpression): BoxedExpression;
-export declare function TR7i(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR7(expr: Expression): Expression;
+export declare function TR7i(expr: Expression): Expression | undefined;
 /**
  * Apply TR7i to all subexpressions
  */
-export declare function applyTR7i(expr: BoxedExpression): BoxedExpression;
-export declare function TR8(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR7i(expr: Expression): Expression;
+export declare function TR8(expr: Expression): Expression | undefined;
 /**
  * Apply TR8 to all subexpressions
  */
-export declare function applyTR8(expr: BoxedExpression): BoxedExpression;
-export declare function TR9(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR8(expr: Expression): Expression;
+export declare function TR9(expr: Expression): Expression | undefined;
 /**
  * Apply TR9 to all subexpressions
  */
-export declare function applyTR9(expr: BoxedExpression): BoxedExpression;
-export declare function TR10(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR9(expr: Expression): Expression;
+export declare function TR10(expr: Expression): Expression | undefined;
 /**
  * Apply TR10 to all subexpressions
  */
-export declare function applyTR10(expr: BoxedExpression): BoxedExpression;
-export declare function TR10i(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR10(expr: Expression): Expression;
+export declare function TR10i(expr: Expression): Expression | undefined;
 /**
  * Apply TR10i to all subexpressions
  */
-export declare function applyTR10i(expr: BoxedExpression): BoxedExpression;
-export declare function TR11(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR10i(expr: Expression): Expression;
+export declare function TR11(expr: Expression): Expression | undefined;
 /**
  * Apply TR11 to all subexpressions
  */
-export declare function applyTR11(expr: BoxedExpression): BoxedExpression;
-export declare function TR11i(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR11(expr: Expression): Expression;
+export declare function TR11i(expr: Expression): Expression | undefined;
 /**
  * Apply TR11i to all subexpressions
  */
-export declare function applyTR11i(expr: BoxedExpression): BoxedExpression;
-export declare function TR12(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR11i(expr: Expression): Expression;
+export declare function TR12(expr: Expression): Expression | undefined;
 /**
  * Apply TR12 to all subexpressions
  */
-export declare function applyTR12(expr: BoxedExpression): BoxedExpression;
-export declare function TR12i(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR12(expr: Expression): Expression;
+export declare function TR12i(expr: Expression): Expression | undefined;
 /**
  * Apply TR12i to all subexpressions
  */
-export declare function applyTR12i(expr: BoxedExpression): BoxedExpression;
-export declare function TR13(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR12i(expr: Expression): Expression;
+export declare function TR13(expr: Expression): Expression | undefined;
 /**
  * Apply TR13 to all subexpressions
  */
-export declare function applyTR13(expr: BoxedExpression): BoxedExpression;
-export declare function TR22(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR13(expr: Expression): Expression;
+export declare function TR22(expr: Expression): Expression | undefined;
 /**
  * Apply TR22 to all subexpressions
  */
-export declare function applyTR22(expr: BoxedExpression): BoxedExpression;
-export declare function TR22i(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR22(expr: Expression): Expression;
+export declare function TR22i(expr: Expression): Expression | undefined;
 /**
  * Apply TR22i to all subexpressions
  */
-export declare function applyTR22i(expr: BoxedExpression): BoxedExpression;
-export declare function TRmorrie(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTR22i(expr: Expression): Expression;
+export declare function TRmorrie(expr: Expression): Expression | undefined;
 /**
  * Apply TRmorrie to all subexpressions
  */
-export declare function applyTRmorrie(expr: BoxedExpression): BoxedExpression;
-export declare function TRpythagorean(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function applyTRmorrie(expr: Expression): Expression;
+export declare function TRpythagorean(expr: Expression): Expression | undefined;
 /**
  * Apply TRpythagorean to all subexpressions
  */
-export declare function applyTRpythagorean(expr: BoxedExpression): BoxedExpression;
+export declare function applyTRpythagorean(expr: Expression): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * Fu Algorithm for Trigonometric Simplification
  *
  * Implementation of the algorithm by Fu, Zhong, and Zeng:
@@ -9,7 +9,7 @@
  * combination transforms (CTR), and rule lists (RL) to simplify
  * trigonometric expressions.
  */
-import type { BoxedExpression, RuleStep } from '../global-types';
+import type { Expression, RuleStep } from '../global-types';
 import { TrigCostFunction } from './fu-cost';
 export interface FuOptions {
     /**
@@ -38,11 +38,11 @@ export interface FuOptions {
  * @param options Configuration options
  * @returns RuleStep with simplified expression, or undefined if no simplification
  */
-export declare function fu(expr: BoxedExpression, options?: FuOptions): RuleStep | undefined;
+export declare function fu(expr: Expression, options?: FuOptions): RuleStep | undefined;
 /**
  * Simplified entry point that returns the expression directly.
  */
-export declare function fuSimplify(expr: BoxedExpression, options?: FuOptions): BoxedExpression;
+export declare function fuSimplify(expr: Expression, options?: FuOptions): Expression;
 export { hasTrigFunction, hasOperator } from './fu-transforms';
 export { trigCost, countTrigFunctions, countLeaves } from './fu-cost';
 export type { TrigCostFunction } from './fu-cost';

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

@@ -0,0 +1,54 @@
+/* 0.50.1 */
+export declare function evaluateAnd(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateOr(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateNot(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateEquivalent(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateImplies(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateXor(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateNand(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+export declare function evaluateNor(args: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | undefined;
+/**
+ * Convert a boolean expression to Negation Normal Form (NNF).
+ * In NNF, negations only appear directly before variables (literals).
+ * This is a prerequisite for CNF/DNF conversion.
+ */
+export declare function toNNF(expr: Expression, ce: ComputeEngine): Expression;
+/**
+ * Convert a boolean expression to Conjunctive Normal Form (CNF).
+ */
+export declare function toCNF(expr: Expression, ce: ComputeEngine): Expression;
+/**
+ * Convert a boolean expression to Disjunctive Normal Form (DNF).
+ */
+export declare function toDNF(expr: Expression, ce: ComputeEngine): Expression;
+/**
+ * Extract all propositional variables from a boolean expression.
+ * Returns a sorted array of unique variable names.
+ */
+export declare function extractVariables(expr: Expression): string[];
+/**
+ * Evaluate a boolean expression with a given truth assignment.
+ * Returns True, False, or undefined if the expression cannot be evaluated.
+ */
+export declare function evaluateWithAssignment(expr: Expression, assignment: Record<string, boolean>, ce: ComputeEngine): Expression;
+/**
+ * Generate all possible truth assignments for a list of variables.
+ * Each assignment is a Record mapping variable names to boolean values.
+ */
+export declare function generateAssignments(variables: string[]): Generator<Record<string, boolean>>;

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -1,12 +1,12 @@
-/* 0.35.6 */
-export declare function simplifyAbs(x: BoxedExpression): RuleStep | undefined;
+/* 0.50.1 */
+export declare function simplifyAbs(x: Expression): RuleStep | undefined;
 /**
  * Simplify expressions where Abs appears as the base of a power.
  * |x|^n -> x^n when n is even
  */
-export declare function simplifyAbsPower(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyAbsPower(x: Expression): RuleStep | undefined;
 /**
  * Even functions: f(|x|) -> f(x)
  * This rule handles Cos, Sec, Cosh, Sech with Abs argument
  */
-export declare function simplifyEvenFunctionAbs(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyEvenFunctionAbs(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Division simplification rules consolidated from simplify-rules.ts.
  * Handles ~5 patterns for simplifying Divide expressions.
@@ -12,4 +12,4 @@
  *
  * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
  */
-export declare function simplifyDivide(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyDivide(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
-export declare function simplifyHyperbolic(x: BoxedExpression): RuleStep | undefined;
+/* 0.50.1 */
+export declare function simplifyHyperbolic(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Infinity simplification rules consolidated from simplify-rules.ts.
  * Handles ~20 patterns for simplifying expressions involving infinity.
@@ -11,4 +11,4 @@
  *
  * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
  */
-export declare function simplifyInfinity(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyInfinity(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Logarithm simplification rules consolidated from simplify-rules.ts.
  * Handles ~30 patterns for simplifying Ln and Log expressions.
@@ -12,4 +12,4 @@
  *
  * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
  */
-export declare function simplifyLog(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyLog(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-logic.d.ts

@@ -0,0 +1,5 @@
+/* 0.50.1 */
+export declare function simplifyLogicFunction(x: Expression): {
+    value: Expression;
+    because: string;
+} | undefined;

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Power simplification rules consolidated from simplify-rules.ts.
  * Handles ~25 patterns for simplifying Power expressions.
@@ -12,4 +12,4 @@
  *
  * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
  */
-export declare function simplifyPower(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyPower(x: Expression): RuleStep | undefined;

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

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.
  */
-export declare function simplifyProduct(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifyProduct(x: Expression): RuleStep | undefined;

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

@@ -1,4 +1,65 @@
-/* 0.35.6 */
+/* 0.50.1 */
+/**
+ * # Performance Optimization Notes for Simplification Rules
+ *
+ * This file contains rules that are applied repeatedly during simplification.
+ * Performance is critical here. Keep these guidelines in mind when writing
+ * or optimizing rules:
+ *
+ * ## 1. Use `_fn()` instead of `function()` when operands are already canonical
+ *
+ * When creating expressions in rule replacements, the operands (from pattern
+ * matching like `ids._x`) are already canonical. Using `_fn()` bypasses
+ * re-canonicalization and avoids potential recursion issues:
+ *
+ * ```typescript
+ * // Slower - re-canonicalizes operands:
+ * replace: (expr, ids) => expr.engine.function('Sin', [ids._x])
+ *
+ * // Faster - operands already canonical:
+ * replace: (expr, ids) => expr.engine._fn('Sin', [ids._x])
+ * ```
+ *
+ * Note: For n-ary operators like Add/Multiply that need flattening or sorting,
+ * `function()` may still be necessary.
+ *
+ * ## 2. Avoid LaTeX strings - prefer MathJSON patterns
+ *
+ * LaTeX strings require parsing which is costly. Use MathJSON arrays instead:
+ *
+ * ```typescript
+ * // Slower - requires LaTeX parsing:
+ * '\\sin(x) -> \\cos(x)'
+ *
+ * // Faster - direct MathJSON:
+ * { match: ['Sin', '_x'], replace: (expr, ids) => expr.engine._fn('Cos', [ids._x]) }
+ * ```
+ *
+ * The `match -> replace` string syntax is convenient for prototyping but should
+ * be converted to MathJSON for production rules.
+ *
+ * ## 3. Use functional rules for quick applicability checks
+ *
+ * Pattern matching has overhead. For rules that only apply to specific operators,
+ * use the functional form to do a quick check first:
+ *
+ * ```typescript
+ * // Pattern matching approach - always attempts match:
+ * { match: ['Abs', ['Negate', '_x']], replace: ... }
+ *
+ * // Functional approach - quick bailout if not applicable:
+ * (x): RuleStep | undefined => {
+ *   if (x.operator !== 'Abs') return undefined;
+ *   if (x.op1.operator !== 'Negate') return undefined;
+ *   return { value: x.engine._fn('Abs', [x.op1.op1]), because: 'abs-negate' };
+ * }
+ * ```
+ *
+ * ## 4. Use helper functions for common replacements
+ *
+ * The helper functions below (toNaN, toZero, etc.) avoid creating new
+ * expressions and improve performance for common constant replacements.
+ */
 /**
  * A set of simplification rules.
  *
@@ -8,10 +69,10 @@
  *
  * where `lhs` is rewritten as `rhs` if `condition` is true.
  *
- * `lhs` and `rhs` can be either an Expression or a LaTeX string.
+ * `lhs` and `rhs` can be either an MathJsonExpression 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,
+ * If using an MathJsonExpression, the expression is *not* canonicalized before being
+ * used. Therefore in some cases using MathJsonExpression, 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/simplify-sum.d.ts

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.
  */
-export declare function simplifySum(x: BoxedExpression): RuleStep | undefined;
+export declare function simplifySum(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
-export declare function simplifyTrig(x: BoxedExpression): RuleStep | undefined;
+/* 0.50.1 */
+export declare function simplifyTrig(x: Expression): RuleStep | undefined;

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-import { BoxedExpression, ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
+/* 0.50.1 */
+import { Expression, IComputeEngine as ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;
 /** @category Tensors */
@@ -16,7 +16,7 @@ export declare class TensorFieldNumber implements TensorField<number> {
     cast(x: number, dtype: 'complex128'): undefined | Complex;
     cast(x: number, dtype: 'complex64'): undefined | Complex;
     cast(x: number, dtype: 'bool'): undefined | boolean;
-    cast(x: number, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: number, dtype: 'expression'): undefined | Expression;
     cast(x: number[], dtype: 'float64'): undefined | number[];
     cast(x: number[], dtype: 'float32'): undefined | number[];
     cast(x: number[], dtype: 'int32'): undefined | number[];
@@ -24,8 +24,8 @@ export declare class TensorFieldNumber implements TensorField<number> {
     cast(x: number[], dtype: 'complex128'): undefined | Complex[];
     cast(x: number[], dtype: 'complex64'): undefined | Complex[];
     cast(x: number[], dtype: 'bool'): undefined | boolean[];
-    cast(x: number[], dtype: 'expression'): undefined | BoxedExpression[];
-    expression(x: number): BoxedExpression;
+    cast(x: number[], dtype: 'expression'): undefined | Expression[];
+    expression(x: number): Expression;
     isZero(x: number): boolean;
     isOne(x: number): boolean;
     equals(lhs: number, rhs: number): boolean;
@@ -40,41 +40,41 @@ export declare class TensorFieldNumber implements TensorField<number> {
     conjugate(x: number): number;
 }
 /** @category Tensors */
-export declare class TensorFieldExpression implements TensorField<BoxedExpression> {
-    one: BoxedExpression;
-    zero: BoxedExpression;
-    nan: BoxedExpression;
+export declare class TensorFieldExpression implements TensorField<Expression> {
+    one: Expression;
+    zero: Expression;
+    nan: Expression;
     private ce;
     constructor(ce: ComputeEngine);
-    cast(x: BoxedExpression, dtype: 'float64'): undefined | number;
-    cast(x: BoxedExpression, dtype: 'float32'): undefined | number;
-    cast(x: BoxedExpression, dtype: 'int32'): undefined | number;
-    cast(x: BoxedExpression, dtype: 'uint8'): undefined | number;
-    cast(x: BoxedExpression, dtype: 'complex128'): undefined | Complex;
-    cast(x: BoxedExpression, dtype: 'complex64'): undefined | Complex;
-    cast(x: BoxedExpression, dtype: 'bool'): undefined | boolean;
-    cast(x: BoxedExpression, dtype: 'expression'): undefined | BoxedExpression;
-    cast(x: BoxedExpression[], dtype: 'float64'): undefined | number[];
-    cast(x: BoxedExpression[], dtype: 'float32'): undefined | number[];
-    cast(x: BoxedExpression[], dtype: 'int32'): undefined | number[];
-    cast(x: BoxedExpression[], dtype: 'uint8'): undefined | number[];
-    cast(x: BoxedExpression[], dtype: 'complex128'): undefined | Complex[];
-    cast(x: BoxedExpression[], dtype: 'complex64'): undefined | Complex[];
-    cast(x: BoxedExpression[], dtype: 'bool'): undefined | boolean[];
-    cast(x: BoxedExpression[], dtype: 'expression'): undefined | BoxedExpression[];
-    expression(x: BoxedExpression): BoxedExpression;
-    isZero(x: BoxedExpression): boolean;
-    isOne(x: BoxedExpression): boolean;
-    equals(lhs: BoxedExpression, rhs: BoxedExpression): boolean;
-    add(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
-    addn(...xs: BoxedExpression[]): BoxedExpression;
-    neg(x: BoxedExpression): BoxedExpression;
-    sub(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
-    mul(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
-    muln(...xs: BoxedExpression[]): BoxedExpression;
-    div(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
-    pow(lhs: BoxedExpression, rhs: number): BoxedExpression;
-    conjugate(x: BoxedExpression): BoxedExpression;
+    cast(x: Expression, dtype: 'float64'): undefined | number;
+    cast(x: Expression, dtype: 'float32'): undefined | number;
+    cast(x: Expression, dtype: 'int32'): undefined | number;
+    cast(x: Expression, dtype: 'uint8'): undefined | number;
+    cast(x: Expression, dtype: 'complex128'): undefined | Complex;
+    cast(x: Expression, dtype: 'complex64'): undefined | Complex;
+    cast(x: Expression, dtype: 'bool'): undefined | boolean;
+    cast(x: Expression, dtype: 'expression'): undefined | Expression;
+    cast(x: Expression[], dtype: 'float64'): undefined | number[];
+    cast(x: Expression[], dtype: 'float32'): undefined | number[];
+    cast(x: Expression[], dtype: 'int32'): undefined | number[];
+    cast(x: Expression[], dtype: 'uint8'): undefined | number[];
+    cast(x: Expression[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: Expression[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: Expression[], dtype: 'bool'): undefined | boolean[];
+    cast(x: Expression[], dtype: 'expression'): undefined | Expression[];
+    expression(x: Expression): Expression;
+    isZero(x: Expression): boolean;
+    isOne(x: Expression): boolean;
+    equals(lhs: Expression, rhs: Expression): boolean;
+    add(lhs: Expression, rhs: Expression): Expression;
+    addn(...xs: Expression[]): Expression;
+    neg(x: Expression): Expression;
+    sub(lhs: Expression, rhs: Expression): Expression;
+    mul(lhs: Expression, rhs: Expression): Expression;
+    muln(...xs: Expression[]): Expression;
+    div(lhs: Expression, rhs: Expression): Expression;
+    pow(lhs: Expression, rhs: number): Expression;
+    conjugate(x: Expression): Expression;
 }
 /** @category Tensors */
 export declare class TensorFieldComplex implements TensorField<Complex> {
@@ -90,7 +90,7 @@ export declare class TensorFieldComplex implements TensorField<Complex> {
     cast(x: Complex, dtype: 'complex128'): undefined | Complex;
     cast(x: Complex, dtype: 'complex64'): undefined | Complex;
     cast(x: Complex, dtype: 'bool'): undefined | boolean;
-    cast(x: Complex, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: Complex, dtype: 'expression'): undefined | Expression;
     cast(x: Complex[], dtype: 'float64'): undefined | number[];
     cast(x: Complex[], dtype: 'float32'): undefined | number[];
     cast(x: Complex[], dtype: 'int32'): undefined | number[];
@@ -98,8 +98,8 @@ export declare class TensorFieldComplex implements TensorField<Complex> {
     cast(x: Complex[], dtype: 'complex128'): undefined | Complex[];
     cast(x: Complex[], dtype: 'complex64'): undefined | Complex[];
     cast(x: Complex[], dtype: 'bool'): undefined | boolean[];
-    cast(x: Complex[], dtype: 'expression'): undefined | BoxedExpression[];
-    expression(z: Complex): BoxedExpression;
+    cast(x: Complex[], dtype: 'expression'): undefined | Expression[];
+    expression(z: Complex): Expression;
     isZero(z: Complex): boolean;
     isOne(z: Complex): boolean;
     equals(lhs: Complex, rhs: Complex): boolean;
@@ -125,4 +125,4 @@ export declare function getSupertype(t1: TensorDataType | undefined, t2: TensorD
  * @category Tensors
  * @internal
  */
-export declare function getExpressionDatatype(expr: BoxedExpression): TensorDataType;
+export declare function getExpressionDatatype(expr: Expression): TensorDataType;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;
@@ -33,10 +33,10 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
     constructor(ce: ComputeEngine, tensorData: TensorData<DT>);
     abstract get dtype(): DT;
     abstract get data(): DataTypeMap[DT][];
-    get expression(): BoxedExpression;
+    get expression(): Expression;
     /**
      * Like expression(), but return a nested JS array instead
-     * of a BoxedExpression
+     * of a Expression
      */
     get array(): NestedArray<DataTypeMap[DT]>;
     /** Indices are 1-based, return a 0-based index in the data */
@@ -79,7 +79,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
     inverse(): undefined | AbstractTensor<DT>;
     pseudoInverse(): undefined | AbstractTensor<DT>;
     adjugateMatrix(): undefined | AbstractTensor<DT>;
-    minor(i: number, j: number): undefined | DataTypeMap[DT];
+    minor(_i: number, _j: number): undefined | DataTypeMap[DT];
     map1(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], scalar: DataTypeMap[DT]): AbstractTensor<DT>;
     map2(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], rhs: AbstractTensor<DT>): AbstractTensor<DT>;
     add(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;