numpy-ts 1.0.0 → 1.1.0

package/dist/types/common/wasm/bins/right_shift.wasm.d.ts

@@ -0,0 +1,17 @@
+export declare function right_shift_i64(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_i64(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_i32(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_i32(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_i16(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_i16(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_i8(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_i8(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_u64(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_u64(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_u32(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_u32(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_u16(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_u16(a: number, out: number, N: number, scalar: number): void;
+export declare function right_shift_u8(a: number, b: number, out: number, N: number): void;
+export declare function right_shift_scalar_u8(a: number, out: number, N: number, scalar: number): void;
+//# sourceMappingURL=right_shift.wasm.d.ts.map

package/dist/types/common/wasm/bins/roll.wasm.d.ts

@@ -0,0 +1,7 @@
+export declare function roll_f64(a: number, out: number, N: number, shift: number): void;
+export declare function roll_f32(a: number, out: number, N: number, shift: number): void;
+export declare function roll_i64(a: number, out: number, N: number, shift: number): void;
+export declare function roll_i32(a: number, out: number, N: number, shift: number): void;
+export declare function roll_i16(a: number, out: number, N: number, shift: number): void;
+export declare function roll_i8(a: number, out: number, N: number, shift: number): void;
+//# sourceMappingURL=roll.wasm.d.ts.map

package/dist/types/common/wasm/bins/rot90.wasm.d.ts

@@ -0,0 +1,7 @@
+export declare function rot90_f64(a: number, out: number, rows: number, cols: number): void;
+export declare function rot90_f32(a: number, out: number, rows: number, cols: number): void;
+export declare function rot90_i64(a: number, out: number, rows: number, cols: number): void;
+export declare function rot90_i32(a: number, out: number, rows: number, cols: number): void;
+export declare function rot90_i16(a: number, out: number, rows: number, cols: number): void;
+export declare function rot90_i8(a: number, out: number, rows: number, cols: number): void;
+//# sourceMappingURL=rot90.wasm.d.ts.map

package/dist/types/common/wasm/bins/searchsorted.wasm.d.ts

@@ -0,0 +1,21 @@
+export declare function searchsorted_left_f64(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_f32(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_i64(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_u64(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_i32(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_u32(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_i16(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_u16(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_i8(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_left_u8(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_f64(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_f32(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_i64(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_u64(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_i32(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_u32(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_i16(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_u16(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_i8(sorted: number, N: number, values: number, out: number, M: number): void;
+export declare function searchsorted_right_u8(sorted: number, N: number, values: number, out: number, M: number): void;
+//# sourceMappingURL=searchsorted.wasm.d.ts.map

package/dist/types/common/wasm/bins/sign.wasm.d.ts

@@ -0,0 +1,7 @@
+export declare function sign_f64(a: number, out: number, N: number): void;
+export declare function sign_f32(a: number, out: number, N: number): void;
+export declare function sign_i64(a: number, out: number, N: number): void;
+export declare function sign_i32(a: number, out: number, N: number): void;
+export declare function sign_i16(a: number, out: number, N: number): void;
+export declare function sign_i8(a: number, out: number, N: number): void;
+//# sourceMappingURL=sign.wasm.d.ts.map

package/dist/types/common/wasm/bins/sinh.wasm.d.ts

@@ -0,0 +1,5 @@
+export declare function sinh_f64(a: number, out: number, N: number): void;
+export declare function sinh_f32(a: number, out: number, N: number): void;
+export declare function sinh_i64(a: number, out: number, N: number): void;
+export declare function sinh_u64(a: number, out: number, N: number): void;
+//# sourceMappingURL=sinh.wasm.d.ts.map

package/dist/types/common/wasm/bins/sort.wasm.d.ts

@@ -0,0 +1,25 @@
+export declare function sort_f64(a: number, N: number): void;
+export declare function sort_f32(a: number, N: number): void;
+export declare function sort_i64(a: number, N: number): void;
+export declare function sort_u64(a: number, N: number): void;
+export declare function sort_i32(a: number, N: number): void;
+export declare function sort_u32(a: number, N: number): void;
+export declare function sort_i16(a: number, N: number): void;
+export declare function sort_u16(a: number, N: number): void;
+export declare function sort_i8(a: number, N: number): void;
+export declare function sort_u8(a: number, N: number): void;
+export declare function sort_slices_f64(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_f32(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_i64(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_u64(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_i32(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_u32(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_i16(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_u16(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_i8(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_u8(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_c128(a: number, N: number): void;
+export declare function sort_c64(a: number, N: number): void;
+export declare function sort_slices_c128(a: number, sliceSize: number, numSlices: number): void;
+export declare function sort_slices_c64(a: number, sliceSize: number, numSlices: number): void;
+//# sourceMappingURL=sort.wasm.d.ts.map

package/dist/types/common/wasm/bins/sqrt.wasm.d.ts

@@ -0,0 +1,7 @@
+export declare function sqrt_f64(a: number, out: number, N: number): void;
+export declare function sqrt_f32(a: number, out: number, N: number): void;
+export declare function sqrt_i64(a: number, out: number, N: number): void;
+export declare function sqrt_i32(a: number, out: number, N: number): void;
+export declare function sqrt_i16(a: number, out: number, N: number): void;
+export declare function sqrt_i8(a: number, out: number, N: number): void;
+//# sourceMappingURL=sqrt.wasm.d.ts.map

package/dist/types/common/wasm/bins/square.wasm.d.ts

@@ -0,0 +1,9 @@
+export declare function square_f64(a: number, out: number, N: number): void;
+export declare function square_f32(a: number, out: number, N: number): void;
+export declare function square_c128(a: number, out: number, N: number): void;
+export declare function square_c64(a: number, out: number, N: number): void;
+export declare function square_i64(a: number, out: number, N: number): void;
+export declare function square_i32(a: number, out: number, N: number): void;
+export declare function square_i16(a: number, out: number, N: number): void;
+export declare function square_i8(a: number, out: number, N: number): void;
+//# sourceMappingURL=square.wasm.d.ts.map

package/dist/types/common/wasm/bins/sub.wasm.d.ts

@@ -0,0 +1,17 @@
+export declare function sub_f64(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_f64(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_f32(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_f32(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_c128(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_c128(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_c64(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_c64(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_i64(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_i64(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_i32(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_i32(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_i16(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_i16(a: number, out: number, N: number, scalar: number): void;
+export declare function sub_i8(a: number, b: number, out: number, N: number): void;
+export declare function sub_scalar_i8(a: number, out: number, N: number, scalar: number): void;
+//# sourceMappingURL=sub.wasm.d.ts.map

package/dist/types/common/wasm/bins/svd.wasm.d.ts

@@ -0,0 +1,2 @@
+export declare function svd_f64(a: number, u_out: number, s: number, vt: number, work: number, m_arg: number, n_arg: number): void;
+//# sourceMappingURL=svd.wasm.d.ts.map

package/dist/types/common/wasm/bins/tan.wasm.d.ts

@@ -0,0 +1,3 @@
+export declare function tan_f64(a: number, out: number, N: number): void;
+export declare function tan_f32(a: number, out: number, N: number): void;
+//# sourceMappingURL=tan.wasm.d.ts.map

package/dist/types/common/wasm/bins/tanh.wasm.d.ts

@@ -0,0 +1,5 @@
+export declare function tanh_f64(a: number, out: number, N: number): void;
+export declare function tanh_f32(a: number, out: number, N: number): void;
+export declare function tanh_i64(a: number, out: number, N: number): void;
+export declare function tanh_u64(a: number, out: number, N: number): void;
+//# sourceMappingURL=tanh.wasm.d.ts.map

package/dist/types/common/wasm/bins/tile.wasm.d.ts

@@ -0,0 +1,7 @@
+export declare function tile_2d_f64(a: number, out: number, rows: number, cols: number, rep_rows: number, rep_cols: number): void;
+export declare function tile_2d_f32(a: number, out: number, rows: number, cols: number, rep_rows: number, rep_cols: number): void;
+export declare function tile_2d_i64(a: number, out: number, rows: number, cols: number, rep_rows: number, rep_cols: number): void;
+export declare function tile_2d_i32(a: number, out: number, rows: number, cols: number, rep_rows: number, rep_cols: number): void;
+export declare function tile_2d_i16(a: number, out: number, rows: number, cols: number, rep_rows: number, rep_cols: number): void;
+export declare function tile_2d_i8(a: number, out: number, rows: number, cols: number, rep_rows: number, rep_cols: number): void;
+//# sourceMappingURL=tile.wasm.d.ts.map

package/dist/types/common/wasm/bins/vdot.wasm.d.ts

@@ -0,0 +1,3 @@
+export declare function vdot_c128(a: number, b: number, out: number, K: number): void;
+export declare function vdot_c64(a: number, b: number, out: number, K: number): void;
+//# sourceMappingURL=vdot.wasm.d.ts.map

package/dist/types/common/wasm/bins/vecdot.wasm.d.ts

@@ -0,0 +1,9 @@
+export declare function vecdot_f64(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_f32(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_c128(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_c64(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_i64(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_i32(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_i16(a: number, b: number, out: number, B: number, K: number): void;
+export declare function vecdot_i8(a: number, b: number, out: number, B: number, K: number): void;
+//# sourceMappingURL=vecdot.wasm.d.ts.map

package/dist/types/common/wasm/bins/vecmat.wasm.d.ts

@@ -0,0 +1,9 @@
+export declare function vecmat_f64(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_f32(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_c128(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_c64(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_i64(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_i32(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_i16(x: number, A: number, y: number, K: number, N: number): void;
+export declare function vecmat_i8(x: number, A: number, y: number, K: number, N: number): void;
+//# sourceMappingURL=vecmat.wasm.d.ts.map

package/dist/types/common/wasm/bitwise_and.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM-accelerated element-wise bitwise AND.
+ *
+ * Binary: out[i] = a[i] & b[i]  (same-shape contiguous arrays)
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmBitwiseAnd(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=bitwise_and.d.ts.map

package/dist/types/common/wasm/bitwise_count.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated bitwise_count (population count).
+ *
+ * Unary: out[i] = popcount(a[i])
+ * Output is always uint8.
+ * For signed types, counts bits of abs(value) to match NumPy.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmBitwiseCount(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=bitwise_count.d.ts.map

package/dist/types/common/wasm/bitwise_not.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM-accelerated element-wise bitwise NOT.
+ *
+ * Unary: out[i] = ~a[i]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmBitwiseNot(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=bitwise_not.d.ts.map

package/dist/types/common/wasm/bitwise_or.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM-accelerated element-wise bitwise OR.
+ *
+ * Binary: out[i] = a[i] | b[i]  (same-shape contiguous arrays)
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmBitwiseOr(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=bitwise_or.d.ts.map

package/dist/types/common/wasm/bitwise_xor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM-accelerated element-wise bitwise XOR.
+ *
+ * Binary: out[i] = a[i] ^ b[i]  (same-shape contiguous arrays)
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmBitwiseXor(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=bitwise_xor.d.ts.map

package/dist/types/common/wasm/cholesky.d.ts

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated Cholesky decomposition.
+ *
+ * Computes A = L·L^T for symmetric positive-definite A[n×n].
+ * Supports float64 and float32. Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated Cholesky decomposition for 2D float64 matrices.
+ * Returns ArrayStorage (lower triangular L) or null.
+ * Throws if the matrix is not positive-definite.
+ */
+export declare function wasmCholesky(a: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated Cholesky decomposition for 2D float32 matrices.
+ * Returns ArrayStorage (lower triangular L) or null.
+ * Throws if the matrix is not positive-definite.
+ */
+export declare function wasmCholeskyF32(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=cholesky.d.ts.map

package/dist/types/common/wasm/clip.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated element-wise clip (clamp).
+ *
+ * Unary: out[i] = clamp(a[i], lo, hi)
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated clip with scalar bounds.
+ * Returns null if WASM can't handle (complex, non-contiguous, array bounds, too small).
+ */
+export declare function wasmClip(a: ArrayStorage, lo: number, hi: number): ArrayStorage | null;
+//# sourceMappingURL=clip.d.ts.map

package/dist/types/common/wasm/config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Global WASM configuration.
+ *
+ * Controls whether WASM kernels are used and their size thresholds.
+ * Useful for testing (force WASM path with multiplier=0, force JS with Infinity).
+ */
+export declare const wasmConfig: {
+    /**
+     * Multiplier applied to all WASM size thresholds.
+     * - 1 (default): normal behavior, WASM used above optimal thresholds
+     * - 0: always use WASM when structurally possible (for testing)
+     * - Infinity: disable WASM entirely, always fall back to JS
+     */
+    thresholdMultiplier: number;
+    /**
+     * Incremented each time a WASM kernel successfully executes.
+     * Reset to 0 by callers (e.g. benchmark runner) to detect per-operation WASM usage.
+     */
+    wasmCallCount: number;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/types/common/wasm/convolve.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 1D convolution (full mode).
+ *
+ * Computes full linear convolution, returns float64 or float32 result.
+ * The JS ops layer handles mode slicing (same/valid) and complex types.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 1D convolution (full mode).
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmConvolve(a: ArrayStorage, v: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=convolve.d.ts.map

package/dist/types/common/wasm/copysign.d.ts

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise copysign.
+ *
+ * Binary: out[i] = copysign(x1[i], x2[i])  (magnitude of x1, sign of x2)
+ * Scalar: out[i] = copysign(x1[i], scalar)
+ * Output is always float64. Returns null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated copysign of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmCopysign(x1: ArrayStorage, x2: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated copysign of array and scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmCopysignScalar(x1: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=copysign.d.ts.map

package/dist/types/common/wasm/correlate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 1D cross-correlation (full mode).
+ *
+ * Computes full cross-correlation, returns float64 or float32 result.
+ * The JS ops layer handles mode slicing (same/valid) and complex types.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 1D cross-correlation (full mode).
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmCorrelate(a: ArrayStorage, v: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=correlate.d.ts.map

package/dist/types/common/wasm/cos.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise cosine.
+ *
+ * Unary: out[i] = cos(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise cosine.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmCos(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=cos.d.ts.map

package/dist/types/common/wasm/cosh.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise hyperbolic cosine.
+ *
+ * Unary: out[i] = cosh(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise hyperbolic cosine.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmCosh(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=cosh.d.ts.map

package/dist/types/common/wasm/cross.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated batched 3-vector cross product.
+ *
+ * Computes n pairs of 3D cross products: out[i] = a[i] × b[i].
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated batched 3-vector cross product.
+ * Both a and b must have shape [..., 3] with matching batch dimensions.
+ * The vector axis must be the last axis and have length 3.
+ * Returns ArrayStorage with same shape, or null.
+ */
+export declare function wasmCross(a: ArrayStorage, b: ArrayStorage, batchSize: number): ArrayStorage | null;
+//# sourceMappingURL=cross.d.ts.map

package/dist/types/common/wasm/diff.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated diff along last axis.
+ *
+ * 1D: flat diff.
+ * nD: uses 2D kernel (rows x cols) for last-axis diffs in one WASM call.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated diff along last axis for C-contiguous arrays.
+ * Handles 1D (flat) and nD (batched rows along last axis).
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmDiff(a: ArrayStorage, axis: number): ArrayStorage | null;
+//# sourceMappingURL=diff.d.ts.map

package/dist/types/common/wasm/divide.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated element-wise division.
+ *
+ * Binary: out[i] = a[i] / b[i]
+ * Scalar: out[i] = a[i] / scalar
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmDiv(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+export declare function wasmDivScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=divide.d.ts.map

package/dist/types/common/wasm/dot.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 1D dot product.
+ *
+ * Computes sum_k a[k] * b[k] for contiguous 1D arrays.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
+/**
+ * WASM-accelerated 1D dot product. Returns null if WASM can't handle.
+ * Both a and b must be 1D, contiguous, same-length.
+ */
+export declare function wasmDot1D(a: ArrayStorage, b: ArrayStorage): number | Complex | null;
+//# sourceMappingURL=dot.d.ts.map

package/dist/types/common/wasm/exp.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise exponential.
+ *
+ * Unary: out[i] = exp(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise exponential.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmExp(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=exp.d.ts.map

package/dist/types/common/wasm/exp2.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise base-2 exponential.
+ *
+ * Unary: out[i] = exp2(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise base-2 exponential.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmExp2(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=exp2.d.ts.map

package/dist/types/common/wasm/fft.d.ts

@@ -0,0 +1,29 @@
+/**
+ * WASM-accelerated FFT kernels.
+ *
+ * Provides 1D complex-to-complex FFT/IFFT and real FFT/IRFFT.
+ * Uses Cooley-Tukey radix-2 for power-of-2 sizes, Bluestein's for arbitrary sizes.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 1D forward complex FFT.
+ * Input: contiguous complex128 (interleaved f64) or complex64 (interleaved f32).
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmFft(a: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated 1D inverse complex FFT.
+ */
+export declare function wasmIfft(a: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated 1D real-to-complex FFT.
+ * Input: contiguous float64 real array. Output: complex128 with n/2+1 elements.
+ */
+export declare function wasmRfft(a: ArrayStorage, n: number): ArrayStorage | null;
+/**
+ * WASM-accelerated 1D complex-to-real inverse FFT.
+ * Input: contiguous complex128 with n_half elements. Output: float64 with n_out elements.
+ */
+export declare function wasmIrfft(a: ArrayStorage, nOut: number): ArrayStorage | null;
+//# sourceMappingURL=fft.d.ts.map

package/dist/types/common/wasm/flip.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated element-wise array reversal.
+ *
+ * Unary: out[i] = a[N-1-i]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated full array reversal.
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmFlip(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=flip.d.ts.map

package/dist/types/common/wasm/frexp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM-accelerated element-wise frexp (decompose into mantissa + exponent).
+ *
+ * Returns [mantissa, exponent] where x = mantissa * 2^exponent.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmFrexp(a: ArrayStorage): [ArrayStorage, ArrayStorage] | null;
+//# sourceMappingURL=frexp.d.ts.map

package/dist/types/common/wasm/gather.d.ts

@@ -0,0 +1,23 @@
+/**
+ * WASM-accelerated extract and take_along_axis operations.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated extract (conditional gather).
+ * condition must be flattened int32, data must be contiguous.
+ * Returns ArrayStorage or null.
+ */
+export declare function wasmExtract(condition: ArrayStorage, storage: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated take_along_axis for 2D arrays along axis 0.
+ * Returns ArrayStorage or null.
+ */
+export declare function wasmTakeAlongAxis2D(storage: ArrayStorage, indices: ArrayStorage, axis: number): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise where: out[i] = cond[i] ? x[i] : y[i].
+ * All three arrays must be contiguous, same shape, non-complex, same dtype for x/y.
+ * Condition is converted to i32 for the WASM kernel.
+ * Returns ArrayStorage or null.
+ */
+export declare function wasmWhere(condition: ArrayStorage, x: ArrayStorage, y: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=gather.d.ts.map

package/dist/types/common/wasm/gcd.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated element-wise GCD (greatest common divisor).
+ *
+ * Scalar: out[i] = gcd(a[i], scalar)
+ * Binary: out[i] = gcd(a[i], b[i])
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmGcdScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+export declare function wasmGcd(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=gcd.d.ts.map

package/dist/types/common/wasm/gradient.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated 1D gradient using central differences.
+ *
+ * Only handles 1D arrays with uniform spacing.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 1D gradient with uniform spacing.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmGradient1D(a: ArrayStorage, spacing: number): ArrayStorage | null;
+//# sourceMappingURL=gradient.d.ts.map

package/dist/types/common/wasm/heaviside.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated element-wise heaviside step function.
+ *
+ * Scalar: out[i] = x1[i] < 0 ? 0 : x1[i] == 0 ? x2 : 1
+ * Binary: out[i] = x1[i] < 0 ? 0 : x1[i] == 0 ? x2[i] : 1
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmHeavisideScalar(x1: ArrayStorage, x2: number, resultDtype: 'float64' | 'float32'): ArrayStorage | null;
+export declare function wasmHeaviside(x1: ArrayStorage, x2: ArrayStorage, resultDtype: 'float64' | 'float32'): ArrayStorage | null;
+//# sourceMappingURL=heaviside.d.ts.map

package/dist/types/common/wasm/hypot.d.ts

@@ -0,0 +1,21 @@
+/**
+ * WASM-accelerated element-wise hypot.
+ *
+ * Binary: out[i] = hypot(a[i], b[i])  (same-shape contiguous arrays)
+ * Scalar: out[i] = hypot(a[i], scalar)
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; int64/uint64 use native i64 kernels
+ * that convert to f64 in WASM (avoiding JS BigInt→Number overhead).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise hypot of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmHypot(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise hypot with scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmHypotScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=hypot.d.ts.map