nerdamer 1.1.13 → 2.0.0-rc.1

package/output/calculus/limit/limitsTable.d.ts

@@ -0,0 +1,2 @@
+import { LookupTable } from '../../core/classes/lookupTable/LookupTable';
+export declare const tableOfLimits: LookupTable;

package/output/calculus/limit/limitsTable.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableOfLimits = void 0;
+const LookupTable_1 = require("../../core/classes/lookupTable/LookupTable");
+const limitsTable = {};
+exports.tableOfLimits = new LookupTable_1.LookupTable();
+exports.tableOfLimits.addEntries(limitsTable);

package/output/core/Settings.d.ts

@@ -0,0 +1,32 @@
+import type { Language } from './errors';
+export type SettingsType = {
+    USE_FRACTIONS: boolean;
+    ALLOW_BIGINT: boolean;
+    EVALUATE: boolean;
+    SUBSTITUTE: boolean;
+    LANGUAGE: Language;
+    ALLOW_IMPLICIT_MULTIPLICATION: boolean;
+    SORT_TERMS: boolean;
+    DEFER_SIMPLIFICATION: boolean;
+    REWRITE_SQRT: boolean;
+    MAX_FRAC_INT: bigint;
+    ALLOW_RAT_SUBS: boolean;
+    IMMUTABLE_VALUE_SETS: boolean;
+    USE_SINGLE_LETTER_VARIABLES: boolean;
+    MAX_PRODUCT_AND_SUMMATION_ITERATION: number;
+    MAX_LOOP_ITERATIONS: number;
+    INITIALIZE_RULES: boolean;
+    INDEX_BASE: number;
+};
+export declare const Settings: SettingsType;
+/**
+ * Allows for the parser to run with a desired setting for a single call
+ *
+ * @param setting The setting to modified for the call
+ * @param value The value of the setting under which the function is called
+ * @param callback The function to be called
+ * @returns The result of the call
+ */
+export declare function scopedBlock<T>(setting: string, value: boolean, callback: () => T): T;
+export declare const RESTRICTED: string[];
+export declare const SPECIAL: string[];

package/output/core/Settings.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECIAL = exports.RESTRICTED = exports.Settings = void 0;
+exports.scopedBlock = scopedBlock;
+const constants_1 = require("./classes/parser/constants");
+exports.Settings = {
+    // Forces decimals to fractions.
+    USE_FRACTIONS: true,
+    // Allow bigInt to be used when numerator or denominator get huge
+    ALLOW_BIGINT: true,
+    // If this is true then functions and numbers will be evaluated
+    EVALUATE: false,
+    // If true variable substitution will be performed
+    SUBSTITUTE: true,
+    // The language being used
+    LANGUAGE: 'eng',
+    // Allows implicit multiplications
+    ALLOW_IMPLICIT_MULTIPLICATION: true,
+    // If true the terms will be sorted. The default is false because of the added overhead.
+    SORT_TERMS: false,
+    // Avoids certain simplifications if set to false for performance boots
+    DEFER_SIMPLIFICATION: false,
+    // If true powers of 1/2 will be rewritten back to sqrt
+    REWRITE_SQRT: true,
+    // The max allowable integer when factoring numerators and denominator
+    MAX_FRAC_INT: BigInt(1e60),
+    // If set to false then rational multipliers will not be allowed in substitutions
+    ALLOW_RAT_SUBS: false,
+    // If set to true, vectors, matrices, and collections will always return a copy
+    IMMUTABLE_VALUE_SETS: true,
+    // If true each letter will be treated a a variable
+    USE_SINGLE_LETTER_VARIABLES: false,
+    // The maximum iteration allowed in sum and product
+    MAX_PRODUCT_AND_SUMMATION_ITERATION: 1e4,
+    // The maximum number of completed iterations allowed for parser control-flow loops
+    MAX_LOOP_ITERATIONS: 1e4,
+    // If true then rules will be initialized on start
+    INITIALIZE_RULES: true,
+    // The base index for element access on vectors and matrices. 0 = zero-based, 1 = one-based.
+    INDEX_BASE: 0,
+};
+/**
+ * Allows for the parser to run with a desired setting for a single call
+ *
+ * @param setting The setting to modified for the call
+ * @param value The value of the setting under which the function is called
+ * @param callback The function to be called
+ * @returns The result of the call
+ */
+function scopedBlock(setting, value, callback) {
+    let retval;
+    // Store the value being currently used
+    const currentSettingValue = exports.Settings[setting];
+    // Update the setting to the desired value
+    exports.Settings[setting] = value;
+    try {
+        retval = callback();
+    }
+    finally {
+        // Restore the value even if the callback throws
+        exports.Settings[setting] = currentSettingValue;
+    }
+    return retval;
+}
+// The list of restricted variables
+exports.RESTRICTED = [constants_1.E, constants_1.PI_NAME, constants_1.DEFAULT_IMAGINARY, constants_1.INDEX_VARIABLE, constants_1.ALL_SYMBOL];
+// The list of special values that get ignore at substitution
+exports.SPECIAL = [constants_1.E, constants_1.PI_NAME];

package/output/core/adapters.d.ts

@@ -0,0 +1,18 @@
+import { Polynomial } from './classes/polynomial/Polynomial';
+import type { ExpressionInput } from './types';
+/**
+ * Extracts the Z Polynomial from Q.
+ * Given a polynomial with rational coefficients, returns:
+ * - zPoly: the polynomial scaled to have integer coefficients (primitive part)
+ * - content: the GCD of the integer coefficients after clearing denominators
+ * - denominator: the common denominator used to clear fractions
+ *
+ * The relationship is: original = (content / denominator) * zPoly
+ *
+ * @param x
+ */
+export declare function expressionToZPoly(x: ExpressionInput): {
+    zPoly: Polynomial;
+    content: Polynomial;
+    denominator: Polynomial;
+};

package/output/core/adapters.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionToZPoly = expressionToZPoly;
+const Expression_1 = require("./classes/expression/Expression");
+const Polynomial_1 = require("./classes/polynomial/Polynomial");
+const bigint_1 = require("./functions/bigint/bigint");
+/**
+ * Extracts the Z Polynomial from Q.
+ * Given a polynomial with rational coefficients, returns:
+ * - zPoly: the polynomial scaled to have integer coefficients (primitive part)
+ * - content: the GCD of the integer coefficients after clearing denominators
+ * - denominator: the common denominator used to clear fractions
+ *
+ * The relationship is: original = (content / denominator) * zPoly
+ *
+ * @param x
+ */
+function expressionToZPoly(x) {
+    x = Expression_1.Expression.create(x);
+    const p = new Polynomial_1.Polynomial(x);
+    const denominators = [];
+    for (const term of p.terms) {
+        const m = term.coeff.getMultiplier();
+        denominators.push(m.denominator);
+    }
+    // LCM of all denominators to clear fractions
+    const lcmDenom = denominators.reduce((acc, d) => (0, bigint_1.LCM)(acc, d), 1n);
+    const common = new Polynomial_1.Polynomial(Expression_1.Expression.Number(lcmDenom));
+    // Scale to integer coefficients
+    const q = p.times(common);
+    // Extract content (GCD of integer coefficients)
+    const content = new Polynomial_1.Polynomial(q.content());
+    // Get the primitive part
+    const pp = q.div(content)[0];
+    return {
+        zPoly: pp,
+        content: content,
+        denominator: common,
+    };
+}

package/output/core/classes/assumption/Assumption.d.ts

@@ -0,0 +1,218 @@
+import Decimal from 'decimal.js';
+import { Expression } from '../expression/Expression';
+import { ASSUMPTION } from '../parser/constants';
+import { Rational } from '../rational/Rational';
+/**
+ * One endpoint of an {@link Assumption} interval.
+ *
+ * Infinity is always represented as an open endpoint because it is not itself a
+ * member of a real interval. `value` remains Decimal-facing for API compatibility;
+ * finite bounds also retain an exact rational representation internally.
+ */
+export type Bound = Readonly<{
+    value: Decimal;
+    inclusive: boolean;
+}>;
+/** Result returned by {@link Assumption.parse}. */
+export type ParsedAssumption = Readonly<{
+    symbol: string;
+    assumption: Assumption;
+}>;
+/** Numeric input accepted when constructing interval assumptions. */
+export type AssumptionValue = Decimal | Rational | string | number;
+/**
+ * Result of a comparison involving an interval-constrained value.
+ *
+ * `true` means the relation holds for every value allowed by the assumption.
+ * `false` means the opposite relation holds for every allowed value. `undefined`
+ * means both outcomes remain possible, so the relation cannot be proved from the
+ * available interval information.
+ */
+export type AssumptionComparison = true | false | undefined;
+/**
+ * Describes the admissible real values of a symbolic variable as one numeric interval.
+ *
+ * @remarks
+ * An `Assumption` is an interval constraint, not a symbolic theorem. It can prove
+ * relations when the interval bounds force an answer, disprove them when the bounds
+ * force the opposite answer, and otherwise reports an unknown result as `undefined`.
+ * Two variables having the same admissible interval therefore does not prove that the
+ * variables are equal.
+ *
+ * Instances are immutable. Repeated assumptions for a variable are intersected by
+ * the global assumption registry rather than modifying an existing interval.
+ *
+ * Finite bounds preserve an exact rational value internally. Decimal inputs therefore
+ * retain the exact value represented by their decimal text, while Rational inputs such
+ * as `1/3` are not rounded through Decimal precision before comparisons are made.
+ *
+ * The 2.0 assumption vocabulary covers a single real interval with numeric bounds.
+ * Integer, parity, complex-domain, relational (`x > y`), union, and general predicate
+ * assumptions are not represented by this class.
+ */
+export declare class Assumption {
+    private readonly endExact;
+    private readonly startExact;
+    /** Runtime tag used by Nerdamer's assumption type guard. */
+    readonly dataType: typeof ASSUMPTION;
+    /** Upper endpoint of the admissible interval. */
+    readonly end: Bound;
+    /** Whether the interval contains exactly one finite value. */
+    readonly isSingleton: boolean;
+    /** Lower endpoint of the admissible interval. */
+    readonly start: Bound;
+    /**
+     * Creates a non-empty real interval.
+     *
+     * @remarks
+     * Infinite endpoints are normalized to open bounds. A zero-width interval is valid
+     * only when both endpoints are inclusive, in which case it represents one exact
+     * value. Rational inputs retain their exact value even when their Decimal projection
+     * is necessarily finite precision.
+     *
+     * @param start - Lower numeric endpoint.
+     * @param end - Upper numeric endpoint.
+     * @param startInclusive - Include the lower endpoint when it is finite.
+     * @param endInclusive - Include the upper endpoint when it is finite.
+     * @throws Error
+     * Thrown when a bound is `NaN`, the bounds are reversed, or the interval is empty.
+     */
+    constructor(start: AssumptionValue, end: AssumptionValue, startInclusive?: boolean, endInclusive?: boolean);
+    /**
+     * Creates an interval extending upward from `x`.
+     *
+     * @param x - Lower endpoint.
+     * @param inclusive - Whether a finite lower endpoint belongs to the interval.
+     * @returns The interval `[x, +∞)` when inclusive, otherwise `(x, +∞)`.
+     */
+    static atLeast(x: AssumptionValue, inclusive?: boolean): Assumption;
+    /**
+     * Creates an interval extending downward from `x`.
+     *
+     * @param x - Upper endpoint.
+     * @param inclusive - Whether a finite upper endpoint belongs to the interval.
+     * @returns The interval `(-∞, x]` when inclusive, otherwise `(-∞, x)`.
+     */
+    static atMost(x: AssumptionValue, inclusive?: boolean): Assumption;
+    /**
+     * Creates the singleton interval containing exactly `x`.
+     *
+     * @param x - The one admissible value.
+     * @returns The closed singleton interval `[x, x]`.
+     */
+    static exactly(x: AssumptionValue): Assumption;
+    static isAssumption(obj: unknown): obj is Assumption;
+    /**
+     * Parses one numeric interval constraint such as `x >= 0` or `n < 10`.
+     *
+     * @remarks
+     * Whitespace is ignored. Variable names use the ASCII identifier form
+     * `[A-Za-z_][A-Za-z0-9_]*`. Supported operators are `=`, `==`, `>`, `>=`, `<`,
+     * and `<=`. Bounds are Decimal-compatible numeric literals; `inf`, `infinity`,
+     * `+inf`, `+infinity`, `-inf`, and `-infinity` are also accepted.
+     *
+     * Expressions such as `x > y`, `x = 1/2`, and property predicates such as
+     * `integer(x)` are outside the string assumption grammar. Parser assertive calls may
+     * still provide already-evaluated Rational bounds directly.
+     *
+     * @param expr - Constraint to parse.
+     * @returns The parsed symbol and its interval assumption.
+     * @throws Error
+     * Thrown when the constraint has an invalid identifier, operator, or numeric bound.
+     */
+    static parse(expr: string): ParsedAssumption;
+    /**
+     * Tests whether a numeric value belongs to this interval.
+     *
+     * @param x - Numeric value to test.
+     * @returns `true` when `x` satisfies both interval bounds.
+     */
+    contains(x: AssumptionValue): boolean;
+    /**
+     * Determines whether values constrained by this interval are equal to `x`.
+     *
+     * @remarks
+     * Equality is proved only when both sides identify the same single value. It is
+     * disproved when the admissible values are disjoint. Overlapping ranges, including
+     * identical non-singleton ranges, return `undefined` because equality depends on the
+     * actual values chosen from those ranges.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when equality is forced, `false` when inequality is forced, or
+     * `undefined` when the available information permits either outcome.
+     */
+    eq(x: Assumption | Expression): AssumptionComparison;
+    /**
+     * Returns the exact value represented by a singleton interval.
+     *
+     * @returns A numeric Expression when this interval is a singleton, otherwise
+     * `undefined`.
+     */
+    getSingletonValue(): Expression | undefined;
+    /**
+     * Determines whether every value in this interval is strictly greater than `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `>` is forced, `false` when `<=` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    gt(x: Assumption | Expression): AssumptionComparison;
+    /**
+     * Determines whether every value in this interval is greater than or equal to `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `>=` is forced, `false` when `<` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    gte(x: Assumption | Expression): AssumptionComparison;
+    /**
+     * Intersects this interval with another interval.
+     *
+     * Endpoint selection uses the exact finite representation retained by each interval,
+     * so repeated constraints do not lose rational precision while narrowing the range.
+     *
+     * @param x - Interval to intersect with this one.
+     * @returns The non-empty intersection, or `undefined` when the intervals are disjoint.
+     */
+    intersect(x: Assumption): Assumption | undefined;
+    /**
+     * Determines whether every value in this interval is strictly less than `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `<` is forced, `false` when `>=` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    lt(x: Assumption | Expression): AssumptionComparison;
+    /**
+     * Determines whether every value in this interval is less than or equal to `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `<=` is forced, `false` when `>` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    lte(x: Assumption | Expression): AssumptionComparison;
+    /**
+     * Tests whether this interval and `x` share at least one admissible value.
+     *
+     * @param x - Interval to test for overlap.
+     * @returns `true` when the intersection is non-empty.
+     */
+    overlaps(x: Assumption): boolean;
+    /**
+     * Tests whether two objects describe the same interval constraint.
+     *
+     * @remarks
+     * This is structural interval equality and is separate from {@link eq}: two different
+     * variables may have identical intervals without being known to have the same value.
+     *
+     * @param x - Interval constraint to compare with this one.
+     * @returns `true` when both endpoints and their inclusivity are identical.
+     */
+    sameInterval(x: Assumption): boolean;
+    /**
+     * Formats the interval using mathematical bracket notation.
+     *
+     * @returns A representation such as `[0, 10)` or `(-Infinity, Infinity)`.
+     */
+    toString(): string;
+}