nerdamer 1.1.13 → 2.0.0-rc.2

package/output/math/math.d.ts

@@ -0,0 +1,695 @@
+import { Expression } from '../core/classes/expression/Expression';
+import { Matrix } from '../core/classes/matrix/Matrix';
+import type { Dictionary } from '../core/classes/dictionary/Dictionary';
+import type { ValuesSet } from '../core/classes/valuesSet/ValuesSet';
+import type { Vector } from '../core/classes/vector/Vector';
+import type { ExpressionInput, NerdamerInput } from '../core/types';
+import type { SolutionSet } from '../solve/classes/SolutionSet';
+/**
+ * Computes the square root of an expression. Equivalent to raising to the power of 1/2.
+ * Nested square roots are automatically simplified (e.g. `sqrt(sqrt(x))` becomes `x^(1/4)`).
+ *
+ * @param x - The expression to take the square root of.
+ * @returns The square root of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `-∞`.
+ *
+ * @example
+ * ```ts
+ * // Numeric
+ * sqrt(4).text()             // "2"
+ * sqrt('1/4').text()         // "1/2"
+ *
+ * // Symbolic
+ * sqrt('x^2').text()         // "x"
+ * sqrt('x').text()           // "sqrt(x)"
+ * sqrt(0).text()             // "0"
+ * ```
+ */
+export declare function sqrt(x: ExpressionInput): Expression;
+/**
+ * Returns a copy that renders numeric values in scientific notation.
+ *
+ * The legacy implementation stored a formatting flag that its formatter did not
+ * consume. Nerdamer 2.0 keeps the expression exact and records the requested number
+ * of significant digits for formatting. Precision validation follows decimal.js and accepts
+ * integer values from 1 through 1e9.
+ */
+export declare function scientific(x: ExpressionInput, significantDigits?: ExpressionInput): Expression;
+/**
+ * Computes the nth root of an expression as its principal power.
+ *
+ * @param x - The expression whose root is requested.
+ * @param n - The root degree.
+ * @returns `x^(1/n)`.
+ */
+export declare function nthroot(x: ExpressionInput, n: ExpressionInput): Expression;
+/** Converts degrees to radians exactly. */
+export declare function radians(x: ExpressionInput): Expression;
+/** Converts radians to degrees exactly. */
+export declare function degrees(x: ExpressionInput): Expression;
+/** Returns the base-10 logarithm using the ordinary logarithm implementation. */
+export declare function log10(x: ExpressionInput): Expression;
+/**
+ * Computes the cube root of an expression.
+ *
+ * For real numeric constants, the *real* cube root is returned (so negative reals stay real).
+ * For complex constants, the principal cube root is used.
+ * Nested cube roots are simplified (e.g. `cbrt(cbrt(x))` becomes `x^(1/9)`).
+ *
+ * Unlike {@link sqrt}, `cbrt` is preserved as a function node rather than rewritten to
+ * `x^(1/3)` to avoid principal-branch issues during symbolic manipulation.
+ *
+ * @param x - The expression to take the cube root of.
+ * @returns The cube root of `x`.
+ *
+ * @example
+ * ```ts
+ * cbrt(8).text()              // "2"
+ * cbrt(-27).text()            // "-3"
+ * cbrt('x').text()            // "cbrt(x)"
+ * ```
+ */
+export declare function cbrt(x: ExpressionInput): Expression;
+/**
+ * Wraps an expression in parentheses. Returns a function node whose only purpose
+ * is to visually group `x` with surrounding parentheses in output.
+ *
+ * @param x - The expression to wrap.
+ * @returns A parenthesised form of `x`.
+ *
+ * @example
+ * ```ts
+ * parens(Expression.create('x+1')).text()  // "(x+1)"
+ * ```
+ */
+export declare function parens(x: ExpressionInput): Expression;
+/**
+ * Computes the Fibonacci number for an integer index.
+ *
+ * Integer inputs are evaluated exactly, including negative indices through the
+ * negafibonacci identity. Symbolic and non-integer inputs remain unevaluated.
+ *
+ * @param x - Fibonacci index.
+ * @returns The exact Fibonacci number for an integer input, or symbolic `fib(x)`.
+ *
+ * @example
+ * ```ts
+ * fibonacci(10).text()   // "55"
+ * fibonacci(-4).text()   // "-3"
+ * fibonacci('x').text()  // "fib(x)"
+ * ```
+ */
+export declare function fibonacci(x: ExpressionInput): Expression;
+/**
+ * Computes the factorial of an expression.
+ *
+ * For non-negative integers, returns the exact integer factorial.
+ * For half-integer arguments (e.g. `1/2`, `3/2`, `-1/2`), returns a closed-form
+ * expression involving `sqrt(π)`.
+ * When `Settings.EVALUATE` is `true` and the input is not an integer, falls back
+ * to the {@link gamma} function via Γ(x + 1).
+ *
+ * @param x - The expression to compute the factorial of.
+ * @returns The factorial of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `-∞`.
+ *
+ * @example
+ * ```ts
+ * factorial(Expression.create(5)).text()       // "120"
+ * factorial(Expression.create(0)).text()       // "1"
+ * factorial(Expression.create('1/2')).text()   // "1/2*sqrt(pi)"
+ * ```
+ */
+export declare function factorial(x: Expression): Expression;
+/**
+ * Computes the double factorial of an expression.
+ *
+ * For a non-negative integer n, the double factorial is the product of all positive
+ * integers up to n that share its parity:
+ * - Even: `n!! = 2 · 4 · 6 · … · n`
+ * - Odd:  `n!! = 1 · 3 · 5 · … · n`
+ *
+ * For non-integer arguments when `Settings.EVALUATE` is `true`, a generalised
+ * formula using the {@link gamma} function is applied.
+ *
+ * @param x - The expression to compute the double factorial of.
+ * @returns The double factorial of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `-∞`.
+ *
+ * @example
+ * ```ts
+ * doubleFactorial(Expression.create(6)).text()   // "48"
+ * doubleFactorial(Expression.create(7)).text()   // "105"
+ * ```
+ */
+export declare function doubleFactorial(x: Expression): Expression;
+/**
+ * Computes the Heaviside step function (unit step function).
+ *
+ * Uses the half-maximum convention at the origin:
+ * - `heaviside(x) = 0` for `x < 0`
+ * - `heaviside(0) = 1/2`
+ * - `heaviside(x) = 1` for `x > 0`
+ *
+ * For symbolic inputs, returns an unevaluated `heaviside(x)` node.
+ *
+ * @param x - The input expression.
+ * @returns The Heaviside step value.
+ *
+ * @example
+ * ```ts
+ * heaviside(Expression.create(3)).text()    // "1"
+ * heaviside(Expression.create(-2)).text()   // "0"
+ * heaviside(Expression.create(0)).text()    // "1/2"
+ * heaviside(Expression.create('t')).text()  // "heaviside(t)"
+ * ```
+ */
+export declare function heaviside(x: Expression): Expression;
+/**
+ * Legacy unit-step function. Unlike {@link heaviside}, the value at zero is 1.
+ */
+export declare function step(x: ExpressionInput): Expression;
+/**
+ * Rectangular pulse with unit width centered at zero.
+ *
+ * Returns 1 for |x| < 1/2, 1/2 at |x| = 1/2, and 0 for |x| > 1/2.
+ */
+export declare function rect(x: ExpressionInput): Expression;
+/** Triangular pulse: max(1 - |x|, 0) when the comparison can be resolved. */
+export declare function tri(x: ExpressionInput): Expression;
+/**
+ * Computes the Dirac delta function (distribution).
+ *
+ * For non-zero numeric inputs, returns `0`. At `x = 0` the symbolic form
+ * `dirac(0)` is returned (the Dirac delta is only meaningful under an
+ * integral or Laplace transform). For symbolic inputs, returns an
+ * unevaluated `dirac(x)` node.
+ *
+ * @param x - The input expression.
+ * @returns The Dirac delta value or symbolic node.
+ *
+ * @example
+ * ```ts
+ * dirac(Expression.create(5)).text()    // "0"
+ * dirac(Expression.create(0)).text()    // "dirac(0)"
+ * dirac(Expression.create('t')).text()  // "dirac(t)"
+ * ```
+ */
+export declare function dirac(x: Expression): Expression;
+/**
+ * Evaluates a numeric expression to a finite number of significant decimal digits.
+ *
+ * Exact rational results are converted to decimal-origin values so subsequent numerical
+ * arithmetic does not keep expanding their numerators and denominators. Symbolic results
+ * remain symbolic after evaluation.
+ *
+ * @param x - Expression to evaluate numerically.
+ * @param precision - Significant digits to retain. Defaults to the active Nerdamer precision.
+ * @returns The evaluated numeric value at the requested precision, or the evaluated symbolic result.
+ */
+export declare function numeric(x: ExpressionInput, precision?: ExpressionInput): Expression;
+/**
+ * Rounds a number to the nth decimal place. If no precision is provided, rounds to
+ * the nearest integer.
+ *
+ * @param x - The expression to round.
+ * @param n - The number of decimal places to round. Defaults to `0`.
+ * @returns The rounded value of `x`.
+ *
+ * @example
+ * ```ts
+ * round('3.7').text()        // "4"
+ * round('2.555', 2).text()   // "2.56"
+ * round('1/3', 4).text()     // "0.3333"
+ * ```
+ */
+export declare function round(x: ExpressionInput, n?: ExpressionInput): Expression;
+/**
+ * Returns the sign of a number as `1`, `-1`, or `0`.
+ *
+ * For constant expressions that are not plain numerics, the expression is
+ * evaluated first to determine its sign.
+ *
+ * @param x - The expression whose sign to determine.
+ * @returns `1`, `-1`, or `0` as an Expression, or a symbolic `sign(x)` node.
+ *
+ * @example
+ * ```ts
+ * sign(5).text()     // "1"
+ * sign(-3).text()    // "-1"
+ * sign(0).text()     // "0"
+ * sign('x').text()   // "sign(x)"
+ * ```
+ */
+export declare function sign(x: ExpressionInput): Expression;
+/**
+ * Rounds a number down to the nearest integer (floor function).
+ *
+ * @param x - The expression to round down.
+ * @returns The greatest integer less than or equal to `x`.
+ *
+ * @example
+ * ```ts
+ * floor('3.7').text()    // "3"
+ * floor('-2.3').text()   // "-3"
+ * floor(5).text()        // "5"
+ * floor('x').text()      // "floor(x)"
+ * ```
+ */
+export declare function floor(x: ExpressionInput): Expression;
+/**
+ * Rounds a number up to the nearest integer (ceiling function).
+ *
+ * @param x - The expression to round up.
+ * @returns The least integer greater than or equal to `x`.
+ *
+ * @example
+ * ```ts
+ * ceiling('3.2').text()    // "4"
+ * ceiling('-2.7').text()   // "-2"
+ * ceiling(5).text()        // "5"
+ * ceiling('x').text()      // "ceil(x)"
+ * ```
+ */
+export declare function ceiling(x: ExpressionInput): Expression;
+/**
+ * Computes the absolute value of an expression.
+ *
+ * Applies symbolic simplifications where possible:
+ * - Even powers are recognised as non-negative (e.g. `abs(x^2)` returns `x^2`).
+ * - Complex inputs use the modulus: `abs(a + bi) = sqrt(a² + b²)`.
+ * - Fully negative sums are negated (e.g. `abs(-x - y)` becomes `x + y`).
+ *
+ * @param x - The expression to take the absolute value of.
+ * @returns The absolute value of `x`.
+ *
+ * @example
+ * ```ts
+ * abs(-5).text()       // "5"
+ * abs('3/4').text()    // "3/4"
+ * abs('x^2').text()    // "x^2"
+ * abs('x').text()      // "abs(x)"
+ * ```
+ */
+export declare function abs(x: ExpressionInput): Expression;
+/**
+ * Computes the modular multiplicative inverse of `a` modulo `p` using the
+ * extended Euclidean algorithm. That is, finds `t` such that `a * t ≡ 1 (mod p)`.
+ *
+ * @param a - The number whose modular inverse is to be calculated.
+ * @param p - The modulus (typically prime).
+ * @returns The modular inverse of `a` mod `p`.
+ * @throws {@link core!MathError} If the inverse does not exist (i.e. `gcd(a, p) ≠ 1`).
+ *
+ * @example
+ * ```ts
+ * modInv(Expression.create(3), Expression.create(7)).text()    // "5"
+ * modInv(Expression.create(10), Expression.create(17)).text()  // "12"
+ * ```
+ */
+export declare function modInv(a: Expression, p: Expression): Expression;
+/**
+ * Computes the modulo (remainder) of `x` divided by `y`.
+ *
+ * Exact Gaussian integers use the same quotient rule as Wolfram Language:
+ * divide, round the real and imaginary quotient components independently to
+ * the nearest integers with midpoint ties going to even, then subtract
+ * `y * quotient` from `x`.
+ *
+ * Complex values outside the Gaussian integers remain symbolic.
+ *
+ * @see https://reference.wolfram.com/language/ref/Mod.html
+ * @see https://reference.wolfram.com/language/ref/Quotient.html
+ * @see https://reference.wolfram.com/language/ref/Round.html
+ *
+ * @param x - The dividend.
+ * @param y - The divisor.
+ * @returns The remainder of `x / y`.
+ * @throws {@link core!UndefinedError} If either `x` or `y` is `±∞`.
+ *
+ * @example
+ * ```ts
+ * mod(Expression.create(10), Expression.create(3)).text()          // "1"
+ * mod(Expression.create('5+3*i'), Expression.create('2+i')).text() // "-1"
+ * ```
+ */
+export declare function mod(x: Expression, y: Expression): Expression;
+/**
+ * Upper incomplete gamma Γ(a, z).
+ *
+ * Positive integer first arguments are expanded exactly using the finite-sum formula.
+ * Other inputs remain symbolic.
+ *
+ * @see https://dlmf.nist.gov/8.4.E8
+ */
+export declare function gammaIncomplete(a: ExpressionInput, z: ExpressionInput): Expression;
+/**
+ * Lower incomplete gamma γ(a, z).
+ *
+ * Positive integer first arguments use γ(a,z) = Γ(a) - Γ(a,z).
+ * Other inputs remain symbolic.
+ *
+ * @see https://dlmf.nist.gov/8.2.E3
+ */
+export declare function gammaIncompleteLower(a: ExpressionInput, z: ExpressionInput): Expression;
+/**
+ * Computes the gamma function Γ(x).
+ *
+ * - For positive integers: `Γ(n) = (n − 1)!`
+ * - For half-integers (e.g. `1/2`, `3/2`, `-3/2`): returns a closed-form
+ *   expression involving `sqrt(π)`.
+ * - For other numeric values: uses a high-precision decimal approximation.
+ * - For symbolic inputs: returns an unevaluated `gamma(x)` node.
+ *
+ * @param x - The input expression.
+ * @returns The gamma function value Γ(x).
+ * @throws {@link core!UndefinedError} If `x` is `-∞`.
+ *
+ * @see https://en.wikipedia.org/wiki/Gamma_function
+ *
+ * @example
+ * ```ts
+ * gamma(Expression.create(5)).text()       // "24"
+ * gamma(Expression.create('1/2')).text()   // "sqrt(pi)"
+ * gamma(Expression.create('x')).text()     // "gamma(x)"
+ * ```
+ */
+export declare function gamma(x: Expression): Expression;
+/**
+ * Computes the complementary error function: `erfc(x) = 1 − erf(x)`.
+ *
+ * @param x - The input expression.
+ * @returns The complementary error function value.
+ *
+ * @see {@link erf}
+ *
+ * @example
+ * ```ts
+ * erfc(Expression.create(0)).text()   // "0"
+ * ```
+ */
+export declare function erfc(x: Expression): Expression;
+/**
+ * Computes the error function erf(x).
+ *
+ * - `erf(+∞) = 1`, `erf(−∞) = −1`
+ * - For numeric inputs, returns a high-precision decimal approximation.
+ * - For symbolic inputs, returns an unevaluated `erf(x)` node.
+ *
+ * @param x - The input expression.
+ * @returns The error function value.
+ *
+ * @see https://en.wikipedia.org/wiki/Error_function
+ *
+ * @example
+ * ```ts
+ * erf(Expression.create(0)).text()     // "0"
+ * erf(Expression.create('x')).text()   // "erf(x)"
+ * ```
+ */
+export declare function erf(x: Expression): Expression;
+/**
+ * Computes the normalized sinc function: `sinc(x) = sin(x) / x`.
+ *
+ * By convention, `sinc(0) = 1` (the removable singularity).
+ * The function is even: `sinc(-x) = sinc(x)`.
+ *
+ * @param x - The input expression.
+ * @returns The sinc function value.
+ *
+ * @example
+ * ```ts
+ * sinc(Expression.create(0)).text()     // "1"
+ * sinc(Expression.create('x')).text()   // "sinc(x)"
+ * ```
+ */
+export declare function sinc(x: Expression): Expression;
+/**
+ * Computes the sine integral: `Si(x) = ∫₀ˣ sin(t)/t dt`.
+ *
+ * - `Si(+∞) = π/2`, `Si(−∞) = −π/2`
+ * - `Si(0) = 0`
+ * - The function is odd: `Si(-x) = -Si(x)`.
+ *
+ * @param x - The input expression.
+ * @returns The sine integral value.
+ *
+ * @example
+ * ```ts
+ * Si(Expression.create(0)).text()     // "0"
+ * Si(Expression.create('x')).text()   // "Si(x)"
+ * ```
+ */
+export declare function Si(x: Expression): Expression;
+/**
+ * Computes the hyperbolic sine integral: `Shi(x) = ∫₀ˣ sinh(t)/t dt`.
+ *
+ * - `Shi(+∞) = +∞`, `Shi(−∞) = −∞`
+ * - `Shi(0) = 0`
+ * - The function is odd: `Shi(-x) = -Shi(x)`.
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic sine integral value.
+ *
+ * @example
+ * ```ts
+ * Shi(Expression.create(0)).text()     // "0"
+ * Shi(Expression.create('x')).text()   // "Shi(x)"
+ * ```
+ */
+export declare function Shi(x: Expression): Expression;
+/**
+ * Computes the cosine integral: `Ci(x) = γ + ln(x) + ∫₀ˣ (cos(t)−1)/t dt`,
+ * where γ is the Euler–Mascheroni constant.
+ *
+ * - `Ci(+∞) = 0`, `Ci(−∞) = 0`
+ * - `Ci(0) = −∞`
+ * - The function is even for the principal branch: `Ci(-x) = Ci(x)`.
+ *
+ * @param x - The input expression.
+ * @returns The cosine integral value.
+ *
+ * @example
+ * ```ts
+ * Ci(Expression.create('x')).text()   // "Ci(x)"
+ * ```
+ */
+export declare function Ci(x: Expression): Expression;
+/**
+ * Computes the hyperbolic cosine integral: `Chi(x) = γ + ln(x) + ∫₀ˣ (cosh(t)−1)/t dt`,
+ * where γ is the Euler–Mascheroni constant.
+ *
+ * - `Chi(±∞) = +∞`
+ * - `Chi(0) = −∞`
+ * - The function is even for the principal branch: `Chi(-x) = Chi(x)`.
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic cosine integral value.
+ *
+ * @example
+ * ```ts
+ * Chi(Expression.create('x')).text()   // "Chi(x)"
+ * ```
+ */
+export declare function Chi(x: Expression): Expression;
+/**
+ * Computes the exponential integral: `Ei(x) = −∫₋ₓ^∞ e^(−t)/t dt` (Cauchy principal value).
+ *
+ * - `Ei(+∞) = +∞`, `Ei(−∞) = 0`
+ * - `Ei(0) = −∞`
+ *
+ * @param x - The input expression.
+ * @returns The exponential integral value.
+ *
+ * @example
+ * ```ts
+ * Ei(Expression.create(0)).text()     // "-Infinity"
+ * Ei(Expression.create('x')).text()   // "Ei(x)"
+ * ```
+ */
+export declare function Ei(x: Expression): Expression;
+/**
+ * Computes the logarithmic integral: `Li(x) = ∫₀ˣ 1/ln(t) dt`.
+ *
+ * - `Li(+∞) = +∞`
+ * - `Li(1) = −∞` (the function has a logarithmic singularity at 1)
+ * - For negative numeric inputs, returns the symbolic form.
+ *
+ * @param x - The input expression.
+ * @returns The logarithmic integral value.
+ *
+ * @example
+ * ```ts
+ * Li(Expression.create('x')).text()   // "Li(x)"
+ * ```
+ */
+export declare function Li(x: Expression): Expression;
+/**
+ * Computes the natural (base-e) logarithm, or optionally a logarithm with a specified base.
+ *
+ * When `Settings.EVALUATE` is `false`, real-domain logarithm identities are
+ * applied only when their arguments are provably positive real values. This
+ * keeps product, quotient, and power rewrites from crossing principal complex
+ * branches when a symbolic sign is unknown.
+ *
+ * For known negative real inputs, returns `log(|x|) + iπ`. Complex inputs use the
+ * principal branch: `log(z) = log|z| + i·arg(z)`.
+ *
+ * @param x - The expression to take the logarithm of.
+ * @param base - Optional logarithm base. Defaults to `e` (natural log).
+ * @param expandPrimes - When `true`, decomposes integer arguments into prime factors
+ *   (e.g. `log(8)` becomes `3·log(2)`). Defaults to `false`.
+ * @returns The logarithm of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `-∞`.
+ *
+ * @example
+ * ```ts
+ * log('e').text()           // "1"
+ * log(1).text()             // "0"
+ * log('e^x').text()         // "x"
+ *
+ * // With base
+ * log(8, 2).text()          // "3"
+ * ```
+ */
+export declare function log(x: ExpressionInput, base?: ExpressionInput, expandPrimes?: boolean): Expression;
+/**
+ * Returns the maximum value from a set of expressions.
+ *
+ * If all arguments can be compared numerically (or have assumed numeric values),
+ * returns the largest. Otherwise returns a symbolic `max(...)` node.
+ *
+ * @param args - Two or more expressions to compare.
+ * @returns The maximum value, or a symbolic `max(...)` node.
+ *
+ * @example
+ * ```ts
+ * max(1, 3, 2).text()     // "3"
+ * max(-5, 0).text()       // "0"
+ * max('x', 'y').text()    // "max(x, y)"
+ * ```
+ */
+export declare function max(...args: ExpressionInput[]): Expression;
+/**
+ * Returns the minimum value from a set of expressions.
+ *
+ * If all arguments can be compared numerically (or have assumed numeric values),
+ * returns the smallest. Otherwise returns a symbolic `min(...)` node.
+ *
+ * @param args - Two or more expressions to compare.
+ * @returns The minimum value, or a symbolic `min(...)` node.
+ *
+ * @example
+ * ```ts
+ * min(1, 3, 2).text()     // "1"
+ * min(-5, 0).text()       // "-5"
+ * min('x', 'y').text()    // "min(x, y)"
+ * ```
+ */
+export declare function min(...args: ExpressionInput[]): Expression;
+/**
+ * Computes the exponential function e^x.
+ *
+ * - `exp(0) = 1`
+ * - `exp(+∞) = +∞`, `exp(−∞) = 0`
+ * - For complex inputs `a + bi` where both parts are numeric, applies Euler's formula:
+ *   `exp(a + bi) = exp(a) · (cos(b) + i·sin(b))`.
+ * - For symbolic inputs, returns `e^(x)`.
+ *
+ * @param x - The exponent expression.
+ * @returns The value of e raised to the power `x`.
+ *
+ * @example
+ * ```ts
+ * exp(0).text()       // "1"
+ * exp(1).text()       // "2.71828182845904..."
+ * exp('x').text()     // "e^(x)"
+ * ```
+ */
+export declare function exp(x: ExpressionInput): Expression;
+/**
+ * Constructs a {@link Matrix} from the provided rows.
+ *
+ * Each argument is an array representing one row of the matrix. All rows must
+ * have the same length; elements are converted to {@link Expression} instances.
+ *
+ * @param args - One or more arrays, each representing one row of the matrix.
+ * @returns A new {@link Matrix} instance.
+ * @throws {@link core!MathError} If rows have inconsistent lengths.
+ *
+ * @example
+ * ```ts
+ * // 2×2 identity matrix
+ * matrix([1, 0], [0, 1]).text()   // "matrix([1, 0], [0, 1])"
+ *
+ * // 2×3 matrix
+ * matrix([1, 2, 3], [4, 5, 6]).text()
+ * ```
+ */
+export declare function matrix(...args: (NerdamerInput[] | Vector)[]): Matrix;
+/**
+ * Computes a finite summation: `sum(expr, k, a, b) = Σ_{k=a}^{b} expr`.
+ *
+ * - If bounds are integers and the number of terms ≤ `Settings.MAX_PRODUCT_AND_SUMMATION_ITERATION`,
+ *   evaluates by accumulating each term.
+ * - If `lower > upper`, returns `0` (empty range).
+ * - If `expr` does not depend on the index variable, simplifies to `expr · (b − a + 1)`.
+ * - Otherwise returns a symbolic `sum(expr, k, a, b)` node.
+ *
+ * @param expr - The expression to be summed.
+ * @param index - The index variable (must be a plain symbol).
+ * @param lower - The lower bound (integer required for evaluation).
+ * @param upper - The upper bound (integer required for evaluation).
+ * @returns The summation result or a symbolic `sum` node.
+ *
+ * @example
+ * ```ts
+ * // Σ_{k=1}^{5} k = 15
+ * sum('k', 'k', 1, 5).text()   // "15"
+ * ```
+ */
+export declare function sum(expr: Expression, index: Expression, lower: Expression, upper: Expression): Expression;
+/**
+ * Computes a finite product: `product(expr, k, a, b) = Π_{k=a}^{b} expr`.
+ *
+ * - If bounds are integers and the number of terms ≤ `Settings.MAX_PRODUCT_AND_SUMMATION_ITERATION`,
+ *   evaluates by multiplying each term.
+ * - If `lower > upper`, returns `1` (empty product).
+ * - If `expr` does not depend on the index variable, simplifies to `expr^(b − a + 1)`.
+ * - Otherwise returns a symbolic `product(expr, k, a, b)` node.
+ *
+ * @param expr - The expression to be multiplied.
+ * @param index - The index variable (must be a plain symbol).
+ * @param lower - The lower bound (integer required for evaluation).
+ * @param upper - The upper bound (integer required for evaluation).
+ * @returns The product result or a symbolic `product` node.
+ *
+ * @example
+ * ```ts
+ * // Π_{k=1}^{5} k = 120 (same as 5!)
+ * product('k', 'k', 1, 5).text() // "120"
+ * ```
+ */
+export declare function product(expr: Expression, index: Expression, lower: Expression, upper: Expression): Expression;
+/**
+ * Tests whether a value is present in a supported finite container.
+ *
+ * @remarks
+ * `Vector` membership uses the vector's element equality, while `ValuesSet` and
+ * `SolutionSet` delegate to their semantic set membership. `Dictionary` membership checks
+ * keys rather than stored values. Unsupported container types remain symbolic.
+ *
+ * @param x - Vector, finite set, solution set, or dictionary to search.
+ * @param value - Value to look up, or dictionary key when `x` is a Dictionary.
+ * @returns `1` when the value is found and `0` otherwise.
+ *
+ * @example
+ * ```ts
+ * const d = Parser.parse('{x=>1, y=>a}') as Dictionary;
+ * contains(d, 'x').text(); // 1
+ *
+ * const v = new Vector(['x', 1, 2]);
+ * contains(v, 10).text(); // 0
+ * ```
+ */
+export declare function contains(x: Expression | Vector | ValuesSet | SolutionSet | Dictionary, value: ExpressionInput): Expression;