@cortex-js/compute-engine 0.31.0 → 0.32.1

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-relational-operators.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,3 +1,3 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexDictionary, LatexDictionaryEntry, LatexString, LatexToken, LibraryCategory, MatchfixParseHandler, PostfixParseHandler, Precedence, SerializeHandler } from '../types';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { Parser } from './types';
 /** For error handling, if we have a symbol prefix, assume
  * the symbol is invalid (it would have been captured by

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -45,6 +45,10 @@ export declare class _Parser implements Parser {
     pushSymbolTable(): void;
     popSymbolTable(): void;
     addSymbol(id: string, type: BoxedType | TypeString): void;
+    private _quantifierScopeDepth;
+    get inQuantifierScope(): boolean;
+    enterQuantifierScope(): void;
+    exitQuantifierScope(): void;
     get index(): number;
     set index(val: number);
     private _tokens;
@@ -292,6 +296,15 @@ export declare class _Parser implements Parser {
     decorate(expr: Expression | null, start: number): Expression | null;
     error(code: string | [string, ...Expression[]], fromToken: number): Expression;
     private isFunctionOperator;
+    /**
+     * Check if a symbol looks like a predicate in First-Order Logic.
+     * A predicate is typically a single uppercase letter (P, Q, R, etc.)
+     * followed by parentheses containing arguments.
+     *
+     * This enables automatic inference of predicates without explicit declaration,
+     * so `\forall x. P(x)` works without having to declare `P` as a function.
+     */
+    private looksLikePredicate;
     /** Return all defs of the specified kind.
      * The defs at the end of the dictionary have priority, since they may
      * override previous definitions. (For example, there is a core definition

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { DelimiterScale } from './types';
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): DelimiterScale;
 export declare function getGroupStyle(_expr: Expression, _level: number): DelimiterScale;

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import { BoxedType, TypeString } from '../types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -47,34 +47,54 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * For example, in `1 + 2 * 3`, the `*` operator has a **higher** precedence
  * than the `+` operator, so it is applied first.
  *
- * The precedence range from 0 to 1000. The larger the number, the higher the
+ * The precedence ranges from 0 to 1000. The larger the number, the higher the
  * precedence, the more "binding" the operator is.
  *
- * Here are some rough ranges for the precedence:
- *
- * - 800: prefix and postfix operators: `\lnot` etc...
- *    - `POSTFIX_PRECEDENCE` = 810: `!`, `'`
- * - 700: some arithmetic operators
- *    - `EXPONENTIATION_PRECEDENCE` = 700: `^`
- * - 600: some binary operators
- *    - `DIVISION_PRECEDENCE` = 600: `\div`
- * - 500: not used
- * - 400: not used
- * - 300: some logic and arithmetic operators:
- *        `\land`, `\lor`, `\times`, etc...
- *   - `MULTIPLICATION_PRECEDENCE` = 390: `\times`
- * - 200: arithmetic operators, inequalities:
- *   - `ADDITION_PRECEDENCE` = 275: `+` `-`
- *   - `ARROW_PRECEDENCE` = 270: `\to` `\rightarrow`
- *   - `ASSIGNMENT_PRECEDENCE` = 260: `:=`
- *   - `COMPARISON_PRECEDENCE` = 245: `\lt` `\gt`
- *   - 241: `\leq`
- * - 100: not used
- * - 0: `,`, `;`, etc...
+ * ## Operator Precedence Table
+ *
+ * | Precedence | Operators | Description |
+ * |------------|-----------|-------------|
+ * | **880** | `\lnot` `\neg` `++` `--` `+` `-` (prefix) | Prefix/postfix unary |
+ * | **810** | `!` `'` `!!` `'''` | Factorial, prime (postfix) |
+ * | **800** | `_` (subscript) | Subscript |
+ * | **780** | `\degree` `\prime` | Degree, prime symbols |
+ * | **740** | `\%` | Percent |
+ * | **720** | `\/` (inline division) | Inline division |
+ * | **700** | `^` `\overset` `\underset` | Exponentiation, over/underscript |
+ * | **650** | (invisible multiply) `\cdot` | Implicit multiplication |
+ * | **600** | `\div` `\frac` | Division |
+ * | **390** | `\times` `*` `/` | Multiplication |
+ * | **350** | `\cup` `\cap` | Set union/intersection |
+ * | **275** | `+` `-` (infix) | Addition, subtraction |
+ * | **270** | `\to` `\rightarrow` `\mapsto` | Arrows |
+ * | **265** | `\setminus` `\smallsetminus` `:` (range) | Set difference, range |
+ * | **260** | `:=` | Assignment |
+ * | **255** | `\ne` | Not equal |
+ * | **250** | `\not\approxeq` | Not approximately equal |
+ * | **247** | `\approx` | Approximately |
+ * | **245-246** | `=` `<` `>` `\lt` `\gt` `\nless` `\ngtr` | Equality, comparison |
+ * | **241-244** | `\le` `\leq` `\ge` `\geq` `>=` | Less/greater or equal |
+ * | **240** | `\in` `\notin` `\subset` `\supset` ... | Set membership/relations |
+ * | **235** | `\land` `\wedge` `\&` | Logical AND |
+ * | **232** | `\veebar` `\barwedge` (Xor, Nand, Nor) | Logical XOR, NAND, NOR |
+ * | **230** | `\lor` `\vee` `\parallel` | Logical OR |
+ * | **220** | `\implies` `\Rightarrow` `\vdash` `\models` | Implication, entailment |
+ * | **219** | `\iff` `\Leftrightarrow` `\equiv` | Equivalence |
+ * | **200** | `\forall` `\exists` `\exists!` | Quantifiers |
+ * | **160** | `\mid` `\vert` (set builder) | Set builder notation |
+ * | **19-20** | `,` `;` `\ldots` | Sequence separators |
+ *
+ * ## Key Relationships
+ *
+ * - **Comparisons bind tighter than logic**: `x = 1 \lor y = 2` parses as
+ *   `(x = 1) \lor (y = 2)`, not `x = (1 \lor y) = 2`
+ * - **AND binds tighter than OR**: `a \land b \lor c` parses as
+ *   `(a \land b) \lor c`
+ * - **Logic operators bind tighter than implication**: `a \lor b \implies c`
+ *   parses as `(a \lor b) \implies c`
  *
  * Some constants are defined below for common precedence values.
  *
- *
  * **Note**: MathML defines
  * [some operator precedence](https://www.w3.org/TR/2009/WD-MathML3-20090924/appendixc.html),
  * but it has some issues and inconsistencies. However,
@@ -518,6 +538,31 @@ export type ParseLatexOptions = NumberFormat & {
      * **Default:** `false`
      */
     preserveLatex: boolean;
+    /**
+     * Controls how quantifier scope is determined when parsing expressions
+     * like `\forall x. P(x) \rightarrow Q(x)`.
+     *
+     * - `"tight"`: The quantifier binds only to the immediately following
+     *   well-formed formula, stopping at logical connectives (`\rightarrow`,
+     *   `\implies`, `\land`, `\lor`, etc.). This follows standard First-Order
+     *   Logic conventions. Use explicit parentheses for wider scope:
+     *   `\forall x. (P(x) \rightarrow Q(x))`.
+     *
+     * - `"loose"`: The quantifier scope extends to the end of the expression
+     *   or until a lower-precedence operator is encountered.
+     *
+     * **Default:** `"tight"`
+     *
+     * @example
+     * // With "tight" (default):
+     * // \forall x. P(x) \rightarrow Q(x)
+     * // parses as: (∀x. P(x)) → Q(x)
+     *
+     * // With "loose":
+     * // \forall x. P(x) \rightarrow Q(x)
+     * // parses as: ∀x. (P(x) → Q(x))
+     */
+    quantifierScope: 'tight' | 'loose';
 };
 /**
  *
@@ -538,6 +583,12 @@ export interface Parser {
     pushSymbolTable(): void;
     popSymbolTable(): void;
     addSymbol(id: MathJsonSymbol, type: BoxedType | TypeString): void;
+    /** True if currently parsing inside a quantifier body (ForAll, Exists, etc.) */
+    readonly inQuantifierScope: boolean;
+    /** Enter a quantifier scope for parsing the body of ForAll, Exists, etc. */
+    enterQuantifierScope(): void;
+    /** Exit the current quantifier scope */
+    exitQuantifierScope(): void;
     /** The index of the current token */
     index: number;
     /** True if the last token has been reached.

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 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;

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import type { SymbolDefinitions, ComputeEngine } from '../global-types';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
 export declare const LIBRARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.31.0 */
+/* 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

@@ -1,6 +1,7 @@
-/* 0.31.0 */
+/* 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export type IndexingSet = {
     index: string | undefined;
     lower: number;

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
 import { Expression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { Rational, SmallInteger } from '../numerics/types';
 import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { Expression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import type { Expression } from '../../math-json/types';
 import type { SmallInteger } from '../numerics/types';

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
  *
  * ## THEORY OF OPERATIONS
  *

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare function lcm(a: bigint, b: bigint): bigint;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [SmallInteger, SmallInteger];
 export declare function isBigRational(x: any | null): x is [bigint, bigint];

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

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

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;

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

@@ -1,4 +1,4 @@
-/* 0.31.0 */
+/* 0.32.1 */
 import type { BigNum } from './types';
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;