nerdamer 2.0.0-rc.2 → 2.0.0

package/output/index.d.ts

@@ -1,4 +1,3 @@
-import { sqcomp } from './algebra/utils';
 import { Assumption } from './core/classes/assumption/Assumption';
 import { Collection } from './core/classes/collection/Collection';
 import { Dictionary } from './core/classes/dictionary/Dictionary';
@@ -13,9 +12,8 @@ import { ValuesSet } from './core/classes/valuesSet/ValuesSet';
 import { Vector } from './core/classes/vector/Vector';
 import { Converter } from './core/converters/Converter';
 import * as errors from './core/errors';
-import { build } from './core/functions/build';
 import { imagPart, polarForm, realPart, rectForm } from './core/functions/complex';
-import { ceiling, dirac, doubleFactorial, fibonacci, gammaIncomplete, gammaIncompleteLower } from './math/math';
+import { gammaIncomplete, gammaIncompleteLower } from './math/math';
 import { continuedFraction, isprime } from './math/utils';
 import { SolutionSet } from './solve/classes/SolutionSet';
 import type { OptionsObject, ParserConstants, ParserValuesObject, TextOptions } from './core/classes/parser/types';
@@ -179,10 +177,10 @@ declare namespace nerdamer {
         user: string[];
         system: string[];
     };
-    var symbols: typeof import("./core/classes/expression/shortcuts").symbols;
+    var symbols: typeof import("./api/core").symbols;
     var version: () => string;
     var errors: typeof import("./core/errors");
-    var buildFunction: typeof build;
+    var buildFunction: (x: ExpressionInput, argsArray?: string[]) => (...args: number[]) => number;
     var classes: {
         Expression: typeof Expression;
         Rational: typeof Rational;
@@ -204,8 +202,9 @@ declare namespace nerdamer {
                 VALUE_SETS: string[];
                 WHITE_SPACE: string[];
                 KNOWN_VALUES: Record<string, ParserEntity>;
+                extractDictionaryKey(scope: import("./core/common/classes/Scope").Scope, values?: ParserValuesObject, assertive?: boolean): string;
                 extractIndices(scope: import("./core/common/classes/Scope").Scope, values?: ParserValuesObject, assertive?: boolean): number[] | Expression[];
-                extractStringKeys(scope: import("./core/common/classes/Scope").Scope): string[];
+                resolveSymbolicAccess(symbolicTarget: Expression, resolvedTarget: ParserEntity, indices: Expression[]): ParserEntity;
                 aliasOperator(symbol: string, alias: string): /*elided*/ any;
                 create(): /*elided*/ any;
                 evaluate(str: string, values?: ParserValuesObject): ParserEntity;
@@ -235,9 +234,9 @@ declare namespace nerdamer {
     var acos: typeof import("./math/trig").acos;
     var asin: typeof import("./math/trig").asin;
     var atan: typeof import("./math/trig").atan;
-    var arccos: typeof import("./math/trig").acos;
-    var arcsin: typeof import("./math/trig").asin;
-    var arctan: typeof import("./math/trig").atan;
+    var arccos: (x: ExpressionInput) => Expression;
+    var arcsin: (x: ExpressionInput) => Expression;
+    var arctan: (x: ExpressionInput) => Expression;
     var atan2: typeof import("./math/trig").atan2;
     var sec: typeof import("./math/trig").sec;
     var csc: typeof import("./math/trig").csc;
@@ -272,14 +271,14 @@ declare namespace nerdamer {
     var max: typeof import("./math/math").max;
     var round: typeof import("./math/math").round;
     var floor: typeof import("./math/math").floor;
-    var ceil: typeof ceiling;
+    var ceil: (x: ExpressionInput) => Expression;
     var trunc: typeof import("./math/trunc").trunc;
     var hypot: typeof import("./math/geometry").hypot;
-    var fact: typeof import("./math/math").factorial;
+    var fact: (x: Expression) => Expression;
     var factorial: typeof import("./math/math").factorial;
-    var dfact: typeof doubleFactorial;
-    var dfactorial: typeof doubleFactorial;
-    var fib: typeof fibonacci;
+    var dfact: (x: Expression) => Expression;
+    var dfactorial: (x: Expression) => Expression;
+    var fib: (x: ExpressionInput) => Expression;
     var mod: typeof import("./math/math").mod;
     var modInv: typeof import("./math/math").modInv;
     var isPrime: typeof isprime;
@@ -299,7 +298,7 @@ declare namespace nerdamer {
     var step: typeof import("./math/math").step;
     var rect: typeof import("./math/math").rect;
     var tri: typeof import("./math/math").tri;
-    var delta: typeof dirac;
+    var delta: (x: Expression) => Expression;
     var Ci: typeof import("./math/math").Ci;
     var Chi: typeof import("./math/math").Chi;
     var Si: typeof import("./math/math").Si;
@@ -312,20 +311,20 @@ declare namespace nerdamer {
     var scientific: typeof import("./math/math").scientific;
     var contains: typeof import("./math/math").contains;
     var subst: typeof import("./core/functions/subst").subst;
-    var uSub: typeof import("./core/functions/subst").uSub;
-    var uUnSub: typeof import("./core/functions/subst").uUnSub;
+    var uSub: typeof import("./api/algebra").uSub;
+    var uUnSub: typeof import("./api/algebra").uUnSub;
     var expand: typeof import("./core/functions/expand/expand").expand;
-    var factor: typeof import("./algebra/factor/factor").factor;
-    var pfactor: typeof import("./algebra/factor/factor").pfactor;
-    var pfactord: typeof import("./algebra/factor/factor").pfactord;
-    var polyFactors: typeof import("./algebra/factor/factor").polyFactors;
-    var completeSquare: typeof sqcomp;
-    var gcd: typeof import("./algebra/gcd/gcd").gcd;
-    var lcm: typeof import("./algebra/gcd/gcd").lcm;
+    var factor: typeof import("./api/algebra").factor;
+    var pfactor: typeof import("./api/algebra").pfactor;
+    var pfactord: typeof import("./api/algebra").pfactord;
+    var polyFactors: typeof import("./api/algebra").polyFactors;
+    var completeSquare: (expr: ExpressionInput, variable?: string) => import("./algebra/utils").CompleteSquareResult;
+    var gcd: typeof import("./api/algebra").gcd;
+    var lcm: typeof import("./api/algebra").lcm;
     var partfrac: typeof import("./algebra/partfrac").partfrac;
     var div: typeof polynomialDiv;
     var divide: typeof polynomialDivide;
-    var simplify: typeof import("./algebra/simplify/simplify").simplify;
+    var simplify: typeof import("./api/algebra").simplify;
     var groebner: typeof import("./algebra/groebner").groebner;
     var solve: typeof import("./solve/solve").solve;
     var roots: typeof import("./solve/solve").roots;
@@ -335,7 +334,7 @@ declare namespace nerdamer {
     var integrate: typeof import("./calculus/integrate/integrate").integrate;
     var laplace: typeof import("./calculus/laplace/laplace").laplace;
     var ilaplace: typeof import("./calculus/laplace/ilaplace").ilaplace;
-    var ilt: typeof import("./calculus/laplace/ilaplace").ilaplace;
+    var ilt: (expr: ExpressionInput, s: ExpressionInput, t: ExpressionInput) => Expression;
     var sum: typeof import("./math/math").sum;
     var product: typeof import("./math/math").product;
     var limit: typeof import("./calculus/limit/limit").limit;
@@ -350,10 +349,11 @@ declare namespace nerdamer {
     var dot: typeof import("./core/classes/vector/functions").dot;
     var cross: typeof import("./core/classes/vector/functions").cross;
     var line: typeof import("./math/geometry").line;
-    var deg: typeof import("./core/classes/polynomial/functions").deg;
-    var content: typeof import("./core/classes/polynomial/functions").content;
-    var coeffs: typeof import("./core/classes/polynomial/functions").coeffs;
+    var deg: typeof import("./api/algebra").deg;
+    var content: typeof import("./api/algebra").content;
+    var coeffs: typeof import("./api/algebra").coeffs;
     var assume: typeof import("./core/classes/assumption/assume").assume;
+    var getAssumptions: typeof import("./core/classes/assumption/assume").getAssumptions;
     var updateAPI: () => typeof nerdamer;
 }
 export default nerdamer;

package/output/index.js

@@ -42,7 +42,8 @@ const gcd_1 = require("./algebra/gcd/gcd");
 const groebner_1 = require("./algebra/groebner");
 const partfrac_1 = require("./algebra/partfrac");
 const simplify_1 = require("./algebra/simplify/simplify");
-const utils_1 = require("./algebra/utils");
+const algebra_1 = require("./api/algebra");
+const core_1 = require("./api/core");
 const diff_1 = require("./calculus/derivative/diff");
 const fresnel_1 = require("./calculus/fresnel");
 const integrate_1 = require("./calculus/integrate/integrate");
@@ -58,7 +59,7 @@ const Expression_1 = require("./core/classes/expression/Expression");
 const shortcuts_1 = require("./core/classes/expression/shortcuts");
 const functions_1 = require("./core/classes/matrix/functions");
 const Matrix_1 = require("./core/classes/matrix/Matrix");
-const utils_2 = require("./core/classes/matrix/utils");
+const utils_1 = require("./core/classes/matrix/utils");
 const constants_1 = require("./core/classes/parser/constants");
 const Parser_1 = require("./core/classes/parser/Parser");
 const scope_1 = require("./core/classes/parser/scripting/scope");
@@ -70,9 +71,8 @@ const functions_3 = require("./core/classes/vector/functions");
 const Vector_1 = require("./core/classes/vector/Vector");
 const Converter_1 = require("./core/converters/Converter");
 const dispatch_1 = require("./core/dispatch");
-const fullFunctions_1 = require("./core/fullFunctions");
 const errors = __importStar(require("./core/errors"));
-const build_1 = require("./core/functions/build");
+const fullFunctions_1 = require("./core/fullFunctions");
 const complex_1 = require("./core/functions/complex");
 const expand_1 = require("./core/functions/expand/expand");
 const setFunction_1 = require("./core/functions/setFunction");
@@ -82,7 +82,7 @@ const geometry_1 = require("./math/geometry");
 const math_1 = require("./math/math");
 const trig_1 = require("./math/trig");
 const trunc_1 = require("./math/trunc");
-const utils_3 = require("./math/utils");
+const utils_2 = require("./math/utils");
 const SolutionSet_1 = require("./solve/classes/SolutionSet");
 const solve_1 = require("./solve/solve");
 const solveSystem_1 = require("./solve/solveSystem");
@@ -536,7 +536,7 @@ nerdamer.errors = errors;
  * nerdamer('cos(x)').buildFunction(['x'])(0);			// 1
  * ```
  */
-nerdamer.buildFunction = build_1.build;
+nerdamer.buildFunction = core_1.buildFunction;
 /**
  * Compatibility registry of selected Nerdamer constructors and the shared Parser instance.
  *
@@ -572,9 +572,36 @@ nerdamer.tan = trig_1.tan;
 nerdamer.acos = trig_1.acos;
 nerdamer.asin = trig_1.asin;
 nerdamer.atan = trig_1.atan;
-nerdamer.arccos = trig_1.acos;
-nerdamer.arcsin = trig_1.asin;
-nerdamer.arctan = trig_1.atan;
+const arccos = trig_1.acos;
+/**
+ * Alias for `nerdamer.acos`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.arccos('1/2').text(); // "1/3*pi"
+ * ```
+ */
+nerdamer.arccos = arccos;
+const arcsin = trig_1.asin;
+/**
+ * Alias for `nerdamer.asin`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.arcsin('1/2').text(); // "1/6*pi"
+ * ```
+ */
+nerdamer.arcsin = arcsin;
+const arctan = trig_1.atan;
+/**
+ * Alias for `nerdamer.atan`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.arctan(1).text(); // "1/4*pi"
+ * ```
+ */
+nerdamer.arctan = arctan;
 nerdamer.atan2 = trig_1.atan2;
 nerdamer.sec = trig_1.sec;
 nerdamer.csc = trig_1.csc;
@@ -611,18 +638,63 @@ nerdamer.min = math_1.min;
 nerdamer.max = math_1.max;
 nerdamer.round = math_1.round;
 nerdamer.floor = math_1.floor;
-nerdamer.ceil = math_1.ceiling;
+const ceil = math_1.ceiling;
+/**
+ * Rounds a value up to the nearest integer.
+ *
+ * @example
+ * ```ts
+ * nerdamer.ceil('3.2').text(); // "4"
+ * ```
+ */
+nerdamer.ceil = ceil;
 nerdamer.trunc = trunc_1.trunc;
 nerdamer.hypot = geometry_1.hypot;
 // Discrete and number-theoretic functions
-nerdamer.fact = math_1.factorial;
+const fact = math_1.factorial;
+/**
+ * Alias for `nerdamer.factorial`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.fact(5).text(); // "120"
+ * ```
+ */
+nerdamer.fact = fact;
 nerdamer.factorial = math_1.factorial;
-nerdamer.dfact = math_1.doubleFactorial;
-nerdamer.dfactorial = math_1.doubleFactorial;
-nerdamer.fib = math_1.fibonacci;
+const dfact = math_1.doubleFactorial;
+/**
+ * Computes the double factorial of an expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer.dfact(6).text(); // "48"
+ * ```
+ */
+nerdamer.dfact = dfact;
+const dfactorial = math_1.doubleFactorial;
+/**
+ * Computes the double factorial of an expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer.dfactorial(7).text(); // "105"
+ * ```
+ */
+nerdamer.dfactorial = dfactorial;
+const fib = math_1.fibonacci;
+/**
+ * Computes the Fibonacci number for an integer index.
+ *
+ * @example
+ * ```ts
+ * nerdamer.fib(10).text(); // "55"
+ * ```
+ */
+nerdamer.fib = fib;
 nerdamer.mod = math_1.mod;
 nerdamer.modInv = math_1.modInv;
-nerdamer.isPrime = utils_3.isprime;
+nerdamer.isPrime = utils_2.isprime;
 // Complex functions
 nerdamer.imagpart = complex_1.imagPart;
 nerdamer.realpart = complex_1.realPart;
@@ -641,7 +713,16 @@ nerdamer.heaviside = math_1.heaviside;
 nerdamer.step = math_1.step;
 nerdamer.rect = math_1.rect;
 nerdamer.tri = math_1.tri;
-nerdamer.delta = math_1.dirac;
+const delta = math_1.dirac;
+/**
+ * Evaluates the Dirac delta function when the input is known to be nonzero.
+ *
+ * @example
+ * ```ts
+ * nerdamer.delta(5).text(); // "0"
+ * ```
+ */
+nerdamer.delta = delta;
 nerdamer.Ci = math_1.Ci;
 nerdamer.Chi = math_1.Chi;
 nerdamer.Si = math_1.Si;
@@ -651,7 +732,7 @@ nerdamer.Ei = math_1.Ei;
 nerdamer.sinc = math_1.sinc;
 // Symbolic utilities
 nerdamer.parens = math_1.parens;
-nerdamer.continued_fraction = utils_3.continuedFraction;
+nerdamer.continued_fraction = utils_2.continuedFraction;
 nerdamer.scientific = math_1.scientific;
 nerdamer.contains = math_1.contains;
 nerdamer.subst = subst_1.subst;
@@ -663,7 +744,15 @@ nerdamer.factor = factor_1.factor;
 nerdamer.pfactor = factor_1.pfactor;
 nerdamer.pfactord = factor_1.pfactord;
 nerdamer.polyFactors = factor_1.polyFactors;
-nerdamer.completeSquare = utils_1.sqcomp;
+/**
+ * Completes the square for a quadratic expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer.completeSquare('x^2+6*x+1').expression.text({ sort: true }); // "(3+x)^2-8"
+ * ```
+ */
+nerdamer.completeSquare = algebra_1.completeSquare;
 nerdamer.gcd = gcd_1.gcd;
 nerdamer.lcm = gcd_1.lcm;
 nerdamer.partfrac = partfrac_1.partfrac;
@@ -681,7 +770,16 @@ nerdamer.diff = diff_1.diff;
 nerdamer.integrate = integrate_1.integrate;
 nerdamer.laplace = laplace_1.laplace;
 nerdamer.ilaplace = ilaplace_1.ilaplace;
-nerdamer.ilt = ilaplace_1.ilaplace;
+const ilt = ilaplace_1.ilaplace;
+/**
+ * Alias for `nerdamer.ilaplace`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.ilt('1/(s^2+1)', 's', 't').text();
+ * ```
+ */
+nerdamer.ilt = ilt;
 nerdamer.sum = math_1.sum;
 nerdamer.product = math_1.product;
 nerdamer.limit = limit_1.limit;
@@ -690,7 +788,7 @@ nerdamer.S = fresnel_1.S;
 nerdamer.C = fresnel_1.C;
 // Matrix operations
 nerdamer.matrix = math_1.matrix;
-nerdamer.imatrix = utils_2.imatrix;
+nerdamer.imatrix = utils_1.imatrix;
 nerdamer.determinant = functions_1.determinant;
 nerdamer.invert = functions_1.invert;
 nerdamer.nullspace = functions_1.nullspace;
@@ -713,6 +811,12 @@ nerdamer.coeffs = functions_2.coeffs;
  * directly can use the documented assumption-domain functions.
  */
 nerdamer.assume = assume_1.assume;
+/**
+ * Returns a snapshot of all process-wide assumptions currently registered by symbol.
+ *
+ * Changing the returned Map does not change Nerdamer's active assumptions.
+ */
+nerdamer.getAssumptions = assume_1.getAssumptions;
 // -----------------------------------------------------------------------------
 // Complete the full-package instance API
 // -----------------------------------------------------------------------------

package/output/math/dispatch.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMathFunctions = loadMathFunctions;
-const dispatch_1 = require("../core/dispatch");
 const constants_1 = require("../core/classes/parser/constants");
 const evaluate_1 = require("../core/classes/parser/scripting/evaluate");
+const dispatch_1 = require("../core/dispatch");
 const expand_1 = require("../core/functions/expand/expand");
 const subst_1 = require("../core/functions/subst");
 const geometry_1 = require("./geometry");

package/output/math/math.js

@@ -146,11 +146,11 @@ function nthroot(x, n) {
 }
 /** Converts degrees to radians exactly. */
 function radians(x) {
-    return Expression_1.Expression.create(x).times(Expression_1.Expression.Pi()).div(180);
+    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(180).div(Expression_1.Expression.Pi());
+    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) {
@@ -366,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);
             }
@@ -380,7 +380,7 @@ 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);
         }
     }
@@ -429,13 +429,13 @@ 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 {
@@ -528,7 +528,7 @@ function dirac(x) {
             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 {
@@ -672,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 {
@@ -784,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;
     }
@@ -874,7 +874,7 @@ 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);
@@ -1443,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;
@@ -1481,7 +1481,7 @@ function log(x, base, expandPrimes = false) {
             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
@@ -1551,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();
@@ -1561,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;
@@ -1582,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;
                 }

package/output/math/trig.js

@@ -402,8 +402,8 @@ function tan(x) {
             retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().tan());
         }
         else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
-            const dblRe = x.realPart().times(2);
-            const dblIm = x.imagPart().times(2);
+            const dblRe = x.realPart().times((0, shortcuts_1.two)());
+            const dblIm = x.imagPart().times((0, shortcuts_1.two)());
             const d = cos(dblRe).plus(cosh(dblIm));
             retval = sin(dblRe).div(d).plus(sinh(dblIm).div(d).i());
         }
@@ -599,7 +599,7 @@ function acos(x) {
     let retval;
     if (Settings_1.Settings.EVALUATE && x.isNUM()) {
         // Becomes complex between [-1, 1]
-        if (x.lt(-1) || x.gt(1)) {
+        if (x.lt((0, shortcuts_1.minusOne)()) || x.gt((0, shortcuts_1.one)())) {
             const sgn = x.sign();
             const halfPi = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
             let asinX = asin(x.abs());
@@ -1225,7 +1225,7 @@ function acosh(x) {
         retval = Expression_1.Expression.Pi().div((0, shortcuts_1.two)()).times(Expression_1.Expression.Img());
     }
     else if (Settings_1.Settings.EVALUATE) {
-        if (x.isComplex() || x.lt('1')) {
+        if (x.isComplex() || x.lt((0, shortcuts_1.one)())) {
             const a = (0, math_1.sqrt)(x.plus((0, shortcuts_1.one)()));
             const b = (0, math_1.sqrt)(x.minus((0, shortcuts_1.one)()));
             const c = x.plus(a.times(b));

package/output/solve/solve.js

@@ -55,7 +55,7 @@ function calculateSolutions(factors, variable, disjointPolynomialFactors = false
         else if (fn.hasVariable(variable)) {
             // First Symbolically
             let solutions = new SymbolicSolver_1.SymbolicSolver(fn, variable).solve();
-            if (solutions.unsolved && fn.isPolynomialLike() && fn.getPower().gt(4)) {
+            if (solutions.unsolved && fn.isPolynomialLike() && fn.getPower().gt((0, shortcuts_1.four)())) {
                 const linearPoly = fn.toLinearAndUnitMultiplier();
                 // See if you can solve the linear polynomial
                 solutions = new SymbolicSolver_1.SymbolicSolver(linearPoly, variable).solve();

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "nerdamer",
-	"version": "2.0.0-rc.2",
+	"version": "2.0.0",
 	"publishConfig": {
-		"tag": "next"
+		"tag": "latest"
 	},
 	"description": "A symbolic math library and computer algebra system for JavaScript and TypeScript.",
 	"directory": {
@@ -29,13 +29,14 @@
 		"build:types": "npm run clean:modules && tsc -p tsconfig.build.json",
 		"build:modules": "npm run build:types",
 		"build:bundle": "npm run clean:dist && webpack --mode=production --env target=full",
+		"build:bundle:all-languages": "npm run clean:dist && webpack --mode=production --env target=full --env language=all",
 		"build:parser": "webpack --mode=production --env target=parser && node tools/smoke-build.cjs parser",
 		"build:full": "npm run build:modules && npm run build:bundle && node tools/smoke-build.cjs full",
+		"build:all-languages": "npm run build:modules && npm run build:bundle:all-languages && node tools/smoke-build.cjs full",
 		"build": "npm run build:full",
 		"docs:parser": "ts-node tools/generate-parser-docs.ts",
-		"docs:check": "typedoc --options typedoc.json --emit none",
 		"validate:package": "ts-node tools/validate-package.ts",
-		"prepublishOnly": "npm run typecheck && npm run test && npm run test:coverage && npm run build && npm run build:parser && npm run docs:parser && npm run docs:check && npm run validate:package",
+		"prepublishOnly": "npm run typecheck && npm run test && npm run test:coverage && npm run build && npm run validate:package",
 		"clean:modules": "node -e \"require('node:fs').rmSync('output', { recursive: true, force: true })\"",
 		"clean:dist": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\""
 	},
@@ -160,21 +161,39 @@
 			"default": "./output/api/debug.js"
 		},
 		"./docs-data/parser-functions.json": "./docs-data/parser-functions.json",
+		"./docs-data/typedoc.json": "./docs-data/typedoc.json",
 		"./dist/bundle.js": "./dist/bundle.js",
-		"./dist/parser.js": "./dist/parser.js",
 		"./package.json": "./package.json"
 	},
 	"typesVersions": {
 		"*": {
-			"core": ["output/api/core.d.ts"],
-			"algebra": ["output/api/algebra.d.ts"],
-			"calculus": ["output/api/calculus.d.ts"],
-			"solve": ["output/api/solve.d.ts"],
-			"structures": ["output/api/structures.d.ts"],
-			"assumptions": ["output/api/assumptions.d.ts"],
-			"parser": ["output/api/parser.d.ts"],
-			"advanced": ["output/api/advanced.d.ts"],
-			"debug": ["output/api/debug.d.ts"]
+			"core": [
+				"output/api/core.d.ts"
+			],
+			"algebra": [
+				"output/api/algebra.d.ts"
+			],
+			"calculus": [
+				"output/api/calculus.d.ts"
+			],
+			"solve": [
+				"output/api/solve.d.ts"
+			],
+			"structures": [
+				"output/api/structures.d.ts"
+			],
+			"assumptions": [
+				"output/api/assumptions.d.ts"
+			],
+			"parser": [
+				"output/api/parser.d.ts"
+			],
+			"advanced": [
+				"output/api/advanced.d.ts"
+			],
+			"debug": [
+				"output/api/debug.d.ts"
+			]
 		}
 	}
-}
+}