@cortex-js/compute-engine 0.30.2 → 0.32.0

package/dist/types/compute-engine/latex-syntax/utils.d.ts

@@ -1,5 +0,0 @@
-/* 0.30.2 */
-export declare function asLatexString(s: unknown): string | null;
-export declare function isRelationalOperator(name: string | undefined): boolean;
-export declare function isInequalityOperator(operator: string | undefined): boolean;
-export declare function isEquationOperator(operator: string | undefined): boolean;

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

@@ -1,4 +0,0 @@
-/* 0.30.2 */
-export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
-export declare const ARITHMETIC_LIBRARY: SymbolDefinitions[];
-export declare function isPrime(expr: BoxedExpression): boolean | undefined;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,27 +0,0 @@
-/* 0.30.2 */
-export declare const DEFAULT_LINSPACE_COUNT = 50;
-export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
-/**
- * Normalize the arguments of range:
- * - [from, to] -> [from, to, 1] if to > from, or [from, to, -1] if to < from
- * - [x] -> [1, x]
- * - arguments rounded to integers
- *
- */
-export declare function range(expr: BoxedExpression): [lower: number, upper: number, step: number];
-/** Return the last value in the range
- * - could be less that lower if step is negative
- * - could be less than upper if step is positive, for
- * example `rangeLast([1, 6, 2])` = 5
- */
-export declare function rangeLast(r: [lower: number, upper: number, step: number]): number;
-/**
- * This function is used to reduce a collection of expressions to a single value. It
- * iterates over the collection, applying the given function to each element and the
- * accumulator. If the function returns `null`, the iteration is stopped and `undefined`
- * is returned. Otherwise, the result of the function is used as the new accumulator.
- * If the iteration completes, the final accumulator is returned.
- */
-export declare function reduceCollection<T>(collection: BoxedExpression, fn: (acc: T, next: BoxedExpression) => T | null, initial: T): Generator<T | undefined>;
-export declare function fromRange(start: number, end: number): number[];
-export declare function sortedIndices(expr: BoxedExpression, fn?: BoxedExpression | undefined): number[] | undefined;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const CORE_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +0,0 @@
-/* 0.30.2 */
-export declare function canonicalInvisibleOperator(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | null;

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

@@ -1,17 +0,0 @@
-/* 0.30.2 */
-import type { SymbolDefinitions, ComputeEngine } from '../global-types';
-export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
-export declare const LIBRARIES: {
-    [category in LibraryCategory]?: SymbolDefinitions | SymbolDefinitions[];
-};
-/**
- * Set the symbol table of the current context (`engine.context`) to `table`
- *
- * `table` can be an array of symbol tables, in order to deal with circular
- * dependencies: it is possible to partition a library into multiple
- * symbol tables, to control the order in which they are processed and
- * avoid having expressions in the definition of an entry reference a symbol
- * or function name that has not yet been added to the symbol table.
- *
- */
-export declare function setSymbolDefinitions(engine: ComputeEngine, table: SymbolDefinitions): void;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

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

@@ -1,6 +0,0 @@
-/* 0.30.2 */
-export declare const LOGIC_LIBRARY: SymbolDefinitions;
-export declare function simplifyLogicFunction(x: BoxedExpression): {
-    value: BoxedExpression;
-    because: string;
-} | undefined;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

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

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

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const SETS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +0,0 @@
-/* 0.30.2 */
-export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

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

@@ -1,77 +0,0 @@
-/* 0.30.2 */
-export type IndexingSet = {
-    index: string | undefined;
-    lower: number;
-    upper: number;
-    isFinite: boolean;
-};
-/**
- * IndexingSet is an expression describing an index variable
- * and a range of values for that variable.
- *
- * Note that when this function is called the indexing set is assumed to be canonical: 'Hold' has been handled, the indexing set is a tuple, and the bounds are canonical.
- *
- * This can take several valid forms:
- * - a symbol, e.g. `n`, the upper and lower bounds are assumed ot be infinity
- * - a tuple, e.g. `["Pair", "n", 1]` or `["Tuple", "n", 1, 10]` with one
- *   or two bounds
- *
- * The result is a normalized version that includes the index, the lower and
- * upper bounds of the range, and a flag indicating whether the range is finite.
- * @param indexingSet
- * @returns
- */
-export declare function normalizeIndexingSet(indexingSet: BoxedExpression): IndexingSet;
-export declare function normalizeIndexingSets(ops: ReadonlyArray<BoxedExpression>): IndexingSet[];
-export declare function indexingSetCartesianProduct(indexingSets: IndexingSet[]): number[][];
-/**
- * Calculates the cartesian product of two arrays.
- * ```ts
- * // Example usage
- * const array1 = [1, 2, 3];
- * const array2 = ['a', 'b', 'c'];
- * const result = cartesianProduct(array1, array2);
- * console.log(result);
- * // Output: [[1, 'a'], [1, 'b'], [1, 'c'], [2, 'a'], [2, 'b'], [2, 'c'], [3, 'a'], [3, 'b'], [3, 'c']]
- * ```
- * @param array1 - The first array.
- * @param array2 - The second array.
- * @returns The cartesian product as a 2D array.
- */
-export declare function cartesianProduct(array1: number[], array2: number[]): number[][];
-/** Given a sequence of arguments, return an array of Limits:
- *
- * - ["Range", 1, 10] -> ["Limits", "Unknown", 1, 10]
- * - 1, 10 -> ["Limits", "Nothing", 1, 10]
- * - [Tuple, "x", 1, 10] -> ["Limits", "x", 1, 10]
- *
- */
-export declare function canonicalLimitsSequence(ops: ReadonlyArray<BoxedExpression>, options: {
-    engine: ComputeEngine;
-}): BoxedExpression[];
-export declare function canonicalLimits(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | null;
-/** Return a limit/indexing set in canonical form as a `Limits` expression
- * with:
- * - `index` (a symbol), `Nothing` if none is present
- * - `lower` (a number), `Nothing` if none is present
- * - `upper` (a number), `Nothing` if none is present
- *
- * Assume we are in the context of a big operator
- * (i.e. `pushScope()` has been called)
- */
-export declare function canonicalIndexingSet(expr: BoxedExpression): BoxedExpression | undefined;
-export declare function canonicalBigop(bigOp: string, body: BoxedExpression, indexingSets: BoxedExpression[], scope: Scope | undefined): BoxedExpression | null;
-/**
- * Process an expression of the form
- * - ['Operator', body, ['Tuple', index1, lower, upper]]
- * - ['Operator', body, ['Tuple', index1, lower, upper], ['Tuple', index2, lower, upper], ...]
- * - ['Operator', body]
- * - ['Operator', collection]
- *
- * `fn()` is the processing done on each element
- * Apply the function `fn` to the body of a big operator, according to the
- * indexing sets.
- */
-export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | undefined>;

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

@@ -1,57 +0,0 @@
-/* 0.30.2 */
-import { BigNumFactory, NumericValue, NumericValueData } from './types';
-import { ExactNumericValue } from './exact-numeric-value';
-import { Expression } from '../../math-json/types';
-import { SmallInteger } from '../numerics/types';
-import { NumericPrimitiveType } from '../../common/type/types';
-export declare class BigNumericValue extends NumericValue {
-    __brand: 'BigNumericValue';
-    decimal: Decimal;
-    bignum: BigNumFactory;
-    constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
-    get type(): NumericPrimitiveType;
-    get isExact(): boolean;
-    get asExact(): ExactNumericValue | undefined;
-    toJSON(): Expression;
-    toString(): string;
-    clone(value: number | Decimal | NumericValueData): BigNumericValue;
-    private _makeExact;
-    get re(): number;
-    get bignumRe(): Decimal;
-    get numerator(): BigNumericValue;
-    get denominator(): ExactNumericValue;
-    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(): BigNumericValue;
-    inv(): BigNumericValue;
-    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(exp: 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/exact-numeric-value.d.ts

@@ -1,75 +0,0 @@
-/* 0.30.2 */
-import { Rational, SmallInteger } from '../numerics/types';
-import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
-import { Expression } from '../../math-json/types';
-import { NumericPrimitiveType } 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(): NumericPrimitiveType;
-    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

@@ -1,56 +0,0 @@
-/* 0.30.2 */
-import { BigNumFactory, NumericValue, NumericValueData } from './types';
-import type { Expression } from '../../math-json/types';
-import type { SmallInteger } from '../numerics/types';
-import { NumericPrimitiveType } from '../../common/type/types';
-export declare class MachineNumericValue extends NumericValue {
-    __brand: 'MachineNumericValue';
-    decimal: number;
-    bignum: BigNumFactory;
-    constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
-    private _makeExact;
-    get type(): NumericPrimitiveType;
-    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/types.d.ts

@@ -1,116 +0,0 @@
-/* 0.30.2 */
- *
- * ## 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 type { Rational, SmallInteger } from '../numerics/types';
-import { NumericPrimitiveType } from '../../common/type/types';
-export type BigNumFactory = (value: Decimal.Value) => Decimal;
-/** The value is equal to `(decimal * rational * sqrt(radical)) + im * i`
- * @category Numerics */
-export type ExactNumericValueData = {
-    rational?: Rational;
-    radical?: number;
-};
-/** @category Numerics */
-export type NumericValueData = {
-    re?: Decimal | number;
-    im?: number;
-};
-/** @category Numerics */
-export type NumericValueFactory = (data: number | Decimal | NumericValueData) => NumericValue;
-/** @category Numerics */
-export declare abstract class NumericValue {
-    abstract get type(): NumericPrimitiveType;
-    /** 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.
-     */
-    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;
-    /** Return a non-exact representation of the numeric value */
-    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, preferably a JavaScript
-     *  number over a string, even if at the expense of precision */
-    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

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

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

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

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

@@ -1,12 +0,0 @@
-/* 0.30.2 */
-/** 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

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

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

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

@@ -1,9 +0,0 @@
-/* 0.30.2 */
-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

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

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

@@ -1,60 +0,0 @@
-/* 0.30.2 */
-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

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