@cortex-js/compute-engine 0.30.2 → 0.32.0

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

@@ -1,47 +0,0 @@
-/* 0.30.2 */
-import { MathJsonSymbol } from '../../math-json/types';
-import { NumericValue } from '../numeric-value/types';
-/**
- * Given a name and a set of arguments, return a boxed function expression.
- *
- * If available, preserve LaTeX and wikidata metadata in the boxed expression.
- *
- * Note that `boxFunction()` should only be called from `ce.function()`
- */
-export declare function boxFunction(ce: ComputeEngine, name: MathJsonSymbol, ops: readonly SemiBoxedExpression[], options?: {
-    metadata?: Metadata;
-    canonical?: CanonicalOptions;
-    structural?: boolean;
-    scope?: Scope;
-}): BoxedExpression;
-/**
- * Notes about the boxed form:
- *
- * [1] Expression with an operator of `Number`, `String`, `Symbol` and `Dictionary`
- *      are converted to the corresponding atomic expression.
- *
- * [2] Expressions with an operator of `Complex` are converted to a (complex) number
- *     or a `Add`/`Multiply` expression.
- *
- *     The precedence of `Complex` (for serialization) is sometimes the
- *     precedence of `Add` (when re and im != 0), sometimes the precedence of
- *    `Multiply` (when im or re === 0). Using a number or an explicit
- *    `Add`/`Multiply` expression avoids this ambiguity.
- *
- * [3] An expression with a `Rational` operator is converted to a rational
- *    number if possible, to a `Divide` otherwise.
- *
- * [4] A `Negate` function applied to a number literal is converted to a number.
- *
- *     Note that `Negate` is only distributed over addition. In practice, having
- * `Negate` factored on multiply/divide is more useful to detect patterns.
- *
- * Note that this function should only be called from `ce.box()`
- *
- */
-export declare function box(ce: ComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
-    canonical?: CanonicalOptions;
-    structural?: boolean;
-    scope?: Scope;
-}): BoxedExpression;
-export declare function semiCanonical(ce: ComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>, scope?: Scope): ReadonlyArray<BoxedExpression>;

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

@@ -1,42 +0,0 @@
-/* 0.30.2 */
-import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedType } from '../../common/type/boxed-type';
-import { Expression } from '../../math-json/types';
-/**
- * BoxedDictionary
- *
- */
-export declare class BoxedDictionary extends _BoxedExpression implements DictionaryInterface {
-    [Symbol.toStringTag]: string;
-    private readonly _keyValues;
-    private _type;
-    constructor(ce: ComputeEngine, keyValues: Record<string, SemiBoxedExpression> | BoxedExpression, options?: {
-        metadata?: Metadata;
-        canonical?: boolean;
-    });
-    private _initFromRecord;
-    private _initFromExpression;
-    get json(): Expression;
-    get hash(): number;
-    get operator(): string;
-    get type(): BoxedType;
-    get isPure(): boolean;
-    get isCanonical(): boolean;
-    set isCanonical(_va: boolean);
-    get value(): BoxedExpression | undefined;
-    get complexity(): number;
-    get isCollection(): boolean;
-    get isIndexedCollection(): boolean;
-    get isLazyCollection(): boolean;
-    xcontains(_rhs: BoxedExpression): boolean | undefined;
-    get xsize(): number | undefined;
-    get isEmptyCollection(): boolean;
-    get isFiniteCollection(): boolean;
-    each(): Generator<BoxedExpression>;
-    get(key: string): BoxedExpression | undefined;
-    has(key: string): boolean;
-    get keys(): string[];
-    get entries(): [string, BoxedExpression][];
-    get values(): BoxedExpression[];
-    match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
-}

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

@@ -1,136 +0,0 @@
-/* 0.30.2 */
-import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, BoxedExpression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition } from '../global-types';
-import { Type } from '../../common/type/types';
-import { BoxedType } from '../../common/type/boxed-type';
-import { NumericValue } from '../numeric-value/types';
-import { _BoxedExpression } from './abstract-boxed-expression';
-/**
- * A boxed function expression represent an expression composed of an operator
- * (the name of the function) and a list of arguments. For example:
- * `["Add", 1, 2]` is a function expression with the operator "Add" and two
- * arguments 1 and 2.
- *
- * If canonical, it has a definition associated with it, based on the operator.
- *
- * The definition contains its signature and its evaluation handler.
- *
- */
-export declare class BoxedFunction extends _BoxedExpression {
-    private readonly _operator;
-    private readonly _ops;
-    private _def;
-    /** @todo: wrong. If the function is scoped (has its own lexical scope), the captured eval context. This includes the lexical scope for this expression
-     */
-    private _capturedContext;
-    /** If the operator is scoped, the local scope associated with
-     * the function expression
-     */
-    private _localScope;
-    private _isPure;
-    private _isStructural;
-    private _hash;
-    private _value;
-    private _valueN;
-    private _sgn;
-    private _type;
-    constructor(ce: ComputeEngine, operator: string, ops: ReadonlyArray<BoxedExpression>, options?: {
-        metadata?: Metadata;
-        canonical?: boolean;
-        structural?: boolean;
-        scope?: Scope;
-    });
-    get hash(): number;
-    /**
-     * For function expressions, `infer()` infers the result type of the function
-     * based on the provided type and inference mode.
-     */
-    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
-    bind(): void;
-    reset(): void;
-    get value(): BoxedExpression | undefined;
-    get isCanonical(): boolean;
-    get isPure(): boolean;
-    get isConstant(): boolean;
-    get constantValue(): number | boolean | string | object | undefined;
-    get json(): Expression;
-    get operator(): string;
-    get ops(): ReadonlyArray<BoxedExpression>;
-    get nops(): number;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
-    get isScoped(): boolean;
-    get localScope(): Scope | undefined;
-    get isValid(): boolean;
-    /** Note: if the expression is not canonical, this will return a canonical
-     * version of the expression in the current lexical scope.
-     */
-    get canonical(): BoxedExpression;
-    get structural(): BoxedExpression;
-    get isStructural(): boolean;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    /**
-     * Note: the result is bound to the current scope, not the scope of the
-     * original expression.
-     * <!-- This may or may not be desirable -->
-     */
-    subs(sub: Substitution, options?: {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    has(v: string | string[]): boolean;
-    get sgn(): Sign | undefined;
-    get isNaN(): boolean | undefined;
-    get isInfinity(): boolean | undefined;
-    get isFinite(): boolean | undefined;
-    get isOne(): boolean | undefined;
-    get isNegativeOne(): boolean | undefined;
-    get isPositive(): boolean | undefined;
-    get isNonNegative(): boolean | undefined;
-    get isNegative(): boolean | undefined;
-    get isNonPositive(): boolean | undefined;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    get complexity(): number | undefined;
-    get baseDefinition(): BoxedBaseDefinition | undefined;
-    get operatorDefinition(): BoxedOperatorDefinition | undefined;
-    get valueDefinition(): BoxedValueDefinition | undefined;
-    get isNumber(): boolean | undefined;
-    get isInteger(): boolean | undefined;
-    get isRational(): boolean | undefined;
-    get isReal(): boolean | undefined;
-    get isFunctionExpression(): boolean;
-    /** The type of the value of the function */
-    get type(): BoxedType;
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
-    N(): BoxedExpression;
-    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
-    get isCollection(): boolean;
-    get isIndexedCollection(): boolean;
-    get isLazyCollection(): boolean;
-    xcontains(rhs: BoxedExpression): boolean | undefined;
-    get xsize(): number | undefined;
-    get isEmptyCollection(): boolean | undefined;
-    get isFiniteCollection(): boolean | undefined;
-    each(): Generator<BoxedExpression>;
-    at(index: number): BoxedExpression | undefined;
-    get(index: BoxedExpression | string): BoxedExpression | undefined;
-    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
-    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
-    _computeValue(options?: Partial<EvaluateOptions>): () => BoxedExpression;
-    _computeValueAsync(options?: Partial<EvaluateOptions>): () => Promise<BoxedExpression>;
-}

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

@@ -1,103 +0,0 @@
-/* 0.30.2 */
-import { Decimal } from 'decimal.js';
-import type { Expression, MathJsonNumberObject } from '../../math-json';
-import type { Rational, SmallInteger } from '../numerics/types';
-import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/types';
-import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, BoxedExpression, PatternMatchOptions, ReplaceOptions, SimplifyOptions } from '../global-types';
-/**
- * BoxedNumber
- *
- */
-export declare class BoxedNumber extends _BoxedExpression {
-    protected readonly _value: SmallInteger | NumericValue;
-    private _hash;
-    /**
-     * By the time the constructor is called, the `value` should have been
-     * screened for cases where it's a well-known value (0, NaN, +Infinity,
-     * etc...) or non-normal (complex number with im = 0, rational with
-     * denom = 1, etc...).
-     *
-     * This is done in `ce.number()`. In general, use `ce.number()` rather
-     * than calling this constructor directly.
-     *
-     * We may store as a machine number if a Decimal is passed that is in machine
-     * range
-     */
-    constructor(ce: ComputeEngine, value: SmallInteger | NumericValueData | ExactNumericValueData | NumericValue, options?: {
-        metadata?: Metadata;
-    });
-    get hash(): number;
-    get json(): Expression;
-    get operator(): string;
-    get isPure(): boolean;
-    get isCanonical(): boolean;
-    set isCanonical(val: boolean);
-    get complexity(): number;
-    /**
-     *
-     * Return a JavaScript number when possible (most cases); else return a
-     * string representation of the number (ComplexInfinity and complex numbers
-     * for example).
-     *
-     * When a JavaScript number is returned, it may have fewer digits than the
-     * original number, but it will be a close approximation.
-     *
-     * @returns {number | string} The value of the number.
-     */
-    valueOf(): number | string;
-    get numericValue(): number | NumericValue;
-    get isNumberLiteral(): boolean;
-    get re(): number;
-    get im(): number;
-    get bignumRe(): Decimal | undefined;
-    get bignumIm(): Decimal | undefined;
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    get value(): BoxedExpression;
-    get type(): BoxedType;
-    get sgn(): Sign | undefined;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
-    subs(sub: Substitution, options?: {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    /** x > 0, same as `isGreater(0)` */
-    get isPositive(): boolean | undefined;
-    /** x >= 0, same as `isGreaterEqual(0)` */
-    get isNonNegative(): boolean | undefined;
-    /** x < 0, same as `isLess(0)` */
-    get isNegative(): boolean | undefined;
-    /** x <= 0, same as `isLessEqual(0)` */
-    get isNonPositive(): boolean | undefined;
-    get isOdd(): boolean | undefined;
-    get isEven(): boolean | undefined;
-    get isInfinity(): boolean;
-    get isNaN(): boolean;
-    get isFinite(): boolean;
-    get isNumber(): true;
-    get isInteger(): boolean;
-    get isRational(): boolean;
-    get isReal(): boolean;
-    is(other: BoxedExpression | number | bigint | boolean): boolean;
-    get canonical(): BoxedExpression;
-    get isStructural(): boolean;
-    get structural(): BoxedExpression;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    N(): BoxedExpression;
-}
-export declare function canonicalNumber(ce: ComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumberObject): number | NumericValue;

package/dist/types/compute-engine/boxed-expression/boxed-operator-definition.d.ts

@@ -1,53 +0,0 @@
-/* 0.30.2 */
-import { BoxedType } from '../../common/type/boxed-type';
-import type { OperatorDefinition, BoxedExpression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, ComputeEngine, Sign } from '../global-types';
-export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition {
-    engine: ComputeEngine;
-    name: string;
-    description?: string | string[];
-    url?: string;
-    wikidata?: string;
-    broadcastable: boolean;
-    associative: boolean;
-    commutative: boolean;
-    commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
-    idempotent: boolean;
-    involution: boolean;
-    pure: boolean;
-    complexity: number;
-    lazy: boolean;
-    scoped: boolean;
-    signature: BoxedType;
-    inferredSignature: boolean;
-    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: ComputeEngine;
-    }) => BoxedType | Type | TypeString | undefined;
-    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: ComputeEngine;
-    }) => Sign | undefined;
-    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
-    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
-    even?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: ComputeEngine;
-    }) => boolean | undefined;
-    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: ComputeEngine;
-    }) => BoxedExpression | null;
-    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
-        engine: ComputeEngine;
-    }) => BoxedExpression | undefined;
-    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
-        engine?: ComputeEngine;
-    }) => Promise<BoxedExpression | undefined>;
-    evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: ComputeEngine;
-    }) => BoxedExpression;
-    compile?: (expr: BoxedExpression) => CompiledExpression;
-    collection?: CollectionHandlers;
-    constructor(ce: ComputeEngine, name: string, def: OperatorDefinition);
-    /** For debugging */
-    toJSON(): any;
-    infer(sig: Type): void;
-    update(def: OperatorDefinition): void;
-    onConfigurationChange(): void;
-}

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

@@ -1,4 +0,0 @@
-/* 0.30.2 */
-import type { BoxedExpression } from '../global-types';
-export declare function isWildcard(expr: BoxedExpression): expr is BoxedSymbol;
-export declare function wildcardName(expr: BoxedExpression): string | null;

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

@@ -1,27 +0,0 @@
-/* 0.30.2 */
-import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedType } from '../../common/type/boxed-type';
-/**
- * BoxedString
- *
- */
-export declare class BoxedString extends _BoxedExpression {
-    [Symbol.toStringTag]: string;
-    private readonly _string;
-    private _utf8Buffer?;
-    private _unicodeScalarValues?;
-    constructor(ce: ComputeEngine, expr: string, metadata?: Metadata);
-    get json(): string;
-    get hash(): number;
-    get operator(): string;
-    get isPure(): boolean;
-    get isCanonical(): boolean;
-    set isCanonical(_va: boolean);
-    get value(): BoxedExpression;
-    get type(): BoxedType;
-    get complexity(): number;
-    get string(): string;
-    get buffer(): Uint8Array;
-    get unicodeScalars(): number[];
-    match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
-}

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

@@ -1,170 +0,0 @@
-/* 0.30.2 */
-import type { Type, TypeString } from '../../common/type/types';
-import type { OneOf } from '../../common/one-of';
-import { BoxedType } from '../../common/type/boxed-type';
-import type { BigNum } from '../numerics/types';
-import { NumericValue } from '../numeric-value/types';
-import type { BoxedExpression, SimplifyOptions, PatternMatchOptions, ReplaceOptions, BoxedValueDefinition, BoxedOperatorDefinition, ComputeEngine, Metadata, CanonicalOptions, BoxedBaseDefinition, BoxedSubstitution, EvaluateOptions, Rule, BoxedRule, BoxedRuleSet, Substitution, Sign, BoxedDefinition, CollectionHandlers } from '../global-types';
-import { _BoxedExpression } from './abstract-boxed-expression';
-/**
- * ### BoxedSymbol
- *
- * A boxed symbol is a reference to a `BoxedDefinition`.
- *
- * A `BoxedDefinition` "owns" all the information about a symbol, its
- * type and various attributes (is it a constant?, etc...).
- *
- * Boxed symbols are bound to a definition during construction if they
- * are canonical.
- *
- * If a symbol is not canonical (and thus not bound to a definition),
- * some properties and methods will return `undefined`, for example
- * `isInteger`, `isRational`, `isReal`, etc...
- *
- * There is a single value definition for each symbol but the value of a
- * symbol can be different in different evaluation contexts, for example
- * a local variable during a recursion.
- *
- * The value of a symbol is tracked in the evaluation context and
- * not in the value definition.
- *
- * The `value` property of a boxed symbol is the value of the symbol
- * in the current evaluation context. It is `undefined` if the symbol
- * is not bound to a definition or if the value is not known (a bound
- * symbol may have no value).
- *
- */
-export declare class BoxedSymbol extends _BoxedExpression {
-    private _hash;
-    /** The name of the symbol */
-    protected _id: MathJsonSymbol;
-    /**
-     * The definition of the symbol, if the symbol is bound/canonical.
-     */
-    private readonly _def;
-    /** Note: to indicate that the symbol should be canonical, pass a def. */
-    constructor(ce: ComputeEngine, name: MathJsonSymbol, options?: {
-        metadata?: Metadata;
-        def?: BoxedDefinition;
-    });
-    get json(): Expression;
-    get hash(): number;
-    get isPure(): boolean;
-    get isConstant(): boolean;
-    bind(): void;
-    reset(): void;
-    get isCanonical(): boolean;
-    set isCanonical(val: boolean);
-    get canonical(): BoxedExpression;
-    is(other: any): boolean;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(n: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
-    get complexity(): number;
-    get operator(): MathJsonSymbol;
-    get symbol(): MathJsonSymbol;
-    get baseDefinition(): BoxedBaseDefinition | undefined;
-    get valueDefinition(): BoxedValueDefinition | undefined;
-    get operatorDefinition(): BoxedOperatorDefinition | undefined;
-    /**
-     *
-     * Assuming the symbol is used as an argument, subsequent inferences will
-     * narrow the domain of the symbol:
-     *
-     * ```
-     * f: real -> number, g: integer -> number
-     * f(x) => x: inferred to real
-     * g(x) => x: narrowed to integer
-     * ```
-     *
-     * If the symbol is used as a return value, its domain should be widened:
-     *
-     * ```
-     * f: number -> integer, g: number -> real
-     * x = f(2) => x: inferred to integer
-     * x = g(2) => x: widened to real
-     * ```
-     *
-     * Arguments accumulate constraints and narrow.
-     * Return values accumulate possibilities and widen.
-     *
-     * @inheritdoc
-     */
-    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
-    /** Return the value of the symbol, undefined if an operator or not bound */
-    get _value(): BoxedExpression | undefined;
-    get value(): BoxedExpression | undefined;
-    set value(value: boolean | string | BigNum | number[] | OneOf<[
-        {
-            re: number;
-            im: number;
-        },
-        {
-            num: number;
-            denom: number;
-        },
-        BoxedExpression
-    ]> | number | undefined);
-    /**
-     * The type of the symbol.
-     *
-     * Note that the type of the value of the symbol may be more specific.'
-     * For example, a symbol could have a type of 'number' but the value
-     * could be 'integer'.
-     *
-     * If the symbol is not canonical (not bound to a definition), the type is
-     * 'unknown'
-     */
-    get type(): BoxedType;
-    set type(t: Type | TypeString | BoxedType);
-    has(x: MathJsonSymbol | MathJsonSymbol[]): boolean;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    get sgn(): Sign | undefined;
-    get isOdd(): boolean | undefined;
-    get isEven(): boolean | undefined;
-    get isFinite(): boolean | undefined;
-    get isInfinity(): boolean | undefined;
-    get isNaN(): boolean | undefined;
-    get isPositive(): boolean | undefined;
-    get isNonPositive(): boolean | undefined;
-    get isNegative(): boolean | undefined;
-    get isNonNegative(): boolean | undefined;
-    get isFunction(): boolean | undefined;
-    get isNumber(): boolean | undefined;
-    get isInteger(): boolean | undefined;
-    get isRational(): boolean | undefined;
-    get isReal(): boolean | undefined;
-    get re(): number;
-    get im(): number;
-    get bignumRe(): BigNum | undefined;
-    get bignumIm(): BigNum | undefined;
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    N(): BoxedExpression;
-    replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): BoxedExpression | null;
-    subs(sub: Substitution, options?: {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    get _asCollection(): CollectionHandlers | undefined;
-    get isCollection(): boolean;
-    get isIndexedCollection(): boolean;
-    get isLazyCollection(): boolean;
-    xcontains(rhs: BoxedExpression): boolean | undefined;
-    get xsize(): number;
-    get isEmptyCollection(): boolean;
-    get isFiniteCollection(): boolean | undefined;
-    each(): Generator<BoxedExpression>;
-    at(index: number): BoxedExpression | undefined;
-    get(index: BoxedExpression | string): BoxedExpression | undefined;
-    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
-    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
-}

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

@@ -1,83 +0,0 @@
-/* 0.30.2 */
-import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, BoxedExpression, SimplifyOptions, PatternMatchOptions, Tensor } from '../global-types';
-import { BoxedType } from '../../common/type/boxed-type';
-import { NumericValue } from '../numeric-value/types';
-import { _BoxedExpression } from './abstract-boxed-expression';
-/**
- * A boxed tensor represents an expression that can be represented by a tensor.
- * This could be a vector, matrix or multi-dimensional array.
- *
- * The object can be created either from a tensor or from an expression that
- * can be represented as a tensor.
- *
- * The structural counterpart (expression if input is tensor, or tensor
- * if input is expression) is created lazily.
- *
- */
-export declare class BoxedTensor<T extends TensorDataType> extends _BoxedExpression {
-    readonly input: {
-        ops: ReadonlyArray<BoxedExpression>;
-        shape: number[];
-        dtype: T;
-    };
-    readonly options?: {
-        metadata?: Metadata;
-    };
-    private _tensor;
-    private _expression?;
-    constructor(ce: ComputeEngine, input: {
-        ops: ReadonlyArray<BoxedExpression>;
-        shape: number[];
-        dtype: T;
-    }, options?: {
-        metadata?: Metadata;
-    });
-    get structural(): BoxedExpression;
-    /** Create the tensor on demand */
-    get tensor(): Tensor<T>;
-    get baseDefinition(): BoxedBaseDefinition | undefined;
-    get operatorDefinition(): BoxedOperatorDefinition | undefined;
-    get hash(): number;
-    get canonical(): BoxedExpression;
-    get isCanonical(): boolean;
-    get isPure(): boolean;
-    get isValid(): boolean;
-    get complexity(): number;
-    get operator(): string;
-    get nops(): number;
-    get ops(): ReadonlyArray<BoxedExpression>;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    sub(rhs: BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    get shape(): number[];
-    get rank(): number;
-    get type(): BoxedType;
-    get json(): Expression;
-    /** Mathematical equality */
-    isEqual(rhs: number | BoxedExpression): boolean | undefined;
-    get isCollection(): boolean;
-    get isIndexedCollection(): boolean;
-    xcontains(other: BoxedExpression): boolean | undefined;
-    get xsize(): number;
-    each(): Generator<BoxedExpression>;
-    at(index: number): BoxedExpression | undefined;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    N(): BoxedExpression;
-}
-export declare function isBoxedTensor(val: unknown): val is BoxedTensor<any>;
-export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<BoxedExpression>): {
-    shape: number[];
-    dtype: TensorDataType;
-} | undefined;