Expression

The generated function uses JavaScript number arithmetic and the registered numerical implementations. It is intended for repeated, relatively low-precision scalar evaluation rather than arbitrary-precision symbolic computation. Functions without a faithful JavaScript-number equivalent are rejected instead of being compiled with approximate or unrelated semantics. When args is omitted, free variables are collected and sorted alphabetically. Supplying args defines the positional argument order explicitly.

core!UnsupportedOperationError If a surviving function has no faithful JavaScript-number implementation.

The expression is expanded as part of coefficient collection. For multivariate input, coefficient keys encode the exponent tuple in the same order as variables. Terms that do not contain a requested variable are retained as coefficients rather than discarded.

Direct construction is primarily a representation-level API. When x is an existing Expression, the constructor deep-copies its expression tree. When plainConstruct is true and x is a string, that string is stored as the raw node value without parsing. Other inputs are delegated to Expression.create, and JavaScript constructor return semantics therefore allow that factory-created expression to become the result of new Expression(...). Ordinary code should use Expression.create for construction/coercion and Expression.copy when an independent tree is required. Direct constructor calls are reserved for low-level representation code.

Multipliers, powers, function arguments, explicit exponential bases, and aggregate elements are recursively copied. Mutating those structures on the returned expression therefore does not mutate the corresponding structures on the source.

Strings and primitive numeric inputs are parsed through Parser. An existing Expression is returned unchanged when no substitution values are supplied; pass copy: true to request an independent deep copy. A Rational is converted to a numeric expression while preserving its decimal-origin marker. An Equation is converted to its residual expression by moving the right side to the left on a copy of the equation. For example, x = 2 becomes the expression x - 2 in canonical form.

core!UnexpectedDataType Thrown when parsing produces another parser entity, such as a vector or matrix, where an Expression is required.

This is a process-wide parser/algebra setting used by the addition operation. Changing it affects subsequent symbolic operations globally.

A copy is created before any changes are made. Distribution is performed only when the expression is sum-like, has power one, and carries a non-unit outer multiplier. Nested sum terms encountered during the pass are handled recursively. Expressions that do not meet those conditions are returned as equivalent copies.

Aggregate nodes pass each stored element and its key to fn. Atomic nodes invoke the callback once with a unit-multiplier form of the expression and the node's value as the key. The callback's return value is ignored; this method does not rebuild the expression. Use Expression.forEveryElement when returned replacements should participate in reconstruction. For atomic nodes, creating the unit-multiplier argument does not mutate the receiver. Aggregate elements, however, are passed by reference, so the callback can mutate their internal objects if it chooses to do so.

The record is mutable representation state. Expression.getElements returns this object directly when it exists; callers that mutate it are responsible for preserving a valid expression representation and regenerating derived values.

Sum-like nodes flatten nested linear sums one level while products retain nested sums. Atomic nodes contribute a unit-multiplier copy. When withMultiplier is true, a product's outer multiplier is appended as a numeric expression before sorting. The option has no effect on sums. Stored aggregate elements are returned by reference rather than deep-copied.

Equality is not a JavaScript identity or raw-tree comparison. Nerdamer first consults applicable assumptions and otherwise subtracts the expressions, canonicalizes numeric radicals where needed, expands the difference, and accepts equality when that result reduces to numeric zero. A false result therefore means equality was not established by the current comparison machinery; it is not a general theorem-prover result for arbitrary symbolic identities.

Evaluation uses the ordinary serialization path. When scientific display metadata is present, a copy without that metadata is serialized so formatting cannot change the value sent through Parser.evaluate. That parser path enables Nerdamer's evaluation mode, so numeric constants and supported numeric functions are evaluated according to the parser's current precision and settings. The original expression is not modified.

Expansion delegates to Nerdamer's canonical expansion algorithm. The result is independent of the receiver, but callers should treat object identity as an implementation detail rather than relying on expansion to allocate a particular representation. Branch-sensitive power rules are preserved rather than treating every algebraic power identity as universally valid over the complex domain.

Unlike Expression.each, callback results are used as replacements. The traversal reconstructs functions, products, sums, and exponential powers while restoring the original outer multiplier and power. Numeric and variable roots are returned unchanged by the traversal helper rather than passed through fn, so the result may preserve the receiver's identity for those atomic cases.

By default the returned strings are function names such as sin and cos. When getValues is true, the collector instead returns each function node's stored value string, such as sin(x), while still deduplicating repeated values. Traversal includes function arguments, aggregate elements, and EXP bases and powers. If fns is supplied, results are appended to that same array.

The array is lazily created when no arguments are present and is returned by reference, not copied. Mutating the returned array therefore mutates this expression. Call Expression.updateValue after structural changes when the stored value string must be regenerated.

EXP nodes return their stored base directly because signs and coefficients that belong inside an exponential base must remain part of that base. Other node types derive the same base from a deep structural copy with the outer multiplier and outer power removed. The EXP branch returns the internal base by reference. The non-EXP branch returns an independent expression and does not re-enter the parser.

The operation collects the rational multiplier's denominator and factors carried by negative powers in a product. It does not first combine a sum over a common denominator. For example, a/x + 8 is a sum whose outer denominator is one, while the individual term a/x has denominator x.

When elements exists, the actual internal record is returned rather than a copy. Mutating it therefore mutates this expression and can invalidate canonical keys or the stored value string unless the caller restores the corresponding representation state. When this node has no element record, a new empty object is returned and is not attached to the expression.

The multiplier is initialized lazily. Numeric nodes derive it from their stored value; other nodes default to one. Without asExpression, the returned Rational is the actual mutable multiplier owned by this expression, not a copy. Passing true wraps that rational value in a new numeric Expression.

The operation separates the numerator of the rational multiplier and recursively collects numerator factors from linear products. It does not first rewrite a sum over a common denominator; a sum such as a/x + 8 therefore remains the numerator of that top-level representation.

The power is initialized lazily and stored on the expression. Numeric (NUM) nodes default to power zero because their numeric value is carried by the multiplier; other node types default to power one. The returned Expression is the mutable internal power object, not a copy.

Nerdamer consults applicable assumptions and otherwise evaluates the difference numerically/symbolically. These Expression comparison methods remain boolean for compatibility. An unknown assumption result falls through to the ordinary comparison path; if the relation still cannot be established, the method returns false. The lower-level Assumption relations preserve unknown as undefined. Complex values are not ordered and cause the comparison to throw.

core!UnsupportedOperationError Thrown when either side is classified as complex.

Nerdamer consults applicable assumptions and otherwise evaluates the difference numerically/symbolically. These Expression comparison methods remain boolean for compatibility. An unknown assumption result falls through to the ordinary comparison path; if the relation still cannot be established, the method returns false. The lower-level Assumption relations preserve unknown as undefined. Complex values are not ordered and cause the comparison to throw.

core!UnsupportedOperationError Thrown when either side is classified as complex.

The check follows the multiplier, explicit power, exponential base, function arguments, and aggregate elements. It tests the rational asDecimal provenance marker; it does not merely search rendered text for a decimal point.

Aggregate elements are always searched. When deep is true, function arguments and the explicit base and power of EXP nodes are searched recursively as well. With deep disabled, nested function arguments and EXP components are not traversed.

This predicate examines this node's effective power; it does not recursively scan every descendant for radicals. When checkIrrationalDenominator is true, the power must also be negative, which identifies a radical occurring in a denominator.

The default implementation is the identity function. Applications may replace this static hook, but doing so changes direct-construction behavior globally. Expression.create does not route every parsed input through this hook.

The result excludes the imaginary-unit factor itself. Decomposition follows principal-branch handling for powered complex values and preserves unresolved complex function components symbolically instead of silently treating them as zero. realpart(...) and imagpart(...) nodes are treated as real-valued component expressions.

Parser.setI

Real symbolic nodes are copied and inverted by negating the outer power and rational multiplier. Complex expressions use the general division path so real and imaginary components are handled correctly. Simple radical denominators are rationalized when the power operation identifies an eligible radical. The receiver is not modified.

core!DivisionByZeroError Thrown by the underlying rational or division operation when the expression is zero.

The check is structural: it recognizes the current imaginary-unit symbol, recurses through function arguments, EXP bases and powers, and aggregate elements. The component functions realpart(...) and imagpart(...) are treated as real-valued by definition even when their arguments contain complex values. This predicate does not impose an ordering or otherwise claim that an unrestricted symbolic expression is provably real.

This is narrower than the mathematical statement "contains no free variables." It recognizes numeric nodes, parser constants such as pi and e, constant-base/constant-power EXP nodes, and sums or products whose elements are recursively recognized as constant. The imaginary unit is handled by dedicated complex logic rather than classified here as a parser constant. Do not use this predicate as a general proof that an arbitrary function expression is or is not mathematically constant.

This is a representation-level symbol check. It does not require the node to have multiplier one or power one, so callers that require exactly the mathematical unit i must impose those additional conditions themselves.

Despite the historical method name, this is not a test for a purely imaginary value with zero real part. A value such as 3 + 2*i also returns true because the evaluated result contains a complex component.

The tolerance is 10^(-Decimal.precision + k). This is a numerical-algorithm convenience and must not be used as a replacement for exact symbolic zero testing; use Expression.isZero when exact representation-level zero is required.

core!UnsupportedOperationError Thrown when the expression is classified as complex.

The predicate accepts recursively composed sums and products whose outer powers are non-negative integers. Function nodes, EXP nodes, infinities, negative powers, and fractional powers are rejected. This is a structural eligibility check used by polynomial-oriented algorithms; it does not construct a algebra!Polynomial.

This is an internal canonicalization key, not a user-facing serialization format. Numeric nodes normally collapse to Expression.numberHash; variables, functions, exponentials, and infinities use multiplier-free identifiers; aggregate nodes derive a key from their canonical elements. Group (GRP) handling can use the power directly when isGroup is requested. The exact key format is coupled to parser/algebra combination logic and should not be persisted as an external interchange format.

Error Thrown when no key-generation rule exists for the node's internal type.

Nerdamer consults applicable assumptions and otherwise evaluates the difference numerically/symbolically. These Expression comparison methods remain boolean for compatibility. An unknown assumption result falls through to the ordinary comparison path; if the relation still cannot be established, the method returns false. The lower-level Assumption relations preserve unknown as undefined. Complex values are not ordered and cause the comparison to throw.

core!UnsupportedOperationError Thrown when either side is classified as complex.

Nerdamer consults applicable assumptions and otherwise evaluates the difference numerically/symbolically. These Expression comparison methods remain boolean for compatibility. An unknown assumption result falls through to the ordinary comparison path; if the relation still cannot be established, the method returns false. The lower-level Assumption relations preserve unknown as undefined. Complex values are not ordered and cause the comparison to throw.

core!UnsupportedOperationError Thrown when either side is classified as complex.

This is a low-level constructor for numeric expression nodes. The supplied value is stored as text and is interpreted as a Rational when the multiplier is first requested. Use Expression.create when the input should be parsed as a general mathematical expression.

The operation delegates to Nerdamer's power canonicalization and simplification rules. Noninteger and complex powers follow principal-branch semantics; identities such as distributing a fractional power over arbitrary products are therefore applied only when the implementation can preserve the relevant branch. The receiver is not modified.

core!UndefinedError Thrown for undefined infinity-related powers handled by the power operation.

core!ZeroToZeroPowerError Thrown for zero-power cases classified as undefined by the power operation.

Decomposition follows principal-branch handling for powered complex values. Explicitly complex function calls that cannot be decomposed are preserved through a symbolic realpart(...) wrapper rather than being guessed. The component functions realpart(...) and imagpart(...) are themselves treated as real-valued.

This list differs from the parser's restricted-name list. It is used by expression traversal when deciding which VAR nodes should be reported as free variables. The distinction is historical and should not be interpreted as a general parser-reservation policy.

This is not a general symbolic sign analysis. Most node types return the sign of their outer Rational multiplier. EXP nodes additionally multiply that result by the representation-level sign of their stored base. Unknown assumptions are not inferred here.

Complex expressions return their modulus sqrt(re^2 + im^2). For other expressions, the method copies the node and removes a negative stored sign or multiplier. This is representation-oriented normalization, not a general assumption-driven implementation of symbolic abs(...).

The ordering is representational, not a mathematical ordering relation. It keeps the imaginary unit last, orders like node types by value and descending power, and otherwise falls back to the internal expression-type order. Replacing this function changes ordering globally for subsequent formatting and reconstruction.

Formatting temporarily switches the class-wide power-operator token while delegating to the normal expression formatter, then restores ^. The expression itself is not modified.

This is stricter than Expression.eq, but it is still not object identity or byte-for-byte tree equality. After verifying matching top-level types (or matching function names for function nodes), it delegates to Nerdamer's symbolic equality comparison.

Substitution supports more than direct variable replacement: the underlying algorithm can match compatible products and sums, recurse into function arguments, and substitute within powers. Inputs are converted through Expression.create. The receiver is not mutated as part of normal execution. Unchanged branches can preserve the receiver's identity, and an exact match can return the supplied replacement object directly, so callers that require independent ownership should copy the result explicitly.

Exact rational text is the default. Use sort: true to render terms in Nerdamer's conventional display order without changing the stored expression. Decimal output, precision, scientific notation, and power wrapping can also be selected per call. The asId mode is used by internal identity/canonicalization logic and should not be treated as a stable interchange format.

This is an internal representation helper for bases whose exponent must be stored separately. When powerLess is true, the existing outer power is deleted from the converted base before it is wrapped. Because Expression.create may reuse an input Expression, callers must not use that option when the original object must remain unchanged.

Base extraction is defined by Expression.getBase. Because getBase() exposes an EXP node's stored base by reference, this method copies that base before returning it. Non-EXP bases are already independent copies.

Function nodes rebuild value from their name and arguments. Product and sum-like nodes rebuild it from their current elements. Other node types are left unchanged. This method mutates the receiver and returns the same object for chaining.

Only VAR nodes are collected. The current imaginary-unit symbol and names in Expression.RESERVED are excluded. Traversal includes function arguments, aggregate elements, and EXP bases and powers. Encounter order is preserved unless the caller sorts the returned array separately. If vars is supplied, new names are appended to that same accumulator without duplicating names already present.