/**
 * Typed Arithmetic Functions (Parallel-First)
 *
 * Polymorphic arithmetic operations using typed-function for runtime dispatch.
 * Supports Complex, Fraction, BigNumber, and Float64Array types.
 *
 * Following the parallel-first philosophy per CLAUDE.md:
 * - Use workers for ALL array transformations (Float64Array)
 * - Use workers for ALL numerical computations that can be batched
 * - Only fall back to sequential for trivial scalar operations
 *
 * @packageDocumentation
 */
import { ComputePool } from '@danielsimonjr/mathts-parallel';
/** 32-bit signed integer */
type i32 = number;
/**
 * Polymorphic addition function with parallel execution for arrays
 *
 * For Float64Array inputs, uses worker pool for parallel computation.
 * Falls back to sequential for scalar types.
 *
 * @example
 * ```typescript
 * 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)
 * await add(float64A, float64B);               // Parallel array add
 * ```
 */
export declare const add: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Polymorphic subtraction function with parallel execution for arrays
 */
export declare const subtract: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Polymorphic multiplication function with parallel execution for arrays
 */
export declare const multiply: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Polymorphic division function with parallel execution for arrays
 */
export declare const divide: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Unary negation with parallel array support
 */
export declare const unaryMinus: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Unary plus (identity)
 */
export declare const unaryPlus: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Absolute value with parallel array support
 */
export declare const abs: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Sign function
 */
export declare const sign: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Power function
 */
export declare const pow: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Square root with parallel array support
 */
export declare const sqrt: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Square with parallel array support
 */
export declare const square: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Cube
 */
export declare const cube: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Cube root
 */
export declare const cbrt: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * N-th root
 */
export declare const nthRoot: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Exponential function (e^x) with parallel array support
 */
export declare const exp: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Natural logarithm (ln x) with parallel array support
 */
export declare const log: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Base-10 logarithm
 */
export declare const log10: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Base-2 logarithm
 */
export declare const log2: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * log(1 + x) with higher precision for small x
 */
export declare const log1p: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * exp(x) - 1 with higher precision for small x
 */
export declare const expm1: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Round to nearest integer
 */
export declare const round: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Floor (round down)
 */
export declare const floor: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Ceiling (round up)
 */
export declare const ceil: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Truncate (round toward zero)
 */
export declare const fix: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Modulo operation
 */
export declare const mod: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Greatest common divisor
 */
export declare const gcd: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Least common multiple
 */
export declare const lcm: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Extended greatest common divisor
 * Returns [gcd, x, y] where gcd = a*x + b*y (Bezout coefficients)
 */
export declare const xgcd: import("@danielsimonjr/mathts-core").TypedFunction;
export declare const norm: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Hyperbolic sine
 */
export declare const sinh: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Hyperbolic cosine
 */
export declare const cosh: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Hyperbolic tangent
 */
export declare const tanh: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Check if values are equal
 */
export declare const equal: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Check if a < b
 */
export declare const smaller: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Check if a > b
 */
export declare const larger: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Check if a <= b
 */
export declare const smallerEq: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Check if a >= b
 */
export declare const largerEq: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Compare two values: -1, 0, or 1
 */
export declare const compare: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Minimum of values with parallel array support
 */
export declare const min: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Maximum of values with parallel array support
 */
export declare const max: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Sum with parallel array support
 */
/**
 * Exactly-rounded sum — the equivalent of Python's `math.fsum` / NumPy's `math.fsum` idiom.
 *
 * `sum` uses pairwise summation, which is accurate to ~machine epsilon and free. But pairwise
 * cannot recover a value that has already been annihilated by catastrophic cancellation:
 *
 *     sum([1e16, 1, -1e16])   ->  0     (so does np.sum — the 1 is lost the moment it meets 1e16)
 *     fsum([1e16, 1, -1e16])  ->  1     (exact)
 *
 * Neumaier compensation tracks the low-order bits each addition discards and folds them back in.
 * ~2-4x slower than `sum`, so it is opt-in. Reach for it when the result is a small difference of
 * large terms: conservation checks, residuals, long-running accumulators.
 */
export declare const fsum: import("@danielsimonjr/mathts-core").TypedFunction;
export declare const sum: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Mean with parallel array support
 */
export declare const mean: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Variance normalization, matching mathjs's `variance(array, normalization)`:
 *   - 'unbiased'    → sum2 / (n - 1)   (sample variance; mathjs DEFAULT)
 *   - 'uncorrected' → sum2 / n         (population variance)
 *   - 'biased'      → sum2 / (n + 1)
 */
export type VarNormalization = 'unbiased' | 'uncorrected' | 'biased';
/**
 * Variance with parallel array support.
 *
 * Defaults to **unbiased** (sample, ÷(n-1)) to match mathjs and the
 * `parallelStatVariance` variant. An optional normalization argument selects
 * 'unbiased' | 'uncorrected' (population) | 'biased'. See VarNormalization.
 */
export declare const variance: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Standard deviation with parallel array support — sqrt of {@link variance};
 * defaults to **unbiased** and accepts the same normalization argument.
 */
export declare const std: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Dot product with parallel array support
 */
export declare const dot: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Parallel matrix multiplication
 * @param a First matrix as flat Float64Array (row-major)
 * @param aRows Number of rows in A
 * @param aCols Number of columns in A (must equal bRows)
 * @param b Second matrix as flat Float64Array (row-major)
 * @param bCols Number of columns in B
 */
export declare function matmul(a: Float64Array, aRows: i32, aCols: i32, b: Float64Array, bCols: i32): Promise<Float64Array>;
/**
 * Parallel matrix transpose
 */
export declare function transpose(data: Float64Array, rows: i32, cols: i32): Promise<Float64Array>;
/**
 * Parallel matrix-vector multiplication
 */
export declare function matvec(matrix: Float64Array, rows: i32, cols: i32, vector: Float64Array): Promise<Float64Array>;
/**
 * Parallel outer product
 */
export declare function outer(a: Float64Array, b: Float64Array): Promise<Float64Array>;
/**
 * Initialize the compute pool (call before using parallel operations)
 */
export declare function initializePool(): Promise<void>;
/**
 * Terminate the compute pool (call when done)
 */
export declare function terminatePool(): Promise<void>;
/**
 * Check if parallelization should be used for given element count
 */
export declare function shouldParallelize(elementCount: i32): boolean;
/**
 * Get the underlying ComputePool instance
 */
export declare function getComputePool(): ComputePool;
export declare const typedArithmetic: {
    add: import("@danielsimonjr/mathts-core").TypedFunction;
    subtract: import("@danielsimonjr/mathts-core").TypedFunction;
    multiply: import("@danielsimonjr/mathts-core").TypedFunction;
    divide: import("@danielsimonjr/mathts-core").TypedFunction;
    unaryMinus: import("@danielsimonjr/mathts-core").TypedFunction;
    unaryPlus: import("@danielsimonjr/mathts-core").TypedFunction;
    abs: import("@danielsimonjr/mathts-core").TypedFunction;
    sign: import("@danielsimonjr/mathts-core").TypedFunction;
    pow: import("@danielsimonjr/mathts-core").TypedFunction;
    sqrt: import("@danielsimonjr/mathts-core").TypedFunction;
    square: import("@danielsimonjr/mathts-core").TypedFunction;
    cube: import("@danielsimonjr/mathts-core").TypedFunction;
    cbrt: import("@danielsimonjr/mathts-core").TypedFunction;
    nthRoot: import("@danielsimonjr/mathts-core").TypedFunction;
    exp: import("@danielsimonjr/mathts-core").TypedFunction;
    log: import("@danielsimonjr/mathts-core").TypedFunction;
    log10: import("@danielsimonjr/mathts-core").TypedFunction;
    log2: import("@danielsimonjr/mathts-core").TypedFunction;
    log1p: import("@danielsimonjr/mathts-core").TypedFunction;
    expm1: import("@danielsimonjr/mathts-core").TypedFunction;
    round: import("@danielsimonjr/mathts-core").TypedFunction;
    floor: import("@danielsimonjr/mathts-core").TypedFunction;
    ceil: import("@danielsimonjr/mathts-core").TypedFunction;
    fix: import("@danielsimonjr/mathts-core").TypedFunction;
    mod: import("@danielsimonjr/mathts-core").TypedFunction;
    gcd: import("@danielsimonjr/mathts-core").TypedFunction;
    lcm: import("@danielsimonjr/mathts-core").TypedFunction;
    xgcd: import("@danielsimonjr/mathts-core").TypedFunction;
    norm: import("@danielsimonjr/mathts-core").TypedFunction;
    sinh: import("@danielsimonjr/mathts-core").TypedFunction;
    cosh: import("@danielsimonjr/mathts-core").TypedFunction;
    tanh: import("@danielsimonjr/mathts-core").TypedFunction;
    equal: import("@danielsimonjr/mathts-core").TypedFunction;
    smaller: import("@danielsimonjr/mathts-core").TypedFunction;
    larger: import("@danielsimonjr/mathts-core").TypedFunction;
    smallerEq: import("@danielsimonjr/mathts-core").TypedFunction;
    largerEq: import("@danielsimonjr/mathts-core").TypedFunction;
    compare: import("@danielsimonjr/mathts-core").TypedFunction;
    min: import("@danielsimonjr/mathts-core").TypedFunction;
    max: import("@danielsimonjr/mathts-core").TypedFunction;
    sum: import("@danielsimonjr/mathts-core").TypedFunction;
    mean: import("@danielsimonjr/mathts-core").TypedFunction;
    variance: import("@danielsimonjr/mathts-core").TypedFunction;
    std: import("@danielsimonjr/mathts-core").TypedFunction;
    dot: import("@danielsimonjr/mathts-core").TypedFunction;
    matmul: typeof matmul;
    transpose: typeof transpose;
    matvec: typeof matvec;
    outer: typeof outer;
    initializePool: typeof initializePool;
    terminatePool: typeof terminatePool;
    shouldParallelize: typeof shouldParallelize;
    getComputePool: typeof getComputePool;
};
export {};
//# sourceMappingURL=arithmetic.d.ts.map