nerdamer 2.0.0-rc.1 → 2.0.0

package/output/math/math.js

@@ -4,13 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sqrt = sqrt;
+exports.scientific = scientific;
 exports.nthroot = nthroot;
+exports.radians = radians;
+exports.degrees = degrees;
+exports.log10 = log10;
 exports.cbrt = cbrt;
 exports.parens = parens;
 exports.fibonacci = fibonacci;
 exports.factorial = factorial;
 exports.doubleFactorial = doubleFactorial;
 exports.heaviside = heaviside;
+exports.step = step;
+exports.rect = rect;
+exports.tri = tri;
 exports.dirac = dirac;
 exports.numeric = numeric;
 exports.round = round;
@@ -20,6 +27,8 @@ exports.ceiling = ceiling;
 exports.abs = abs;
 exports.modInv = modInv;
 exports.mod = mod;
+exports.gammaIncomplete = gammaIncomplete;
+exports.gammaIncompleteLower = gammaIncompleteLower;
 exports.gamma = gamma;
 exports.erfc = erfc;
 exports.erf = erf;
@@ -37,7 +46,6 @@ 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");
@@ -58,12 +66,11 @@ 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';
+const DEFAULT_SCIENTIFIC_SIGNIFICANT_DIGITS = 10;
 /**
  * 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)`).
@@ -109,6 +116,24 @@ function sqrt(x) {
     }
     return retval;
 }
+/**
+ * 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.
+ */
+function scientific(x, significantDigits = DEFAULT_SCIENTIFIC_SIGNIFICANT_DIGITS) {
+    const digits = Expression_1.Expression.create(significantDigits);
+    const requestedDigits = digits.isNUM() && digits.isInteger()
+        ? Number(digits.getMultiplier().numerator)
+        : Number.NaN;
+    const precision = (0, Rational_1.validateScientificSignificantDigits)(requestedDigits, digits.text());
+    const retval = Expression_1.Expression.create(x, undefined, true);
+    retval.scientific = precision;
+    return retval;
+}
 /**
  * Computes the nth root of an expression as its principal power.
  *
@@ -119,6 +144,18 @@ function sqrt(x) {
 function nthroot(x, n) {
     return (0, power_1.power)(Expression_1.Expression.create(x), (0, shortcuts_1.one)().div(Expression_1.Expression.create(n)));
 }
+/** Converts degrees to radians exactly. */
+function radians(x) {
+    return Expression_1.Expression.create(x).times(Expression_1.Expression.Pi()).div(Expression_1.Expression.create(180));
+}
+/** Converts radians to degrees exactly. */
+function degrees(x) {
+    return Expression_1.Expression.create(x).times(Expression_1.Expression.create(180)).div(Expression_1.Expression.Pi());
+}
+/** Returns the base-10 logarithm using the ordinary logarithm implementation. */
+function log10(x) {
+    return log(x, 10);
+}
 /**
  * Computes the cube root of an expression.
  *
@@ -162,7 +199,7 @@ function cbrt(x) {
             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);
+            return Expression_1.Expression.create(r);
         }
         if (xe.isComplex()) {
             const re = xe.realPart();
@@ -199,7 +236,7 @@ function cbrt(x) {
  * ```
  */
 function parens(x) {
-    return Expression_1.Expression.toFunction(constants_1.WRAP, [x]);
+    return Expression_1.Expression.toFunction(constants_1.WRAP, [Expression_1.Expression.create(x)]);
 }
 /**
  * Computes the Fibonacci number for an integer index.
@@ -224,7 +261,7 @@ function fibonacci(x) {
         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)]);
+        retval = Expression_1.Expression.toFunction(constants_2.FIB, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -268,7 +305,7 @@ function factorial(x) {
         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 n = Expression_1.Expression.create(m.numerator - 1n).div((0, shortcuts_1.two)());
             const sqrtPi = sqrt(Expression_1.Expression.Pi());
             if (sign === -1) {
                 retval = (0, shortcuts_1.four)()
@@ -285,7 +322,7 @@ function factorial(x) {
             }
         }
         else {
-            retval = Expression_1.Expression.toFunction(constants_2.FACTORIAL, [new Expression_1.Expression(x)]);
+            retval = Expression_1.Expression.toFunction(constants_2.FACTORIAL, [Expression_1.Expression.create(x)]);
         }
     }
     return retval;
@@ -329,7 +366,7 @@ function doubleFactorial(x) {
             for (let i = 1; i <= n; i++) {
                 let q = (0, shortcuts_1.two)().times(i);
                 if (!even) {
-                    q = q.minus(1);
+                    q = q.minus((0, shortcuts_1.one)());
                 }
                 r = r.times(q);
             }
@@ -343,12 +380,12 @@ function doubleFactorial(x) {
                 .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));
+            const c = gamma(x.div((0, shortcuts_1.two)()).plus((0, shortcuts_1.one)()));
             retval = a.times(b).times(c);
         }
     }
     else {
-        retval = Expression_1.Expression.toFunction(constants_1.DOUBLE_FACTORIAL, [new Expression_1.Expression(x)]);
+        retval = Expression_1.Expression.toFunction(constants_1.DOUBLE_FACTORIAL, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -392,20 +429,71 @@ function heaviside(x) {
             retval = (0, shortcuts_1.half)();
         }
     }
-    else if (useAssumptions && x.gt(0)) {
+    else if (useAssumptions && x.gt((0, shortcuts_1.zero)())) {
         retval = (0, shortcuts_1.one)();
     }
-    else if (useAssumptions && x.lt(0)) {
+    else if (useAssumptions && x.lt((0, shortcuts_1.zero)())) {
         retval = (0, shortcuts_1.zero)();
     }
-    else if (useAssumptions && x.gte(0) && x.lte(0)) {
+    else if (useAssumptions && x.gte((0, shortcuts_1.zero)()) && x.lte((0, shortcuts_1.zero)())) {
         retval = (0, shortcuts_1.half)();
     }
     else {
-        retval = Expression_1.Expression.toFunction(constants_1.HEAVISIDE, [new Expression_1.Expression(x)]);
+        retval = Expression_1.Expression.toFunction(constants_1.HEAVISIDE, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
+/**
+ * Legacy unit-step function. Unlike {@link heaviside}, the value at zero is 1.
+ */
+function step(x) {
+    x = Expression_1.Expression.create(x);
+    const useAssumptions = !x.isConstant() && !x.isComplex() && (0, assume_1.hasAssumptions)();
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? (0, shortcuts_1.zero)() : (0, shortcuts_1.one)();
+    }
+    if (x.isNUM()) {
+        return x.sign() < 0 ? (0, shortcuts_1.zero)() : (0, shortcuts_1.one)();
+    }
+    if (useAssumptions && x.lt((0, shortcuts_1.zero)())) {
+        return (0, shortcuts_1.zero)();
+    }
+    if (useAssumptions && x.gte((0, shortcuts_1.zero)())) {
+        return (0, shortcuts_1.one)();
+    }
+    return Expression_1.Expression.toFunction('step', [x]);
+}
+/**
+ * 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.
+ */
+function rect(x) {
+    const input = Expression_1.Expression.create(x);
+    const magnitude = abs(input);
+    if (magnitude.lt((0, shortcuts_1.half)())) {
+        return (0, shortcuts_1.one)();
+    }
+    if (magnitude.eq((0, shortcuts_1.half)())) {
+        return (0, shortcuts_1.half)();
+    }
+    if (magnitude.gt((0, shortcuts_1.half)())) {
+        return (0, shortcuts_1.zero)();
+    }
+    return Expression_1.Expression.toFunction('rect', [input]);
+}
+/** Triangular pulse: max(1 - |x|, 0) when the comparison can be resolved. */
+function tri(x) {
+    const input = Expression_1.Expression.create(x);
+    const magnitude = abs(input);
+    if (magnitude.lt((0, shortcuts_1.one)())) {
+        return (0, shortcuts_1.one)().minus(magnitude);
+    }
+    if (magnitude.gte((0, shortcuts_1.one)())) {
+        return (0, shortcuts_1.zero)();
+    }
+    return Expression_1.Expression.toFunction('tri', [input]);
+}
 /**
  * Computes the Dirac delta function (distribution).
  *
@@ -434,17 +522,17 @@ function dirac(x) {
         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)]);
+            retval = Expression_1.Expression.toFunction(constants_1.DIRAC, [Expression_1.Expression.create(x)]);
         }
         else {
             retval = (0, shortcuts_1.zero)();
         }
     }
-    else if (useAssumptions && (x.gt(0) || x.lt(0))) {
+    else if (useAssumptions && (x.gt((0, shortcuts_1.zero)()) || x.lt((0, shortcuts_1.zero)()))) {
         retval = (0, shortcuts_1.zero)();
     }
     else {
-        retval = Expression_1.Expression.toFunction(constants_1.DIRAC, [new Expression_1.Expression(x)]);
+        retval = Expression_1.Expression.toFunction(constants_1.DIRAC, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -545,7 +633,7 @@ function round(x, n) {
         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));
+        retval = Expression_1.Expression.create(decimal_js_1.default.round(d.times(t)).div(t));
     }
     else {
         retval = Expression_1.Expression.toFunction(constants_1.ROUND, [x, n]);
@@ -584,13 +672,13 @@ function sign(x) {
     else if (!(0, assume_1.hasAssumptions)()) {
         retval = Expression_1.Expression.toFunction(constants_1.SGN, [x]);
     }
-    else if (x.gt(0)) {
+    else if (x.gt((0, shortcuts_1.zero)())) {
         retval = (0, shortcuts_1.one)();
     }
-    else if (x.lt(0)) {
+    else if (x.lt((0, shortcuts_1.zero)())) {
         retval = (0, shortcuts_1.one)().neg();
     }
-    else if (x.eq(0)) {
+    else if (x.eq((0, shortcuts_1.zero)())) {
         retval = (0, shortcuts_1.zero)();
     }
     else {
@@ -621,7 +709,7 @@ function floor(x) {
     else if (x.isNUM()) {
         // Convert n & x to a decimals
         const d = x.getMultiplier().toDecimal();
-        retval = new Expression_1.Expression(d.floor());
+        retval = Expression_1.Expression.create(d.floor());
     }
     else {
         retval = Expression_1.Expression.toFunction(constants_1.FLOOR, [x]);
@@ -651,7 +739,7 @@ function ceiling(x) {
     else if (x.isNUM()) {
         // Convert n & x to a decimals
         const d = x.getMultiplier().toDecimal();
-        retval = new Expression_1.Expression(d.ceil());
+        retval = Expression_1.Expression.create(d.ceil());
     }
     else {
         retval = Expression_1.Expression.toFunction(constants_1.CEIL, [x]);
@@ -696,11 +784,11 @@ function abs(x) {
     else if (x.isComplex()) {
         retval = (0, geometry_1.hypot)(x.realPart(), x.imagPart());
     }
-    else if (useAssumptions && x.gte(0)) {
+    else if (useAssumptions && x.gte((0, shortcuts_1.zero)())) {
         retval = x;
         wrap = false;
     }
-    else if (useAssumptions && x.lte(0)) {
+    else if (useAssumptions && x.lte((0, shortcuts_1.zero)())) {
         retval = x.neg();
         wrap = false;
     }
@@ -786,14 +874,42 @@ function modInv(a, p) {
         [t, tp] = [tp, t.minus(q.times(tp))];
         [r, rp] = [rp, r.minus(q.times(rp))];
     }
-    if (r.gt(1)) {
+    if (r.gt((0, shortcuts_1.one)())) {
         throw new errors_1.MathError((0, errors_1.message)('noInverse'));
     }
     return mod(t, p);
 }
+/**
+ * Rounds an exact rational quotient to the nearest integer, choosing the even
+ * integer when the value lies exactly halfway between two integers.
+ */
+function roundRatioToNearestEven(numerator, denominator) {
+    const quotient = numerator / denominator;
+    const remainder = numerator % denominator;
+    const twiceRemainder = (0, bigint_1.abs)(remainder) * 2n;
+    const direction = BigInt((0, bigint_1.sign)(numerator));
+    if (twiceRemainder < denominator) {
+        return quotient;
+    }
+    if (twiceRemainder > denominator) {
+        return quotient + direction;
+    }
+    return (0, bigint_1.isEven)(quotient) ? quotient : quotient + direction;
+}
 /**
  * Computes the modulo (remainder) of `x` divided by `y`.
  *
+ * Exact Gaussian integers use the same quotient rule as Wolfram Language:
+ * divide, round the real and imaginary quotient components independently to
+ * the nearest integers with midpoint ties going to even, then subtract
+ * `y * quotient` from `x`.
+ *
+ * Complex values outside the Gaussian integers remain symbolic.
+ *
+ * @see https://reference.wolfram.com/language/ref/Mod.html
+ * @see https://reference.wolfram.com/language/ref/Quotient.html
+ * @see https://reference.wolfram.com/language/ref/Round.html
+ *
  * @param x - The dividend.
  * @param y - The divisor.
  * @returns The remainder of `x / y`.
@@ -801,8 +917,8 @@ function modInv(a, p) {
  *
  * @example
  * ```ts
- * mod(Expression.create(10), Expression.create(3)).text()   // "1"
- * mod(Expression.create(7), Expression.create(2)).text()    // "1"
+ * mod(Expression.create(10), Expression.create(3)).text()          // "1"
+ * mod(Expression.create('5+3*i'), Expression.create('2+i')).text() // "-1"
  * ```
  */
 function mod(x, y) {
@@ -813,16 +929,96 @@ function mod(x, y) {
     if (x.isNUM() && y.isNUM()) {
         retval = Expression_1.Expression.create(x.getMultiplier().mod(y.getMultiplier()));
     }
+    else if (x.isComplex() || y.isComplex()) {
+        const xReal = x.realPart();
+        const xImag = x.imagPart();
+        const yReal = y.realPart();
+        const yImag = y.imagPart();
+        if (xReal.isNUM() &&
+            xReal.isInteger() &&
+            xImag.isNUM() &&
+            xImag.isInteger() &&
+            yReal.isNUM() &&
+            yReal.isInteger() &&
+            yImag.isNUM() &&
+            yImag.isInteger()) {
+            const a = xReal.getMultiplier().numerator;
+            const b = xImag.getMultiplier().numerator;
+            const c = yReal.getMultiplier().numerator;
+            const d = yImag.getMultiplier().numerator;
+            const denominator = c * c + d * d;
+            if (denominator === 0n) {
+                retval = Expression_1.Expression.toFunction(constants_1.MOD, [Expression_1.Expression.create(x), Expression_1.Expression.create(y)]);
+            }
+            else {
+                const quotientReal = roundRatioToNearestEven(a * c + b * d, denominator);
+                const quotientImag = roundRatioToNearestEven(b * c - a * d, denominator);
+                const remainderReal = a - c * quotientReal + d * quotientImag;
+                const remainderImag = b - c * quotientImag - d * quotientReal;
+                retval = Expression_1.Expression.Number(remainderReal).plus(Expression_1.Expression.Number(remainderImag).i());
+            }
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_1.MOD, [Expression_1.Expression.create(x), Expression_1.Expression.create(y)]);
+        }
+    }
     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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.MOD, [Expression_1.Expression.create(x), Expression_1.Expression.create(y)]);
     }
     return retval;
 }
+/**
+ * Upper incomplete gamma Γ(a, z).
+ *
+ * Positive integer first arguments are expanded exactly using the finite-sum formula.
+ * Other inputs remain symbolic.
+ *
+ * @see https://dlmf.nist.gov/8.4.E8
+ */
+function gammaIncomplete(a, z) {
+    const order = Expression_1.Expression.create(a);
+    const argument = Expression_1.Expression.create(z);
+    if (!order.isNUM() || !order.isInteger() || order.lte((0, shortcuts_1.zero)())) {
+        return Expression_1.Expression.toFunction('gamma_incomplete', [order, argument]);
+    }
+    const n = order.getMultiplier().numerator;
+    if (n > BigInt(Settings_1.Settings.MAX_PRODUCT_AND_SUMMATION_ITERATION)) {
+        return Expression_1.Expression.toFunction('gamma_incomplete', [order, argument]);
+    }
+    let term = (0, shortcuts_1.one)();
+    let series = (0, shortcuts_1.one)();
+    let k = 1n;
+    while (k < n) {
+        term = term.times(argument).div(Expression_1.Expression.Number(k));
+        series = series.plus(term);
+        k++;
+    }
+    return factorial(Expression_1.Expression.Number(n - 1n)).times(exp(argument.neg())).times(series);
+}
+/**
+ * Lower incomplete gamma γ(a, z).
+ *
+ * Positive integer first arguments use γ(a,z) = Γ(a) - Γ(a,z).
+ * Other inputs remain symbolic.
+ *
+ * @see https://dlmf.nist.gov/8.2.E3
+ */
+function gammaIncompleteLower(a, z) {
+    const order = Expression_1.Expression.create(a);
+    const argument = Expression_1.Expression.create(z);
+    if (!order.isNUM() || !order.isInteger() || order.lte((0, shortcuts_1.zero)())) {
+        return Expression_1.Expression.toFunction('gamma_incomplete_lower', [order, argument]);
+    }
+    if (order.getMultiplier().numerator > BigInt(Settings_1.Settings.MAX_PRODUCT_AND_SUMMATION_ITERATION)) {
+        return Expression_1.Expression.toFunction('gamma_incomplete_lower', [order, argument]);
+    }
+    return gamma(order).minus(gammaIncomplete(order, argument));
+}
 /**
  * Computes the gamma function Γ(x).
  *
@@ -956,7 +1152,7 @@ function erf(x) {
         }
     }
     else {
-        retval = Expression_1.Expression.toFunction(constants_1.ERF, [new Expression_1.Expression(x)]);
+        retval = Expression_1.Expression.toFunction(constants_1.ERF, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -996,7 +1192,7 @@ function sinc(x) {
         retval = (0, trig_1.sin)(x).div(x);
     }
     else {
-        retval = Expression_1.Expression.toFunction(constants_1.SINC, [new Expression_1.Expression(x)]);
+        retval = Expression_1.Expression.toFunction(constants_1.SINC, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1034,7 +1230,7 @@ function Si(x) {
         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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.SI, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1069,7 +1265,7 @@ function Shi(x) {
         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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.SHI, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1104,7 +1300,7 @@ function Ci(x) {
         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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.CI, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1139,7 +1335,7 @@ function Chi(x) {
         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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.CHI, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1170,7 +1366,7 @@ function Ei(x) {
         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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.EI, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1200,14 +1396,14 @@ function Li(x) {
     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)]);
+            retval = Expression_1.Expression.toFunction(constants_1.LI, [Expression_1.Expression.create(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)]);
+        retval = Expression_1.Expression.toFunction(constants_1.LI, [Expression_1.Expression.create(x)]);
     }
     return retval;
 }
@@ -1247,8 +1443,8 @@ function log(x, base, expandPrimes = false) {
     if (baseExpr &&
         x.isInteger() &&
         baseExpr.isInteger() &&
-        x.gt(0) &&
-        baseExpr.gt(1)) {
+        x.gt((0, shortcuts_1.zero)()) &&
+        baseExpr.gt((0, shortcuts_1.one)())) {
         const target = x.getMultiplier().numerator;
         const radix = baseExpr.getMultiplier().numerator;
         let value = 1n;
@@ -1282,10 +1478,10 @@ function log(x, base, expandPrimes = false) {
             retval = (0, shortcuts_1.one)().times(exponent);
         }
         else {
-            retval = Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [new Expression_1.Expression(x)]);
+            retval = Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [Expression_1.Expression.create(x)]);
         }
     }
-    else if (!x.isComplex() && x.lt(0)) {
+    else if (!x.isComplex() && x.lt((0, shortcuts_1.zero)())) {
         retval = Expression_1.Expression.Pi().times(Expression_1.Expression.Img()).plus(log(x.abs()));
     }
     // Handle complex numbers regardless of EVALUATE setting
@@ -1355,7 +1551,7 @@ function log(x, base, expandPrimes = false) {
                 for (const element of elements) {
                     let elementIsPositive = false;
                     if (element.isNUM()) {
-                        elementIsPositive = element.gt(0);
+                        elementIsPositive = element.gt((0, shortcuts_1.zero)());
                     }
                     else {
                         const elementPower = element.getPower();
@@ -1365,7 +1561,7 @@ function log(x, base, expandPrimes = false) {
                         elementIsPositive =
                             !elementPower.isComplex() &&
                                 !elementBase.isComplex() &&
-                                elementBase.gt(0);
+                                elementBase.gt((0, shortcuts_1.zero)());
                     }
                     if (!elementIsPositive) {
                         canSplitProduct = false;
@@ -1386,11 +1582,11 @@ function log(x, base, expandPrimes = false) {
                 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);
+                    mFreeIsPositive = !mFree.isComplex() && mFree.gt((0, shortcuts_1.zero)());
                 }
                 // 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)) {
+                else if (!pow.isComplex() && !baseExpr.isComplex() && baseExpr.gt((0, shortcuts_1.zero)())) {
                     logExpr = log(baseExpr).times(pow);
                     mFreeIsPositive = true;
                 }
@@ -1407,7 +1603,7 @@ function log(x, base, expandPrimes = false) {
             }
         }
     }
-    retval = retval || Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [new Expression_1.Expression(x)]);
+    retval = retval || Expression_1.Expression.toFunction(Expression_1.Expression.LOG, [Expression_1.Expression.create(x)]);
     // Handle base conversion: log_b(x) = log(x) / log(b)
     if (baseExpr && retval && !exactBaseLog) {
         retval = retval.div(log(baseExpr));
@@ -1719,58 +1915,6 @@ function product(expr, index, lower, upper) {
     }
     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.
  *