nerdamer 2.0.0-rc.1 → 2.0.0

package/output/algebra/polynomial/modularGcd.js

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * @module modularGcd
+ *
+ * Greatest common divisors for sparse polynomials over a modular field.
+ *
+ * External references consulted for finite-field Euclidean GCD and recursive
+ * evaluation/interpolation:
+ * - SymPy finite-field polynomial GCD:
+ *   https://github.com/sympy/sympy/blob/120ee85f346f6292b763cc195afda4f907260d4a/sympy/polys/galoistools.py
+ * - SymPy sparse univariate modular GCD bridge:
+ *   https://github.com/sympy/sympy/blob/120ee85f346f6292b763cc195afda4f907260d4a/sympy/polys/zippel.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modularGcdUnivariate = modularGcdUnivariate;
+exports.modularGcdFiniteField = modularGcdFiniteField;
+exports.modularGcdBivariate = modularGcdBivariate;
+exports.modularGcdTrivariate = modularGcdTrivariate;
+const errors_1 = require("../../core/errors");
+const primeFactor_1 = require("../../core/functions/bigint/primeFactor");
+const ModularSparsePolynomial_1 = require("./ModularSparsePolynomial");
+// SymPy gives failed sparse interpolation data a small number of fresh attempts
+// before abandoning the current modular image.
+const MODULAR_GCD_RECONSTRUCTION_ATTEMPTS = 3n;
+/**
+ * Computes polynomial content in one selected coefficient variable.
+ *
+ * Terms are grouped by their complete exponent vector outside coefficientVariable.
+ * The grouping key is used only for identity and is never parsed back into exponents.
+ */
+function modularContentInVariable(polynomial, coefficientVariable) {
+    polynomial.degree(coefficientVariable);
+    if (polynomial.isZero()) {
+        return ModularSparsePolynomial_1.ModularSparsePolynomial.zero(polynomial.variableCount, polynomial.modulus);
+    }
+    const groups = new Map();
+    for (const term of polynomial.terms()) {
+        const groupExponents = [...term.exponents];
+        groupExponents[coefficientVariable] = 0n;
+        const key = groupExponents.join(',');
+        const coefficientExponents = new Array(polynomial.variableCount).fill(0n);
+        coefficientExponents[coefficientVariable] = term.exponents[coefficientVariable];
+        const group = groups.get(key) ?? [];
+        group.push({
+            coefficient: term.coefficient,
+            exponents: coefficientExponents,
+        });
+        groups.set(key, group);
+    }
+    let content = ModularSparsePolynomial_1.ModularSparsePolynomial.zero(polynomial.variableCount, polynomial.modulus);
+    for (const terms of groups.values()) {
+        const coefficient = new ModularSparsePolynomial_1.ModularSparsePolynomial(polynomial.variableCount, polynomial.modulus, terms);
+        content = content.isZero()
+            ? coefficient.monic('lex')
+            : modularGcdUnivariate(content, coefficient, coefficientVariable);
+        if (content.isConstant()) {
+            return ModularSparsePolynomial_1.ModularSparsePolynomial.constant(polynomial.variableCount, polynomial.modulus, 1n);
+        }
+    }
+    return content.monic('lex');
+}
+/** Removes polynomial content in one selected coefficient variable. */
+function modularPrimitivePartInVariable(polynomial, coefficientVariable) {
+    if (polynomial.isZero()) {
+        return {
+            content: ModularSparsePolynomial_1.ModularSparsePolynomial.zero(polynomial.variableCount, polynomial.modulus),
+            primitive: polynomial,
+        };
+    }
+    const content = modularContentInVariable(polynomial, coefficientVariable);
+    const primitive = polynomial.divideExact(content);
+    if (primitive === null) {
+        throw new RangeError((0, errors_1.message)('polyModularContentExactDivision'));
+    }
+    return { content, primitive };
+}
+/**
+ * Returns the coefficient polynomial at the lexicographically greatest monomial
+ * in polynomialVariables. The result depends only on coefficientVariable.
+ */
+function modularLeadingCoefficientInVariables(polynomial, polynomialVariables, coefficientVariable) {
+    polynomial.degree(coefficientVariable);
+    for (const variableIndex of polynomialVariables) {
+        polynomial.degree(variableIndex);
+    }
+    const terms = polynomial.terms();
+    if (terms.length === 0) {
+        return null;
+    }
+    let leading = terms[0];
+    for (let termIndex = 1; termIndex < terms.length; termIndex++) {
+        const term = terms[termIndex];
+        for (const variableIndex of polynomialVariables) {
+            if (term.exponents[variableIndex] === leading.exponents[variableIndex]) {
+                continue;
+            }
+            if (term.exponents[variableIndex] > leading.exponents[variableIndex]) {
+                leading = term;
+            }
+            break;
+        }
+    }
+    const coefficientTerms = [];
+    for (const term of terms) {
+        let matches = true;
+        for (const variableIndex of polynomialVariables) {
+            if (term.exponents[variableIndex] !== leading.exponents[variableIndex]) {
+                matches = false;
+                break;
+            }
+        }
+        if (!matches) {
+            continue;
+        }
+        const exponents = new Array(polynomial.variableCount).fill(0n);
+        exponents[coefficientVariable] = term.exponents[coefficientVariable];
+        coefficientTerms.push({
+            coefficient: term.coefficient,
+            exponents,
+        });
+    }
+    return new ModularSparsePolynomial_1.ModularSparsePolynomial(polynomial.variableCount, polynomial.modulus, coefficientTerms);
+}
+/**
+ * Returns the monomial support over selected variables.
+ *
+ * Keys are used only for set membership and are never decoded back into exponents.
+ */
+function monomialSupport(polynomial, variables) {
+    const support = new Set();
+    for (const term of polynomial.terms()) {
+        support.add(variables.map(variableIndex => term.exponents[variableIndex]).join(','));
+    }
+    return support;
+}
+/**
+ * Computes the monic GCD of two univariate polynomials over the same modular field.
+ *
+ * The polynomial ring may retain additional variable coordinates, but neither input
+ * may depend on variables other than variableIndex.
+ */
+function modularGcdUnivariate(left, right, variableIndex) {
+    if (left.variableCount !== right.variableCount || left.modulus !== right.modulus) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD', requirement: (0, errors_1.message)('polyReqSamePolynomialRing') }));
+    }
+    left.degree(variableIndex);
+    right.degree(variableIndex);
+    for (const activeVariable of left.variables()) {
+        if (activeVariable !== variableIndex) {
+            throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD inputs', requirement: (0, errors_1.message)('polyReqUnivariatePolynomial') }));
+        }
+    }
+    for (const activeVariable of right.variables()) {
+        if (activeVariable !== variableIndex) {
+            throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD inputs', requirement: (0, errors_1.message)('polyReqUnivariatePolynomial') }));
+        }
+    }
+    let a = new ModularSparsePolynomial_1.ModularSparsePolynomial(left.variableCount, left.modulus, left.terms());
+    let b = new ModularSparsePolynomial_1.ModularSparsePolynomial(right.variableCount, right.modulus, right.terms());
+    while (!b.isZero()) {
+        const division = a.divideWithRemainder(b, 'lex');
+        a = b;
+        b = division.remainder;
+    }
+    return a.isZero() ? a : a.monic('lex');
+}
+/**
+ * Computes a modular GCD recursively by specializing the last selected variable.
+ *
+ * The caller supplies the variable order used by the recursive polynomial view.
+ * Ring coordinates not listed in variables must be dormant.
+ */
+function modularGcdRecursive(left, right, variables) {
+    if (variables.length === 1) {
+        return modularGcdUnivariate(left, right, variables[0]);
+    }
+    if (left.isZero()) {
+        return right.isZero() ? right : right.monic('lex');
+    }
+    if (right.isZero()) {
+        return left.monic('lex');
+    }
+    const interpolationVariable = variables[variables.length - 1];
+    const polynomialVariables = variables.slice(0, -1);
+    const leftParts = modularPrimitivePartInVariable(left, interpolationVariable);
+    const rightParts = modularPrimitivePartInVariable(right, interpolationVariable);
+    const contentGcd = modularGcdUnivariate(leftParts.content, rightParts.content, interpolationVariable);
+    const leftLeading = modularLeadingCoefficientInVariables(leftParts.primitive, polynomialVariables, interpolationVariable);
+    const rightLeading = modularLeadingCoefficientInVariables(rightParts.primitive, polynomialVariables, interpolationVariable);
+    if (leftLeading === null || rightLeading === null) {
+        return null;
+    }
+    const scaling = modularGcdUnivariate(leftLeading, rightLeading, interpolationVariable);
+    const leftInterpolationDegree = leftParts.primitive.degree(interpolationVariable) ?? 0n;
+    const rightInterpolationDegree = rightParts.primitive.degree(interpolationVariable) ?? 0n;
+    const maxGcdDegree = leftInterpolationDegree < rightInterpolationDegree
+        ? leftInterpolationDegree
+        : rightInterpolationDegree;
+    const leftLeadingDegree = leftLeading.degree(interpolationVariable) ?? 0n;
+    const rightLeadingDegree = rightLeading.degree(interpolationVariable) ?? 0n;
+    const scalingDegree = scaling.degree(interpolationVariable) ?? 0n;
+    const requiredSamples = maxGcdDegree + 2n;
+    const badPointBound = leftLeadingDegree + rightLeadingDegree + scalingDegree;
+    const availablePoints = left.modulus - 1n;
+    const requestedPoints = requiredSamples * MODULAR_GCD_RECONSTRUCTION_ATTEMPTS + badPointBound;
+    const scanLimit = availablePoints < requestedPoints ? availablePoints : requestedPoints;
+    let expectedDegrees = null;
+    let expectedSupport = null;
+    let acceptedSamples = 0n;
+    let reconstructionAttempts = 0n;
+    let samples = [];
+    for (let value = 1n; value <= scanLimit; value++) {
+        const leftLeadingValue = leftLeading.evaluateVariable(interpolationVariable, value);
+        const rightLeadingValue = rightLeading.evaluateVariable(interpolationVariable, value);
+        const scalingValue = scaling.evaluateVariable(interpolationVariable, value).constantTerm();
+        if (leftLeadingValue.constantTerm() === 0n ||
+            rightLeadingValue.constantTerm() === 0n ||
+            scalingValue === 0n) {
+            continue;
+        }
+        const evaluatedLeft = leftParts.primitive.evaluateVariable(interpolationVariable, value);
+        const evaluatedRight = rightParts.primitive.evaluateVariable(interpolationVariable, value);
+        if (evaluatedLeft.isZero() || evaluatedRight.isZero()) {
+            continue;
+        }
+        const image = modularGcdRecursive(evaluatedLeft, evaluatedRight, polynomialVariables);
+        if (image === null) {
+            continue;
+        }
+        if (image.isConstant() && !image.isZero()) {
+            return contentGcd;
+        }
+        const imageDegrees = polynomialVariables.map(variableIndex => image.degree(variableIndex) ?? 0n);
+        if (expectedDegrees === null) {
+            expectedDegrees = imageDegrees;
+        }
+        else {
+            let degreeComparison = 0;
+            for (let index = 0; index < imageDegrees.length; index++) {
+                if (imageDegrees[index] < expectedDegrees[index]) {
+                    degreeComparison = -1;
+                    break;
+                }
+                if (imageDegrees[index] > expectedDegrees[index]) {
+                    degreeComparison = 1;
+                    break;
+                }
+            }
+            if (degreeComparison < 0) {
+                expectedDegrees = imageDegrees;
+                expectedSupport = null;
+                samples = [];
+                acceptedSamples = 0n;
+                reconstructionAttempts = 0n;
+            }
+            else if (degreeComparison > 0) {
+                continue;
+            }
+        }
+        const imageSupport = monomialSupport(image, polynomialVariables);
+        if (expectedSupport === null) {
+            expectedSupport = imageSupport;
+        }
+        else {
+            const imageContainsExpected = [...expectedSupport].every(key => imageSupport.has(key));
+            const currentSupport = expectedSupport;
+            const expectedContainsImage = [...imageSupport].every(key => currentSupport.has(key));
+            if (imageContainsExpected && !expectedContainsImage) {
+                expectedSupport = imageSupport;
+                samples = [];
+                acceptedSamples = 0n;
+                reconstructionAttempts = 0n;
+            }
+            else if (!imageContainsExpected) {
+                continue;
+            }
+        }
+        samples.push({
+            value,
+            polynomial: image.scale(scalingValue),
+        });
+        acceptedSamples++;
+        if (acceptedSamples < requiredSamples) {
+            continue;
+        }
+        const interpolated = ModularSparsePolynomial_1.ModularSparsePolynomial.interpolateVariable(interpolationVariable, samples);
+        const reconstructed = modularPrimitivePartInVariable(interpolated, interpolationVariable).primitive;
+        const candidate = reconstructed.multiply(contentGcd).monic('lex');
+        if (left.divideExact(candidate) !== null && right.divideExact(candidate) !== null) {
+            return candidate;
+        }
+        reconstructionAttempts++;
+        if (reconstructionAttempts >= MODULAR_GCD_RECONSTRUCTION_ATTEMPTS) {
+            return null;
+        }
+        samples = [];
+        acceptedSamples = 0n;
+    }
+    return null;
+}
+/**
+ * Computes a multivariate GCD over a prime field using recursive
+ * evaluation and interpolation.
+ *
+ * variables must follow polynomial-ring order and contain every active variable
+ * in both inputs exactly once. Dormant ring coordinates may be omitted.
+ */
+function modularGcdFiniteField(left, right, variables) {
+    if (left.variableCount !== right.variableCount || left.modulus !== right.modulus) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD', requirement: (0, errors_1.message)('polyReqSamePolynomialRing') }));
+    }
+    if (variables.length === 0) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD', requirement: (0, errors_1.message)('polyReqAtLeastOneVariable') }));
+    }
+    if (!(0, primeFactor_1.isPrimeBig)(left.modulus)) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Multivariate modular GCD', requirement: (0, errors_1.message)('polyReqPrimeModulus') }));
+    }
+    const selected = new Set();
+    let previousVariable = -1;
+    for (const variableIndex of variables) {
+        left.degree(variableIndex);
+        right.degree(variableIndex);
+        if (selected.has(variableIndex)) {
+            throw new RangeError((0, errors_1.message)('polyVariablesUnique', { operation: 'Modular polynomial GCD' }));
+        }
+        if (variableIndex <= previousVariable) {
+            throw new RangeError((0, errors_1.message)('polyVariablesRingOrder', { operation: 'Modular polynomial GCD' }));
+        }
+        selected.add(variableIndex);
+        previousVariable = variableIndex;
+    }
+    for (const activeVariable of [...left.variables(), ...right.variables()]) {
+        if (!selected.has(activeVariable)) {
+            throw new RangeError((0, errors_1.message)('polyInputsSelectedOnly', { operation: 'Modular polynomial GCD' }));
+        }
+    }
+    return modularGcdRecursive(left, right, variables);
+}
+/**
+ * Computes a bivariate GCD over a prime field by evaluation and interpolation.
+ */
+function modularGcdBivariate(left, right, mainVariable, interpolationVariable) {
+    if (mainVariable >= interpolationVariable) {
+        throw new RangeError((0, errors_1.message)('polyVariablesRingOrder', { operation: 'Bivariate modular GCD' }));
+    }
+    return modularGcdFiniteField(left, right, [mainVariable, interpolationVariable]);
+}
+/**
+ * Computes a trivariate GCD over a prime field by recursively specializing the
+ * last selected variable and reconstructing from bivariate GCD images.
+ *
+ * The selected variables must follow their polynomial-ring order. Other ring
+ * coordinates may remain dormant.
+ */
+function modularGcdTrivariate(left, right, mainVariable, secondaryVariable, interpolationVariable) {
+    if (mainVariable >= secondaryVariable ||
+        secondaryVariable >= interpolationVariable) {
+        throw new RangeError((0, errors_1.message)('polyVariablesRingOrder', { operation: 'Trivariate modular GCD' }));
+    }
+    return modularGcdFiniteField(left, right, [
+        mainVariable,
+        secondaryVariable,
+        interpolationVariable,
+    ]);
+}

package/output/algebra/polynomialize.js

@@ -5,8 +5,10 @@ const subst_1 = require("../core/functions/subst");
 const simplify_1 = require("./simplify/simplify");
 function polynomialize(expression, map, callback) {
     map ??= {};
-    // First simplify the expression
-    let x = (0, simplify_1.simplify)(expression);
+    // Ordinary polynomial input is already in the exact domain required below.
+    // Avoid routing it through the full simplifier, which ends by factoring and can
+    // recursively re-enter polynomial GCD preprocessing.
+    let x = expression.isPolynomialLike() ? expression : (0, simplify_1.simplify)(expression);
     // Substitute out all functions
     [x, map] = (0, subst_1.uSubFN)(x, map);
     // Substitute out all exponential functions

package/output/algebra/simplify/funcsimp.js

@@ -337,7 +337,7 @@ function simplifyLogs(x) {
     // Principal-log identities such as log(a)+log(b)=log(a*b) and
     // c*log(a)=log(a^c) are only branch-safe when the log arguments are
     // provably positive real values. Preserve unknown-sign terms unchanged.
-    const transformableLogTerms = logTerms.filter(t => !t.arg.isComplex() && t.arg.gt(0));
+    const transformableLogTerms = logTerms.filter(t => !t.arg.isComplex() && t.arg.gt((0, shortcuts_1.zero)()));
     if (transformableLogTerms.length === 0) {
         return x;
     }

package/output/algebra/simplify/ratsimp.js

@@ -72,7 +72,7 @@ function simplifyRadicals(x) {
                 // Principal radicals can be combined when both radicands are known nonnegative.
                 // Reciprocals still require a strictly signed base because a zero denominator
                 // cannot be admitted by the sign proof for a negative power.
-                if (!u.isComplex() && !v.isComplex() && u.gte(0) && v.gte(0)) {
+                if (!u.isComplex() && !v.isComplex() && u.gte((0, shortcuts_1.zero)()) && v.gte((0, shortcuts_1.zero)())) {
                     const multiplier = a.getMultiplier().times(b.getMultiplier());
                     if (u.isNUM() && v.isNUM()) {
                         // Preserve exact numeric reduction when the combined radicand is numeric.

package/output/algebra/simplify/simplify.js

@@ -116,8 +116,17 @@ function factorResult(x) {
     if (x.isNUM()) {
         return x;
     }
-    const num = (0, utils_1.product)(...(0, factor_1.polyFactorExpressions)(x.getNumerator()));
-    const den = (0, utils_1.product)(...(0, factor_1.polyFactorExpressions)(x.getDenominator()));
+    function rebuildFactorResult(original, factors) {
+        let retval = (0, utils_1.product)(...factors);
+        if (original.hasDecimal() && factors.length === 1 && factors[0].eq(original)) {
+            retval = original;
+        }
+        return retval;
+    }
+    const numerator = x.getNumerator();
+    const denominator = x.getDenominator();
+    const num = rebuildFactorResult(numerator, (0, factor_1.polyFactorExpressions)(numerator));
+    const den = rebuildFactorResult(denominator, (0, factor_1.polyFactorExpressions)(denominator));
     return num.div(den);
 }
 /**

package/output/algebra/utils.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../core/classes/expression/Expression';
 import type { ExpressionInput } from '../core/types';
-/** Components of a quadratic rewritten by {@link sqcomp}. */
+/** Components of a quadratic rewritten in completed-square form. */
 export interface CompleteSquareResult {
     /** Original quadratic coefficient. */
     a: Expression;

package/output/algebra/utils.js

@@ -38,11 +38,11 @@ function sqcomp(expr, variable) {
     const b = c.hasPower(1) ? c.getPower(1) : (0, shortcuts_1.zero)();
     const k0 = c.hasPower(0) ? c.getPower(0) : (0, shortcuts_1.zero)();
     // h = b / (2a)
-    const h = b.div(a.times(2));
+    const h = b.div(a.times((0, shortcuts_1.two)()));
     // k = c - b² / (4a)
-    const k = k0.minus(b.pow(2).div(a.times(4)));
+    const k = k0.minus(b.pow((0, shortcuts_1.two)()).div(a.times((0, shortcuts_1.four)())));
     // Build a*(variable + h)^2 + k
     const x = Expression_1.Expression.create(variable);
-    const expression = a.times(x.plus(h).pow(2)).plus(k);
+    const expression = a.times(x.plus(h).pow((0, shortcuts_1.two)())).plus(k);
     return { a, h, k, variable, expression };
 }

package/output/api/advanced.d.ts

@@ -1,7 +1,8 @@
 export { Groebner, GroebnerBudgetExceeded, eliminate, groebnerBasisWithOptions, idealMembership, reduceByBasis, solve as solveRationalSystem, } from '../algebra/algorithms/groebnerBase';
 export type { GroebnerBasisOptions, GroebnerStats, MonomialOrder, RationalSolution, } from '../algebra/algorithms/groebnerBase';
-export { MultiPoly } from '../algebra/algorithms/multiPoly/MultiPoly';
 /** Advanced numerical and exact-polynomial APIs. */
 export { Complex } from '../core/classes/complex/Complex';
+export { SparsePolynomial } from '../core/classes/polynomial/SparsePolynomial';
+export type { SparsePolynomialTerm } from '../core/classes/polynomial/SparsePolynomial';
 export { FunctionSolver } from '../solve/classes/FunctionSolver';
 export type { FunctionSolverOptions, Root, RootFindingMethod, } from '../solve/classes/FunctionSolver';

package/output/api/advanced.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionSolver = exports.Complex = exports.MultiPoly = exports.solveRationalSystem = exports.reduceByBasis = exports.idealMembership = exports.groebnerBasisWithOptions = exports.eliminate = exports.GroebnerBudgetExceeded = exports.Groebner = void 0;
+exports.FunctionSolver = exports.SparsePolynomial = exports.Complex = exports.solveRationalSystem = exports.reduceByBasis = exports.idealMembership = exports.groebnerBasisWithOptions = exports.eliminate = exports.GroebnerBudgetExceeded = exports.Groebner = void 0;
 var groebnerBase_1 = require("../algebra/algorithms/groebnerBase");
 Object.defineProperty(exports, "Groebner", { enumerable: true, get: function () { return groebnerBase_1.Groebner; } });
 Object.defineProperty(exports, "GroebnerBudgetExceeded", { enumerable: true, get: function () { return groebnerBase_1.GroebnerBudgetExceeded; } });
@@ -9,10 +9,10 @@ Object.defineProperty(exports, "groebnerBasisWithOptions", { enumerable: true, g
 Object.defineProperty(exports, "idealMembership", { enumerable: true, get: function () { return groebnerBase_1.idealMembership; } });
 Object.defineProperty(exports, "reduceByBasis", { enumerable: true, get: function () { return groebnerBase_1.reduceByBasis; } });
 Object.defineProperty(exports, "solveRationalSystem", { enumerable: true, get: function () { return groebnerBase_1.solve; } });
-var MultiPoly_1 = require("../algebra/algorithms/multiPoly/MultiPoly");
-Object.defineProperty(exports, "MultiPoly", { enumerable: true, get: function () { return MultiPoly_1.MultiPoly; } });
 /** Advanced numerical and exact-polynomial APIs. */
 var Complex_1 = require("../core/classes/complex/Complex");
 Object.defineProperty(exports, "Complex", { enumerable: true, get: function () { return Complex_1.Complex; } });
+var SparsePolynomial_1 = require("../core/classes/polynomial/SparsePolynomial");
+Object.defineProperty(exports, "SparsePolynomial", { enumerable: true, get: function () { return SparsePolynomial_1.SparsePolynomial; } });
 var FunctionSolver_1 = require("../solve/classes/FunctionSolver");
 Object.defineProperty(exports, "FunctionSolver", { enumerable: true, get: function () { return FunctionSolver_1.FunctionSolver; } });

package/output/api/algebra.d.ts

@@ -1,13 +1,30 @@
-/** Public symbolic algebra and polynomial APIs. */
-export { factor, polyFactors } from '../algebra/factor/factor';
+import type { CompleteSquareResult } from '../algebra/utils';
+import type { ExpressionInput } from '../core/types';
+export { factor, pfactor, pfactord, polyFactors } from '../algebra/factor/factor';
 export { gcd, lcm } from '../algebra/gcd/gcd';
 export { groebner } from '../algebra/groebner';
 export { partfrac } from '../algebra/partfrac';
 export { simplify } from '../algebra/simplify/simplify';
-export { sqcomp as completeSquare } from '../algebra/utils';
+/**
+ * Completes the square for a quadratic expression.
+ *
+ * For `a*x^2+b*x+c`, the returned expression has the form
+ * `a*(x+h)^2+k`, with `h=b/(2*a)` and `k=c-b^2/(4*a)`.
+ *
+ * @param expr - Quadratic expression to rewrite.
+ * @param variable - Variable to use. Defaults to the first variable in the expression.
+ * @returns The quadratic coefficient, shift, remainder, selected variable, and rewritten expression.
+ *
+ * @example
+ * ```ts
+ * const result = completeSquare('x^2+6*x+1');
+ * result.expression.text({ sort: true }); // "(3+x)^2-8"
+ * ```
+ */
+export declare const completeSquare: (expr: ExpressionInput, variable?: string) => CompleteSquareResult;
 export type { CompleteSquareResult } from '../algebra/utils';
 export { CoeffObject } from '../core/classes/expression/CoeffObject';
-export { content, deg } from '../core/classes/polynomial/functions';
+export { coeffs, content, deg } from '../core/classes/polynomial/functions';
 export { Polynomial } from '../core/classes/polynomial/Polynomial';
 export type { EvalInputType, Ordering, PolyType, VariableFrequency, } from '../core/classes/polynomial/Polynomial';
 export { Term } from '../core/classes/polynomial/Term';

package/output/api/algebra.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPrime = exports.uUnSub = exports.uSub = exports.Term = exports.Polynomial = exports.deg = exports.content = exports.CoeffObject = exports.completeSquare = exports.simplify = exports.partfrac = exports.groebner = exports.lcm = exports.gcd = exports.polyFactors = exports.factor = void 0;
+exports.isPrime = exports.uUnSub = exports.uSub = exports.Term = exports.Polynomial = exports.deg = exports.content = exports.coeffs = exports.CoeffObject = exports.completeSquare = exports.simplify = exports.partfrac = exports.groebner = exports.lcm = exports.gcd = exports.polyFactors = exports.pfactord = exports.pfactor = exports.factor = void 0;
 /** Public symbolic algebra and polynomial APIs. */
+const utils_1 = require("../algebra/utils");
 var factor_1 = require("../algebra/factor/factor");
 Object.defineProperty(exports, "factor", { enumerable: true, get: function () { return factor_1.factor; } });
+Object.defineProperty(exports, "pfactor", { enumerable: true, get: function () { return factor_1.pfactor; } });
+Object.defineProperty(exports, "pfactord", { enumerable: true, get: function () { return factor_1.pfactord; } });
 Object.defineProperty(exports, "polyFactors", { enumerable: true, get: function () { return factor_1.polyFactors; } });
 var gcd_1 = require("../algebra/gcd/gcd");
 Object.defineProperty(exports, "gcd", { enumerable: true, get: function () { return gcd_1.gcd; } });
@@ -14,11 +17,27 @@ var partfrac_1 = require("../algebra/partfrac");
 Object.defineProperty(exports, "partfrac", { enumerable: true, get: function () { return partfrac_1.partfrac; } });
 var simplify_1 = require("../algebra/simplify/simplify");
 Object.defineProperty(exports, "simplify", { enumerable: true, get: function () { return simplify_1.simplify; } });
-var utils_1 = require("../algebra/utils");
-Object.defineProperty(exports, "completeSquare", { enumerable: true, get: function () { return utils_1.sqcomp; } });
+/**
+ * Completes the square for a quadratic expression.
+ *
+ * For `a*x^2+b*x+c`, the returned expression has the form
+ * `a*(x+h)^2+k`, with `h=b/(2*a)` and `k=c-b^2/(4*a)`.
+ *
+ * @param expr - Quadratic expression to rewrite.
+ * @param variable - Variable to use. Defaults to the first variable in the expression.
+ * @returns The quadratic coefficient, shift, remainder, selected variable, and rewritten expression.
+ *
+ * @example
+ * ```ts
+ * const result = completeSquare('x^2+6*x+1');
+ * result.expression.text({ sort: true }); // "(3+x)^2-8"
+ * ```
+ */
+exports.completeSquare = utils_1.sqcomp;
 var CoeffObject_1 = require("../core/classes/expression/CoeffObject");
 Object.defineProperty(exports, "CoeffObject", { enumerable: true, get: function () { return CoeffObject_1.CoeffObject; } });
 var functions_1 = require("../core/classes/polynomial/functions");
+Object.defineProperty(exports, "coeffs", { enumerable: true, get: function () { return functions_1.coeffs; } });
 Object.defineProperty(exports, "content", { enumerable: true, get: function () { return functions_1.content; } });
 Object.defineProperty(exports, "deg", { enumerable: true, get: function () { return functions_1.deg; } });
 var Polynomial_1 = require("../core/classes/polynomial/Polynomial");

package/output/api/assumptions.d.ts

@@ -1,4 +1,4 @@
-export { assume, clearAssumptions, forgetAssumptionFor, getAssumptionFor, } from '../core/classes/assumption/assume';
+export { assume, clearAssumptions, forgetAssumptionFor, getAssumptionFor, getAssumptions, } from '../core/classes/assumption/assume';
 /** Public process-wide assumption APIs. */
 export { Assumption } from '../core/classes/assumption/Assumption';
 export type { AssumptionComparison, AssumptionValue, Bound, ParsedAssumption, } from '../core/classes/assumption/Assumption';

package/output/api/assumptions.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Assumption = exports.getAssumptionFor = exports.forgetAssumptionFor = exports.clearAssumptions = exports.assume = void 0;
+exports.Assumption = exports.getAssumptions = exports.getAssumptionFor = exports.forgetAssumptionFor = exports.clearAssumptions = exports.assume = void 0;
 var assume_1 = require("../core/classes/assumption/assume");
 Object.defineProperty(exports, "assume", { enumerable: true, get: function () { return assume_1.assume; } });
 Object.defineProperty(exports, "clearAssumptions", { enumerable: true, get: function () { return assume_1.clearAssumptions; } });
 Object.defineProperty(exports, "forgetAssumptionFor", { enumerable: true, get: function () { return assume_1.forgetAssumptionFor; } });
 Object.defineProperty(exports, "getAssumptionFor", { enumerable: true, get: function () { return assume_1.getAssumptionFor; } });
+Object.defineProperty(exports, "getAssumptions", { enumerable: true, get: function () { return assume_1.getAssumptions; } });
 /** Public process-wide assumption APIs. */
 var Assumption_1 = require("../core/classes/assumption/Assumption");
 Object.defineProperty(exports, "Assumption", { enumerable: true, get: function () { return Assumption_1.Assumption; } });

package/output/api/calculus.d.ts

@@ -6,4 +6,5 @@ export { ilaplace } from '../calculus/laplace/ilaplace';
 export { laplace } from '../calculus/laplace/laplace';
 export { limit } from '../calculus/limit/limit';
 export type { LimitDir } from '../calculus/limit/limit';
-export { defint, product, sum } from '../math/math';
+export { defint } from '../math/defint/defint';
+export { product, sum } from '../math/math';

package/output/api/calculus.js

@@ -15,7 +15,8 @@ var laplace_1 = require("../calculus/laplace/laplace");
 Object.defineProperty(exports, "laplace", { enumerable: true, get: function () { return laplace_1.laplace; } });
 var limit_1 = require("../calculus/limit/limit");
 Object.defineProperty(exports, "limit", { enumerable: true, get: function () { return limit_1.limit; } });
+var defint_1 = require("../math/defint/defint");
+Object.defineProperty(exports, "defint", { enumerable: true, get: function () { return defint_1.defint; } });
 var math_1 = require("../math/math");
-Object.defineProperty(exports, "defint", { enumerable: true, get: function () { return math_1.defint; } });
 Object.defineProperty(exports, "product", { enumerable: true, get: function () { return math_1.product; } });
 Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return math_1.sum; } });

package/output/api/core.d.ts

@@ -1,9 +1,4 @@
-/**
- * Core Nerdamer object model and shared public types.
- *
- * Import from `nerdamer/core` when working directly with Nerdamer values rather
- * than through the callable compatibility root.
- */
+import type { ExpressionInput } from '../core/types';
 export { Equation } from '../core/classes/equation/Equation';
 export { CoeffObject } from '../core/classes/expression/CoeffObject';
 export { Expression } from '../core/classes/expression/Expression';
@@ -13,5 +8,31 @@ export type { JsFunction, OptionValue, OptionsObject, ParserConstants, ParserVal
 export { Rational } from '../core/classes/rational/Rational';
 export { Converter } from '../core/converters/Converter';
 export { AssignmentError, DimensionError, DivisionByZeroError, MathError, MissingReferenceError, NaNError, NotImplementedError, OperatorError, ParserError, ParserSyntaxError, PolynomialError, UndefinedError, UnexpectedDataType, UnexpectedInputError, UnexpectedTokenError, UnsupportedOperationError, ZeroToZeroPowerError, } from '../core/errors';
-export { build as buildFunction } from '../core/functions/build';
+/**
+ * Compiles an expression into a native JavaScript-number function for repeated evaluation.
+ *
+ * @remarks
+ * Function calls are linked to Nerdamer's numerical implementations, including any dependencies
+ * they require. The compiler supports scalar JavaScript-number arithmetic rather than Nerdamer's
+ * full symbolic or structured value model. Symbolic-only operations such as indexed sums,
+ * products, solvers, and matrix operations are rejected if they remain in the expression.
+ *
+ * `buildFunction` uses `new Function`, so it may be unavailable under a Content Security Policy
+ * that forbids dynamic JavaScript evaluation. When `argsArray` is omitted, free variables are
+ * sorted alphabetically.
+ *
+ * @param x - The expression to compile.
+ * @param argsArray - Variable names in the positional order expected by the compiled function.
+ * @returns The compiled JavaScript-number function.
+ * @throws {@link core!UnsupportedOperationError} If the expression contains the imaginary unit or a
+ * function for which no matching JavaScript-number implementation is registered.
+ *
+ * @example
+ * ```ts
+ * buildFunction('x-y')(9, 7);                // 2
+ * buildFunction('x-y', ['y', 'x'])(9, 7);    // -2
+ * buildFunction('erf(x)+2')(9);              // 3
+ * ```
+ */
+export declare const buildFunction: (x: ExpressionInput, argsArray?: string[]) => (...args: number[]) => number;
 export type { ExpressionInput, NerdamerInput, ParserEntity, StructuredEntityType, } from '../core/types';