nerdamer 1.1.13 → 2.0.0-rc.1

package/output/math/math.js

@@ -0,0 +1,1811 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrt = sqrt;
+exports.nthroot = nthroot;
+exports.cbrt = cbrt;
+exports.parens = parens;
+exports.fibonacci = fibonacci;
+exports.factorial = factorial;
+exports.doubleFactorial = doubleFactorial;
+exports.heaviside = heaviside;
+exports.dirac = dirac;
+exports.numeric = numeric;
+exports.round = round;
+exports.sign = sign;
+exports.floor = floor;
+exports.ceiling = ceiling;
+exports.abs = abs;
+exports.modInv = modInv;
+exports.mod = mod;
+exports.gamma = gamma;
+exports.erfc = erfc;
+exports.erf = erf;
+exports.sinc = sinc;
+exports.Si = Si;
+exports.Shi = Shi;
+exports.Ci = Ci;
+exports.Chi = Chi;
+exports.Ei = Ei;
+exports.Li = Li;
+exports.log = log;
+exports.max = max;
+exports.min = min;
+exports.exp = exp;
+exports.matrix = matrix;
+exports.sum = sum;
+exports.product = product;
+exports.defint = defint;
+exports.contains = contains;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const assume_1 = require("../core/classes/assumption/assume");
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const utils_1 = require("../core/classes/expression/utils");
+const Matrix_1 = require("../core/classes/matrix/Matrix");
+const constants_1 = require("../core/classes/parser/constants");
+const constants_2 = require("../core/classes/parser/constants");
+const multiply_1 = require("../core/classes/parser/operations/multiply");
+const power_1 = require("../core/classes/parser/operations/power");
+const subtract_1 = require("../core/classes/parser/operations/subtract");
+const utils_2 = require("../core/classes/polynomial/utils");
+const Rational_1 = require("../core/classes/rational/Rational");
+const errors_1 = require("../core/errors");
+const bigint_1 = require("../core/functions/bigint/bigint");
+const primeFactor_1 = require("../core/functions/bigint/primeFactor");
+const complex_1 = require("../core/functions/complex");
+const decimal_1 = require("../core/functions/decimal");
+const Settings_1 = require("../core/Settings");
+const defintNative_1 = require("./defint/defintNative");
+const geometry_1 = require("./geometry");
+const trig_1 = require("./trig");
+const utils_3 = require("./utils");
+const NATIVE_DEFINITE_INTEGRATION_PRECISION = 17;
+const POSITIVE_INTEGER_PRECISION = 'a positive integer precision';
+/**
+ * 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"
+ * ```
+ */
+function sqrt(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+        }
+        retval = Expression_1.Expression.Inf();
+    }
+    else if (x.isOne()) {
+        retval = (0, shortcuts_1.one)();
+    }
+    else if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    // e.g. sqrt(sqrt(x))
+    else if (x.isFunction(constants_1.SQRT)) {
+        // Unwrap the square root
+        retval = (0, multiply_1.multiply)(sqrt(Expression_1.Expression.fromRational(x.getMultiplier())), (0, power_1.power)((0, power_1.sqrtToPow)(x.toUnitMultiplier()), (0, shortcuts_1.half)()));
+    }
+    else {
+        retval = (0, power_1.power)(x, (0, shortcuts_1.half)());
+    }
+    return retval;
+}
+/**
+ * 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)`.
+ */
+function nthroot(x, n) {
+    return (0, power_1.power)(Expression_1.Expression.create(x), (0, shortcuts_1.one)().div(Expression_1.Expression.create(n)));
+}
+/**
+ * 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)"
+ * ```
+ */
+function cbrt(x) {
+    x = Expression_1.Expression.create(x);
+    // Resolve simple values before constant evaluation.
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    if (x.isOne()) {
+        return (0, shortcuts_1.one)();
+    }
+    if (x.isZero()) {
+        return (0, shortcuts_1.zero)();
+    }
+    // If requested, evaluate constant arguments first. This avoids leaving things like
+    // cbrt(-1/2 + (sqrt(3)*sqrt(31))/18) unevaluated.
+    //
+    // For real constants, this uses the *real* cube root (so negative reals stay real).
+    // For complex constants, it returns the principal cube root.
+    if (Settings_1.Settings.EVALUATE && x.isConstant()) {
+        const xe = x.isNUM() || x.isComplex() ? x : x.evaluate();
+        if (xe.isNUM()) {
+            const d = xe.getMultiplier().toDecimal();
+            const oneThird = new decimal_js_1.default(1).div(3);
+            const r = d.isNeg() ? d.abs().pow(oneThird).neg() : d.pow(oneThird);
+            return new Expression_1.Expression(r);
+        }
+        if (xe.isComplex()) {
+            const re = xe.realPart();
+            const im = xe.imagPart();
+            const a = Number(re.getMultiplier().toDecimal());
+            const b = Number(im.getMultiplier().toDecimal());
+            const mag = Math.hypot(a, b);
+            const ang = Math.atan2(b, a);
+            const mag13 = Math.cbrt(mag);
+            const ang13 = ang / 3;
+            const rr = mag13 * Math.cos(ang13);
+            const ii = mag13 * Math.sin(ang13);
+            return Expression_1.Expression.create(rr).plus(Expression_1.Expression.create(ii).times(Expression_1.Expression.Img()));
+        }
+    }
+    // e.g. cbrt(cbrt(x))
+    if (x.isFunction(constants_1.CBRT)) {
+        return (0, multiply_1.multiply)(cbrt(Expression_1.Expression.fromRational(x.getMultiplier())), (0, power_1.power)(x.toUnitMultiplier(), (0, shortcuts_1.third)()));
+    }
+    // Keep cbrt as a function node (rather than x^(1/3)) to avoid principal-branch
+    // issues during symbolic manipulation.
+    return Expression_1.Expression.toFunction(constants_1.CBRT, [x]);
+}
+/**
+ * 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)"
+ * ```
+ */
+function parens(x) {
+    return Expression_1.Expression.toFunction(constants_1.WRAP, [x]);
+}
+/**
+ * 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)"
+ * ```
+ */
+function fibonacci(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    if (x.isNUM() && x.isInteger()) {
+        retval = Expression_1.Expression.Number((0, bigint_1.fibonacci)(x.getMultiplier().numerator));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_2.FIB, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function factorial(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+        }
+        return Expression_1.Expression.Inf();
+    }
+    if (x.isInteger()) {
+        retval = Expression_1.Expression.Number((0, bigint_1.factorial)(x.getMultiplier().numerator));
+    }
+    else if (Settings_1.Settings.EVALUATE) {
+        retval = gamma(x.plus((0, shortcuts_1.one)()));
+    }
+    else {
+        // Check if we can simplify half integer factorials
+        let m = x.getMultiplier();
+        if (x.isNUM() && m.denominator === 2n) {
+            const sign = m.sign();
+            m = m.abs();
+            const n = new Expression_1.Expression(m.numerator - 1n).div((0, shortcuts_1.two)());
+            const sqrtPi = sqrt(Expression_1.Expression.Pi());
+            if (sign === -1) {
+                retval = (0, shortcuts_1.four)()
+                    .neg()
+                    .pow(n)
+                    .times(factorial(n))
+                    .div(factorial(n.times((0, shortcuts_1.two)())))
+                    .times(sqrtPi);
+            }
+            else {
+                retval = factorial(n.times((0, shortcuts_1.two)()).plus((0, shortcuts_1.one)()))
+                    .div((0, shortcuts_1.four)().pow(n).times(factorial(n)).times((0, shortcuts_1.two)()))
+                    .times(sqrtPi);
+            }
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_2.FACTORIAL, [new Expression_1.Expression(x)]);
+        }
+    }
+    return retval;
+}
+/**
+ * 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"
+ * ```
+ */
+function doubleFactorial(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+        }
+        return Expression_1.Expression.Inf();
+    }
+    if (Settings_1.Settings.EVALUATE) {
+        if (x.isInteger()) {
+            const even = x.isEven();
+            const xn = Number(x.getMultiplier().toDecimal());
+            // If x = even then n = x/2 else n = (x-1)/2
+            const n = even ? xn / 2 : (xn + 1) / 2;
+            let r = (0, shortcuts_1.one)();
+            for (let i = 1; i <= n; i++) {
+                let q = (0, shortcuts_1.two)().times(i);
+                if (!even) {
+                    q = q.minus(1);
+                }
+                r = r.times(q);
+            }
+            retval = r;
+        }
+        else {
+            const pi = Expression_1.Expression.Pi(true);
+            const a = (0, shortcuts_1.two)().pow(x
+                .times((0, shortcuts_1.two)())
+                .plus((0, shortcuts_1.one)())
+                .minus((0, trig_1.cos)(pi.times(x)))
+                .div((0, shortcuts_1.four)()));
+            const b = pi.pow((0, trig_1.cos)(pi.times(x)).minus((0, shortcuts_1.one)()).div((0, shortcuts_1.four)()));
+            const c = gamma(x.div((0, shortcuts_1.two)()).plus(1));
+            retval = a.times(b).times(c);
+        }
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.DOUBLE_FACTORIAL, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function heaviside(x) {
+    let retval;
+    const useAssumptions = !x.isConstant() && !x.isComplex() && (0, assume_1.hasAssumptions)();
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? (0, shortcuts_1.zero)() : (0, shortcuts_1.one)();
+    }
+    else if (x.isNUM()) {
+        const s = x.sign();
+        if (s === 1) {
+            retval = (0, shortcuts_1.one)();
+        }
+        else if (s === -1) {
+            retval = (0, shortcuts_1.zero)();
+        }
+        else {
+            // x === 0: half-maximum convention
+            retval = (0, shortcuts_1.half)();
+        }
+    }
+    else if (useAssumptions && x.gt(0)) {
+        retval = (0, shortcuts_1.one)();
+    }
+    else if (useAssumptions && x.lt(0)) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (useAssumptions && x.gte(0) && x.lte(0)) {
+        retval = (0, shortcuts_1.half)();
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.HEAVISIDE, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function dirac(x) {
+    let retval;
+    const useAssumptions = !x.isConstant() && !x.isComplex() && (0, assume_1.hasAssumptions)();
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.isNUM()) {
+        if (x.isZero()) {
+            // Dirac delta at zero is technically infinite, but we return
+            // the symbolic form to avoid misleading numeric results.
+            retval = Expression_1.Expression.toFunction(constants_1.DIRAC, [new Expression_1.Expression(x)]);
+        }
+        else {
+            retval = (0, shortcuts_1.zero)();
+        }
+    }
+    else if (useAssumptions && (x.gt(0) || x.lt(0))) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.DIRAC, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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.
+ */
+function numeric(x, precision) {
+    x = Expression_1.Expression.create(x);
+    return (0, Settings_1.scopedBlock)('DEFER_SIMPLIFICATION', false, () => {
+        let digits = Rational_1.Rational.getPrecision();
+        if (precision !== undefined) {
+            const requested = Expression_1.Expression.create(precision).evaluate();
+            if (!requested.isNUM() || !requested.isInteger()) {
+                throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+                    expected: POSITIVE_INTEGER_PRECISION,
+                    received: requested.text(),
+                }));
+            }
+            const multiplier = requested.getMultiplier();
+            if (multiplier.numerator <= 0n ||
+                multiplier.numerator > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+                    expected: POSITIVE_INTEGER_PRECISION,
+                    received: requested.text(),
+                }));
+            }
+            digits = Number(multiplier.numerator);
+        }
+        const previousPrecision = Rational_1.Rational.getPrecision();
+        let retval;
+        try {
+            if (digits !== previousPrecision) {
+                Rational_1.Rational.set({ precision: digits });
+            }
+            const evaluated = x.isNUM() ? x : x.evaluate();
+            if (evaluated.variables().length > 0) {
+                retval = evaluated;
+            }
+            else if (evaluated.isNUM()) {
+                const multiplier = evaluated.getMultiplier();
+                const decimal = new decimal_js_1.default(multiplier.numerator.toString())
+                    .div(multiplier.denominator.toString())
+                    .toSignificantDigits(digits);
+                retval = Expression_1.Expression.Number(decimal);
+                retval.getMultiplier().asDecimal = true;
+                retval.precision = digits;
+            }
+            else if (evaluated.isComplex()) {
+                const real = numeric(evaluated.realPart(), digits);
+                const imaginary = numeric(evaluated.imagPart(), digits);
+                retval = real.plus(imaginary.times(Expression_1.Expression.Img()));
+                retval.precision = digits;
+            }
+            else {
+                retval = evaluated;
+            }
+        }
+        finally {
+            if (digits !== previousPrecision) {
+                Rational_1.Rational.set({ precision: previousPrecision });
+            }
+        }
+        return retval;
+    });
+}
+/**
+ * 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"
+ * ```
+ */
+function round(x, n) {
+    x = Expression_1.Expression.create(x);
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    n = n ? Expression_1.Expression.create(n) : (0, shortcuts_1.zero)();
+    let retval;
+    if (x.isNUM() && n.isInteger()) {
+        // Convert n & x to a decimals
+        const d = x.getMultiplier().toDecimal();
+        const s = n.getMultiplier().toDecimal();
+        const t = new decimal_js_1.default(10).pow(s);
+        retval = new Expression_1.Expression(decimal_js_1.default.round(d.times(t)).div(t));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.ROUND, [x, n]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function sign(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    if (x.isComplex()) {
+        retval = (0, complex_1.csgn)(x);
+    }
+    else if (x.isPosInf() || x.isNegInf()) {
+        retval = Expression_1.Expression.create(x.isNegInf() ? -1 : 1);
+    }
+    else if (x.isConstant()) {
+        retval = Expression_1.Expression.create((x.isNUM() ? x : x.evaluate()).getMultiplier().sign());
+    }
+    else if (!(0, assume_1.hasAssumptions)()) {
+        retval = Expression_1.Expression.toFunction(constants_1.SGN, [x]);
+    }
+    else if (x.gt(0)) {
+        retval = (0, shortcuts_1.one)();
+    }
+    else if (x.lt(0)) {
+        retval = (0, shortcuts_1.one)().neg();
+    }
+    else if (x.eq(0)) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.SGN, [x]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function floor(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    else if (x.isNUM()) {
+        // Convert n & x to a decimals
+        const d = x.getMultiplier().toDecimal();
+        retval = new Expression_1.Expression(d.floor());
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.FLOOR, [x]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function ceiling(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    else if (x.isNUM()) {
+        // Convert n & x to a decimals
+        const d = x.getMultiplier().toDecimal();
+        retval = new Expression_1.Expression(d.ceil());
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.CEIL, [x]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function abs(x) {
+    x = Expression_1.Expression.create(x);
+    if (x.isPosInf() || x.isNegInf()) {
+        return Expression_1.Expression.Inf();
+    }
+    let retval = x;
+    let wrap = true;
+    const useAssumptions = !x.isConstant() && (0, assume_1.hasAssumptions)();
+    if (!x.isConstant() && x.getPower().isEven()) {
+        retval = x;
+        // Remove the sign
+        if (retval.sign() === -1) {
+            retval = retval.neg();
+        }
+        wrap = false;
+    }
+    else if (x.isComplex()) {
+        retval = (0, geometry_1.hypot)(x.realPart(), x.imagPart());
+    }
+    else if (useAssumptions && x.gte(0)) {
+        retval = x;
+        wrap = false;
+    }
+    else if (useAssumptions && x.lte(0)) {
+        retval = x.neg();
+        wrap = false;
+    }
+    // Attempt to simplify expression in the for -x-y to |x+y|
+    else if (x.isSum()) {
+        // We'll loop through and sort out the constants and variables
+        // We can use this later to see if it has to be returned as the abs function
+        const constants = [];
+        const variables = [];
+        const elements = x.elementsArray();
+        let allNegative = true;
+        // Assume a positive sign. We'll flip this if we negate the expression.
+        // This is strictly for keeping track of what occurred with the sign.
+        // This avoids us having to go through each term again.
+        let sign = 1;
+        for (let i = 0; i < elements.length; i++) {
+            const e = elements[i];
+            if (e.isConstant()) {
+                constants.push(e);
+            }
+            else {
+                variables.push(e);
+            }
+            // Check if all are negative. It takes only
+            if (e.sign() !== -1) {
+                allNegative = false;
+            }
+            // If all negative
+            if (allNegative || (variables.length === 1 && variables[0].sign() === -1)) {
+                retval = x.neg().expand();
+                sign = -1; // Flip the sign.
+            }
+            const next = elements[i + 1];
+            const isGRP = next && variables.length === 1 && next.value === variables[0].value;
+            // Check if it needs to be wrapped. We would prefer to have expressions like |x^2+1| in the form x^2+1
+            if (variables.length === 1 && variables[0].getPower().isEven() && !isGRP) {
+                // Assume that we won't have wrap
+                wrap = false;
+                // Check that the rest of the signs are positive
+                for (let i = 0; i < constants.length; i++) {
+                    if (constants[i].sign() * sign === -1) {
+                        wrap = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    else if (x.sign() === -1) {
+        retval = x.neg();
+    }
+    // Just wrap it in a function if no simplification occurred
+    if (!retval) {
+        retval = x;
+    }
+    if (!retval.isConstant() && wrap) {
+        retval = Expression_1.Expression.toFunction(constants_1.ABS, [retval]);
+    }
+    return retval;
+}
+/**
+ * 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"
+ * ```
+ */
+function modInv(a, p) {
+    let t = (0, shortcuts_1.zero)();
+    let tp = (0, shortcuts_1.one)(); // newT
+    let r = p;
+    let rp = mod(a, p); // newR
+    while (!rp.isZero()) {
+        const q = floor(r.div(rp));
+        [t, tp] = [tp, t.minus(q.times(tp))];
+        [r, rp] = [rp, r.minus(q.times(rp))];
+    }
+    if (r.gt(1)) {
+        throw new errors_1.MathError((0, errors_1.message)('noInverse'));
+    }
+    return mod(t, p);
+}
+/**
+ * Computes the modulo (remainder) of `x` divided by `y`.
+ *
+ * @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(7), Expression.create(2)).text()    // "1"
+ * ```
+ */
+function mod(x, y) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf() || y.isPosInf() || y.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    if (x.isNUM() && y.isNUM()) {
+        retval = Expression_1.Expression.create(x.getMultiplier().mod(y.getMultiplier()));
+    }
+    else if (x.isPolynomialLike() &&
+        y.isPolynomialLike() &&
+        (0, utils_2.maxCommonVariableOccurrence)(x, y)) {
+        retval = (0, utils_2.polyMod)(x, y).getExpression();
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.MOD, [new Expression_1.Expression(x), new Expression_1.Expression(y)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function gamma(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+        }
+        return Expression_1.Expression.Inf();
+    }
+    if (x.isNUM()) {
+        const m = x.getMultiplier();
+        if (x.isInteger() && !x.isNegative()) {
+            // gamma(n) = (n-1)! for positive integers
+            if (x.isZero()) {
+                retval = Expression_1.Expression.toFunction(constants_1.GAMMA, [x]);
+            }
+            else {
+                retval = factorial(x.minus((0, shortcuts_1.one)()));
+            }
+        }
+        else if (m.denominator === 2n) {
+            const sqrtPi = sqrt(Expression_1.Expression.Pi());
+            const k = m.numerator;
+            // poles: 0, -1, -2, ...
+            if (k <= 0n && k % 2n === 0n) {
+                retval = Expression_1.Expression.toFunction(constants_1.GAMMA, [x]);
+            }
+            else if (k === 1n) {
+                // gamma(1/2) = sqrt(pi
+                retval = sqrtPi;
+            }
+            else if (k > 1n) {
+                // positive half-integers
+                let y = (0, shortcuts_1.half)();
+                let r = sqrtPi;
+                while (!y.eq(x)) {
+                    r = y.times(r);
+                    y = y.plus((0, shortcuts_1.one)());
+                }
+                retval = r;
+            }
+            else {
+                // negative half-integers via recurrence
+                let y = (0, shortcuts_1.half)();
+                let r = sqrtPi;
+                while (!y.eq(x)) {
+                    y = y.minus((0, shortcuts_1.one)());
+                    r = r.div(y);
+                }
+                retval = r;
+            }
+        }
+        else {
+            retval = Expression_1.Expression.Number((0, decimal_1.gamma)(m.toDecimal()));
+        }
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.GAMMA, [x]);
+    }
+    return retval;
+}
+/**
+ * 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"
+ * ```
+ */
+function erfc(x) {
+    return (0, subtract_1.subtract)((0, shortcuts_1.one)(), erf(x));
+}
+/**
+ * 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)"
+ * ```
+ */
+function erf(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? (0, shortcuts_1.one)().neg() : (0, shortcuts_1.one)();
+    }
+    else if (x.isNUM()) {
+        const m = x.getMultiplier();
+        // Gives junk values after erf > 6.7
+        if (m.gt('6.5')) {
+            retval = (0, shortcuts_1.one)();
+        }
+        else {
+            // Calculate it's numeric value
+            retval = Expression_1.Expression.Number((0, decimal_1.erf)(m.toDecimal()));
+        }
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.ERF, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function sinc(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.isZero()) {
+        retval = (0, shortcuts_1.one)();
+    }
+    else if ((0, trig_1.sin)(x).isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.sign() === -1) {
+        retval = sinc(x.neg());
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        retval = Expression_1.Expression.Number((0, decimal_1.sinc)(x.getMultiplier().toDecimal()));
+    }
+    else if (Settings_1.Settings.EVALUATE) {
+        retval = (0, trig_1.sin)(x).div(x);
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.SINC, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function Si(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+        if (x.isNegInf()) {
+            retval = retval.neg();
+        }
+    }
+    else if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.sign() === -1) {
+        retval = Si(x.neg()).neg();
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        retval = Expression_1.Expression.Number((0, decimal_1.Si)(x.getMultiplier().toDecimal()));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.SI, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function Shi(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    else if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.sign() === -1) {
+        retval = Shi(x.neg()).neg();
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        retval = Expression_1.Expression.Number((0, decimal_1.Shi)(x.getMultiplier().toDecimal()));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.SHI, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function Ci(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.isZero()) {
+        retval = Expression_1.Expression.NegInf();
+    }
+    else if (x.sign() === -1) {
+        retval = Ci(x.neg());
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        retval = Expression_1.Expression.Number((0, decimal_1.Ci)(x.getMultiplier().toDecimal()));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.CI, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function Chi(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = Expression_1.Expression.Inf();
+    }
+    else if (x.isZero()) {
+        retval = Expression_1.Expression.NegInf();
+    }
+    else if (x.sign() === -1) {
+        retval = Chi(x.neg());
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        retval = Expression_1.Expression.Number((0, decimal_1.Chi)(x.getMultiplier().toDecimal()));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.CHI, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function Ei(x) {
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? (0, shortcuts_1.zero)() : Expression_1.Expression.Inf();
+    }
+    else if (x.isZero()) {
+        retval = Expression_1.Expression.NegInf();
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        retval = Expression_1.Expression.Number((0, decimal_1.Ei)(x.getMultiplier().toDecimal()));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.EI, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function Li(x) {
+    let retval;
+    if (x.isPosInf()) {
+        retval = Expression_1.Expression.Inf();
+    }
+    else if (x.isOne()) {
+        retval = Expression_1.Expression.NegInf();
+    }
+    else if (x.isNUM() && Settings_1.Settings.EVALUATE) {
+        const m = x.getMultiplier();
+        if (m.isNegative()) {
+            retval = Expression_1.Expression.toFunction(constants_1.LI, [new Expression_1.Expression(x)]);
+        }
+        else {
+            retval = Expression_1.Expression.Number((0, decimal_1.Li)(m.toDecimal()));
+        }
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.LI, [new Expression_1.Expression(x)]);
+    }
+    return retval;
+}
+/**
+ * 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"
+ * ```
+ */
+function log(x, base, expandPrimes = false) {
+    x = Expression_1.Expression.create(x);
+    const baseExpr = base === undefined ? undefined : Expression_1.Expression.create(base);
+    let exactBaseLog;
+    let retval;
+    if (baseExpr &&
+        x.isInteger() &&
+        baseExpr.isInteger() &&
+        x.gt(0) &&
+        baseExpr.gt(1)) {
+        const target = x.getMultiplier().numerator;
+        const radix = baseExpr.getMultiplier().numerator;
+        let value = 1n;
+        let exponent = 0n;
+        while (value < target) {
+            value *= radix;
+            exponent++;
+        }
+        if (value === target) {
+            exactBaseLog = Expression_1.Expression.Number(exponent);
+        }
+    }
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+        }
+        retval = Expression_1.Expression.Inf();
+    }
+    else if (x.isOne()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (exactBaseLog) {
+        retval = exactBaseLog;
+    }
+    else if (x.isE() && x.getMultiplier().isOne()) {
+        const exponent = x.getPower();
+        // Principal Log(e^z) only simplifies directly when z has no complex component. A complex
+        // exponent can wrap by a multiple of 2*pi*i when mapped back to the
+        // principal branch, so preserve that form instead of returning z.
+        if (!exponent.isComplex()) {
+            retval = (0, shortcuts_1.one)().times(exponent);
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [new Expression_1.Expression(x)]);
+        }
+    }
+    else if (!x.isComplex() && x.lt(0)) {
+        retval = Expression_1.Expression.Pi().times(Expression_1.Expression.Img()).plus(log(x.abs()));
+    }
+    // Handle complex numbers regardless of EVALUATE setting
+    else if (x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        // Compute |z|
+        const mag = sqrt(re.sq().plus(im.sq()));
+        // log(z) = log(|z|) + i*arg(z)
+        retval = log(mag).plus((0, trig_1.atan2)(im, re).i());
+    }
+    // Don't collapse
+    else if (Settings_1.Settings.EVALUATE) {
+        if (x.isNUM()) {
+            // If a numeric base is provided, compute log_b(x) directly.
+            if (baseExpr && baseExpr.isNUM()) {
+                const lnX = x.getMultiplier().toDecimal().ln();
+                const lnB = baseExpr.getMultiplier().toDecimal().ln();
+                retval = Expression_1.Expression.Number(lnX.div(lnB));
+            }
+            else {
+                retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().ln());
+            }
+        }
+    }
+    // Symbolic cases
+    else {
+        // Rational number: log(a/b) → log(a) - log(b)
+        // Handle NUM first to avoid infinite recursion with multiplier factoring
+        if (x.isNUM()) {
+            const rat = x.getMultiplier();
+            const num = rat.numerator < 0n ? -rat.numerator : rat.numerator;
+            const den = rat.denominator < 0n ? -rat.denominator : rat.denominator;
+            if (den !== 1n) {
+                // log(a/b) = log(a) - log(b)
+                retval = log(Expression_1.Expression.Number(num)).minus(log(Expression_1.Expression.Number(den)));
+            }
+            else if (expandPrimes) {
+                // Try to decompose into prime factors: log(8) → 3*log(2)
+                const factors = (0, primeFactor_1.primeFactorCounts)(num);
+                const primes = Object.keys(factors);
+                if (primes.length > 0 && (primes.length > 1 || factors[primes[0]] > 1n)) {
+                    retval = (0, shortcuts_1.zero)();
+                    for (const prime in factors) {
+                        const count = factors[prime];
+                        const logPrime = Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [
+                            Expression_1.Expression.Number(prime),
+                        ]);
+                        retval = retval.plus(logPrime.times(Expression_1.Expression.Number(count)));
+                    }
+                }
+                // else: it's prime, fall through to default
+            }
+        }
+        // Non-NUM symbolic cases: only apply real-domain logarithm identities
+        // when the relevant factors are provably positive and the powers are real.
+        else {
+            const m = x.getMultiplier();
+            const mFree = x.toUnitMultiplier();
+            let logExpr;
+            let mFreeIsPositive = false;
+            // Product: log(a*b*c) → log(a) + log(b) + log(c), but only
+            // when every factor is known to stay on the positive real axis.
+            if (mFree.isProduct() && mFree.isLinear()) {
+                const elements = mFree.elementsArray();
+                let canSplitProduct = true;
+                for (const element of elements) {
+                    let elementIsPositive = false;
+                    if (element.isNUM()) {
+                        elementIsPositive = element.gt(0);
+                    }
+                    else {
+                        const elementPower = element.getPower();
+                        const elementBase = element.isEXP()
+                            ? element.getBase()
+                            : (0, utils_3.stripPower)(element);
+                        elementIsPositive =
+                            !elementPower.isComplex() &&
+                                !elementBase.isComplex() &&
+                                elementBase.gt(0);
+                    }
+                    if (!elementIsPositive) {
+                        canSplitProduct = false;
+                        break;
+                    }
+                }
+                if (canSplitProduct) {
+                    let sum = (0, shortcuts_1.zero)();
+                    for (const element of elements) {
+                        sum = sum.plus(log(element));
+                    }
+                    logExpr = sum;
+                    mFreeIsPositive = true;
+                }
+            }
+            else {
+                const pow = mFree.getPower();
+                const baseExpr = mFree.isEXP() ? mFree.getBase() : (0, utils_3.stripPower)(mFree);
+                if (pow.isOne()) {
+                    logExpr = Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [mFree]);
+                    mFreeIsPositive = !mFree.isComplex() && mFree.gt(0);
+                }
+                // log(a^p) → p*log(a) is branch-safe for a positive real base
+                // and a real exponent. Unknown-sign bases remain attached.
+                else if (!pow.isComplex() && !baseExpr.isComplex() && baseExpr.gt(0)) {
+                    logExpr = log(baseExpr).times(pow);
+                    mFreeIsPositive = true;
+                }
+            }
+            // log(m*expr) = log(m) + log(expr) is only valid here when
+            // both pieces are known positive. Otherwise preserve the original log.
+            if (logExpr !== undefined && !m.isOne()) {
+                if (m.sign() > 0 && mFreeIsPositive) {
+                    retval = logExpr.plus(log(Expression_1.Expression.fromRational(m)));
+                }
+            }
+            else {
+                retval = logExpr;
+            }
+        }
+    }
+    retval = retval || Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [new Expression_1.Expression(x)]);
+    // Handle base conversion: log_b(x) = log(x) / log(b)
+    if (baseExpr && retval && !exactBaseLog) {
+        retval = retval.div(log(baseExpr));
+    }
+    return retval;
+}
+function aggregator(args, condition, assumedCondition) {
+    let retval = undefined;
+    const inputs = args.map(e => Expression_1.Expression.create(e));
+    let canCompare = true;
+    const expressions = inputs.map(e => {
+        const value = (0, utils_1.getNumericOrAssumedValue)(e);
+        if (value === undefined) {
+            canCompare = false;
+        }
+        return value;
+    });
+    if (canCompare === true &&
+        expressions.length > 0 &&
+        expressions.every((e) => e !== undefined)) {
+        let m = expressions[0];
+        for (let i = 1; i < expressions.length; i++) {
+            const e = expressions[i];
+            if (condition(e, m)) {
+                m = e;
+            }
+        }
+        retval = m;
+    }
+    else {
+        const useAssumptions = (0, assume_1.hasAssumptions)() &&
+            inputs.every(e => !e.isComplex()) &&
+            inputs.some(e => e.variables().some(v => (0, assume_1.getAssumptionFor)(v) !== undefined));
+        if (useAssumptions) {
+            for (const candidate of inputs) {
+                if (inputs.every(e => assumedCondition(candidate, e))) {
+                    retval = candidate;
+                    break;
+                }
+            }
+        }
+        // Equal values need no ordering when numeric or assumed comparison is unavailable.
+        if (retval === undefined && inputs.length > 0 && inputs.every(e => e.eq(inputs[0]))) {
+            retval = inputs[0];
+        }
+    }
+    return retval;
+}
+/**
+ * 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)"
+ * ```
+ */
+function max(...args) {
+    const maxValue = aggregator(args, (a, b) => a.gt(b), (a, b) => a.gte(b));
+    return maxValue ?? Expression_1.Expression.toFunction(constants_1.MAX, args);
+}
+/**
+ * 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)"
+ * ```
+ */
+function min(...args) {
+    const minValue = aggregator(args, (a, b) => a.lt(b), (a, b) => a.lte(b));
+    return minValue ?? Expression_1.Expression.toFunction(constants_1.MIN, args);
+}
+/**
+ * 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)"
+ * ```
+ */
+function exp(x) {
+    let retval;
+    let z;
+    let re;
+    let im;
+    let c;
+    let s;
+    let ea;
+    x = Expression_1.Expression.create(x);
+    // Easy simplifications
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? (0, shortcuts_1.zero)() : Expression_1.Expression.Inf();
+    }
+    else if (x.isZero()) {
+        retval = (0, shortcuts_1.one)();
+    }
+    else if (Settings_1.Settings.EVALUATE) {
+        // Handle complex
+        if (x.isComplex()) {
+            // Only evaluate if we can guarantee a numeric value in C.
+            // We do this by evaluating x first, then requiring both real and imaginary
+            // parts to be numeric.
+            z = x.evaluate();
+            re = z.realPart();
+            im = z.imagPart();
+            if (re.isNUM() && im.isNUM()) {
+                // exp(a+bi) = exp(a) * (cos(b) + i*sin(b))
+                ea = Expression_1.Expression.Number(re.getMultiplier().toDecimal().exp());
+                c = (0, trig_1.cos)(im);
+                s = (0, trig_1.sin)(im);
+                retval = ea.times(c.plus(s.i()));
+            }
+        }
+        else if (x.isNUM()) {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().exp());
+        }
+    }
+    return retval ?? Expression_1.Expression.create(`e^(${x})`);
+}
+/**
+ * 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()
+ * ```
+ */
+function matrix(...args) {
+    return new Matrix_1.Matrix(...args);
+}
+/**
+ * Attempts to extract an integer bigint from an Expression.
+ * Returns null if the expression is not an exact integer.
+ */
+function toIntegerBigint(x) {
+    const isInt = x.isInteger();
+    if (!isInt) {
+        return null;
+    }
+    const m = x.getMultiplier();
+    const den = m.denominator;
+    if (den !== 1n) {
+        return null;
+    }
+    const num = m.numerator;
+    return num;
+}
+/**
+ * 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"
+ * ```
+ */
+function sum(expr, index, lower, upper) {
+    // Validate index variable
+    if (!index.isPlainVariable()) {
+        return Expression_1.Expression.toFunction(constants_1.SUM_FUNCTION, [expr, index, lower, upper]);
+    }
+    expr = Expression_1.Expression.create(expr);
+    index = Expression_1.Expression.create(index);
+    lower = Expression_1.Expression.create(lower);
+    upper = Expression_1.Expression.create(upper);
+    const indexName = index.text();
+    // Attempt integer bounds extraction
+    const lo = toIntegerBigint(lower);
+    const hi = toIntegerBigint(upper);
+    if (lo === null || hi === null) {
+        // Non-integer bounds → symbolic
+        return Expression_1.Expression.toFunction(constants_1.SUM_FUNCTION, [expr, index, lower, upper]);
+    }
+    // Empty range → 0
+    if (lo > hi) {
+        return (0, shortcuts_1.zero)();
+    }
+    const terms = hi - lo + 1n;
+    // Prevent runaway evaluation
+    if (terms > Settings_1.Settings.MAX_PRODUCT_AND_SUMMATION_ITERATION) {
+        return Expression_1.Expression.toFunction(constants_1.SUM_FUNCTION, [expr, index, lower, upper]);
+    }
+    // If expression does not depend on index, simplify:
+    // sum(c, k, a, b) = c * (b - a + 1)
+    const dependsOnIndex = expr.hasVariable(indexName);
+    if (!dependsOnIndex) {
+        const countExpr = Expression_1.Expression.create(terms);
+        return expr.times(countExpr);
+    }
+    // Numeric accumulation
+    let acc = (0, shortcuts_1.zero)();
+    let i = lo;
+    while (i <= hi) {
+        const values = {};
+        values[indexName] = i;
+        const term = expr.evaluate(values);
+        acc = acc.plus(term);
+        i = i + 1n;
+    }
+    return acc;
+}
+/**
+ * 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"
+ * ```
+ */
+function product(expr, index, lower, upper) {
+    if (!index.isPlainVariable()) {
+        return Expression_1.Expression.toFunction(constants_1.PRODUCT_FUNCTION, [expr, index, lower, upper]);
+    }
+    expr = Expression_1.Expression.create(expr);
+    index = Expression_1.Expression.create(index);
+    lower = Expression_1.Expression.create(lower);
+    upper = Expression_1.Expression.create(upper);
+    const indexName = index.text();
+    const lo = toIntegerBigint(lower);
+    const hi = toIntegerBigint(upper);
+    if (lo === null || hi === null) {
+        return Expression_1.Expression.toFunction(constants_1.PRODUCT_FUNCTION, [expr, index, lower, upper]);
+    }
+    // Empty range → 1
+    if (lo > hi) {
+        return (0, shortcuts_1.one)();
+    }
+    const terms = hi - lo + 1n;
+    if (terms > Settings_1.Settings.MAX_PRODUCT_AND_SUMMATION_ITERATION) {
+        return Expression_1.Expression.toFunction(constants_1.PRODUCT_FUNCTION, [expr, index, lower, upper]);
+    }
+    // product(c, k, a, b) = c^(b-a+1)
+    const dependsOnIndex = expr.hasVariable(indexName);
+    if (!dependsOnIndex) {
+        const countExpr = Expression_1.Expression.create(terms);
+        return (0, power_1.power)(expr, countExpr);
+    }
+    let acc = (0, shortcuts_1.one)();
+    let i = lo;
+    while (i <= hi) {
+        const values = {};
+        values[indexName] = i;
+        const term = expr.evaluate(values);
+        acc = acc.times(term);
+        i = i + 1n;
+    }
+    return acc;
+}
+/**
+ * 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.
+ *
+ * @param f The function being integrated
+ * @param dx The variable of integration
+ * @param from The lower limit of the integral
+ * @param to The upper limit of the integral
+ * @returns The numeric value if possible else a symbolic function
+ *
+ * @example
+ * ```ts
+ * defint('cos(x)-x^2+6', 'x', 1, 6); // -42.787553149673464
+ * ```
+ */
+function defint(f, dx, from, to) {
+    let retval;
+    f = Expression_1.Expression.create(f);
+    dx = Expression_1.Expression.create(dx);
+    from = Expression_1.Expression.create(from);
+    to = Expression_1.Expression.create(to);
+    const inputVars = f.variables();
+    // Get the variable
+    const v = (0, utils_1.assertPlainVariableAndGetString)(dx);
+    // Pull factors that are constant with respect to the integration variable across the bounds.
+    if (!inputVars.includes(v)) {
+        retval = f.times(to.minus(from));
+    }
+    else {
+        let numericFrom = from;
+        let numericTo = to;
+        if (!numericFrom.isNUM() && numericFrom.isConstant()) {
+            numericFrom = numericFrom.evaluate();
+        }
+        if (!numericTo.isNUM() && numericTo.isConstant()) {
+            numericTo = numericTo.evaluate();
+        }
+        if (inputVars.length === 1 &&
+            inputVars[0] === v &&
+            numericFrom.isNUM() &&
+            numericTo.isNUM()) {
+            const a = Number(numericFrom.getMultiplier().toDecimal());
+            const b = Number(numericTo.getMultiplier().toDecimal());
+            retval = Expression_1.Expression.create((0, defintNative_1.definiteIntegrateNative)(f.buildFunction(), a, b));
+            retval.precision = NATIVE_DEFINITE_INTEGRATION_PRECISION; // Mark it as limited precision
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_1.DEFINT, [f, dx, from, to]);
+        }
+    }
+    return retval;
+}
+/**
+ * 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
+ * ```
+ */
+function contains(x, value) {
+    value = Expression_1.Expression.create(value);
+    let retval;
+    if (x.dataType === constants_1.VECTOR) {
+        retval = Expression_1.Expression.create(Number(x.indexOf(value) !== -1));
+    }
+    else if (x.dataType === constants_1.SET || x.dataType === constants_1.SOLUTIONS_SET) {
+        retval = Expression_1.Expression.create(Number(x.has(value)));
+    }
+    else if (x.dataType === constants_1.DICTIONARY) {
+        retval = Expression_1.Expression.create(Number(x.has(value.text())));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.CONTAINS, [x, value]);
+    }
+    return retval;
+}