numpy-ts 1.0.0 → 1.2.0

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

@@ -0,0 +1,20 @@
+export declare function reduce_min_f64(a: number, N: number): number;
+export declare function reduce_min_f32(a: number, N: number): number;
+export declare function reduce_min_i64(a: number, N: number): number;
+export declare function reduce_min_u64(a: number, N: number): number;
+export declare function reduce_min_i32(a: number, N: number): number;
+export declare function reduce_min_u32(a: number, N: number): number;
+export declare function reduce_min_i16(a: number, N: number): number;
+export declare function reduce_min_u16(a: number, N: number): number;
+export declare function reduce_min_i8(a: number, N: number): number;
+export declare function reduce_min_u8(a: number, N: number): number;
+export declare function reduce_min_strided_f32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_i64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_u64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_i32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_u32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_i16(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_u16(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_i8(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_min_strided_u8(a: number, out: number, outer: number, axis: number, inner: number): void;
+//# sourceMappingURL=reduce_min.wasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare function reduce_nanmax_f64(a: number, N: number): number;
+export declare function reduce_nanmax_f32(a: number, N: number): number;
+//# sourceMappingURL=reduce_nanmax.wasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare function reduce_nanmin_f64(a: number, N: number): number;
+export declare function reduce_nanmin_f32(a: number, N: number): number;
+//# sourceMappingURL=reduce_nanmin.wasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare function reduce_nansum_f64(a: number, N: number): number;
+export declare function reduce_nansum_f32(a: number, N: number): number;
+//# sourceMappingURL=reduce_nansum.wasm.d.ts.map

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

@@ -0,0 +1,19 @@
+export declare function reduce_prod_f64(a: number, N: number): number;
+export declare function reduce_prod_f32(a: number, N: number): number;
+export declare function reduce_prod_i64(a: number, N: number): number;
+export declare function reduce_prod_i32(a: number, N: number): number;
+export declare function reduce_prod_i16(a: number, N: number): number;
+export declare function reduce_prod_u16(a: number, N: number): number;
+export declare function reduce_prod_i8(a: number, N: number): number;
+export declare function reduce_prod_u8(a: number, N: number): number;
+export declare function reduce_prod_strided_f64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_f32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_i64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_u64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_i32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_u32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_i16(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_u16(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_i8(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_prod_strided_u8(a: number, out: number, outer: number, axis: number, inner: number): void;
+//# sourceMappingURL=reduce_prod.wasm.d.ts.map

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

@@ -0,0 +1,2 @@
+export declare function reduce_quantile_f64(a: number, N: number, q: number): number;
+//# sourceMappingURL=reduce_quantile.wasm.d.ts.map

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

@@ -0,0 +1,11 @@
+export declare function reduce_std_f64(a: number, N: number): number;
+export declare function reduce_std_f32(a: number, N: number): number;
+export declare function reduce_std_i64(a: number, N: number): number;
+export declare function reduce_std_u64(a: number, N: number): number;
+export declare function reduce_std_i32(a: number, N: number): number;
+export declare function reduce_std_u32(a: number, N: number): number;
+export declare function reduce_std_i16(a: number, N: number): number;
+export declare function reduce_std_u16(a: number, N: number): number;
+export declare function reduce_std_i8(a: number, N: number): number;
+export declare function reduce_std_u8(a: number, N: number): number;
+//# sourceMappingURL=reduce_std.wasm.d.ts.map

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

@@ -0,0 +1,17 @@
+export declare function reduce_sum_f64(a: number, N: number): number;
+export declare function reduce_sum_f32(a: number, N: number): number;
+export declare function reduce_sum_i64(a: number, N: number): number;
+export declare function reduce_sum_i32(a: number, N: number): number;
+export declare function reduce_sum_i16(a: number, N: number): number;
+export declare function reduce_sum_i8(a: number, N: number): number;
+export declare function reduce_sum_strided_f64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_f32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_i64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_u64(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_i32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_u32(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_i16(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_u16(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_i8(a: number, out: number, outer: number, axis: number, inner: number): void;
+export declare function reduce_sum_strided_u8(a: number, out: number, outer: number, axis: number, inner: number): void;
+//# sourceMappingURL=reduce_sum.wasm.d.ts.map

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

@@ -0,0 +1,11 @@
+export declare function reduce_var_f64(a: number, N: number): number;
+export declare function reduce_var_f32(a: number, N: number): number;
+export declare function reduce_var_i64(a: number, N: number): number;
+export declare function reduce_var_u64(a: number, N: number): number;
+export declare function reduce_var_i32(a: number, N: number): number;
+export declare function reduce_var_u32(a: number, N: number): number;
+export declare function reduce_var_i16(a: number, N: number): number;
+export declare function reduce_var_u16(a: number, N: number): number;
+export declare function reduce_var_i8(a: number, N: number): number;
+export declare function reduce_var_u8(a: number, N: number): number;
+//# sourceMappingURL=reduce_var.wasm.d.ts.map

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

@@ -0,0 +1,7 @@
+export declare function repeat_f64(a: number, out: number, N: number, reps: number): void;
+export declare function repeat_f32(a: number, out: number, N: number, reps: number): void;
+export declare function repeat_i64(a: number, out: number, N: number, reps: number): void;
+export declare function repeat_i32(a: number, out: number, N: number, reps: number): void;
+export declare function repeat_i16(a: number, out: number, N: number, reps: number): void;
+export declare function repeat_i8(a: number, out: number, N: number, reps: number): void;
+//# sourceMappingURL=repeat.wasm.d.ts.map

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

@@ -0,0 +1,60 @@
+export declare function mt19937_init(seed_val: number): void;
+export declare function mt19937_genrand(): number;
+export declare function mt19937_random_f64(): number;
+export declare function mt19937_get_state(out: number): number;
+export declare function mt19937_set_state(state: number, index: number): void;
+export declare function seed_sequence(seed: number, out_ptr: number, n_words: number): void;
+export declare function pcg64_init_from_ss(words: number): void;
+export declare function pcg64_init(state_lo: number, state_hi: number, inc_lo: number, inc_hi: number): void;
+export declare function pcg64_step(): number;
+export declare function pcg64_random_f64(): number;
+export declare function pcg64_bounded_uint64(off: number, rng: number): number;
+export declare function fill_bounded_uint64_pcg(out: number, n: number, off: number, rng: number): void;
+export declare function pcg64_get_state(out: number): void;
+export declare function pcg64_set_state(state_lo: number, state_hi: number, inc_lo: number, inc_hi: number): void;
+export declare function pcg64_set_state_ptr(data: number): void;
+export declare function standard_normal_pcg(): number;
+export declare function standard_exponential_pcg(): number;
+export declare function fill_standard_normal_pcg(out: number, n: number): void;
+export declare function fill_standard_exponential_pcg(out: number, n: number): void;
+export declare function legacy_gauss(): number;
+export declare function legacy_standard_exponential(): number;
+export declare function legacy_gauss_reset(): void;
+export declare function fill_legacy_gauss(out: number, n: number): void;
+export declare function fill_legacy_standard_exponential(out: number, n: number): void;
+export declare function legacy_standard_gamma(shape: number): number;
+export declare function fill_legacy_standard_gamma(out: number, n: number, shape: number): void;
+export declare function fill_legacy_chisquare(out: number, n: number, df: number): void;
+export declare function fill_uniform_f64_mt(out: number, n: number): void;
+export declare function fill_uniform_f64_pcg(out: number, n: number): void;
+export declare function fill_rk_interval(out: number, n: number, max: number): void;
+export declare function fill_randint_u8(out: number, n: number, rng_val: number, off: number): void;
+export declare function fill_randint_u16(out: number, n: number, rng_val: number, off: number): void;
+export declare function fill_randint_i64(out: number, n: number, max: number, low: number): void;
+export declare function fill_pareto(out: number, n: number, a: number): void;
+export declare function fill_power(out: number, n: number, a: number): void;
+export declare function fill_weibull(out: number, n: number, a: number): void;
+export declare function fill_logistic(out: number, n: number, loc: number, scale: number): void;
+export declare function fill_gumbel(out: number, n: number, loc: number, scale: number): void;
+export declare function fill_laplace(out: number, n: number, loc: number, scale: number): void;
+export declare function fill_rayleigh(out: number, n: number, scale: number): void;
+export declare function fill_triangular(out: number, n: number, left: number, mode: number, right: number): void;
+export declare function fill_standard_cauchy(out: number, n: number): void;
+export declare function fill_lognormal(out: number, n: number, mean: number, sigma: number): void;
+export declare function fill_wald(out: number, n: number, mean: number, scale: number): void;
+export declare function fill_standard_t(out: number, n: number, df: number): void;
+export declare function fill_beta(out: number, n: number, a: number, b: number): void;
+export declare function fill_f(out: number, n: number, dfnum: number, dfden: number): void;
+export declare function fill_noncentral_chisquare(out: number, n: number, df: number, nonc: number): void;
+export declare function fill_noncentral_f(out: number, n: number, dfnum: number, dfden: number, nonc: number): void;
+export declare function fill_vonmises(out: number, n: number, mu: number, kappa: number): void;
+export declare function fill_poisson(out: number, n: number, lam: number): void;
+export declare function fill_binomial(out: number, n: number, trials: number, p: number): void;
+export declare function fill_negative_binomial(out: number, n: number, nn: number, p: number): void;
+export declare function fill_geometric(out: number, n: number, p: number): void;
+export declare function fill_hypergeometric(out: number, n: number, good: number, bad: number, sample: number): void;
+export declare function fill_logseries(out: number, n: number, p: number): void;
+export declare function fill_zipf(out: number, n: number, a: number): void;
+export declare function fill_permutation(out: number, n: number): void;
+export declare function fill_permutation_pcg(out: number, n: number): void;
+//# sourceMappingURL=rng.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,27 @@
+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_f16(a: number, N: number): void;
+export declare function sort_slices_f16(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