nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/classes/polynomial/functions.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deg = deg;
+exports.content = content;
+exports.coeffs = coeffs;
+exports.div = div;
+exports.divide = divide;
+const Expression_1 = require("../expression/Expression");
+const shortcuts_1 = require("../expression/shortcuts");
+const utils_1 = require("../expression/utils");
+const constants_1 = require("../parser/constants");
+const Vector_1 = require("../vector/Vector");
+const Polynomial_1 = require("./Polynomial");
+const SparsePolynomialAdapter_1 = require("./SparsePolynomialAdapter");
+const utils_2 = require("./utils");
+/**
+ * Returns the degree of a polynomial expression.
+ *
+ * @remarks
+ * With no variable, `deg(p)` returns the total degree: the largest sum of powers in any
+ * term. With a variable, `deg(p, x)` returns the largest power of `x`, treating the other
+ * variables as coefficients. If the input cannot be converted to a polynomial, the call
+ * remains symbolic instead of throwing.
+ *
+ * @param x - Expression-like input or polynomial to inspect.
+ * @param variable - Optional variable whose degree should be returned.
+ * @returns A numeric expression for polynomial input, otherwise an unevaluated `deg(...)` call.
+ *
+ * @example
+ * ```ts
+ * deg('x^2*y^3+x').text();      // "5"
+ * deg('x^2*y^3+x', 'x').text(); // "2"
+ * deg('x^2*y^3+x', 'y').text(); // "3"
+ * ```
+ */
+function deg(x, variable) {
+    let variableExpression;
+    let variableName;
+    if (variable !== undefined) {
+        variableExpression = Expression_1.Expression.create(variable);
+        variableName = (0, utils_1.assertPlainVariableAndGetString)(variableExpression);
+    }
+    let retval = undefined;
+    if (Polynomial_1.Polynomial.isPolynomial(x)) {
+        retval = Expression_1.Expression.create(x.deg(variableName));
+    }
+    else {
+        const inputExpression = Expression_1.Expression.create(x);
+        try {
+            const variables = inputExpression.variables().sort();
+            const converted = (0, SparsePolynomialAdapter_1.expressionToIntegerSparsePolynomial)(inputExpression, variables);
+            let degree;
+            if (variableName === undefined) {
+                degree = converted.polynomial.totalDegree() ?? 0n;
+            }
+            else {
+                const variableIndex = variables.indexOf(variableName);
+                degree =
+                    variableIndex === -1
+                        ? 0n
+                        : (converted.polynomial.degree(variableIndex) ?? 0n);
+            }
+            retval = Expression_1.Expression.Number(degree);
+        }
+        catch {
+            try {
+                retval = Expression_1.Expression.create(new Polynomial_1.Polynomial(inputExpression).deg(variableName));
+            }
+            catch { }
+        }
+    }
+    const input = Polynomial_1.Polynomial.isPolynomial(x) ? x.getExpression() : x;
+    const args = variableExpression === undefined ? [input] : [input, variableExpression];
+    return retval ?? Expression_1.Expression.toFunction(constants_1.DEG, args);
+}
+/**
+ * Returns the exact numeric content of polynomial expression input.
+ *
+ * @remarks
+ * Content means the greatest common divisor of the polynomial's numeric coefficients.
+ * For example, the content of `6*x^2+15*x*y-3*y` is `3`. This function does not choose
+ * a main variable or compute a polynomial-valued GCD of symbolic coefficient expressions.
+ * If expression conversion fails, the operation remains symbolic as `content(input)`.
+ *
+ * @param x - Expression-like input or polynomial to inspect.
+ * @returns A numeric expression for converted input, otherwise an unevaluated symbolic
+ * `content` call.
+ *
+ * @example
+ * ```ts
+ * content('6*x^2+15*x-3').text(); // "3"
+ * ```
+ */
+function content(x) {
+    let retval = undefined;
+    if (Polynomial_1.Polynomial.isPolynomial(x)) {
+        retval = Expression_1.Expression.create(x.content());
+    }
+    else {
+        const inputExpression = Expression_1.Expression.create(x);
+        try {
+            if (inputExpression.isZero()) {
+                retval = Expression_1.Expression.create(new Polynomial_1.Polynomial(inputExpression).content());
+            }
+            else {
+                const variables = inputExpression.variables().sort();
+                const converted = (0, SparsePolynomialAdapter_1.expressionToIntegerSparsePolynomial)(inputExpression, variables);
+                retval = Expression_1.Expression.Number(converted.polynomial.content()).div(Expression_1.Expression.Number(converted.denominator));
+                retval.getMultiplier().asDecimal = inputExpression.hasDecimal();
+            }
+        }
+        catch {
+            try {
+                retval = Expression_1.Expression.create(new Polynomial_1.Polynomial(inputExpression).content());
+            }
+            catch { }
+        }
+    }
+    return retval ?? Expression_1.Expression.toFunction(constants_1.CONTENT, [Polynomial_1.Polynomial.isPolynomial(x) ? x.getExpression() : x]);
+}
+/**
+ * Returns polynomial coefficients as a dense Vector ordered by ascending power.
+ *
+ * When no variable is supplied, the first variable in the expression is used, matching
+ * the legacy parser helper. A constant expression therefore has the single coefficient
+ * at power zero.
+ */
+function coeffs(x, variable) {
+    const expression = Expression_1.Expression.create(x);
+    let variableName;
+    if (variable !== undefined) {
+        variableName = (0, utils_1.assertPlainVariableAndGetString)(Expression_1.Expression.create(variable));
+    }
+    else {
+        variableName = expression.variables()[0];
+    }
+    return variableName === undefined
+        ? new Vector_1.Vector([expression.copy()])
+        : expression.coeffs(variableName).toVector();
+}
+/**
+ * Returns the quotient and remainder of polynomial division.
+ *
+ * @remarks
+ * This is the parser-facing compatibility behavior historically exposed as `div(a,b)`.
+ * It delegates to the existing polynomial division implementation. When more than one
+ * variable is present, Nerdamer treats the input as a multivariable polynomial rather than
+ * silently choosing one variable and treating the others as coefficients. If either input
+ * is not polynomial-like, the legacy fallback is preserved as `[0, dividend]`. Once both
+ * inputs are polynomial, failures from the division engine are allowed to propagate.
+ */
+function div(dividend, divisor) {
+    const numerator = Expression_1.Expression.create(dividend);
+    const denominator = Expression_1.Expression.create(divisor);
+    let retval;
+    if (numerator.isPolynomialLike() && denominator.isPolynomialLike()) {
+        const [quotient, remainder] = (0, utils_2.divide)(numerator, denominator);
+        retval = new Vector_1.Vector([quotient, remainder]);
+    }
+    else {
+        retval = new Vector_1.Vector([(0, shortcuts_1.zero)(), numerator]);
+    }
+    return retval;
+}
+/**
+ * Divides two expressions using polynomial quotient/remainder reconstruction when possible.
+ *
+ * @remarks
+ * This restores the parser-facing compatibility behavior historically exposed as
+ * `divide(a,b)`: a successful polynomial division is returned as
+ * `quotient + remainder/divisor`, so the result is a reusable symbolic expression. When
+ * more than one variable is present, Nerdamer treats the input as a multivariable polynomial
+ * rather than silently choosing a main variable. Inputs outside the polynomial domain fall
+ * back to ordinary symbolic division. Once both inputs are polynomial, failures from the
+ * division engine are allowed to propagate.
+ */
+function divide(dividend, divisor) {
+    const numerator = Expression_1.Expression.create(dividend);
+    const denominator = Expression_1.Expression.create(divisor);
+    let retval;
+    if (numerator.isPolynomialLike() && denominator.isPolynomialLike()) {
+        const [quotient, remainder] = (0, utils_2.divide)(numerator, denominator);
+        retval = quotient.plus(remainder.div(denominator));
+    }
+    else {
+        retval = numerator.div(denominator);
+    }
+    return retval;
+}

package/output/core/classes/polynomial/utils.d.ts

@@ -0,0 +1,62 @@
+import { Polynomial } from './Polynomial';
+import type { Expression } from '../expression/Expression';
+import type { Ordering, PolyType } from './Polynomial';
+/**
+ * Divides a polynomial by given list of divisors
+ * See - Ideals Varieties and Algorithms 4th ed. p.81
+ *
+ * @param Fs The array of divisors
+ * @param g The dividend
+ * @param ordering The ordering to be used (optional).
+ * @returns
+ */
+export declare function polyDiv(Fs: PolyType[], g: PolyType, ordering?: Ordering, variables?: string[]): [Expression[], Expression];
+/**
+ * Divides one polynomial by another
+ *
+ * @param f The dividend
+ * @param g The divisor
+ * @param ordering The ordering to be used (optional).
+ * @returns [The quotient, The remainder]
+ */
+export declare function divide(f: PolyType, g: PolyType, ordering?: Ordering, variables?: string[]): Expression[];
+/**
+ * Computes the S-Polynomial given two polynomials
+ *
+ * @param f
+ * @param g
+ * @param ordering
+ * @param variables
+ * @returns
+ */
+export declare function S(f: PolyType, g: PolyType, ordering?: Ordering, variables?: string[]): Polynomial;
+/**
+ * Combines all the variables of a set of polynomials
+ *
+ * @param F
+ * @returns
+ */
+export declare function combinePolynomialVariables(F: Polynomial[]): string[];
+/**
+ * Calculates the polynomial modulus of two polynomials as f mod g
+ *
+ * @param f
+ * @param g
+ * @param ordering
+ * @param variables
+ * @returns
+ */
+export declare function polyMod(f: PolyType, g: PolyType, ordering?: Ordering, variables?: string[]): Polynomial;
+export declare function maxCommonVariableOccurrence(f: PolyType, g: PolyType): string | undefined;
+/**
+ * Convert number to polynomial form.
+ * e.g. polynomialFromNumber (89, 1) = [8, 9] = 8*x+9
+ * e.g. polynomialFromNumber (89, 2) = [1, -1, -1] = x^2-x-1
+ * Try (x+4)(x+5)
+ *
+ * @param n The number
+ * @param p The power of the lead monomial
+ * @param base The base to use for the polynomial. Default = 10
+ * @returns
+ */
+export declare function polynomialFromNumber(n: number, p: number, base?: number, startingCoeff?: number, endingCoeff?: number): number[];

package/output/core/classes/polynomial/utils.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polyDiv = polyDiv;
+exports.divide = divide;
+exports.S = S;
+exports.combinePolynomialVariables = combinePolynomialVariables;
+exports.polyMod = polyMod;
+exports.maxCommonVariableOccurrence = maxCommonVariableOccurrence;
+exports.polynomialFromNumber = polynomialFromNumber;
+const errors_1 = require("../../errors");
+const utils_1 = require("../../functions/utils");
+const shortcuts_1 = require("../expression/shortcuts");
+const Polynomial_1 = require("./Polynomial");
+function normalizePolynomialInputs(inputs, ordering, variables) {
+    const provisional = inputs.map(input => Polynomial_1.Polynomial.toPolynomial(input, ordering, variables));
+    if (variables !== undefined) {
+        return {
+            polynomials: provisional,
+            variables,
+        };
+    }
+    const resolvedVariables = combinePolynomialVariables(provisional);
+    if (resolvedVariables.length === 0) {
+        return {
+            polynomials: provisional,
+            variables: undefined,
+        };
+    }
+    return {
+        polynomials: inputs.map(input => Polynomial_1.Polynomial.toPolynomial(input, ordering, resolvedVariables)),
+        variables: resolvedVariables,
+    };
+}
+/**
+ * Divides a polynomial by given list of divisors
+ * See - Ideals Varieties and Algorithms 4th ed. p.81
+ *
+ * @param Fs The array of divisors
+ * @param g The dividend
+ * @param ordering The ordering to be used (optional).
+ * @returns
+ */
+function polyDiv(Fs, g, ordering, variables) {
+    const { polynomials } = normalizePolynomialInputs([...Fs, g], ordering, variables);
+    const F = polynomials.slice(0, Fs.length);
+    let p = polynomials[Fs.length].order(ordering);
+    // The collection of q's to be returned
+    const qArray = Fs.map(() => {
+        return (0, shortcuts_1.zero)();
+    });
+    let r = (0, shortcuts_1.zero)();
+    let iter = 0;
+    const maxIter = Fs.length * 1000;
+    // Begin
+    while (!p.isZero()) {
+        if (iter++ > maxIter) {
+            throw new Error((0, errors_1.message)('polynomialMaximumIterations'));
+        }
+        let divisionOccurred = false;
+        const s = F.length;
+        let i = 0; // Use zero since TS arrays are zero based
+        while (i < s && !divisionOccurred) {
+            const fi = F[i];
+            const fiLT = fi.LT();
+            const pLT = p.LT();
+            if (fiLT.divides(pLT)) {
+                const q = pLT.div(fiLT);
+                qArray[i] = qArray[i].plus(q.getExpression());
+                // Guarantees a reduction at each step
+                p = p.minus(fi.times(q)).order(ordering);
+                divisionOccurred = true;
+            }
+            else {
+                i++;
+            }
+        }
+        const pLT = p.LT();
+        if (!divisionOccurred) {
+            r = r.plus(pLT.getExpression());
+            p = p.minus(pLT).order(ordering);
+        }
+    }
+    return [qArray, r];
+}
+/**
+ * Divides one polynomial by another
+ *
+ * @param f The dividend
+ * @param g The divisor
+ * @param ordering The ordering to be used (optional).
+ * @returns [The quotient, The remainder]
+ */
+function divide(f, g, ordering, variables) {
+    const [quo, rem] = polyDiv([g], f, ordering, variables);
+    return [quo[0], rem];
+}
+/**
+ * Computes the S-Polynomial given two polynomials
+ *
+ * @param f
+ * @param g
+ * @param ordering
+ * @param variables
+ * @returns
+ */
+function S(f, g, ordering, variables) {
+    const { polynomials: [p, q], } = normalizePolynomialInputs([f, g], ordering, variables);
+    const pLT = p.LT();
+    const qLT = q.LT();
+    const xg = pLT.LCM(qLT);
+    return p.times(xg.div(pLT)).minus(q.times(xg.div(qLT)));
+}
+/**
+ * Combines all the variables of a set of polynomials
+ *
+ * @param F
+ * @returns
+ */
+function combinePolynomialVariables(F) {
+    let variables = [];
+    F.forEach(f => {
+        variables = (0, utils_1.arrayAddUnique)(variables, f.variables);
+    });
+    variables.sort();
+    return variables;
+}
+/**
+ * Calculates the polynomial modulus of two polynomials as f mod g
+ *
+ * @param f
+ * @param g
+ * @param ordering
+ * @param variables
+ * @returns
+ */
+function polyMod(f, g, ordering, variables) {
+    const { variables: resolvedVariables } = normalizePolynomialInputs([f, g], ordering, variables);
+    const [, rem] = divide(f, g, ordering, resolvedVariables);
+    return Polynomial_1.Polynomial.toPolynomial(rem, ordering, resolvedVariables).order(ordering);
+}
+function maxCommonVariableOccurrence(f, g) {
+    const a = Polynomial_1.Polynomial.toPolynomial(f).maxVariableFrequency();
+    const b = Polynomial_1.Polynomial.toPolynomial(g).maxVariableFrequency();
+    // At this point any variable will do as long as it occurs in both a and b
+    for (const x in a) {
+        if (x in b) {
+            return x;
+        }
+    }
+}
+/**
+ * Convert number to polynomial form.
+ * e.g. polynomialFromNumber (89, 1) = [8, 9] = 8*x+9
+ * e.g. polynomialFromNumber (89, 2) = [1, -1, -1] = x^2-x-1
+ * Try (x+4)(x+5)
+ *
+ * @param n The number
+ * @param p The power of the lead monomial
+ * @param base The base to use for the polynomial. Default = 10
+ * @returns
+ */
+function polynomialFromNumber(n, p, base = 10, startingCoeff, endingCoeff) {
+    const remainder = function (a, b) {
+        if (a === 0) {
+            return 0;
+        }
+        return Math.abs(a) < Math.abs(b) ? -(b % a) : a % b;
+    };
+    const coeffs = [];
+    for (let i = p; i >= 0; i--) {
+        // Calculate the base
+        const m = base ** i;
+        // console.log(`m: ${m}, n: ${n}`)
+        // Get the mod. This will be negative if the
+        const rem = remainder(n, m);
+        const d = n - rem;
+        const coeff = d / m;
+        if (i === p && (coeff < 1 || startingCoeff !== undefined)) {
+            const c = startingCoeff || 1;
+            coeffs.push(c);
+            n -= c * m;
+            continue;
+        }
+        // Avoid fractions as coefficients
+        if (Math.abs(d) < Math.abs(m)) {
+            coeffs.push(0);
+        }
+        else {
+            // console.log(`d: ${d}, rem: ${rem}, n: ${n}, coeff: ${coeff}`)
+            // Push the coefficient
+            coeffs.push(coeff);
+            // Point to the remainder as the new number
+            n = rem;
+        }
+    }
+    // Adjust if the ending coeff is provided. If it cannot be adjusted then the current
+    // constant will be used
+    if (endingCoeff !== undefined) {
+        const lastIndex = coeffs.length - 1;
+        const newCoeff = coeffs[lastIndex] - endingCoeff;
+        if (newCoeff % base === 0) {
+            coeffs[lastIndex] = endingCoeff;
+            coeffs[lastIndex - 1] += newCoeff / base;
+        }
+    }
+    return coeffs.reverse();
+}