numpy-ts 1.0.0 → 1.2.0

package/dist/types/common/dtype.d.ts

@@ -2,7 +2,7 @@
  * DType (Data Type) system for numpy-ts
  *
  * Supports NumPy numeric types:
- * - Floating point: float32, float64
+ * - Floating point: float16, float32, float64
  * - Complex: complex64, complex128
  * - Signed integers: int8, int16, int32, int64
  * - Unsigned integers: uint8, uint16, uint32, uint64
@@ -11,11 +11,16 @@
 /**
  * All supported dtypes
  */
-export type DType = 'float64' | 'float32' | 'complex128' | 'complex64' | 'int64' | 'int32' | 'int16' | 'int8' | 'uint64' | 'uint32' | 'uint16' | 'uint8' | 'bool';
+export type DType = 'float64' | 'float32' | 'float16' | 'complex128' | 'complex64' | 'int64' | 'int32' | 'int16' | 'int8' | 'uint64' | 'uint32' | 'uint16' | 'uint8' | 'bool';
 /**
  * TypedArray types for each dtype
  */
-export type TypedArray = Float64Array | Float32Array | BigInt64Array | Int32Array | Int16Array | Int8Array | BigUint64Array | Uint32Array | Uint16Array | Uint8Array;
+export type TypedArray = Float64Array | Float32Array | Float16Array | BigInt64Array | Int32Array | Int16Array | Int8Array | BigUint64Array | Uint32Array | Uint16Array | Uint8Array;
+/**
+ * Whether the runtime supports native Float16Array (TC39 proposal, available in modern engines).
+ * When false, float16 dtype uses Float32Array as a fallback backing store.
+ */
+export declare const hasFloat16: boolean;
 /**
  * Default dtype (matches NumPy)
  */
@@ -27,7 +32,7 @@ export declare const DEFAULT_DTYPE: DType;
  * Note: Complex arrays have 2x the physical elements (interleaved real, imag).
  */
 export declare function getTypedArrayConstructor(dtype: DType): TypedArrayConstructor | null;
-type TypedArrayConstructor = Float64ArrayConstructor | Float32ArrayConstructor | BigInt64ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | BigUint64ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor;
+type TypedArrayConstructor = Float64ArrayConstructor | Float32ArrayConstructor | Float16ArrayConstructor | BigInt64ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | BigUint64ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor;
 /**
  * Get the element size in bytes for a given dtype.
  * For complex types, returns the full element size (both real and imag parts).

package/dist/types/common/float16-conv.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IEEE 754 half-precision (float16) conversion utilities.
+ *
+ * Used for NPY serialization/deserialization when native Float16Array
+ * is not available. When Float16Array IS available, these are only needed
+ * for NPY byte-level operations.
+ *
+ * @internal
+ */
+/**
+ * Convert a float16 (stored as uint16 bits) to a float64 number.
+ * Handles denormals, infinities, NaN, and signed zero.
+ */
+export declare function float16BitsToNumber(bits: number): number;
+/**
+ * Convert a float64 number to float16 bits (uint16).
+ * Rounds to nearest even. Handles overflow to infinity and underflow to zero/denormal.
+ */
+export declare function numberToFloat16Bits(value: number): number;
+/**
+ * Create a typed array from float16 raw bytes (for NPY parsing).
+ *
+ * If native Float16Array is available, constructs one directly.
+ * Otherwise, converts each float16 value to float32 and returns a Float32Array.
+ */
+export declare function float16BytesToTypedArray(buffer: ArrayBuffer, byteOffset: number, numElements: number, needsByteSwap: boolean): Float32Array;
+//# sourceMappingURL=float16-conv.d.ts.map

package/dist/types/common/internal/indexing.d.ts

@@ -7,24 +7,21 @@
  */
 export declare function computeStrides(shape: readonly number[]): number[];
 /**
- * Convert multi-index to linear index in row-major order
- */
-export declare function multiIndexToLinear(indices: number[], shape: readonly number[]): number;
-/**
- * Convert multi-index to buffer position using actual strides and offset.
- * Unlike multiIndexToLinear (which assumes C-contiguous layout),
- * this works correctly for non-contiguous views/slices.
- */
-export declare function multiIndexToBuffer(indices: number[], strides: readonly number[], offset: number): number;
-/**
- * Convert outer index and axis index to full multi-index
- * Used in reductions along a specific axis
+ * Precompute stride-based offsets for iterating over an axis reduction.
+ *
+ * Returns { baseOffsets, axisStride } where:
+ * - baseOffsets[outerIdx] is the buffer offset of the first element along the
+ *   reduction axis for that output position
+ * - axisStride is the stride along the reduction axis in the buffer
+ *
+ * Inner loop becomes:
+ *   let off = baseOffsets[outerIdx];
+ *   for (k = 0; k < axisSize; k++, off += axisStride) { data[off] ... }
  *
- * @param outerIdx - Linear index in the reduced (output) array
- * @param axis - The axis being reduced
- * @param axisIdx - Position along the reduction axis
- * @param shape - Original array shape
- * @returns Full multi-index in the original array
+ * This eliminates per-element allocations and index decomposition.
  */
-export declare function outerIndexToMultiIndex(outerIdx: number, axis: number, axisIdx: number, shape: readonly number[]): number[];
+export declare function precomputeAxisOffsets(shape: readonly number[], strides: readonly number[], offset: number, axis: number, outerSize: number): {
+    baseOffsets: Int32Array;
+    axisStride: number;
+};
 //# sourceMappingURL=indexing.d.ts.map

package/dist/types/common/ndarray-core.d.ts

@@ -10,21 +10,11 @@
 import { type DType, type TypedArray } from './dtype';
 import { Complex } from './complex';
 import { ArrayStorage } from './storage';
-/**
- * Minimal NDArray class - core functionality without operation methods
- *
- * This class provides:
- * - Array properties (shape, dtype, data, etc.)
- * - Element access (get, set, iget, iset)
- * - Basic methods (copy, astype, fill, slice)
- * - Conversion methods (toArray, tolist, tobytes)
- *
- * Operation methods (add, sin, reshape, etc.) are NOT included.
- * Use NDArray from ndarray-full.ts for the complete API.
- */
 export declare class NDArrayCore {
     protected _storage: ArrayStorage;
     protected _base?: NDArrayCore;
+    [key: number]: NDArrayCore | number | bigint | Complex;
+    private static readonly _proxyHandler;
     constructor(storage: ArrayStorage, base?: NDArrayCore);
     /**
      * Get internal storage (for ops modules)
@@ -100,7 +90,7 @@ export declare class NDArrayCore {
     /**
      * Slice the array
      */
-    slice(...sliceStrs: string[]): NDArrayCore;
+    slice(...sliceStrs: string[]): this;
     /**
      * String representation
      */

package/dist/types/common/ops/linalg.d.ts

@@ -24,14 +24,15 @@ import { Complex } from '../complex';
  */
 export declare function dot(a: ArrayStorage, b: ArrayStorage): ArrayStorage | number | bigint | Complex;
 /**
- * Matrix multiplication
- * Requires 2D arrays with compatible shapes
+ * Matrix multiplication - fully NumPy-compatible.
  *
- * Automatically detects transposed/non-contiguous arrays via strides
- * and uses appropriate DGEMM transpose parameters.
- *
- * Note: Currently uses float64 precision for all operations.
- * Integer inputs are promoted to float64 (matching NumPy behavior).
+ * Behavior by input dimensions:
+ * - 0D: raises ValueError (at least 1-D required)
+ * - 1D @ 1D: inner product → 0D scalar array
+ * - 2D @ 1D: matrix-vector → 1D
+ * - 1D @ 2D: vector-matrix → 1D
+ * - 2D @ 2D: matrix multiplication → 2D (optimized with DGEMM)
+ * - ND @ ND (N≥3): batched matrix multiply, batch dims broadcast → ND
  */
 export declare function matmul(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
 /**
@@ -43,7 +44,7 @@ export declare function matmul(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  * @param a - Input 2D array
  * @returns Sum of diagonal elements
  */
-export declare function trace(a: ArrayStorage): number | bigint | Complex;
+export declare function trace(a: ArrayStorage, offset?: number, axis1?: number, axis2?: number): ArrayStorage | number | bigint | Complex;
 /**
  * Permute the dimensions of an array
  *
@@ -158,7 +159,7 @@ export declare function kron(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  * @param axis - If defined, the axis of a, b and c that defines the vectors
  * @returns Cross product of a and b
  */
-export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, axisc?: number, axis?: number): ArrayStorage | number | Complex;
+export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, axisc?: number, axis?: number): ArrayStorage | number | bigint | Complex;
 /**
  * Vector norm.
  *
@@ -246,7 +247,7 @@ export declare function svd(a: ArrayStorage, full_matrices?: boolean, compute_uv
  * @param a - Square matrix
  * @returns Determinant
  */
-export declare function det(a: ArrayStorage): number;
+export declare function det(a: ArrayStorage): number | ArrayStorage;
 /**
  * Compute the matrix inverse - optimized to do LU decomposition once.
  *
@@ -442,8 +443,8 @@ export declare function vecmat(x1: ArrayStorage, x2: ArrayStorage): ArrayStorage
  * @returns { sign, logabsdet }
  */
 export declare function slogdet(a: ArrayStorage): {
-    sign: number;
-    logabsdet: number;
+    sign: number | ArrayStorage;
+    logabsdet: number | ArrayStorage;
 };
 /**
  * Compute singular values of a matrix.

package/dist/types/common/ops/random.d.ts

@@ -5,17 +5,21 @@
  * - Legacy API (np.random.seed, random, rand, uniform, etc.) uses MT19937
  * - Modern API (np.random.default_rng) uses PCG64 with SeedSequence
  *
- * Both implementations produce identical output to NumPy when seeded.
+ * Core RNG and distribution algorithms run in WASM (Zig) for:
+ * - Exact NumPy output matching (Ziggurat for Generator, polar for legacy)
+ * - Native u128 for PCG64 (vs slow JS BigInt)
  */
 import { ArrayStorage } from '../storage';
 import { type DType } from '../dtype';
 /**
- * Random number generator class (matches NumPy's Generator from default_rng)
+ * Random number generator class (matches NumPy's Generator from default_rng).
+ * Each instance maintains its own PCG64 state snapshot, swapped into WASM on each call.
  */
 export declare class Generator {
-    private _pcgState;
+    private _state;
     constructor(seedValue?: number);
-    private _randomFloat;
+    /** Load this instance's state into WASM, run fn, snapshot state back. */
+    private _withState;
     random(size?: number | number[]): ArrayStorage | number;
     integers(low: number, high?: number, size?: number | number[]): ArrayStorage | number;
     standard_normal(size?: number | number[]): ArrayStorage | number;
@@ -185,7 +189,7 @@ export declare function set_bit_generator(bitgen: BitGenerator): void;
 export declare function standard_exponential(size?: number | number[]): ArrayStorage | number;
 /**
  * Draw samples from a standard gamma distribution
- * Uses Marsaglia and Tsang's method
+ * Uses NumPy's legacy_standard_gamma algorithm exactly
  * @param shape - Shape parameter (alpha, must be > 0)
  * @param size - Output shape
  */
@@ -203,6 +207,7 @@ export declare function standard_cauchy(size?: number | number[]): ArrayStorage
 export declare function standard_t(df: number, size?: number | number[]): ArrayStorage | number;
 /**
  * Draw samples from a Gamma distribution
+ * NumPy: scale * legacy_standard_gamma(shape)
  * @param shape - Shape parameter (k, alpha) (must be > 0)
  * @param scale - Scale parameter (theta) (default 1.0)
  * @param size - Output shape

package/dist/types/common/ops/sets.d.ts

@@ -5,7 +5,7 @@ import { ArrayStorage } from '../storage';
 /**
  * Find the unique elements of an array
  */
-export declare function unique(a: ArrayStorage, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): ArrayStorage | {
+export declare function unique(a: ArrayStorage, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean, axis?: number): ArrayStorage | {
     values: ArrayStorage;
     indices?: ArrayStorage;
     inverse?: ArrayStorage;

package/dist/types/common/ops/shape.d.ts

@@ -5,6 +5,17 @@
  * @module ops/shape
  */
 import { ArrayStorage } from '../storage';
+/**
+ * Slice an array along one or more dimensions
+ * Returns a view (no data copy) with adjusted shape, strides, and offset
+ */
+export declare function slice(storage: ArrayStorage, ...sliceStrs: string[]): ArrayStorage;
+/**
+ * Slice an array along one or more dimensions, keeping all dimensions (rank-preserving)
+ * Like slice(), but integer-index specs produce a size-1 dimension instead of dropping it.
+ * Returns a view (no data copy) with adjusted shape, strides, and offset
+ */
+export declare function sliceKeepDim(storage: ArrayStorage, ...sliceStrs: string[]): ArrayStorage;
 /**
  * Reshape array to a new shape
  * Returns a view if array is C-contiguous, otherwise copies data

package/dist/types/common/storage.d.ts

@@ -7,6 +7,10 @@
  */
 import { type DType, type TypedArray } from './dtype';
 import { Complex } from './complex';
+/**
+ * Maximum number of dimensions an array can have (matches NumPy's limit).
+ */
+export declare const MAX_NDIM = 64;
 /**
  * Internal storage for NDArray data
  * Manages the underlying TypedArray and metadata

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated element-wise absolute value.
+ *
+ * Unary: out[i] = |a[i]|
+ * Returns null if WASM can't handle this case.
+ * Complex types are not handled here (magnitude needs sqrt, handled in JS).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise absolute value.
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmAbs(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=abs.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise addition.
+ *
+ * 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 add of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmAdd(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise add of array + scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmAddScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=add.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise arccos.
+ *
+ * Unary: out[i] = acos(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 arccos.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmArccos(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=arccos.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise arcsin.
+ *
+ * Unary: out[i] = asin(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 arcsin.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmArcsin(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=arcsin.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise arctangent.
+ *
+ * Unary: out[i] = arctan(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 arctangent.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmArctan(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=arctan.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * WASM-accelerated argpartition (returns indices for quickselect partition).
+ *
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import type { DType, TypedArray } from '../dtype';
+/**
+ * WASM-accelerated argpartition of contiguous slices.
+ * Uses batch kernel when slices are packed contiguously.
+ */
+export declare function wasmArgpartitionSlices(inputData: TypedArray, resultData: Int32Array, inputSliceOffsets: Int32Array | number[], outputSliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, kth: number, dtype: DType): boolean;
+/**
+ * WASM-accelerated argpartition of a contiguous 1D buffer.
+ * Returns ArrayStorage of int32 indices or null if WASM can't handle it.
+ */
+export declare function wasmArgpartition(a: ArrayStorage, kth: number): ArrayStorage | null;
+//# sourceMappingURL=argpartition.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * WASM-accelerated argsort (returns indices that would sort an array).
+ *
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import type { DType, TypedArray } from '../dtype';
+/**
+ * WASM-accelerated argsort of contiguous slices.
+ * Uses batch kernel when slices are packed contiguously.
+ */
+export declare function wasmArgsortSlices(inputData: TypedArray, resultData: Int32Array, inputSliceOffsets: Int32Array | number[], outputSliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, dtype: DType): boolean;
+/**
+ * WASM-accelerated argsort of a contiguous 1D buffer.
+ * Returns ArrayStorage of int32 indices or null if WASM can't handle it.
+ */
+export declare function wasmArgsort(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=argsort.d.ts.map

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

@@ -0,0 +1,7 @@
+export declare function abs_f64(a: number, out: number, N: number): void;
+export declare function abs_f32(a: number, out: number, N: number): void;
+export declare function abs_i64(a: number, out: number, N: number): void;
+export declare function abs_i32(a: number, out: number, N: number): void;
+export declare function abs_i16(a: number, out: number, N: number): void;
+export declare function abs_i8(a: number, out: number, N: number): void;
+//# sourceMappingURL=abs.wasm.d.ts.map

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

@@ -0,0 +1,17 @@
+export declare function add_f64(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_f64(a: number, out: number, N: number, scalar: number): void;
+export declare function add_f32(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_f32(a: number, out: number, N: number, scalar: number): void;
+export declare function add_c128(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_c128(a: number, out: number, N: number, scalar: number): void;
+export declare function add_c64(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_c64(a: number, out: number, N: number, scalar: number): void;
+export declare function add_i64(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_i64(a: number, out: number, N: number, scalar: number): void;
+export declare function add_i32(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_i32(a: number, out: number, N: number, scalar: number): void;
+export declare function add_i16(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_i16(a: number, out: number, N: number, scalar: number): void;
+export declare function add_i8(a: number, b: number, out: number, N: number): void;
+export declare function add_scalar_i8(a: number, out: number, N: number, scalar: number): void;
+//# sourceMappingURL=add.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function arccos_f64(a: number, out: number, N: number): void;
+export declare function arccos_f32(a: number, out: number, N: number): void;
+export declare function arccos_i64(a: number, out: number, N: number): void;
+export declare function arccos_u64(a: number, out: number, N: number): void;
+//# sourceMappingURL=arccos.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function arcsin_f64(a: number, out: number, N: number): void;
+export declare function arcsin_f32(a: number, out: number, N: number): void;
+export declare function arcsin_i64(a: number, out: number, N: number): void;
+export declare function arcsin_u64(a: number, out: number, N: number): void;
+//# sourceMappingURL=arcsin.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function arctan_f64(a: number, out: number, N: number): void;
+export declare function arctan_f32(a: number, out: number, N: number): void;
+export declare function arctan_i64(a: number, out: number, N: number): void;
+export declare function arctan_u64(a: number, out: number, N: number): void;
+//# sourceMappingURL=arctan.wasm.d.ts.map

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

@@ -0,0 +1,21 @@
+export declare function argpartition_f64(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_f32(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_i64(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_u64(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_i32(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_u32(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_i16(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_u16(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_i8(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_u8(a: number, out: number, N: number, kth: number): void;
+export declare function argpartition_slices_f64(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_f32(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_i64(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_u64(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_i32(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_u32(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_i16(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_u16(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_i8(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+export declare function argpartition_slices_u8(a: number, out: number, sliceSize: number, numSlices: number, kth: number): void;
+//# sourceMappingURL=argpartition.wasm.d.ts.map

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

@@ -0,0 +1,25 @@
+export declare function argsort_f64(a: number, out: number, N: number): void;
+export declare function argsort_f32(a: number, out: number, N: number): void;
+export declare function argsort_i64(a: number, out: number, N: number): void;
+export declare function argsort_u64(a: number, out: number, N: number): void;
+export declare function argsort_i32(a: number, out: number, N: number): void;
+export declare function argsort_u32(a: number, out: number, N: number): void;
+export declare function argsort_i16(a: number, out: number, N: number): void;
+export declare function argsort_u16(a: number, out: number, N: number): void;
+export declare function argsort_i8(a: number, out: number, N: number): void;
+export declare function argsort_u8(a: number, out: number, N: number): void;
+export declare function argsort_slices_f64(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_f32(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_i64(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_u64(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_i32(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_u32(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_i16(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_u16(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_i8(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_u8(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_c128(a: number, out: number, N: number): void;
+export declare function argsort_c64(a: number, out: number, N: number): void;
+export declare function argsort_slices_c128(a: number, out: number, sliceSize: number, numSlices: number): void;
+export declare function argsort_slices_c64(a: number, out: number, sliceSize: number, numSlices: number): void;
+//# sourceMappingURL=argsort.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function bitwise_and_i64(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_and_i32(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_and_i16(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_and_i8(a: number, b: number, out: number, N: number): void;
+//# sourceMappingURL=bitwise_and.wasm.d.ts.map

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

@@ -0,0 +1,9 @@
+export declare function bitwise_count_i64(a: number, out: number, N: number): void;
+export declare function bitwise_count_u64(a: number, out: number, N: number): void;
+export declare function bitwise_count_i32(a: number, out: number, N: number): void;
+export declare function bitwise_count_u32(a: number, out: number, N: number): void;
+export declare function bitwise_count_i16(a: number, out: number, N: number): void;
+export declare function bitwise_count_u16(a: number, out: number, N: number): void;
+export declare function bitwise_count_i8(a: number, out: number, N: number): void;
+export declare function bitwise_count_u8(a: number, out: number, N: number): void;
+//# sourceMappingURL=bitwise_count.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function bitwise_not_i64(a: number, out: number, N: number): void;
+export declare function bitwise_not_i32(a: number, out: number, N: number): void;
+export declare function bitwise_not_i16(a: number, out: number, N: number): void;
+export declare function bitwise_not_i8(a: number, out: number, N: number): void;
+//# sourceMappingURL=bitwise_not.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function bitwise_or_i64(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_or_i32(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_or_i16(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_or_i8(a: number, b: number, out: number, N: number): void;
+//# sourceMappingURL=bitwise_or.wasm.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function bitwise_xor_i64(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_xor_i32(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_xor_i16(a: number, b: number, out: number, N: number): void;
+export declare function bitwise_xor_i8(a: number, b: number, out: number, N: number): void;
+//# sourceMappingURL=bitwise_xor.wasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare function cholesky_f64(a: number, out: number, n_arg: number): number;
+export declare function cholesky_f32(a: number, out: number, n_arg: number): number;
+//# sourceMappingURL=cholesky.wasm.d.ts.map

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

@@ -0,0 +1,11 @@
+export declare function clip_f64(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_f32(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_i64(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_u64(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_i32(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_u32(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_i16(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_u16(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_i8(a: number, out: number, N: number, lo: number, hi: number): void;
+export declare function clip_u8(a: number, out: number, N: number, lo: number, hi: number): void;
+//# sourceMappingURL=clip.wasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare function convolve_f64(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_f32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+//# sourceMappingURL=convolve.wasm.d.ts.map

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

@@ -0,0 +1,21 @@
+export declare function copysign_f64(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_f32(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_i64(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_u64(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_i32(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_u32(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_i16(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_u16(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_i8(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_u8(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_scalar_f64(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_f32(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_i64(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_u64(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_i32(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_u32(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_i16(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_u16(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_i8(x1: number, out: number, N: number, scalar: number): void;
+export declare function copysign_scalar_u8(x1: number, out: number, N: number, scalar: number): void;
+//# sourceMappingURL=copysign.wasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare function correlate_f64(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_f32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+//# sourceMappingURL=correlate.wasm.d.ts.map

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

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

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

@@ -0,0 +1,5 @@
+export declare function cosh_f64(a: number, out: number, N: number): void;
+export declare function cosh_f32(a: number, out: number, N: number): void;
+export declare function cosh_i64(a: number, out: number, N: number): void;
+export declare function cosh_u64(a: number, out: number, N: number): void;
+//# sourceMappingURL=cosh.wasm.d.ts.map

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

@@ -0,0 +1,9 @@
+export declare function cross_f64(a: number, b: number, out: number, n: number): void;
+export declare function cross_f32(a: number, b: number, out: number, n: number): void;
+export declare function cross_c128(a: number, b: number, out: number, n: number): void;
+export declare function cross_c64(a: number, b: number, out: number, n: number): void;
+export declare function cross_i64(a: number, b: number, out: number, n: number): void;
+export declare function cross_i32(a: number, b: number, out: number, n: number): void;
+export declare function cross_i16(a: number, b: number, out: number, n: number): void;
+export declare function cross_i8(a: number, b: number, out: number, n: number): void;
+//# sourceMappingURL=cross.wasm.d.ts.map