@cortex-js/compute-engine 0.32.0 → 0.33.0

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

@@ -0,0 +1,5 @@
+/* 0.33.0 */
+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

@@ -0,0 +1,4 @@
+/* 0.33.0 */
+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

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

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

@@ -0,0 +1,27 @@
+/* 0.33.0 */
+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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+/* 0.33.0 */
+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

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

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

@@ -0,0 +1,94 @@
+/* 0.33.0 */
+/**
+ * Quantifier domain helpers and boolean analysis functions.
+ * Extracted from logic.ts for better code organization.
+ */
+/**
+ * Result of extracting a finite domain from an Element expression.
+ * - `status: 'success'` - Domain was successfully extracted
+ * - `status: 'non-enumerable'` - Domain exists but cannot be enumerated (e.g., infinite set, unknown symbol)
+ * - `status: 'error'` - Invalid Element expression (missing variable, malformed domain)
+ */
+export type ExtractDomainResult = {
+    status: 'success';
+    variable: string;
+    values: BoxedExpression[];
+} | {
+    status: 'non-enumerable';
+    variable: string;
+    domain: BoxedExpression;
+    reason: string;
+} | {
+    status: 'error';
+    reason: string;
+};
+/**
+ * Extract the finite domain from a quantifier's condition.
+ * Supports:
+ * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
+ * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
+ * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
+ * - ["Element", "x", ["Set", 1, 2, 3], condition] → filtered values (EL-3)
+ * Returns detailed result indicating success, non-enumerable domain, or error.
+ */
+export declare function extractFiniteDomainWithReason(condition: BoxedExpression, ce: ComputeEngine): ExtractDomainResult;
+/**
+ * Extract the finite domain from a quantifier's condition.
+ * Supports:
+ * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
+ * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
+ * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
+ * Returns null if the domain is not finite or not recognized.
+ * @deprecated Use extractFiniteDomainWithReason for better error handling
+ */
+export declare function extractFiniteDomain(condition: BoxedExpression, ce: ComputeEngine): {
+    variable: string;
+    values: BoxedExpression[];
+} | null;
+/**
+ * Check if an expression contains a reference to a specific variable.
+ */
+export declare function bodyContainsVariable(expr: BoxedExpression, variable: string): boolean;
+/**
+ * For nested quantifiers like ∀x∈S. ∀y∈T. P(x,y), collect the inner domains.
+ * Returns an array of {variable, values} for nested ForAll/Exists with finite domains.
+ */
+export declare function collectNestedDomains(body: BoxedExpression, ce: ComputeEngine): {
+    variable: string;
+    values: BoxedExpression[];
+}[];
+/**
+ * Get the innermost body of nested quantifiers.
+ */
+export declare function getInnermostBody(body: BoxedExpression): BoxedExpression;
+/**
+ * Evaluate ForAll over a Cartesian product of domains.
+ * Returns True if the predicate holds for all combinations.
+ */
+export declare function evaluateForAllCartesian(domains: {
+    variable: string;
+    values: BoxedExpression[];
+}[], body: BoxedExpression, ce: ComputeEngine): BoxedExpression | undefined;
+/**
+ * Evaluate Exists over a Cartesian product of domains.
+ * Returns True if the predicate holds for at least one combination.
+ */
+export declare function evaluateExistsCartesian(domains: {
+    variable: string;
+    values: BoxedExpression[];
+}[], body: BoxedExpression, ce: ComputeEngine): BoxedExpression | undefined;
+/**
+ * Check if a boolean expression is satisfiable.
+ * Returns True if there exists an assignment that makes the expression true.
+ */
+export declare function isSatisfiable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Check if a boolean expression is a tautology.
+ * Returns True if the expression is true for all possible assignments.
+ */
+export declare function isTautology(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Generate a truth table for a boolean expression.
+ * Returns a List of Lists with headers and rows.
+ */
+export declare function generateTruthTable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;

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

@@ -0,0 +1,54 @@
+/* 0.33.0 */
+export declare function evaluateAnd(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateOr(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateNot(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateEquivalent(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateImplies(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateXor(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateNand(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+export declare function evaluateNor(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | undefined;
+/**
+ * Convert a boolean expression to Negation Normal Form (NNF).
+ * In NNF, negations only appear directly before variables (literals).
+ * This is a prerequisite for CNF/DNF conversion.
+ */
+export declare function toNNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Convert a boolean expression to Conjunctive Normal Form (CNF).
+ */
+export declare function toCNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Convert a boolean expression to Disjunctive Normal Form (DNF).
+ */
+export declare function toDNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Extract all propositional variables from a boolean expression.
+ * Returns a sorted array of unique variable names.
+ */
+export declare function extractVariables(expr: BoxedExpression): string[];
+/**
+ * Evaluate a boolean expression with a given truth assignment.
+ * Returns True, False, or undefined if the expression cannot be evaluated.
+ */
+export declare function evaluateWithAssignment(expr: BoxedExpression, assignment: Record<string, boolean>, ce: ComputeEngine): BoxedExpression;
+/**
+ * Generate all possible truth assignments for a list of variables.
+ * Each assignment is a Record mapping variable names to boolean values.
+ */
+export declare function generateAssignments(variables: string[]): Generator<Record<string, boolean>>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,135 @@
+/* 0.33.0 */
+/**
+ * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
+ * Returns undefined if the set cannot be converted to a Limits form.
+ *
+ * Mappings:
+ * - NonNegativeIntegers (ℕ₀) → [0, ∞)
+ * - PositiveIntegers (ℤ⁺) → [1, ∞)
+ * - NegativeIntegers (ℤ⁻) → Not supported (would need negative direction)
+ * - Integers (ℤ) → Not supported (bidirectional)
+ * - Other sets (Reals, Complexes, etc.) → Not supported (non-integer)
+ */
+export declare function convertInfiniteSetToLimits(domainSymbol: string): {
+    lower: number;
+    upper: number;
+    isFinite: false;
+} | undefined;
+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
+ *
+ * Or, for Element expressions, preserve them in canonical form.
+ *
+ * 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;
+/**
+ * A special symbol used to signal that a BigOp could not be evaluated
+ * because the domain is non-enumerable (e.g., infinite set, unknown symbol).
+ * When this is returned, the Sum/Product should keep the expression symbolic
+ * rather than returning NaN.
+ */
+export declare const NON_ENUMERABLE_DOMAIN: unique symbol;
+/**
+ * Result type for reduceBigOp that includes reason for failure
+ */
+export type BigOpResult<T> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'non-enumerable';
+    reason: string;
+    domain?: BoxedExpression;
+} | {
+    status: 'error';
+    reason: string;
+};
+/**
+ * Process an expression of the form
+ * - ['Operator', body, ['Tuple', index1, lower, upper]]
+ * - ['Operator', body, ['Tuple', index1, lower, upper], ['Tuple', index2, lower, upper], ...]
+ * - ['Operator', body, ['Element', index, collection]]
+ * - ['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.
+ *
+ * Returns either the reduced value, or `typeof NON_ENUMERABLE_DOMAIN` if the
+ * domain cannot be enumerated (in which case the expression should remain symbolic).
+ */
+export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | typeof NON_ENUMERABLE_DOMAIN | undefined>;
+/**
+ * Result type for reduceElementIndexingSets to distinguish between
+ * successful evaluation, non-enumerable domains (keep symbolic), and errors.
+ */
+export type ReduceElementResult<T> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'non-enumerable';
+    reason: string;
+    domain?: BoxedExpression;
+} | {
+    status: 'error';
+    reason: string;
+};

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

@@ -0,0 +1,57 @@
+/* 0.33.0 */
+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

@@ -0,0 +1,75 @@
+/* 0.33.0 */
+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

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