@cortex-js/compute-engine 0.21.0 → 0.22.0

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

@@ -1,3 +1,3 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export type CanonicalArithmeticFunctions = 'Add' | 'Negate' | 'Sqrt' | 'Multiply' | 'Divide' | 'Power' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,3 +1,3 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const CONTROL_STRUCTURES_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,3 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const CORE_LIBRARY: IdentifierDefinitions[];
+export declare function canonicalInvisibleOperator(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression | null;

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
     Functions: (string | string[])[];

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 import { FunctionDefinition, IComputeEngine, IdentifierDefinitions, SymbolDefinition } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
 export declare const LIBRARIES: {

package/dist/types/compute-engine/library/linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const LINEAR_ALGEBRA_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const LOGIC_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const POLYNOMIALS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare function randomExpression(level?: number): Expression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const RELOP_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const SETS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const STATISTICS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const TRIGONOMETRY_LIBRARY: IdentifierDefinitions[];

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

@@ -1,14 +1,14 @@
-/* 0.21.0 */
+/* 0.22.0 */
 /**
  * Assume the caller has setup a scope. The index
  * variable will be declared in that scope.
  *
- * @param limits
+ * @param indexingSet
  *
  */
-export declare function canonicalLimits(limits: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function canonicalIndexingSet(indexingSet: BoxedExpression | undefined): BoxedExpression | undefined;
 /**
- * Limits is an expression describing an index variable
+ * IndexingSet is an expression describing an index variable
  * and a range of values for that variable.
  *
  * This can take several valid forms:
@@ -21,7 +21,7 @@ export declare function canonicalLimits(limits: BoxedExpression | undefined): Bo
  * @param limits
  * @returns
  */
-export declare function normalizeLimits(limits: BoxedExpression | undefined): [
+export declare function normalizeIndexingSet(limits: BoxedExpression | undefined): [
     index: string | undefined,
     lower: number,
     upper: number,

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint;
 export declare function gcd(a: bigint, b: bigint): bigint;
 export declare function lcm(a: bigint, b: bigint): bigint;

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;

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

@@ -1,2 +1,2 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare function isPrime(n: number): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [number, number];
 export declare function isBigRational(x: any | null): x is [bigint, bigint];

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -91,40 +91,39 @@ export type BoxedSubstitution = Substitution<BoxedExpression>;
  * `"$\frac{\pi}{2}$"`.
  */
 export type LatexString = string;
+export type PatternReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression;
+export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: IComputeEngine) => boolean;
 /**
- *  A rule describes how to modify an expressions that matches a `lhs` pattern
- * into a new expressions matching `rhs`.
+ *  A rule describes how to modify an expressions that matches a pattern `match`
+ * into a new expression `replace`.
  *
  * `x-1` \( \to \) `1-x`
  * `(x+1)(x-1)` \( \to \) `x^2-1
  *
- * The `lhs` can be expressed as a LaTeX string or a MathJSON expression.
+ * The `match` pattern can be expressed as a LaTeX string or a MathJSON expression.
  *
- * Unbound variables (`x`, but not `Pi`) are matched structurally with a
- * a target expression, then the expression is rewritten as the `rhs`, with
- * the corresponding unbound variables in the `rhs` replaced by their values
- * in the `lhs.
  *
- * Pattern symbols (e.g. `_1`, `_a`) can be used as well.
+ * Anonymous wildcards (`_`) will match any
+ * expression. Named wildcards (`_x`, `_a`, etc...) will match any expression
+ * and bind the expression to the wildcard name.
  *
- * In addition:
- *  - `__1` (`__a`, etc..) match a sequence of one or more expressions
- *  - `___1` (`___a`, etc...) match a sequence of zero or more expressions
+ * In addition the sequence wildcard (`__1`, `__a`, etc...) will match a sequence
+ * of one or more expressions, and bind the sequence to the wildcard name.
  */
-export type Rule = [
-    lhs: LatexString | SemiBoxedExpression | Pattern,
-    rhs: LatexString | SemiBoxedExpression,
-    options?: {
-        condition?: LatexString | ((wildcards: BoxedSubstitution) => boolean);
-        priority?: number;
-    }
-];
-export type BoxedRule = [
-    lhs: Pattern,
-    rhs: BoxedExpression,
-    priority: number,
-    condition: undefined | ((wildcards: BoxedSubstitution) => boolean)
-];
+export type Rule = {
+    match: LatexString | SemiBoxedExpression | Pattern;
+    replace: LatexString | SemiBoxedExpression | PatternReplaceFunction;
+    condition?: LatexString | PatternConditionFunction;
+    priority?: number;
+    id?: string;
+};
+export type BoxedRule = {
+    match: Pattern;
+    replace: BoxedExpression | PatternReplaceFunction;
+    condition: undefined | PatternConditionFunction;
+    priority: number;
+    id?: string;
+};
 export type BoxedRuleSet = Set<BoxedRule>;
 export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 /** A domain constructor is the head of a domain expression. */
@@ -189,6 +188,7 @@ export type JsonSerializationOptions = {
      */
     precision: 'auto' | 'max' | number;
 };
+export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
 /**
  * ## THEORY OF OPERATIONS
  *
@@ -233,6 +233,12 @@ export interface BoxedExpression {
      * @category Primitive Methods
      */
     toString(): string;
+    /**
+     * Output to the console a string representation of the expression.
+     *
+     * @category Primitive Methods
+     */
+    print(): void;
     /** Similar to`expr.valueOf()` but includes a hint.
      * @category Primitive Methods
      */
@@ -590,10 +596,22 @@ export interface BoxedExpression {
      * Note it is possible for `numericValue` to be `null`, and for `isNotZero`
      * to be true. For example, when a symbol has been defined with an assumption.
      *
+     * Conversely, `isNumber` may be true even if `numericValue` is `null`,
+     * example the symbol `Pi` return true for `isNumber` but `numericValue` is
+     * `null`. It's value can be accessed with `.value.numericValue`
+     *
      * @category Numeric Expression
      *
      */
     readonly numericValue: number | Decimal | Complex | Rational | null;
+    /** The shape describes the axis of the expression.
+     * When the expression is a scalar (number), the shape is `[]`.
+     * When the expression is a vector, the shape is `[n]`.
+     * When the expression is a matrix, the shape is `[n, m]`.
+     */
+    readonly shape: number[];
+    /** Return 0 for a scalar, 1 for a vector, 2 for a matrix, > 2 for a multidimensional matrix. It's the length of `expr.shape` */
+    readonly rank: number;
     /**
      * Return the following, depending on the value of this expression:
      *
@@ -976,6 +994,14 @@ export interface BoxedExpression {
  * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
  */
 export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
+/**
+ * Control how a pattern is matched to an expression.
+ *
+ * - `substitution`: if present, assumes these values for the named wildcards, and ensure that subsequent occurence of the same wildcard have the same value.
+ * - `recursive`: if true, match recursively, otherwise match only the top level.
+ * - `numericTolerance`: if present, the tolerance for numeric comparison.
+ * - `exact`: if true, only match expressions that are structurally identical. If false, match expressions that are structurally identical or equivalent. For example, when false, `["Add", '_a', 2]` matches `2`, with a value of `_a` of `0`. If true, the expression does not match.
+ */
 export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
     recursive?: boolean;
@@ -1631,7 +1657,7 @@ export interface IComputeEngine {
     lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
     lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
     canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
@@ -1644,6 +1670,13 @@ export interface IComputeEngine {
     }): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
     domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
+    /**
+     * Create a boxed function expression.
+     *
+     * @param head
+     * @param ops
+     * @param options
+     */
     fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], options?: {
         canonical: boolean;
     }): BoxedExpression;
@@ -1671,18 +1704,19 @@ export interface IComputeEngine {
     neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    tuple(elements: number[], metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
     parse(s: LatexString | string, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
     parse(s: null, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): null;
     parse(s: LatexString | string | null, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): null | BoxedExpression;
     serialize(expr: SemiBoxedExpression, options?: {
         canonical?: boolean;

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

@@ -1,10 +1,16 @@
-/* 0.21.0 */
+/* 0.22.0 */
 /**
- * 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`.
+ * For each rules in the rule set that match, return the `replace` of the rule
+ *
  * @param rules
  */
 export declare function matchRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution): BoxedExpression[];
+/**
+ * Create a boxed rule set from a non-boxed rule set
+ * @param ce
+ * @param rs
+ * @returns
+ */
 export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedRuleSet;
 /**
  * Apply the rules in the ruleset and return a modified expression.
@@ -12,13 +18,3 @@ export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedR
  * If no rule applied, return `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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality
@@ -15,3 +15,4 @@ export declare function findUnivariateRoots(expr: BoxedExpression, x: string): B
  * `2x < 4` => `x < 2`
  */
 export declare function univariateSolve(expr: BoxedExpression, x: string): SemiBoxedExpression[] | null;
+export declare const HARMONIZATION_RULES: Rule[];

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 /**
  *
  * @param fn The function to differentiate, a `["Function"]` expression or

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 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.

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

@@ -1,6 +1,7 @@
-/* 0.21.0 */
+/* 0.22.0 */
 /**
  * Flatten the arguments.
  */
 export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[];
 export declare function flattenSequence(xs: BoxedExpression[]): BoxedExpression[];
+export declare function flattenDelimiter(ce: IComputeEngine, body: undefined | BoxedExpression): BoxedExpression;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 /**
  * Group terms in a product by common term.
  *

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

@@ -1,4 +1,4 @@
-/* 0.21.0 */
+/* 0.22.0 */
 export declare class Sum {
     private engine;
     private _isCanonical;

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

@@ -0,0 +1,168 @@
+/* 0.22.0 */
+import { BoxedExpression, IComputeEngine } from '../public';
+export type DataTypeMap = {
+    float64: number;
+    float32: number;
+    int32: number;
+    uint8: number;
+    complex128: Complex;
+    complex64: Complex;
+    bool: boolean;
+    string: string;
+    expression: BoxedExpression;
+};
+export type TensorDataType = keyof DataTypeMap;
+export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: IComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;
+export interface TensorField<T extends number | Complex | BoxedExpression | boolean | string = number> {
+    readonly one: T;
+    readonly zero: T;
+    readonly nan: T;
+    cast(x: T, dtype: 'float64'): undefined | number;
+    cast(x: T, dtype: 'float32'): undefined | number;
+    cast(x: T, dtype: 'int32'): undefined | number;
+    cast(x: T, dtype: 'uint8'): undefined | number;
+    cast(x: T, dtype: 'complex128'): undefined | Complex;
+    cast(x: T, dtype: 'complex64'): undefined | Complex;
+    cast(x: T, dtype: 'bool'): undefined | boolean;
+    cast(x: T, dtype: 'string'): undefined | string;
+    cast(x: T, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: T[], dtype: 'float64'): undefined | number[];
+    cast(x: T[], dtype: 'float32'): undefined | number[];
+    cast(x: T[], dtype: 'int32'): undefined | number[];
+    cast(x: T[], dtype: 'uint8'): undefined | number[];
+    cast(x: T[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: T[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: T[], dtype: 'bool'): undefined | boolean[];
+    cast(x: T[], dtype: 'string'): undefined | string[];
+    cast(x: T[], dtype: 'expression'): undefined | BoxedExpression[];
+    cast(x: T | T[], dtype: TensorDataType): undefined | Complex | number | boolean | string | BoxedExpression | Complex[] | number[] | boolean[] | string[] | BoxedExpression[];
+    expression(x: T): BoxedExpression;
+    isZero(x: T): boolean;
+    isOne(x: T): boolean;
+    equals(lhs: T, rhs: T): boolean;
+    add(lhs: T, rhs: T): T;
+    addn(...xs: T[]): T;
+    neg(x: T): T;
+    sub(lhs: T, rhs: T): T;
+    mul(lhs: T, rhs: T): T;
+    muln(...xs: T[]): T;
+    div(lhs: T, rhs: T): T;
+    pow(rhs: T, n: number): T;
+    conjugate(x: T): T;
+}
+export declare class TensorFieldNumber implements TensorField<number> {
+    private ce;
+    one: number;
+    zero: number;
+    nan: number;
+    constructor(ce: IComputeEngine);
+    cast(x: number, dtype: 'float64'): undefined | number;
+    cast(x: number, dtype: 'float32'): undefined | number;
+    cast(x: number, dtype: 'int32'): undefined | number;
+    cast(x: number, dtype: 'uint8'): undefined | 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: 'string'): undefined | string;
+    cast(x: number, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: number[], dtype: 'float64'): undefined | number[];
+    cast(x: number[], dtype: 'float32'): undefined | number[];
+    cast(x: number[], dtype: 'int32'): undefined | number[];
+    cast(x: number[], dtype: 'uint8'): undefined | 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: 'string'): undefined | string[];
+    cast(x: number[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(x: number): BoxedExpression;
+    isZero(x: number): boolean;
+    isOne(x: number): boolean;
+    equals(lhs: number, rhs: number): boolean;
+    add(lhs: number, rhs: number): number;
+    addn(...xs: number[]): number;
+    neg(x: number): number;
+    sub(lhs: number, rhs: number): number;
+    mul(lhs: number, rhs: number): number;
+    muln(...xs: number[]): number;
+    div(lhs: number, rhs: number): number;
+    pow(lhs: number, rhs: number): number;
+    conjugate(x: number): number;
+}
+export declare class TensorFieldExpression implements TensorField<BoxedExpression> {
+    one: BoxedExpression;
+    zero: BoxedExpression;
+    nan: BoxedExpression;
+    private ce;
+    constructor(ce: IComputeEngine);
+    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: 'string'): undefined | string;
+    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: 'string'): undefined | string[];
+    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;
+}
+export declare class TensorFieldComplex implements TensorField<Complex> {
+    one: Complex;
+    zero: Complex;
+    nan: Complex;
+    private ce;
+    constructor(ce: IComputeEngine);
+    cast(x: Complex, dtype: 'float64'): undefined | number;
+    cast(x: Complex, dtype: 'float32'): undefined | number;
+    cast(x: Complex, dtype: 'int32'): undefined | number;
+    cast(x: Complex, dtype: 'uint8'): undefined | number;
+    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: 'string'): undefined | string;
+    cast(x: Complex, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: Complex[], dtype: 'float64'): undefined | number[];
+    cast(x: Complex[], dtype: 'float32'): undefined | number[];
+    cast(x: Complex[], dtype: 'int32'): undefined | number[];
+    cast(x: Complex[], dtype: 'uint8'): undefined | number[];
+    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: 'string'): undefined | string[];
+    cast(x: Complex[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(z: Complex): BoxedExpression;
+    isZero(z: Complex): boolean;
+    isOne(z: Complex): boolean;
+    equals(lhs: Complex, rhs: Complex): boolean;
+    add(lhs: Complex, rhs: Complex): Complex;
+    addn(...xs: Complex[]): Complex;
+    neg(z: Complex): Complex;
+    sub(lhs: Complex, rhs: Complex): Complex;
+    mul(lhs: Complex, rhs: Complex): Complex;
+    muln(...xs: Complex[]): Complex;
+    div(lhs: Complex, rhs: Complex): Complex;
+    pow(lhs: Complex, rhs: number): Complex;
+    conjugate(z: Complex): Complex;
+}
+export declare function getSupertype(t1: TensorDataType, t2: TensorDataType): TensorDataType;
+export declare function getExpressionDatatype(expr: BoxedExpression): TensorDataType;