numpy-ts 1.0.0 → 1.2.0

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,65 @@
+/**
+ * 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';
+import type { TypedArray } from '../dtype';
+/**
+ * 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;
+/**
+ * WASM-accelerated 2D complex FFT or IFFT.
+ * Input: contiguous complex128 2D array (rows × cols).
+ */
+export declare function wasmFft2(data: Float64Array, rows: number, cols: number, inverse: boolean): Float64Array | null;
+/**
+ * WASM-accelerated batch 1D complex FFT or IFFT.
+ * Processes `batch` contiguous rows of `n` complex elements each.
+ */
+export declare function wasmFftBatch(data: Float64Array, n: number, batch: number, inverse: boolean): Float64Array | null;
+/**
+ * WASM-accelerated batch real→complex rfft.
+ * Input: real f64 data with `batch` rows of `n` elements.
+ */
+export declare function wasmRfftBatch(srcData: Float64Array, n: number, batch: number, inStride: number, outStride: number): Float64Array | null;
+/**
+ * WASM-accelerated batch complex→real irfft.
+ * Input: complex128 data with `batch` rows of `nHalf` complex elements.
+ */
+export declare function wasmIrfftBatch(srcData: Float64Array, nHalf: number, nOut: number, batch: number, inStride: number, outStride: number): Float64Array | null;
+/**
+ * WASM-accelerated 2D real→complex rfft2.
+ * Input: real f64 (rows × cols). Output: complex128 (rows × halfCols).
+ */
+export declare function wasmRfft2(inputData: Float64Array | TypedArray, rows: number, cols: number): Float64Array | null;
+/**
+ * WASM-accelerated 2D inverse real FFT (irfft2).
+ * Input: complex128 (rows × colsHalf). Output: real f64 (rows × outCols).
+ */
+export declare function wasmIrfft2(inputData: Float64Array, rows: number, colsHalf: number, outCols: number): Float64Array | null;
+/**
+ * WASM-accelerated 3D inverse real FFT (irfftn for 3D).
+ * Input: complex128 (d0 × d1 × d2Half). Output: real f64 (d0 × d1 × d2Out).
+ */
+export declare function wasmIrfftn3d(srcData: Float64Array, d0: number, d1: number, d2Half: number, d2Out: number): Float64Array | 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' | 'float16'): ArrayStorage | null;
+export declare function wasmHeaviside(x1: ArrayStorage, x2: ArrayStorage, resultDtype: 'float64' | 'float32' | 'float16'): 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

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

@@ -0,0 +1,10 @@
+/**
+ * WASM-accelerated np.indices() for 2D and 3D grids.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated indices for 2D/3D grids with int32 dtype.
+ * Returns null if WASM can't handle this case.
+ */
+export declare function wasmIndices(dimensions: number[], dtype: string): ArrayStorage | null;
+//# sourceMappingURL=indices.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated inner product kernel.
+ *
+ * Pure compute backend — takes ArrayStorage inputs, returns ArrayStorage or
+ * null if WASM can't handle this case (unsupported dtype, non-contiguous,
+ * below size threshold). The caller (linalg.ts) handles the JS fallback.
+ *
+ * inner(A[M,K], B[N,K]) → C[M,N] where C[i,j] = sum_k A[i,k] * B[j,k]
+ */
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
+/**
+ * WASM-accelerated inner product. Returns null if WASM can't handle this case.
+ *
+ * Handles the 2D general case: inner(A[M,K], B[N,K]) → C[M,N].
+ * The 1D·1D case (scalar result) is also handled when both inputs are 1D.
+ * The caller should fall back to JS when null is returned.
+ */
+export declare function wasmInner(a: ArrayStorage, b: ArrayStorage): ArrayStorage | number | Complex | null;
+//# sourceMappingURL=inner.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated Kronecker product.
+ *
+ * Computes C = A ⊗ B for A[am×an] and B[bm×bn].
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated Kronecker product: A[am×an] ⊗ B[bm×bn] → C[(am*bm)×(an*bn)].
+ * Both inputs must be 2D and contiguous.
+ */
+export declare function wasmKron(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=kron.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * WASM-accelerated element-wise ldexp (x1 * 2^x2).
+ *
+ * Scalar variant only (x2 is a single integer).
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmLdexpScalar(a: ArrayStorage, exp: number): ArrayStorage | null;
+//# sourceMappingURL=ldexp.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated element-wise left shift.
+ *
+ * Binary: out[i] = a[i] << b[i]  (same-shape contiguous arrays)
+ * Scalar: out[i] = a[i] << scalar
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmLeftShift(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+export declare function wasmLeftShiftScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=left_shift.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated lexsort (indirect stable sort on multiple keys).
+ *
+ * All keys must be the same dtype and contiguous.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated lexsort.
+ * All keys must be the same dtype and 1D contiguous.
+ * Returns ArrayStorage of int32 indices or null if WASM can't handle it.
+ */
+export declare function wasmLexsort(keys: ArrayStorage[]): ArrayStorage | null;
+//# sourceMappingURL=lexsort.d.ts.map

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

@@ -0,0 +1,21 @@
+/**
+ * WASM-accelerated element-wise logaddexp.
+ *
+ * Binary: out[i] = log(exp(a[i]) + exp(b[i]))  (same-shape contiguous arrays)
+ * Scalar: out[i] = log(exp(a[i]) + exp(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 logaddexp of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogaddexp(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise logaddexp with scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogaddexpScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=logaddexp.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise logical AND.
+ *
+ * Binary: out[i] = (a[i] != 0) & (b[i] != 0)
+ * Scalar: out[i] = (a[i] != 0) & (scalar != 0)
+ * Output is always bool (Uint8Array). Returns null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated logical AND of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogicalAnd(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated logical AND of array and scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogicalAndScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=logical_and.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated element-wise logical NOT.
+ *
+ * Unary: out[i] = (a[i] == 0) ? 1 : 0
+ * Output is always bool (Uint8Array). Returns null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated logical NOT.
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmLogicalNot(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=logical_not.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise logical OR.
+ *
+ * Binary: out[i] = (a[i] != 0) | (b[i] != 0)
+ * Scalar: out[i] = (a[i] != 0) | (scalar != 0)
+ * Output is always bool (Uint8Array). Returns null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated logical OR of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogicalOr(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated logical OR of array and scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogicalOrScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=logical_or.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise logical XOR.
+ *
+ * Binary: out[i] = (a[i] != 0) ^ (b[i] != 0)
+ * Scalar: out[i] = (a[i] != 0) ^ (scalar != 0)
+ * Output is always bool (Uint8Array). Returns null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated logical XOR of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogicalXor(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated logical XOR of array and scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmLogicalXorScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=logical_xor.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * WASM-accelerated matmul kernel.
+ *
+ * Pure compute backend — takes ArrayStorage inputs, returns ArrayStorage or
+ * null if WASM can't handle this case (unsupported dtype, non-contiguous,
+ * below size threshold). The caller (linalg.ts) handles the JS fallback.
+ *
+ * Handles batched matmul by looping over batch dimensions in JS and
+ * dispatching each 2D slice to WASM.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated matmul. Returns null if WASM can't handle this case.
+ *
+ * The caller should fall back to JS when null is returned.
+ */
+export declare function wasmMatmul(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=matmul.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated matrix-vector product.
+ *
+ * Computes y[i] = sum_k A[i,k] * x[k] for A[M,K] and x[K].
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated matvec: A[M,K] · x[K] → y[M].
+ * A must be 2D, x must be 1D, both contiguous.
+ */
+export declare function wasmMatvec(A: ArrayStorage, x: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=matvec.d.ts.map

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

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

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise multiplication.
+ *
+ * Binary: out[i] = a[i] * b[i]  (same-shape contiguous arrays)
+ * Scalar: out[i] = a[i] * scalar
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise multiply of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmMul(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise multiply scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmMulScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=mul.d.ts.map

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

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

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

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated outer product.
+ *
+ * Computes C[i,j] = a[i] * b[j] for a[M] and b[N].
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated outer product: a[M] ⊗ b[N] → C[M,N].
+ * Both inputs are flattened to 1D first by the caller.
+ */
+export declare function wasmOuter(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=outer.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 2D constant zero-padding.
+ *
+ * Pads a [rows x cols] matrix with `pad_width` zeros on all sides.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 2D constant zero-pad with uniform pad_width.
+ * Only handles 2D C-contiguous arrays with constant_values=0 and uniform pad_width.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmPad2D(a: ArrayStorage, padWidth: number): ArrayStorage | null;
+//# sourceMappingURL=pad.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated in-place partition (quickselect).
+ *
+ * Partitions a contiguous 1D buffer so that element at kth position
+ * is in its final sorted position.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import type { DType, TypedArray } from '../dtype';
+/**
+ * WASM-accelerated partition of contiguous slices.
+ * Uses batch kernel when slices are packed contiguously.
+ */
+export declare function wasmPartitionSlices(resultData: TypedArray, sliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, kth: number, dtype: DType): boolean;
+/**
+ * WASM-accelerated partition of a contiguous 1D buffer.
+ * Returns partitioned ArrayStorage or null if WASM can't handle it.
+ */
+export declare function wasmPartition(a: ArrayStorage, kth: number): ArrayStorage | null;
+//# sourceMappingURL=partition.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise power.
+ *
+ * Binary: out[i] = a[i] ^ b[i]  (same-shape contiguous arrays)
+ * Scalar: out[i] = a[i] ^ scalar
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise power of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmPower(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise power with scalar exponent.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmPowerScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=power.d.ts.map

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

@@ -0,0 +1,17 @@
+/**
+ * WASM-accelerated Householder QR decomposition.
+ *
+ * Computes A = Q·R for A[m×n], where Q[m×k] is orthogonal and R[k×n] is upper triangular.
+ * k = min(m, n). Only supports float64 (matches JS behavior of converting all inputs to float64).
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated QR decomposition for 2D float64 matrices.
+ * Returns { q: ArrayStorage, r: ArrayStorage } or null.
+ */
+export declare function wasmQr(a: ArrayStorage): {
+    q: ArrayStorage;
+    r: ArrayStorage;
+} | null;
+//# sourceMappingURL=qr.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction all (logical AND).
+ *
+ * Reduction: result = 1 if 0 if any a[i] == 0, else 1.
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (non-zero check is sign-agnostic).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction all (no axis, full array).
+ * Returns 0 or 1 as number, or null if WASM can't handle.
+ */
+export declare function wasmReduceAll(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_all.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction any (logical OR).
+ *
+ * Reduction: result = 1 if any a[i] != 0, else 0.
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (non-zero check is sign-agnostic).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction any (no axis, full array).
+ * Returns 0 or 1 as number, or null if WASM can't handle.
+ */
+export declare function wasmReduceAny(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_any.d.ts.map