@cortex-js/compute-engine 0.32.0 → 0.32.1

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

@@ -0,0 +1,5 @@
+/* 0.32.1 */
+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.32.1 */
+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.32.1 */
+export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -0,0 +1,27 @@
+/* 0.32.1 */
+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.32.1 */
+export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

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

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

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

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

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

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

@@ -0,0 +1,4 @@
+/* 0.32.1 */
+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.32.1 */
+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.32.1 */
+export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

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

@@ -0,0 +1,64 @@
+/* 0.32.1 */
+/**
+ * Quantifier domain helpers and boolean analysis functions.
+ * Extracted from logic.ts for better code organization.
+ */
+/**
+ * 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.
+ */
+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,58 @@
+/* 0.32.1 */
+/**
+ * Basic evaluation functions for logical operators.
+ * Extracted from logic.ts for better code organization.
+ */
+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.32.1 */
+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.32.1 */
+export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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