@cortex-js/compute-engine 0.25.0 → 0.26.0

package/dist/types/compute-engine/numeric-value/exact-numeric-value.d.ts

@@ -0,0 +1,77 @@
+/* 0.26.0 */
+import { SmallInteger } from '../numerics/numeric';
+import { Rational } from '../numerics/rationals';
+import { ExactNumericValueData, NumericValue, NumericValueFactory } from './public';
+import { Expression } from '../../math-json/types';
+import { BigNumFactory } from './big-numeric-value';
+import { NumericType } from '../../common/type/types';
+/**
+ * An ExactNumericValue is the sum of a Gaussian imaginary and the product of
+ * a rational number and a square root:
+ *
+ *     a/b * sqrt(c) + ki where a, b, c and k are integers
+ *
+ * Note that ExactNumericValue does not "know" about BigNumericValue, but
+ * BigNumericValue "knows" about ExactNumericValue.
+ *
+ */
+export declare class ExactNumericValue extends NumericValue {
+    __brand: 'ExactNumericValue';
+    rational: Rational;
+    radical: number;
+    im: number;
+    factory: NumericValueFactory;
+    bignum: BigNumFactory;
+    /** The caller is responsible to make sure the input is valid, i.e.
+     * - rational is a fraction of integers (but it may not be reduced)
+     * - radical is an integer
+     */
+    constructor(value: number | bigint | ExactNumericValueData, factory: NumericValueFactory, bignum: BigNumFactory);
+    get type(): NumericType;
+    get isExact(): boolean;
+    get asExact(): NumericValue | undefined;
+    toJSON(): Expression;
+    clone(value: number | ExactNumericValueData): ExactNumericValue;
+    /** Object.toString() */
+    toString(): string;
+    get sign(): -1 | 0 | 1;
+    get re(): number;
+    get bignumRe(): Decimal;
+    get numerator(): ExactNumericValue;
+    get denominator(): ExactNumericValue;
+    normalize(): void;
+    get isNaN(): boolean;
+    get isPositiveInfinity(): boolean;
+    get isNegativeInfinity(): boolean;
+    get isComplexInfinity(): boolean;
+    get isZero(): boolean;
+    get isOne(): boolean;
+    get isNegativeOne(): boolean;
+    sgn(): -1 | 0 | 1 | undefined;
+    N(): NumericValue;
+    neg(): ExactNumericValue;
+    inv(): NumericValue;
+    add(other: number | NumericValue): NumericValue;
+    sub(other: NumericValue): NumericValue;
+    mul(other: number | Decimal | NumericValue): NumericValue;
+    div(other: SmallInteger | NumericValue): NumericValue;
+    pow(exponent: number | NumericValue | {
+        re: number;
+        im: number;
+    }): NumericValue;
+    root(exponent: number): NumericValue;
+    sqrt(): NumericValue;
+    gcd(other: NumericValue): NumericValue;
+    abs(): NumericValue;
+    ln(base?: number): NumericValue;
+    exp(): NumericValue;
+    floor(): NumericValue;
+    ceil(): NumericValue;
+    round(): NumericValue;
+    eq(other: number | NumericValue): boolean;
+    lt(other: number | NumericValue): boolean | undefined;
+    lte(other: number | NumericValue): boolean | undefined;
+    gt(other: number | NumericValue): boolean | undefined;
+    gte(other: number | NumericValue): boolean | undefined;
+    static sum(values: NumericValue[], factory: NumericValueFactory, bignumFactory: BigNumFactory): NumericValue[];
+}

package/dist/types/compute-engine/numeric-value/machine-numeric-value.d.ts

@@ -0,0 +1,58 @@
+/* 0.26.0 */
+import { NumericValue, NumericValueData } from './public';
+import type { Expression } from '../../math-json/types';
+import { SmallInteger } from '../numerics/numeric';
+import { NumericType } from '../../common/type/types';
+import { BigNumFactory } from './big-numeric-value';
+export declare class MachineNumericValue extends NumericValue {
+    __brand: 'MachineNumericValue';
+    decimal: number;
+    im: number;
+    bignum: BigNumFactory;
+    constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
+    private _makeExact;
+    get type(): NumericType;
+    get isExact(): boolean;
+    get asExact(): NumericValue | undefined;
+    toJSON(): Expression;
+    toString(): string;
+    clone(value: number | Decimal | NumericValueData): MachineNumericValue;
+    get re(): number;
+    get bignumRe(): Decimal | undefined;
+    get numerator(): MachineNumericValue;
+    get denominator(): NumericValue;
+    get isNaN(): boolean;
+    get isPositiveInfinity(): boolean;
+    get isNegativeInfinity(): boolean;
+    get isComplexInfinity(): boolean;
+    get isZero(): boolean;
+    isZeroWithTolerance(tolerance: number | Decimal): boolean;
+    get isOne(): boolean;
+    get isNegativeOne(): boolean;
+    sgn(): -1 | 0 | 1 | undefined;
+    N(): NumericValue;
+    neg(): NumericValue;
+    inv(): NumericValue;
+    add(other: number | NumericValue): NumericValue;
+    sub(other: NumericValue): NumericValue;
+    mul(other: number | Decimal | NumericValue): NumericValue;
+    div(other: SmallInteger | NumericValue): NumericValue;
+    pow(exponent: number | {
+        re: number;
+        im: number;
+    }): NumericValue;
+    root(exponent: number): NumericValue;
+    sqrt(): NumericValue;
+    gcd(other: NumericValue): NumericValue;
+    abs(): NumericValue;
+    ln(base?: number): NumericValue;
+    exp(): NumericValue;
+    floor(): NumericValue;
+    ceil(): NumericValue;
+    round(): NumericValue;
+    eq(other: number | NumericValue): boolean;
+    lt(other: number | NumericValue): boolean | undefined;
+    lte(other: number | NumericValue): boolean | undefined;
+    gt(other: number | NumericValue): boolean | undefined;
+    gte(other: number | NumericValue): boolean | undefined;
+}

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

@@ -0,0 +1,110 @@
+/* 0.26.0 */
+ *
+ * ## THEORY OF OPERATIONS
+ *
+ * A numeric value represents a number literal.
+ *
+ * It is defined as a functional field over the complex numbers.
+ *
+ * It includes basic arithmetic operations: addition, subtraction,
+ * multiplication, power, division, negation, inversion, square root.
+ *
+ * Several flavors of numeric values are available:
+ * - `NumericValue` is the base class for all numeric values.
+ * - `ExactNumericValue` is a numeric value that represents numbers as the
+ *    sum of an imaginary number and the product of a rational and a radical
+ *    (square root of a integer).
+ * - `BigNumericValue` is a numeric value that represents numbers as the
+ *   sum of an imaginary number and a decimal (arbitrary precision) number.
+ *
+ * An exact numeric value may need to be converted to a float one, for
+ *   example when calculating the square root of a square root.
+ *
+ * A float numeric value is never converted to an exact one.
+ *
+ */
+import Decimal from 'decimal.js';
+import { SmallInteger } from '../numerics/numeric';
+import { Rational } from '../numerics/rationals';
+import { NumericType } from '../../common/type/types';
+/** The value is equal to `(decimal * rational * sqrt(radical)) + im * i` */
+export type ExactNumericValueData = {
+    rational?: Rational;
+    radical?: number;
+};
+export type NumericValueData = {
+    re?: Decimal | number;
+    im?: number;
+};
+export type NumericValueFactory = (data: number | Decimal | NumericValueData) => NumericValue;
+export declare abstract class NumericValue {
+    abstract get type(): NumericType;
+    /** True if numeric value is the product of a rational and the square root of an integer.
+     *
+     * This includes: 3/4√5, -2, √2, etc...
+     *
+     * But it doesn't include 0.5, 3.141592, etc...
+     *
+     */
+    abstract get isExact(): boolean;
+    /** If `isExact()`, returns an ExactNumericValue, otherwise returns undefined.
+     */
+    abstract get asExact(): NumericValue | undefined;
+    /** The real part of this numeric value.
+     *
+     * Can be negative, 0 or positive.
+     */
+    abstract get re(): number;
+    /**  bignum version of .re, if available */
+    get bignumRe(): Decimal | undefined;
+    /** The imaginary part of this numeric value.
+     *
+     * Can be negative, zero or positive.
+     */
+    readonly im: number;
+    get bignumIm(): Decimal | undefined;
+    abstract get numerator(): NumericValue;
+    abstract get denominator(): NumericValue;
+    abstract get isNaN(): boolean;
+    abstract get isPositiveInfinity(): boolean;
+    abstract get isNegativeInfinity(): boolean;
+    abstract get isComplexInfinity(): boolean;
+    abstract get isZero(): boolean;
+    isZeroWithTolerance(_tolerance: number | Decimal): boolean;
+    abstract get isOne(): boolean;
+    abstract get isNegativeOne(): boolean;
+    /** The sign of complex numbers is undefined */
+    abstract sgn(): -1 | 0 | 1 | undefined;
+    abstract N(): NumericValue;
+    abstract neg(): NumericValue;
+    abstract inv(): NumericValue;
+    abstract add(other: number | NumericValue): NumericValue;
+    abstract sub(other: NumericValue): NumericValue;
+    abstract mul(other: number | Decimal | NumericValue): NumericValue;
+    abstract div(other: SmallInteger | NumericValue): NumericValue;
+    abstract pow(n: number | NumericValue | {
+        re: number;
+        im: number;
+    }): NumericValue;
+    abstract root(n: number): NumericValue;
+    abstract sqrt(): NumericValue;
+    abstract gcd(other: NumericValue): NumericValue;
+    abstract abs(): NumericValue;
+    abstract ln(base?: number): NumericValue;
+    abstract exp(): NumericValue;
+    abstract floor(): NumericValue;
+    abstract ceil(): NumericValue;
+    abstract round(): NumericValue;
+    abstract eq(other: number | NumericValue): boolean;
+    abstract lt(other: number | NumericValue): boolean | undefined;
+    abstract lte(other: number | NumericValue): boolean | undefined;
+    abstract gt(other: number | NumericValue): boolean | undefined;
+    abstract gte(other: number | NumericValue): boolean | undefined;
+    /** Object.valueOf(): returns a primitive value */
+    valueOf(): number | string;
+    /** Object.toPrimitive() */
+    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
+    /** Object.toJSON */
+    toJSON(): any;
+    print(): void;
+}

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

@@ -0,0 +1,2 @@
+/* 0.26.0 */
+export declare function bigint(a: Decimal | number | bigint | string): bigint | null;

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

@@ -0,0 +1,12 @@
+/* 0.26.0 */
+export type BigNum = Decimal;
+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;
+}

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

@@ -0,0 +1,4 @@
+/* 0.26.0 */
+export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
+/** Output a shorthand if possible */
+export declare function numberToExpression(num: number | bigint): Expression;

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

@@ -0,0 +1,12 @@
+/* 0.26.0 */
+/** An interval is a continuous set of real numbers */
+export type Interval = {
+    start: number;
+    openStart: boolean;
+    end: number;
+    openEnd: boolean;
+};
+export declare function interval(expr: BoxedExpression): Interval | undefined;
+export declare function intervalContains(int: Interval, val: number): boolean;
+/** Return true if int1 is a subset of int2 */
+export declare function intervalSubset(int1: Interval, int2: Interval): boolean;

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

@@ -0,0 +1,19 @@
+/* 0.26.0 */
+ * Return a numerical approximation of the integral
+ * of the function `f` from `a` to `b` using Monte Carlo integration.
+ *
+ * Thoughts for future improvements:
+ * - use a MISER algorithm to improve the accuracy
+ * - use a stratified sampling to improve the accuracy
+ * - use a quasi-Monte Carlo method to improve the accuracy
+ * - use a Markov Chain Monte Carlo method to improve the accuracy
+ * - use a Metropolis-Hastings algorithm to improve the accuracy
+ * - use a Hamiltonian Monte Carlo algorithm to improve the accuracy
+ * - use a Gibbs sampling algorithm to improve the accuracy
+ *
+ *
+ * See:
+ * - https://64.github.io/monte-carlo/
+ *
+ */
+export declare function monteCarloEstimate(f: (x: number) => number, a: number, b: number, n?: number): number;

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

@@ -1,20 +1,10 @@
-/* 0.25.0 */
-import { Expression } from '../../math-json';
-export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
-export declare function bigint(a: Decimal | number | bigint | string): bigint;
-export declare function gcd(a: bigint, b: bigint): bigint;
+/* 0.26.0 */
 export declare function lcm(a: bigint, b: bigint): bigint;
-export declare function primeFactors(d: bigint): Map<bigint, number>;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
  *
- * factorPower(75, 2) -> [5, 3] = 5^2 * 3
+ * canonicalInteger(75, 2) -> [5, 3] = 5^2 * 3
  *
  */
-export declare function factorPower(n: bigint, exponent: number): [factor: bigint, root: bigint];
-/**
- * Return a, b, c such that n = a * b^c
- * @param n
- *
- */
-export declare function canonicalInteger(n: bigint): [a: bigint, b: bigint, c: bigint];
+export declare function canonicalInteger(n: bigint, exponent: number): [factor: bigint, root: bigint];
+export declare function reducedInteger(n: bigint): bigint | number;

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

@@ -1,13 +1,10 @@
-/* 0.25.0 */
-import { IComputeEngine } from '../public';
-export declare function gcd(a: Decimal, b: Decimal): Decimal;
-export declare function lcm(a: Decimal, b: Decimal): Decimal;
-export declare function factorial(ce: IComputeEngine, n: Decimal): Decimal;
-export declare function factorial2(ce: IComputeEngine, n: Decimal): Decimal;
-export declare function gammaln(ce: IComputeEngine, z: Decimal): Decimal;
-export declare function gamma(ce: IComputeEngine, z: Decimal): Decimal;
+/* 0.26.0 */
+export declare function gcd(a: BigNum, b: BigNum): BigNum;
+export declare function lcm(a: BigNum, b: BigNum): BigNum;
+export declare function factorial(ce: IBigNum, n: 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: Decimal): boolean;
+export declare function isInMachineRange(d: BigNum): boolean;

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

@@ -1,3 +1,3 @@
-/* 0.25.0 */
+/* 0.26.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,11 +1,13 @@
-/* 0.25.0 */
-import { Decimal } from 'decimal.js';
+/* 0.26.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const MACHINE_TOLERANCE_BITS = 7;
 export declare const MACHINE_TOLERANCE: number;
-export declare const NUMERIC_TOLERANCE: number;
 export declare const SMALL_INTEGER = 1000000;
+type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
+export type SmallInteger = IsInteger<number>;
+/** 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;
 /**
@@ -14,50 +16,18 @@ export declare const MAX_SYMBOLIC_TERMS = 200;
  */
 export declare function nextUp(x: number): number;
 export declare function nextDown(x: number): number;
-/**
- * Return a, b, c such that n = a * b^c
- * @param n
- *
- */
-export declare function canonicalInteger(n: number): [a: number, b: number, c: number];
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
  *
- * factorPower(75, 2) -> [5, 3] = 5^2 * 3
+ * canonicalInteger(75, 2) -> [5, 3] = 5^2 * 3
  *
  */
-export declare function factorPower(n: number, exponent: number): [factor: number, root: number];
+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 gammaln(z: number): number;
-export declare function gamma(z: number): number;
-export declare function chop(n: number, tolerance: number): number;
-export declare function chop(n: Decimal, tolerance: number): 0 | Decimal;
-export declare function chop(n: Complex, tolerance: number): 0 | Complex;
-/**
- * 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;
-/**
- * Trivial function, used when compiling.
- */
-export declare function erfc(x: number): number;
-/**
- * Inverse Error Function.
- *
- */
-export declare function erfInv(x: 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.
@@ -77,25 +47,6 @@ export declare function erfInv(x: number): number;
  * See https://en.wikipedia.org/wiki/Finite_difference_coefficient
  */
 export declare function centeredDiff8thOrder(f: (number: any) => number, x: number, h?: number): number;
-/**
- * Return a numerical approximation of the integral
- * of the function `f` from `a` to `b` using Monte Carlo integration.
- *
- * Thoughts for future improvements:
- * - use a MISER algorithm to improve the accuracy
- * - use a stratified sampling to improve the accuracy
- * - use a quasi-Monte Carlo method to improve the accuracy
- * - use a Markov Chain Monte Carlo method to improve the accuracy
- * - use a Metropolis-Hastings algorithm to improve the accuracy
- * - use a Hamiltonian Monte Carlo algorithm to improve the accuracy
- * - use a Gibbs sampling algorithm to improve the accuracy
- *
- *
- * See:
- * - https://64.github.io/monte-carlo/
- *
- */
-export declare function monteCarloEstimate(f: (x: number) => number, a: number, b: number, n?: number): number;
 /**
  *
  * @param f
@@ -104,5 +55,4 @@ export declare function monteCarloEstimate(f: (x: number) => number, a: number,
  * @returns
  */
 export declare function limit(f: (x: number) => number, x: number, dir?: number): number;
-export declare function fromRoman(roman: string): [result: number, rest: string];
-export declare function fromDigits(s: string, baseInput?: string | number): [result: number, rest: string];
+export {};

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

@@ -1,7 +1,7 @@
-/* 0.25.0 */
-export declare const SMALL_PRIMES: Set<number>;
-export declare const LARGEST_SMALL_PRIME = 7919;
+/* 0.26.0 */
 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

@@ -1,31 +1,47 @@
-/* 0.25.0 */
+/* 0.26.0 */
+/**
  * @category Boxed Expression
  */
-export type Rational = [number, number] | [bigint, bigint];
+export type Rational = [SmallInteger, SmallInteger] | [bigint, bigint];
 export declare function isRational(x: any | null): x is Rational;
-export declare function isMachineRational(x: any | null): x is [number, number];
+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 isRationalZero(x: Rational): boolean;
-export declare function isRationalOne(x: Rational): boolean;
-export declare function isRationalInteger(x: Rational): boolean;
-export declare function isRationalNegativeOne(x: Rational): boolean;
+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 neg(x: [number, number]): [number, number];
+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: [number, number]): [number, number];
+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 pow(r: Rational, exp: number): 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 reducedRational(r: [number, number]): [number, number];
+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) = n
+/** 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: Rational];
+export declare function reduceRationalSquareRoot(n: Rational): [factor: Rational, root: number | bigint];

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

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

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

@@ -0,0 +1,28 @@
+/* 0.26.0 */
+import { BigNum } from './bignum';
+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: IComputeEngine, z: BigNum): BigNum;
+export declare function bigGamma(ce: IComputeEngine, z: BigNum): BigNum;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.25.0 */
+/* 0.26.0 */
  *
  * The Compute Engine is a symbolic computation engine that can be used to
  * manipulate and evaluate mathematical expressions.
@@ -12,7 +12,8 @@
  * @module "compute-engine"
  *
  */
-import { FunctionDefinition, SemiBoxedExpression, SymbolDefinition } from './boxed-expression/public';
+import type { OneOf } from '../common/one-of';
+import type { FunctionDefinition, SemiBoxedExpression, SymbolDefinition } from './boxed-expression/public';
 export * from './boxed-expression/public';
 /**
  * A table mapping identifiers to their definition.
@@ -24,11 +25,14 @@ export * from './boxed-expression/public';
  * - The first character should be a letter: `/^[a-zA-Z]/`
  * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
  *
- * If a semi boxed expression
  * @category Definitions
  *
  */
-export type IdentifierDefinition = SymbolDefinition | FunctionDefinition | SemiBoxedExpression;
+export type IdentifierDefinition = OneOf<[
+    SymbolDefinition,
+    FunctionDefinition,
+    SemiBoxedExpression
+]>;
 /**
  * @category Definitions
  *

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

@@ -1,4 +1,4 @@
-/* 0.25.0 */
+/* 0.26.0 */
 /**
  *
  * @param fn The function to differentiate, a `["Function"]` expression or
@@ -8,7 +8,7 @@
  * @returns a function expression representing the derivative of `fn` with
  * respect to the variables in `degrees`.
  */
-export declare function differentiateFunction(fn: BoxedExpression, degrees: number[]): BoxedExpression | undefined;
+export declare function derivative(fn: BoxedExpression, order: number): BoxedExpression | undefined;
 /**
  * Calculate the partial derivative of an expression with respect to a
  * variable, `v`.

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

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

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

@@ -1,4 +1,4 @@
-/* 0.25.0 */
+/* 0.26.0 */
 /**
  * @todo: a set to "tidy" an expression. Different from a canonical form, but
  * inline with the user's expectations.

package/dist/types/compute-engine/{symbolic → tensor}/tensors.d.ts

@@ -1,5 +1,5 @@
-/* 0.25.0 */
-import { DataTypeMap, TensorDataType, TensorField } from './tensor-fields';
+/* 0.26.0 */
+import { DataTypeMap, TensorDataType, TensorField } from '../boxed-expression/tensor-fields';
 /**
  * @noInheritDoc
  */
@@ -99,7 +99,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
     equals(rhs: AbstractTensor<DT>): boolean;
 }
 export declare function makeTensor<T extends TensorDataType>(ce: IComputeEngine, data: TensorData<T> | {
-    head: string;
+    operator: string;
     ops: BoxedExpression[];
     dtype: T;
     shape: number[];