numpy-ts 1.0.0 → 1.1.0

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

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated reduction sum.
+ *
+ * Reduction: result = sum(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (wrapping addition gives same bits).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction sum (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceSum(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided sum along an axis.
+ * Output is always f64 (the JS caller converts to the correct output dtype).
+ * Returns f64 ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceSumStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_sum.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated flat repeat.
+ *
+ * repeat: Each element a[i] is written `reps` times to output.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated flat repeat with uniform repeat count.
+ * Only handles flattened repeat (no axis) with a single repeat count (not array).
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmRepeat(a: ArrayStorage, reps: number): ArrayStorage | null;
+//# sourceMappingURL=repeat.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated element-wise right 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 wasmRightShift(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+export declare function wasmRightShiftScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=right_shift.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated flat array roll (circular shift).
+ *
+ * roll: out[i] = a[(i - shift + N) % N]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated flat roll (no axis).
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmRoll(a: ArrayStorage, shift: number): ArrayStorage | null;
+//# sourceMappingURL=roll.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 2D 90-degree rotation (k=1, CCW).
+ *
+ * rot90: dst[r,c] = src[c, cols-1-r]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 2D rot90 (k=1, CCW).
+ * Only handles 2D C-contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmRot90(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=rot90.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * WASM Runtime — shared memory management for all WASM kernels.
+ *
+ * All kernel modules share a single WebAssembly.Memory instance.
+ * Uses a bump allocator that resets on every kernel call (no fragmentation).
+ * Memory grows monotonically (high-water-mark pattern).
+ */
+import type { TypedArray } from '../dtype';
+/**
+ * Get the shared WebAssembly.Memory instance.
+ * All WASM kernel modules import this same memory.
+ * Starts with 17 pages (~1.1MB) — enough for debug (ReleaseSmall/Safe) WASM builds
+ * which have larger binaries and declare higher minimum memory.
+ */
+export declare function getSharedMemory(): WebAssembly.Memory;
+/**
+ * Ensure the shared memory has at least `bytes` of usable space
+ * (above heapBase). Grows if necessary.
+ */
+export declare function ensureMemory(bytes: number): void;
+/**
+ * Reset the bump allocator. Call before each kernel invocation.
+ * Also increments wasmCallCount so callers can detect WASM execution.
+ */
+export declare function resetAllocator(base?: number): void;
+/**
+ * Set the heap base offset. Called once when the first WASM instance
+ * is initialized (reads __heap_base from the WASM exports).
+ */
+export declare function setHeapBase(base: number): void;
+/**
+ * Bump-allocate `bytes` from WASM memory. Returns the byte offset.
+ * Always 8-byte aligned for TypedArray compatibility.
+ */
+export declare function alloc(bytes: number): number;
+/**
+ * Copy a JS TypedArray into WASM memory. Returns the byte offset.
+ */
+export declare function copyIn(src: TypedArray): number;
+/**
+ * Copy data from WASM memory into a new JS TypedArray.
+ */
+export declare function copyOut<T extends TypedArray>(ptr: number, length: number, Ctor: new (buffer: ArrayBuffer, byteOffset: number, length: number) => T): T;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * WASM-accelerated searchsorted (binary search for insertion indices).
+ *
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated searchsorted.
+ * Returns ArrayStorage of int32 insertion indices or null if WASM can't handle it.
+ */
+export declare function wasmSearchsorted(sorted: ArrayStorage, values: ArrayStorage, side: 'left' | 'right'): ArrayStorage | null;
+//# sourceMappingURL=searchsorted.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated element-wise sign.
+ *
+ * Unary: out[i] = sign(a[i])  (returns -1, 0, or 1)
+ * Returns null if WASM can't handle this case.
+ * Not defined for complex types.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise sign.
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmSign(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sign.d.ts.map

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

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

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

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated in-place array sorting.
+ *
+ * Sorts a contiguous 1D buffer in-place using heap sort.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import type { DType, TypedArray } from '../dtype';
+/**
+ * WASM-accelerated sort of contiguous slices in a typed array buffer.
+ * Uses a single batched WASM call for all slices (eliminates per-slice JS→WASM overhead).
+ * Returns true if WASM handled it.
+ */
+export declare function wasmSortSlices(resultData: TypedArray, sliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, dtype: DType): boolean;
+/**
+ * WASM-accelerated sort of a contiguous 1D buffer.
+ * Returns sorted ArrayStorage or null if WASM can't handle it.
+ */
+export declare function wasmSort(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sort.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise square root.
+ *
+ * Unary: out[i] = sqrt(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types output same type; integer types use native WASM kernels
+ * that convert to f64 internally (no JS conversion loop needed).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise square root.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmSqrt(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sqrt.d.ts.map

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

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

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * WASM-accelerated Singular Value Decomposition.
+ *
+ * Computes A[m×n] = U[m×m] · diag(S) · Vt[n×n] via Jacobi eigendecomposition of A^T·A.
+ * 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 full SVD for 2D float64 matrices.
+ * Returns { u: ArrayStorage, s: ArrayStorage, vt: ArrayStorage } or null.
+ */
+export declare function wasmSvd(a: ArrayStorage): {
+    u: ArrayStorage;
+    s: ArrayStorage;
+    vt: ArrayStorage;
+} | null;
+//# sourceMappingURL=svd.d.ts.map

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

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

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 2D tile.
+ *
+ * Tiles a [rows x cols] matrix by [rep_rows x rep_cols].
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 2D tile.
+ * Only handles 2D C-contiguous arrays with 2-element reps.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmTile2D(a: ArrayStorage, repRows: number, repCols: number): ArrayStorage | null;
+//# sourceMappingURL=tile.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * WASM-accelerated conjugate dot product (vdot) for complex types.
+ *
+ * Computes sum_k conj(a[k]) * b[k] for flattened 1D complex arrays.
+ * For real/integer types, vdot = dot — use wasmDot1D instead.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
+/**
+ * WASM-accelerated conjugate dot product for complex types.
+ * Both a and b must be 1D, contiguous, same-length, complex dtype.
+ * Returns Complex or null.
+ */
+export declare function wasmVdotComplex(a: ArrayStorage, b: ArrayStorage): Complex | null;
+//# sourceMappingURL=vdot.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated batched vector dot product (vecdot).
+ *
+ * Computes out[i] = sum_k a[i,k] * b[i,k] for contiguous 2D arrays
+ * where the last axis is contracted. Both a and b must have the same shape.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated vecdot for 2D arrays with contraction along the last axis.
+ * a and b must be 2D with matching shapes, both C-contiguous.
+ * Returns ArrayStorage with shape [B] (batch dimension), or null.
+ */
+export declare function wasmVecdot(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=vecdot.d.ts.map

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

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

package/dist/types/core/linalg.d.ts

@@ -7,8 +7,8 @@
 import { NDArrayCore, Complex } from './types';
 /** Dot product of two arrays */
 export declare function dot(a: NDArrayCore, b: NDArrayCore): NDArrayCore | number | bigint | Complex;
-/** Matrix trace (sum of diagonal elements) */
-export declare function trace(a: NDArrayCore): number | bigint | Complex;
+/** Matrix trace (sum of diagonal elements, supports ND batch) */
+export declare function trace(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArrayCore | number | bigint | Complex;
 /** Return diagonal or construct diagonal array */
 export declare function diagonal(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArrayCore;
 /** Kronecker product */
@@ -39,7 +39,7 @@ export declare function matvec(x1: NDArrayCore, x2: NDArrayCore): NDArrayCore;
 /** Vector-matrix product */
 export declare function vecmat(x1: NDArrayCore, x2: NDArrayCore): NDArrayCore;
 /** Cross product */
-export declare function cross(a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number): NDArrayCore | number | Complex;
+export declare function cross(a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number): NDArrayCore | number | bigint | Complex;
 /** Matrix multiplication */
 export declare function matmul(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
 export declare const linalg: {
@@ -47,8 +47,8 @@ export declare const linalg: {
     matmul: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
     /** Dot product */
     dot: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore | number | bigint | Complex;
-    /** Matrix determinant */
-    det: (a: NDArrayCore) => number;
+    /** Matrix determinant (supports batched ND input) */
+    det: (a: NDArrayCore) => number | NDArrayCore;
     /** Matrix inverse */
     inv: (a: NDArrayCore) => NDArrayCore;
     /** Solve linear system Ax = b */
@@ -102,8 +102,8 @@ export declare const linalg: {
     eigvalsh: (a: NDArrayCore, UPLO?: "L" | "U") => NDArrayCore;
     /** Sign and log of determinant */
     slogdet: (a: NDArrayCore) => {
-        sign: number;
-        logabsdet: number;
+        sign: number | NDArrayCore;
+        logabsdet: number | NDArrayCore;
     };
     /** Singular values */
     svdvals: (a: NDArrayCore) => NDArrayCore;
@@ -118,13 +118,13 @@ export declare const linalg: {
     /** Matrix norm */
     matrix_norm: (x: NDArrayCore, ord?: number | "fro" | "nuc", keepdims?: boolean) => NDArrayCore | number;
     /** Cross product */
-    cross: (a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArrayCore | number | Complex;
+    cross: (a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArrayCore | number | bigint | Complex;
     /** Matrix transpose (transposes last two axes) - returns a view */
     matrix_transpose: (a: NDArrayCore) => NDArrayCore;
     /** Permute array dimensions - returns a view */
     permute_dims: (a: NDArrayCore, axes?: number[]) => NDArrayCore;
-    /** Matrix trace (sum of diagonal elements) */
-    trace: (a: NDArrayCore) => number | bigint | Complex;
+    /** Matrix trace (sum of diagonal elements, supports ND batch) */
+    trace: (a: NDArrayCore, offset?: number, axis1?: number, axis2?: number) => NDArrayCore | number | bigint | Complex;
     /** Extract diagonal */
     diagonal: (a: NDArrayCore, offset?: number, axis1?: number, axis2?: number) => NDArrayCore;
     /** Outer product */

package/dist/types/core/reduction.d.ts

@@ -6,17 +6,17 @@
  */
 import { NDArrayCore, Complex } from './types';
 /** Sum of array elements */
-export declare function sum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | bigint | Complex;
+export declare function sum(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | bigint | Complex;
 /** Mean of array elements */
-export declare function mean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function mean(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Product of array elements */
-export declare function prod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | bigint | Complex;
+export declare function prod(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | bigint | Complex;
 /** Maximum of array elements */
-export declare function max(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function max(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Alias for max */
 export declare const amax: typeof max;
 /** Minimum of array elements */
-export declare function min(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function min(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Alias for min */
 export declare const amin: typeof min;
 /** Peak-to-peak (max - min) */
@@ -26,13 +26,13 @@ export declare function argmin(a: NDArrayCore, axis?: number): NDArrayCore | num
 /** Index of maximum value */
 export declare function argmax(a: NDArrayCore, axis?: number): NDArrayCore | number;
 /** Variance of array elements */
-export declare function variance(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+export declare function variance(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArrayCore | number;
 /** Alias for variance */
 export declare const var_: typeof variance;
 /** Standard deviation of array elements */
-export declare function std(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+export declare function std(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArrayCore | number;
 /** Median of array elements */
-export declare function median(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number;
+export declare function median(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number;
 /** Percentile of array elements */
 export declare function percentile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArrayCore | number;
 /** Quantile of array elements */
@@ -40,9 +40,9 @@ export declare function quantile(a: NDArrayCore, q: number, axis?: number, keepd
 /** Weighted average */
 export declare function average(a: NDArrayCore, axis?: number, weights?: NDArrayCore, keepdims?: boolean): NDArrayCore | number | Complex;
 /** Test if all elements are true */
-export declare function all(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | boolean;
+export declare function all(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | boolean;
 /** Test if any element is true */
-export declare function any(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | boolean;
+export declare function any(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | boolean;
 /** Cumulative sum */
 export declare function cumsum(a: NDArrayCore, axis?: number): NDArrayCore;
 /** Alias for cumsum */
@@ -52,19 +52,19 @@ export declare function cumprod(a: NDArrayCore, axis?: number): NDArrayCore;
 /** Alias for cumprod */
 export declare const cumulative_prod: typeof cumprod;
 /** Sum ignoring NaN */
-export declare function nansum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function nansum(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Product ignoring NaN */
-export declare function nanprod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function nanprod(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Mean ignoring NaN */
-export declare function nanmean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function nanmean(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Variance ignoring NaN */
-export declare function nanvar(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+export declare function nanvar(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArrayCore | number;
 /** Standard deviation ignoring NaN */
-export declare function nanstd(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+export declare function nanstd(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArrayCore | number;
 /** Minimum ignoring NaN */
-export declare function nanmin(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function nanmin(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Maximum ignoring NaN */
-export declare function nanmax(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+export declare function nanmax(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArrayCore | number | Complex;
 /** Index of minimum ignoring NaN */
 export declare function nanargmin(a: NDArrayCore, axis?: number): NDArrayCore | number;
 /** Index of maximum ignoring NaN */

package/dist/types/core/sets.d.ts

@@ -6,7 +6,7 @@
  */
 import { NDArrayCore } from './types';
 /** Find unique elements */
-export declare function unique(ar: NDArrayCore, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): NDArrayCore | {
+export declare function unique(ar: NDArrayCore, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean, axis?: number): NDArrayCore | {
     values: NDArrayCore;
     indices?: NDArrayCore;
     inverse?: NDArrayCore;

package/dist/types/core/sorting.d.ts

@@ -30,5 +30,5 @@ export declare function searchsorted(a: NDArrayCore, v: NDArrayCore, side?: 'lef
 /** Extract elements where condition is True */
 export declare function extract(condition: NDArrayCore, a: NDArrayCore): NDArrayCore;
 /** Count non-zero elements */
-export declare function count_nonzero(a: NDArrayCore, axis?: number): NDArrayCore | number;
+export declare function count_nonzero(a: NDArrayCore, axis?: number | number[]): NDArrayCore | number;
 //# sourceMappingURL=sorting.d.ts.map

package/dist/types/full/index.d.ts

@@ -251,6 +251,8 @@ export declare function diff(a: NDArrayCore, n?: number, axis?: number): NDArray
 export declare function ediff1d(a: NDArrayCore, to_end?: number[] | null, to_begin?: number[] | null): NDArray;
 /** Dot product of two arrays */
 export declare function dot(a: NDArrayCore, b: NDArrayCore): NDArray | number | bigint | Complex;
+/** Matrix trace (sum of diagonal elements, supports ND batch) */
+export declare function trace(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArray | number | bigint | Complex;
 /** Return diagonal or construct diagonal array */
 export declare function diagonal(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArray;
 /** Kronecker product */
@@ -370,15 +372,15 @@ export declare function polyval(p: NDArrayCore | number[], x: NDArrayCore | numb
  */
 export declare function roots(p: NDArrayCore | number[]): NDArray;
 /** Sum of array elements */
-export declare function sum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+export declare function sum(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | bigint | Complex;
 /** Mean of array elements */
-export declare function mean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function mean(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Product of array elements */
-export declare function prod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+export declare function prod(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | bigint | Complex;
 /** Maximum of array elements */
-export declare function max(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function max(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Minimum of array elements */
-export declare function min(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function min(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Peak-to-peak (max - min) */
 export declare function ptp(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /** Index of minimum value */
@@ -386,11 +388,11 @@ export declare function argmin(a: NDArrayCore, axis?: number): NDArray | number;
 /** Index of maximum value */
 export declare function argmax(a: NDArrayCore, axis?: number): NDArray | number;
 /** Variance of array elements */
-export declare function variance(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+export declare function variance(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArray | number;
 /** Standard deviation of array elements */
-export declare function std(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+export declare function std(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArray | number;
 /** Median of array elements */
-export declare function median(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number;
+export declare function median(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number;
 /** Percentile of array elements */
 export declare function percentile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArray | number;
 /** Quantile of array elements */
@@ -398,27 +400,27 @@ export declare function quantile(a: NDArrayCore, q: number, axis?: number, keepd
 /** Weighted average */
 export declare function average(a: NDArrayCore, axis?: number, weights?: NDArrayCore, keepdims?: boolean): NDArray | number | Complex;
 /** Test if all elements are true */
-export declare function all(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | boolean;
+export declare function all(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | boolean;
 /** Test if any element is true */
-export declare function any(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | boolean;
+export declare function any(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | boolean;
 /** Cumulative sum */
 export declare function cumsum(a: NDArrayCore, axis?: number): NDArray;
 /** Cumulative product */
 export declare function cumprod(a: NDArrayCore, axis?: number): NDArray;
 /** Sum ignoring NaN */
-export declare function nansum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function nansum(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Product ignoring NaN */
-export declare function nanprod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function nanprod(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Mean ignoring NaN */
-export declare function nanmean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function nanmean(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Variance ignoring NaN */
-export declare function nanvar(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+export declare function nanvar(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArray | number;
 /** Standard deviation ignoring NaN */
-export declare function nanstd(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+export declare function nanstd(a: NDArrayCore, axis?: number | number[], ddof?: number, keepdims?: boolean): NDArray | number;
 /** Minimum ignoring NaN */
-export declare function nanmin(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function nanmin(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Maximum ignoring NaN */
-export declare function nanmax(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export declare function nanmax(a: NDArrayCore, axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
 /** Index of minimum ignoring NaN */
 export declare function nanargmin(a: NDArrayCore, axis?: number): NDArray | number;
 /** Index of maximum ignoring NaN */
@@ -599,5 +601,5 @@ export declare function arcsinh(x: NDArrayCore): NDArray;
 export declare function arccosh(x: NDArrayCore): NDArray;
 /** Inverse hyperbolic tangent */
 export declare function arctanh(x: NDArrayCore): NDArray;
-export { broadcast_arrays, broadcast_shapes, put, put_along_axis, place, putmask, copyto, ix_, fill_diagonal, array_equal, array_equiv, may_share_memory, shares_memory, geterr, seterr, pow, abs, true_divide, conjugate, array2string, array_repr, array_str, set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, gradient, trace, einsum, einsum_path, vdot, linalg, iscomplexobj, isrealobj, isfortran, isscalar, iterable, isdtype, promote_types, allclose, amax, amin, var_, cumulative_sum, cumulative_prod, round_, unique, unique_all, unique_counts, unique_inverse, split, array_split, vsplit, hsplit, dsplit, atleast_1d, atleast_2d, atleast_3d, row_stack, where, searchsorted, count_nonzero, histogram, histogram2d, histogramdd, histogram_bin_edges, asin, acos, atan, atan2, asinh, acosh, atanh, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill, } from '../core';
+export { broadcast_arrays, broadcast_shapes, put, put_along_axis, place, putmask, copyto, ix_, fill_diagonal, array_equal, array_equiv, may_share_memory, shares_memory, geterr, seterr, pow, abs, true_divide, conjugate, array2string, array_repr, array_str, set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, gradient, einsum, einsum_path, vdot, linalg, iscomplexobj, isrealobj, isfortran, isscalar, iterable, isdtype, promote_types, allclose, amax, amin, var_, cumulative_sum, cumulative_prod, round_, unique, unique_all, unique_counts, unique_inverse, split, array_split, vsplit, hsplit, dsplit, atleast_1d, atleast_2d, atleast_3d, row_stack, where, searchsorted, count_nonzero, histogram, histogram2d, histogramdd, histogram_bin_edges, asin, acos, atan, atan2, asinh, acosh, atanh, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill, } from '../core';
 //# sourceMappingURL=index.d.ts.map