@danielsimonjr/mathts-core 0.14.1 → 0.15.0

package/dist/types/dual-rules.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Canonical elementary-function derivative rules for forward-mode automatic
+ * differentiation. This is the single source of truth for the chain rules,
+ * shared by the scalar {@link Dual} (core) and the tensor `DualTensor`
+ * (autograd) so neither reinvents them.
+ *
+ * Each rule is a pair of pure `number → number` functions:
+ *   - `primal(x)` — f(x)
+ *   - `deriv(x, y)` — f′(x), given both x and the already-computed y = f(x),
+ *     so output-reusing derivatives (exp, tanh, sqrt, cbrt, expm1) stay cheap.
+ *
+ * Keeping these as plain scalar functions (no `Dual`/`Tensor` allocation) is
+ * what lets autograd's `Float64Array` element-wise loop stay allocation-free.
+ * It is also the propagation path: a future accelerated `primal` in the
+ * standard layer (WASM/SIMD batch kernels) can be swapped in here and every
+ * consumer inherits the speedup without touching this contract.
+ */
+/** A forward-mode derivative rule for a unary elementary function. */
+export interface DualUnaryRule {
+    /** f(x). */
+    readonly primal: (x: number) => number;
+    /** f′(x), given x and y = f(x) (y lets exp/tanh/sqrt/… avoid recomputation). */
+    readonly deriv: (x: number, y: number) => number;
+}
+/**
+ * The canonical table. Derivatives are stated in the cheapest exact form
+ * (reusing y where that avoids a redundant transcendental call).
+ */
+export declare const DUAL_UNARY_RULES: {
+    exp: {
+        primal: (x: number) => number;
+        deriv: (_x: number, y: number) => number;
+    };
+    expm1: {
+        primal: (x: number) => number;
+        deriv: (_x: number, y: number) => number;
+    };
+    log: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    log2: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    log10: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    log1p: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    sin: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    cos: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    tan: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    asin: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    acos: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    atan: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    sinh: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    cosh: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    tanh: {
+        primal: (x: number) => number;
+        deriv: (_x: number, y: number) => number;
+    };
+    asinh: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    acosh: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    atanh: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    sqrt: {
+        primal: (x: number) => number;
+        deriv: (_x: number, y: number) => number;
+    };
+    cbrt: {
+        primal: (x: number) => number;
+        deriv: (_x: number, y: number) => number;
+    };
+    square: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    reciprocal: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    abs: {
+        primal: (x: number) => number;
+        deriv: (x: number) => number;
+    };
+    sign: {
+        primal: (x: number) => number;
+        deriv: () => number;
+    };
+};
+/** Name of a rule in {@link DUAL_UNARY_RULES}. */
+export type DualUnaryRuleName = keyof typeof DUAL_UNARY_RULES;
+//# sourceMappingURL=dual-rules.d.ts.map

package/dist/types/dual-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-rules.d.ts","sourceRoot":"","sources":["../../src/types/dual-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,YAAY;IACZ,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAClD;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwBnB,MAAM;QAAa,KAAK;;CACO,CAAC;AAE1C,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,gBAAgB,CAAC"}

package/dist/types/dual.d.ts

@@ -0,0 +1,36 @@
+export declare class Dual {
+    /** Function value (the real part). */
+    readonly value: number;
+    /** First derivative (the ε coefficient). */
+    readonly deriv: number;
+    constructor(value: number, deriv?: number);
+    /** A constant (derivative 0). */
+    static constant(v: number): Dual;
+    /** A seed variable (derivative 1) — the point of differentiation. */
+    static variable(v: number): Dual;
+    add(o: Dual): Dual;
+    sub(o: Dual): Dual;
+    mul(o: Dual): Dual;
+    div(o: Dual): Dual;
+    neg(): Dual;
+    /** Power with a constant real exponent: d(xᵏ) = k·xᵏ⁻¹·dx. */
+    powConst(k: number): Dual;
+    /** General power a^b: d = a^b·(b'·ln a + b·a'/a). */
+    pow(o: Dual): Dual;
+    private unary;
+    sin(): Dual;
+    cos(): Dual;
+    tan(): Dual;
+    exp(): Dual;
+    log(): Dual;
+    sqrt(): Dual;
+    square(): Dual;
+    abs(): Dual;
+    sinh(): Dual;
+    cosh(): Dual;
+    tanh(): Dual;
+    toString(): string;
+}
+/** Type guard for {@link Dual}. */
+export declare function isDual(x: unknown): x is Dual;
+//# sourceMappingURL=dual.d.ts.map

package/dist/types/dual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual.d.ts","sourceRoot":"","sources":["../../src/types/dual.ts"],"names":[],"mappings":"AAkBA,qBAAa,IAAI;IACf,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,YAAY,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,EAGnC;IAED,iCAAiC;IACjC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAE/B;IAED,qEAAqE;IACrE,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAE/B;IAGD,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEjB;IACD,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEjB;IACD,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEjB;IACD,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAGjB;IACD,GAAG,IAAI,IAAI,CAEV;IACD,8DAA8D;IAC9D,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAExB;IACD,qDAAqD;IACrD,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAIjB;IAMD,OAAO,CAAC,KAAK;IAIb,GAAG,IAAI,IAAI,CAEV;IACD,GAAG,IAAI,IAAI,CAEV;IACD,GAAG,IAAI,IAAI,CAEV;IACD,GAAG,IAAI,IAAI,CAEV;IACD,GAAG,IAAI,IAAI,CAEV;IACD,IAAI,IAAI,IAAI,CAEX;IACD,MAAM,IAAI,IAAI,CAEb;IACD,GAAG,IAAI,IAAI,CAEV;IACD,IAAI,IAAI,IAAI,CAEX;IACD,IAAI,IAAI,IAAI,CAEX;IACD,IAAI,IAAI,IAAI,CAEX;IAED,QAAQ,IAAI,MAAM,CAEjB;CACF;AAED,mCAAmC;AACnC,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,CAE5C"}

package/dist/types/fraction.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Fraction (rational number) implementation
+ * @module @danielsimonjr/mathts-core/types/fraction
+ */
+import type { Scalar, IFraction } from './interfaces';
+/**
+ * Check if a value is a Fraction
+ */
+export declare function isFraction(value: unknown): value is Fraction;
+/**
+ * Fraction class for exact rational arithmetic
+ * Uses bigint for arbitrary precision numerator and denominator.
+ * All fractions are automatically reduced to lowest terms.
+ */
+export declare class Fraction implements IFraction {
+    readonly type = "Fraction";
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+    constructor(numerator: bigint | number | string | Fraction, denominator?: bigint | number | string | Fraction);
+    /**
+     * Create a Fraction from a number (with optional precision)
+     */
+    static fromNumber(n: number, maxDenominator?: bigint): Fraction;
+    /**
+     * Create a Fraction from a decimal string
+     */
+    static fromDecimalString(str: string): Fraction;
+    /**
+     * Parse a fraction from a string
+     * Supports formats: "3/4", "-3/4", "3", "3.14", "0.(3)"
+     */
+    static parse(str: string): Fraction;
+    /**
+     * Create a Fraction from a JSON object
+     */
+    static fromJSON(json: {
+        n: string;
+        d: string;
+    } | {
+        numerator: string;
+        denominator: string;
+    }): Fraction;
+    /**
+     * Compare two fractions
+     * @returns -1, 0, or 1
+     */
+    static compare(a: Fraction, b: Fraction): number;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): {
+        mathjs: string;
+        n: string;
+        d: string;
+    };
+    /**
+     * Convert to number
+     */
+    toNumber(): number;
+    /**
+     * Convert to decimal string with specified precision
+     */
+    toDecimal(precision?: number): string;
+    /**
+     * Convert to LaTeX string
+     */
+    toLatex(): string;
+    /**
+     * Convert to mixed number representation
+     */
+    toMixed(): {
+        whole: bigint;
+        numerator: bigint;
+        denominator: bigint;
+    };
+    /**
+     * Addition: a/b + c/d = (ad + bc) / bd
+     */
+    add(other: Scalar): Fraction;
+    /**
+     * Subtraction: a/b - c/d = (ad - bc) / bd
+     */
+    subtract(other: Scalar): Fraction;
+    /**
+     * Multiplication: a/b * c/d = ac / bd
+     */
+    multiply(other: Scalar): Fraction;
+    /**
+     * Division: a/b ÷ c/d = ad / bc
+     */
+    divide(other: Scalar): Fraction;
+    mul(other: Scalar): Fraction;
+    sub(other: Scalar): Fraction;
+    div(other: Scalar): Fraction;
+    /**
+     * Negation: -(a/b) = -a/b
+     */
+    negate(): Fraction;
+    /**
+     * Absolute value: |a/b|
+     */
+    abs(): Fraction;
+    /**
+     * Reciprocal: b/a
+     */
+    inverse(): Fraction;
+    /**
+     * Power (integer exponent)
+     */
+    pow(n: number | bigint): Fraction;
+    /**
+     * Modulo operation
+     */
+    mod(other: Fraction): Fraction;
+    /**
+     * Check equality
+     */
+    equals(other: Fraction): boolean;
+    /**
+     * Check if less than
+     */
+    lessThan(other: Fraction): boolean;
+    /**
+     * Check if less than or equal
+     */
+    lessThanOrEqual(other: Fraction): boolean;
+    /**
+     * Check if greater than
+     */
+    greaterThan(other: Fraction): boolean;
+    /**
+     * Check if greater than or equal
+     */
+    greaterThanOrEqual(other: Fraction): boolean;
+    /**
+     * Compare with another fraction
+     * @returns -1, 0, or 1
+     */
+    compareTo(other: Fraction): number;
+    compare(other: Fraction): number;
+    /**
+     * Return fraction already in lowest terms (no-op since constructor reduces)
+     */
+    simplify(): Fraction;
+    /**
+     * Check if this is zero
+     */
+    isZero(): boolean;
+    /**
+     * Check if this is positive
+     */
+    isPositive(): boolean;
+    /**
+     * Check if this is negative
+     */
+    isNegative(): boolean;
+    /**
+     * Check if this is an integer
+     */
+    isInteger(): boolean;
+    /**
+     * Check if this is a unit fraction (1/n)
+     */
+    isUnit(): boolean;
+    /**
+     * Floor: largest integer ≤ this
+     */
+    floor(): Fraction;
+    /**
+     * Ceiling: smallest integer ≥ this
+     */
+    ceil(): Fraction;
+    /**
+     * Round to nearest integer
+     */
+    round(): Fraction;
+    /**
+     * Truncate (round toward zero)
+     */
+    trunc(): Fraction;
+    /**
+     * Get the sign: -1, 0, or 1
+     */
+    sign(): number;
+    /**
+     * Clone this fraction
+     */
+    clone(): Fraction;
+    /**
+     * Get the GCD of numerator and denominator (always 1 since we reduce)
+     */
+    gcd(): bigint;
+    /**
+     * Get continued fraction representation
+     */
+    toContinuedFraction(): bigint[];
+    /**
+     * Create fraction from continued fraction
+     */
+    static fromContinuedFraction(cf: bigint[]): Fraction;
+    /**
+     * Mediant of two fractions: (a+c)/(b+d)
+     * Used in Stern-Brocot tree and Farey sequences
+     */
+    mediant(other: Fraction): Fraction;
+}
+/**
+ * Common fraction constants
+ */
+export declare const FRACTION_ZERO: Fraction;
+export declare const FRACTION_ONE: Fraction;
+export declare const FRACTION_NEG_ONE: Fraction;
+export declare const FRACTION_HALF: Fraction;
+export declare const FRACTION_THIRD: Fraction;
+export declare const FRACTION_QUARTER: Fraction;
+//# sourceMappingURL=fraction.d.ts.map

package/dist/types/fraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fraction.d.ts","sourceRoot":"","sources":["../../src/types/fraction.ts"],"names":[],"mappings":"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"}

package/dist/types/interfaces.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Base interfaces for MathTS types
+ * @module @danielsimonjr/mathts-core/types/interfaces
+ */
+/**
+ * Base interface for all MathTS numeric types
+ */
+export interface MathTSValue {
+    readonly type: string;
+    valueOf(): number | bigint;
+    toString(): string;
+    toJSON(): unknown;
+}
+/**
+ * Scalar types that support arithmetic
+ */
+export interface Scalar extends MathTSValue {
+    add(other: Scalar): Scalar;
+    subtract(other: Scalar): Scalar;
+    multiply(other: Scalar): Scalar;
+    divide(other: Scalar): Scalar;
+    negate(): Scalar;
+    abs(): Scalar | number;
+}
+/**
+ * Available computation backends
+ */
+export type BackendType = 'js' | 'wasm' | 'gpu';
+/**
+ * Supported numeric types
+ */
+export type NumericType = 'float32' | 'float64' | 'int32' | 'int64' | 'complex64' | 'complex128';
+/**
+ * Matrix backend interface
+ */
+export interface MatrixBackend {
+    readonly name: BackendType;
+    readonly isAvailable: boolean;
+    matmul(a: Float64Array, b: Float64Array, m: number, n: number, k: number): Float64Array;
+    transpose(data: Float64Array, rows: number, cols: number): Float64Array;
+    add(a: Float64Array, b: Float64Array): Float64Array;
+    subtract(a: Float64Array, b: Float64Array): Float64Array;
+    scale(data: Float64Array, scalar: number): Float64Array;
+    lu(data: Float64Array, n: number): {
+        L: Float64Array;
+        U: Float64Array;
+        P: Int32Array;
+    };
+    qr(data: Float64Array, m: number, n: number): {
+        Q: Float64Array;
+        R: Float64Array;
+    };
+    svd(data: Float64Array, m: number, n: number): {
+        U: Float64Array;
+        S: Float64Array;
+        V: Float64Array;
+    };
+    eig(data: Float64Array, n: number): {
+        values: Float64Array;
+        vectors: Float64Array;
+    };
+}
+/**
+ * Matrix interface with backend abstraction
+ */
+export interface IMatrix<T = number> extends MathTSValue {
+    readonly rows: number;
+    readonly cols: number;
+    readonly size: readonly [number, number];
+    readonly length: number;
+    readonly backend: MatrixBackend;
+    get(row: number, col: number): T;
+    set(row: number, col: number, value: T): void;
+    row(index: number): IMatrix<T>;
+    column(index: number): IMatrix<T>;
+    slice(rowStart: number, rowEnd: number, colStart: number, colEnd: number): IMatrix<T>;
+    transpose(): IMatrix<T>;
+    reshape(rows: number, cols: number): IMatrix<T>;
+    flatten(): T[];
+    add(other: IMatrix<T> | T): IMatrix<T>;
+    subtract(other: IMatrix<T> | T): IMatrix<T>;
+    multiply(other: IMatrix<T> | T): IMatrix<T>;
+    toArray(): T[][];
+    toBuffer(): ArrayBuffer;
+    clone(): IMatrix<T>;
+}
+/**
+ * Complex number interface
+ */
+export interface IComplex extends Scalar {
+    readonly re: number;
+    readonly im: number;
+    conjugate(): IComplex;
+    arg(): number;
+    sqrt(): IComplex;
+    exp(): IComplex;
+    log(): IComplex;
+}
+/**
+ * Fraction interface for exact rational arithmetic
+ */
+export interface IFraction extends Scalar {
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+    simplify(): IFraction;
+    toNumber(): number;
+}
+/**
+ * BigNumber interface for arbitrary precision decimals
+ */
+export interface IBigNumber extends MathTSValue {
+    add(other: IBigNumber | number | string): IBigNumber;
+    subtract(other: IBigNumber | number | string): IBigNumber;
+    multiply(other: IBigNumber | number | string): IBigNumber;
+    divide(other: IBigNumber | number | string): IBigNumber;
+    negate(): IBigNumber;
+    abs(): IBigNumber;
+    pow(n: number | bigint): IBigNumber;
+    sqrt(): IBigNumber;
+    isNaN(): boolean;
+    isFinite(): boolean;
+    isInfinite(): boolean;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    isInteger(): boolean;
+    equals(other: IBigNumber): boolean;
+    lessThan(other: IBigNumber): boolean;
+    greaterThan(other: IBigNumber): boolean;
+    compareTo(other: IBigNumber): number;
+    toFixed(decimalPlaces?: number): string;
+    toExponential(decimalPlaces?: number): string;
+    toPrecision(significantDigits?: number): string;
+    toBigInt(): bigint;
+}
+/**
+ * Matrix dimensions
+ */
+export interface MatrixDimensions {
+    rows: number;
+    cols: number;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/types/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/types/interfaces.ts"],"names":[],"mappings":"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"}