@danielsimonjr/mathts-functions 0.2.3 → 0.2.4

package/dist/typed/arithmetic.d.ts

@@ -0,0 +1,302 @@
+/**
+ * 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("typed-function").TypedFunction;
+/**
+ * Polymorphic subtraction function with parallel execution for arrays
+ */
+export declare const subtract: import("typed-function").TypedFunction;
+/**
+ * Polymorphic multiplication function with parallel execution for arrays
+ */
+export declare const multiply: import("typed-function").TypedFunction;
+/**
+ * Polymorphic division function with parallel execution for arrays
+ */
+export declare const divide: import("typed-function").TypedFunction;
+/**
+ * Unary negation with parallel array support
+ */
+export declare const unaryMinus: import("typed-function").TypedFunction;
+/**
+ * Unary plus (identity)
+ */
+export declare const unaryPlus: import("typed-function").TypedFunction;
+/**
+ * Absolute value with parallel array support
+ */
+export declare const abs: import("typed-function").TypedFunction;
+/**
+ * Sign function
+ */
+export declare const sign: import("typed-function").TypedFunction;
+/**
+ * Power function
+ */
+export declare const pow: import("typed-function").TypedFunction;
+/**
+ * Square root with parallel array support
+ */
+export declare const sqrt: import("typed-function").TypedFunction;
+/**
+ * Square with parallel array support
+ */
+export declare const square: import("typed-function").TypedFunction;
+/**
+ * Cube
+ */
+export declare const cube: import("typed-function").TypedFunction;
+/**
+ * Cube root
+ */
+export declare const cbrt: import("typed-function").TypedFunction;
+/**
+ * N-th root
+ */
+export declare const nthRoot: import("typed-function").TypedFunction;
+/**
+ * Exponential function (e^x) with parallel array support
+ */
+export declare const exp: import("typed-function").TypedFunction;
+/**
+ * Natural logarithm (ln x) with parallel array support
+ */
+export declare const log: import("typed-function").TypedFunction;
+/**
+ * Base-10 logarithm
+ */
+export declare const log10: import("typed-function").TypedFunction;
+/**
+ * Base-2 logarithm
+ */
+export declare const log2: import("typed-function").TypedFunction;
+/**
+ * log(1 + x) with higher precision for small x
+ */
+export declare const log1p: import("typed-function").TypedFunction;
+/**
+ * exp(x) - 1 with higher precision for small x
+ */
+export declare const expm1: import("typed-function").TypedFunction;
+/**
+ * Round to nearest integer
+ */
+export declare const round: import("typed-function").TypedFunction;
+/**
+ * Floor (round down)
+ */
+export declare const floor: import("typed-function").TypedFunction;
+/**
+ * Ceiling (round up)
+ */
+export declare const ceil: import("typed-function").TypedFunction;
+/**
+ * Truncate (round toward zero)
+ */
+export declare const fix: import("typed-function").TypedFunction;
+/**
+ * Modulo operation
+ */
+export declare const mod: import("typed-function").TypedFunction;
+/**
+ * Greatest common divisor
+ */
+export declare const gcd: import("typed-function").TypedFunction;
+/**
+ * Least common multiple
+ */
+export declare const lcm: import("typed-function").TypedFunction;
+/**
+ * Extended greatest common divisor
+ * Returns [gcd, x, y] where gcd = a*x + b*y (Bezout coefficients)
+ */
+export declare const xgcd: import("typed-function").TypedFunction;
+/**
+ * Vector/array norm (Euclidean norm by default) with parallel support
+ */
+export declare const norm: import("typed-function").TypedFunction;
+/**
+ * Hyperbolic sine
+ */
+export declare const sinh: import("typed-function").TypedFunction;
+/**
+ * Hyperbolic cosine
+ */
+export declare const cosh: import("typed-function").TypedFunction;
+/**
+ * Hyperbolic tangent
+ */
+export declare const tanh: import("typed-function").TypedFunction;
+/**
+ * Check if values are equal
+ */
+export declare const equal: import("typed-function").TypedFunction;
+/**
+ * Check if a < b
+ */
+export declare const smaller: import("typed-function").TypedFunction;
+/**
+ * Check if a > b
+ */
+export declare const larger: import("typed-function").TypedFunction;
+/**
+ * Check if a <= b
+ */
+export declare const smallerEq: import("typed-function").TypedFunction;
+/**
+ * Check if a >= b
+ */
+export declare const largerEq: import("typed-function").TypedFunction;
+/**
+ * Compare two values: -1, 0, or 1
+ */
+export declare const compare: import("typed-function").TypedFunction;
+/**
+ * Minimum of values with parallel array support
+ */
+export declare const min: import("typed-function").TypedFunction;
+/**
+ * Maximum of values with parallel array support
+ */
+export declare const max: import("typed-function").TypedFunction;
+/**
+ * Sum with parallel array support
+ */
+export declare const sum: import("typed-function").TypedFunction;
+/**
+ * Mean with parallel array support
+ */
+export declare const mean: import("typed-function").TypedFunction;
+/**
+ * Variance with parallel array support
+ */
+export declare const variance: import("typed-function").TypedFunction;
+/**
+ * Standard deviation with parallel array support
+ */
+export declare const std: import("typed-function").TypedFunction;
+/**
+ * Dot product with parallel array support
+ */
+export declare const dot: import("typed-function").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("typed-function").TypedFunction;
+    subtract: import("typed-function").TypedFunction;
+    multiply: import("typed-function").TypedFunction;
+    divide: import("typed-function").TypedFunction;
+    unaryMinus: import("typed-function").TypedFunction;
+    unaryPlus: import("typed-function").TypedFunction;
+    abs: import("typed-function").TypedFunction;
+    sign: import("typed-function").TypedFunction;
+    pow: import("typed-function").TypedFunction;
+    sqrt: import("typed-function").TypedFunction;
+    square: import("typed-function").TypedFunction;
+    cube: import("typed-function").TypedFunction;
+    cbrt: import("typed-function").TypedFunction;
+    nthRoot: import("typed-function").TypedFunction;
+    exp: import("typed-function").TypedFunction;
+    log: import("typed-function").TypedFunction;
+    log10: import("typed-function").TypedFunction;
+    log2: import("typed-function").TypedFunction;
+    log1p: import("typed-function").TypedFunction;
+    expm1: import("typed-function").TypedFunction;
+    round: import("typed-function").TypedFunction;
+    floor: import("typed-function").TypedFunction;
+    ceil: import("typed-function").TypedFunction;
+    fix: import("typed-function").TypedFunction;
+    mod: import("typed-function").TypedFunction;
+    gcd: import("typed-function").TypedFunction;
+    lcm: import("typed-function").TypedFunction;
+    xgcd: import("typed-function").TypedFunction;
+    norm: import("typed-function").TypedFunction;
+    sinh: import("typed-function").TypedFunction;
+    cosh: import("typed-function").TypedFunction;
+    tanh: import("typed-function").TypedFunction;
+    equal: import("typed-function").TypedFunction;
+    smaller: import("typed-function").TypedFunction;
+    larger: import("typed-function").TypedFunction;
+    smallerEq: import("typed-function").TypedFunction;
+    largerEq: import("typed-function").TypedFunction;
+    compare: import("typed-function").TypedFunction;
+    min: import("typed-function").TypedFunction;
+    max: import("typed-function").TypedFunction;
+    sum: import("typed-function").TypedFunction;
+    mean: import("typed-function").TypedFunction;
+    variance: import("typed-function").TypedFunction;
+    std: import("typed-function").TypedFunction;
+    dot: import("typed-function").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

package/dist/typed/arithmetic.d.ts.map

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

package/dist/typed/bitwise.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Typed Bitwise Functions (Parallel-First)
+ *
+ * Polymorphic bitwise operations using typed-function for runtime
+ * dispatch. Supports `number`, `BigNumber`, `bigint`, and `Int32Array`.
+ *
+ * Following the parallel-first philosophy per CLAUDE.md:
+ * - Use the `ComputePool` for ALL `Int32Array` transformations.
+ * - Use native ops on scalar inputs (no worker dispatch overhead).
+ *
+ * BigNumber bitwise semantics: the mathjs-synced helpers in
+ * `functions/src/utils/bignumber/bitwise.ts` operate on the
+ * `decimal.js`-internal coefficient layout (`x.d` / `x.e` / `x.s`),
+ * which `@danielsimonjr/mathts-core`'s `BigNumber` does not expose.
+ * We therefore reimplement the BigNumber path by routing through
+ * native `bigint` when the operand is a finite integer — that
+ * matches what the mathjs path does on integers anyway. NaN /
+ * non-integer inputs throw, mirroring mathjs behavior.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Polymorphic bitwise AND.
+ *
+ * @example
+ * ```typescript
+ * bitAnd(0b1010, 0b1100);                   // 0b1000
+ * bitAnd(53n, 131n);                        // 1n
+ * await bitAnd(int32A, int32B);             // Parallel Int32Array AND
+ * ```
+ */
+export declare const bitAnd: import("typed-function").TypedFunction;
+export declare const bitOr: import("typed-function").TypedFunction;
+export declare const bitXor: import("typed-function").TypedFunction;
+export declare const bitNot: import("typed-function").TypedFunction;
+export declare const leftShift: import("typed-function").TypedFunction;
+export declare const rightArithShift: import("typed-function").TypedFunction;
+export declare const rightLogShift: import("typed-function").TypedFunction;
+export declare const typedBitwise: {
+    bitAnd: import("typed-function").TypedFunction;
+    bitOr: import("typed-function").TypedFunction;
+    bitXor: import("typed-function").TypedFunction;
+    bitNot: import("typed-function").TypedFunction;
+    leftShift: import("typed-function").TypedFunction;
+    rightArithShift: import("typed-function").TypedFunction;
+    rightLogShift: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=bitwise.d.ts.map

package/dist/typed/bitwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/typed/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA2FH;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,wCAmCjB,CAAC;AAMH,eAAO,MAAM,KAAK,wCAgChB,CAAC;AAMH,eAAO,MAAM,MAAM,wCAgCjB,CAAC;AAMH,eAAO,MAAM,MAAM,wCAuBjB,CAAC;AAMH,eAAO,MAAM,SAAS,wCAwCpB,CAAC;AAMH,eAAO,MAAM,eAAe,wCAwC1B,CAAC;AAMH,eAAO,MAAM,aAAa,wCAwCxB,CAAC;AAMH,eAAO,MAAM,YAAY;;;;;;;;CAQxB,CAAC"}