numpy-ts 1.0.0 → 1.1.0

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/lstsq.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated least-squares solve via QR decomposition.
+ *
+ * Solves Ax = b for overdetermined systems (m >= n) using Householder QR.
+ * Only handles single RHS (1D b). For multi-RHS, falls back to JS/SVD.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated least-squares solve for 2D A and 1D b.
+ * Returns x[n] or null.
+ */
+export declare function wasmLstsq(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=lstsq.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

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction argmax.
+ *
+ * Reduction: result = argmax(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction argmax (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceArgmax(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_argmax.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction argmin.
+ *
+ * Reduction: result = argmin(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction argmin (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceArgmin(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_argmin.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction count_nz.
+ *
+ * Reduction: result = count_nonzero(a[0..N])
+ * 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 count_nz (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceCountNz(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_count_nz.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated reduction max.
+ *
+ * Reduction: result = max(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction max (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceMax(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided max along an axis.
+ * Output dtype matches input dtype. Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceMaxStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_max.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated reduction mean.
+ *
+ * Reduction: result = mean(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels (for correct floatFromInt).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction mean (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceMean(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided mean along an axis.
+ * Output is always float64. Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceMeanStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_mean.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated reduction min.
+ *
+ * Reduction: result = min(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction min (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceMin(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided min along an axis.
+ * Output dtype matches input dtype. Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceMinStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_min.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction nanmax.
+ *
+ * Reduction: result = nanmax(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Only float64 and float32.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction nanmax (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceNanmax(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_nanmax.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction nanmin.
+ *
+ * Reduction: result = nanmin(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Only float64 and float32.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction nanmin (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceNanmin(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_nanmin.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction nansum.
+ *
+ * Reduction: result = nansum(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Only float64 and float32 — TS routes int/uint to regular sum.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction nansum (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceNansum(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_nansum.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated reduction product.
+ *
+ * Reduction: result = product(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (wrapping multiplication gives same bits).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction product (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceProd(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided prod along an axis.
+ * Output dtype may be promoted (narrow ints → i64/u64).
+ * Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceProdStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_prod.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated quantile computation.
+ *
+ * Sorts a copy of the data in WASM, then interpolates.
+ * All dtypes are converted to f64 before passing to WASM.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated quantile (no axis, full array).
+ * Converts all data to f64, sorts in WASM, interpolates.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmReduceQuantile(a: ArrayStorage, q: number): number | null;
+//# sourceMappingURL=reduce_quantile.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction std.
+ *
+ * Reduction: result = std(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction std (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceStd(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_std.d.ts.map