@cortex-js/compute-engine 0.31.0 → 0.32.0

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

@@ -1,43 +0,0 @@
-/* 0.31.0 */
-export declare function isRational(x: any | null): x is Rational;
-export declare function isMachineRational(x: any | null): x is [SmallInteger, SmallInteger];
-export declare function isBigRational(x: any | null): x is [bigint, bigint];
-export declare function isZero(x: Rational): boolean;
-export declare function isPositive(x: Rational): boolean;
-export declare function isOne(x: Rational): boolean;
-export declare function isNegativeOne(x: Rational): boolean;
-export declare function isInteger(x: Rational): boolean;
-export declare function machineNumerator(x: Rational): number;
-export declare function machineDenominator(x: Rational): number;
-export declare function rationalAsFloat(x: Rational): number;
-export declare function isNeg(x: Rational): boolean;
-export declare function div(lhs: Rational, rhs: Rational): Rational;
-/**
- * Add a literal numeric value to a rational.
- * If the rational is a bigint, this is a hint to do the calculation in bigint
- * (no need to check `bignumPreferred()`).
- * @param lhs
- * @param rhs
- * @returns
- */
-export declare function add(lhs: Rational, rhs: Rational): Rational;
-export declare function mul(lhs: Rational, rhs: Rational): Rational;
-export declare function neg(x: [SmallInteger, SmallInteger]): [SmallInteger, SmallInteger];
-export declare function neg(x: [bigint, bigint]): [bigint, bigint];
-export declare function neg(x: Rational): Rational;
-export declare function inverse(x: [SmallInteger, SmallInteger]): [SmallInteger, SmallInteger];
-export declare function inverse(x: [bigint, bigint]): [bigint, bigint];
-export declare function inverse(x: Rational): Rational;
-export declare function asMachineRational(r: Rational): [SmallInteger, SmallInteger];
-export declare function pow(r: Rational, exp: SmallInteger): Rational;
-export declare function sqrt(r: Rational): Rational | undefined;
-export declare function rationalGcd(lhs: Rational, rhs: Rational): Rational;
-export declare function reducedRational(r: [SmallInteger, SmallInteger]): [SmallInteger, SmallInteger];
-export declare function reducedRational(r: [bigint, bigint]): [bigint, bigint];
-export declare function reducedRational(r: Rational): Rational;
-/** Return a rational approximation of x */
-export declare function rationalize(x: number): [n: number, d: number] | number;
-/** Return [factor, root] such that factor * sqrt(root) = sqrt(n)
- * when factor and root are rationals
- */
-export declare function reduceRationalSquareRoot(n: Rational): [factor: Rational, root: number | bigint];

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

@@ -1,80 +0,0 @@
-/* 0.31.0 */
-
-    Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
-
-
-    The `Richardson` module provides a function `extrapolate` that
-    extrapolates a given function `f(x)` to `f(x0)`, evaluating
-    `f` only  at a geometric sequence of points `> x0`
-    (or optionally `< x0`).
-    
-    The key algorithm is Richardson extrapolation using a Neville—Aitken
-    tableau, which adaptively increases the degree of an extrapolation
-    polynomial until convergence is achieved to a desired tolerance
-    (or convergence stalls due to e.g. floating-point errors).  This
-    allows one to obtain `f(x0)` to high-order accuracy, assuming
-    that `f(x0+h)` has a Taylor series or some other power
-    series in `h`.
-*/
-export interface ExtrapolateOptions {
-    contract?: number;
-    step?: number;
-    power?: number;
-    atol?: number;
-    rtol?: number;
-    maxeval?: number;
-    breaktol?: number;
-}
-/**
- *
- * Extrapolate `f(x)` to `f₀ ≈ f(x0)`, evaluating `f` only at `x > x0` points
-(or `x < x0` if `h < 0`) using Richardson extrapolation starting at
-`x=x₀+h`.  It returns a tuple `(f₀, err)` of the estimated `f(x0)`
-and an error estimate.
-
-The return value of `f` can be any type supporting `±` and `norm`
-operations (i.e. a normed vector space).
-Similarly, `h` and `x0` can be in any normed vector space,
-in which case `extrapolate` performs Richardson extrapolation
-of `f(x0+s*h)` to `s=0⁺` (i.e. it takes the limit as `x` goes
-to `x0` along the `h` direction).
-
-On each step of Richardson extrapolation, it shrinks `x-x0` by
-a factor of `contract`, stopping when the estimated error is
-`< max(rtol*norm(f₀), atol)`, when the estimated error
-increases by more than `breaktol` (e.g. due to numerical errors in the
-computation of `f`), when `f` returns a non-finite value (`NaN` or `Inf`),
- or when `f` has been evaluated `maxeval` times.   Note that
-if the function may converge to zero, you may want
-specify a nonzero `atol` (which cannot be set by default
-because it depends on the scale/units of `f`); alternatively,
-in such cases `extrapolate` will halt when it becomes
-limited by the floating-point precision.   (Passing `breaktol=Inf`
-can be useful to force `extrapolate` to continue shrinking `h` even
-if polynomial extrapolation is initially failing to converge,
-possibly at the cost of extraneous function evaluations.)
-
-
-If `x0 = ±∞` (`±Inf`), then `extrapolate` computes the limit of
-`f(x)` as `x ⟶ ±∞` using geometrically *increasing* values
-of `h` (by factors of `1/contract`).
-
-In general, the starting `h` should be large enough that `f(x0+h)`
-can be computed accurately and efficiently (e.g. without
-severe cancellation errors), but small enough that `f` does not
-oscillate much between `x0` and `h`.  i.e. `h` should be a typical
-scale over which the function `f` varies significantly.
-
-Technically, Richardson extrapolation assumes that `f(x0+h)` can
-be expanded in a power series in `h^power`, where the default
-`power=1` corresponds to an ordinary Taylor series (i.e. assuming
-`f` is analytic at `x0`).  If this is not true, you may obtain
-slow convergence from `extrapolate`, but you can pass a different
-value of `power` (e.g. `power=0.5`) if your `f` has some different
-(Puiseux) power-series expansion.   Conversely, if `f` is
-an *even* function around `x0`, i.e. `f(x0+h) == f(x0-h)`,
-so that its Taylor series contains only *even* powers of `h`,
-you can accelerate convergence by passing `power=2`.
-
- */
-export declare function extrapolate(f: (x: number) => number, x0: number, options?: ExtrapolateOptions): [val: number, err: number];

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,28 +0,0 @@
-/* 0.31.0 */
-import type { BigNum } from './types';
-export declare function gammaln(z: number): number;
-export declare function gamma(z: number): number;
-/**
- * Inverse Error Function.
- *
- */
-export declare function erfInv(x: number): number;
-/**
- * Trivial function, used when compiling.
- */
-export declare function erfc(x: number): number;
-/**
- * An approximation of the gaussian error function, Erf(), using
- * Abramowitz and Stegun approximation.
- *
- * Thoughts for future improvements:
- * - https://math.stackexchange.com/questions/321569/approximating-the-error-function-erf-by-analytical-functions
- * - https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions
-
- *
- * References:
- * - NIST: https://dlmf.nist.gov/7.24#i
- */
-export declare function erf(x: number): number;
-export declare function bigGammaln(ce: ComputeEngine, z: BigNum): BigNum;
-export declare function bigGamma(ce: ComputeEngine, z: BigNum): BigNum;

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

@@ -1,24 +0,0 @@
-/* 0.31.0 */
-import type { BigNum } from './types';
-export declare function mean(values: Iterable<number>): number;
-export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function median(values: Iterable<number>): number;
-export declare function bigMedian(values: Iterable<BigNum>): BigNum;
-export declare function variance(values: Iterable<number>): number;
-export declare function bigVariance(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function populationVariance(values: Iterable<number>): number;
-export declare function bigPopulationVariance(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function standardDeviation(values: Iterable<number>): number;
-export declare function bigStandardDeviation(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function populationStandardDeviation(values: Iterable<number>): number;
-export declare function bigPopulationStandardDeviation(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function kurtosis(values: Iterable<number>): number;
-export declare function bigKurtosis(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function skewness(values: Iterable<number>): number;
-export declare function bigSkewness(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function mode(values: Iterable<number>): number;
-export declare function bigMode(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
-export declare function quartiles(values: Iterable<number>): [number, number, number];
-export declare function bigQuartiles(values: Iterable<BigNum>): [BigNum, BigNum, BigNum];
-export declare function interquartileRange(values: Iterable<number>): number;
-export declare function bigInterquartileRange(values: Iterable<BigNum>): BigNum;

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

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

@@ -1,30 +0,0 @@
-/* 0.31.0 */
-type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
-/** A `SmallInteger` is an integer < 1e6
- * @category Numerics
- */
-export type SmallInteger = IsInteger<number>;
-/**
- * A rational number is a number that can be expressed as the quotient or fraction p/q of two integers,
- * a numerator p and a non-zero denominator q.
- *
- * A rational can either be represented as a pair of small integers or
- * a pair of big integers.
- *
- * @category Numerics
- */
-export type Rational = [SmallInteger, SmallInteger] | [bigint, bigint];
-/** @category Numerics */
-export type BigNum = Decimal;
-/** @category Numerics */
-export interface IBigNum {
-    readonly _BIGNUM_NAN: BigNum;
-    readonly _BIGNUM_ZERO: BigNum;
-    readonly _BIGNUM_ONE: BigNum;
-    readonly _BIGNUM_TWO: BigNum;
-    readonly _BIGNUM_HALF: BigNum;
-    readonly _BIGNUM_PI: BigNum;
-    readonly _BIGNUM_NEGATIVE_ONE: BigNum;
-    bignum(value: string | number | bigint | BigNum): BigNum;
-}
-export {};

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

@@ -1,3 +0,0 @@
-/* 0.31.0 */
-/** Calculate the antiderivative of fn, as an expression (not a function) */
-export declare function antiderivative(fn: BoxedExpression, index: string): BoxedExpression;

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

@@ -1,18 +0,0 @@
-/* 0.31.0 */
-/**
- *
- * @param fn The function to differentiate, a function literal.
- *
- * @returns a function expression representing the derivative of `fn` with
- * respect to the variables in `degrees`.
- */
-export declare function derivative(fn: BoxedExpression, order: number): BoxedExpression | undefined;
-/**
- * Calculate the partial derivative of an expression with respect to a
- * variable, `v`.
- *
- * All expressions that do not explicitly depend on `v` are taken to have zero
- * partial derivative.
- *
- */
-export declare function differentiate(expr: BoxedExpression, v: string): BoxedExpression | undefined;

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

@@ -1,5 +0,0 @@
-/* 0.31.0 */
-/**
- *
- */
-export declare function distribute(expr: BoxedExpression, g?: string, f?: string): BoxedExpression;

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

@@ -1,27 +0,0 @@
-/* 0.31.0 */
-/**
- * @todo: a set to "tidy" an expression. Different from a canonical form, but
- * inline with the user's expectations.
- *
- * Example:
- *
- * - a^n * a^m -> a^(n+m)
- * - a / √b -> (a * √b) / b
- *
- */
-/**
- * A set of simplification rules.
- *
- * The rules are expressed as
- *
- *    `[lhs, rhs, condition]`
- *
- * where `lhs` is rewritten as `rhs` if `condition` is true.
- *
- * `lhs` and `rhs` can be either an Expression 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,
- * may be necessary as the expression could be simplified by the canonicalization.
- */
-export declare const SIMPLIFY_RULES: Rule[];

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

@@ -1,128 +0,0 @@
-/* 0.31.0 */
-import { BoxedExpression, 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 */
-export declare class TensorFieldNumber implements TensorField<number> {
-    private ce;
-    one: number;
-    zero: number;
-    nan: number;
-    constructor(ce: ComputeEngine);
-    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: '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: '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;
-}
-/** @category Tensors */
-export declare class TensorFieldExpression implements TensorField<BoxedExpression> {
-    one: BoxedExpression;
-    zero: BoxedExpression;
-    nan: BoxedExpression;
-    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;
-}
-/** @category Tensors */
-export declare class TensorFieldComplex implements TensorField<Complex> {
-    one: Complex;
-    zero: Complex;
-    nan: Complex;
-    private ce;
-    constructor(ce: ComputeEngine);
-    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: '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: '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;
-}
-/**
- * @category Tensors
- * @internal
- */
-export declare function getSupertype(t1: TensorDataType | undefined, t2: TensorDataType): TensorDataType;
-/**
- * If the expression is a literal number, return the datatype of the
- * number (or boolean). Otherwise, return the `expression`.
- *
- * @category Tensors
- * @internal
- */
-export declare function getExpressionDatatype(expr: BoxedExpression): TensorDataType;

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

@@ -1,93 +0,0 @@
-/* 0.31.0 */
-/** @category Tensors */
-export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
-    private ce;
-    /**
-     * Return a tuple of tensors that have the same dtype.
-     * If necessary, one of the two input tensors is upcast.
-     *
-     * The shape of the tensors is reshaped to a compatible
-     * shape. If the shape is not compatible, `undefined` is returned.
-     *
-     * @param lhs
-     * @param rhs
-     */
-    static align<T1 extends TensorDataType, T2 extends TensorDataType>(lhs: AbstractTensor<T1>, rhs: AbstractTensor<T2>): [AbstractTensor<T1>, AbstractTensor<T1>];
-    static align<T1 extends TensorDataType, T2 extends TensorDataType>(lhs: AbstractTensor<T1>, rhs: AbstractTensor<T2>): [AbstractTensor<T2>, AbstractTensor<T2>];
-    /**
-     * Apply a function to the elements of two tensors, or to a tensor
-     * and a scalar.
-     *
-     * The tensors are aligned and broadcasted if necessary.
-     *
-     * @param fn
-     * @param lhs
-     * @param rhs
-     * @returns
-     */
-    static broadcast<T extends TensorDataType>(fn: (lhs: DataTypeMap[T], rhs: DataTypeMap[T]) => DataTypeMap[T], lhs: AbstractTensor<T>, rhs: AbstractTensor<T> | DataTypeMap[T]): AbstractTensor<T>;
-    readonly field: TensorField<DataTypeMap[DT]>;
-    readonly shape: number[];
-    readonly rank: number;
-    private readonly _strides;
-    constructor(ce: ComputeEngine, tensorData: TensorData<DT>);
-    abstract get dtype(): DT;
-    abstract get data(): DataTypeMap[DT][];
-    get expression(): BoxedExpression;
-    /**
-     * Like expression(), but return a nested JS array instead
-     * of a BoxedExpression
-     */
-    get array(): NestedArray<DataTypeMap[DT]>;
-    /** Indices are 1-based, return a 0-based index in the data */
-    private _index;
-    get isSquare(): boolean;
-    get isSymmetric(): boolean;
-    get isSkewSymmetric(): boolean;
-    get isUpperTriangular(): boolean;
-    get isLowerTriangular(): boolean;
-    get isTriangular(): boolean;
-    get isDiagonal(): boolean;
-    get isIdentity(): boolean;
-    get isZero(): boolean;
-    /**
-     *  The number of indices should match the rank of the tensor.
-     *
-     * Note: the indices are 1-based
-     * Note: the data is broadcast (wraps around) if the indices are out of bounds
-     *
-     * LaTeX notation `A\lbracki, j\rbrack` or `A_{i, j}`
-     */
-    at(...indices: number[]): DataTypeMap[DT];
-    diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
-    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT];
-    /**
-     * Change the shape of the tensor
-     *
-     * The data is reused (and shared) between the two tensors.
-     */
-    reshape(...shape: number[]): AbstractTensor<DT>;
-    slice(index: number): AbstractTensor<DT>;
-    flatten(): DataTypeMap[DT][];
-    upcast<DT extends keyof DataTypeMap>(dtype: DT): AbstractTensor<DT>;
-    /** Transpose the first and second axis */
-    transpose(): undefined | AbstractTensor<DT>;
-    /** Transpose two axes. */
-    transpose(axis1: number, axis2: number, fn?: (v: DataTypeMap[DT]) => DataTypeMap[DT]): undefined | AbstractTensor<DT>;
-    conjugateTranspose(axis1: number, axis2: number): undefined | AbstractTensor<DT>;
-    determinant(): undefined | DataTypeMap[DT];
-    inverse(): undefined | AbstractTensor<DT>;
-    pseudoInverse(): undefined | AbstractTensor<DT>;
-    adjugateMatrix(): undefined | AbstractTensor<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>;
-    subtract(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
-    multiply(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
-    divide(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
-    power(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
-    equals(rhs: AbstractTensor<DT>): boolean;
-}
-/** @category Tensors */
-export declare function makeTensor<T extends TensorDataType>(ce: ComputeEngine, data: TensorData<T>): AbstractTensor<T>;

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

@@ -1,8 +0,0 @@
-/* 0.31.0 */
-export * from '../math-json/types';
-export * from '../common/type/boxed-type';
-export * from '../common/type/types';
-export type * from './latex-syntax/types';
-export * from './numerics/types';
-export * from './numeric-value/types';
-export * from './global-types';

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

@@ -1,3 +0,0 @@
-/* 0.31.0 */
-export { ComputeEngine } from './compute-engine/index';
-export * from './compute-engine/types';

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

@@ -1,11 +0,0 @@
-/* 0.31.0 */
- * Return true if the string is a valid symbol.
- *
- * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)
- *
- * See https://cortexjs.io/math-json/#symbols for a full definition of the
- * profile.
- */
-export declare function isValidSymbol(s: string): boolean;
-export declare const EMOJIS: RegExp;
-export declare function validateSymbol(s: unknown): 'valid' | 'not-a-string' | 'empty-string' | 'expected-nfc' | 'unexpected-mixed-emoji' | 'unexpected-bidi-marker' | 'unexpected-script' | 'invalid-first-char' | 'invalid-char';

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

@@ -1,122 +0,0 @@
-/* 0.31.0 */
- * The following properties can be added to any MathJSON expression
- * to provide additional information about the expression.
- *
- * @category MathJSON */
-export type MathJsonAttributes = {
-    /** A human readable string to annotate this expression, since JSON does not
-     * allow comments in its encoding */
-    comment?: string;
-    /** A Markdown-encoded string providing documentation about this expression.
-     */
-    documentation?: string;
-    /** A visual representation of this expression as a LaTeX string.
-     *
-     * This can be useful to preserve non-semantic details, for example
-     * parentheses in an expression or styling attributes.
-     */
-    latex?: string;
-    /**
-     * A short string referencing an entry in a wikibase.
-     *
-     * For example:
-     *
-     * `"Q167"` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
-     *  for the `Pi` constant.
-     */
-    wikidata?: string;
-    /** A base URL for the `wikidata` key.
-     *
-     * A full URL can be produced by concatenating this key with the `wikidata`
-     * key. This key applies to this node and all its children.
-     *
-     * The default value is "https://www.wikidata.org/wiki/"
-     */
-    wikibase?: string;
-    /** A short string indicating an entry in an OpenMath Content Dictionary.
-     *
-     * For example: `arith1/#abs`.
-     *
-     */
-    openmathSymbol?: string;
-    /** A base URL for an OpenMath content dictionary. This key applies to this
-     * node and all its children.
-     *
-     * The default value is "http://www.openmath.org/cd".
-     */
-    openmathCd?: string;
-    /**  A URL to the source code from which this expression was generated.
-     */
-    sourceUrl?: string;
-    /** The source code from which this expression was generated.
-     *
-     * It could be a LaTeX expression, or some other source language.
-     */
-    sourceContent?: string;
-    /**
-     * A character offset in `sourceContent` or `sourceUrl` from which this
-     * expression was generated.
-     */
-    sourceOffsets?: [start: number, end: number];
-};
-/** @category MathJSON */
-export type MathJsonSymbol = string;
-/**
- * A MathJSON numeric quantity.
- *
- * The `num` string is made of:
- * - an optional `-` minus sign
- * - a string of decimal digits
- * - an optional fraction part (a `.` decimal marker followed by decimal digits)
- * - an optional repeating decimal pattern: a string of digits enclosed in
- *    parentheses
- * - an optional exponent part (a `e` or `E` exponent marker followed by an
- *   optional `-` minus sign, followed by a string of digits)
- *
- * It can also consist of the string `NaN`, `-Infinity` or `+Infinity` to
- * represent these respective values.
- *
- * A MathJSON number may contain more digits or an exponent with a greater
- * range than can be represented in an IEEE 64-bit floating-point.
- *
- * For example:
- * - `-12.34`
- * - `0.234e-56`
- * - `1.(3)`
- * - `123456789123456789.123(4567)e999`
- * @category MathJSON
- */
-export type MathJsonNumberObject = {
-    num: 'NaN' | '-Infinity' | '+Infinity' | string;
-} & MathJsonAttributes;
-/** @category MathJSON */
-export type MathJsonSymbolObject = {
-    sym: MathJsonSymbol;
-} & MathJsonAttributes;
-/** @category MathJSON */
-export type MathJsonStringObject = {
-    str: string;
-} & MathJsonAttributes;
-/** @category MathJSON */
-export type MathJsonFunctionObject = {
-    fn: [MathJsonSymbol, ...Expression[]];
-} & MathJsonAttributes;
-/** @category MathJSON */
-export type DictionaryValue = boolean | number | string | ExpressionObject | ReadonlyArray<DictionaryValue>;
-/** @category MathJSON */
-export type MathJsonDictionaryObject = {
-    dict: Record<string, DictionaryValue>;
-} & MathJsonAttributes;
-/**
- * @category MathJSON
- */
-export type ExpressionObject = MathJsonNumberObject | MathJsonStringObject | MathJsonSymbolObject | MathJsonFunctionObject | MathJsonDictionaryObject;
-/**
- * A MathJSON expression is a recursive data structure.
- *
- * The leaf nodes of an expression are numbers, strings and symbols.
- * The dictionary and function nodes can contain expressions themselves.
- *
- * @category MathJSON
- */
-export type Expression = ExpressionObject | number | MathJsonSymbol | string | readonly [MathJsonSymbol, ...Expression[]];