nerdamer API

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`).

Computes the arccosine (inverse cosine) of an expression. Returns exact symbolic values involving π for well-known inputs: `0 → π/2`, `1/2 → π/3`, `1/√2 → π/4`, `√3/2 → π/6`, `1 → 0`. Uses the identity `acos(-x) = π − acos(x)` for negative arguments. For numeric inputs outside `[-1, 1]`, returns a complex result via `π/2 + asin(|x|)` with the appropriate sign adjustment.

Computes the inverse hyperbolic cosine of an expression. - `acosh(1) = 0` - `acosh(0) = iπ/2` - `acosh(+∞) = +∞` - For inputs less than 1, returns a complex result via `log(x + sqrt(x²−1))`.

Computes the arccotangent (inverse cotangent) of an expression: `acot(x) = atan(1/x)`. At infinity: `acot(+∞) = 0`, `acot(−∞) = π`.

Computes the inverse hyperbolic cotangent of an expression: `acoth(x) = atanh(1/x)`. - `acoth(±∞) = 0` - For real evaluation, uses the identity `acoth(x) = (1/2)·ln((x + 1)/(x − 1))`.

Computes the arccosecant (inverse cosecant) of an expression: `acsc(x) = asin(1/x)`. At infinity: `acsc(±∞) = 0`.

Computes the inverse hyperbolic cosecant of an expression: `acsch(x) = asinh(1/x)`. - `acsch(±∞) = 0` - For real evaluation, uses the identity `acsch(x) = ln((1 + sqrt(1/x² + 1))/x)`.

Aliases an existing parser operator and returns the root API for chaining.

Computes the arccosine (inverse cosine) of an expression. Returns exact symbolic values involving π for well-known inputs: `0 → π/2`, `1/2 → π/3`, `1/√2 → π/4`, `√3/2 → π/6`, `1 → 0`. Uses the identity `acos(-x) = π − acos(x)` for negative arguments. For numeric inputs outside `[-1, 1]`, returns a complex result via `π/2 + asin(|x|)` with the appropriate sign adjustment.

Computes the arcsine (inverse sine) of an expression. Returns exact symbolic values involving π for well-known inputs: `0 → 0`, `1/2 → π/6`, `1/√2 → π/4`, `√3/2 → π/3`, `1 → π/2`. Uses the identity `asin(-x) = -asin(x)` for negative arguments. For numeric inputs outside `[-1, 1]`, returns a complex result.

Computes the arctangent (inverse tangent) of an expression. Returns exact symbolic values involving π for well-known inputs: `0 → 0`, `1/√3 → π/6`, `1 → π/4`, `√3 → π/3`. Uses the identity `atan(-x) = -atan(x)` for negative arguments. At infinity: `atan(+∞) = π/2`, `atan(−∞) = −π/2`.

Returns the argument of an expression

Computes the arcsecant (inverse secant) of an expression: `asec(x) = acos(1/x)`. At infinity: `asec(±∞) = π/2`.

Computes the inverse hyperbolic secant of an expression: `asech(x) = acosh(1/x)`. For real evaluation, uses the identity `asech(x) = ln((1 + sqrt(1/x² − 1))/x)`.

Computes the arcsine (inverse sine) of an expression. Returns exact symbolic values involving π for well-known inputs: `0 → 0`, `1/2 → π/6`, `1/√2 → π/4`, `√3/2 → π/3`, `1 → π/2`. Uses the identity `asin(-x) = -asin(x)` for negative arguments. For numeric inputs outside `[-1, 1]`, returns a complex result.

Computes the inverse hyperbolic sine of an expression. - `asinh(0) = 0` - `asinh(+∞) = +∞`, `asinh(−∞) = −∞` - For complex inputs, uses `log(x + sqrt(x² + 1))`.

Registers a process-wide numeric interval assumption.

Computes the arctangent (inverse tangent) of an expression. Returns exact symbolic values involving π for well-known inputs: `0 → 0`, `1/√3 → π/6`, `1 → π/4`, `√3 → π/3`. Uses the identity `atan(-x) = -atan(x)` for negative arguments. At infinity: `atan(+∞) = π/2`, `atan(−∞) = −π/2`.

Computes the two-argument arctangent `atan2(y, x)`, which returns the angle in radians between the positive x-axis and the point `(x, y)`. Unlike atan, `atan2` correctly handles all four quadrants and returns values in the range `(−π, π]`. Returns exact multiples of π where possible.

Computes the inverse hyperbolic tangent of an expression. - `atanh(0) = 0` - For inputs outside `(-1, 1)` or complex inputs, uses the identity `atanh(z) = (1/2)·ln((1 + z)/(1 − z))`.

Compiles an expression into a native JavaScript-number function.

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 sqrt, `cbrt` is preserved as a function node rather than rewritten to `x^(1/3)` to avoid principal-branch issues during symbolic manipulation.

Rounds a number up to the nearest integer (ceiling function).

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)`.

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)`.

Clears all known parser values.

Tests whether a value is present in a supported finite container.

Returns the exact rational content of polynomial expression input.

Parses the supported TeX subset into a Nerdamer parser entity.

Converts an expression to TeX without requiring the caller to construct a converter. String input follows the legacy source-preserving path before symbolic normalization; entity input keeps ordinary structured Converter behavior.

Computes the cosine of an expression. Returns exact symbolic values for well-known multiples of π (π/6, π/4, π/3, π/2, π, etc.). Cosine is an even function: `cos(-x)` automatically simplifies to `cos(x)`. Inverse trig compositions are resolved: - `cos(acos(x))` returns `x` - `cos(asin(x))` returns `sqrt(1 − x²)` - `cos(atan(x))` returns `1/sqrt(1 + x²)`

Computes the hyperbolic cosine of an expression. - `cosh(0) = 1` - `cosh(±∞) = +∞` - For complex inputs: `cosh(a + bi) = cosh(a)·cos(b) + i·sinh(a)·sin(b)`

Computes the cotangent of an expression: `cot(x) = cos(x)/sin(x)`. Returns exact values at well-known angles by dividing cos by sin.

Computes the hyperbolic cotangent of an expression: `coth(x) = 1/tanh(x)`. - `coth(+∞) = 1`, `coth(−∞) = −1` - `coth(0)` is undefined.

Computes a three-dimensional cross product or preserves symbolic operands.

Computes the cosecant of an expression: `csc(x) = 1/sin(x)`. Returns exact values at well-known angles by inverting the result of sin.

Computes the hyperbolic cosecant of an expression: `csch(x) = 1/sinh(x)`. - `csch(±∞) = 0` - `csch(0)` is undefined.

Calculates the definite integral using Adaptive Simpson. Note that this function uses native JS number due to severe computational overhead when implemented with Decimal.js.

Returns the total degree of polynomial expression input.

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.

Computes the determinant without mutating the supplied Matrix.

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 gamma function is applied.

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 gamma function is applied.

Differentiates an expression symbolically. The chain, product, sum, and power rules are applied recursively, together with the built-in derivative table for recognized functions. An omitted variable is inferred as the first variable in the expression. Existing Expression input is reused during normalization.

Returns the quotient and remainder of polynomial division.

Divides two expressions using polynomial quotient/remainder reconstruction when possible.

Computes the dot product of two Vectors or preserves two symbolic operands.

Computes the exponential integral: `Ei(x) = −∫₋ₓ^∞ e^(−t)/t dt` (Cauchy principal value). - `Ei(+∞) = +∞`, `Ei(−∞) = 0` - `Ei(0) = −∞`

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.

Computes the complementary error function: `erfc(x) = 1 − erf(x)`.

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)`.

Expands the function by distributing the power and the multiplier whenever possible

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 gamma function via Γ(x + 1).

Factors polynomial-like numerator and denominator components of an 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 gamma function via Γ(x + 1).

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.

Rounds a number down to the nearest integer (floor function).

Lists currently registered parser functions by registration level.

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.

Computes a symbolic greatest common divisor over rational polynomial structure.

Reads the current value of a shared parser setting. `PRECISION` mirrors the root setter's special handling and is read from the shared Rational/Decimal precision. Other settings delegate to the parser.

Returns the current text registered for a parser constant. Built-in constants are generated at the active precision before being returned. As in the legacy API, an unknown constant is reported as the string `'undefined'`.

Returns a detached snapshot of a registered parser operator.

Returns a snapshot of all known parser values in text or TeX form.

Computes an expression-facing Groebner basis for polynomial generators.

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.

Returns the symbolic hypotenuse of two expressions. Matching linear sine and cosine terms collapse through the Pythagorean identity; otherwise the result is the principal square root of the sum of squares.

Computes a symbolic inverse Laplace transform from a transform variable to a time variable. The strategy applies linearity, extracts constants, consults the inverse transform table, normalizes supported shifted quadratics and exponential delays, and finally tries partial-fraction decomposition.

Computes a symbolic inverse Laplace transform from a transform variable to a time variable. The strategy applies linearity, extracts constants, consults the inverse transform table, normalizes supported shifted quadratics and exponential delays, and finally tries partial-fraction decomposition.

Retrieves the imaginary part of a complex number

Creates an identity matrix of integer size.

Finds a symbolic indefinite integral with respect to a plain variable. Constants and linear sums are separated first. The remaining integrand is tried against the integral table and bounded strategies for radical and algebraic substitution, quadratic radicals, integration by parts, derivative-pattern substitution, rational decomposition, and the Weierstrass tangent half-angle substitution.

Computes a symbolic Laplace transform from a time variable to a transform variable. The expression is expanded, linear sums are transformed term by term, constants independent of the time variable are extracted, and the remaining expression is matched against the transform table.

Returns the least common multiple of two expressions. Numeric inputs reuse exact `Rational` arithmetic. Polynomial expressions use the existing GCD normalization so shared symbolic factors are retained.

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.

Computes a symbolic finite or infinite limit. The implementation combines direct substitution, side-aware pole analysis, simplification, bounded L'Hopital recursion, indeterminate-form rewrites, composition rules, dominant-growth analysis at infinity, and a table of known limits.

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)`.

Constructs a 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 Expression instances.

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.

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.

Computes the modulo (remainder) of `x` divided by `y`.

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)`.

Computes the nth root of an expression as its principal power.

Decomposes a rational expression P(x)/Q(x) into partial fractions.

Calculates the polar from of a complex number //IMPROVE: Potential speed boost by just returning i.

Formats a parser entity or notation string as TeX or normalized text.

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.

Retrieves the real part of a complex number

Attempts to convert a polar form complex to rectangular form. If no exact identity is found, the decimal representation in rectangular form is returned.

Rounds a number to the nth decimal place. If no precision is provided, rounds to the nearest integer.

Computes the secant of an expression: `sec(x) = 1/cos(x)`. Returns exact values at well-known angles by inverting the result of cos.

Computes the hyperbolic secant of an expression: `sech(x) = 1/cosh(x)`. - `sech(0) = 1` - `sech(±∞) = 0`

Changes one or more shared parser settings. The legacy `PRECISION` setting is routed through Parser.setPrecision so Decimal-backed calculations and the finite-precision `pi` and `e` constants remain synchronized.

Registers or removes a parser constant using the legacy public entry point. Numeric values are converted to exact rational text before registration so they do not introduce decimal-formatting intent. The string `'delete'` removes the constant. Registration changes shared parser state.

Registers a symbolic function using the legacy public signature. Calls subsequently parsed with `name` substitute their arguments into `body` in the supplied order. Registration changes shared parser state.

Registers or updates a parser operator and returns the root API for chaining.

Sets a known parser value. Unlike a constant, a known value can be overridden by the values object supplied to a parse call.

Computes the hyperbolic sine integral: `Shi(x) = ∫₀ˣ sinh(t)/t dt`. - `Shi(+∞) = +∞`, `Shi(−∞) = −∞` - `Shi(0) = 0` - The function is odd: `Shi(-x) = -Shi(x)`.

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)`.

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.

Applies Nerdamer's finite symbolic simplification strategy to an expression.

Computes the sine of an expression. Returns exact symbolic values for well-known multiples of π (π/6, π/4, π/3, π/2, π, etc.). Sine is an odd function: `sin(-x)` automatically simplifies to `-sin(x)`. Inverse trig compositions are resolved: - `sin(asin(x))` returns `x` - `sin(acos(x))` returns `sqrt(1 − x²)` - `sin(atan(x))` returns `x/sqrt(1 + x²)`

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)`.

Computes the hyperbolic sine of an expression. - `sinh(0) = 0` - `sinh(+∞) = +∞`, `sinh(−∞) = −∞` - For complex inputs: `sinh(a + bi) = sinh(a)·cos(b) + i·cosh(a)·sin(b)`

Solves an equation or finds the zeros of an expression in one variable. The solver normalizes the input to `expression = 0`, tries direct symbolic transformations, factors numerator and denominator, and then applies symbolic, polynomial-numeric, and bounded function-numeric strategies to the factors. Zeros of denominator factors are excluded from the result.

Solves a system of expressions or equations for an ordered set of variables. Expressions are interpreted as equal to zero. The solver first tries exact linear reduction, then a lexicographic Groebner basis with symbolic back substitution for polynomial systems, and finally bounded multivariate Newton-Raphson. Rational polynomial systems may have denominators cleared for symbolic work; candidates are checked against the original domain.

Solves a system of expressions or equations for an ordered set of variables. Expressions are interpreted as equal to zero. The solver first tries exact linear reduction, then a lexicographic Groebner basis with symbolic back substitution for polynomial systems, and finally bounded multivariate Newton-Raphson. Rational polynomial systems may have denominators cleared for symbolic work; candidates are checked against the original domain.

Solves a system of expressions or equations for an ordered set of variables. Expressions are interpreted as equal to zero. The solver first tries exact linear reduction, then a lexicographic Groebner basis with symbolic back substitution for polynomial systems, and finally bounded multivariate Newton-Raphson. Rational polynomial systems may have denominators cleared for symbolic work; candidates are checked against the original domain.

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)`).

Replaces a value with another using the existing Expression tree.

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.

Creates frozen plain-variable Expressions keyed by their requested names.

Computes the tangent of an expression. Tangent is an odd function: `tan(-x)` automatically simplifies to `-tan(x)`. Returns `0` for all integer multiples of π. Inverse trig compositions are resolved: - `tan(atan(x))` returns `x` - `tan(asin(x))` returns `x/sqrt(1 − x²)` - `tan(acos(x))` returns `sqrt(1 − x²)/x`

Computes the hyperbolic tangent of an expression. - `tanh(0) = 0` - `tanh(+∞) = 1`, `tanh(−∞) = −1` - For complex inputs, uses the identity `tanh(z) = sinh(z)/cosh(z)` with component-wise evaluation.

Truncates a number toward zero. Numeric inputs discard their fractional part without changing the sign of the integer portion. Symbolic inputs remain unevaluated.

Function exported by Nerdamer.

Returns the package version declared by this Nerdamer build.

Compatibility registry of selected Nerdamer constructors and the shared Parser instance.

Runtime namespace containing Nerdamer's public error constructors. Use these constructors for reliable `instanceof` checks when calling the compatibility root API.

Thrown when code attempts to assign to a reserved or otherwise non-assignable parser name.

Thrown when vector, matrix, or structured-entity dimensions are incompatible.

Thrown for exact division by zero. Small nonzero numerical values are not treated as zero.

General mathematical precondition error for cases without a more specific error type.

Thrown when a named converter or pattern reference cannot be resolved.

Thrown when a required numeric conversion produces `NaN`.

Used for recognized operations that have not been implemented yet.

Used for invalid parser-operator definitions and operator dispatch failures.

General parser error for construction, evaluation, and registered-function failures.

Parser syntax error kept separate from lower-level tokenization failures.

Thrown when input cannot be represented as a polynomial under the requested contract.

Used when a mathematical operation has no defined value in the handled domain.

Used when input parses successfully but does not have the form an operation requires.

Thrown when tokenization encounters invalid adjacency, punctuation, or bracket structure.

Thrown when an operation is known but unsupported for the supplied form or domain.

Thrown for the indeterminate symbolic form `0^0`.