nerdamer 1.1.13 → 2.0.0-rc.1

package/index.d.ts

@@ -1,430 +1,14 @@
-export as namespace nerdamer
-export = nerdamer
-declare function nerdamer(
-	expression: nerdamer.ExpressionParam,
-	subs?: { [name: string]: string },
-	option?: keyof nerdamer.Options | (keyof nerdamer.Options)[],
-	location?: nerdamer.int): nerdamer.Expression
-declare namespace nerdamer {
-	export type ExpressionParam = Expression | string
-	export interface Options {
-		numer: never, expand: never
-	}
-	type int = number
-	/**
-	 * Returns the current version of nerdamer.
-	 */
-	export function version(): string
+import * as generated from './output/index';
 
-	/**
-	 * Sets a constant value which nerdamer will automatically substitute when parsing expression/equation
-	 * @param name The variable to be set as the constant.
-	 * @param value The value for the expression to be set to.
-	 */
-	export function setConstant(name: string, value: number | string): typeof nerdamer
+import type { SettingsType } from './output/core/Settings';
 
-	/**
-	 * Sets a function which can then be called using nerdamer.
-	 * @param function_name The function name
-	 * @param param_array The parameter array in the order in which the arguments are to be passed
-	 * @param function_body The body of the function
-	 * @example
-	 * nerdamer.setFunction('f', ['x', 'y'], 'x^2+y')
-	 * var x = nerdamer('f(4, 7)').toString()
-	 * console.log(x.toString())
-	 * nerdamer.setFunction('g', ['z', 'x', 'y'], '2*x+3*y+4*z')
-	 * x = nerdamer('g(3, 1, 2)')
-	 * console.log(x.toString())
-	 */
-	export function setFunction(function_name: string, param_array: string[], function_body: string): typeof nerdamer
+type GeneratedNerdamer = typeof generated.default;
+type RootSettings = SettingsType & { PRECISION: number };
+type Nerdamer = Omit<GeneratedNerdamer, 'get'> &
+	((...args: Parameters<GeneratedNerdamer>) => ReturnType<GeneratedNerdamer>) & {
+		get<K extends keyof RootSettings>(setting: K): RootSettings[K];
+	};
 
-	/**
-	 * Returns the nerdamer core object. This object contains all the core functions of nerdamer and houses the parser.
-	 * @example
-	 * Object.keys(nerdamer.getCore())
-	 */
-	export function getCore(): any
+declare const nerdamer: Nerdamer;
 
-	/**
-	 * Gets the list of reserved names. This is a list of names already in use by nerdamer excluding variable names. This is not a static list.
-	 * @param asArray Pass in true to get the list back as an array instead of as an object.
-	 */
-	export function reserved(asArray: true): string[]
-	export function reserved(asArray?: false): any
-
-	/**
-	 * Clears all stored expressions.
-	 * @example
-	 * var x = nerdamer('x*x')
-	 console.log(nerdamer.expressions())
-	 nerdamer.flush() //clear all expressions
-	 console.log(nerdamer.expressions())
-	 */
-	export function flush(): typeof nerdamer
-
-	/**
-	 * Converts and expression to LaTeX without evaluating expression.
-	 * @param expression The expression being converted.
-	 */
-	export function convertToLaTeX(expression: string): string
-
-	/**
-	 * Attempts to import a LaTeX string.
-	 * @param TeX The expression being converted.
-	 */
-	export function convertFromLaTeX(TeX: string): Expression
-	
-	/**
-	 * Each time an expression is parsed nerdamer stores the result. Use this method to get back stored expressions.
-	 * @param asObject Pass in true to get expressions as numbered object with 1 as starting index
-	 * @param asLatex Pass in the string "LaTeX" to get the expression to LaTeX, otherwise expressions come back as strings
-	 */
-	export function expressions(asObject?: boolean, asLatex?: 'LaTeX'): string[]
-
-	/**
-	 * Registers a module function with nerdamer. The object needs to contain at a minimum, a name property (text), a numargs property (int), this is -1 for variable arguments or an array containing the min and max arguments, the visible property (bool) which allows use of this function through nerdamer, defaults to true, and a build property containing a function which returns the function to be used. This function is also handy for creating aliases to functions. See below how the alias D was created for the diff function).
-	 * @param o
-	 */
-	export interface ModuleFunction {
-		/**
-		 * Name of function.
-		 */
-		name: string,
-
-		/**
-		 * Number of function arguments, -1 for variable arguments or an tuple containing minimum and maximum number of arguments.
-		 */
-		numargs: int | [int, int],
-
-		/**
-		 * Allows use of this function through nerdamer. Defaults to true.
-		 */
-		visible?: boolean,
-
-		/**
-		 * Return the function to be used.
-		 */
-		build(): (...args: number[]) => number
-	}
-
-	/**
-	 * Registers one or more module functions with nerdamer.
-	 * @param f
-	 * @example
-	 * var core = nerdamer.getCore()
-	 var _ = core.PARSER
-	 function f(a, b) {
-//use clone for safety since a or b might be returned
-var sum = _.add(a.clone(), b.clone())
-var product = _.multiply(a.clone(), b.clone())
-return _.multiply(sum, product)
-}
-	 //register the function with nerdamer
-	 nerdamer.register({
-	 name: 'myFunction',
-	 numargs: 2,
-	 visible: true,
-	 build: function(){ return f }
-})
-
-	 //create an alias for the diff function
-	 var core = nerdamer.getCore()
-	 nerdamer.register({
-		name: 'D',
-		visible: true,
-		numargs: [1, 3],
-		build: function(){ return core.Calculus.diff }
-})
-	 */
-	export function register(f: ModuleFunction | ModuleFunction[]): typeof nerdamer
-
-	/**
-	 * This method can be used to check that the variable meets variable name requirements for nerdamer. Variable names Must start with a letter or underscore and may contains any combination of numbers, letters, and underscores after that.
-	 * @param variable_name The variable name being validated.
-	 * @example
-	 * nerdamer.validVarName('cos') // false
-	 * nerdamer.validVarName('chicken1') // true
-	 * nerdamer.validVarName('1chicken') // false
-	 * nerdamer.validVarName('_') // true
-	 */
-	export function validVarName(variable_name: string): boolean
-
-	/**
-	 * Sets a known value in nerdamer. This differs from setConstant as the value can be overridden trough the scope. See example.
-	 * @param name The known value to be set.
-	 * @param value The value for the expression to be set to
-	 * @example
-	 * nerdamer.setVar('x', '11')
-	 * nerdamer('x*x') // == 121
-	 * // nerdamer will use 13 instead of 11:
-	 * nerdamer('x*x', {x: 13}) // == 169
-	 * // the value will be 121 again since the known value isn't being overridden:
-	 * nerdamer('x*x') // == 121
-	 * nerdamer.setVar('x', 'delete')
-	 * // since there no longer is a known value it will just be evaluated symbolically:
-	 * nerdamer('x*x') // == x^2
-	 */
-	export function setVar(name: string, value: number | string | 'delete'): void
-
-	/**
-	 * Clears all previously set variables.
-	 */
-	export function clearVars(): typeof nerdamer
-
-	/**
-	 * Gets all previously set variables.
-	 * @param option Use "LaTeX" to get as LaTeX. Defaults to text.
-	 */
-	export function getVars(option: 'LaTeX' | 'text'): { [name: string]: string }
-
-	/**
-	 * Sets the value of a nerdamer setting. Currently PARSE2NUMBER and IMAGINARY. Setting PARSE2NUMBER to true will let nerdamer always try to return a number whenenver possible. IMAGINARY allows you to change the variable used for imaginary to j for instance.
-	 * @param setting The setting to be changed
-	 * @param value The value to set the setting to.
-	 * @example
-	 * nerdamer.set('PARSE2NUMBER', true)
-	 * nerdamer('cos(9)+1') // == 14846499/167059106
-	 * nerdamer.set('IMAGINARY', 'j')
-	 * nerdamer('sqrt(-1)') // == j
-	 */
-	export function set(setting: 'PARSE2NUMBER', value: boolean): typeof nerdamer
-	export function set(setting: 'IMAGINARY', value: string | 'i'): typeof nerdamer
-	export function set(setting: 'POWER_OPERATOR', value: '**' | '^'): typeof nerdamer
-
-	export interface Expression {
-		/**
-		 * Generates a JavaScript function given the expression. This is perfect for plotting and filtering user input. Plotting for the demo is accomplished using this. The order of the parameters is in alphabetical order by default but an argument array can be provided with the desired order.
-		 * @param args_array The argument array with the order in which they are preferred.
-		 */
-		buildFunction(args_array?: string[]): (...args: number[]) => number
-
-		/**
-		 * Forces evaluation of the expression.
-		 * @example
-		 * const x = nerdamer('sin(9+5)')
-		 * //the expression is simplified but the functions aren't called:
-		 * x.toString() // == sin(14)
-		 * // force function calls with evaluate:
-		 * x.evaluate().toString() // == 127690464/128901187
-		 */
-		evaluate(): Expression
-
-		/**
-		 * Substitutes a given value for another given value
-		 * @param value The value being substituted.
-		 * @param for_value The value to substitute for.
-		 */
-		sub(value: string, for_value: string): Expression
-
-		/**
-		 * Get a list of the variables contained within the expression.
-		 */
-		variables(): string[]
-
-		/**
-		 * Gets expression as LaTeX
-		 */
-		toTeX(): string
-
-		/**
-		 * Returns the value of the expression as a string or a number
-		 */
-		valueOf(): string | number
-
-		/**
-		 * Gets the list of reserved names. This is a list of names already in use by nerdamer excluding variable names. This is not a static list.
-		 * @param outputType Pass in the string 'decimals' to always get back numers as decimals. Pass in the string 'fractions' to always get back number as fractions. Defaults to decimals.
-		 */
-		text(outputType?: 'decimals' | 'fractions'): string
-
-		/**
-		 * This method requires that the Solve, Calculus, and Algebra add-ons are loaded. It will attempt to solve an equation. If solutions no solutions are found then an empty array is returned. It can solve for multivariate polynomials up to the third degree. After which it can solve numerically for polynomials up to the the 100th degree. If it's a univariate equation it will attempt to solve it using numerical methods.
-		 * @param variable The variable to solve for.
-		 * @example
-		 * nerdamer('a*x^2+b*x=y').evaluate({y: 'x-7'}) // == ??
-		 * eq.solveFor('x') // ?? TODO
-		 */
-		solveFor(variable: string): Expression
-
-		/**
-		 * Forces the expression to displayed with decimals
-		 */
-		toDecimal(prec?: number): string
-
-		/**
-		 * Checks to see if the expression's value equals a number. Compares the direct value returned.
-		 * The function will not check for all possible cases. To avoid this call evaluate.
-		 * @example
-		 * nerdamer('sqrt(5)').isNumber()
-		 * // false
-		 * nerdamer('sqrt(5)').evaluate().isNumber()
-		 * // true
-		 */
-		isNumber(): boolean
-		
-		/**
-		 * Checks if a number evaluates to an imaginary number
-		 * @example
-		 * nerdamer('sqrt(-5)+8').isImaginary()
-		 * // true
-		 * nerdamer('sqrt(5)+8').isImaginary()
-		 * // false
-		 */
-		isImaginary(): boolean
-
-		/**
-		 * Adds a value to an expression
-		 * @example
-		 * nerdamer('x').add(3)
-		 */
-		add(symbol: number | string | Expression): Expression
-
-		/**
-		 * Subtracts a value from an expression
-		 * @example
-		 * nerdamer('x').subtract(3)
-		 */
-		subtract(symbol: number | string | Expression): Expression
-
-		/**
-		 * Multiplies an expression by a value
-		 * @example
-		 * nerdamer('x').multiply(3)
-		 */
-		multiply(symbol: number | string | Expression): Expression
-
-		/**
-		 * Divides an expression by a valule
-		 * @example
-		 * nerdamer('9*x').divide(3)
-		 */
-		divide(symbol: number | string | Expression): Expression
-
-		/**
-		 * Raises an expression to a power
-		 * @example
-		 * nerdamer('x').pow(3)
-		 */
-		pow(symbol: number | string | Expression): Expression
-
-		/**
-		 * Checks if two values are equal
-		 * @param value The value being tested
-		 * @example
-		 * nerdamer('sqrt(9)').eq(3)
-		 * // true
-		 * nerdamer('x').eq('y')
-		 * // false
-		 */
-		eq(value: number | string | Expression): boolean
-
-		/**
-		 * Checks if a value is less than another
-		 * @param value The value being tested
-		 * @example
-		 * nerdamer('sqrt(9)').lt(3)
-		 * // false
-		 * nerdamer('8').lt(100)
-		 * // true
-		 */
-		lt(value: number | string | Expression): boolean
-
-		 /**
-		 * Checks if a value is less than or equal to another
-		 * @param value The value being tested
-		 * @example
-		 * nerdamer('sqrt(9)').lte(3)
-		 * // true
-		 * nerdamer('x').lte(100)
-		 * // false
-		 */
-		lte(value: number | string | Expression): boolean
-
-		/**
-		 * Checks if a value is greater than another
-		 * @param value The value being tested
-		 * @example
-		 * nerdamer('sqrt(9)').gt(3)
-		 * // false
-		 * nerdamer('800').gt(100)
-		 * // true
-		 */
-		gt(value: number | string | Expression): boolean
-
-		/**
-		 * Checks if a value is greater than or equal to another
-		 * @param value The value being tested
-		 * @example
-		 * nerdamer('sqrt(9)').gte(3)
-		 * // true
-		 * nerdamer('x').gte(100)
-		 * // false
-		 */
-		gte(value: number | string | Expression): boolean
-		
-		/**
-		 * Expands a function or expression.
-		 * @example
-		 * nerdamer('x*(x+1)').expand();
-		 * // x+x^2
-		 * nerdamer('(x+y)*(x-5)*x').expand();
-		 * // -5*x*y-5*x^2+x^3+x^2*y
-		 */
-		expand(): Expression
-	}
-
-	////////// CALCULUS
-
-	/**
-	 * Gets the GCD of 2 polynomials
-	 * @param expression Returns the appropriate value if possible otherwise it returns the function with the simplified expression.
-	 * @param index The index of summation.
-	 * @param lower Starting index.
-	 * @param upper Ending index.
-	 */
-	export function sum(expression: ExpressionParam,
-		index: string,
-		lower: ExpressionParam,
-		upper: ExpressionParam): Expression
-
-	/**
-	 *
-	 * @param expression Returns the appropriate value if possible otherwise it returns the function with the simplified expression.
-	 * @param variable The variable with respect to which to integrate.
-	 */
-	export function integrate(expression: ExpressionParam, variable: string): Expression
-
-	/**
-	 *
-	 * @param expression Returns the appropriate value if possible otherwise it returns the function with the simplified expression.
-	 * @param variable The variable with respect to which to differentiate.
-	 * @param n Calculate the nth derivative.
-	 */
-	export function diff(expression: ExpressionParam, variable: string, n?: int): Expression
-
-	////////// ALGEBRA
-
-	/**
-	 * Divides 2 polynominals.
-	 * @param expression Returns the appropriate value if possible otherwise it returns the function with the simplified expression.
-	 */
-	export function divide(expression: ExpressionParam): Expression
-
-	/**
-	 * Factor an expression.
-	 * @param expression Returns the appropriate value if possible otherwise it returns the function with the simplified expression.
-	 */
-	export function factor(expression: ExpressionParam): Expression
-
-	/**
-	 * Gets the GCD of 2 polynomials.
-	 * @param expression Returns the appropriate value if possible otherwise it returns the function with the simplified expression.
-	 */
-	export function gcd(expression: ExpressionParam): Expression
-
-	/**
-	 * Finds the roots of a univariate polynomial.
-	 * @param expression
-	 */
-	export function factor(expression: ExpressionParam): Expression
-}
+export = nerdamer;

package/output/algebra/adapters.d.ts

@@ -0,0 +1,33 @@
+import { Expression } from '../core/classes/expression/Expression';
+import { Polynomial } from '../core/classes/polynomial/Polynomial';
+import { MultiPoly } from './algorithms/multiPoly/MultiPoly';
+import type { PolyType } from '../core/classes/polynomial/Polynomial';
+import type { FactorsObject } from './algorithms/factor';
+/**
+ * Converts a polynomial to a MultiPoly to be used with the polynomial algorithms.
+ *
+ * @param p The polynomial to be converted.
+ * @param variables Optional variable order.
+ * @returns The MultiPoly and variable order used for its term keys.
+ */
+export declare function polynomialToMultiPoly(p: PolyType, variables?: string[]): {
+    poly: MultiPoly;
+    variables: string[];
+};
+export declare function multiPolyToExpression(poly: MultiPoly, variables: string[]): Expression;
+/**
+ * Converts the factored Expression or Polynomial to an array of Expressions.
+ *
+ * @param factorObj The integer polynomial factors.
+ * @param variables The variable order used by each factor.
+ * @returns Expression factors including non-unit content.
+ */
+export declare function factorsToExpressions(factorObj: FactorsObject, variables: string[]): Expression[];
+/**
+ * Converts the factored Expression or Polynomial to an array of Polynomials.
+ *
+ * @param factorsObj The integer polynomial factors.
+ * @param variables The variable order used by each factor.
+ * @returns Polynomial wrappers around the converted factors.
+ */
+export declare function factorsToPolynomials(factorsObj: FactorsObject, variables: string[]): Polynomial[];

package/output/algebra/adapters.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polynomialToMultiPoly = polynomialToMultiPoly;
+exports.multiPolyToExpression = multiPolyToExpression;
+exports.factorsToExpressions = factorsToExpressions;
+exports.factorsToPolynomials = factorsToPolynomials;
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+const MultiPoly_1 = require("./algorithms/multiPoly/MultiPoly");
+/**
+ * Converts a polynomial to a MultiPoly to be used with the polynomial algorithms.
+ *
+ * @param p The polynomial to be converted.
+ * @param variables Optional variable order.
+ * @returns The MultiPoly and variable order used for its term keys.
+ */
+function polynomialToMultiPoly(p, variables) {
+    p = Polynomial_1.Polynomial.toPolynomial(p);
+    const poly = new MultiPoly_1.MultiPoly();
+    variables = variables ?? p.variables;
+    for (const term of p.terms) {
+        const keyElements = [];
+        for (let i = 0; i < variables.length; i++) {
+            const power = term.powers[variables[i]];
+            // Don't add zero powers or undefined powers
+            if (!power) {
+                continue;
+            }
+            // Generate the key which is nothing more than index:power
+            keyElements.push(`${i}:${power}`);
+        }
+        const key = keyElements.join(',');
+        poly.terms.set(key, term.coeff.getMultiplier().numerator);
+    }
+    return { poly, variables };
+}
+function multiPolyToExpression(poly, variables) {
+    let retval;
+    if (poly.terms.size === 0) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else {
+        let result;
+        for (const [key, coeff] of poly.terms) {
+            // Build the coefficient as an Expression directly
+            let term = Expression_1.Expression.Number(coeff);
+            // Multiply by each variable raised to its power
+            if (key !== '') {
+                for (const part of key.split(',')) {
+                    const [varIndex, power] = part.split(':');
+                    const v = Expression_1.Expression.Variable(variables[+varIndex]);
+                    term = term.times(power === '1' ? v : v.pow(Expression_1.Expression.Number(power)));
+                }
+            }
+            // Accumulate into sum
+            result = result === undefined ? term : result.plus(term);
+        }
+        retval = result ?? (0, shortcuts_1.zero)();
+    }
+    return retval;
+}
+/**
+ * Converts a PolyFactor to an Expression object.
+ *
+ * @param factor The factor to convert.
+ * @param variables The variable order used by the factor's MultiPoly.
+ * @returns The equivalent Expression.
+ */
+function makeExpression(factor, variables) {
+    // The terms of each factor
+    let exp = multiPolyToExpression(factor.poly, variables);
+    // Add back the power
+    if (factor.multiplicity > 1n) {
+        exp = exp.pow(Expression_1.Expression.Number(factor.multiplicity));
+    }
+    return exp;
+}
+/**
+ * Converts the factored Expression or Polynomial to an array of Expressions.
+ *
+ * @param factorObj The integer polynomial factors.
+ * @param variables The variable order used by each factor.
+ * @returns Expression factors including non-unit content.
+ */
+function factorsToExpressions(factorObj, variables) {
+    const factors = [];
+    // set the terms
+    // Add the content
+    if (factorObj.content !== 1n) {
+        factors.push(Expression_1.Expression.Number(factorObj.content));
+    }
+    // Now the factors
+    for (const factor of factorObj.factors) {
+        const f = makeExpression(factor, variables);
+        factors.push(f);
+    }
+    return factors;
+}
+/**
+ * Converts the factored Expression or Polynomial to an array of Polynomials.
+ *
+ * @param factorsObj The integer polynomial factors.
+ * @param variables The variable order used by each factor.
+ * @returns Polynomial wrappers around the converted factors.
+ */
+function factorsToPolynomials(factorsObj, variables) {
+    return factorsToExpressions(factorsObj, variables).map(e => new Polynomial_1.Polynomial(e));
+}

package/output/algebra/algorithms/arith.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @module arith
+ *
+ * Low-level integer and modular arithmetic helpers used throughout the library.
+ *
+ * - All integer arithmetic is done with `bigint`.
+ * - Modular routines assume a prime modulus `p` when inverses are required.
+ */
+/**
+ * Shared integer + modular arithmetic primitives used across Zippel GCD and
+ * multivariate factorization.
+ *
+ * Design goals:
+ * - BigInt-only arithmetic for coefficient paths.
+ * - Small, stable surface area: use `abs`, `gcd`, `pow`.
+ */
+/** Absolute value for BigInt. */
+export declare function abs(a: bigint): bigint;
+/**
+ * Euclidean GCD for BigInt.
+ *
+ * Returns a nonnegative gcd. gcd(0,0) = 0.
+ */
+export declare function gcd(a: bigint, b: bigint): bigint;
+/**
+ * Integer exponentiation for BigInt with a nonnegative exponent.
+ *
+ * This is NOT modular exponentiation (see {@link modPow}).
+ */
+export declare function pow(base: bigint, exp: bigint): bigint;
+/**
+ * Integer exponentiation for BigInt with a small nonnegative JS number exponent.
+ *
+ * Convenience wrapper used throughout factorization code where exponents are known
+ * to fit in a number.
+ */
+export declare function powN(base: bigint, exp: number): bigint;
+/**
+ * Integer square root: floor(sqrt(n)) for n >= 0.
+ */
+export declare function bigIntSqrt(n: bigint): bigint;
+/**
+ * Exact n-th root if it exists.
+ * Returns r such that r^n === value, or null if value is not a perfect n-th power.
+ */
+export declare function intNthRootExact(value: bigint, n: number): bigint | null;
+/**
+ * Return positive divisors of n (n > 0) by trial division.
+ *
+ * NOTE: This is intended for small integers used in factoring heuristics.
+ */
+export declare function getDivisors(n: bigint): bigint[];
+/** Normalize a into the range [0, |p|). Throws if p is zero. */
+export declare function modNorm(a: bigint, p: bigint): bigint;
+/** Map a to the symmetric residue class (-|p|/2, |p|/2]. */
+export declare function modSymmetric(a: bigint, p: bigint): bigint;
+/** Modular multiplicative inverse of a mod p, where gcd(a,p)=1. */
+export declare function modInv(a: bigint, p: bigint): bigint;
+/**
+ * Content (GCD of coefficients) for an iterable of bigint coefficients.
+ * Returns 0n for the all-zero collection.
+ */
+export declare function contentBigint(coeffs: Iterable<bigint>): bigint;
+/** Bit-length of a bigint (0 -> 0). */
+export declare function bigintBitLength(a: bigint): number;
+/** Next prime >= start. */
+export declare function nextPrime32(start: number): number;
+type AlgebraPhase = 'prime-selection' | 'specialization' | 'lift' | 'reconstruction' | 'verification' | 'budget' | 'normalization' | 'unknown';
+declare class AlgebraError extends Error {
+    /** Additional structured debugging info. Always present (possibly empty). */
+    readonly details: Record<string, unknown>;
+    readonly phase: AlgebraPhase;
+    constructor(message: string, phase?: AlgebraPhase, details?: Record<string, unknown>);
+}
+export declare class PrimeSelectionError extends AlgebraError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when Zippel-style multivariate GCD exceeds its specialization / interpolation budget.
+ */
+export declare class GcdBudgetExceededError extends AlgebraError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export {};