nerdamer 1.1.13 → 2.0.0-rc.1

package/output/algebra/simplify/trigsimp.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifyTrigSum = simplifyTrigSum;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const constants_1 = require("../../core/classes/parser/constants");
+const trig_1 = require("../../math/trig");
+/**
+ * Extracts trig information from a sum term.
+ * Returns null if the term doesn't contain a sin^2 or cos^2.
+ */
+function extractTrigSquared(term) {
+    // Case 1: Direct trig function, e.g. sin(x)^2 or 3*cos(x)^2
+    if ((term.isFunction(constants_1.SIN) || term.isFunction(constants_1.COS)) && term.getPower().eq((0, shortcuts_1.two)())) {
+        return {
+            coeff: Expression_1.Expression.fromRational(term.getMultiplier()),
+            trigFn: term.isFunction(constants_1.SIN) ? constants_1.SIN : constants_1.COS,
+            arg: term.getArguments()[0],
+            trigPower: term.getPower(),
+            original: term,
+        };
+    }
+    // Case 2: Product containing a trig function, e.g. x*cos(x)^2
+    if (term.isProduct()) {
+        let trigElement = null;
+        let trigFn = null;
+        let trigMultiplier = (0, shortcuts_1.one)();
+        const coeffParts = [];
+        for (const element of term.elementsArray()) {
+            if (!trigElement &&
+                (element.isFunction(constants_1.SIN) || element.isFunction(constants_1.COS)) &&
+                element.getPower().eq((0, shortcuts_1.two)())) {
+                trigElement = element;
+                trigFn = element.isFunction(constants_1.SIN) ? constants_1.SIN : constants_1.COS;
+                trigMultiplier = Expression_1.Expression.fromRational(element.getMultiplier());
+            }
+            else {
+                coeffParts.push(element);
+            }
+        }
+        if (trigElement && trigFn) {
+            let coeff = Expression_1.Expression.fromRational(term.getMultiplier());
+            for (const part of coeffParts) {
+                coeff = coeff.times(part);
+            }
+            coeff = coeff.times(trigMultiplier);
+            return {
+                coeff,
+                trigFn,
+                arg: (trigElement).getArguments()[0],
+                trigPower: (trigElement).getPower(),
+                original: term,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Extracts tan^2, sec^2, csc^2, or cot^2 terms from a sum element.
+ */
+function extractDerivedTrigSquared(term) {
+    const fns = [constants_1.TAN, constants_1.SEC, constants_1.CSC, constants_1.COT];
+    // Case 1: Direct function, e.g. sec(x)^2
+    for (const fn of fns) {
+        if (term.isFunction(fn) && term.getPower().eq((0, shortcuts_1.two)())) {
+            return {
+                coeff: Expression_1.Expression.fromRational(term.getMultiplier()),
+                trigFn: fn,
+                arg: term.getArguments()[0],
+                trigPower: term.getPower(),
+                original: term,
+            };
+        }
+    }
+    // Case 2: Product containing a derived trig function
+    if (term.isProduct()) {
+        let trigElement = null;
+        let trigFn = null;
+        let trigMultiplier = (0, shortcuts_1.one)();
+        const coeffParts = [];
+        for (const element of term.elementsArray()) {
+            if (!trigElement) {
+                for (const fn of fns) {
+                    if (element.isFunction(fn) && element.getPower().eq((0, shortcuts_1.two)())) {
+                        trigElement = element;
+                        trigFn = fn;
+                        trigMultiplier = Expression_1.Expression.fromRational(element.getMultiplier());
+                        break;
+                    }
+                }
+                if (!trigElement) {
+                    coeffParts.push(element);
+                }
+            }
+            else {
+                coeffParts.push(element);
+            }
+        }
+        if (trigElement && trigFn) {
+            let coeff = Expression_1.Expression.fromRational(term.getMultiplier());
+            for (const part of coeffParts) {
+                coeff = coeff.times(part);
+            }
+            coeff = coeff.times(trigMultiplier);
+            return {
+                coeff,
+                trigFn,
+                arg: trigElement.getArguments()[0],
+                trigPower: trigElement.getPower(),
+                original: term,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Simplifies trig identities in a sum expression.
+ *
+ * Applies:
+ *   a·sin(u)² + a·cos(u)² = a                (Pythagorean)
+ *   a·sec(u)² - a·tan(u)² = a                (sec²-tan²=1)
+ *   a·csc(u)² - a·cot(u)² = a                (csc²-cot²=1)
+ *   Partial Pythagorean for mismatched coefficients
+ */
+function simplifyTrigSum(x) {
+    if (!x.isSum()) {
+        return x;
+    }
+    // Step 1: Apply the standard sin²+cos²=1 Pythagorean identity
+    let result = simplifyPythagorean(x);
+    // Step 2: Apply sec²-tan²=1 and csc²-cot²=1 identities
+    if (result.isSum()) {
+        result = simplifyDerivedPythagorean(result);
+    }
+    return result;
+}
+/**
+ * Standard Pythagorean: a·sin²(u) + a·cos²(u) = a
+ * With partial support for mismatched coefficients.
+ */
+function simplifyPythagorean(x) {
+    if (!x.isSum()) {
+        return x;
+    }
+    const trigTerms = [];
+    const otherTerms = [];
+    for (const term of x.elementsArray()) {
+        const info = extractTrigSquared(term);
+        if (info) {
+            trigTerms.push(info);
+        }
+        else {
+            otherTerms.push(term);
+        }
+    }
+    const hasSin = trigTerms.some(t => t.trigFn === constants_1.SIN);
+    const hasCos = trigTerms.some(t => t.trigFn === constants_1.COS);
+    if (!hasSin || !hasCos) {
+        return x;
+    }
+    const byArg = new Map();
+    for (const t of trigTerms) {
+        const key = t.arg.text();
+        let group = byArg.get(key);
+        if (!group) {
+            group = { sins: [], coss: [] };
+            byArg.set(key, group);
+        }
+        if (t.trigFn === constants_1.SIN) {
+            group.sins.push(t);
+        }
+        else {
+            group.coss.push(t);
+        }
+    }
+    const resultTerms = [...otherTerms];
+    for (const [, group] of byArg) {
+        const { sins, coss } = group;
+        const usedSins = new Set();
+        const usedCoss = new Set();
+        // Step 1: Full Pythagorean cancellation for matching coefficients
+        for (let i = 0; i < sins.length; i++) {
+            for (let j = 0; j < coss.length; j++) {
+                if (usedSins.has(i) || usedCoss.has(j)) {
+                    continue;
+                }
+                if (sins[i].coeff.eq(coss[j].coeff)) {
+                    resultTerms.push(sins[i].coeff);
+                    usedSins.add(i);
+                    usedCoss.add(j);
+                }
+            }
+        }
+        // Step 2: Partial Pythagorean for mismatched coefficients
+        for (let i = 0; i < sins.length; i++) {
+            if (usedSins.has(i)) {
+                continue;
+            }
+            for (let j = 0; j < coss.length; j++) {
+                if (usedCoss.has(j)) {
+                    continue;
+                }
+                if (sins[i].arg.eq(coss[j].arg)) {
+                    const a = sins[i].coeff;
+                    const b = coss[j].coeff;
+                    const diff = a.minus(b);
+                    let smaller;
+                    let larger;
+                    let remainderFn;
+                    if (diff.sign() === 1) {
+                        smaller = b;
+                        larger = a;
+                        remainderFn = (0, trig_1.sin)(sins[i].arg).pow((0, shortcuts_1.two)());
+                    }
+                    else {
+                        smaller = a;
+                        larger = b;
+                        remainderFn = (0, trig_1.cos)(coss[j].arg).pow((0, shortcuts_1.two)());
+                    }
+                    const scale = smaller.getDenominator();
+                    const scaledSmaller = smaller.times(scale);
+                    const scaledRemainder = larger.minus(smaller).times(scale);
+                    const inner = scaledSmaller.plus(scaledRemainder.times(remainderFn));
+                    resultTerms.push((0, shortcuts_1.one)().div(scale).times(inner));
+                    usedSins.add(i);
+                    usedCoss.add(j);
+                }
+            }
+        }
+        // Add back unmatched terms
+        for (let i = 0; i < sins.length; i++) {
+            if (!usedSins.has(i)) {
+                resultTerms.push(sins[i].original);
+            }
+        }
+        for (let j = 0; j < coss.length; j++) {
+            if (!usedCoss.has(j)) {
+                resultTerms.push(coss[j].original);
+            }
+        }
+    }
+    if (resultTerms.length === 1) {
+        return resultTerms[0];
+    }
+    let result = (0, shortcuts_1.zero)();
+    for (const term of resultTerms) {
+        result = result.plus(term);
+    }
+    return result;
+}
+/**
+ * Derived Pythagorean identities applied to sums:
+ *
+ *   a·sec(u)² - a·tan(u)² = a     (from 1 + tan² = sec²)
+ *   a·csc(u)² - a·cot(u)² = a     (from 1 + cot² = csc²)
+ *
+ * Also handles:
+ *   a·sec(u)² = a + a·tan(u)²     (rewrite sec² as 1+tan²)
+ *   a·tan(u)² = a·sec(u)² - a     (rewrite tan² as sec²-1)
+ */
+function simplifyDerivedPythagorean(x) {
+    if (!x.isSum()) {
+        return x;
+    }
+    const derivedTerms = [];
+    const otherTerms = [];
+    for (const term of x.elementsArray()) {
+        const info = extractDerivedTrigSquared(term);
+        if (info) {
+            derivedTerms.push(info);
+        }
+        else {
+            otherTerms.push(term);
+        }
+    }
+    if (derivedTerms.length < 2) {
+        return x;
+    }
+    // Group by argument
+    const byArg = new Map();
+    for (const t of derivedTerms) {
+        const key = t.arg.text();
+        let group = byArg.get(key);
+        if (!group) {
+            group = { secs: [], tans: [], cscs: [], cots: [] };
+            byArg.set(key, group);
+        }
+        if (t.trigFn === constants_1.SEC) {
+            group.secs.push(t);
+        }
+        else if (t.trigFn === constants_1.TAN) {
+            group.tans.push(t);
+        }
+        else if (t.trigFn === constants_1.CSC) {
+            group.cscs.push(t);
+        }
+        else if (t.trigFn === constants_1.COT) {
+            group.cots.push(t);
+        }
+    }
+    const resultTerms = [...otherTerms];
+    for (const [, group] of byArg) {
+        const { secs, tans, cscs, cots } = group;
+        const usedSecs = new Set();
+        const usedTans = new Set();
+        const usedCscs = new Set();
+        const usedCots = new Set();
+        // sec²(u) - tan²(u) = 1 → a·sec²(u) + (-a)·tan²(u) = a
+        for (let i = 0; i < secs.length; i++) {
+            for (let j = 0; j < tans.length; j++) {
+                if (usedSecs.has(i) || usedTans.has(j)) {
+                    continue;
+                }
+                // sec² coeff is a, tan² coeff is -a → result is a
+                const secCoeff = secs[i].coeff;
+                const tanCoeff = tans[j].coeff;
+                if (secCoeff.eq(tanCoeff.neg())) {
+                    resultTerms.push(secCoeff);
+                    usedSecs.add(i);
+                    usedTans.add(j);
+                }
+            }
+        }
+        // csc²(u) - cot²(u) = 1 → a·csc²(u) + (-a)·cot²(u) = a
+        for (let i = 0; i < cscs.length; i++) {
+            for (let j = 0; j < cots.length; j++) {
+                if (usedCscs.has(i) || usedCots.has(j)) {
+                    continue;
+                }
+                const cscCoeff = cscs[i].coeff;
+                const cotCoeff = cots[j].coeff;
+                if (cscCoeff.eq(cotCoeff.neg())) {
+                    resultTerms.push(cscCoeff);
+                    usedCscs.add(i);
+                    usedCots.add(j);
+                }
+            }
+        }
+        // Add back unmatched terms
+        for (let i = 0; i < secs.length; i++) {
+            if (!usedSecs.has(i)) {
+                resultTerms.push(secs[i].original);
+            }
+        }
+        for (let j = 0; j < tans.length; j++) {
+            if (!usedTans.has(j)) {
+                resultTerms.push(tans[j].original);
+            }
+        }
+        for (let i = 0; i < cscs.length; i++) {
+            if (!usedCscs.has(i)) {
+                resultTerms.push(cscs[i].original);
+            }
+        }
+        for (let j = 0; j < cots.length; j++) {
+            if (!usedCots.has(j)) {
+                resultTerms.push(cots[j].original);
+            }
+        }
+    }
+    if (resultTerms.length === 1) {
+        return resultTerms[0];
+    }
+    let result = (0, shortcuts_1.zero)();
+    for (const term of resultTerms) {
+        result = result.plus(term);
+    }
+    return result;
+}

package/output/algebra/simplify/utils.d.ts

@@ -0,0 +1,32 @@
+import type { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Strategies
+ *
+ * Sums
+ * ===================
+ * Rewrite cos^2+sin^2=1
+ * Rewrite sec^2-tan^2=1, csc^2-cot^2=1
+ * Combine log terms: log(a)+log(b) → log(a·b)
+ *
+ * Products
+ * ===================
+ * Radicalize expression
+ * Rewrite all trig functions as sin & cos and then fish back out other identities
+ * Recursively call simplify until expression in === out
+ * Factor the top polynomial by the bottom
+ * Simplify factorial ratios: n!/(n+k)! → 1/((n+1)...(n+k))
+ * Rewrite sin(u)*cos(u) → (1/2)*sin(2u)
+ *
+ * Functions
+ * ==================
+ * trigreduce: power reduction for sin²/cos² → half-angle form
+ *
+ * Factor out the GCD
+ */
+export declare function hasIrrationalDenominator(x: Expression): boolean;
+/**
+ * Checks if a product expression contains at least two factorial terms
+ * (one with positive power, one with negative), indicating a ratio that
+ * can potentially be simplified.
+ */
+export declare function hasFactorialRatio(x: Expression): boolean;

package/output/algebra/simplify/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasIrrationalDenominator = hasIrrationalDenominator;
+exports.hasFactorialRatio = hasFactorialRatio;
+const constants_1 = require("../../core/classes/parser/constants");
+/**
+ * Strategies
+ *
+ * Sums
+ * ===================
+ * Rewrite cos^2+sin^2=1
+ * Rewrite sec^2-tan^2=1, csc^2-cot^2=1
+ * Combine log terms: log(a)+log(b) → log(a·b)
+ *
+ * Products
+ * ===================
+ * Radicalize expression
+ * Rewrite all trig functions as sin & cos and then fish back out other identities
+ * Recursively call simplify until expression in === out
+ * Factor the top polynomial by the bottom
+ * Simplify factorial ratios: n!/(n+k)! → 1/((n+1)...(n+k))
+ * Rewrite sin(u)*cos(u) → (1/2)*sin(2u)
+ *
+ * Functions
+ * ==================
+ * trigreduce: power reduction for sin²/cos² → half-angle form
+ *
+ * Factor out the GCD
+ */
+function hasIrrationalDenominator(x) {
+    const checkIrrationalDenominator = true;
+    return x.hasRadical(checkIrrationalDenominator);
+}
+/**
+ * Checks if a product expression contains at least two factorial terms
+ * (one with positive power, one with negative), indicating a ratio that
+ * can potentially be simplified.
+ */
+function hasFactorialRatio(x) {
+    if (!x.isProduct()) {
+        return false;
+    }
+    let hasPos = false;
+    let hasNeg = false;
+    for (const element of x.elementsArray()) {
+        if (element.isFunction(constants_1.FACTORIAL)) {
+            if (element.getPower().sign() === 1) {
+                hasPos = true;
+            }
+            else if (element.getPower().sign() === -1) {
+                hasNeg = true;
+            }
+        }
+    }
+    return hasPos && hasNeg;
+}

package/output/algebra/utils.d.ts

@@ -0,0 +1,32 @@
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+/** Components of a quadratic rewritten by {@link sqcomp}. */
+export interface CompleteSquareResult {
+    /** Original quadratic coefficient. */
+    a: Expression;
+    /** Shift in `a*(variable+h)^2+k`. */
+    h: Expression;
+    /** Remaining constant in `a*(variable+h)^2+k`. */
+    k: Expression;
+    /** Variable used for the rewrite. */
+    variable: string;
+    /** Completed-square expression. */
+    expression: Expression;
+}
+/**
+ * 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 = sqcomp('x^2+6*x+1');
+ * result.expression.text({ sort: true }); // "(3+x)^2-8"
+ * ```
+ */
+export declare function sqcomp(expr: ExpressionInput, variable?: string): CompleteSquareResult;

package/output/algebra/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqcomp = sqcomp;
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const errors_1 = require("../core/errors");
+/**
+ * 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 = sqcomp('x^2+6*x+1');
+ * result.expression.text({ sort: true }); // "(3+x)^2-8"
+ * ```
+ */
+function sqcomp(expr, variable) {
+    const e = Expression_1.Expression.create(expr);
+    // Auto-detect variable if not provided
+    if (!variable) {
+        const vars = e.variables();
+        if (vars.length === 0) {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('noVariableInExpression'));
+        }
+        variable = vars[0];
+    }
+    const c = e.coeffs(variable);
+    if (c.max() !== 2) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('quadraticExpressionExpected'));
+    }
+    const a = c.hasPower(2) ? c.getPower(2) : (0, shortcuts_1.zero)();
+    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));
+    // k = c - b² / (4a)
+    const k = k0.minus(b.pow(2).div(a.times(4)));
+    // Build a*(variable + h)^2 + k
+    const x = Expression_1.Expression.create(variable);
+    const expression = a.times(x.plus(h).pow(2)).plus(k);
+    return { a, h, k, variable, expression };
+}

package/output/api/advanced.d.ts

@@ -0,0 +1,7 @@
+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 { FunctionSolver } from '../solve/classes/FunctionSolver';
+export type { FunctionSolverOptions, Root, RootFindingMethod, } from '../solve/classes/FunctionSolver';

package/output/api/advanced.js

@@ -0,0 +1,18 @@
+"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;
+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; } });
+Object.defineProperty(exports, "eliminate", { enumerable: true, get: function () { return groebnerBase_1.eliminate; } });
+Object.defineProperty(exports, "groebnerBasisWithOptions", { enumerable: true, get: function () { return groebnerBase_1.groebnerBasisWithOptions; } });
+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 FunctionSolver_1 = require("../solve/classes/FunctionSolver");
+Object.defineProperty(exports, "FunctionSolver", { enumerable: true, get: function () { return FunctionSolver_1.FunctionSolver; } });

package/output/api/algebra.d.ts

@@ -0,0 +1,17 @@
+/** Public symbolic algebra and polynomial APIs. */
+export { factor, 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';
+export type { CompleteSquareResult } from '../algebra/utils';
+export { CoeffObject } from '../core/classes/expression/CoeffObject';
+export { 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';
+export type { PowersObject } from '../core/classes/polynomial/Term';
+export { uSub, uUnSub } from '../core/functions/subst';
+export type { SubstitutionMap, USubstitutionResult, } from '../core/functions/subst';
+export { isprime as isPrime } from '../math/utils';

package/output/api/algebra.js

@@ -0,0 +1,32 @@
+"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;
+/** Public symbolic algebra and polynomial APIs. */
+var factor_1 = require("../algebra/factor/factor");
+Object.defineProperty(exports, "factor", { enumerable: true, get: function () { return factor_1.factor; } });
+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; } });
+Object.defineProperty(exports, "lcm", { enumerable: true, get: function () { return gcd_1.lcm; } });
+var groebner_1 = require("../algebra/groebner");
+Object.defineProperty(exports, "groebner", { enumerable: true, get: function () { return groebner_1.groebner; } });
+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; } });
+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, "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");
+Object.defineProperty(exports, "Polynomial", { enumerable: true, get: function () { return Polynomial_1.Polynomial; } });
+var Term_1 = require("../core/classes/polynomial/Term");
+Object.defineProperty(exports, "Term", { enumerable: true, get: function () { return Term_1.Term; } });
+var subst_1 = require("../core/functions/subst");
+Object.defineProperty(exports, "uSub", { enumerable: true, get: function () { return subst_1.uSub; } });
+Object.defineProperty(exports, "uUnSub", { enumerable: true, get: function () { return subst_1.uUnSub; } });
+var utils_2 = require("../math/utils");
+Object.defineProperty(exports, "isPrime", { enumerable: true, get: function () { return utils_2.isprime; } });

package/output/api/assumptions.d.ts

@@ -0,0 +1,4 @@
+export { assume, clearAssumptions, forgetAssumptionFor, getAssumptionFor, } 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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assumption = 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; } });
+/** 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

@@ -0,0 +1,9 @@
+/** Public calculus APIs. */
+export { diff } from '../calculus/derivative/diff';
+export { S, C } from '../calculus/fresnel';
+export { integrate } from '../calculus/integrate/integrate';
+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';

package/output/api/calculus.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = exports.product = exports.defint = exports.limit = exports.laplace = exports.ilaplace = exports.integrate = exports.C = exports.S = exports.diff = void 0;
+/** Public calculus APIs. */
+var diff_1 = require("../calculus/derivative/diff");
+Object.defineProperty(exports, "diff", { enumerable: true, get: function () { return diff_1.diff; } });
+var fresnel_1 = require("../calculus/fresnel");
+Object.defineProperty(exports, "S", { enumerable: true, get: function () { return fresnel_1.S; } });
+Object.defineProperty(exports, "C", { enumerable: true, get: function () { return fresnel_1.C; } });
+var integrate_1 = require("../calculus/integrate/integrate");
+Object.defineProperty(exports, "integrate", { enumerable: true, get: function () { return integrate_1.integrate; } });
+var ilaplace_1 = require("../calculus/laplace/ilaplace");
+Object.defineProperty(exports, "ilaplace", { enumerable: true, get: function () { return ilaplace_1.ilaplace; } });
+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 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; } });