nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/complex/Complex.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Complex = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const errors_1 = require("../../errors");
+/**
+ * Represents a numerical complex value backed by `decimal.js` components.
+ *
+ * @remarks
+ * This class is a numerical helper used by algorithms such as polynomial root solving. It is
+ * distinct from Nerdamer's symbolic complex expressions: it does not parse expressions, carry
+ * symbolic structure, or implement branch-sensitive transcendental functions. Component
+ * arithmetic follows the active global `decimal.js` precision.
+ *
+ * Arithmetic methods return new `Complex` objects rather than modifying the receiver. The
+ * {@link Complex.re} and {@link Complex.im} fields are public, however, so callers can reassign
+ * components directly.
+ */
+class Complex {
+    /** Imaginary component. */
+    im;
+    /** Real component. */
+    re;
+    /**
+     * Creates a numerical complex value.
+     *
+     * @remarks
+     * Existing Decimal components are retained by reference; numeric inputs are converted to
+     * new Decimal values. `decimal.js` arithmetic itself returns new Decimal objects.
+     *
+     * @param re - Real component.
+     * @param im - Imaginary component; defaults to zero.
+     */
+    constructor(re, im = 0) {
+        this.re = typeof re === 'number' ? new decimal_js_1.default(re) : re;
+        this.im = typeof im === 'number' ? new decimal_js_1.default(im) : im;
+    }
+    /**
+     * Creates a numerical complex value from Decimal or native-number components.
+     *
+     * @param re - Real component.
+     * @param im - Imaginary component; defaults to zero.
+     * @returns A new `Complex` value.
+     */
+    static create(re, im = 0) {
+        return new Complex(re instanceof decimal_js_1.default ? re : new decimal_js_1.default(re), im instanceof decimal_js_1.default ? im : new decimal_js_1.default(im));
+    }
+    /**
+     * Computes the modulus `sqrt(re^2 + im^2)`.
+     *
+     * @returns A new Decimal containing the nonnegative magnitude.
+     */
+    abs() {
+        return this.re.mul(this.re).plus(this.im.mul(this.im)).sqrt();
+    }
+    /**
+     * Adds another complex value component-wise.
+     *
+     * @param other - Complex value to add.
+     * @returns A new complex sum.
+     */
+    add(other) {
+        return new Complex(this.re.plus(other.re), this.im.plus(other.im));
+    }
+    /**
+     * Returns the complex conjugate `re - im*i`.
+     *
+     * @returns A new complex value with the imaginary component negated.
+     */
+    conjugate() {
+        return new Complex(this.re, this.im.neg());
+    }
+    /**
+     * Divides this complex value by another using the standard rectangular formula.
+     *
+     * @remarks
+     * Division rejects an exactly zero squared modulus. No numerical tolerance is applied at
+     * this arithmetic layer; iterative algorithms are responsible for choosing any tolerance
+     * appropriate to their convergence logic.
+     *
+     * @param other - Complex divisor.
+     * @returns A new complex quotient.
+     * @throws {@link core!DivisionByZeroError}
+     * Thrown when both components of `other` are exactly zero at the current Decimal value.
+     */
+    div(other) {
+        const denom = other.re.mul(other.re).plus(other.im.mul(other.im));
+        // Exact division by zero is undefined. Numerical tolerances belong to
+        // the algorithms using Complex rather than this arithmetic primitive.
+        if (denom.isZero()) {
+            throw new errors_1.DivisionByZeroError((0, errors_1.message)('divisionByZero'));
+        }
+        return new Complex(this.re.mul(other.re).plus(this.im.mul(other.im)).div(denom), this.im.mul(other.re).minus(this.re.mul(other.im)).div(denom));
+    }
+    /**
+     * Multiplies two rectangular complex values.
+     *
+     * @param other - Complex factor.
+     * @returns A new complex product.
+     */
+    mul(other) {
+        return new Complex(this.re.mul(other.re).minus(this.im.mul(other.im)), this.re.mul(other.im).plus(this.im.mul(other.re)));
+    }
+    /**
+     * Returns the additive inverse of this complex value.
+     *
+     * @returns A new complex value with both components negated.
+     */
+    neg() {
+        return new Complex(this.re.neg(), this.im.neg());
+    }
+    /**
+     * Multiplies both complex components by a real scalar.
+     *
+     * @param s - Decimal or native-number scale factor.
+     * @returns A new scaled complex value.
+     */
+    scale(s) {
+        const scalar = s instanceof decimal_js_1.default ? s : new decimal_js_1.default(s);
+        return new Complex(this.re.mul(scalar), this.im.mul(scalar));
+    }
+    /**
+     * Subtracts another complex value component-wise.
+     *
+     * @param other - Complex value to subtract.
+     * @returns A new complex difference.
+     */
+    sub(other) {
+        return new Complex(this.re.minus(other.re), this.im.minus(other.im));
+    }
+}
+exports.Complex = Complex;

package/output/core/classes/decimalSet/DecimalSet.d.ts

@@ -0,0 +1,226 @@
+import Decimal from 'decimal.js';
+/**
+ * A high-performance set implementation for Decimal.js numbers.
+ *
+ * This class provides a complete set of operations for working with sets of
+ * arbitrary-precision decimal numbers. It uses string representation internally
+ * for efficient equality comparison and hashing.
+ *
+ * @example
+ * ```typescript
+ * const setA = new DecimalSet([1, 2, 3]);
+ * const setB = new DecimalSet([2, 3, 4]);
+ * const union = setA.union(setB); // {1, 2, 3, 4}
+ * const intersection = setA.intersection(setB); // {2, 3}
+ * ```
+ */
+export declare class DecimalSet {
+    private readonly elements;
+    /**
+     * Creates a new DecimalSet.
+     *
+     * @param values - Optional array of values to initialize the set
+     */
+    constructor(values?: Iterable<Decimal.Value>);
+    /**
+     * Creates a DecimalSet from an array of values.
+     *
+     * @param values - Array of values
+     * @returns A new DecimalSet
+     */
+    static from(values: Iterable<Decimal.Value>): DecimalSet;
+    /**
+     * Creates a DecimalSet from a range of values.
+     *
+     * @param start - Start value (inclusive)
+     * @param end - End value (exclusive)
+     * @param step - Step size (default 1)
+     * @returns A new DecimalSet
+     * @throws If a bound or step is non-finite, the step is zero, or the configured
+     * Decimal precision is too low for the step to advance the current value.
+     */
+    static range(start: Decimal.Value, end: Decimal.Value, step?: Decimal.Value): DecimalSet;
+    /**
+     * Adds a value to the set.
+     *
+     * @param value - The value to add
+     * @returns The set instance for chaining
+     */
+    add(value: Decimal.Value): this;
+    /**
+     * Removes all elements from the set.
+     */
+    clear(): void;
+    /**
+     * Creates a shallow copy of the set.
+     */
+    clone(): DecimalSet;
+    /**
+     * Removes a value from the set.
+     *
+     * @param value - The value to remove
+     * @returns True if the value was present and removed, false otherwise
+     */
+    delete(value: Decimal.Value): boolean;
+    /**
+     * Creates a new set containing the difference (this \ other).
+     *
+     * @param other - The other set
+     * @returns A new set containing elements in this set but not in the other
+     */
+    difference(other: DecimalSet): DecimalSet;
+    /**
+     * Checks if this set equals another set.
+     *
+     * @param other - The other set
+     * @returns True if both sets contain the same elements
+     */
+    equals(other: DecimalSet): boolean;
+    /**
+     * Tests whether all elements pass the predicate test.
+     *
+     * @param predicate - Function to test each element
+     * @returns True if all elements pass the test
+     */
+    every(predicate: (value: Decimal) => boolean): boolean;
+    /**
+     * Filters the set based on a predicate function.
+     *
+     * @param predicate - Function to test each element
+     * @returns A new set containing only elements that pass the test
+     */
+    filter(predicate: (value: Decimal) => boolean): DecimalSet;
+    /**
+     * Executes a callback for each element in the set.
+     *
+     * @param callback - Function to execute for each element
+     * @param thisArg - Value to use as 'this' when executing callback
+     */
+    forEach(callback: (value: Decimal, value2: Decimal, set: DecimalSet) => void, thisArg?: unknown): void;
+    /**
+     * Checks if a value is in the set.
+     *
+     * @param value - The value to check
+     * @returns True if the value is in the set
+     */
+    has(value: Decimal.Value): boolean;
+    /**
+     * Creates a new set containing the intersection of this set and another.
+     *
+     * @param other - The other set
+     * @returns A new set containing only elements present in both sets
+     */
+    intersection(other: DecimalSet): DecimalSet;
+    /**
+     * Checks if this set is disjoint with another set.
+     *
+     * @param other - The other set
+     * @returns True if the sets have no elements in common
+     */
+    isDisjointFrom(other: DecimalSet): boolean;
+    /**
+     * Checks if the set is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Checks if this set is a proper subset of another set.
+     *
+     * @param other - The other set
+     * @returns True if this is a subset but not equal to the other set
+     */
+    isProperSubsetOf(other: DecimalSet): boolean;
+    /**
+     * Checks if this set is a proper superset of another set.
+     *
+     * @param other - The other set
+     * @returns True if this is a superset but not equal to the other set
+     */
+    isProperSupersetOf(other: DecimalSet): boolean;
+    /**
+     * Checks if this set is a subset of another set.
+     *
+     * @param other - The other set
+     * @returns True if all elements of this set are in the other set
+     */
+    isSubsetOf(other: DecimalSet): boolean;
+    /**
+     * Checks if this set is a superset of another set.
+     *
+     * @param other - The other set
+     * @returns True if all elements of the other set are in this set
+     */
+    isSupersetOf(other: DecimalSet): boolean;
+    /**
+     * Maps each element to a new value using a transform function.
+     *
+     * @param transform - Function to transform each element
+     * @returns A new set containing the transformed elements
+     */
+    map(transform: (value: Decimal) => Decimal.Value): DecimalSet;
+    /**
+     * Returns the maximum value in the set.
+     *
+     * @returns The maximum value, or undefined if the set is empty
+     */
+    max(): Decimal | undefined;
+    /**
+     * Returns the minimum value in the set.
+     *
+     * @returns The minimum value, or undefined if the set is empty
+     */
+    min(): Decimal | undefined;
+    /**
+     * Returns the number of elements in the set.
+     */
+    get size(): number;
+    /**
+     * Tests whether some element passes the predicate test.
+     *
+     * @param predicate - Function to test each element
+     * @returns True if at least one element passes the test
+     */
+    some(predicate: (value: Decimal) => boolean): boolean;
+    /**
+     * Returns the sum of all values in the set.
+     *
+     * @returns The sum, or zero if the set is empty
+     */
+    sum(): Decimal;
+    /**
+     * Returns an iterator over the values in the set (same as values()).
+     */
+    [Symbol.iterator](): IterableIterator<Decimal>;
+    /**
+     * Creates a new set containing the symmetric difference.
+     *
+     * @param other - The other set
+     * @returns A new set containing elements in either set but not both
+     */
+    symmetricDifference(other: DecimalSet): DecimalSet;
+    /**
+     * Converts the set to an array.
+     */
+    toArray(): Decimal[];
+    /**
+     * Returns a sorted array of the set's elements.
+     *
+     * @param compareFn - Optional comparison function
+     * @returns Sorted array of elements
+     */
+    toSorted(compareFn?: (a: Decimal, b: Decimal) => number): Decimal[];
+    /**
+     * Creates a string representation of the set.
+     */
+    toString(): string;
+    /**
+     * Creates a new set containing the union of this set and another.
+     *
+     * @param other - The other set
+     * @returns A new set containing all elements from both sets
+     */
+    union(other: DecimalSet): DecimalSet;
+    /**
+     * Returns an iterator over the values in the set.
+     */
+    values(): IterableIterator<Decimal>;
+}