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.

Alias for nerdamer.acos.

Alias for nerdamer.asin.

Alias for nerdamer.atan.

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 numeric interval assumption in Nerdamer's global assumption state.

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 for repeated evaluation.

Computes the normalized Fresnel cosine integral C(x) = integral(cos(pi*t^2/2), t, 0, x). Numeric real arguments are evaluated numerically. Symbolic arguments remain as C(x).

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 value up to the nearest integer.

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.

Returns polynomial coefficients as a dense Vector ordered by ascending power. When no variable is supplied, the first variable in the expression is used, matching the legacy parser helper. A constant expression therefore has the single coefficient at power zero.

Completes the square for a quadratic expression. For a*x^2+b*x+c, the returned expression has the form a*(x+h)^2+k, with h=b/(2*a) and k=c-b^2/(4*a).

Returns the complex conjugate of an expression. For a complex number z = a + bi, the conjugate is a - bi. Distributes over sums, products, integer powers, and powers whose constant base is known not to lie on the principal logarithm's branch cut.

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

Returns the exact numeric content of polynomial expression input.

Returns the continued-fraction decomposition as a Collection containing sign, whole part, and a Vector of partial quotients.

Parses the supported TeX subset into a Nerdamer parser entity.

Converts an expression to TeX math markup 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.

Converts an expression to TeX math markup 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.

Returns the complex signum (csgn) of an expression, following the Maple/SymPy convention. Returns 1 if Re(z) > 0, -1 if Re(z) < 0, and sgn(Im(z)) if Re(z) = 0. Returns 0 for z = 0. For expressions containing free variables where the sign cannot be determined, returns an unevaluated symbolic csgn(z). Useful for branch cut decisions in sqrt, log, and power simplification.

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 degree of a polynomial expression.

Converts radians to degrees exactly.

Evaluates the Dirac delta function when the input is known to be nonzero.

Computes the determinant without mutating the supplied Matrix.

Computes the double factorial of an expression.

Computes the double factorial of an expression.

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

Alias for nerdamer.factorial.

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.

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.

Upper incomplete gamma Γ(a, z). Positive integer first arguments are expanded exactly using the finite-sum formula. Other inputs remain symbolic.

Lower incomplete gamma γ(a, z). Positive integer first arguments use γ(a,z) = Γ(a) - Γ(a,z). Other inputs remain symbolic.

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 a snapshot of all currently registered assumptions. Changing the returned Map does not change Nerdamer's active assumptions.

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.

Alias for nerdamer.ilaplace.

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.

Returns the inverse without modifying the supplied Matrix.

Tests whether an exact integer expression is prime. Non-integer or unresolved symbolic input remains as an unevaluated isprime(...) expression so it can be simplified later.

Returns whether Nerdamer currently reserves a variable or symbol name.

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 polynomial GCD 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.

Returns the line through two two-dimensional points, evaluated at dimension.

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

Returns the base-10 logarithm using the ordinary logarithm implementation.

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

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.

Returns the nullspace basis as a Vector of basis vectors.

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.

Wraps an expression in parentheses. Returns a function node whose only purpose is to visually group x with surrounding parentheses in output.

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

Returns the prime factors of a positive integer in ascending order. Repeated factors are retained, so pfactor(100) returns [2, 2, 5, 5]. The value 1 has no prime factors and returns an empty Vector.

Returns the prime-factor multiplicities of a positive integer. Dictionary keys are prime numbers in ascending order and values are their occurrence counts. For example, pfactord(100) returns {2 => 2, 5 => 2}.

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

Wraps the polynomial factor expressions in an ordered Vector.

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.

Converts degrees to radians exactly.

Retrieves the real part of a complex number

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.

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

Returns polynomial roots as a Vector. Unlike solve(), which returns a SolutionSet with solver metadata, this function preserves the roots API's Vector return type. Numeric constants retain the historical square-root interpretation. Univariate polynomials delegate to PolynomialSolver and therefore return numerical roots.

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

Computes the normalized Fresnel sine integral S(x) = integral(sin(pi*t^2/2), t, 0, x). Numeric real arguments are evaluated numerically. Symbolic arguments remain as S(x).

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.

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 limited-range 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 multivariate Newton-Raphson over a fixed search interval. 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 multivariate Newton-Raphson over a fixed search interval. 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)).

Legacy unit-step function. Unlike heaviside, the value at zero is 1.

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.

A convenience function for creating simple symbols reducing the reliance on strings

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.

Triangular pulse: max(1 - |x|, 0) when the comparison can be resolved.

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.

Replaces one repeated sub-expression with a generated uN symbol. The generated symbol is chosen so it does not collide with variables already present in the expression or substitution map. Pass the returned map to later calls when several substitutions should share one namespace, then use uUnSub to restore the original expressions.

Restores substitutions produced by uSub.

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 requirements.

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.