nerdamer 1.1.13 → 2.0.0-rc.2

package/output/math/trunc.d.ts

@@ -0,0 +1,19 @@
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Truncates a number toward zero.
+ *
+ * Numeric inputs discard their fractional part without changing the sign of the
+ * integer portion. Symbolic inputs remain unevaluated.
+ *
+ * @param x - The expression to truncate.
+ * @returns The integer portion of `x`, or symbolic `trunc(x)`.
+ *
+ * @example
+ * ```ts
+ * trunc('3.7').text()    // "3"
+ * trunc('-2.7').text()   // "-2"
+ * trunc('x').text()      // "trunc(x)"
+ * ```
+ */
+export declare function trunc(x: ExpressionInput): Expression;

package/output/math/trunc.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trunc = trunc;
+const Expression_1 = require("../core/classes/expression/Expression");
+const constants_1 = require("../core/classes/parser/constants");
+/**
+ * Truncates a number toward zero.
+ *
+ * Numeric inputs discard their fractional part without changing the sign of the
+ * integer portion. Symbolic inputs remain unevaluated.
+ *
+ * @param x - The expression to truncate.
+ * @returns The integer portion of `x`, or symbolic `trunc(x)`.
+ *
+ * @example
+ * ```ts
+ * trunc('3.7').text()    // "3"
+ * trunc('-2.7').text()   // "-2"
+ * trunc('x').text()      // "trunc(x)"
+ * ```
+ */
+function trunc(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    else if (x.isNUM()) {
+        const m = x.getMultiplier();
+        retval = Expression_1.Expression.Number(m.numerator / m.denominator);
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.TRUNC, [x]);
+    }
+    return retval;
+}

package/output/math/utils.d.ts

@@ -0,0 +1,66 @@
+import { Collection } from '../core/classes/collection/Collection';
+import { Expression } from '../core/classes/expression/Expression';
+export { product, stripPower, sum } from '../core/classes/expression/utils';
+import type { ExpressionInput, ParserEntity } from '../core/types';
+/**
+ * Returns the continued-fraction decomposition as a Collection containing
+ * sign, whole part, and a Vector of partial quotients.
+ */
+export declare function continuedFraction(x: ExpressionInput, depth?: ExpressionInput): Collection;
+/**
+ * Contains useful functions which are not likely to be exported to the user through `build`
+ */
+/**
+ * Places the Expression in a form that will defer any simplification. Expand must be explicitly called.
+ * TODO: This should likely be its own type but it seems a bit overblown to create whole new type
+ * just for factors.
+ *
+ * @param x
+ * @returns
+ */
+export declare function toFactor(x: Expression): Expression;
+export declare function roots(x: number, y: number, product: number): [number, number];
+export declare function getCombinations(factors: number[], num?: number, startAt?: number, combinations?: number[]): number[];
+export declare function findMatches(factors: number[], target: number): number[][];
+/**
+ * Converts an array of coefficient in decending power order to a polynomial string
+ *
+ * @param arr Array of coefficients in order of descending powers
+ * @param variable The variable to be used. Defaults to 'x'
+ * @returns
+ */
+export declare function polynomialStringFromArray(arr: number[], variable?: string): string;
+/**
+ * Trims leading zeroes from an array
+ *
+ * @param polyArray
+ * @returns
+ */
+export declare function trimZeros(polyArray: Expression[]): Expression[];
+/**
+ * Returns the index of an element in an array. Use this instead of Array.indexOf
+ * since it recognized equality in Expression, Vectors, Matrices, etc.
+ *
+ * @param arr
+ * @param e
+ * @returns
+ */
+export declare function indexOf(arr: ParserEntity[], e: ParserEntity): number;
+/**
+ * Returns the number of elements in a Vector, SolutionSet, ValuesSet
+ * @param x
+ * @returns
+ */
+export declare function count(x: ParserEntity): Expression;
+/** Returns the dimensions of a structured parser value. */
+export declare function size(x: ParserEntity): ParserEntity;
+/**
+ * Tests whether an exact integer expression is prime.
+ *
+ * Non-integer or unresolved symbolic input remains as an unevaluated `isprime(...)`
+ * expression so it can be simplified later.
+ *
+ * @param x - Expression-compatible value to test.
+ * @returns `1` for prime integers, `0` for composite integers, or an unevaluated symbolic call.
+ */
+export declare function isprime(x: ExpressionInput): Expression;

package/output/math/utils.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = exports.stripPower = exports.product = void 0;
+exports.continuedFraction = continuedFraction;
+exports.toFactor = toFactor;
+exports.roots = roots;
+exports.getCombinations = getCombinations;
+exports.findMatches = findMatches;
+exports.polynomialStringFromArray = polynomialStringFromArray;
+exports.trimZeros = trimZeros;
+exports.indexOf = indexOf;
+exports.count = count;
+exports.size = size;
+exports.isprime = isprime;
+const Collection_1 = require("../core/classes/collection/Collection");
+const Dictionary_1 = require("../core/classes/dictionary/Dictionary");
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+var utils_1 = require("../core/classes/expression/utils");
+Object.defineProperty(exports, "product", { enumerable: true, get: function () { return utils_1.product; } });
+Object.defineProperty(exports, "stripPower", { enumerable: true, get: function () { return utils_1.stripPower; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return utils_1.sum; } });
+const Matrix_1 = require("../core/classes/matrix/Matrix");
+const constants_1 = require("../core/classes/parser/constants");
+const ValuesSet_1 = require("../core/classes/valuesSet/ValuesSet");
+const Vector_1 = require("../core/classes/vector/Vector");
+const errors_1 = require("../core/errors");
+const primeFactor_1 = require("../core/functions/bigint/primeFactor");
+/**
+ * Returns the continued-fraction decomposition as a Collection containing
+ * sign, whole part, and a Vector of partial quotients.
+ */
+function continuedFraction(x, depth = 10) {
+    const input = Expression_1.Expression.create(x);
+    const limitExpression = Expression_1.Expression.create(depth);
+    if (!limitExpression.isNUM() ||
+        !limitExpression.isInteger() ||
+        limitExpression.lt((0, shortcuts_1.zero)()) ||
+        limitExpression.getMultiplier().numerator > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: 'a non-negative integer',
+            received: limitExpression.text(),
+        }));
+    }
+    const limit = Number(limitExpression.getMultiplier().numerator);
+    const evaluated = input.isConstant() ? input.evaluate() : input;
+    if (!evaluated.isNUM()) {
+        return new Collection_1.Collection([(0, shortcuts_1.one)(), input, new Vector_1.Vector()]);
+    }
+    const rational = evaluated.getMultiplier();
+    const sign = Expression_1.Expression.Number(rational.sign());
+    const numerator = rational.numerator < 0n ? -rational.numerator : rational.numerator;
+    let denominator = rational.denominator;
+    const whole = numerator / denominator;
+    let remainder = numerator % denominator;
+    const fractions = [];
+    for (let i = 0; i < limit && remainder !== 0n; i++) {
+        const quotient = denominator / remainder;
+        fractions.push(Expression_1.Expression.Number(quotient));
+        const nextRemainder = denominator % remainder;
+        denominator = remainder;
+        remainder = nextRemainder;
+    }
+    return new Collection_1.Collection([sign, Expression_1.Expression.Number(whole), new Vector_1.Vector(fractions)]);
+}
+/**
+ * Contains useful functions which are not likely to be exported to the user through `build`
+ */
+/**
+ * Places the Expression in a form that will defer any simplification. Expand must be explicitly called.
+ * TODO: This should likely be its own type but it seems a bit overblown to create whole new type
+ * just for factors.
+ *
+ * @param x
+ * @returns
+ */
+function toFactor(x) {
+    return Expression_1.Expression.toEXP(x, (0, shortcuts_1.one)());
+}
+function roots(x, y, product) {
+    const a = (x + y + Math.sqrt((x + y) ** 2 - 4 * product)) / 2;
+    const b = (x + y - Math.sqrt((x + y) ** 2 - 4 * product)) / 2;
+    return [Math.min(a, b), Math.max(a, b)];
+}
+function getCombinations(factors, num, startAt = 1, combinations) {
+    combinations ??= [factors[0]];
+    // Start at the beginning
+    num = num || factors[0];
+    for (let i = startAt; i < factors.length; i++) {
+        // Calculate this combination
+        const product = num * factors[i];
+        combinations.push(product);
+        // Get the rest of the combinations with this
+        for (let j = startAt + 1; j < factors.length; j++) {
+            combinations.push(factors[startAt] * factors[j]);
+        }
+        // We now have to calculate the combinations witht the remaining factors
+        getCombinations(factors, product, i + 1, combinations);
+    }
+    combinations = [...new Set(combinations)].sort((a, b) => a - b);
+    return combinations;
+}
+function findMatches(factors, target) {
+    const matches = [];
+    for (let i = 0; i < factors.length; i++) {
+        const a = factors[i];
+        for (let j = factors.length - 1; j > i; j--) {
+            const b = factors[j];
+            const product = a * b;
+            // If the range is less than the target number then we're out of range
+            if (product < target) {
+                break;
+            }
+            // The combination has to be an exact match
+            if (product === target) {
+                matches.push([Math.min(a, b), Math.max(a, b)]);
+            }
+        }
+    }
+    return matches;
+}
+/**
+ * Converts an array of coefficient in decending power order to a polynomial string
+ *
+ * @param arr Array of coefficients in order of descending powers
+ * @param variable The variable to be used. Defaults to 'x'
+ * @returns
+ */
+function polynomialStringFromArray(arr, variable = 'x') {
+    const terms = [];
+    // Make a copy and reverse
+    const polyArray = [...arr].reverse();
+    for (let p = 0; p < polyArray.length; p++) {
+        const c = polyArray[p];
+        if (c !== 0) {
+            if (p === 0) {
+                terms.push(String(c));
+            }
+            else {
+                const m = c === 1 ? '' : c === -1 ? '-' : `${c}*`;
+                const pow = p === 1 ? '' : '^' + p;
+                terms.push(`${m}${variable}${pow}`);
+            }
+        }
+    }
+    return terms.reverse().join('+').replace(/\+-/g, '-');
+}
+/**
+ * Trims leading zeroes from an array
+ *
+ * @param polyArray
+ * @returns
+ */
+function trimZeros(polyArray) {
+    let i = polyArray.length - 1;
+    while (i > 0 && polyArray[i].isZero()) {
+        i--;
+    }
+    return polyArray.slice(0, i + 1);
+}
+/**
+ * Returns the index of an element in an array. Use this instead of Array.indexOf
+ * since it recognized equality in Expression, Vectors, Matrices, etc.
+ *
+ * @param arr
+ * @param e
+ * @returns
+ */
+function indexOf(arr, e) {
+    for (let i = 0; i < arr.length; i++) {
+        const element = arr[i];
+        if (element.eq(e)) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Returns the number of elements in a Vector, SolutionSet, ValuesSet
+ * @param x
+ * @returns
+ */
+function count(x) {
+    if (Vector_1.Vector.isVector(x) || ValuesSet_1.ValuesSet.isValuesSet(x) || Dictionary_1.Dictionary.isDictionary(x)) {
+        return Expression_1.Expression.Number(x.count());
+    }
+    return Expression_1.Expression.toFunction(constants_1.COUNT, [x]);
+}
+/** Returns the dimensions of a structured parser value. */
+function size(x) {
+    if (Vector_1.Vector.isVector(x) ||
+        Matrix_1.Matrix.isMatrix(x) ||
+        Collection_1.Collection.isCollection(x) ||
+        ValuesSet_1.ValuesSet.isValuesSet(x) ||
+        Dictionary_1.Dictionary.isDictionary(x)) {
+        return Vector_1.Vector.create(x.dimensions());
+    }
+    return Expression_1.Expression.toFunction(constants_1.SIZE, [x]);
+}
+/**
+ * Tests whether an exact integer expression is prime.
+ *
+ * Non-integer or unresolved symbolic input remains as an unevaluated `isprime(...)`
+ * expression so it can be simplified later.
+ *
+ * @param x - Expression-compatible value to test.
+ * @returns `1` for prime integers, `0` for composite integers, or an unevaluated symbolic call.
+ */
+function isprime(x) {
+    const expression = Expression_1.Expression.create(x);
+    let retval;
+    if (expression.isInteger()) {
+        retval = Expression_1.Expression.Number(Number((0, primeFactor_1.isPrimeBig)(expression.getMultiplier().numerator)));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.ISPRIME, [expression]);
+    }
+    return retval;
+}

package/output/solve/classes/DecimalMatrix.d.ts

@@ -0,0 +1,17 @@
+import Decimal from 'decimal.js';
+/**
+ * A lightweight numeric matrix over Decimal.js for use in numerical solvers.
+ * Supports only the operations needed for Newton-Raphson: construction and linear solve.
+ */
+export declare class DecimalMatrix {
+    private readonly cols;
+    private data;
+    private readonly rows;
+    constructor(data: Decimal[][]);
+    /**
+     * Solves the linear system Ax = b using Gaussian elimination with partial pivoting.
+     * Returns the solution vector x, or null if the system is singular.
+     */
+    static solve(A: DecimalMatrix, b: Decimal[]): Decimal[] | null;
+    private get;
+}

package/output/solve/classes/DecimalMatrix.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecimalMatrix = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+/**
+ * A lightweight numeric matrix over Decimal.js for use in numerical solvers.
+ * Supports only the operations needed for Newton-Raphson: construction and linear solve.
+ */
+class DecimalMatrix {
+    cols;
+    data;
+    rows;
+    constructor(data) {
+        this.rows = data.length;
+        this.cols = data.length > 0 ? data[0].length : 0;
+        this.data = data.map(row => row.map(v => new decimal_js_1.default(v)));
+    }
+    /**
+     * Solves the linear system Ax = b using Gaussian elimination with partial pivoting.
+     * Returns the solution vector x, or null if the system is singular.
+     */
+    static solve(A, b) {
+        const n = A.rows;
+        if (n !== A.cols || n !== b.length) {
+            return null;
+        }
+        // Build augmented matrix [A | b]
+        const aug = [];
+        for (let i = 0; i < n; i++) {
+            const row = [];
+            for (let j = 0; j < n; j++) {
+                row.push(new decimal_js_1.default(A.get(i, j)));
+            }
+            row.push(new decimal_js_1.default(b[i]));
+            aug.push(row);
+        }
+        // Forward elimination with partial pivoting
+        for (let col = 0; col < n; col++) {
+            // Find pivot
+            let maxAbs = aug[col][col].abs();
+            let maxRow = col;
+            for (let row = col + 1; row < n; row++) {
+                const val = aug[row][col].abs();
+                if (val.greaterThan(maxAbs)) {
+                    maxAbs = val;
+                    maxRow = row;
+                }
+            }
+            if (maxAbs.lessThan(new decimal_js_1.default('1e-30'))) {
+                return null; // Singular
+            }
+            // Swap rows
+            if (maxRow !== col) {
+                [aug[col], aug[maxRow]] = [aug[maxRow], aug[col]];
+            }
+            // Eliminate below
+            const pivot = aug[col][col];
+            for (let row = col + 1; row < n; row++) {
+                const factor = aug[row][col].div(pivot);
+                for (let j = col; j <= n; j++) {
+                    aug[row][j] = aug[row][j].minus(factor.times(aug[col][j]));
+                }
+            }
+        }
+        // Back substitution
+        const x = new Array(n);
+        for (let i = n - 1; i >= 0; i--) {
+            let sum = aug[i][n];
+            for (let j = i + 1; j < n; j++) {
+                sum = sum.minus(aug[i][j].times(x[j]));
+            }
+            if (aug[i][i].abs().lessThan(new decimal_js_1.default('1e-30'))) {
+                return null; // Singular
+            }
+            x[i] = sum.div(aug[i][i]);
+        }
+        return x;
+    }
+    get(i, j) {
+        return this.data[i][j];
+    }
+}
+exports.DecimalMatrix = DecimalMatrix;

package/output/solve/classes/FunctionSolver.d.ts

@@ -0,0 +1,135 @@
+import Decimal from 'decimal.js';
+import { Expression } from '../../core/classes/expression/Expression';
+/** Numerical method used to refine a candidate interval. */
+export type RootFindingMethod = 'Brent' | 'NewtonRaphson';
+/** Options for numerical root searches over a fixed interval with {@link FunctionSolver}. */
+export interface FunctionSolverOptions {
+    /** Upper endpoint of the search interval. Defaults to `100`. */
+    upperBound?: Decimal | number;
+    /** Lower endpoint of the search interval. Defaults to `-100`. */
+    lowerBound?: Decimal | number;
+    /** Central-difference step used by Newton-Raphson. Defaults to `1e-15`. */
+    derivativeStep?: Decimal | number;
+    /** Maximum refinement iterations for each candidate. Defaults to `200`. */
+    maxIterations?: number;
+    /** Spacing used to scan for candidate intervals. Defaults to `0.1`. */
+    stepSize?: number;
+    /** Residual and convergence tolerance. Defaults to `1e-14`. */
+    tolerance?: number;
+    /** Maximum number of roots to return. Defaults to `20`. */
+    maxRoots?: number;
+    /** Reserved diagnostic flag. The current implementation emits no output. */
+    verbose?: boolean;
+    /** Refinement method. Defaults to `'Brent'`. */
+    method?: RootFindingMethod;
+}
+/**
+ * Metadata returned by a single numerical root-refinement attempt.
+ */
+export interface Root {
+    /** The root found */
+    root: Decimal;
+    /** Number of iterations performed */
+    iterations: number;
+    /** Whether the algorithm converged */
+    converged: boolean;
+    /** Final error estimate */
+    error: Decimal;
+    /** The error message if any */
+    errorMsg?: string;
+}
+/**
+ * Searches a fixed interval for real roots of a univariate expression.
+ *
+ * @remarks
+ * {@link roots} scans the configured interval from its center toward both
+ * endpoints. It refines sign-changing intervals with Brent's method or
+ * Newton-Raphson, verifies residuals, merges nearby results, and returns roots
+ * in ascending order. This is a heuristic search: an even-multiplicity root
+ * can be missed unless a scan point lands sufficiently close to it, and
+ * periodic functions are limited by both the interval and `maxRoots`.
+ *
+ * Calculations use the ambient `decimal.js` precision. An Expression supplied
+ * to the constructor is retained rather than copied, and the public settings
+ * may be adjusted before a search.
+ *
+ * @example
+ * ```ts
+ * const solver = new FunctionSolver('cos(x)-x', 'x', {
+ *     lowerBound: 0,
+ *     upperBound: 1,
+ * });
+ * const roots = solver.roots();
+ * ```
+ */
+export declare class FunctionSolver {
+    derivativeStep: Decimal;
+    func: Expression;
+    lowerBound: Decimal;
+    maxIters: number;
+    maxRoots: number;
+    method?: RootFindingMethod;
+    stepSize: number;
+    tolerance: Decimal;
+    upperBound: Decimal;
+    variable: string;
+    verbose: boolean;
+    /**
+     * Creates a real-root solver for the configured search interval.
+     *
+     * @param func - Expression to evaluate, or a string parsed as an Expression.
+     * @param variable - Variable to substitute. When omitted, the expression must
+     * contain at most one variable.
+     * @param options - Search interval, refinement method, and tolerances.
+     * @throws {@link core!UnsupportedOperationError} If `variable` is omitted and the
+     * expression contains more than one variable.
+     */
+    constructor(func: Expression | string, variable?: string, options?: FunctionSolverOptions);
+    private calculateIntervals;
+    private getVariable;
+    /**
+     * Refines a bracket using Brent's combination of bisection, secant, and
+     * inverse-quadratic interpolation.
+     *
+     * @param a - First bracket endpoint.
+     * @param b - Second bracket endpoint.
+     * @returns Refinement metadata. Invalid brackets and exhausted iterations are
+     * represented in the returned {@link Root}; they are not thrown.
+     */
+    Brent(a: Decimal, b: Decimal): Root;
+    /** Approximates the derivative with a central difference. */
+    df(x: Decimal, h: Decimal): Decimal;
+    /**
+     * Evaluates the configured expression at a real value.
+     *
+     * @throws {@link core!UnexpectedInputError} If evaluation does not produce a scalar
+     * Expression.
+     */
+    evaluate(at: Decimal | number | string): Decimal;
+    /**
+     * Refines a root from an initial guess using Newton-Raphson and a numerical
+     * derivative.
+     *
+     * @returns Refinement metadata, including non-convergence or a zero derivative.
+     */
+    NewtonRaphson(guess: Decimal): {
+        root: Decimal;
+        iterations: number;
+        converged: boolean;
+        error: Decimal;
+        errorMsg: string;
+    } | {
+        root: Decimal;
+        iterations: number;
+        converged: boolean;
+        error: Decimal;
+        errorMsg?: undefined;
+    };
+    /**
+     * Searches the configured interval for real roots.
+     *
+     * @returns Verified, deduplicated roots in ascending order, limited by
+     * `maxRoots`. Failed evaluations and failed refinements are skipped.
+     */
+    roots(): Expression[];
+}