@cortex-js/compute-engine 0.32.0 → 0.32.1

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

@@ -0,0 +1,4 @@
+/* 0.32.1 */
+    estimate: number;
+    error: number;
+};

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

@@ -0,0 +1,18 @@
+/* 0.32.1 */
+export declare function lcm(a: bigint, b: bigint): bigint;
+/** Return `[factor, root]` such that
+ * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
+ *
+ * canonicalInteger(75, 2) -> [5, 3] = 5^2 * 3
+ *
+ */
+export declare function canonicalInteger(n: bigint, exponent: number): [factor: bigint, root: bigint];
+export declare function reducedInteger(n: bigint): bigint | number;
+/**
+ * Computes the factorial of a number as a generator to allow interruptibility.
+ * Yields intermediate values periodically, but these are not intended to be the primary result.
+ *
+ * @param n - The number to compute the factorial of (as a BigInt).
+ * @returns A generator that can be iterated for intermediate values, with the final value returned when the computation completes.
+ */
+export declare function factorial(n: bigint): Generator<bigint, bigint>;

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

@@ -0,0 +1,9 @@
+/* 0.32.1 */
+export declare function gcd(a: BigNum, b: BigNum): BigNum;
+export declare function lcm(a: BigNum, b: BigNum): BigNum;
+export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;
+/**
+ * If the exponent of the bignum is in the range of the exponents
+ * for machine numbers,return true.
+ */
+export declare function isInMachineRange(d: BigNum): boolean;

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

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

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

@@ -0,0 +1,60 @@
+/* 0.32.1 */
+export declare const MACHINE_PRECISION_BITS = 53;
+export declare const MACHINE_PRECISION: number;
+export declare const DEFAULT_TOLERANCE = 1e-10;
+export declare const SMALL_INTEGER = 1000000;
+/** The largest number of digits of a bigint */
+export declare const MAX_BIGINT_DIGITS = 1024;
+export declare const MAX_ITERATION = 1000000;
+export declare const MAX_SYMBOLIC_TERMS = 200;
+/**
+ * Returns the smallest floating-point number greater than x.
+ * Denormalized values may not be supported.
+ */
+export declare function nextUp(x: number): number;
+export declare function nextDown(x: number): number;
+/** Return `[factor, root]` such that
+ * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
+ *
+ * canonicalInteger(75, 2) -> [5, 3] = 5^2 * 3
+ *
+ */
+export declare function canonicalInteger(n: number, exponent: number): readonly [factor: number, root: number];
+export declare function gcd(a: number, b: number): number;
+export declare function lcm(a: number, b: number): number;
+export declare function factorial(n: number): number;
+export declare function factorial2(n: number): number;
+export declare function chop(n: number, tolerance?: number): 0 | number;
+/**
+ * An 8th-order centered difference approximation can be used to get a highly
+ * accurate approximation of the first derivative of a function.
+ * The formula for the 8th-order centered difference approximation for the
+ * first derivative is given by:
+ *
+ * $$ f'(x) \approx \frac{1}{280h} \left[ -f(x-4h) + \frac{4}{3}f(x-3h) - \frac{1}{5}f(x-2h) + \frac{8}{5}f(x-h) - \frac{8}{5}f(x+h) + \frac{1}{5}f(x+2h) - \frac{4}{3}f(x+3h) + f(x+4h) \right]$$
+ *
+ * Note: Mathematica uses an 8th order approximation for the first derivative
+ *
+ * f: the function
+ * x: the point at which to approximate the derivative
+ * h: the step size
+ *
+ * See https://en.wikipedia.org/wiki/Finite_difference_coefficient
+ */
+export declare function centeredDiff8thOrder(f: (number: any) => number, x: number, h?: number): number;
+/**
+ *
+ * @param f
+ * @param x
+ * @param dir Direction of approach: > 0 for right, < 0 for left, 0 for both
+ * @returns
+ */
+export declare function limit(f: (x: number) => number, x: number, dir?: number): number;
+export declare function cantorEnumerateRationals(): Generator<[number, number]>;
+export declare function cantorEnumeratePositiveRationals(): Generator<[
+    number,
+    number
+]>;
+export declare function cantorEnumerateComplexNumbers(): Generator<[number, number]>;
+export declare function cantorEnumerateIntegers(): Generator<number>;
+export declare function cantorEnumerateNaturalNumbers(): Generator<number>;

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

@@ -0,0 +1,7 @@
+/* 0.32.1 */
+export declare function primeFactors(n: number): {
+    [factor: number]: number;
+};
+export declare function isPrime(n: number): boolean | undefined;
+export declare function isPrimeBigint(n: bigint): boolean | undefined;
+export declare function bigPrimeFactors(d: bigint): Map<bigint, number>;

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

@@ -0,0 +1,43 @@
+/* 0.32.1 */
+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

@@ -0,0 +1,80 @@
+/* 0.32.1 */
+
+    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

@@ -0,0 +1,28 @@
+/* 0.32.1 */
+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

@@ -0,0 +1,24 @@
+/* 0.32.1 */
+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

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

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

@@ -0,0 +1,30 @@
+/* 0.32.1 */
+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

@@ -0,0 +1,3 @@
+/* 0.32.1 */
+/** 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

@@ -0,0 +1,18 @@
+/* 0.32.1 */
+/**
+ *
+ * @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

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

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

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

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

@@ -0,0 +1,27 @@
+/* 0.32.1 */
+/**
+ * @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/symbolic/simplify-sum.d.ts

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

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

@@ -0,0 +1,128 @@
+/* 0.32.1 */
+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

@@ -0,0 +1,93 @@
+/* 0.32.1 */
+/** @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

@@ -0,0 +1,8 @@
+/* 0.32.1 */
+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

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

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

@@ -0,0 +1,11 @@
+/* 0.32.1 */
+ * 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';