nerdamer 2.0.0-rc.1 → 2.0.0

package/dist/bundle.js.LICENSE.txt

@@ -1,7 +1,7 @@
 /*!
-   *  decimal.js v10.6.0
-   *  An arbitrary-precision Decimal type for JavaScript.
-   *  https://github.com/MikeMcl/decimal.js
-   *  Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
-   *  MIT Licence
-   */
+ *  decimal.js v10.6.0
+ *  An arbitrary-precision Decimal type for JavaScript.
+ *  https://github.com/MikeMcl/decimal.js
+ *  Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
+ *  MIT Licence
+ */

package/output/algebra/adapters.d.ts

@@ -1,33 +1,3 @@
-import { Expression } from '../core/classes/expression/Expression';
-import { Polynomial } from '../core/classes/polynomial/Polynomial';
-import { MultiPoly } from './algorithms/multiPoly/MultiPoly';
-import type { PolyType } from '../core/classes/polynomial/Polynomial';
-import type { FactorsObject } from './algorithms/factor';
-/**
- * Converts a polynomial to a MultiPoly to be used with the polynomial algorithms.
- *
- * @param p The polynomial to be converted.
- * @param variables Optional variable order.
- * @returns The MultiPoly and variable order used for its term keys.
- */
-export declare function polynomialToMultiPoly(p: PolyType, variables?: string[]): {
-    poly: MultiPoly;
-    variables: string[];
-};
-export declare function multiPolyToExpression(poly: MultiPoly, variables: string[]): Expression;
-/**
- * Converts the factored Expression or Polynomial to an array of Expressions.
- *
- * @param factorObj The integer polynomial factors.
- * @param variables The variable order used by each factor.
- * @returns Expression factors including non-unit content.
- */
-export declare function factorsToExpressions(factorObj: FactorsObject, variables: string[]): Expression[];
-/**
- * Converts the factored Expression or Polynomial to an array of Polynomials.
- *
- * @param factorsObj The integer polynomial factors.
- * @param variables The variable order used by each factor.
- * @returns Polynomial wrappers around the converted factors.
- */
-export declare function factorsToPolynomials(factorsObj: FactorsObject, variables: string[]): Polynomial[];
+import type { Expression } from '../core/classes/expression/Expression';
+/** Completes the square and returns the expression expected by parser notation. */
+export declare function completeSquare(expr: Expression, variable?: Expression): Expression;

package/output/algebra/adapters.js

@@ -1,109 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.polynomialToMultiPoly = polynomialToMultiPoly;
-exports.multiPolyToExpression = multiPolyToExpression;
-exports.factorsToExpressions = factorsToExpressions;
-exports.factorsToPolynomials = factorsToPolynomials;
-const Expression_1 = require("../core/classes/expression/Expression");
-const shortcuts_1 = require("../core/classes/expression/shortcuts");
-const Polynomial_1 = require("../core/classes/polynomial/Polynomial");
-const MultiPoly_1 = require("./algorithms/multiPoly/MultiPoly");
-/**
- * Converts a polynomial to a MultiPoly to be used with the polynomial algorithms.
- *
- * @param p The polynomial to be converted.
- * @param variables Optional variable order.
- * @returns The MultiPoly and variable order used for its term keys.
- */
-function polynomialToMultiPoly(p, variables) {
-    p = Polynomial_1.Polynomial.toPolynomial(p);
-    const poly = new MultiPoly_1.MultiPoly();
-    variables = variables ?? p.variables;
-    for (const term of p.terms) {
-        const keyElements = [];
-        for (let i = 0; i < variables.length; i++) {
-            const power = term.powers[variables[i]];
-            // Don't add zero powers or undefined powers
-            if (!power) {
-                continue;
-            }
-            // Generate the key which is nothing more than index:power
-            keyElements.push(`${i}:${power}`);
-        }
-        const key = keyElements.join(',');
-        poly.terms.set(key, term.coeff.getMultiplier().numerator);
-    }
-    return { poly, variables };
-}
-function multiPolyToExpression(poly, variables) {
-    let retval;
-    if (poly.terms.size === 0) {
-        retval = (0, shortcuts_1.zero)();
-    }
-    else {
-        let result;
-        for (const [key, coeff] of poly.terms) {
-            // Build the coefficient as an Expression directly
-            let term = Expression_1.Expression.Number(coeff);
-            // Multiply by each variable raised to its power
-            if (key !== '') {
-                for (const part of key.split(',')) {
-                    const [varIndex, power] = part.split(':');
-                    const v = Expression_1.Expression.Variable(variables[+varIndex]);
-                    term = term.times(power === '1' ? v : v.pow(Expression_1.Expression.Number(power)));
-                }
-            }
-            // Accumulate into sum
-            result = result === undefined ? term : result.plus(term);
-        }
-        retval = result ?? (0, shortcuts_1.zero)();
-    }
+exports.completeSquare = completeSquare;
+const utils_1 = require("../core/classes/expression/utils");
+const utils_2 = require("./utils");
+/** Completes the square and returns the expression expected by parser notation. */
+function completeSquare(expr, variable) {
+    const variableName = variable === undefined ? undefined : (0, utils_1.assertPlainVariableAndGetString)(variable);
+    const retval = (0, utils_2.sqcomp)(expr, variableName).expression;
     return retval;
 }
-/**
- * Converts a PolyFactor to an Expression object.
- *
- * @param factor The factor to convert.
- * @param variables The variable order used by the factor's MultiPoly.
- * @returns The equivalent Expression.
- */
-function makeExpression(factor, variables) {
-    // The terms of each factor
-    let exp = multiPolyToExpression(factor.poly, variables);
-    // Add back the power
-    if (factor.multiplicity > 1n) {
-        exp = exp.pow(Expression_1.Expression.Number(factor.multiplicity));
-    }
-    return exp;
-}
-/**
- * Converts the factored Expression or Polynomial to an array of Expressions.
- *
- * @param factorObj The integer polynomial factors.
- * @param variables The variable order used by each factor.
- * @returns Expression factors including non-unit content.
- */
-function factorsToExpressions(factorObj, variables) {
-    const factors = [];
-    // set the terms
-    // Add the content
-    if (factorObj.content !== 1n) {
-        factors.push(Expression_1.Expression.Number(factorObj.content));
-    }
-    // Now the factors
-    for (const factor of factorObj.factors) {
-        const f = makeExpression(factor, variables);
-        factors.push(f);
-    }
-    return factors;
-}
-/**
- * Converts the factored Expression or Polynomial to an array of Polynomials.
- *
- * @param factorsObj The integer polynomial factors.
- * @param variables The variable order used by each factor.
- * @returns Polynomial wrappers around the converted factors.
- */
-function factorsToPolynomials(factorsObj, variables) {
-    return factorsToExpressions(factorsObj, variables).map(e => new Polynomial_1.Polynomial(e));
-}

package/output/algebra/algorithms/arith.js

@@ -22,6 +22,7 @@ exports.modInv = modInv;
 exports.contentBigint = contentBigint;
 exports.bigintBitLength = bigintBitLength;
 exports.nextPrime32 = nextPrime32;
+const errors_1 = require("../../core/errors");
 /**
  * Shared integer + modular arithmetic primitives used across Zippel GCD and
  * multivariate factorization.
@@ -57,7 +58,7 @@ function gcd(a, b) {
  */
 function pow(base, exp) {
     if (exp < 0n) {
-        throw new Error('pow: negative exponent');
+        throw new Error((0, errors_1.message)('arithPowNegativeExponent'));
     }
     let b = base;
     let e = exp;
@@ -79,7 +80,7 @@ function pow(base, exp) {
  */
 function powN(base, exp) {
     if (!Number.isInteger(exp) || exp < 0) {
-        throw new Error('powN: exponent must be a nonnegative integer');
+        throw new Error((0, errors_1.message)('arithPowNNonnegativeInteger'));
     }
     return pow(base, BigInt(exp));
 }
@@ -91,7 +92,7 @@ function powN(base, exp) {
  */
 function bigIntSqrt(n) {
     if (n < 0n) {
-        throw new Error('bigIntSqrt: negative input');
+        throw new Error((0, errors_1.message)('arithBigIntSqrtNegative'));
     }
     if (n < 2n) {
         return n;
@@ -111,7 +112,7 @@ function bigIntSqrt(n) {
  */
 function intNthRootExact(value, n) {
     if (!Number.isInteger(n) || n <= 0) {
-        throw new Error('intNthRootExact: n must be a positive integer');
+        throw new Error((0, errors_1.message)('arithNthRootPositiveInteger'));
     }
     if (value < 0n) {
         // Only odd roots exist for negative values.
@@ -156,7 +157,7 @@ function intNthRootExact(value, n) {
  */
 function getDivisors(n) {
     if (n <= 0n) {
-        throw new Error('getDivisors: n must be positive');
+        throw new Error((0, errors_1.message)('arithDivisorsPositive'));
     }
     const out = [];
     const r = bigIntSqrt(n);
@@ -195,7 +196,7 @@ function egcd(a, b) {
 /** Normalize a into the range [0, |p|). Throws if p is zero. */
 function modNorm(a, p) {
     if (p === 0n) {
-        throw new Error('modNorm: modulus must be nonzero');
+        throw new Error((0, errors_1.message)('arithModNormNonzeroModulus'));
     }
     const m = abs(p);
     const r = a % m;
@@ -204,7 +205,7 @@ function modNorm(a, p) {
 /** Map a to the symmetric residue class (-|p|/2, |p|/2]. */
 function modSymmetric(a, p) {
     if (p === 0n) {
-        throw new Error('modSymmetric: modulus must be nonzero');
+        throw new Error((0, errors_1.message)('arithModSymmetricNonzeroModulus'));
     }
     const m = abs(p);
     const r = modNorm(a, m);
@@ -215,11 +216,11 @@ function modSymmetric(a, p) {
 function modInv(a, p) {
     const aa = modNorm(a, p);
     if (aa === 0n) {
-        throw new Error('modInv: non-invertible (0)');
+        throw new Error((0, errors_1.message)('arithModInvZeroNoninvertible'));
     }
     const { g, x } = egcd(aa, p);
     if (g !== 1n && g !== -1n) {
-        throw new Error('modInv: non-invertible');
+        throw new Error((0, errors_1.message)('arithModInvNoninvertible'));
     }
     return modNorm(x, p);
 }

package/output/algebra/algorithms/groebnerBase.d.ts

@@ -11,8 +11,16 @@
  * - elimination ideals
  * - ideal membership testing
  * - triangular back-substitution solver
+ *
+ * External references consulted:
+ * - SymPy Gröbner basis implementation:
+ *   https://github.com/sympy/sympy/blob/120ee85f346f6292b763cc195afda4f907260d4a/sympy/polys/groebnertools.py
+ * - Giovini, Mora, Niesi, Robbiano, Traverso, "One Sugar Cube, Please":
+ *   https://doi.org/10.1145/120694.120701
+ * - Bigatti, Caboara, Robbiano, "Computing inhomogeneous Gröbner bases":
+ *   https://doi.org/10.1016/j.jsc.2010.10.002
  */
-import { MultiPoly } from './multiPoly/MultiPoly';
+import { SparsePolynomial } from '../../core/classes/polynomial/SparsePolynomial';
 /** Monomial order used for leading terms, pair processing, and reduction. */
 export type MonomialOrder = 'LEX' | 'GRLEX' | 'GREVLEX';
 /** Deterministic work counters captured when a Groebner resource budget is exceeded. */
@@ -64,33 +72,30 @@ export declare class GroebnerBudgetExceeded extends Error {
     constructor(message: string, stats: GroebnerStats);
 }
 /**
- * Computes a Groebner basis for an exact integer-coefficient ideal.
+ * Computes a Groebner basis for exact sparse integer polynomials.
  *
- * @remarks
- * Variable indices in every {@link MultiPoly} must agree with `vars`. The Buchberger
- * engine uses fraction-free reduction. With `reduced: true`, it interreduces, removes
- * coefficient content, normalizes leading signs, and makes a polynomial monic only
- * when exact integer division permits it. The returned basis is sorted deterministically,
- * and the routine works from normalized copies rather than editing the supplied generators.
+ * The input polynomials must belong to the same ring. With `reduced: true`, the
+ * basis is interreduced, coefficient content is removed, leading signs are normalized,
+ * and exact monic normalization is applied when possible. Results are sorted
+ * deterministically and the supplied polynomials are not modified.
  *
- * @param polys - Ideal generators over integer coefficients.
- * @param vars - Variable names aligned with exponent indices.
+ * @param polys - Ideal generators in one sparse polynomial ring.
  * @param order - Monomial order; defaults to `LEX`.
  * @param reduced - Return the normalized/interreduced basis; defaults to `true`.
- * @returns New basis polynomials in deterministic presentation order.
+ * @returns New sparse basis polynomials in deterministic presentation order.
  */
-export declare function Groebner(polys: MultiPoly[], vars: string[], order?: MonomialOrder, reduced?: boolean): MultiPoly[];
+export declare function Groebner(polys: readonly SparsePolynomial[], order?: MonomialOrder, reduced?: boolean): SparsePolynomial[];
 /**
  * Computes a Groebner basis with ordering, strategy, and budget control.
  *
- * @param polys - Exact integer-coefficient generators with consistent variable indices.
+ * @param polys - Exact sparse integer-coefficient generators in one ring.
  * @param opts - Ordering, normalization, pair-selection, and deterministic budget options.
  * @returns New basis polynomials. Work statistics are exposed only when a budget is
  * exceeded; successful calls return the basis itself.
  * @throws {@link GroebnerBudgetExceeded} Thrown after a configured pair-count or
  * basis-size limit is exceeded.
  */
-export declare function groebnerBasisWithOptions(polys: readonly MultiPoly[], opts?: GroebnerBasisOptions): MultiPoly[];
+export declare function groebnerBasisWithOptions(polys: readonly SparsePolynomial[], opts?: GroebnerBasisOptions): SparsePolynomial[];
 /**
  * Computes the part of the ideal that lies in the polynomial ring generated by `keepVars`.
  *
@@ -102,7 +107,7 @@ export declare function groebnerBasisWithOptions(polys: readonly MultiPoly[], op
  * @returns New basis polynomials involving only retained variables.
  * @throws {@link GroebnerBudgetExceeded} Thrown when a configured budget is exceeded.
  */
-export declare function eliminate(polys: MultiPoly[], vars: string[], keepVars: string[], opts?: Omit<GroebnerBasisOptions, 'order'>): MultiPoly[];
+export declare function eliminate(polys: readonly SparsePolynomial[], vars: readonly string[], keepVars: readonly string[], opts?: Omit<GroebnerBasisOptions, 'order'>): SparsePolynomial[];
 /**
  * Tests exact ideal membership by reducing against a computed Groebner basis.
  *
@@ -113,21 +118,20 @@ export declare function eliminate(polys: MultiPoly[], vars: string[], keepVars:
  * @returns Whether the normal form of `f` is zero.
  * @throws {@link GroebnerBudgetExceeded} Thrown when basis computation exceeds a budget.
  */
-export declare function idealMembership(f: MultiPoly, polys: MultiPoly[], order?: MonomialOrder, opts?: Omit<GroebnerBasisOptions, 'order' | 'reduced'>): boolean;
+export declare function idealMembership(f: SparsePolynomial, polys: readonly SparsePolynomial[], order?: MonomialOrder, opts?: Omit<GroebnerBasisOptions, 'order' | 'reduced'>): boolean;
 /**
  * Reduces a polynomial by a basis or arbitrary reducer set using fraction-free arithmetic.
  *
  * @remarks
  * This does not compute or verify a Groebner basis. The result is a canonical ideal
- * normal form only when `basis` is already a basis for the selected order. Reduction
- * works from normalized polynomial copies, leaving the supplied objects alone.
+ * normal form only when `basis` is already a basis for the selected order.
  *
  * @param f - Polynomial to reduce.
  * @param basis - Reducers, normally a Groebner basis.
  * @param order - Monomial order used to select leading terms.
  * @returns The primitive-normalized remainder.
  */
-export declare function reduceByBasis(f: MultiPoly, basis: readonly MultiPoly[], order?: MonomialOrder): MultiPoly;
+export declare function reduceByBasis(f: SparsePolynomial, basis: readonly SparsePolynomial[], order?: MonomialOrder): SparsePolynomial;
 /**
  * Maps each solved variable to a reduced rational numerator/denominator pair.
  *
@@ -154,4 +158,4 @@ export type RationalSolution = Map<string, {
  * or a non-finite/unsupported triangular result; these cases are not distinguished.
  * @throws {@link GroebnerBudgetExceeded} Thrown when basis computation exceeds a budget.
  */
-export declare function solve(polys: MultiPoly[], vars: string[], opts?: Omit<GroebnerBasisOptions, 'order' | 'reduced'>): RationalSolution[];
+export declare function solve(polys: readonly SparsePolynomial[], vars: readonly string[], opts?: Omit<GroebnerBasisOptions, 'order' | 'reduced'>): RationalSolution[];