@danielsimonjr/mathts-core 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1236 @@
+import { TypedInstance, TypedFunction } from 'typed-function';
+export { ReferTo, ReferToSelf, SignatureFunction, TypedFunction, TypedInstance, create, default as typed } from 'typed-function';
+
+/**
+ * Base interfaces for MathTS types
+ * @module @danielsimonjr/mathts-core/types/interfaces
+ */
+/**
+ * Base interface for all MathTS numeric types
+ */
+interface MathTSValue {
+    readonly type: string;
+    valueOf(): number | bigint;
+    toString(): string;
+    toJSON(): unknown;
+}
+/**
+ * Scalar types that support arithmetic
+ */
+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
+ */
+type BackendType = 'js' | 'wasm' | 'gpu';
+/**
+ * Supported numeric types
+ */
+type NumericType = 'float32' | 'float64' | 'int32' | 'int64' | 'complex64' | 'complex128';
+/**
+ * Matrix backend interface
+ */
+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
+ */
+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
+ */
+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
+ */
+interface IFraction extends Scalar {
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+    simplify(): IFraction;
+    toNumber(): number;
+}
+/**
+ * BigNumber interface for arbitrary precision decimals
+ */
+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
+ */
+interface MatrixDimensions {
+    rows: number;
+    cols: number;
+}
+
+/**
+ * Complex number implementation
+ * @module @danielsimonjr/mathts-core/types/complex
+ */
+
+/**
+ * Check if a value is a Complex number
+ */
+declare function isComplex(value: unknown): value is Complex;
+/**
+ * Complex number class with full arithmetic support
+ * Implements the IComplex interface for type-safe complex number operations.
+ */
+declare class Complex implements IComplex {
+    readonly type = "Complex";
+    readonly re: number;
+    readonly im: number;
+    constructor(re: number, im?: number);
+    /**
+     * Create a Complex from polar form (r, θ)
+     * @param r - magnitude (radius)
+     * @param theta - angle in radians
+     */
+    static fromPolar(r: number, theta: number): Complex;
+    /**
+     * Create a Complex from a real number
+     */
+    static fromNumber(n: number): Complex;
+    /**
+     * Create a Complex from a JSON object
+     */
+    static fromJSON(json: {
+        re: number;
+        im: number;
+    }): Complex;
+    /**
+     * Parse a complex number from a string
+     * Supports formats: "3+4i", "3-4i", "3", "4i", "-4i", "i", "-i"
+     */
+    static parse(str: string): Complex;
+    /**
+     * Compare two complex numbers lexicographically (re first, then im)
+     * @returns -1, 0, or 1
+     */
+    static compare(a: Complex, b: Complex): number;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): {
+        mathjs: string;
+        re: number;
+        im: number;
+    };
+    /**
+     * Return polar representation
+     */
+    toPolar(): {
+        r: number;
+        phi: number;
+    };
+    /**
+     * Format with options (precision, notation, etc.)
+     */
+    format(options?: {
+        precision?: number;
+        notation?: 'fixed' | 'exponential' | 'auto';
+    }): string;
+    /**
+     * Complex conjugate (a + bi → a - bi)
+     */
+    conjugate(): Complex;
+    /**
+     * Magnitude (absolute value) |z| = √(re² + im²)
+     */
+    abs(): number;
+    /**
+     * Phase angle (argument) in radians, range (-π, π]
+     */
+    arg(): number;
+    /**
+     * Squared magnitude |z|² = re² + im²
+     * More efficient than abs() when you don't need the square root
+     */
+    abs2(): number;
+    /**
+     * Addition: (a + bi) + (c + di) = (a + c) + (b + d)i
+     */
+    add(other: Scalar): Complex;
+    /**
+     * Subtraction: (a + bi) - (c + di) = (a - c) + (b - d)i
+     */
+    subtract(other: Scalar): Complex;
+    /**
+     * Multiplication: (a + bi)(c + di) = (ac - bd) + (ad + bc)i
+     */
+    multiply(other: Scalar): Complex;
+    /**
+     * Division: (a + bi)/(c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
+     */
+    divide(other: Scalar): Complex;
+    /**
+     * Negation: -(a + bi) = -a - bi
+     */
+    negate(): Complex;
+    /**
+     * Multiplicative inverse: 1/z = z̄/|z|²
+     */
+    inverse(): Complex;
+    /**
+     * Square root using principal branch
+     * √z = √r · e^(iθ/2) where r = |z|, θ = arg(z)
+     */
+    sqrt(): Complex;
+    /**
+     * n-th root (returns principal root)
+     */
+    nthRoot(n: number): Complex;
+    /**
+     * All n-th roots
+     */
+    nthRoots(n: number): Complex[];
+    /**
+     * Exponential: e^(a+bi) = e^a · (cos(b) + i·sin(b))
+     */
+    exp(): Complex;
+    /**
+     * Natural logarithm: ln(z) = ln|z| + i·arg(z)
+     */
+    log(): Complex;
+    /**
+     * Logarithm base 10
+     */
+    log10(): Complex;
+    /**
+     * Logarithm base 2
+     */
+    log2(): Complex;
+    /**
+     * Power: z^w = e^(w·ln(z))
+     */
+    pow(n: number | Complex): Complex;
+    /**
+     * Sine: sin(a + bi) = sin(a)cosh(b) + i·cos(a)sinh(b)
+     */
+    sin(): Complex;
+    /**
+     * Cosine: cos(a + bi) = cos(a)cosh(b) - i·sin(a)sinh(b)
+     */
+    cos(): Complex;
+    /**
+     * Tangent: tan(z) = sin(z) / cos(z)
+     */
+    tan(): Complex;
+    /**
+     * Cotangent: cot(z) = cos(z) / sin(z)
+     */
+    cot(): Complex;
+    /**
+     * Secant: sec(z) = 1 / cos(z)
+     */
+    sec(): Complex;
+    /**
+     * Cosecant: csc(z) = 1 / sin(z)
+     */
+    csc(): Complex;
+    /**
+     * Hyperbolic sine: sinh(z) = (e^z - e^(-z)) / 2
+     */
+    sinh(): Complex;
+    /**
+     * Hyperbolic cosine: cosh(z) = (e^z + e^(-z)) / 2
+     */
+    cosh(): Complex;
+    /**
+     * Hyperbolic tangent: tanh(z) = sinh(z) / cosh(z)
+     */
+    tanh(): Complex;
+    /**
+     * Hyperbolic cotangent: coth(z) = cosh(z) / sinh(z)
+     */
+    coth(): Complex;
+    /**
+     * Hyperbolic secant: sech(z) = 1 / cosh(z)
+     */
+    sech(): Complex;
+    /**
+     * Hyperbolic cosecant: csch(z) = 1 / sinh(z)
+     */
+    csch(): Complex;
+    /**
+     * Arc sine: asin(z) = -i·ln(iz + √(1 - z²))
+     */
+    asin(): Complex;
+    /**
+     * Arc cosine: acos(z) = π/2 - asin(z)
+     */
+    acos(): Complex;
+    /**
+     * Arc tangent: atan(z) = (i/2)·ln((i + z)/(i - z))
+     */
+    atan(): Complex;
+    /**
+     * Inverse hyperbolic sine: asinh(z) = ln(z + √(z² + 1))
+     */
+    asinh(): Complex;
+    /**
+     * Inverse hyperbolic cosine: acosh(z) = ln(z + √(z² - 1))
+     */
+    acosh(): Complex;
+    /**
+     * Inverse hyperbolic tangent: atanh(z) = (1/2)·ln((1 + z)/(1 - z))
+     */
+    atanh(): Complex;
+    /**
+     * Check equality within tolerance
+     */
+    equals(other: Complex, epsilon?: number): boolean;
+    /**
+     * Check if this is a real number (im ≈ 0)
+     */
+    isReal(epsilon?: number): boolean;
+    /**
+     * Check if this is purely imaginary (re ≈ 0, im ≠ 0)
+     */
+    isImaginary(epsilon?: number): boolean;
+    /**
+     * Check if this is zero
+     */
+    isZero(epsilon?: number): boolean;
+    /**
+     * Check if this is NaN
+     */
+    isNaN(): boolean;
+    /**
+     * Check if this is infinite
+     */
+    isInfinite(): boolean;
+    /**
+     * Clone this complex number
+     */
+    clone(): Complex;
+    /**
+     * Round real and imaginary parts to specified decimals
+     */
+    round(decimals?: number): Complex;
+    /**
+     * Floor real and imaginary parts
+     */
+    floor(): Complex;
+    /**
+     * Ceil real and imaginary parts
+     */
+    ceil(): Complex;
+    /**
+     * Sign function: z / |z| (unit complex number in same direction)
+     */
+    sign(): Complex;
+}
+/**
+ * Imaginary unit constant: i = √(-1)
+ */
+declare const I: Complex;
+/**
+ * Common constants
+ */
+declare const COMPLEX_ZERO: Complex;
+declare const COMPLEX_ONE: Complex;
+declare const COMPLEX_NEG_ONE: Complex;
+
+/**
+ * Fraction (rational number) implementation
+ * @module @danielsimonjr/mathts-core/types/fraction
+ */
+
+/**
+ * Check if a value is a Fraction
+ */
+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.
+ */
+declare class Fraction implements IFraction {
+    readonly type = "Fraction";
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+    constructor(numerator: bigint | number | string, denominator?: bigint | number | string);
+    /**
+     * 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;
+    /**
+     * 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
+ */
+declare const FRACTION_ZERO: Fraction;
+declare const FRACTION_ONE: Fraction;
+declare const FRACTION_NEG_ONE: Fraction;
+declare const FRACTION_HALF: Fraction;
+declare const FRACTION_THIRD: Fraction;
+declare const FRACTION_QUARTER: Fraction;
+
+/**
+ * BigNumber (arbitrary precision decimal) implementation
+ * @module @danielsimonjr/mathts-core/types/bignumber
+ */
+
+/**
+ * Check if a value is a BigNumber
+ */
+declare function isBigNumber(value: unknown): value is BigNumber;
+/**
+ * Configuration for BigNumber operations
+ */
+interface BigNumberConfig {
+    /** Number of significant digits (default: 64) */
+    precision: number;
+    /** Rounding mode (default: 'halfUp') */
+    rounding: RoundingMode;
+    /** Minimum exponent (default: -1e9) */
+    minExponent: number;
+    /** Maximum exponent (default: 1e9) */
+    maxExponent: number;
+}
+type RoundingMode = 'up' | 'down' | 'ceil' | 'floor' | 'halfUp' | 'halfDown' | 'halfEven' | 'halfCeil' | 'halfFloor';
+/**
+ * BigNumber class for arbitrary precision decimal arithmetic
+ *
+ * Internally stores: sign * coefficient * 10^exponent
+ * where coefficient is a bigint with the significant digits.
+ */
+declare class BigNumber implements MathTSValue {
+    readonly type = "BigNumber";
+    private readonly _sign;
+    private readonly _coefficient;
+    private readonly _exponent;
+    private readonly _isNaN;
+    private readonly _isInfinite;
+    private constructor();
+    /**
+     * Create a BigNumber from a number
+     */
+    static fromNumber(n: number): BigNumber;
+    /**
+     * Create a BigNumber from a string
+     */
+    static parse(str: string): BigNumber;
+    /**
+     * Create from bigint
+     */
+    static fromBigInt(n: bigint): BigNumber;
+    /**
+     * Create a BigNumber from a JSON object
+     */
+    static fromJSON(json: {
+        value: string;
+    }): BigNumber;
+    /**
+     * Get/set global configuration
+     */
+    static config(newConfig?: Partial<BigNumberConfig>): BigNumberConfig;
+    /**
+     * Reset configuration to defaults
+     */
+    static resetConfig(): void;
+    /**
+     * Compare two BigNumbers
+     * @returns -1, 0, or 1
+     */
+    static compare(a: BigNumber, b: BigNumber): number;
+    private static compareMagnitude;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): {
+        mathjs: string;
+        value: string;
+    };
+    /**
+     * Convert to fixed-point notation
+     */
+    toFixed(decimalPlaces?: number): string;
+    private toFixedInternal;
+    /**
+     * Convert to exponential notation
+     */
+    toExponential(decimalPlaces?: number): string;
+    /**
+     * Convert to precision
+     */
+    toPrecision(significantDigits?: number): string;
+    /**
+     * Convert to bigint (truncated)
+     */
+    toBigInt(): bigint;
+    /**
+     * Addition
+     */
+    add(other: Scalar | BigNumber | number | string): BigNumber;
+    /**
+     * Subtraction
+     */
+    subtract(other: Scalar | BigNumber | number | string): BigNumber;
+    /**
+     * Multiplication
+     */
+    multiply(other: Scalar | BigNumber | number | string): BigNumber;
+    /**
+     * Division
+     */
+    divide(other: Scalar | BigNumber | number | string): BigNumber;
+    /**
+     * Negation
+     */
+    negate(): BigNumber;
+    /**
+     * Absolute value
+     */
+    abs(): BigNumber;
+    /**
+     * Power (integer exponent)
+     */
+    pow(n: number | bigint): BigNumber;
+    /**
+     * Square root
+     */
+    sqrt(): BigNumber;
+    equals(other: BigNumber): boolean;
+    lessThan(other: BigNumber): boolean;
+    lessThanOrEqual(other: BigNumber): boolean;
+    greaterThan(other: BigNumber): boolean;
+    greaterThanOrEqual(other: BigNumber): boolean;
+    compareTo(other: BigNumber): number;
+    compare(other: BigNumber): number;
+    /**
+     * Round to specified decimal places
+     */
+    round(decimalPlaces?: number, mode?: RoundingMode): BigNumber;
+    private shouldRound;
+    /**
+     * Round to specified precision (significant digits)
+     */
+    roundToPrecision(precision: number, mode?: RoundingMode): BigNumber;
+    floor(): BigNumber;
+    ceil(): BigNumber;
+    trunc(): BigNumber;
+    /**
+     * Modulo (remainder after division)
+     * Result has the same sign as the dividend (this).
+     */
+    mod(other: Scalar | BigNumber | number | string): BigNumber;
+    /**
+     * Sine of this BigNumber (in radians)
+     * Uses Taylor series: sin(x) = x - x^3/3! + x^5/5! - ...
+     */
+    sin(): BigNumber;
+    /**
+     * Cosine of this BigNumber (in radians)
+     * Uses Taylor series: cos(x) = 1 - x^2/2! + x^4/4! - ...
+     */
+    cos(): BigNumber;
+    /**
+     * Tangent of this BigNumber (in radians)
+     * tan(x) = sin(x) / cos(x)
+     */
+    tan(): BigNumber;
+    /**
+     * Arcsine of this BigNumber
+     * Returns value in [-PI/2, PI/2]
+     */
+    asin(): BigNumber;
+    /**
+     * Arccosine of this BigNumber
+     * Returns value in [0, PI]
+     */
+    acos(): BigNumber;
+    /**
+     * Arctangent of this BigNumber
+     * Returns value in (-PI/2, PI/2)
+     * Uses Taylor series with argument reduction for convergence.
+     */
+    atan(): BigNumber;
+    /**
+     * Two-argument arctangent: atan2(y, x)
+     * this = y, argument = x
+     * Returns angle in (-PI, PI]
+     */
+    atan2(x: BigNumber): BigNumber;
+    /**
+     * Hyperbolic sine: sinh(x) = (e^x - e^(-x)) / 2
+     */
+    sinh(): BigNumber;
+    /**
+     * Hyperbolic cosine: cosh(x) = (e^x + e^(-x)) / 2
+     */
+    cosh(): BigNumber;
+    /**
+     * Hyperbolic tangent: tanh(x) = sinh(x) / cosh(x)
+     */
+    tanh(): BigNumber;
+    /**
+     * Inverse hyperbolic sine: asinh(x) = ln(x + sqrt(x^2 + 1))
+     */
+    asinh(): BigNumber;
+    /**
+     * Inverse hyperbolic cosine: acosh(x) = ln(x + sqrt(x^2 - 1))
+     * Domain: x >= 1
+     */
+    acosh(): BigNumber;
+    /**
+     * Inverse hyperbolic tangent: atanh(x) = 0.5 * ln((1+x)/(1-x))
+     * Domain: -1 < x < 1
+     */
+    atanh(): BigNumber;
+    /**
+     * Exponential function: e^x
+     * Uses Taylor series: e^x = 1 + x + x^2/2! + x^3/3! + ...
+     * With argument reduction: e^x = (e^(x/2^k))^(2^k) for faster convergence.
+     */
+    exp(): BigNumber;
+    /**
+     * Natural logarithm: ln(x)
+     * Uses the AGM (arithmetic-geometric mean) method for fast convergence.
+     * Fallback: series ln((1+y)/(1-y)) = 2*(y + y^3/3 + y^5/5 + ...) where y = (x-1)/(x+1)
+     */
+    ln(): BigNumber;
+    /**
+     * Base-10 logarithm: log10(x) = ln(x) / ln(10)
+     */
+    log10(): BigNumber;
+    /**
+     * Base-2 logarithm: log2(x) = ln(x) / ln(2)
+     */
+    log2(): BigNumber;
+    /**
+     * Cube root
+     * Uses Newton-Raphson iteration.
+     */
+    cbrt(): BigNumber;
+    /**
+     * e^x - 1 (more precise than exp(x) - 1 for small x)
+     * Uses Taylor series directly: expm1(x) = x + x^2/2! + x^3/3! + ...
+     */
+    expm1(): BigNumber;
+    /**
+     * ln(1 + x) (more precise than ln(1 + x) for small x)
+     */
+    log1p(): BigNumber;
+    /**
+     * Hypotenuse: sqrt(this^2 + other^2)
+     */
+    hypot(other: BigNumber): BigNumber;
+    /** Reduce angle to [-PI, PI] range */
+    private _reduceAngle;
+    /** Taylor series for sin(x), assumes x is in [-PI, PI] */
+    private _sinTaylor;
+    /** Taylor series for cos(x), assumes x is in [-PI, PI] */
+    private _cosTaylor;
+    /** Taylor series for atan(x), assumes |x| <= 0.5 */
+    private _atanTaylor;
+    isNaN(): boolean;
+    isFinite(): boolean;
+    isInfinite(): boolean;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    isInteger(): boolean;
+    sign(): number;
+    clone(): BigNumber;
+    private ensureBigNumber;
+    private alignExponents;
+    private normalize;
+}
+/**
+ * Common BigNumber constants
+ */
+declare const BIGNUMBER_ZERO: BigNumber;
+declare const BIGNUMBER_ONE: BigNumber;
+declare const BIGNUMBER_NEG_ONE: BigNumber;
+declare const BIGNUMBER_TEN: BigNumber;
+declare const BIGNUMBER_PI: BigNumber;
+declare const BIGNUMBER_E: BigNumber;
+declare const BIGNUMBER_LN2: BigNumber;
+declare const BIGNUMBER_LN10: BigNumber;
+
+/**
+ * MathTS typed-function Integration
+ *
+ * Creates a configured typed-function instance with MathTS types
+ * for runtime type dispatch across numeric types, matrices, and more.
+ *
+ * This module directly uses the typed-function library API without
+ * any intermediate abstraction layers.
+ *
+ * Supports WASM-accelerated dispatch when available.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Initialize WASM dispatch for typed-function (optional, improves performance)
+ *
+ * Uses the unified typed.init() API to enable WASM-accelerated dispatch
+ * with automatic fallback to pure JS when WASM is unavailable.
+ *
+ * @param options - Initialization options
+ * @returns Promise resolving to true if WASM was initialized successfully
+ */
+declare function initTypedWasm(options?: {
+    preferWasm?: boolean;
+}): Promise<boolean>;
+/**
+ * Check if WASM dispatch is available
+ */
+declare function isTypedWasmAvailable(): boolean;
+
+/**
+ * Type definition for typed-function
+ */
+interface TypeDef {
+    name: string;
+    test: (x: unknown) => boolean;
+}
+/**
+ * Conversion definition for typed-function
+ */
+interface ConversionDef {
+    from: string;
+    to: string;
+    convert: (value: unknown) => unknown;
+}
+declare const isNumber: (x: unknown) => x is number;
+declare const isBoolean: (x: unknown) => x is boolean;
+declare const isString: (x: unknown) => x is string;
+declare const isBigInt: (x: unknown) => x is bigint;
+declare const isArray: (x: unknown) => x is unknown[];
+declare const isFunction: (x: unknown) => x is (...args: unknown[]) => unknown;
+declare const isObject: (x: unknown) => x is object;
+declare const isNull: (x: unknown) => x is null;
+declare const isUndefined: (x: unknown) => x is undefined;
+/**
+ * Check if value is a Matrix (duck typing until Matrix class is implemented)
+ */
+declare const isMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a DenseMatrix
+ */
+declare const isDenseMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a SparseMatrix
+ */
+declare const isSparseMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a Unit
+ */
+declare const isUnit: (x: unknown) => boolean;
+/**
+ * Extended type definition with optional WASM mask support
+ */
+interface MathTSTypeDef extends TypeDef {
+    /** Optional WASM type mask for accelerated dispatch (auto-registered when WASM available) */
+    wasmMask?: number;
+}
+/**
+ * MathTS-specific types to add to typed-function.
+ * Note: Most primitive types (number, boolean, string, etc.) are already built into typed-function
+ *
+ * When WASM is available, custom type masks are automatically registered for efficient dispatch.
+ */
+declare const MATHTS_TYPES: MathTSTypeDef[];
+declare const MATHTS_CONVERSIONS: ConversionDef[];
+/**
+ * Create a new MathTS typed instance
+ *
+ * This creates an isolated typed universe with MathTS types and conversions.
+ * Uses typed-function's addType() API which automatically registers WASM
+ * type masks when available.
+ *
+ * @returns A new typed-function instance configured for MathTS
+ *
+ * @example
+ * ```typescript
+ * const myTyped = createMathTSTyped();
+ *
+ * const add = myTyped('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'Complex, Complex': (a, b) => a.add(b),
+ *   'Fraction, Fraction': (a, b) => a.add(b),
+ *   'BigNumber, BigNumber': (a, b) => a.add(b),
+ * });
+ * ```
+ */
+declare function createMathTSTyped(): TypedInstance;
+/**
+ * Default MathTS typed instance
+ *
+ * This is the primary typed-function instance used throughout MathTS.
+ * It comes pre-configured with all MathTS types and conversions.
+ *
+ * @example
+ * ```typescript
+ * import { mathTyped, Complex, Fraction, BigNumber } from '@danielsimonjr/mathts-core';
+ *
+ * // Create a polymorphic add function
+ * const add = mathTyped('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'Complex, Complex': (a, b) => a.add(b),
+ *   'Fraction, Fraction': (a, b) => a.add(b),
+ *   'BigNumber, BigNumber': (a, b) => a.add(b),
+ * });
+ *
+ * // Works with automatic type coercion
+ * add(1, 2);                              // 3
+ * add(new Complex(1, 2), new Complex(3, 4)); // Complex(4, 6)
+ * add(new Fraction(1, 2), new Fraction(1, 3)); // Fraction(5, 6)
+ * add(1, new Complex(2, 3));              // Complex(3, 3) - auto-converts
+ * ```
+ */
+declare const mathTyped: TypedInstance;
+
+/**
+ * TypeRegistry class for managing custom type registrations
+ * This is a MathTS utility, not from typed-function
+ */
+declare class TypeRegistry {
+    private types;
+    private conversions;
+    private instance;
+    /**
+     * Register a new type
+     */
+    registerType<T>(name: string, test: (x: unknown) => x is T): this;
+    /**
+     * Register a type conversion
+     */
+    registerConversion<From, To>(from: string, to: string, convert: (value: From) => To): this;
+    /**
+     * Check if a type is registered
+     */
+    hasType(name: string): boolean;
+    /**
+     * Check if a conversion is registered
+     */
+    hasConversion(from: string, to: string): boolean;
+    /**
+     * Get all registered type names
+     */
+    getTypeNames(): string[];
+    /**
+     * Build a typed-function instance from the registry
+     */
+    build(): TypedInstance;
+    /**
+     * Clear all registered types and conversions
+     */
+    clear(): void;
+}
+/**
+ * Helper to create a typed function with the MathTS typed instance
+ */
+declare function createTypedFunction<T>(name: string, signatures: {
+    [signature: string]: (...args: unknown[]) => T;
+}, typedInstance?: TypedInstance): (...args: unknown[]) => T;
+
+declare function registerNativeTypes(): void;
+
+/**
+ * MathTS Function Factory
+ *
+ * Provides a factory pattern for creating MathTS functions with:
+ * - Typed function dispatch via typed-function
+ * - Dependency injection for inter-function references
+ * - Backend selection integration
+ * - Lazy loading support
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Configuration for MathTS instance
+ */
+interface MathTSConfig {
+    /** Numeric precision (for BigNumber) */
+    precision: number;
+    /** Default matrix type */
+    matrix: 'Matrix' | 'Array';
+    /** Number type for parsing */
+    number: 'number' | 'BigNumber' | 'Fraction';
+    /** Enable predictable randomness */
+    randomSeed: string | null;
+    /** Epsilon for floating point comparison */
+    epsilon: number;
+    /** Preferred backend for matrix operations */
+    preferredBackend: 'auto' | 'js' | 'wasm' | 'gpu';
+    /** Minimum elements to use WASM backend */
+    wasmThreshold: number;
+    /** Minimum elements to use GPU backend */
+    gpuThreshold: number;
+    /** Enable parallel processing */
+    parallelEnabled: boolean;
+    /** Minimum elements to parallelize */
+    parallelThreshold: number;
+}
+/**
+ * Default MathTS configuration
+ */
+declare const DEFAULT_CONFIG: MathTSConfig;
+/**
+ * Factory function definition
+ */
+interface FactoryFunction<T = TypedFunction> {
+    /** Name of the function */
+    name: string;
+    /** Dependencies required by this function */
+    dependencies: string[];
+    /** Factory that creates the function given dependencies */
+    factory: (deps: FactoryDependencies) => T;
+}
+/**
+ * Dependencies passed to factory functions
+ */
+interface FactoryDependencies {
+    /** MathTS configuration */
+    config: MathTSConfig;
+    /** typed-function instance */
+    typed: TypedInstance;
+    /** Registered functions (for cross-references) */
+    [key: string]: unknown;
+}
+/**
+ * Import definition for a factory function
+ */
+type FactoryImport = FactoryFunction | (() => Promise<FactoryFunction>);
+/**
+ * MathTS function registry
+ */
+declare class FunctionRegistry {
+    private factories;
+    private instances;
+    private dependencies;
+    private creating;
+    constructor(config?: Partial<MathTSConfig>, typed?: TypedInstance);
+    /**
+     * Register a factory function
+     */
+    register(factory: FactoryFunction): void;
+    /**
+     * Register multiple factory functions
+     */
+    registerAll(factories: FactoryFunction[]): void;
+    /**
+     * Get or create a function by name
+     */
+    get(name: string): TypedFunction;
+    /**
+     * Check if a function is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered function names
+     */
+    names(): string[];
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<MathTSConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): MathTSConfig;
+}
+/**
+ * Create a factory function definition
+ *
+ * @example
+ * ```typescript
+ * export const addFactory = createFactory('add', ['typed'], ({ typed }) =>
+ *   typed('add', {
+ *     'number, number': (a, b) => a + b,
+ *     'Complex, Complex': (a, b) => ({ re: a.re + b.re, im: a.im + b.im }),
+ *   })
+ * );
+ * ```
+ */
+declare function createFactory<T = TypedFunction>(name: string, dependencies: string[], factory: (deps: FactoryDependencies) => T): FactoryFunction<T>;
+declare const registry: FunctionRegistry;
+declare const math: {
+    /**
+     * Get a registered function
+     */
+    get: (name: string) => TypedFunction;
+    /**
+     * Register a factory function
+     */
+    register: (factory: FactoryFunction) => void;
+    /**
+     * Get configuration
+     */
+    config: () => MathTSConfig;
+    /**
+     * Update configuration
+     */
+    configure: (config: Partial<MathTSConfig>) => void;
+};
+
+/**
+ * @danielsimonjr/mathts-core - Core types and utilities for MathTS
+ * @packageDocumentation
+ */
+
+declare const VERSION = "0.1.0";
+
+export { BIGNUMBER_E, BIGNUMBER_LN10, BIGNUMBER_LN2, BIGNUMBER_NEG_ONE, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_TEN, BIGNUMBER_ZERO, type BackendType, BigNumber, type BigNumberConfig, COMPLEX_NEG_ONE, COMPLEX_ONE, COMPLEX_ZERO, Complex, type ConversionDef, DEFAULT_CONFIG, FRACTION_HALF, FRACTION_NEG_ONE, FRACTION_ONE, FRACTION_QUARTER, FRACTION_THIRD, FRACTION_ZERO, type FactoryDependencies, type FactoryFunction, type FactoryImport, Fraction, FunctionRegistry, I, type IBigNumber, type IComplex, type IFraction, type IMatrix, MATHTS_CONVERSIONS, MATHTS_TYPES, type MathTSConfig, type MathTSValue, type MatrixBackend, type MatrixDimensions, type NumericType, type RoundingMode, type Scalar, type TypeDef, TypeRegistry, VERSION, createFactory, createMathTSTyped, createTypedFunction, initTypedWasm, isArray, isBigInt, isBigNumber, isBoolean, isComplex, isDenseMatrix, isFraction, isFunction, isMatrix, isNull, isNumber, isObject, isSparseMatrix, isString, isTypedWasmAvailable, isUndefined, isUnit, math, mathTyped, registerNativeTypes, registry };